HBase - Guia rápido

Desde 1970, o RDBMS é a solução para problemas relacionados ao armazenamento e manutenção de dados. Após o advento do big data, as empresas perceberam os benefícios do processamento de big data e começaram a optar por soluções como o Hadoop.

O Hadoop usa o sistema de arquivos distribuído para armazenar big data e MapReduce para processá-lo. O Hadoop se destaca no armazenamento e processamento de dados enormes em vários formatos, como arbitrário, semi-estruturado ou até mesmo não estruturado.

Limitações do Hadoop

O Hadoop pode executar apenas processamento em lote e os dados serão acessados apenas de maneira sequencial. Isso significa que é necessário pesquisar todo o conjunto de dados, mesmo para os trabalhos mais simples.

Um enorme conjunto de dados quando processado resulta em outro enorme conjunto de dados, que também deve ser processado sequencialmente. Neste ponto, uma nova solução é necessária para acessar qualquer ponto de dados em uma única unidade de tempo (acesso aleatório).

Bancos de dados de acesso aleatório Hadoop

Aplicativos como HBase, Cassandra, couchDB, Dynamo e MongoDB são alguns dos bancos de dados que armazenam grandes quantidades de dados e acessam os dados de maneira aleatória.

O que é HBase?

HBase é um banco de dados orientado a coluna distribuído construído sobre o sistema de arquivos Hadoop. É um projeto de código aberto e escalonável horizontalmente.

HBase é um modelo de dados semelhante à grande mesa do Google, projetado para fornecer acesso aleatório rápido a grandes quantidades de dados estruturados. Ele aproveita a tolerância a falhas fornecida pelo Hadoop File System (HDFS).

É uma parte do ecossistema Hadoop que fornece acesso aleatório de leitura / gravação em tempo real aos dados no Hadoop File System.

É possível armazenar os dados no HDFS diretamente ou por meio do HBase. O consumidor de dados lê / acessa os dados no HDFS aleatoriamente usando o HBase. O HBase se baseia no Hadoop File System e fornece acesso de leitura e gravação.

HBase e HDFS

HDFS	HBase
HDFS é um sistema de arquivos distribuído adequado para armazenar arquivos grandes.	HBase é um banco de dados construído sobre o HDFS.
O HDFS não oferece suporte para pesquisas rápidas de registros individuais.	O HBase fornece pesquisas rápidas para tabelas maiores.
Ele fornece processamento em lote de alta latência; nenhum conceito de processamento em lote.	Ele fornece acesso de baixa latência a linhas únicas de bilhões de registros (acesso aleatório).
Ele fornece apenas acesso sequencial de dados.	O HBase usa tabelas Hash internamente e fornece acesso aleatório, e armazena os dados em arquivos HDFS indexados para pesquisas mais rápidas.

Mecanismo de armazenamento em HBase

HBase é um column-oriented databasee as tabelas nele são classificadas por linha. O esquema da tabela define apenas famílias de colunas, que são os pares de valores-chave. Uma tabela possui vários grupos de colunas e cada grupo de colunas pode ter qualquer número de colunas. Os valores das colunas subsequentes são armazenados de forma contígua no disco. Cada valor de célula da tabela possui um carimbo de data / hora. Resumindo, em um HBase:

A tabela é uma coleção de linhas.
Linha é uma coleção de famílias de colunas.
A família de colunas é uma coleção de colunas.
A coluna é uma coleção de pares de valores-chave.

A seguir, é fornecido um exemplo de esquema de tabela no HBase.

Rowid	Família de coluna			Família de coluna			Família de coluna			Família de coluna
Rowid	col1	col2	col3	col1	col2	col3	col1	col2	col3	col1	col2	col3
1
2
3

Orientado a coluna e orientado a linha

Bancos de dados orientados a colunas são aqueles que armazenam tabelas de dados como seções de colunas de dados, em vez de linhas de dados. Em breve, eles terão famílias de colunas.

Banco de dados orientado a linha	Banco de dados orientado a coluna
É adequado para o Processo de Transação Online (OLTP).	É adequado para processamento analítico online (OLAP).
Esses bancos de dados são projetados para um pequeno número de linhas e colunas.	Bancos de dados orientados a colunas são projetados para tabelas enormes.

A imagem a seguir mostra famílias de colunas em um banco de dados orientado a colunas:

HBase e RDBMS

HBase	RDBMS
O HBase não tem esquema, não tem o conceito de esquema de colunas fixas; define apenas famílias de colunas.	Um RDBMS é governado por seu esquema, que descreve toda a estrutura das tabelas.
É construído para mesas largas. O HBase é escalonável horizontalmente.	É fino e feito para pequenas mesas. Difícil de escalar.
Nenhuma transação existe no HBase.	O RDBMS é transacional.
Possui dados desnormalizados.	Ele terá dados normalizados.
É bom para dados semiestruturados e também estruturados.	É bom para dados estruturados.

Características do HBase

O HBase é linearmente escalonável.
Possui suporte a falhas automáticas.
Ele fornece leitura e gravação consistentes.
Ele se integra ao Hadoop, tanto como origem quanto como destino.
Possui API Java fácil para cliente.
Ele fornece replicação de dados entre clusters.

Onde usar o HBase

O Apache HBase é usado para ter acesso aleatório de leitura / gravação em tempo real ao Big Data.
Ele hospeda tabelas muito grandes em cima de clusters de hardware comum.
Apache HBase é um banco de dados não relacional modelado de acordo com o Bigtable do Google. O Bigtable atua no Google File System, da mesma forma que o Apache HBase funciona no Hadoop e HDFS.

Aplicações de HBase

Ele é usado sempre que houver necessidade de escrever aplicativos pesados.
O HBase é usado sempre que precisamos fornecer acesso aleatório rápido aos dados disponíveis.
Empresas como Facebook, Twitter, Yahoo e Adobe usam o HBase internamente.

História HBase

Ano	Evento
Novembro de 2006	O Google divulgou o artigo no BigTable.
Fevereiro de 2007	O protótipo inicial do HBase foi criado como uma contribuição do Hadoop.
Out 2007	O primeiro HBase utilizável junto com o Hadoop 0.15.0 foi lançado.
Janeiro de 2008	HBase se tornou o subprojeto do Hadoop.
Outubro de 2008	HBase 0.18.1 foi lançado.
Janeiro de 2009	HBase 0.19.0 foi lançado.
Setembro de 2009	O HBase 0.20.0 foi lançado.
Maio de 2010	HBase tornou-se o projeto de nível superior do Apache.

No HBase, as tabelas são divididas em regiões e atendidas pelos servidores da região. As regiões são divididas verticalmente por famílias de colunas em “Lojas”. As lojas são salvas como arquivos no HDFS. Abaixo é mostrada a arquitetura do HBase.

Note: O termo 'armazenamento' é usado para regiões para explicar a estrutura de armazenamento.

O HBase tem três componentes principais: a biblioteca cliente, um servidor mestre e servidores regionais. Os servidores de região podem ser adicionados ou removidos conforme a necessidade.

MasterServer

O servidor mestre -

Atribui regiões aos servidores de região e tem a ajuda do Apache ZooKeeper para essa tarefa.
Lida com o balanceamento de carga das regiões nos servidores regionais. Ele descarrega os servidores ocupados e muda as regiões para servidores menos ocupados.
Mantém o estado do cluster negociando o balanceamento de carga.
É responsável por mudanças de esquema e outras operações de metadados, como criação de tabelas e famílias de colunas.

Regiões

As regiões nada mais são do que tabelas que são divididas e distribuídas pelos servidores da região.

Servidor de região

Os servidores de região têm regiões que -

Comunique-se com o cliente e administre operações relacionadas a dados.
Lida com solicitações de leitura e gravação para todas as regiões sob ele.
Decida o tamanho da região seguindo os limites de tamanho da região.

Quando examinamos mais profundamente o servidor de região, ele contém regiões e armazenamentos conforme mostrado abaixo:

O armazenamento contém armazenamento de memória e HFiles. Memstore é como uma memória cache. Qualquer coisa inserida no HBase é armazenada aqui inicialmente. Posteriormente, os dados são transferidos e salvos em Hfiles como blocos e o armazenamento de memória é liberado.

Funcionário do zoológico

Zookeeper é um projeto de código aberto que fornece serviços como manutenção de informações de configuração, nomenclatura, fornecimento de sincronização distribuída, etc.
Zookeeper tem nós efêmeros que representam servidores de diferentes regiões. Os servidores principais usam esses nós para descobrir os servidores disponíveis.
Além da disponibilidade, os nós também são usados para rastrear falhas de servidor ou partições de rede.
Os clientes se comunicam com os servidores da região por meio do zookeeper.
Nos modos pseudo e autônomo, o próprio HBase cuidará do zookeeper.

Este capítulo explica como o HBase é instalado e configurado inicialmente. Java e Hadoop são necessários para prosseguir com o HBase, portanto, você deve baixar e instalar java e Hadoop em seu sistema.

Configuração de pré-instalação

Antes de instalar o Hadoop no ambiente Linux, precisamos configurar o Linux usando ssh(Capsula segura). Siga as etapas fornecidas abaixo para configurar o ambiente Linux.

Criação de um usuário

Em primeiro lugar, é recomendável criar um usuário separado para o Hadoop para isolar o sistema de arquivos Hadoop do sistema de arquivos Unix. Siga as etapas abaixo para criar um usuário.

Abra a raiz usando o comando “su”.
Crie um usuário a partir da conta root usando o comando “useradd username”.
Agora você pode abrir uma conta de usuário existente usando o comando “su username”.

Abra o terminal Linux e digite os seguintes comandos para criar um usuário.

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

Configuração e geração de chave SSH

A configuração do SSH é necessária para executar diferentes operações no cluster, como iniciar, parar e operações de shell daemon distribuído. Para autenticar diferentes usuários do Hadoop, é necessário fornecer um par de chaves pública / privada para um usuário do Hadoop e compartilhá-lo com diferentes usuários.

Os comandos a seguir são usados para gerar um par de valores-chave usando SSH. Copie o formulário de chaves públicas id_rsa.pub para authorized_keys e forneça as permissões de proprietário, leitura e gravação para o arquivo authorized_keys respectivamente.

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

Verificar ssh

ssh localhost

Instalando Java

Java é o principal pré-requisito para Hadoop e HBase. Em primeiro lugar, você deve verificar a existência de java em seu sistema usando “java -version”. A sintaxe do comando da versão java é fornecida abaixo.

$ java -version

Se tudo funcionar bem, você receberá a seguinte saída.

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 o java não estiver instalado em seu sistema, siga as etapas abaixo para instalar o java.

Passo 1

Baixe o java (JDK <versão mais recente> - X64.tar.gz) visitando o seguinte link Oracle Java .

Então jdk-7u71-linux-x64.tar.gz será baixado em seu sistema.

Passo 2

Geralmente, você encontrará o arquivo java baixado na pasta Downloads. Verifique e extraia ojdk-7u71-linux-x64.gz arquivo usando os seguintes comandos.

$ 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

etapa 3

Para disponibilizar o java a todos os usuários, você deve movê-lo para o local “/ usr / local /”. Abra o root e digite os seguintes comandos.

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

Passo 4

Para configurar PATH e JAVA_HOME variáveis, adicione os seguintes comandos para ~/.bashrc Arquivo.

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

Agora aplique todas as alterações no sistema em execução atual.

$ source ~/.bashrc

Etapa 5

Use os seguintes comandos para configurar alternativas 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

Agora verifique o java -version comando do terminal como explicado acima.

Baixando Hadoop

Depois de instalar o java, você deve instalar o Hadoop. Em primeiro lugar, verifique a existência do Hadoop usando o comando “versão do Hadoop” conforme mostrado abaixo.

hadoop version

Se tudo funcionar bem, você receberá a seguinte saída.

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 o seu sistema não conseguir localizar o Hadoop, faça download do Hadoop em seu sistema. Siga os comandos fornecidos abaixo para fazer isso.

Baixe e extraia o hadoop-2.6.0 da Apache Software Foundation usando os comandos a seguir.

$ 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

Instalando Hadoop

Instale o Hadoop em qualquer um dos modos necessários. Aqui, estamos demonstrando as funcionalidades do HBase no modo pseudo distribuído, portanto, instale o Hadoop no modo pseudo distribuído.

As etapas a seguir são usadas para instalar Hadoop 2.4.1.

Etapa 1 - Configurando o Hadoop

Você pode definir variáveis de ambiente Hadoop anexando os seguintes comandos a ~/.bashrc Arquivo.

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

Agora aplique todas as alterações no sistema em execução atual.

$ source ~/.bashrc

Etapa 2 - Configuração do Hadoop

Você pode encontrar todos os arquivos de configuração do Hadoop no local “$ HADOOP_HOME / etc / hadoop”. Você precisa fazer alterações nesses arquivos de configuração de acordo com sua infraestrutura Hadoop.

$ cd $HADOOP_HOME/etc/hadoop

Para desenvolver programas Hadoop em java, você deve redefinir a variável de ambiente java em hadoop-env.sh arquivo substituindo JAVA_HOME valor com a localização de java em seu sistema.

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

Você terá que editar os seguintes arquivos para configurar o Hadoop.

core-site.xml

o core-site.xml arquivo contém informações como o número da porta usado para a instância do Hadoop, memória alocada para o sistema de arquivos, limite de memória para armazenamento de dados e o tamanho dos buffers de leitura / gravação.

Abra core-site.xml e adicione as seguintes propriedades entre as tags <configuration> e </configuration>.

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

hdfs-site.xml

o hdfs-site.xml arquivo contém informações como o valor dos dados de replicação, caminho do namenode e caminho do datanode de seus sistemas de arquivos locais, onde você deseja armazenar a infraestrutura do Hadoop.

Vamos supor os seguintes dados.

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

Abra este arquivo e adicione as seguintes propriedades entre as marcas <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: No arquivo acima, todos os valores de propriedade são definidos pelo usuário e você pode fazer alterações de acordo com sua infraestrutura Hadoop.

yarn-site.xml

Este arquivo é usado para configurar o yarn no Hadoop. Abra o arquivo yarn-site.xml e adicione a seguinte propriedade entre <configuration $ gt ;, </ configuration $ gt; tags neste arquivo.

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

mapred-site.xml

Este arquivo é usado para especificar qual estrutura MapReduce estamos usando. Por padrão, o Hadoop contém um modelo de yarn-site.xml. Em primeiro lugar, é necessário copiar o arquivo demapred-site.xml.template para mapred-site.xml arquivo usando o seguinte comando.

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

Abrir mapred-site.xml arquivo e adicione as seguintes propriedades entre as marcas <configuration> e </configuration>.

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

Verificando a instalação do Hadoop

As etapas a seguir são usadas para verificar a instalação do Hadoop.

Etapa 1 - Configuração do Nó de Nome

Configure o namenode usando o comando “hdfs namenode -format” como segue.

$ cd ~ $ hdfs namenode -format

O resultado esperado é o seguinte.

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

Etapa 2 - Verificar Hadoop dfs

O seguinte comando é usado para iniciar o dfs. Executar este comando iniciará seu sistema de arquivos Hadoop.

$ start-dfs.sh

A saída esperada é a seguinte.

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]

Etapa 3 - Verificação do script do Yarn

O seguinte comando é usado para iniciar o script yarn. Executar este comando iniciará seus daemons de yarn.

$ start-yarn.sh

A saída esperada é a seguinte.

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

Etapa 4 - Acessando o Hadoop no navegador

O número da porta padrão para acessar o Hadoop é 50070. Use o seguinte url para obter os serviços do Hadoop em seu navegador.

http://localhost:50070

Etapa 5 - Verificar todos os aplicativos do cluster

O número da porta padrão para acessar todos os aplicativos do cluster é 8088. Use o seguinte url para visitar este serviço.

http://localhost:8088/

Instalando HBase

Podemos instalar o HBase em qualquer um dos três modos: modo autônomo, modo pseudo-distribuído e modo totalmente distribuído.

Instalando HBase em modo autônomo

Baixe a última versão estável do formulário HBase http://www.interior-dsgn.com/apache/hbase/stable/usando o comando “wget” e extraia-o usando o comando tar “zxvf”. Veja o seguinte comando.

$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

Mude para o modo de superusuário e mova a pasta HBase para / usr / local conforme mostrado abaixo.

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

Configurando HBase no modo autônomo

Antes de prosseguir com o HBase, você deve editar os arquivos a seguir e configurar o HBase.

hbase-env.sh

Defina o java Home para HBase e abra hbase-env.sharquivo da pasta conf. Edite a variável de ambiente JAVA_HOME e altere o caminho existente para sua variável JAVA_HOME atual, conforme mostrado abaixo.

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

Isso abrirá o arquivo env.sh do HBase. Agora substitua o existenteJAVA_HOME valor com seu valor atual, conforme mostrado abaixo.

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

hbase-site.xml

Este é o principal arquivo de configuração do HBase. Defina o diretório de dados em um local apropriado abrindo a pasta inicial do HBase em / usr / local / HBase. Dentro da pasta conf, você encontrará vários arquivos, abra ohbase-site.xml arquivo como mostrado abaixo.

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

Dentro de hbase-site.xmlarquivo, você encontrará as marcas <configuration> e </configuration>. Dentro deles, defina o diretório HBase sob a chave de propriedade com o nome “hbase.rootdir” conforme mostrado abaixo.

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

Com isso, a parte de instalação e configuração do HBase foi concluída com sucesso. Podemos iniciar o HBase usandostart-hbase.shscript fornecido na pasta bin do HBase. Para isso, abra o HBase Home Folder e execute o script de início do HBase conforme mostrado abaixo.

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

Se tudo correr bem, quando você tentar executar o script de início do HBase, aparecerá uma mensagem dizendo que o HBase foi iniciado.

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

Instalando HBase em modo pseudo-distribuído

Vamos agora verificar como o HBase está instalado no modo pseudo-distribuído.

Configurando HBase

Antes de continuar com o HBase, configure o Hadoop e o HDFS em seu sistema local ou em um sistema remoto e certifique-se de que estejam em execução. Pare o HBase se ele estiver em execução.

hbase-site.xml

Edite o arquivo hbase-site.xml para adicionar as seguintes propriedades.

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

Ele mencionará em qual modo o HBase deve ser executado. No mesmo arquivo do sistema de arquivos local, altere o hbase.rootdir, o endereço da sua instância HDFS, usando a sintaxe hdfs: //// URI. Estamos executando o HDFS no localhost na porta 8030.

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

Iniciando HBase

Após o término da configuração, navegue até a pasta inicial do HBase e inicie o HBase usando o seguinte comando.

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

Note: Antes de iniciar o HBase, verifique se o Hadoop está em execução.

Verificando o diretório HBase em HDFS

HBase cria seu diretório em HDFS. Para ver o diretório criado, navegue até Hadoop bin e digite o seguinte comando.

$ ./bin/hadoop fs -ls /hbase

Se tudo correr bem, você receberá a seguinte saída.

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

Iniciando e parando um mestre

Usando o “local-master-backup.sh” você pode iniciar até 10 servidores. Abra a pasta pessoal do HBase, masterize e execute o seguinte comando para iniciá-lo.

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

Para matar um mestre de backup, você precisa de seu ID de processo, que será armazenado em um arquivo chamado “/tmp/hbase-USER-X-master.pid.” você pode matar o backup master usando o seguinte comando.

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

Iniciando e parando RegionServers

Você pode executar vários servidores de região de um único sistema usando o seguinte comando.

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

Para parar um servidor de região, use o seguinte comando.

$ .bin/local-regionservers.sh stop 3

Iniciando HBaseShell

Depois de instalar o HBase com sucesso, você pode iniciar o HBase Shell. A seguir, está a sequência de etapas que devem ser seguidas para iniciar o shell do HBase. Abra o terminal e faça login como superusuário.

Inicie o sistema de arquivos Hadoop

Navegue pela pasta sbin inicial do Hadoop e inicie o sistema de arquivos Hadoop conforme mostrado abaixo.

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

Iniciar HBase

Navegue pela pasta bin do diretório raiz do HBase e inicie o HBase.

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

Iniciar o servidor mestre HBase

Este será o mesmo diretório. Inicie como mostrado abaixo.

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

Iniciar região

Inicie o servidor da região conforme mostrado abaixo.

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

Inicie o HBase Shell

Você pode iniciar o shell do HBase usando o seguinte comando.

$cd bin
$./hbase shell

Isso lhe dará o prompt do shell do HBase, conforme mostrado abaixo.

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>

Interface da Web HBase

Para acessar a interface web do HBase, digite a seguinte url no navegador.

http://localhost:60010

Esta interface lista seus servidores de região atualmente em execução, mestres de backup e tabelas HBase.

Servidores de região HBase e backup mestres

Tabelas HBase

Configurando o ambiente Java

Também podemos nos comunicar com o HBase usando bibliotecas Java, mas antes de acessar o HBase usando a API Java, você precisa definir o classpath para essas bibliotecas.

Configurando o Classpath

Antes de prosseguir com a programação, defina o classpath para bibliotecas HBase em .bashrcArquivo. Abrir.bashrc em qualquer um dos editores conforme mostrado abaixo.

$ gedit ~/.bashrc

Defina o classpath para bibliotecas HBase (pasta lib no HBase) nele conforme mostrado abaixo.

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

Isso evita a exceção “classe não encontrada” ao acessar o HBase usando a API Java.

Este capítulo explica como iniciar o shell interativo do HBase que vem junto com o HBase.

HBase Shell

O HBase contém um shell com o qual você pode se comunicar com o HBase. O HBase usa o Hadoop File System para armazenar seus dados. Ele terá um servidor mestre e servidores regionais. O armazenamento de dados será na forma de regiões (tabelas). Essas regiões serão divididas e armazenadas em servidores de região.

O servidor mestre gerencia esses servidores regionais e todas essas tarefas ocorrem no HDFS. Abaixo estão alguns dos comandos suportados pelo HBase Shell.

Comandos Gerais

status - Fornece o status do HBase, por exemplo, o número de servidores.
version - Fornece a versão do HBase em uso.
table_help - Fornece ajuda para comandos de referência de tabela.
whoami - Fornece informações sobre o usuário.

Linguagem de definição de dados

Esses são os comandos que operam nas tabelas no HBase.

create - Cria uma mesa.
list - Lista todas as tabelas no HBase.
disable - Desativa uma mesa.
is_disabled - Verifica se uma tabela está desabilitada.
enable - Ativa uma mesa.
is_enabled - Verifica se uma tabela está habilitada.
describe - Fornece a descrição de uma tabela.
alter - Altera uma mesa.
exists - Verifica se existe uma mesa.
drop - Descarta uma tabela do HBase.
drop_all - Descarta as tabelas que correspondem ao 'regex' fornecido no comando.
Java Admin API- Antes de todos os comandos acima, Java fornece uma API Admin para obter funcionalidades DDL por meio da programação. Debaixoorg.apache.hadoop.hbase.client pacote, HBaseAdmin e HTableDescriptor são as duas classes importantes neste pacote que fornecem funcionalidades DDL.

Linguagem de manipulação de dados

put - Coloca um valor de célula em uma coluna especificada em uma linha especificada em uma tabela particular.
get - Busca o conteúdo de uma linha ou célula.
delete - Exclui um valor de célula em uma tabela.
deleteall - Exclui todas as células em uma determinada linha.
scan - Faz a varredura e retorna os dados da tabela.
count - Conta e retorna o número de linhas em uma tabela.
truncate - Desativa, descarta e recria uma tabela especificada.
Java client API - Antes de todos os comandos acima, o Java fornece uma API de cliente para atingir as funcionalidades DML, CRUD (Create Retrieve Update Delete) e mais por meio da programação, no pacote org.apache.hadoop.hbase.client. HTable Put e Get são as classes importantes neste pacote.

Iniciando o HBase Shell

Para acessar o shell do HBase, você deve navegar até a pasta inicial do HBase.

cd /usr/localhost/
cd Hbase

Você pode iniciar o shell interativo do HBase usando “hbase shell” comando como mostrado abaixo.

./bin/hbase shell

Se você instalou com sucesso o HBase em seu sistema, ele lhe dará o prompt do shell do HBase conforme mostrado abaixo.

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>

Para sair do comando shell interativo a qualquer momento, digite exit ou use <ctrl + c>. Verifique o funcionamento do shell antes de prosseguir. Use olist comando para este propósito. Listé um comando usado para obter a lista de todas as tabelas no HBase. Em primeiro lugar, verifique a instalação e a configuração do HBase em seu sistema usando este comando conforme mostrado abaixo.

hbase(main):001:0> list

Quando você digita este comando, ele fornece a seguinte saída.

hbase(main):001:0> list
TABLE

Os comandos gerais no HBase são status, version, table_help e whoami. Este capítulo explica esses comandos.

status

Este comando retorna o status do sistema, incluindo os detalhes dos servidores em execução no sistema. Sua sintaxe é a seguinte:

hbase(main):009:0> status

Se você executar este comando, ele retornará a seguinte saída.

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

versão

Este comando retorna a versão do HBase usada em seu sistema. Sua sintaxe é a seguinte:

hbase(main):010:0> version

Se você executar este comando, ele retornará a seguinte saída.

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

table_help

Este comando o orienta sobre o que e como usar comandos referenciados por tabela. A seguir está a sintaxe para usar este comando.

hbase(main):02:0> table_help

Quando você usa este comando, ele mostra tópicos de ajuda para comandos relacionados à tabela. A seguir, está a saída parcial deste 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'…...

Quem sou eu

Este comando retorna os detalhes do usuário do HBase. Se você executar este comando, retorna o usuário HBase atual conforme mostrado abaixo.

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

O HBase é escrito em java, portanto, fornece uma API java para se comunicar com o HBase. A API Java é a maneira mais rápida de se comunicar com o HBase. A seguir está a API de administração java referenciada que cobre as tarefas usadas para gerenciar tabelas.

Classe HBaseAdmin

HBaseAdminé uma classe que representa o Admin. Esta classe pertence aoorg.apache.hadoop.hbase.clientpacote. Usando esta classe, você pode executar as tarefas de um administrador. Você pode obter a instância do Admin usandoConnection.getAdmin() método.

Métodos e Descrição

S.No.	Métodos e Descrição
1	void createTable(HTableDescriptor desc) Cria uma nova tabela.
2	void createTable(HTableDescriptor desc, byte[][] splitKeys) Cria uma nova tabela com um conjunto inicial de regiões vazias definidas pelas chaves de divisão especificadas.
3	void deleteColumn(byte[] tableName, String columnName) Exclui uma coluna de uma tabela.
4	void deleteColumn(String tableName, String columnName) Exclua uma coluna de uma tabela.
5	void deleteTable(String tableName) Exclui uma tabela.

Descritor de Classe

Esta classe contém os detalhes sobre uma tabela HBase, como:

os descritores de todas as famílias de colunas,
se a tabela é uma tabela de catálogo,
se a tabela for somente leitura,
o tamanho máximo do mem store,
quando a divisão da região deve ocorrer,
coprocessadores associados a ele, etc.

Construtores

S.No.	Construtor e resumo
1	HTableDescriptor(TableName name) Constrói um descritor de tabela especificando um objeto TableName.

Métodos e Descrição

S.No.	Métodos e Descrição
1	HTableDescriptor addFamily(HColumnDescriptor family) Adiciona um grupo de colunas ao descritor fornecido

Criação de uma tabela usando HBase Shell

Você pode criar uma tabela usando o createcomando, aqui você deve especificar o nome da tabela e o nome da família da coluna. osyntax para criar uma tabela no shell do HBase é mostrado abaixo.

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

Exemplo

A seguir, é fornecido um esquema de amostra de uma tabela chamada emp. Possui duas famílias de colunas: “dados pessoais” e “dados profissionais”.

Chave de linha	dados pessoais	dados profissionais

Você pode criar esta tabela no shell do HBase conforme mostrado abaixo.

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

E isso lhe dará a seguinte saída.

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

Verificação

Você pode verificar se a tabela é criada usando o listcomando como mostrado abaixo. Aqui você pode observar a tabela emp criada.

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

Criação de uma tabela usando a API Java

Você pode criar uma tabela no HBase usando o createTable() método de HBaseAdminclasse. Esta classe pertence aoorg.apache.hadoop.hbase.clientpacote. Abaixo estão as etapas para criar uma tabela no HBase usando a API Java.

Etapa 1: instanciar HBaseAdmin

Esta classe requer o objeto Configuration como um parâmetro, portanto, inicialmente instancie a classe Configuration e passe essa instância para HBaseAdmin.

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

Etapa 2: Criar TableDescriptor

HTableDescriptor é uma classe que pertence ao org.apache.hadoop.hbaseclasse. Essa classe é como um contêiner de nomes de tabelas e famílias de colunas.

//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);

Etapa 3: Executar por meio de Admin

Usando o createTable() método de HBaseAdmin classe, você pode executar a tabela criada no modo Admin.

admin.createTable(table);

A seguir está o programa completo para criar uma tabela via 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 ");
   }
}

Compile e execute o programa acima conforme mostrado abaixo.

$javac CreateTable.java
$java CreateTable

O seguinte deve ser o resultado:

Table created

Listando uma tabela usando o HBase Shell

list é o comando usado para listar todas as tabelas no HBase. A seguir está a sintaxe do comando list.

hbase(main):001:0 > list

Quando você digita este comando e executa no prompt do HBase, ele exibe a lista de todas as tabelas no HBase conforme mostrado abaixo.

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

Aqui você pode observar uma mesa chamada emp.

Listando tabelas usando a API Java

Siga as etapas fornecidas abaixo para obter a lista de tabelas do HBase usando a API Java.

Passo 1

Você tem um método chamado listTables() na aula HBaseAdminpara obter a lista de todas as tabelas no HBase. Este método retorna uma matriz deHTableDescriptor objetos.

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

Você pode obter o comprimento do HTableDescriptor[] array usando a variável de comprimento do HTableDescriptorclasse. Obtenha o nome das tabelas deste objeto usandogetNameAsString()método. Execute o loop 'for' usando-os e obtenha a lista das tabelas no HBase.

A seguir está o programa para listar todas as tabelas no HBase usando a 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());
      }
   
   }
}

Compile e execute o programa acima conforme mostrado abaixo.

$javac ListTables.java
$java ListTables

O seguinte deve ser o resultado:

User
emp

Desativando uma tabela usando o HBase Shell

Para excluir uma tabela ou alterar suas configurações, você precisa primeiro desabilitar a tabela usando o comando disable. Você pode reativá-lo usando o comando enable.

A seguir está a sintaxe para desabilitar uma tabela:

disable ‘emp’

Exemplo

Abaixo está um exemplo que mostra como desabilitar uma tabela.

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

Verificação

Depois de desativar a tabela, você ainda pode sentir sua existência por meio de list e existscomandos. Você não pode escanear. Isso lhe dará o seguinte erro.

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

está desabilitado

Este comando é usado para descobrir se uma tabela está desabilitada. Sua sintaxe é a seguinte.

hbase> is_disabled 'table name'

O exemplo a seguir verifica se a tabela chamada emp está desabilitada. Se estiver desabilitado, ele retornará verdadeiro e se não, retornará falso.

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

disable_all

Este comando é usado para desabilitar todas as tabelas que correspondem ao regex fornecido. A sintaxe paradisable_all comando é fornecido abaixo.

hbase> disable_all 'r.*'

Suponha que existam 5 tabelas no HBase, a saber raja, rajani, rajendra, rajesh e raju. O código a seguir irá desativar todas as tabelas começando comraj.

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

Desativar uma tabela usando a API Java

Para verificar se uma tabela está desabilitada, isTableDisabled() método é usado e para desabilitar uma tabela, disableTable()método é usado. Esses métodos pertencem aoHBaseAdminclasse. Siga as etapas abaixo para desabilitar uma tabela.

Passo 1

Instanciar HBaseAdmin classe como mostrado abaixo.

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

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

Passo 2

Verifique se a tabela está desabilitada usando isTableDisabled() método conforme mostrado abaixo.

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

etapa 3

Se a tabela não estiver desabilitada, desabilite-a conforme mostrado abaixo.

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

A seguir está o programa completo para verificar se a tabela está desabilitada; se não, como desativá-lo.

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");
      }
   }
}

Compile e execute o programa acima conforme mostrado abaixo.

$javac DisableTable.java
$java DsiableTable

O seguinte deve ser o resultado:

false
Table disabled

Habilitando uma tabela usando HBase Shell

Sintaxe para habilitar uma tabela:

enable ‘emp’

Exemplo

Dada a seguir é um exemplo para habilitar uma tabela.

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

Verificação

Depois de habilitar a tabela, faça a varredura. Se você pode ver o esquema, sua tabela foi habilitada com sucesso.

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

está ativado

Este comando é usado para descobrir se uma tabela está habilitada. Sua sintaxe é a seguinte:

hbase> is_enabled 'table name'

O código a seguir verifica se a tabela chamada empestá ativado. Se estiver habilitado, ele retornará verdadeiro e se não, retornará falso.

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

Habilitar uma tabela usando a API Java

Para verificar se uma tabela está habilitada, isTableEnabled()método é usado; e para habilitar uma mesa,enableTable()método é usado. Esses métodos pertencem aHBaseAdminclasse. Siga as etapas fornecidas abaixo para habilitar uma tabela.

Passo 1

Instanciar HBaseAdmin classe como mostrado abaixo.

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

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

Passo 2

Verifique se a tabela está habilitada usando isTableEnabled() método conforme mostrado abaixo.

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

etapa 3

Se a tabela não estiver desabilitada, desabilite-a conforme mostrado abaixo.

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

A seguir está o programa completo para verificar se a tabela está habilitada e, se não estiver, como habilitá-la.

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");
      }
   }
}

Compile e execute o programa acima conforme mostrado abaixo.

$javac EnableTable.java
$java EnableTable

O seguinte deve ser o resultado:

false
Table Enabled

descrever

Este comando retorna a descrição da tabela. Sua sintaxe é a seguinte:

hbase> describe 'table name'

A seguir está a saída do comando describe no emp mesa.

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

alterar

Alter é o comando usado para fazer alterações em uma tabela existente. Usando este comando, você pode alterar o número máximo de células de um grupo de colunas, definir e excluir operadores de escopo de tabela e excluir um grupo de colunas de uma tabela.

Mudando o número máximo de células de uma família de colunas

A seguir está a sintaxe para alterar o número máximo de células de uma família de colunas.

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

No exemplo a seguir, o número máximo de células é definido como 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

Operadores de escopo de tabela

Usando alter, você pode definir e remover operadores de escopo de tabela como MAX_FILESIZE, READONLY, MEMSTORE_FLUSHSIZE, DEFERRED_LOG_FLUSH, etc.

Configurando somente leitura

A seguir é fornecida a sintaxe para tornar uma tabela somente leitura.

hbase>alter 't1', READONLY(option)

No exemplo a seguir, fizemos o emp tabela somente leitura.

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

Removendo Operadores de Escopo de Tabela

Também podemos remover os operadores de escopo da tabela. A seguir está a sintaxe para remover 'MAX_FILESIZE' da tabela emp.

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

Excluindo uma Família de Colunas

Usando alter, você também pode excluir um grupo de colunas. A seguir está a sintaxe para excluir um grupo de colunas usando alter.

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

A seguir está um exemplo para excluir um grupo de colunas da tabela 'emp'.

Suponha que haja uma tabela chamada funcionário no HBase. Ele contém os seguintes dados:

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

Agora vamos deletar o grupo de colunas chamado professional usando o 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

Agora verifique os dados na tabela após a alteração. Observe que a família de colunas 'profissional' não existe mais, pois nós a deletamos.

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

Adicionando uma família de colunas usando a API Java

Você pode adicionar um grupo de colunas a uma tabela usando o método addColumn() do HBAseAdminclasse. Siga as etapas fornecidas abaixo para adicionar um grupo de colunas a uma tabela.

Passo 1

Instancie o HBaseAdmin classe.

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

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

Passo 2

o addColumn() método requer um nome de tabela e um objeto de HColumnDescriptorclasse. Portanto instancie oHColumnDescriptorclasse. O construtor deHColumnDescriptorpor sua vez, requer um nome de família de coluna que deve ser adicionado. Aqui, estamos adicionando um grupo de colunas denominado “contactDetails” à tabela “funcionário” existente.

// Instantiating columnDescriptor object

HColumnDescriptor columnDescriptor = new
HColumnDescriptor("contactDetails");

etapa 3

Adicione a família de colunas usando addColumnmétodo. Passe o nome da mesa e oHColumnDescriptor objeto de classe como parâmetros para este método.

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

A seguir está o programa completo para adicionar um grupo de colunas a uma tabela existente.

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");
   }
}

Compile e execute o programa acima conforme mostrado abaixo.

$javac AddColumn.java
$java AddColumn

A compilação acima funciona apenas se você tiver definido o classpath em “ .bashrc”. Caso contrário, siga o procedimento fornecido abaixo para compilar seu arquivo .java.

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

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

Se tudo correr bem, ele produzirá o seguinte resultado:

column added

Excluindo uma família de colunas usando a API Java

Você pode excluir um grupo de colunas de uma tabela usando o método deleteColumn() do HBAseAdminclasse. Siga as etapas fornecidas abaixo para adicionar um grupo de colunas a uma tabela.

Passo 1

Instancie o HBaseAdmin classe.

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

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

Passo 2

Adicione a família de colunas usando deleteColumn()método. Passe o nome da tabela e o nome da família da coluna como parâmetros para este método.

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

A seguir está o programa completo para excluir um grupo de colunas de uma tabela existente.

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"); 
   }
}

Compile e execute o programa acima conforme mostrado abaixo.

$javac DeleteColumn.java $java DeleteColumn

O seguinte deve ser o resultado:

column deleted

Existência de tabela usando HBase Shell

Você pode verificar a existência de uma mesa usando o existscomando. O exemplo a seguir mostra como usar este 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

Verificando a existência de tabelas usando a API Java

Você pode verificar a existência de uma tabela no HBase usando o tableExists() método do HBaseAdmin classe. Siga as etapas fornecidas a seguir para verificar a existência de uma tabela no HBase.

Passo 1

Instantiate the HBaseAdimn class

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

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

Passo 2

Verifique a existência da tabela usando o tableExists( ) método.

A seguir está o programa java para testar a existência de uma tabela no HBase usando a 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);
   }
}

Compile e execute o programa acima conforme mostrado abaixo.

$javac TableExists.java $java TableExists

O seguinte deve ser o resultado:

true

Descartando uma tabela usando o HBase Shell

Usando o dropcomando, você pode excluir uma tabela. Antes de derrubar uma mesa, você deve desabilitá-la.

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

Verifique se a tabela foi excluída usando o comando existing.

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

drop_all

Este comando é usado para eliminar as tabelas que correspondem ao “regex” fornecido no comando. Sua sintaxe é a seguinte:

hbase> drop_all ‘t.*’

Note: Antes de largar uma mesa, você deve desabilitá-la.

Exemplo

Suponha que haja tabelas chamadas raja, rajani, rajendra, rajesh e raju.

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

Todas essas tabelas começam com as letras raj. Em primeiro lugar, vamos desabilitar todas essas tabelas usando odisable_all comando como mostrado abaixo.

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

Agora você pode excluir todos eles usando o drop_all comando conforme fornecido abaixo.

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

Excluindo uma tabela usando a API Java

Você pode excluir uma tabela usando o deleteTable() método no HBaseAdminclasse. Siga as etapas fornecidas a seguir para excluir uma tabela usando a API Java.

Passo 1

Instancie a classe HBaseAdmin.

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

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

Passo 2

Desative a tabela usando o disableTable() método do HBaseAdmin classe.

admin.disableTable("emp1");

etapa 3

Agora exclua a tabela usando o deleteTable() método do HBaseAdmin classe.

admin.deleteTable("emp12");

A seguir está o programa java completo para excluir uma tabela no 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");
   }
}

Compile e execute o programa acima conforme mostrado abaixo.

$javac DeleteTable.java $java DeleteTable

O seguinte deve ser o resultado:

Table deleted

Saída

Você sai do shell digitando o exit comando.

hbase(main):021:0> exit

Parando o HBase

Para parar o HBase, navegue até a pasta inicial do HBase e digite o seguinte comando.

./bin/stop-hbase.sh

Parando o HBase usando a API Java

Você pode desligar o HBase usando o shutdown() método do HBaseAdminclasse. Siga as etapas fornecidas abaixo para desligar o HBase:

Passo 1

Instancie a classe HbaseAdmin.

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

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

Passo 2

Desligue o HBase usando o shutdown() método do HBaseAdmin classe.

admin.shutdown();

A seguir está o programa para interromper o 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();
   }
}

Compile e execute o programa acima conforme mostrado abaixo.

$javac ShutDownHbase.java $java ShutDownHbase

O seguinte deve ser o resultado:

Shutting down hbase

Este capítulo descreve a API do cliente Java para HBase que é usada para executar CRUDoperações em tabelas HBase. HBase é escrito em Java e possui uma API Java Native. Portanto, ele fornece acesso programático à Linguagem de Manipulação de Dados (DML).

Configuração de classe HBase

Adiciona arquivos de configuração do HBase a uma configuração. Esta classe pertence aoorg.apache.hadoop.hbase pacote.

Métodos e descrição

S.No.	Métodos e Descrição
1	static org.apache.hadoop.conf.Configuration create() Este método cria uma configuração com recursos HBase.

Classe HTable

HTable é uma classe interna HBase que representa uma tabela HBase. É uma implementação de tabela usada para se comunicar com uma única tabela HBase. Esta classe pertence aoorg.apache.hadoop.hbase.client classe.

Construtores

S.No.	Construtores e descrição
1	HTable()
2	HTable(TableName tableName, ClusterConnection connection, ExecutorService pool) Usando este construtor, você pode criar um objeto para acessar uma tabela HBase.

Métodos e descrição

S.No.	Métodos e Descrição
1	void close() Libera todos os recursos do HTable.
2	void delete(Delete delete) Exclui as células / linha especificadas.
3	boolean exists(Get get) Usando este método, você pode testar a existência de colunas na tabela, conforme especificado por Get.
4	Result get(Get get) Recupera certas células de uma determinada linha.
5	org.apache.hadoop.conf.Configuration getConfiguration() Retorna o objeto Configuration usado por esta instância.
6	TableName getName() Retorna a instância do nome da tabela desta tabela.
7	HTableDescriptor getTableDescriptor() Retorna o descritor de tabela para esta tabela.
8	byte[] getTableName() Retorna o nome desta tabela.
9	void put(Put put) Usando este método, você pode inserir dados na tabela.

Class Put

Esta classe é usada para realizar operações Put para uma única linha. Pertence aoorg.apache.hadoop.hbase.client pacote.

Construtores

S.No.	Construtores e descrição
1	Put(byte[] row) Usando este construtor, você pode criar uma operação Put para a linha especificada.
2	Put(byte[] rowArray, int rowOffset, int rowLength) Usando este construtor, você pode fazer uma cópia da chave de linha passada para mantê-la local.
3	Put(byte[] rowArray, int rowOffset, int rowLength, long ts) Usando este construtor, você pode fazer uma cópia da chave de linha passada para mantê-la local.
4	Put(byte[] row, long ts) Usando esse construtor, podemos criar uma operação Put para a linha especificada, usando um determinado carimbo de data / hora.

Métodos

S.No.	Métodos e Descrição
1	Put add(byte[] family, byte[] qualifier, byte[] value) Adiciona a coluna e o valor especificados a esta operação Put.
2	Put add(byte[] family, byte[] qualifier, long ts, byte[] value) Adiciona a coluna e o valor especificados, com o carimbo de data / hora especificado como sua versão para esta operação Put.
3	Put add(byte[] family, ByteBuffer qualifier, long ts, ByteBuffer value) Adiciona a coluna e o valor especificados, com o carimbo de data / hora especificado como sua versão para esta operação Put.
4	Put add(byte[] family, ByteBuffer qualifier, long ts, ByteBuffer value) Adiciona a coluna e o valor especificados, com o carimbo de data / hora especificado como sua versão para esta operação Put.

Class Get

Esta classe é usada para realizar operações Get em uma única linha. Esta classe pertence aoorg.apache.hadoop.hbase.client pacote.

Construtor

S.No.	Construtor e Descrição
1	Get(byte[] row) Usando este construtor, você pode criar uma operação Get para a linha especificada.
2	Get(Get get)

Métodos

S.No.	Métodos e Descrição
1	Get addColumn(byte[] family, byte[] qualifier) Recupera a coluna da família específica com o qualificador especificado.
2	Get addFamily(byte[] family) Recupera todas as colunas da família especificada.

Eliminar Classe

Esta classe é usada para realizar operações de exclusão em uma única linha. Para excluir uma linha inteira, instancie um objeto Delete com a linha a ser excluída. Esta classe pertence aoorg.apache.hadoop.hbase.client pacote.

Construtor

S.No.	Construtor e Descrição
1	Delete(byte[] row) Cria uma operação Delete para a linha especificada.
2	Delete(byte[] rowArray, int rowOffset, int rowLength) Cria uma operação Delete para a linha e o carimbo de data / hora especificados.
3	Delete(byte[] rowArray, int rowOffset, int rowLength, long ts) Cria uma operação Delete para a linha e o carimbo de data / hora especificados.
4	Delete(byte[] row, long timestamp) Cria uma operação Delete para a linha e o carimbo de data / hora especificados.

Métodos

S.No.	Métodos e Descrição
1	Delete addColumn(byte[] family, byte[] qualifier) Exclui a versão mais recente da coluna especificada.
2	Delete addColumns(byte[] family, byte[] qualifier, long timestamp) Exclui todas as versões da coluna especificada com um carimbo de data / hora menor ou igual ao carimbo de data / hora especificado.
3	Delete addFamily(byte[] family) Exclui todas as versões de todas as colunas da família especificada.
4	Delete addFamily(byte[] family, long timestamp) Exclui todas as colunas da família especificada com um carimbo de data / hora menor ou igual ao carimbo de data / hora especificado.

Resultado da Classe

Esta classe é usada para obter um resultado de linha única de uma consulta Get ou Scan.

Construtores

S.No.	Construtores
1	Result() Usando esse construtor, você pode criar um Result vazio sem carga útil KeyValue; retorna null se você chamar Cells () brutos.

Métodos

S.No.	Métodos e Descrição
1	byte[] getValue(byte[] family, byte[] qualifier) Este método é usado para obter a versão mais recente da coluna especificada.
2	byte[] getRow() Este método é usado para recuperar a chave de linha que corresponde à linha a partir da qual este Resultado foi criado.

Inserindo dados usando HBase Shell

Este capítulo demonstra como criar dados em uma tabela HBase. Para criar dados em uma tabela HBase, os seguintes comandos e métodos são usados:

put comando,
add() método de Put classe, e
put() método de HTable classe.

Como exemplo, vamos criar a seguinte tabela no HBase.

Usando putcomando, você pode inserir linhas em uma tabela. Sua sintaxe é a seguinte:

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

Inserindo a primeira linha

Vamos inserir os valores da primeira linha na tabela emp como mostrado abaixo.

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

Insira as linhas restantes usando o comando put da mesma maneira. Se você inserir a tabela inteira, obterá a seguinte saída.

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

Inserindo dados usando a API Java

Você pode inserir dados em Hbase usando o add() método do Putclasse. Você pode salvá-lo usando oput() método do HTableclasse. Essas classes pertencem aoorg.apache.hadoop.hbase.clientpacote. Abaixo são fornecidas as etapas para criar dados em uma tabela de HBase.

Etapa 1: instanciar a classe de configuração

o Configurationclasse adiciona arquivos de configuração HBase a seu objeto. Você pode criar um objeto de configuração usando ocreate() método do HbaseConfiguration classe como mostrado abaixo.

Configuration conf = HbaseConfiguration.create();

Etapa 2: instanciar a classe HTable

Você tem uma classe chamada HTable, uma implementação da Tabela no HBase. Esta classe é usada para se comunicar com uma única tabela HBase. Ao instanciar essa classe, ele aceita o objeto de configuração e o nome da tabela como parâmetros. Você pode instanciar a classe HTable conforme mostrado abaixo.

HTable hTable = new HTable(conf, tableName);

Etapa 3: instancie o PutClass

Para inserir dados em uma tabela HBase, o add()método e suas variantes são usados. Este método pertence aPut, portanto, instancie a classe put. Esta classe requer o nome da linha em que você deseja inserir os dados, em formato de string. Você pode instanciar oPut classe como mostrado abaixo.

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

Etapa 4: InsertData

o add() método de Putclasse é usada para inserir dados. Requer matrizes de 3 bytes que representam família de colunas, qualificador de coluna (nome da coluna) e o valor a ser inserido, respectivamente. Insira dados na tabela HBase usando o método add () conforme mostrado abaixo.

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

Etapa 5: salve os dados na tabela

Depois de inserir as linhas necessárias, salve as alterações adicionando a instância put ao put() método da classe HTable conforme mostrado abaixo.

hTable.put(p);

Etapa 6: feche a instância HTable

Após criar os dados na Tabela HBase, feche o HTable instância usando o close() método conforme mostrado abaixo.

hTable.close();

A seguir está o programa completo para criar dados na Tabela 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();
   }
}

Compile e execute o programa acima conforme mostrado abaixo.

$javac InsertData.java $java InsertData

O seguinte deve ser o resultado:

data inserted

Atualizando dados usando HBase Shell

Você pode atualizar um valor de célula existente usando o putcomando. Para fazer isso, basta seguir a mesma sintaxe e mencionar seu novo valor conforme mostrado abaixo.

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

O valor recém-fornecido substitui o valor existente, atualizando a linha.

Exemplo

Suponha que haja uma tabela no HBase chamada emp com os seguintes dados.

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

O comando a seguir atualizará o valor da cidade do funcionário chamado 'Raju' para Delhi.

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

A tabela atualizada é a seguinte, onde você pode observar que a cidade de Raju foi alterada para '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

Atualizando dados usando a API Java

Você pode atualizar os dados em uma célula particular usando o put()método. Siga as etapas fornecidas abaixo para atualizar um valor de célula existente de uma tabela.

Etapa 1: instanciar a classe de configuração

Configurationclasse adiciona arquivos de configuração HBase a seu objeto. Você pode criar um objeto de configuração usando ocreate() método do HbaseConfiguration classe como mostrado abaixo.

Configuration conf = HbaseConfiguration.create();

Etapa 2: instanciar a classe HTable

HTable hTable = new HTable(conf, tableName);

Etapa 3: instanciar a classe Put

Para inserir dados na Tabela HBase, o add()método e suas variantes são usados. Este método pertence aPut, portanto instancie o putclasse. Esta classe requer o nome da linha em que você deseja inserir os dados, em formato de string. Você pode instanciar oPut classe como mostrado abaixo.

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

Etapa 4: Atualizar uma célula existente

o add() método de Putclasse é usada para inserir dados. Requer matrizes de 3 bytes que representam família de colunas, qualificador de coluna (nome da coluna) e o valor a ser inserido, respectivamente. Insira os dados na tabela HBase usando oadd() método conforme mostrado abaixo.

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

Etapa 5: salve os dados na tabela

Depois de inserir as linhas necessárias, salve as alterações adicionando a instância put ao put() método da classe HTable conforme mostrado abaixo.

hTable.put(p);

Etapa 6: Fechar a instância HTable

Depois de criar dados na Tabela HBase, feche o HTable instância usando o método close () conforme mostrado abaixo.

hTable.close();

A seguir está o programa completo para atualizar os dados de uma determinada tabela.

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

Compile e execute o programa acima conforme mostrado abaixo.

$javac UpdateData.java $java UpdateData

O seguinte deve ser o resultado:

data Updated

Leitura de dados usando HBase Shell

o get comando e o get() método de HTableclasse são usados para ler dados de uma tabela no HBase. Usandogetcomando, você pode obter uma única linha de dados por vez. Sua sintaxe é a seguinte:

get ’<table name>’,’row1’

Exemplo

O exemplo a seguir mostra como usar o comando get. Vamos examinar a primeira linha doemp mesa.

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

Lendo uma coluna específica

Dada a seguir está a sintaxe para ler uma coluna específica usando o get método.

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

Exemplo

Dada a seguir é o exemplo para ler uma coluna específica na tabela 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

Lendo dados usando a API Java

Para ler os dados de uma tabela HBase, use o get()método da classe HTable. Este método requer uma instância doGetclasse. Siga as etapas fornecidas abaixo para recuperar os dados da tabela HBase.

Etapa 1: instanciar a classe de configuração

Configuration conf = HbaseConfiguration.create();

Etapa 2: instanciar a classe HTable

HTable hTable = new HTable(conf, tableName);

Etapa 3: instanciar a classe Get

Você pode recuperar dados da tabela HBase usando o get() método do HTableclasse. Este método extrai uma célula de uma determinada linha. Requer umGetobjeto de classe como parâmetro. Crie-o conforme mostrado abaixo.

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

Step 4: Read the Data

While retrieving data, you can get a single row by id, or get a set of rows by a set of row ids, or scan an entire table or a subset of rows.

You can retrieve an HBase table data using the add method variants in Get class.

To get a specific column from a specific column family, use the following method.

get.addFamily(personal)

To get all the columns from a specific column family, use the following method.

get.addColumn(personal, name)

Step 5: Get the Result

Get the result by passing your Get class instance to the get method of the HTable class. This method returns the Result class object, which holds the requested result. Given below is the usage of get() method.

Result result = table.get(g);

Step 6: Reading Values from the Result Instance

The Result class provides the getValue() method to read the values from its instance. Use it as shown below to read the values from the Result instance.

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

Given below is the complete program to read values from an HBase table.

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);
   }
}

Compile and execute the above program as shown below.

$javac RetriveData.java $java RetriveData

The following should be the output:

name: Raju city: Delhi

Deleting a Specific Cell in a Table

Using the delete command, you can delete a specific cell in a table. The syntax of delete command is as follows:

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

Example

Here is an example to delete a specific cell. Here we are deleting the salary.

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

Deleting All Cells in a Table

Using the “deleteall” command, you can delete all the cells in a row. Given below is the syntax of deleteall command.

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

Example

Here is an example of “deleteall” command, where we are deleting all the cells of row1 of emp table.

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

Verifique a tabela usando o scancomando. Um instantâneo da tabela após excluí-la é fornecido abaixo.

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

Exclusão de dados usando a API Java

Você pode excluir dados de uma tabela HBase usando o delete() método do HTableclasse. Siga as etapas abaixo para excluir dados de uma tabela.

Etapa 1: instanciar a classe de configuração

Configuration conf = HbaseConfiguration.create();

Etapa 2: instanciar a classe HTable

HTable hTable = new HTable(conf, tableName);

Etapa 3: instanciar a classe de exclusão

Instancie o Deleteclasse passando o rowid da linha que deve ser excluída, no formato de matriz de bytes. Você também pode passar timestamp e Rowlock para este construtor.

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

Etapa 4: Selecione os dados a serem excluídos

Você pode excluir os dados usando os métodos de exclusão do Deleteclasse. Esta classe possui vários métodos de exclusão. Escolha as colunas ou famílias de colunas a serem excluídas usando esses métodos. Dê uma olhada nos exemplos a seguir que mostram o uso dos métodos da classe Delete.

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

Etapa 5: Exclua os dados

Exclua os dados selecionados passando o delete instância para o delete() método do HTable classe como mostrado abaixo.

table.delete(delete);

Etapa 6: feche o HTableInstance

Depois de excluir os dados, feche o HTable Instância.

table.close();

A seguir está o programa completo para excluir dados da tabela 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.....");
   }
}

Compile e execute o programa acima conforme mostrado abaixo.

$javac Deletedata.java $java DeleteData

O seguinte deve ser o resultado:

data deleted

Digitalizando usando HBase Shell

o scancomando é usado para visualizar os dados em HTable. Usando o comando scan, você pode obter os dados da tabela. Sua sintaxe é a seguinte:

scan ‘<table name>’

Exemplo

O exemplo a seguir mostra como ler dados de uma tabela usando o comando scan. Aqui estamos lendo oemp mesa.

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

Digitalizando usando API Java

O programa completo para verificar todos os dados da tabela usando a API Java é o seguinte.

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

Compile e execute o programa acima conforme mostrado abaixo.

$javac ScanTable.java $java ScanTable

O seguinte deve ser o resultado:

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

contagem

Você pode contar o número de linhas de uma tabela usando o countcomando. Sua sintaxe é a seguinte:

count ‘<table name>’

Depois de excluir a primeira linha, a tabela emp terá duas linhas. Verifique como mostrado abaixo.

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

truncar

Este comando desabilita descartes e recria uma tabela. A sintaxe detruncate é o seguinte:

hbase> truncate 'table name'

Exemplo

A seguir está o exemplo do comando truncate. Aqui nós truncamos oemp mesa.

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

Depois de truncar a tabela, use o comando scan para verificar. Você obterá uma tabela com zero linhas.

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

Podemos conceder e revogar permissões para usuários no HBase. Existem três comandos para fins de segurança: grant, revoke e user_permission.

conceder

o grantcomando concede direitos específicos como ler, escrever, executar e admin em uma tabela para um determinado usuário. A sintaxe do comando grant é a seguinte:

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

Podemos conceder zero ou mais privilégios a um usuário do conjunto de RWXCA, onde

R - representa o privilégio de leitura.
W - representa o privilégio de gravação.
X - representa o privilégio de execução.
C - representa o privilégio de criação.
A - representa o privilégio de administrador.

Abaixo está um exemplo que concede todos os privilégios a um usuário chamado 'Tutorialspoint'.

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

revogar

o revokecomando é usado para revogar os direitos de acesso de um usuário de uma tabela. Sua sintaxe é a seguinte:

hbase> revoke <user>

O código a seguir revoga todas as permissões do usuário chamado 'Tutorialspoint'.

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

user_permission

Este comando é usado para listar todas as permissões para uma determinada tabela. A sintaxe deuser_permission é o seguinte:

hbase>user_permission ‘tablename’

O código a seguir lista todas as permissões de usuário da tabela 'emp'.

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