hbase 订阅
HBase是一个分布式的、面向列的开源数据库,该技术来源于 Fay Chang 所撰写的Google论文“Bigtable:一个结构化数据的分布式存储系统”。就像Bigtable利用了Google文件系统(File System)所提供的分布式数据存储一样,HBase在Hadoop之上提供了类似于Bigtable的能力。HBase是Apache的Hadoop项目的子项目。HBase不同于一般的关系数据库,它是一个适合于非结构化数据存储的数据库。另一个不同的是HBase基于列的而不是基于行的模式。 展开全文
HBase是一个分布式的、面向列的开源数据库,该技术来源于 Fay Chang 所撰写的Google论文“Bigtable:一个结构化数据的分布式存储系统”。就像Bigtable利用了Google文件系统(File System)所提供的分布式数据存储一样,HBase在Hadoop之上提供了类似于Bigtable的能力。HBase是Apache的Hadoop项目的子项目。HBase不同于一般的关系数据库,它是一个适合于非结构化数据存储的数据库。另一个不同的是HBase基于列的而不是基于行的模式。
信息
系    统
Google
属    性
开源数据库
结    构
分布式存储系统
来    源
Fay Chang 所撰写的“Bigtable
中文名
HBase
隶    属
Apache的Hadoop项目
HBase结构介绍
HBase – Hadoop Database,是一个高可靠性、高性能、面向列、可伸缩的分布式存储系统,利用HBase技术可在廉价PC Server上搭建起大规模结构化存储集群。与FUJITSU Cliq等商用大数据产品不同,HBase是Google Bigtable的开源实现,类似Google Bigtable利用GFS作为其文件存储系统,HBase利用Hadoop HDFS作为其文件存储系统;Google运行MapReduce来处理Bigtable中的海量数据,HBase同样利用Hadoop MapReduce来处理HBase中的海量数据;Google Bigtable利用 Chubby作为协同服务,HBase利用Zookeeper作为对应。 [1]  上图描述Hadoop EcoSystem中的各层系统。其中,HBase位于结构化存储层,Hadoop HDFS为HBase提供了高可靠性的底层存储支持,Hadoop MapReduce为HBase提供了高性能的计算能力,Zookeeper为HBase提供了稳定服务和failover机制。 此外,Pig和Hive还为HBase提供了高层语言支持,使得在HBase上进行数据统计处理变的非常简单。 Sqoop则为HBase提供了方便的RDBMS数据导入功能,使得传统数据库数据向HBase中迁移变的非常方便。
收起全文
精华内容
下载资源
问答
  • HBase

    千次阅读 2021-01-08 12:33:41
    HBaseHBase简介什么是HBaseHbase特点HBase架构HBase中的角色HMasterHMasterRegionServer其他组件 HBase简介 什么是HBase HBase是一个高可靠性、高性能、面向列、可伸缩的分布式存储系统,利用HBASE技术可在廉价PC ...

    HBase简介

    什么是HBase

    HBase是一个高可靠性、高性能、面向列、可伸缩的分布式存储系统,利用HBASE技术可在廉价PC Server上搭建起大规模结构化存储集群。

    HBase的目标是存储并处理大型的数据,更具体来说是仅需使用普通的硬件配置,就能够处理由成千上万的行和列所组成的大型数据。

    HBase是Google Bigtable的开源实现,但是也有很多不同之处。比如:Google Bigtable利用GFS作为其文件存储系统,HBase利用Hadoop HDFS作为其文件存储系统;Google运行MAPREDUCE来处理Bigtable中的海量数据,HBase同样利用Hadoop MapReduce来处理HBase中的海量数据;Google Bigtable利用Chubby作为协同服务,HBase利用Zookeeper作为对应。

    Hbase特点

    1)海量存储

    Hbase适合存储PB级别的海量数据,在PB级别的数据以及采用廉价PC存储的情况下,能在几十到百毫秒内返回数据。这与Hbase的极易扩展性息息相关。正式因为Hbase良好的扩展性,才为海量数据的存储提供了便利。

    2)列式存储

    这里的列式存储其实说的是列族(ColumnFamily)存储,Hbase是根据列族来存储数据的。列族下面可以有非常多的列,列族在创建表的时候就必须指定。

    3)极易扩展

    Hbase的扩展性主要体现在两个方面,一个是基于上层处理能力(RegionServer)的扩展,一个是基于存储的扩展(HDFS)。
    通过横向添加RegionSever的机器,进行水平扩展,提升Hbase上层的处理能力,提升Hbsae服务更多Region的能力。
    备注:RegionServer的作用是管理region、承接业务的访问,这个后面会详细的介绍通过横向添加Datanode的机器,进行存储层扩容,提升Hbase的数据存储能力和提升后端存储的读写能力。

    4)高并发(多核)

    由于目前大部分使用Hbase的架构,都是采用的廉价PC,因此单个IO的延迟其实并不小,一般在几十到上百ms之间。这里说的高并发,主要是在并发的情况下,Hbase的单个IO延迟下降并不多。能获得高并发、低延迟的服务。

    5)稀疏

    稀疏主要是针对Hbase列的灵活性,在列族中,你可以指定任意多的列,在列数据为空的情况下,是不会占用存储空间的。

    HBase架构

    在这里插入图片描述
    从图中可以看出Hbase是由Client、Zookeeper、Master、HRegionServer、HDFS等几个组件组成,下面来介绍一下几个组件的相关功能:

    1)Client

    Client包含了访问Hbase的接口,另外Client还维护了对应的cache来加速Hbase的访问,比如cache的.META.元数据的信息。

    2)Zookeeper

    HBase通过Zookeeper来做master的高可用、RegionServer的监控、元数据的入口以及集群配置的维护等工作。具体工作如下:

    通过Zoopkeeper来保证集群中只有1个master在运行,如果master异常,会通过竞争机制产生新的master提供服务。

    通过Zoopkeeper来监控RegionServer的状态,当RegionSevrer有异常的时候,通过回调的形式通知Master RegionServer上下线的信息。

    通过Zoopkeeper存储元数据的统一入口地址

    3)Hmaster(NameNode)

    master节点的主要职责如下:
    为RegionServer分配Region

    维护整个集群的负载均衡

    维护集群的元数据信息

    发现失效的Region,并将失效的Region分配到正常的RegionServer上

    当RegionSever失效的时候,协调对应Hlog的拆分

    4)HregionServer(DataNode)

    HregionServer直接对接用户的读写请求,是真正的“干活”的节点。它的功能概括如下:

    管理master为其分配的Region

    处理来自客户端的读写请求

    负责和底层HDFS的交互,存储数据到HDFS

    负责Region变大以后的拆分

    负责Storefile的合并工作

    5)HDFS

    HDFS为Hbase提供最终的底层数据存储服务,同时为HBase提供高可用(Hlog存储在HDFS)的支持,具体功能概括如下:

    提供元数据和表数据的底层分布式存储服务

    数据多副本,保证的高可靠和高可用性

    HBase中的角色

    HMaster

    HMaster

    功能
    1.监控RegionServer
    2.处理RegionServer故障转移
    3.处理元数据的变更
    4.处理region的分配或转移
    5.在空闲时间进行数据的负载均衡
    6.通过Zookeeper发布自己的位置给客户端

    RegionServer

    功能
    1.负责存储HBase的实际数据
    2.处理分配给它的Region
    3.刷新缓存到HDFS
    4.维护Hlog
    5.执行压缩
    6.负责处理Region分片

    其他组件

    1.Write-Ahead logs

    HBase的修改记录,当对HBase读写数据的时候,数据不是直接写进磁盘,它会在内存中保留一段时间(时间以及数据量阈值可以设定)。但把数据保存在内存中可能有更高的概率引起数据丢失,为了解决这个问题,数据会先写在一个叫做Write-Ahead logfile的文件中,然后再写入内存中。所以在系统出现故障的时候,数据可以通过这个日志文件重建。

    2.Region

    Hbase表的分片,HBase表会根据RowKey值被切分成不同的region存储在RegionServer中,在一个RegionServer中可以有多个不同的region。

    3.Store

    HFile存储在Store中,一个Store对应HBase表中的一个列族(列簇, Column Family)。

    4.MemStore

    顾名思义,就是内存存储,位于内存中,用来保存当前的数据操作,所以当数据保存在WAL中之后,RegsionServer会在内存中存储键值对。

    5.HFile

    这是在磁盘上保存原始数据的实际的物理文件,是实际的存储文件。StoreFile是以Hfile的形式存储在HDFS的。

    HBase安装

    Zookeeper正常部署

    首先保证Zookeeper集群的正常部署,并启动之:

    [atguigu@hadoop102 zookeeper-3.4.10]$ bin/zkServer.sh start
    [atguigu@hadoop103 zookeeper-3.4.10]$ bin/zkServer.sh start
    [atguigu@hadoop104 zookeeper-3.4.10]$ bin/zkServer.sh start
    

    Hadoop正常部署

    Hadoop集群的正常部署并启动:

    [atguigu@hadoop102 hadoop-2.7.2]$ sbin/start-dfs.sh
    [atguigu@hadoop103 hadoop-2.7.2]$ sbin/start-yarn.sh
    

    HBase的解压

    解压HBase到指定目录:

    [atguigu@hadoop102 software]$ tar -zxvf hbase-1.3.1-bin.tar.gz -C /opt/module
    

    HBase的配置文件

    修改HBase对应的配置文件。

    1)hbase-env.sh修改内容:

    export JAVA_HOME=/opt/module/jdk1.8.0_144
    export HBASE_MANAGES_ZK=false
    

    JDK1.8需要注释

    #export HBASE_MASTER_OPTS。。。。
    #export HBASE_REGIONSERVER_OPTS。。。
    

    2)hbase-site.xml修改内容:

    <configuration>
    	<property>     
    		<name>hbase.rootdir</name>     
    		<value>hdfs://hadoop102:9000/hbase</value>   
    	</property>
    
    	<property>   
    		<name>hbase.cluster.distributed</name>
    		<value>true</value>
    	</property>
    
       <!-- 0.98后的新变动,之前版本没有.port,默认端口为60000 -->
    	<property>
    		<name>hbase.master.port</name>
    		<value>16000</value>
    	</property>
    
    	<property>   
    		<name>hbase.zookeeper.quorum</name>
    	     <value>hadoop102:2181,hadoop103:2181,hadoop104:2181</value>
    	</property>
    
    	<property>   
    		<name>hbase.zookeeper.property.dataDir</name>
    	     <value>/opt/module/zookeeper-3.4.10/zkData</value>
    	</property>
    </configuration>
    

    3)regionservers:

    hadoop102
    hadoop103
    hadoop104
    

    4)软连接hadoop配置文件到hbase:

    [atguigu@hadoop102 module]$ ln -s /opt/module/hadoop-2.7.2/etc/hadoop/core-site.xml 
    /opt/module/hbase/conf/core-site.xml
    [atguigu@hadoop102 module]$ ln -s /opt/module/hadoop-2.7.2/etc/hadoop/hdfs-site.xml 
    /opt/module/hbase/conf/hdfs-site.xml
    

    HBase远程发送到其他集群

    [atguigu@hadoop102 module]$ xsync hbase/ 
    

    HBase服务的启动

    1.启动方式1

    [atguigu@hadoop102 hbase]$ bin/hbase-daemon.sh start master
    [atguigu@hadoop102 hbase]$ bin/hbase-daemon.sh start regionserver
    

    提示:如果集群之间的节点时间不同步,会导致regionserver无法启动,抛出ClockOutOfSyncException异常。
    修复提示:
    a、同步时间服务

    b、属性:hbase.master.maxclockskew设置更大的值

    <property>
            <name>hbase.master.maxclockskew</name>
            <value>180000</value>
            <description>Time difference of regionserver from master</description>
     </property>
    

    2.启动方式2

    [atguigu@hadoop102 hbase]$ bin/start-hbase.sh
    

    对应的停止服务:

    [atguigu@hadoop102 hbase]$ bin/stop-hbase.sh
    

    查看HBase页面

    启动成功后,可以通过“host:port”的方式来访问HBase管理页面,例如:

    http://hadoop102:16010 
    

    HBase Shell操作

    基本操作

    1.进入HBase客户端命令行

    [atguigu@hadoop102 hbase]$ bin/hbase shell
    

    2.查看帮助命令

    hbase(main):001:0> help
    

    3.查看当前数据库中有哪些表

    hbase(main):002:0> list
    

    表的操作

    1.创建表

    hbase(main):002:0> create 'student','info'
    

    2.插入数据到表

    hbase(main):003:0> put 'student','1001','info:sex','male'
    hbase(main):004:0> put 'student','1001','info:age','18'
    hbase(main):005:0> put 'student','1002','info:name','Janna'
    hbase(main):006:0> put 'student','1002','info:sex','female'
    hbase(main):007:0> put 'student','1002','info:age','20'
    

    3.扫描查看表数据

    hbase(main):008:0> scan 'student'
    hbase(main):009:0> scan 'student',{STARTROW => '1001', STOPROW  => '1001'}
    hbase(main):010:0> scan 'student',{STARTROW => '1001'}
    

    4.查看表结构

    hbase(main):011:0> describe 'student'
    

    5.更新指定字段的数据

    hbase(main):012:0> put 'student','1001','info:name','Nick'
    hbase(main):013:0> put 'student','1001','info:age','100'
    

    6.查看“指定行”或“指定列族:列”的数据

    hbase(main):014:0> get 'student','1001'
    hbase(main):015:0> get 'student','1001','info:name'
    

    7.统计表数据行数

    hbase(main):021:0> count 'student'
    

    8.删除数据
    删除某rowkey的全部数据:

    hbase(main):016:0> deleteall 'student','1001'
    

    删除某rowkey的某一列数据:

    hbase(main):017:0> delete 'student','1002','info:sex'
    

    9.清空表数据

    hbase(main):018:0> truncate 'student'
    

    提示:清空表的操作顺序为先disable,然后再truncate。
    10.删除表
    首先需要先让该表为disable状态:

    hbase(main):019:0> disable 'student'
    

    然后才能drop这个表:

    hbase(main):020:0> drop 'student'
    

    提示:如果直接drop表,会报错:ERROR: Table student is enabled. Disable it first.
    11.变更表信息
    将info列族中的数据存放3个版本:

    hbase(main):022:0> alter 'student',{NAME=>'info',VERSIONS=>3}
    hbase(main):022:0> get 'student','1001',{COLUMN=>'info:name',VERSIONS=>3}
    

    HBase数据结构

    RowKey

    与nosql数据库们一样,RowKey是用来检索记录的主键。访问HBASE table中的行,只有三种方式:

    1.通过单个RowKey访问(get)

    2.通过RowKey的range(正则)(like)

    3.全表扫描(scan)

    RowKey行键 (RowKey)可以是任意字符串(最大长度是64KB,实际应用中长度一般为 10-100bytes),在HBASE内部,RowKey保存为字节数组。存储时,数据按照RowKey的字典序(byte order)排序存储。设计RowKey时,要充分排序存储这个特性,将经常一起读取的行存储放到一起。(位置相关性)

    Column Family

    列族:HBASE表中的每个列,都归属于某个列族。列族是表的schema的一部 分(而列不是),必须在使用表之前定义。列名都以列族作为前缀。例如 courses:history,courses:math都属于courses 这个列族。

    Cell

    由{rowkey, column Family:columu, version} 唯一确定的单元。cell中的数据是没有类型的,全部是字节码形式存贮。
    关键字:无类型、字节码

    Time Stamp

    HBASE 中通过rowkey和columns确定的为一个存贮单元称为cell。每个 cell都保存 着同一份数据的多个版本。版本通过时间戳来索引。时间戳的类型是 64位整型。时间戳可以由HBASE(在数据写入时自动 )赋值,此时时间戳是精确到毫秒 的当前系统时间。时间戳也可以由客户显式赋值。如果应用程序要避免数据版 本冲突,就必须自己生成具有唯一性的时间戳。每个 cell中,不同版本的数据按照时间倒序排序,即最新的数据排在最前面。
    为了避免数据存在过多版本造成的的管理 (包括存贮和索引)负担,HBASE提供 了两种数据版本回收方式。一是保存数据的最后n个版本,二是保存最近一段 时间内的版本(比如最近七天)。用户可以针对每个列族进行设置。

    命名空间

    命名空间的结构:
    在这里插入图片描述

    1. Table:表,所有的表都是命名空间的成员,即表必属于某个命名空间,如果没有指定,则在default默认的命名空间中。

    2. RegionServer group:一个命名空间包含了默认的RegionServer Group。

    3. Permission:权限,命名空间能够让我们来定义访问控制列表ACL(Access Control List)。例如,创建表,读取表,删除,更新等等操作。

    4. Quota:限额,可以强制一个命名空间可包含的region的数量。

    HBase原理

    读流程

    在这里插入图片描述
    1)Client先访问zookeeper,从meta表读取region的位置,然后读取meta表中的数据。meta中又存储了用户表的region信息;
    2)根据namespace、表名和rowkey在meta表中找到对应的region信息;
    3)找到这个region对应的regionserver;
    4)查找对应的region;
    5)先从MemStore找数据,如果没有,再到BlockCache里面读;
    6)BlockCache还没有,再到StoreFile上读(为了读取的效率);
    7)如果是从StoreFile里面读取的数据,不是直接返回给客户端,而是先写入BlockCache,再返回给客户端。

    写流程

    在这里插入图片描述
    1)Client向HregionServer发送写请求;
    2)HregionServer将数据写到HLog(write ahead log)。为了数据的持久化和恢复;
    3)HregionServer将数据写到内存(MemStore);
    4)反馈Client写成功。

    数据flush过程

    1)当MemStore数据达到阈值(默认是128M,老版本是64M),将数据刷到硬盘,将内存中的数据删除,同时删除HLog中的历史数据;
    2)并将数据存储到HDFS中;
    3)在HLog中做标记点。

    数据合并过程

    1)当数据块达到3块,Hmaster触发合并操作,Region将数据块加载到本地,进行合并;
    2)当合并的数据超过256M,进行拆分,将拆分后的Region分配给不同的HregionServer管理;
    3)当HregionServer宕机后,将HregionServer上的hlog拆分,然后分配给不同的HregionServer加载,修改.META.;
    4)注意:HLog会同步到HDFS。

    HBase API操作

    环境准备

    新建项目后在pom.xml中添加依赖:

    <dependency>
        <groupId>org.apache.hbase</groupId>
        <artifactId>hbase-server</artifactId>
        <version>1.3.1</version>
    </dependency>
    
    <dependency>
        <groupId>org.apache.hbase</groupId>
        <artifactId>hbase-client</artifactId>
        <version>1.3.1</version>
    </dependency>
    
    <dependency>
    	<groupId>jdk.tools</groupId>
    	<artifactId>jdk.tools</artifactId>
    	<version>1.8</version>
    	<scope>system</scope>
    	<systemPath>${JAVA_HOME}/lib/tools.jar</systemPath>
    </dependency>
    

    HBaseAPI

    获取Configuration对象

    public static Configuration conf;
    static{
    	//使用HBaseConfiguration的单例方法实例化
    	conf = HBaseConfiguration.create();
    conf.set("hbase.zookeeper.quorum", "192.168.9.102");
    conf.set("hbase.zookeeper.property.clientPort", "2181");
    }
    

    判断表是否存在

    public static boolean isTableExist(String tableName) throws MasterNotRunningException,
     ZooKeeperConnectionException, IOException{
    	//在HBase中管理、访问表需要先创建HBaseAdmin对象
    //Connection connection = ConnectionFactory.createConnection(conf);
    //HBaseAdmin admin = (HBaseAdmin) connection.getAdmin();
    	HBaseAdmin admin = new HBaseAdmin(conf);
    	return admin.tableExists(tableName);
    }
    

    创建表

    public static void createTable(String tableName, String... columnFamily) throws
     MasterNotRunningException, ZooKeeperConnectionException, IOException{
    	HBaseAdmin admin = new HBaseAdmin(conf);
    	//判断表是否存在
    	if(isTableExist(tableName)){
    		System.out.println("表" + tableName + "已存在");
    		//System.exit(0);
    	}else{
    		//创建表属性对象,表名需要转字节
    		HTableDescriptor descriptor = new HTableDescriptor(TableName.valueOf(tableName));
    		//创建多个列族
    		for(String cf : columnFamily){
    			descriptor.addFamily(new HColumnDescriptor(cf));
    		}
    		//根据对表的配置,创建表
    		admin.createTable(descriptor);
    		System.out.println("表" + tableName + "创建成功!");
    	}
    }
    

    删除表

    public static void dropTable(String tableName) throws MasterNotRunningException,
     ZooKeeperConnectionException, IOException{
    	HBaseAdmin admin = new HBaseAdmin(conf);
    	if(isTableExist(tableName)){
    		admin.disableTable(tableName);
    		admin.deleteTable(tableName);
    		System.out.println("表" + tableName + "删除成功!");
    	}else{
    		System.out.println("表" + tableName + "不存在!");
    	}
    }
    

    向表中插入数据

    public static void addRowData(String tableName, String rowKey, String columnFamily, String
     column, String value) throws IOException{
    	//创建HTable对象
    	HTable hTable = new HTable(conf, tableName);
    	//向表中插入数据
    	Put put = new Put(Bytes.toBytes(rowKey));
    	//向Put对象中组装数据
    	put.add(Bytes.toBytes(columnFamily), Bytes.toBytes(column), Bytes.toBytes(value));
    	hTable.put(put);
    	hTable.close();
    	System.out.println("插入数据成功");
    }
    

    删除多行数据

    public static void deleteMultiRow(String tableName, String... rows) throws IOException{
    	HTable hTable = new HTable(conf, tableName);
    	List<Delete> deleteList = new ArrayList<Delete>();
    	for(String row : rows){
    		Delete delete = new Delete(Bytes.toBytes(row));
    		deleteList.add(delete);
    	}
    	hTable.delete(deleteList);
    	hTable.close();
    }
    

    获取所有数据

    public static void getAllRows(String tableName) throws IOException{
    	HTable hTable = new HTable(conf, tableName);
    	//得到用于扫描region的对象
    	Scan scan = new Scan();
    	//使用HTable得到resultcanner实现类的对象
    	ResultScanner resultScanner = hTable.getScanner(scan);
    	for(Result result : resultScanner){
    		Cell[] cells = result.rawCells();
    		for(Cell cell : cells){
    			//得到rowkey
    			System.out.println("行键:" + Bytes.toString(CellUtil.cloneRow(cell)));
    			//得到列族
    			System.out.println("列族" + Bytes.toString(CellUtil.cloneFamily(cell)));
    			System.out.println("列:" + Bytes.toString(CellUtil.cloneQualifier(cell)));
    			System.out.println("值:" + Bytes.toString(CellUtil.cloneValue(cell)));
    		}
    	}
    }
    

    获取某一行数据

    public static void getRow(String tableName, String rowKey) throws IOException{
    	HTable table = new HTable(conf, tableName);
    	Get get = new Get(Bytes.toBytes(rowKey));
    	//get.setMaxVersions();显示所有版本
        //get.setTimeStamp();显示指定时间戳的版本
    	Result result = table.get(get);
    	for(Cell cell : result.rawCells()){
    		System.out.println("行键:" + Bytes.toString(result.getRow()));
    		System.out.println("列族" + Bytes.toString(CellUtil.cloneFamily(cell)));
    		System.out.println("列:" + Bytes.toString(CellUtil.cloneQualifier(cell)));
    		System.out.println("值:" + Bytes.toString(CellUtil.cloneValue(cell)));
    		System.out.println("时间戳:" + cell.getTimestamp());
    	}
    }
    

    获取某一行指定“列族:列”的数据

    public static void getRowQualifier(String tableName, String rowKey, String family, String
     qualifier) throws IOException{
    	HTable table = new HTable(conf, tableName);
    	Get get = new Get(Bytes.toBytes(rowKey));
    	get.addColumn(Bytes.toBytes(family), Bytes.toBytes(qualifier));
    	Result result = table.get(get);
    	for(Cell cell : result.rawCells()){
    		System.out.println("行键:" + Bytes.toString(result.getRow()));
    		System.out.println("列族" + Bytes.toString(CellUtil.cloneFamily(cell)));
    		System.out.println("列:" + Bytes.toString(CellUtil.cloneQualifier(cell)));
    		System.out.println("值:" + Bytes.toString(CellUtil.cloneValue(cell)));
    	}
    }
    

    MapReduce

    官方HBase-MapReduce

    1.查看HBase的MapReduce任务的执行

    $ bin/hbase mapredcp
    

    2.环境变量的导入
    (1)执行环境变量的导入(临时生效,在命令行执行下述操作)

    $ export HBASE_HOME=/opt/module/hbase-1.3.1
    $ export HADOOP_HOME=/opt/module/hadoop-2.7.2
    $ export HADOOP_CLASSPATH=`${HBASE_HOME}/bin/hbase mapredcp`
    

    (2)永久生效:在/etc/profile配置

    export HBASE_HOME=/opt/module/hbase-1.3.1
    export HADOOP_HOME=/opt/module/hadoop-2.7.2
    并在hadoop-env.sh中配置:(注意:在for循环之后配)
    export HADOOP_CLASSPATH=$HADOOP_CLASSPATH:/opt/module/hbase/lib/*
    

    3.运行官方的MapReduce任务
    – 案例一:统计Student表中有多少行数据

    $ /opt/module/hadoop-2.7.2/bin/yarn jar lib/hbase-server-1.3.1.jar rowcounter student
    

    – 案例二:使用MapReduce将本地数据导入到HBase
    1)在本地创建一个tsv格式的文件:fruit.tsv

    1001	Apple	Red
    1002	Pear		Yellow
    1003	Pineapple	Yellow
    

    2)创建HBase表

    hbase(main):001:0> create 'fruit','info'
    

    3)在HDFS中创建input_fruit文件夹并上传fruit.tsv文件

    $ /opt/module/hadoop-2.7.2/bin/hdfs dfs -mkdir /input_fruit/
    $ /opt/module/hadoop-2.7.2/bin/hdfs dfs -put fruit.tsv /input_fruit/
    

    4)执行MapReduce到HBase的fruit表中

    $ /opt/module/hadoop-2.7.2/bin/yarn jar lib/hbase-server-1.3.1.jar importtsv \
    -Dimporttsv.columns=HBASE_ROW_KEY,info:name,info:color fruit \
    hdfs://hadoop102:9000/input_fruit
    

    5)使用scan命令查看导入后的结果

    hbase(main):001:0> scan ‘fruit’
    

    自定义HBase-MapReduce1

    目标:将fruit表中的一部分数据,通过MR迁入到fruit_mr表中。
    分步实现:
    1.构建ReadFruitMapper类,用于读取fruit表中的数据

    package com.atguigu;
    
    import java.io.IOException;
    import org.apache.hadoop.hbase.Cell;
    import org.apache.hadoop.hbase.CellUtil;
    import org.apache.hadoop.hbase.client.Put;
    import org.apache.hadoop.hbase.client.Result;
    import org.apache.hadoop.hbase.io.ImmutableBytesWritable;
    import org.apache.hadoop.hbase.mapreduce.TableMapper;
    import org.apache.hadoop.hbase.util.Bytes;
    
    public class ReadFruitMapper extends TableMapper<ImmutableBytesWritable, Put> {
    
    	@Override
    	protected void map(ImmutableBytesWritable key, Result value, Context context) 
    	throws IOException, InterruptedException {
    	//将fruit的name和color提取出来,相当于将每一行数据读取出来放入到Put对象中。
    		Put put = new Put(key.get());
    		//遍历添加column行
    		for(Cell cell: value.rawCells()){
    			//添加/克隆列族:info
    			if("info".equals(Bytes.toString(CellUtil.cloneFamily(cell)))){
    				//添加/克隆列:name
    				if("name".equals(Bytes.toString(CellUtil.cloneQualifier(cell)))){
    					//将该列cell加入到put对象中
    					put.add(cell);
    					//添加/克隆列:color
    				}else if("color".equals(Bytes.toString(CellUtil.cloneQualifier(cell)))){
    					//向该列cell加入到put对象中
    					put.add(cell);
    				}
    			}
    		}
    		//将从fruit读取到的每行数据写入到context中作为map的输出
    		context.write(key, put);
    	}
    }
    

    2. 构建WriteFruitMRReducer类,用于将读取到的fruit表中的数据写入到fruit_mr表中

    package com.atguigu.hbase_mr;
    
    import java.io.IOException;
    import org.apache.hadoop.hbase.client.Put;
    import org.apache.hadoop.hbase.io.ImmutableBytesWritable;
    import org.apache.hadoop.hbase.mapreduce.TableReducer;
    import org.apache.hadoop.io.NullWritable;
    
    public class WriteFruitMRReducer extends TableReducer<ImmutableBytesWritable, Put, NullWritable> {
    	@Override
    	protected void reduce(ImmutableBytesWritable key, Iterable<Put> values, Context context) 
    	throws IOException, InterruptedException {
    		//读出来的每一行数据写入到fruit_mr表中
    		for(Put put: values){
    			context.write(NullWritable.get(), put);
    		}
    	}
    }
    

    3.构建Fruit2FruitMRRunner extends Configured implements Tool用于组装运行Job任务

    //组装Job
    	public int run(String[] args) throws Exception {
    		//得到Configuration
    		Configuration conf = this.getConf();
    		//创建Job任务
    		Job job = Job.getInstance(conf, this.getClass().getSimpleName());
    		job.setJarByClass(Fruit2FruitMRRunner.class);
    
    		//配置Job
    		Scan scan = new Scan();
    		scan.setCacheBlocks(false);
    		scan.setCaching(500);
    
    		//设置Mapper,注意导入的是mapreduce包下的,不是mapred包下的,后者是老版本
    		TableMapReduceUtil.initTableMapperJob(
    		"fruit", //数据源的表名
    		scan, //scan扫描控制器
    		ReadFruitMapper.class,//设置Mapper类
    		ImmutableBytesWritable.class,//设置Mapper输出key类型
    		Put.class,//设置Mapper输出value值类型
    		job//设置给哪个JOB
    		);
    		//设置Reducer
    		TableMapReduceUtil.initTableReducerJob("fruit_mr", WriteFruitMRReducer.class, job);
    		//设置Reduce数量,最少1个
    		job.setNumReduceTasks(1);
    
    		boolean isSuccess = job.waitForCompletion(true);
    		if(!isSuccess){
    			throw new IOException("Job running with error");
    		}
    		return isSuccess ? 0 : 1;
    	}
    

    4.主函数中调用运行该Job任务

    public static void main( String[] args ) throws Exception{
    Configuration conf = HBaseConfiguration.create();
    int status = ToolRunner.run(conf, new Fruit2FruitMRRunner(), args);
    System.exit(status);
    }
    

    5.打包运行任务

    $ /opt/module/hadoop-2.7.2/bin/yarn jar ~/softwares/jars/hbase-0.0.1-SNAPSHOT.jar
     com.z.hbase.mr1.Fruit2FruitMRRunner
    

    提示:运行任务前,如果待数据导入的表不存在,则需要提前创建。
    提示:maven打包命令:-P local clean package或-P dev clean package install(将第三方jar包一同打包,需要插件:maven-shade-plugin)

    自定义HBase-MapReduce2

    目标:实现将HDFS中的数据写入到HBase表中。
    分步实现:
    1.构建ReadFruitFromHDFSMapper于读取HDFS中的文件数据

    package com.atguigu;
    
    import java.io.IOException;
    
    import org.apache.hadoop.hbase.client.Put;
    import org.apache.hadoop.hbase.io.ImmutableBytesWritable;
    import org.apache.hadoop.hbase.util.Bytes;
    import org.apache.hadoop.io.LongWritable;
    import org.apache.hadoop.io.Text;
    import org.apache.hadoop.mapreduce.Mapper;
    
    public class ReadFruitFromHDFSMapper extends Mapper<LongWritable, Text, ImmutableBytesWritable, Put> {
    	@Override
    	protected void map(LongWritable key, Text value, Context context) throws IOException, InterruptedException {
    		//从HDFS中读取的数据
    		String lineValue = value.toString();
    		//读取出来的每行数据使用\t进行分割,存于String数组
    		String[] values = lineValue.split("\t");
    		
    		//根据数据中值的含义取值
    		String rowKey = values[0];
    		String name = values[1];
    		String color = values[2];
    		
    		//初始化rowKey
    		ImmutableBytesWritable rowKeyWritable = new ImmutableBytesWritable(Bytes.toBytes(rowKey));
    		
    		//初始化put对象
    		Put put = new Put(Bytes.toBytes(rowKey));
    		
    		//参数分别:列族、列、值  
            put.add(Bytes.toBytes("info"), Bytes.toBytes("name"),  Bytes.toBytes(name)); 
            put.add(Bytes.toBytes("info"), Bytes.toBytes("color"),  Bytes.toBytes(color)); 
            
            context.write(rowKeyWritable, put);
    	}
    }
    

    2.构建WriteFruitMRFromTxtReducer类

    package com.z.hbase.mr2;
    
    import java.io.IOException;
    import org.apache.hadoop.hbase.client.Put;
    import org.apache.hadoop.hbase.io.ImmutableBytesWritable;
    import org.apache.hadoop.hbase.mapreduce.TableReducer;
    import org.apache.hadoop.io.NullWritable;
    
    public class WriteFruitMRFromTxtReducer extends TableReducer<ImmutableBytesWritable, Put, NullWritable> {
    	@Override
    	protected void reduce(ImmutableBytesWritable key, Iterable<Put> values, Context context) throws IOException, InterruptedException {
    		//读出来的每一行数据写入到fruit_hdfs表中
    		for(Put put: values){
    			context.write(NullWritable.get(), put);
    		}
    	}
    }
    

    3.创建Txt2FruitRunner组装Job

    public int run(String[] args) throws Exception {
    //得到Configuration
    Configuration conf = this.getConf();
    

    //创建Job任务

    Job job = Job.getInstance(conf, this.getClass().getSimpleName());
    job.setJarByClass(Txt2FruitRunner.class);
    Path inPath = new Path("hdfs://hadoop102:9000/input_fruit/fruit.tsv");
    FileInputFormat.addInputPath(job, inPath);
    

    //设置Mapper

    job.setMapperClass(ReadFruitFromHDFSMapper.class);
    job.setMapOutputKeyClass(ImmutableBytesWritable.class);
    job.setMapOutputValueClass(Put.class);
    

    //设置Reducer

    TableMapReduceUtil.initTableReducerJob("fruit_mr", WriteFruitMRFromTxtReducer.class, job);
    

    //设置Reduce数量,最少1个

    job.setNumReduceTasks(1);
    
    boolean isSuccess = job.waitForCompletion(true);
    if(!isSuccess){
    throw new IOException("Job running with error");
    }
    
    return isSuccess ? 0 : 1;
    }
    

    4.调用执行Job

    public static void main(String[] args) throws Exception {
    		Configuration conf = HBaseConfiguration.create();
    	    int status = ToolRunner.run(conf, new Txt2FruitRunner(), args);
    	    System.exit(status);
    }
    

    5.打包运行

    $ /opt/module/hadoop-2.7.2/bin/yarn jar hbase-0.0.1-SNAPSHOT.jar com.atguigu.hbase.mr2.Txt2FruitRunner
    

    提示:运行任务前,如果待数据导入的表不存在,则需要提前创建之。
    提示:maven打包命令:-P local clean package或-P dev clean package install(将第三方jar包一同打包,需要插件:maven-shade-plugin)

    HBase优化

    高可用

    在HBase中Hmaster负责监控RegionServer的生命周期,均衡RegionServer的负载,如果Hmaster挂掉了,那么整个HBase集群将陷入不健康的状态,并且此时的工作状态并不会维持太久。所以HBase支持对Hmaster的高可用配置。

    1.关闭HBase集群(如果没有开启则跳过此步)

    [atguigu@hadoop102 hbase]$ bin/stop-hbase.sh
    

    2.在conf目录下创建backup-masters文件

    [atguigu@hadoop102 hbase]$ touch conf/backup-masters
    

    3.在backup-masters文件中配置高可用HMaster节点

    [atguigu@hadoop102 hbase]$ echo hadoop103 > conf/backup-masters
    

    4.将整个conf目录scp到其他节点

    [atguigu@hadoop102 hbase]$ scp -r conf/ hadoop103:/opt/module/hbase/
    [atguigu@hadoop102 hbase]$ scp -r conf/ hadoop104:/opt/module/hbase/
    

    5.打开页面测试查看

    http://hadooo102:16010 
    

    预分区

    每一个region维护着startRow与endRowKey,如果加入的数据符合某个region维护的rowKey范围,则该数据交给这个region维护。那么依照这个原则,我们可以将数据所要投放的分区提前大致的规划好,以提高HBase性能。
    1.手动设定预分区

    hbase> create 'staff1','info','partition1',SPLITS => ['1000','2000','3000','4000']
    

    2.生成16进制序列预分区

    create 'staff2','info','partition2',{NUMREGIONS => 15, SPLITALGO => 'HexStringSplit'}
    

    3.按照文件中设置的规则预分区
    创建splits.txt文件内容如下:

    aaaa
    bbbb
    cccc
    dddd
    

    然后执行:

    create 'staff3','partition3',SPLITS_FILE => 'splits.txt'
    

    4.使用JavaAPI创建预分区

    //自定义算法,产生一系列Hash散列值存储在二维数组中
    byte[][] splitKeys = 某个散列值函数
    //创建HBaseAdmin实例
    HBaseAdmin hAdmin = new HBaseAdmin(HBaseConfiguration.create());
    //创建HTableDescriptor实例
    HTableDescriptor tableDesc = new HTableDescriptor(tableName);
    //通过HTableDescriptor实例和散列值二维数组创建带有预分区的HBase表
    hAdmin.createTable(tableDesc, splitKeys);
    

    RowKey设计

    一条数据的唯一标识就是rowkey,那么这条数据存储于哪个分区,取决于rowkey处于哪个一个预分区的区间内,设计rowkey的主要目的 ,就是让数据均匀的分布于所有的region中,在一定程度上防止数据倾斜。接下来我们就谈一谈rowkey常用的设计方案。

    1.生成随机数、hash、散列值

    比如:

    原本rowKey为1001的,SHA1后变成:dd01903921ea24941c26a48f2cec24e0bb0e8cc7

    原本rowKey为3001的,SHA1后变成:49042c54de64a1e9bf0b33e00245660ef92dc7bd

    原本rowKey为5001的,SHA1后变成:7b61dec07e02c188790670af43e717f0f46e8913

    在做此操作之前,一般我们会选择从数据集中抽取样本,来决定什么样的rowKey来Hash后作为每个分区的临界值。

    2.字符串反转
    20170524000001转成10000042507102

    20170524000002转成20000042507102

    这样也可以在一定程度上散列逐步put进来的数据。

    3.字符串拼接

    20170524000001_a12e

    20170524000001_93i7

    内存优化

    HBase操作过程中需要大量的内存开销,毕竟Table是可以缓存在内存中的,一般会分配整个可用内存的70%给HBase的Java堆。但是不建议分配非常大的堆内存,因为GC过程持续太久会导致RegionServer处于长期不可用状态,一般16~48G内存就可以了,如果因为框架占用内存过高导致系统内存不足,框架一样会被系统服务拖死。

    基础优化

    1.允许在HDFS的文件中追加内容

    hdfs-site.xml、hbase-site.xml

    属性:dfs.support.append

    解释:开启HDFS追加同步,可以优秀的配合HBase的数据同步和持久化。默认值为true。

    2.优化DataNode允许的最大文件打开数

    hdfs-site.xml

    属性:dfs.datanode.max.transfer.threads

    解释:HBase一般都会同一时间操作大量的文件,根据集群的数量和规模以及数据动作,设置为4096或者更高。默认值:4096

    3.优化延迟高的数据操作的等待时间

    hdfs-site.xml

    属性:dfs.image.transfer.timeout

    解释:如果对于某一次数据操作来讲,延迟非常高,socket需要等待更长的时间,建议把该值设置为更大的值(默认60000毫秒),以确保socket不会被timeout掉。

    4.优化数据的写入效率

    mapred-site.xml

    属性:

    mapreduce.map.output.compress

    mapreduce.map.output.compress.codec

    解释:开启这两个数据可以大大提高文件的写入效率,减少写入时间。第一个属性值修改为true,第二个属性值修改为:

    org.apache.hadoop.io.compress.GzipCodec或者其他压缩方式。

    5.设置RPC监听数量

    hbase-site.xml

    属性:hbase.regionserver.handler.count

    解释:默认值为30,用于指定RPC监听的数量,可以根据客户端的请求数进行调整,读写请求较多时,增加此值。

    6.优化HStore文件大小

    hbase-site.xml

    属性:hbase.hregion.max.filesize

    解释:默认值10737418240(10GB),如果需要运行HBase的MR任务,可以减小此值,因为一个region对应一个map任务,如果单个region过大,会导致map任务执行时间过长。该值的意思就是,如果HFile的大小达到这个数值,则这个region会被切分为两个Hfile。

    7.优化hbase客户端缓存

    hbase-site.xml

    属性:hbase.client.write.buffer

    解释:用于指定HBase客户端缓存,增大该值可以减少RPC调用次数,但是会消耗更多内存,反之则反之。一般我们需要设定一定的缓存大小,以达到减少RPC次数的目的。

    8.指定scan.next扫描HBase所获取的行数

    hbase-site.xml

    属性:hbase.client.scanner.caching

    解释:用于指定scan.next方法获取的默认行数,值越大,消耗内存越大。

    9.flush、compact、split机制

    当MemStore达到阈值,将Memstore中的数据Flush进Storefile;compact机制则是把flush出来的小文件合并成大的Storefile文件。split则是当Region达到阈值,会把过大的Region一分为二。

    涉及属性:

    即:128M就是Memstore的默认阈值

    hbase.hregion.memstore.flush.size:134217728

    即:这个参数的作用是当单个HRegion内所有的Memstore大小总和超过指定值时,flush该HRegion的所有memstore。RegionServer的flush是通过将请求添加一个队列,模拟生产消费模型来异步处理的。那这里就有一个问题,当队列来不及消费,产生大量积压请求时,可能会导致内存陡增,最坏的情况是触发OOM。

    hbase.regionserver.global.memstore.upperLimit:0.4

    hbase.regionserver.global.memstore.lowerLimit:0.38

    即:当MemStore使用内存总量达到

    hbase.regionserver.global.memstore.upperLimit指定值时,将会有多个MemStores flush到文件中,MemStore flush 顺序是按照大小降序执行的,直到刷新到MemStore使用内存略小于lowerLimit

    展开全文
  • hbase

    千次阅读 2018-08-03 11:34:02
    HBase是一个高可靠性、高性能、面向列、可伸缩的分布式存储系统。  适合于存储大表数据(表的规模可以达到数十亿行以及数百万列),并且对大表数据的读、写访问可以达到实时级别;  利用Hadoop HDFS...

    一、hbase

    HBase是一个高可靠性、高性能、面向列、可伸缩的分布式存储系统。

     适合于存储大表数据(表的规模可以达到数十亿行以及数百万列),并且对大表数据的读、写访问可以达到实时级别;
     利用Hadoop HDFS(Hadoop Distributed File System)作为其文件存储系统,提供高可靠性、高性能、列存储、可伸缩、实时读写的数据库系统;
     利用ZooKeeper作为协同服务。

    与RMDB比较:

    HBase
    分布式存储,面向列。
    动态扩展列。
    普通商用硬件支持,扩容成本低。
    RMDB
    数据结构固定。
    需要预先定义好数据结构。
    需要大量IO,扩展成本大。

    HBase适合具有如下需求的应用:

    海量数据(TB、PB)
    高吞吐量
    需要在海量数据中实现高效的随机读取
    需要很好的性能伸缩能力
    能够同时处理结构化和非结构化的数据
    不需要完全拥有传统关系型数据库所具备的ACID特性

    数据结构介绍:

    结构化数据
     具有固定的结构,属性划分,以及类型等信息。我们通常所理解的关系型数据库中所存储的数据信息,大多是结构化数据, 如职工信息表,拥有ID、Name、Phone、Address等属性信息。
     通常直接
    展开全文
  • 一篇文章让你了解Hive和HBase的区别

    万次阅读 多人点赞 2018-08-07 09:41:38
    相信做大数据开发的朋友对hive和HBase一定不会陌生。 HBASE 想了解更多大数据相关知识可以点击“了解更多” Hive是基于Hadoop的一个数据仓库工具,可以将结构化的数据文件映射为一张数据库表,并提供简单的sql...

    相信做大数据开发的朋友对hive和HBase一定不会陌生。

    一篇文章让你了解Hive和HBase的区别

    HBASE

    想了解更多大数据相关知识可以加V免费领取资料哦:baizhan112

    Hive是基于Hadoop的一个数据仓库工具,可以将结构化的数据文件映射为一张数据库表,并提供简单的sql查询功能,可以将sql语句转换为MapReduce任务进行运行。HBase是Hadoop的数据库,一个分布式、可扩展、大数据的存储。单个的从字面意思上或许很难看出二者的区别,别急,下面我们就对二者做个详细的介绍。

    两者的特点

    Hive帮助熟悉SQL的人运行MapReduce任务。因为它是JDBC兼容的,同时,它也能够和现存的SQL工具整合在一起。运行Hive查询会花费很长时间,因为它会默认遍历表中所有的数据。虽然有这样的缺点,一次遍历的数据量可以通过Hive的分区机制来控制。分区允许在数据集上运行过滤查询,这些数据集存储在不同的文件夹内,查询的时候只遍历指定文件夹(分区)中的数据。这种机制可以用来,例如,只处理在某一个时间范围内的文件,只要这些文件名中包括了时间格式。

    HBase通过存储key/value来工作。它支持四种主要的操作:增加或者更新行,查看一个范围内的cell,获取指定的行,删除指定的行、列或者是列的版本。版本信息用来获取历史数据(每一行的历史数据可以被删除,然后通过Hbase compactions就可以释放出空间)。虽然HBase包括表格,但是schema仅仅被表格和列簇所要求,列不需要schema。Hbase的表格包括增加/计数功能。

    限制

    Hive目前不支持更新操作。另外,由于hive在hadoop上运行批量操作,它需要花费很长的时间,通常是几分钟到几个小时才可以获取到查询的结果。Hive必须提供预先定义好的schema将文件和目录映射到列,并且Hive与ACID不兼容。

    HBase查询是通过特定的语言来编写的,这种语言需要重新学习。类SQL的功能可以通过Apache Phonenix实现,但这是以必须提供schema为代价的。另外,Hbase也并不是兼容所有的ACID特性,虽然它支持某些特性。最后但不是最重要的–为了运行Hbase,Zookeeper是必须的,zookeeper是一个用来进行分布式协调的服务,这些服务包括配置服务,维护元信息和命名空间服务。

    应用场景

    Hive适合用来对一段时间内的数据进行分析查询,例如,用来计算趋势或者网站的日志。Hive不应该用来进行实时的查询。因为它需要很长时间才可以返回结果。

    Hbase非常适合用来进行大数据的实时查询。Facebook用Hbase进行消息和实时的分析。它也可以用来统计Facebook的连接数。

    总结

    Hive和Hbase是两种基于Hadoop的不同技术–Hive是一种类SQL的引擎,并且运行MapReduce任务,Hbase是一种在Hadoop之上的NoSQL 的Key/vale数据库。当然,这两种工具是可以同时使用的。就像用Google来搜索,用FaceBook进行社交一样,Hive可以用来进行统计查询,HBase可以用来进行实时查询,数据也可以从Hive写到Hbase,设置再从Hbase写回Hive。

    展开全文
  • hbase(main):011:0> create 'myns:user_info','base_info','extra_info' 1. 插入数据(put命令,不能一次性插入多条) hbase(main):012:0> put 'myns:user_info','001','base_info:username','张三' 2. scan...
  • HBase Shell命令大全

    万次阅读 多人点赞 2019-03-18 20:55:18
    HBase关键名称: Row Key 列族 column family 单元 Cell 时间戳 timestamp HBase Shell 是官方提供的一组命令,用于操作HBase。如果配置了HBase的环境变量了,就可以知己在命令行中输入hbase shell 命令进入命令行。...

    一:简介

    HBase的名字的来源于Hadoop database,即hadoop数据库,不同于一般的关系数据库,它是非结构化数据存储的数据库,而且它是基于列的而不是基于行的模式。

    HBase是一个分布式的、面向列的、基于Google Bigtable的开源实现。
    利用Hadoop HDFS作为其文件存储系统,
    利用Hadoop MapReduce来处理HBase中的海量数据,
    利用Zookeeper作为协同服务。

    二:HBase重要概念

    HBase的表结构

    HBase以表的形式存储数据。表有行和列组成。列划分为若干个列族/列簇(column family),每个列族/列簇下面可以有多个普通列。

    在这里插入图片描述

    表Table

    HBase是用表来存储数据的。

    命名空间namespace

    namespace命名空间指对一组表的逻辑分组,类似RDBMS中的database,方便对表在业务上划分。
    HBase系统默认定义了两个缺省的namespace:

    • hbase:系统内建表,包含namespace和meta表
    • default:用户建表时未指定namespace的表都创建在此

    行键 Row Key

    行键,每一行的主键列,每行的行键要唯一,行键的值为任意字符串(最大长度是 64KB,实际应用中长度一般为 10-100bytes),在HBase内部,rowKey保存为字节数组byte[]
    行的一次读写是原子操作 (不论一次读写多少列)

    区域Region

    Table在行的方向上分割为多个Region。

    Region是按大小分割的,每个表开始只有一个region,随着数据的增多,region不断增大,当增大到一个阀值的时候,region就会等分为两个新的region,之后会有越来越多的region。

    Region是HBase中分布式存储和负载均衡的最小单元。不同的Region分布到不同的RegionServer上。

    Region由一个或者多个Store组成, 每个Store保存一个column family, 每个Store又由一个MemStore(存储在内存中)和0到多个StoreFile(存储在HDFS上)组成
    在这里插入图片描述

    列族 column family

    列族是每个子列的父级,每个子列都属于一个列族,一个列族包含一个或者多个相关列,创建表的时候需要指定列族,而列不需要必须指定。通过“列族名:列名”来表示某个具体的子列。

    HBase中的Schema就是 TableName + Column Family Name

    列限定符

    就是列族下的每个子列名称,或者称为相关列,或者称为限定符,只是翻译不同。
    通过columnFamily:column来定位某个子列。

    存储单元 cell

    我们外观看到的每个单元格其实都对应着多个存储单元,默认情况下一个单元格对应着一个存储单元,一个存储单元可以存储一份数据,如果一个单元格有多个存储单元就表示一个单元格可以存储多个值。可以通过version来设置存储单元个数。可以通过
    rowKey + columnFamily + column + timestamp来唯一确定一个存储单元。cell中的数据是没有类型的,全部是字节码形式存贮。

    hbase按照时间戳降序排列各时间版本,其他映射建按照升序排序。

    时间戳版本号 timestamp

    每个cell都保存着同一份数据的多个版本。版本通过时间戳来索引。时间戳的类型是 64位整型。时间戳可以由hbase(在数据写入时自动 )赋值,此时时间戳是精确到毫秒的当前系统时间。时间戳也可以由客户显式赋值。如果应用程序要避免数据版本冲突,就必须自己生成具有唯一性的时间戳。每个cell中,不同版本的数据按照时间倒序排序,即最新的数据排在最前面。

    为了避免数据存在过多版本造成的的管理 (包括存贮和索引)负担,hbase提供了两种数据版本回收方式。一是保存数据的最后n个版本,二是保存最近一段时间内的版本(比如最近七天)。用户可以针对每个列族进行设置。

    三:HBase Shell

    命名描述语法
    help ‘命名名’查看命令的使用描述help ‘命令名’
    whoami我是谁whoami
    version返回hbase版本信息version
    status返回hbase集群的状态信息status
    table_help查看如何操作表table_help
    create创建表create ‘表名’, ‘列族名1’, ‘列族名2’, ‘列族名N’
    alter修改列族添加一个列族:alter ‘表名’, ‘列族名’
    删除列族:alter ‘表名’, {NAME=> ‘列族名’, METHOD=> ‘delete’}
    describe显示表相关的详细信息describe ‘表名’
    list列出hbase中存在的所有表list
    exists测试表是否存在exists ‘表名’
    put添加或修改的表的值put ‘表名’, ‘行键’, ‘列族名’, ‘列值’
    put ‘表名’, ‘行键’, ‘列族名:列名’, ‘列值’
    scan通过对表的扫描来获取对用的值scan ‘表名’
    扫描某个列族: scan ‘表名’, {COLUMN=>‘列族名’}
    扫描某个列族的某个列: scan ‘表名’, {COLUMN=>‘列族名:列名’}
    查询同一个列族的多个列: scan ‘表名’, {COLUMNS => [ ‘列族名1:列名1’, ‘列族名1:列名2’, …]}
    get获取行或单元(cell)的值get ‘表名’, ‘行键’
    get ‘表名’, ‘行键’, ‘列族名’
    count统计表中行的数量count ‘表名’
    incr增加指定表行或列的值incr ‘表名’, ‘行键’, ‘列族:列名’, 步长值
    get_counter获取计数器get_counter ‘表名’, ‘行键’, ‘列族:列名’
    delete删除指定对象的值(可以为表,行,列对应的值,另外也可以指定时间戳的值)删除列族的某个列: delete ‘表名’, ‘行键’, ‘列族名:列名’
    deleteall删除指定行的所有元素值deleteall ‘表名’, ‘行键’
    truncate重新创建指定表truncate ‘表名’
    enable使表有效enable ‘表名’
    is_enabled是否启用is_enabled ‘表名’
    disable使表无效disable ‘表名’
    is_disabled是否无效is_disabled ‘表名’
    drop删除表drop的表必须是disable的
    disable ‘表名’
    drop ‘表名’
    shutdown关闭hbase集群(与exit不同)
    tools列出hbase所支持的工具
    exit退出hbase shell

    HBase Shell 是官方提供的一组命令,用于操作HBase。如果配置了HBase的环境变量了,就可以知己在命令行中输入hbase shell 命令进入命令行。

    hbase shell
    

    在这里插入图片描述

    help命令

    可以通过 help '命名名称'来查看命令行的具体使用,包括命令的作用和用法。
    通过help ‘hbase’ 命名来查看hbase shell 支持的所有命令,hbase将命令进行分组,其中ddl、dml使用较多。
    在这里插入图片描述

    在这里插入图片描述

    四:general 命名

    1. 显示集群状态status

    可以为 ‘summary’, ‘simple’, ‘detailed’, or ‘replication’. 默认为 ‘summary’

    hbase> status
    hbase> status 'simple'
    hbase> status 'summary'
    hbase> status 'detailed'
    hbase> status 'replication'
    hbase> status 'replication', 'source'
    hbase> status 'replication', 'sink'
    

    在这里插入图片描述

    2. 查询数据库版本version

    在这里插入图片描述

    3. 显示当前用户与组 whoami

    在这里插入图片描述

    4. 查看操作表的命令table_help

    在这里插入图片描述

    5. 退出HBase Shell exit

    exit
    

    五:ddl命令

    1. 创建表create

    注意:创建表时只需要指定列族名称,不需要指定列名。

    # 语法
    create '表名', {NAME => '列族名1'}, {NAME => '列族名2'}, {NAME => '列族名3'}
    # 此种方式是上上面的简写方式,使用上面方式可以为列族指定更多的属性,如VERSIONS、TTL、BLOCKCACHE、CONFIGURATION等属性
    create '表名', '列族名1', '列族名2', '列族名3'
    
    create '表名', {NAME => '列族名1', VERSIONS => 版本号, TTL => 过期时间, BLOCKCACHE => true}
    
    
    # 示例
    create 'tbl_user', 'info', 'detail'
    create 't1', {NAME => 'f1', VERSIONS => 1, TTL => 2592000, BLOCKCACHE => true}
    

    在这里插入图片描述

    2. 修改(添加、删除)表结构Schema alter

    2.1 添加一个列族

    # 语法 
    alter '表名', '列族名'
    
    # 示例
    alter 'tbl_user', 'address'
    

    在这里插入图片描述

    2.2 删除一个列族

    # 语法 
    alter '表名', {NAME=> '列族名', METHOD=> 'delete'}
    
    # 示例
    alter 'tbl_user', {NAME=> 'address', METHOD=> 'delete'}
    

    在这里插入图片描述
    3.3 修改列族的属性
    可以修改列族的VERSIONS、IN_MEMORY

    # 修改f1列族的版本为5
    alter 't1', NAME => 'f1', VERSIONS => 5
    
    # 修改多个列族,修改f2为内存,版本号为5
    alter 't1', 'f1', {NAME => 'f2', IN_MEMORY => true}, {NAME => 'f3', VERSIONS => 5}
    
    # 也可以修改table-scope属性,例如MAX_FILESIZE, READONLY,MEMSTORE_FLUSHSIZE, DEFERRED_LOG_FLUSH等。
    # 例如,修改region的最大大小为128MB:
    alter 't1', MAX_FILESIZE => '134217728'
    

    3. 异步修改Schema alter_async

    # change or add the 'f1' column family in table 't1' from defaults
    to instead keep a maximum of 5 cell VERSIONS
    alter_async 't1', NAME => 'f1', VERSIONS => 5
    
    # delete the 'f1' column family in table 'ns1:t1'
    alter_async 'ns1:t1', NAME => 'f1', METHOD => 'delete'
    alter_async 'ns1:t1', 'delete' => 'f1'
    
    # change the max size of a family to 128MB
    alter 't1', METHOD => 'table_att', MAX_FILESIZE => '134217728'
    alter 't1', {NAME => 'f1'}, {NAME => 'f2', METHOD => 'delete'}
    

    4. 获取alter_async执行的状态 alter_status

    alter_status '表名'
    

    5. 获取表的描述describe

    # 语法 
    describe '表名'
    
    # 示例
    describe 'tbl_user'
    

    在这里插入图片描述

    6. 列举所有表list

    在这里插入图片描述

    7. 表是否存在exists

    # 语法 
    exists '表名'
    
    # 示例
    exists 'tbl_user'
    

    在这里插入图片描述

    8. 启用表enable和禁用表disable

    通过enable和disable来启用/禁用这个表,相应的可以通过is_enabled和is_disabled来检查表是否被禁用。

    # 语法
    enable '表名'
    is_enabled '表名'
    
    disable '表名'
    is_disabled '表名'
    
    # 示例
    disable 'tbl_user'
    is_disabled 'tbl_user'
    
    enable 'tbl_user'
    is_enabled 'tbl_user'
    

    在这里插入图片描述

    9. 禁用满足正则表达式的所有表disable_all

    • .匹配除“\n”和"\r"之外的任何单个字符
    • *匹配前面的子表达式任意次
    # 匹配以t开头的表名
    disable_all 't.*'
    # 匹配指定命名空间ns下的以t开头的所有表
    disable_all 'ns:t.*'
    # 匹配ns命名空间下的所有表
    disable_all 'ns:.*'
    

    10. 启用满足正则表达式的所有表enable_all

    enable_all 't.*'
    enable_all 'ns:t.*'
    enable_all 'ns:.*'
    

    11. 删除表drop

    需要先禁用表,然后再删除表,启用的表是不允许删除的

    # 语法
    disable '表名'
    drop '表名'
    
    # 示例
    disable 'tbl_user'
    drop 'tbl_user'
    

    在这里插入图片描述

    12. 删除满足正则表达式的所有表drop_all

    drop_all 't.*'
    drop_all 'ns:t.*'
    drop_all 'ns:.*'
    

    13. 获取某个表赋值给一个变量 get_table

    通过 var = get_table ‘表名’ 赋值给一个变量对象,然后对象.来调用,就像面向对象编程一样,通过对象.方法来调用,这种方式在操作某个表时就不必每次列举表名了。
    在这里插入图片描述

    14. 获取rowKey所在的区 locate_region

    locate_region '表名', '行键'
    

    在这里插入图片描述

    15. 显示hbase所支持的所有过滤器show_filters

    过滤器用于get和scan命令中作为筛选数据的条件,类型关系型数据库中的where的作用
    在这里插入图片描述


    六:namespace命令

    1. 列举命名空间 list_namespace

    在这里插入图片描述

    2. 获取命名空间描述 describe_namespace

    在这里插入图片描述

    3. 查看命名空间下的所有表 list_namespace_tables

    在这里插入图片描述

    4. 创建命名空间create_namespace

    在这里插入图片描述

    5. 修改命名空间的属性

    # add/modify a property
    alter_namespace 'ns1', {METHOD => 'set', 'PROPERTY_NAME' => 'PROPERTY_VALUE'}
    # delete a property
    alter_namespace 'ns1', {METHOD => 'unset', NAME=>'PROPERTY_NAME'}
    

    6. 删除命名空间drop_namespace

    drop_namespace '命名空间名称'
    

    七:dml命令

    1. 插入或者修改数据put

    # 语法
    # 当列族中只有一个列时'列族名:列名'使用'列族名'
    put '表名', '行键', '列族名', '列值'
    put '表名', '行键', '列族名:列名', '列值'
    
    # 示例
    
    # 创建表
    create 'tbl_user', 'info', 'detail', 'address'
    
    # 第一行数据
    put 'tbl_user', 'mengday', 'info:id', '1'
    put 'tbl_user', 'mengday', 'info:name', '张三'
    put 'tbl_user', 'mengday', 'info:age', '28'
    
    put 'tbl_user', 'mengday', 'detail:birthday', '1990-06-26'
    put 'tbl_user', 'mengday', 'detail:email', 'abc@163.com'
    put 'tbl_user', 'mengday', 'detail:create_time', '2019-03-04 14:26:10'
    
    put 'tbl_user', 'mengday', 'address', '上海市'
    
    # 第二行数据
    put 'tbl_user', 'vbirdbest', 'info:id', '2'
    put 'tbl_user', 'vbirdbest', 'info:name', '李四'
    put 'tbl_user', 'vbirdbest', 'info:age', '27'
    
    put 'tbl_user', 'vbirdbest', 'detail:birthday', '1990-06-27'
    put 'tbl_user', 'vbirdbest', 'detail:email', 'xxx@gmail.com'
    put 'tbl_user', 'vbirdbest', 'detail:create_time', '2019-03-05 14:26:10'
    
    put 'tbl_user', 'vbirdbest', 'address', '北京市'
    
    
    # 第一行数据
    put 'tbl_user', 'xiaoming', 'info:id', '3'
    put 'tbl_user', 'xiaoming', 'info:name', '王五'
    put 'tbl_user', 'xiaoming', 'info:age', '26'
    
    put 'tbl_user', 'xiaoming', 'detail:birthday', '1990-06-28'
    put 'tbl_user', 'xiaoming', 'detail:email', 'xyz@qq.com'
    put 'tbl_user', 'xiaoming', 'detail:create_time', '2019-03-06 14:26:10'
    
    put 'tbl_user', 'xiaoming', 'address', '杭州市'
    

    在这里插入图片描述

    2. 全表扫描scan

    获取表的所有数据

    # 语法
    scan '表名'
    
    # 示例
    scan 'tbl_user'
    

    在这里插入图片描述
    注意:中文编码了

    扫描整个列簇

    # 语法
    scan '表名', {COLUMN=>'列族名'}
    
    # 示例
    scan 'tbl_user', {COLUMN=>'info'}
    

    在这里插入图片描述

    扫描整个列簇的某个列

    # 语法
    scan '表名', {COLUMN=>'列族名:列名'}
    
    # 示例
    scan 'tbl_user', {COLUMN=>'info:age'}
    

    在这里插入图片描述

    3. 获取数据get

    # 语法
    get '表名', '行键'
    
    # 示例
    get 'tbl_user', 'mengday'
    

    在这里插入图片描述
    根据某一行某列族的数据

    # 语法
    get '表名', '行键', '列族名'
    
    # 示例
    get 'tbl_user', 'mengday', 'info'
    

    在这里插入图片描述

    # 创建表,c1版本为4, 元数据mykey=myvalue
    hbase(main):009:0> create 't1', {NAME => 'c1', VERSIONS => 4}, METADATA => { 'mykey' => 'myvalue' }
    0 row(s) in 2.2810 seconds
    
    => Hbase::Table - t1
    # 添加列族c2, c3
    hbase(main):010:0> alter 't1', 'c2', 'c3'
    Updating all regions with the new schema...
    1/1 regions updated.
    Done.
    Updating all regions with the new schema...
    1/1 regions updated.
    Done.
    0 row(s) in 3.8320 seconds
    
    # 出入数据,c1 插入4个版本的值
    hbase(main):011:0> put 't1', 'r1', 'c1', 'v1'
    0 row(s) in 0.1000 seconds
    
    hbase(main):012:0> put 't1', 'r1', 'c1', 'v11'
    0 row(s) in 0.0180 seconds
    
    hbase(main):013:0> put 't1', 'r1', 'c1', 'v111'
    0 row(s) in 0.0140 seconds
    
    hbase(main):014:0> put 't1', 'r1', 'c1', 'v1111'
    0 row(s) in 0.0140 seconds
    
    # 插入c2、c3的值
    hbase(main):015:0> put 't1', 'r1', 'c2', 'v2'
    0 row(s) in 0.0140 seconds
    
    hbase(main):016:0> put 't1', 'r1', 'c3', 'v3'
    0 row(s) in 0.0210 seconds
    
    # 获取rowKey=r1的一行记录
    hbase(main):017:0> get 't1', 'r1'
    COLUMN                                              CELL
     c1:                                                timestamp=1552819382575, value=v1111
     c2:                                                timestamp=1552819392398, value=v2
     c3:                                                timestamp=1552819398244, value=v3
    3 row(s) in 0.0550 seconds
    
    # 获取rowKey=r1并且 1552819392398 <= 时间戳范围 < 1552819398244
    hbase(main):018:0> get 't1', 'r1', {TIMERANGE => [1552819392398, 1552819398244]}
    COLUMN                                              CELL
     c2:                                                timestamp=1552819392398, value=v2
    1 row(s) in 0.0090 seconds
    
    # 获取指定列的值
    hbase(main):019:0> get 't1', 'r1', {COLUMN => 'c1'}
    COLUMN                                              CELL
     c1:                                                timestamp=1552819382575, value=v1111
    1 row(s) in 0.0160 seconds
    
    # 获取指定列的值,多个值使用数组表示
    hbase(main):020:0> get 't1', 'r1', {COLUMN => ['c1', 'c2', 'c3']}
    COLUMN                                              CELL
     c1:                                                timestamp=1552819382575, value=v1111
     c2:                                                timestamp=1552819392398, value=v2
     c3:                                                timestamp=1552819398244, value=v3
    3 row(s) in 0.0170 seconds
    
    # 获取c1的值,获取4个版本的值,默认是按照时间戳降续排序的
    hbase(main):021:0> get 't1', 'r1', {COLUMN => 'c1', VERSIONS => 4}
    COLUMN                                              CELL
     c1:                                                timestamp=1552819382575, value=v1111
     c1:                                                timestamp=1552819376343, value=v111
     c1:                                                timestamp=1552819368993, value=v11
     c1:                                                timestamp=1552819362975, value=v1
    4 row(s) in 0.0180 seconds
    
    # 获取c1的3个版本值
    hbase(main):027:0* get 't1', 'r1', {COLUMN => 'c1', VERSIONS => 3}
    COLUMN                                               CELL
     c1:                                                 timestamp=1552819382575, value=v1111
     c1:                                                 timestamp=1552819376343, value=v111
     c1:                                                 timestamp=1552819368993, value=v11
    3 row(s) in 0.0090 seconds
    
    # 获取指定时间戳版本的列
    hbase(main):022:0> get 't1', 'r1', {COLUMN => 'c1', TIMESTAMP => 1552819376343}
    COLUMN                                              CELL
     c1:                                                timestamp=1552819376343, value=v111
    1 row(s) in 0.0170 seconds
    
    hbase(main):023:0> get 't1', 'r1', {COLUMN => 'c1', TIMESTAMP => 1552819376343, VERSIONS => 4}
    COLUMN                                              CELL
     c1:                                                timestamp=1552819376343, value=v111
    1 row(s) in 0.0130 seconds
    
    # 获取rowKey=r1中的值等于v2的所有列
    hbase(main):024:0> get 't1', 'r1', {FILTER => "ValueFilter(=, 'binary:v2')"}
    COLUMN                                              CELL
     c2:                                                timestamp=1552819392398, value=v2
    1 row(s) in 0.0510 seconds
    
    
    hbase(main):025:0> get 't1', 'r1', {COLUMN => 'c1', ATTRIBUTES => {'mykey'=>'myvalue'}}
    COLUMN                                              CELL
     c1:                                                timestamp=1552819382575, value=v1111
    1 row(s) in 0.0100 seconds
    

    4. 删除某个列族中的某个列delete

    # 语法
    delete '表名', '行键', '列族名:列名'
    
    
    create 'tbl_test', 'columnFamily1'
    
    put 'tbl_test', 'rowKey1', 'columnFamily1:column1', 'value1'
    put 'tbl_test', 'rowKey1', 'columnFamily1:column2', 'value2'
    
    delete 'tbl_test', 'rowKey1', 'columnFamily1:column1'
    

    在这里插入图片描述

    5. 删除某行数据deleteall

    # 语法
    deleteall '表名', '行键'
    
    # 示例
    deleteall 'tbl_test', 'rowKey1'
    

    在这里插入图片描述

    6. 清空整个表的数据truncate

    先disable表,然后再drop表,最后重新create表

    truncate '表名'
    

    在这里插入图片描述

    7. 查询表中有多少行count

    # 语法
    count '表名'
    
    # 示例
    count 'tbl_user'
    

    在这里插入图片描述

    8. 自增incr

    # 语法
    incr '表名', '行键', '列族:列名', 步长值
    
    # 示例 
    # 注意:incr 可以对不存的行键操作,如果行键已经存在会报错,如果使用put修改了incr的值再使用incr也会报错
    # ERROR: org.apache.hadoop.hbase.DoNotRetryIOException: Field is not a long, it's 2 bytes wide
    incr 'tbl_user', 'xiaohong', 'info:age', 1
    

    在这里插入图片描述

    9. 计数器get_counter

    # 点击量:日、周、月
    create 'counters', 'daily', 'weekly', 'monthly'
    incr 'counters', '20110101', 'daily:hits', 1
    incr 'counters', '20110101', 'daily:hits', 1
    get_counter 'counters', '20110101', 'daily:hits'
    

    在这里插入图片描述

    10. 修饰词

    10.1 COLUMNS: 查询同一个列族的多个列
    # 语法
    
    scan '表名', {COLUMNS => [ '列族名1:列名1', '列族名1:列名2', ...]}
    
    # 示例
    scan 'tbl_user', {COLUMNS => [ 'info:id', 'info:age']}
    

    在这里插入图片描述

    10.2 TIMESTAMP 指定时间戳
    scan 't1', {COLUMNS => 'c2', TIMESTAMP=> 1552819392398}
    
    10.3 TIMERANGE表示的是”>=开始时间 and <结束时间“
    # 语法
    scan '表名',{TIMERANGE=>[timestamp1, timestamp2]}
    
    # 示例
    scan 'tbl_user',{TIMERANGE=>[1551938004321, 1551938036450]}
    

    在这里插入图片描述

    10.4 VERSIONS

    默认情况下一个列只能存储一个数据,后面如果修改数据就会将原来的覆盖掉,可以通过指定VERSIONS时HBase一列能存储多个值。

    create 'tbl_test', 'columnFamily1'
    describe 'tbl_test'
    
    # 修改列族版本号
    alter 'tbl_test', { NAME=>'columnFamily1', VERSIONS=>3 }
    
    put 'tbl_test', 'rowKey1', 'columnFamily1:column1', 'value1'
    put 'tbl_test', 'rowKey1', 'columnFamily1:column1', 'value2'
    put 'tbl_test', 'rowKey1', 'columnFamily1:column1', 'value3'
    
    # 默认返回最新的一条数据
    get 'tbl_test','rowKey1','columnFamily1:column1'
    
    # 返回3个
    get 'tbl_test','rowKey1',{COLUMN=>'columnFamily1:column1', VERSIONS=>3}
    # 返回2个
    get 'tbl_test','rowKey1',{COLUMN=>'columnFamily1:column1', VERSIONS=>2}
    

    在这里插入图片描述

    10.5 STARTROW

    ROWKEY起始行。会先根据这个key定位到region,再向后扫描

    # 语法
    scan '表名', { STARTROW => '行键名'}
    
    # 示例
    scan 'tbl_user', { STARTROW => 'vbirdbest'}
    

    在这里插入图片描述

    10.6 STOPROW :截止到STOPROW行,STOPROW行之前的数据,不包括STOPROW这行数据
    # 语法
    scan '表名', { STOPROW => '行键名'}
    
    # 示例
    scan 'tbl_user', { STOPROW => 'vbirdbest'}
    

    在这里插入图片描述

    10.7 LIMIT 返回的行数
    # 语法
    scan '表名', { LIMIT => 行数}
    
    # 示例
    scan 'tbl_user', { LIMIT => 2 }
    

    在这里插入图片描述

    11. FILTER条件过滤器

    过滤器之间可以使用AND、OR连接多个过滤器。

    ValueFilter 值过滤器
    # 语法:binary 等于某个值
    scan '表名', FILTER=>"ValueFilter(=,'binary:列值')"
    # 语法 substring:包含某个值
    scan '表名', FILTER=>"ValueFilter(=,'substring:列值')"
    
    # 示例
    scan 'tbl_user', FILTER=>"ValueFilter(=, 'binary:26')"
    scan 'tbl_user', FILTER=>"ValueFilter(=, 'substring:6')"
    

    在这里插入图片描述

    ColumnPrefixFilter 列名前缀过滤器
    # 语法 substring:包含某个值
    scan '表名', FILTER=>"ColumnPrefixFilter('列名前缀')"
    
    # 示例
    scan 'tbl_user', FILTER=>"ColumnPrefixFilter('birth')"
    # 通过括号、AND和OR的条件组合多个过滤器
    scan 'tbl_user', FILTER=>"ColumnPrefixFilter('birth') AND ValueFilter(=,'substring:26')"
    

    在这里插入图片描述

    rowKey字典排序

    Table中的所有行都是按照row key的字典排序的
    在这里插入图片描述

    三:HBase 常见错误

    hbase shell在使用的时候经常会报错,这里列举了几个错误:

    1. HBase创建不存在的表报已经存在错误 ERROR: Table already exists: !

    解决办法:

    # 1. 进入zookeeper client模式
    cd /usr/local/Cellar/hbase/1.2.9/bin
    hbase zkcli
    
    # 2. 在zk client模式下输入ls /hbase/table命令看到zombie table
    ls /hbase/table
    
    # 3. 删除表,TABLE_NAME为要删除的表名
    rmr /hbase/table/TABLE_NAME
    
    # 4. 重启hbase
    ./stop-hbase.sh
    ./start-hbase.sh
    
    2. ERROR: org.apache.hadoop.hbase.ipc.ServerNotRunningYetException: Server is not running yet
    # 使用jps查看是否有datanode服务
    jps
    
    删除hadoop 的临时目录
    /usr/local/Cellar/hadoop/3.1.1/libexec/tmp
    
    3. ERROR: Can’t get master address from ZooKeeper; znode data == null
    # 重启hbase
    ./stop-hbase.sh
    
    ./start-hbase.sh
    

    4. ERROR: org.apache.hadoop.hbase.PleaseHoldException: Master is initializing

    这个错误出现的原因很多,这里说一下我的错误原因是hbase-site.xml中的有个属性名配置错误, 网上有的是hbase.rootdir, name配置成这个有的时候会报错有的时候不会报错,报错的时候格式化一下hadoop然后再重新启动,这种方式有的时候能解决问题,有的时候解决不了。这里我将hbase.rootdir改为hbase.root.dir 就不报错了,不知道是不是版本不同属性名配置不同,我的hadoop版本为3.1.1,hbase版本为1.2.9

    <!-- 正确的配置的属性名应为hbase.root.dir而不是hbase.rootdir -->
    <property>
      <name>hbase.root.dir</name>
      <value>hdfs://localhost:8020/hbase</value>
    </property>
    

    相关文档

    HBase操作(Shell与Java API)https://blog.csdn.net/u013980127/article/details/52443155

    展开全文
  • Hbase原理、基本概念、基本架构

    万次阅读 多人点赞 2013-12-26 16:36:37
    HBase是一个构建在HDFS上的分布式列存储系统; HBase是基于Google BigTable模型开发的,典型的key/value系统; HBase是Apache Hadoop生态系统中的重要一员,主要用于海量结构化数据存储; 从逻辑上讲,HBase将数据...
  • HbaseTemplate 操作hbase

    热门讨论 2015-04-10 09:58:38
    java 利用 sping-data-hadoop HbaseTemplate 操作hbase find get execute 等方法 可以直接运行
  • 搭建完集群之后,在hbase shell中查看表或者查看状态时,出现error: KeeperErrorCode = NoNode for /hbase/master 如图所示: 错误原因 在我们查看日志文件时发现hbase启动成功后,过几秒钟就自动停止了。这是因为...
  • 搭建pinpoint需要的hbase初始化脚本hbase-create.hbase
  • Hbase权限控制

    万次阅读 2016-05-15 23:36:09
    Hbase权限配置、使用手册 1 Hbase权限控制简介 Hbase的权限控制是通过AccessController Coprocessor协处理器框架实现的,可实现对用户的RWXCA的权限控制。 2 配置 配置hbase-site.xml CM主页→点击hbase(进入Hbase...
  • HBase学习总结

    万次阅读 2016-01-08 22:58:19
    HBase的下载与安装   (HBase是一种数据库:Hadoop数据库,它是一种NoSQL存储系统,专门设计用来快速随机读写大规模数据。本文介绍HBase的下载与安装的整个过程。)  一、HBase的下载  1.登录HBase官网...
  • HBase_Hbase 查看Hbase 版本

    千次阅读 2020-04-20 15:45:25
    我们可以利用 Hbase-shell 进行版本的查看 进入Hbase-shell 后可以看到 hbase版本 [root@cdh-manager ~]# hbase shell Java HotSpot(TM) 64-Bit Server VM warning: Using incremental CMS is deprecated and ...
  • hbase1.2.3

    2017-10-30 23:33:46
    hbase-1.2.3-bin.tar.gz 本文首先简单介绍了HBase,然后重点讲述了HBase的高并发和实时处理数据 、HBase数据模型、HBase物理存储、HBase系统架构,HBase调优、HBase Shell访问等
  • hbase笔记

    万次阅读 2020-09-08 09:39:16
    【1】HBase介绍 【2】单机部署 【3】伪分布式部署 【4】ubuntu16.04集群部署hbase 【1】HBase介绍 HBase(Hadoop Database)是一个高可靠性、高性能、面向列、可伸缩、 实时读写的分布式数据库,利用Hadoop HDFS作为其...
  • hbase安装包

    2018-11-05 17:11:36
    hbase 安装包,分别有hadoop-common-2.2.0-bin-master、hbase-0.98.3-hadoop2
  • 大数据HBase系列之HBase基本操作

    万次阅读 2018-11-01 18:04:52
    1. hbase命令 版本查看 hbase version 连接Zookeeper客户端 hbase zkcli 连接HBase客户端 hbase shell 2. CRUD 2.1 创建表 -- 语法:create '表名','列族名' create 'student','info' 2.2 显示所有表 ...
  • spring hbase hbaseTemplate

    千次阅读 2016-12-23 09:52:16
    spring hbase template延续spring 模板模式的一贯风格,只需要配置连接池属性和注册template,重写template的方法即可使用。 吐槽:个人当时网上搜索时,发现很多都是copy代码,用不了。无语。 开始之前:有一个...
  • hbase 实战hbase 实战hbase 实战hbase 实战hbase 实战hbase 实战hbase 实战
  • hbase入门精讲

    万人学习 2015-10-16 09:47:47
    通过学习hbase,掌握hbase的体系结构,集群安装,使用hbase shell访问hbase中的数据,使用hbase Java访问hbase,使用mapreduce把数据从HDFS中导入到hbase中,掌握过滤器等工具。
  • HBase JDBC连接

    万次阅读 2018-10-17 09:26:02
    JDBC连接HBase 1.pom.xml中的依赖 <dependencies> <dependency> <groupId>junit</groupId> <artifactId>junit</artifactId> <version>3.8.1</version...
  • python3 使用 thrift 操作hbase 安装hbase-thirft后有一个Hbase报错 使用这个修改完成的Hbase类替换掉原来的Hbase类问题全部解决 主要是因为python版本兼容性带来的问题
  • HBase:Sqoop整合HBase

    千次阅读 2019-12-20 08:40:53
    Sqoop整合HBase sqoop是一个数据导入导出的工具,可以将关系型数据库当中的数据导入到大数据平台来,也可以将大数据平台当中的数据导入到关系型数据库当中去 我们也可以通过sqoop导入数据到hbase或者从hbase当中导出...
  • hbase-0.94.14

    2018-07-06 20:56:12
    hbase-0.94.14hbase-0.94.14hbase-0.94.14hbase-0.94.14hbase-0.94.14hbase-0.94.14hbase-0.94.14hbase-0.94.14hbase-0.94.14hbase-0.94.14hbase-0.94.14hbase-0.94.14hbase-0.94.14hbase-0.94.14hbase-0.94.14hbase...
  • 大数据技术之_11_HBase学习_01_HBase 简介+HBase 安装+HBase Shell 操作+HBase 数据结构+HBase 原理
  • HBase学习(一) HBase搭建

    千次阅读 2021-03-09 15:24:59
    目录准备工作解压并配置HBase启动HBase可能出现的问题 准备工作 创建集群 Hadoop集群搭建 zookeeper搭建 Hbase下载 将下载好的hbase安装包上传至虚拟机中 解压并配置HBaseHBase解压到指定的目录下,我的目录是在...
  • HBaseHBase的eclipse开发环境搭建

    千次阅读 2016-02-25 19:56:44
    hbase

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 212,054
精华内容 84,821
关键字:

hbase