Hbase概述_hbase 详细介绍

一、Hbase简介

hbase是Apache 组织开源的顶级项目 distributed, scalable(可伸缩), big data store （大数据存储）产品
hbase是基于Hadoop的一个NoSQL产品  Column类型的NoSQL
hbase是Google BigTable的开源实现, 爬虫爬取的网页
hbase运行亿级数据查询时，效率可达到秒级，毫秒级 在线处理 实时的处理

NoSQL特点
	1. 部分NoSQL In-Memory 内存型 （Redis)
	2. Schema-Less NoSchema 弱格式 无格式
	3. 杜绝表连接
	4. 弱化事务，没有事务 （Redis有事务，MongoDB(4.0x 没事务 4.0x后有事务了)
	5. 搭建集群方便 
NoSQL分类
	1. key value 类型 redis
	2. document  类型 mongodb
	3. column    类型 HBase Cassandra
	4. 图         类型 neo4j (金融 知识图谱) 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

二、存储形式

安装

1. linux服务器 ip 主机名 主机映射 防火墙 selinux ssh免密 jdk
2. hadoop安装
   2.1 解压缩
   2.2 6个配置文件
   2.3 格式化
   2.4 启动进程
3. 安装zookeeper
   3.1 解压缩
   3.2 配置conf/zoo.cfg 
   3.3 创建临时目录 data ---> myid文件（集群）
   3.4 启动服务
4. hbase的安装
   4.1 解压缩hbase
   4.2 hdfs上创建 /hbase文件夹
                 hbase_home/data/tmp文件夹
   4.3 修改hbase相关的配置文件 
       env.sh
       export HBASE_MANAGES_ZK=false
       export JAVA_HOME=/usr/java/jdk1.7.0_71
       hbase-site.xml 
       <property >
	   <name>hbase.tmp.dir</name>
	   <value>/opt/install/hbase-0.98.6-hadoop2/data/tmp</value>
       </property>
       <property >
            <name>hbase.rootdir</name>
            <value>hdfs://CentOS8:8020/hbase</value>
        </property>
        <property >
            <name>hbase.cluster.distributed</name>
            <value>true</value>
        </property>
        <property>
            <name>hbase.zookeeper.quorum</name>
            <value>CentOS8</value>
        </property>
   4.4 修改
       regionservers文件
       hadoop31.baizhiedu.com
   4.5 替换hbase相关hadoop的jar
   4.6 启动hbase
       bin/hbase-daemon.sh start master
       bin/hbase-daemon.sh start regionserver
   4.7 网络访问
       http://CentOS8:60010
       bin/hbase shell
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46

Hbase 存储一个数
 	 rowkey   CloumnFamily(列簇):Quelify(限定符)  值   时间戳
 	 1 			base:name zhangsan      223232323
 	 				base:age     30				202020323
 	 				base:salary  3000            293298120   
1
2
3
4
5

三、Hbase的shell命令

1、建数据库相关

1. help 帮助命令
   help '命令名字'
2. hbase中数据库的概念
   namespace 
		2.1 显示所有的数据库        list_namespace  默认:default   hbase
		2.2 显示当前数据库中所有的表 list_namespace_tables 'hbase'
		2.3 创建一个数据库          create_namespace 'testNS'
		2.4 描述数据库                 describe_namespace 'testNS'
		2.5 删除数据库                 drop_namespace 'testNS'
		2.6 修改数据库                 alter_namespace
1
2
3
4
5
6
7
8
9
10

2、建Hbase表

2.1 基本的建表方式 【默认default库中】
   create 't1','cf1'   ---表名，列簇名   (不指定NS 默认的 nameSpace库)
2.2 创建多个列簇【默认default库中】
   create 't1','cf1','cf2'  --表名，列簇名1，列簇名2
2.3 指定表所属的数据库
   create 'NS:t1','cf1' --库名：表名，列簇名1
2.4 详细描述列簇的相关属性
   create 'NS:t2',{NAME=>'cf1',VERSIONS=>2,COMPRESSION=>'SNAPPY'},{NAME=>'cf2'}  
   版本数（同一rowkey同一列簇只存两个版本）
2.5 描述表 
   describe 'ns10:t1'
   describe_namespace 'NS:t2'  获取列簇详细属性
2..6 修改表属性
 alter 'ns1:t2',{NAME=>'cf2',VERSIONS=>2}
 
2..7 删除表
   disable 'ns1:t2' （先失效在删除）
   drop 'ns1:t2'
2..8 失效 生效表相关命令
   enable disable 
   enable_all disable_all
   is_enable is_disable
2..9  判断表是否存在
   exists ‘NS：t1’
2..10 表的查找命令
   list 'ns:t.*'
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

3、新增删除查询数据

3.1 插入数据
   put 't1'，’rowkey‘,'family:qualify','value'
   put 'ns:t1'，’rowkey‘,'family:qualify','value'
3.2 删除数据
   delete 'ns:t1' ,'rowkey','family:qualify','timestamp'
3.3 全表扫描 
    scan '表名'
    scan 'ns1:tb1', {STARTROW => '20170521_10001',STOPROW => '20170521_10003'}
    scan 'ns1:user',{STARTROW=>'001',STOPROW=>'004'}
    不包括stoprow的值
3.4 某条数据的查询
    get 'ns1:user','001'
    get 'ns1:user','001','base:name'
1
2
3
4
5
6
7
8
9
10
11
12
13

四、HBase的Java API

1、引入与Hbase版本对应的依赖

<!-- https://mvnrepository.com/artifact/org.apache.hbase/hbase-client -->
<dependency>
    <groupId>org.apache.hbase</groupId>
    <artifactId>hbase-client</artifactId>
    <version>0.98.6-hadoop2</version>
</dependency>

<!-- https://mvnrepository.com/artifact/org.apache.hbase/hbase-server -->
<dependency>
    <groupId>org.apache.hbase</groupId>
    <artifactId>hbase-server</artifactId>
    <version>0.98.6-hadoop2</version>
</dependency>

1
2
3
4
5
6
7
8
9
10
11
12
13
14

2、java访问HBase的核心API

Configruation  HBase相关的配置 
	Htable         HBase中的表
		Put            插入数据 
		Get            查询数据
		Scan           扫描数据
	   BytesUtil      字节处理
1
2
3
4
5
6

3、获取Htable

   //封装 获取表的对象
    public HTable getHTable(String tableName) throws Exception {
        Configuration configuration = HBaseConfiguration.create();    
 		configuration.set("hbase.zookeeper.quorum","172.28.0.2,172.28.0.3，~~";
        HTable hTable = new HTable(configuration, Bytes.toBytes(tableName));
        return hTable;
    }
1
2
3
4
5
6
7

4、add

	Put put = new Put(Bytes.toBytes("00001111"));//--rowkry-列簇--限定符--值
    put.add(Bytes.toBytes("base"), Bytes.toBytes("name"), Bytes.toBytes("xiaohei"));
	        
    hTable.put(put);
1
2
3
4

5、delete

	 Delete delete = new Delete(Bytes.toBytes("00001111"));
	 hTable.delete(delete);
1
2

6、Get、Scan

（1）根据rowkey查询（标准rowkey）
        Get get = new Get(Bytes.toBytes("11990aaauser1"));
        Result result = hTable.get(get);
       
       //结果的处理
        Cell[] cells = result.rawCells();
 for (Cell cell : cells) {
            System.out.println(
                    Bytes.toString(result.getRow()) + "： " + Bytes.toString(CellUtil.cloneFamily(cell)) +
                            " ：" + Bytes.toString(CellUtil.cloneQualifier(cell)) +
                            " ： " + Bytes.toString(CellUtil.cloneValue(cell))+" ： "+cell.getTimestamp());
        }
        hTable.close();

（2）、Scan All（全表扫描）
        Scan scan = new Scan();
       
        //scan.setStartRow(Bytes.toBytes("suns1111"));
        //scan.setStopRow(Bytes.toBytes("suns1113"));

        ResultScanner scanner = hTable.getScanner(scan);
		 for (Result result : scanner) {
		    //结果的处理
		        Cell[] cells = result.rawCells();
		 for (Cell cell : cells) {
		            System.out.println(
		                    Bytes.toString(result.getRow()) + "： " + Bytes.toString(CellUtil.cloneFamily(cell)) +
		                            " ：" + Bytes.toString(CellUtil.cloneQualifier(cell)) +
		                            " ： " + Bytes.toString(CellUtil.cloneValue(cell))+" ： "+cell.getTimestamp());
		        }
		 }
         hTable.close();
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

7、filter过滤器

7.1、行键相关的过滤器

1.比较行键值的大小
	Filter filter1 = new RowFilter(CompareFilter.CompareOp.GREATER, new BinaryComparator(Bytes.toBytes("0003")));
	scan.setFilter(filter1);
	
2. 比较行键按照特定的规则设计
	Filter filter1 = new PrefixFilter(Bytes.toBytes("000"));
	scan.setFilter(filter1);
1
2
3
4
5
6
7

7.2、列簇筛选

 Filter filter1 = new FamilyFilter(CompareFilter.CompareOp.EQUAL, new BinaryComparator(Bytes.toBytes("base")));
 scan.setFilter(filter1);
1
2

7.3、限定符筛选

 Filter filter1 = new QualifierFilter(CompareFilter.CompareOp.EQUAL, new BinaryComparator(Bytes.toBytes("pwd")));
scan.setFilter(filter1);
1
2

7.4、值筛选（包含）

 Filter filter1 = new ValueFilter(CompareFilter.CompareOp.EQUAL, new SubstringComparator("sd"));
        scan.setFilter(filter1);
  单值过滤器：
1
2
3

7.5、列簇中的数据进行筛选

SingleColumnValueFilter filter = new SingleColumnValueFilter(
                Bytes.toBytes("base"),
                Bytes.toBytes("sex"),
                CompareFilter.CompareOp.EQUAL,
                new SubstringComparator("male"));
          filter.setFilterIfMissing(true);
        //filter.setFilterIfMissing(false); //符合要求的数据 password=123456
                                          //column 中不包含password限定符 查询出来
        scan.setFilter(filter);
        

同时要排除password 限定符        
SingleColumnValueExcludeFilter filter = new SingleColumnValueExcludeFilter(
                Bytes.toBytes("base"),
                Bytes.toBytes("password"),
                CompareFilter.CompareOp.NOT_EQUAL,
                new SubstringComparator("66666"));
  filter.setFilterIfMissing(true);
        //filter.setFilterIfMissing(false); //符合要求的数据 password=123456
        //column 中不包含password限定符 查询出来
        scan.setFilter(filter);
        
  ResultScanner scanner = hTable.getScanner(scan);
  
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

7.6 、FilterList

设置多个过滤器 同时生效
 FilterList filterList = new FilterList();

 Filter filter1 = new PrefixFilter(Bytes.toBytes("000"));

  SingleColumnValueFilter filter2 = new SingleColumnValueFilter(
                Bytes.toBytes("base"),
                Bytes.toBytes("password"),
                CompareFilter.CompareOp.EQUAL,
                new SubstringComparator("123456"));
  filter2.setFilterIfMissing(true);

  filterList.addFilter(filter1);
  filterList.addFilter(filter2);

  scan.setFilter(filterList);
  
  ResultScanner scanner = hTable.getScanner(scan);
  
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

五、HBase的架构

1、列簇的相关属性

   create 'table_name',{NAME=>'',VERSIONS=>''}
		  # 列簇的名字
			   NAME='xxxxx'
		   
		   # 列簇对应限定符 能存几个版本的数据
			   VERSIONS => '1'
		   
		   # TTL Time To Live  
			   指定的是cell中的数据，存储在HBase中的存活时间 'FOREVER'
			   TTL => 100  (设置失效性100秒)
		   
		   # 指定HBase上存储的数据 是否 启动压缩
			   COMPRESSION => 'NONE'（默认）
			   COMPRESSION => 'snappy'（压缩算法）
		   
		   # 列簇中的数据，存储在内存中，提高查询效率 （默认关闭）
			   IN_MEMORY => 'false’ 
		   
		   # 缓存 列簇部分数据，从而提高查询效率
			  	 BLOCKCACHE => 'true' （热点数据存缓存）
		   
		   # Block是列簇中存储数据的最小单位
			   BLOCKSIZE => '65536' （64Kb）
			   调整大   顺序查询  需求高
			   调整小   随机查询  需求高
		    
		   # 提高查询效率
			   	BLOOMFILTER 布隆过滤（判断有没有索引）

			列簇对应存的是文件Hfile---->文件被打散成快（快索引）
			
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

2、HBase的体系结构

   一张t_user表存在一个reglon中
   reglon通过store来存对应的列簇（多少个列簇就有多少个store）
   		store包含 MemStore、StoreFile
		写数据先往MemStore中写，达到阀值进行Flush---->StoreFile中写（StoreFile对应文件类型为Hfile类型  映射Hdfs文件）
		
应该是每一个 RegionServer 就只有一个 HLog，而不是一个 Region 有一个 HLog。
Hlog（数据先写入预写日志，在MemStore中写，防止数据丢失）

1
2
3
4
5
6
7
8

3、reglon的裂变compact 和 split

一个表足够大，一个reglon列表成多个reglon（放在多个reglon
Server中进行存储）

1
2
3

4、各组件的作用

4.1、ZooKeeper

	1、zooKeeper 选举 Master，避免单点 Master 单点故障问题。
	2、实时监控 RegionServer 的状态，将 RegionServer 的上线和下线信息实时通知给 Master
    3、存Hbase的元数据信息（存储 HBase 的 Schema，包括有哪些 Table，每个 Table 有哪些 Column Family）
 
	存储所有 Region 的寻址入口：-ROOT-表在哪台服务器上。
	-ROOT-这张表的位置信息
1
2
3
4
5
6

4.2、HMaster

1、管理用户对Table表的CRUD
2、管理redion
	Region分裂后，分配 Region到RegionServer ，保证 RegionServer 的负载均衡
	RegionServer 宕机后，并重新分配其上的 Region
1
2
3
4

4.3、RegionServer

管理 Region，响应用户对这些 Region 的 IO 请求
Split 过大的 Region，负责 Compact 操作

	可以看到，client 访问 HBase 上数据的过程并不需要 master 参与，寻址访问 zookeeper ，数据读写访问 RegioneServer，
	Master 仅仅维护者 Table 和 Region 的元数据信息，负载很低。
	
	.META. 存的是所有的 Region 的位置信息，那么 RegioneServer 当中 Region 在进行分裂之后 的新产生的 Region，是由 Master 来决定发到哪个 RegioneServer，这就意味着，
	只有 Master 知道 new Region 的位置信息，所以，由 Master 来管理.META.这个表当中的数据的 CRUD。
	
	所以结合以上两点表明，在没有 Region 分裂的情况，Master 宕机一段时间是可以忍受的
	
1
2
3
4
5
6
7
8
9
10
11

4.4、HRegion

table在行的方向上分隔为多个Region。Region是HBase中分布式存储和负载均衡的最小单元，即不同的region可以分别在不同的Region Server上，但同一个Region是不会拆分到多个server上。

Region按大小分隔，每个表一般是只有一个region。随着数据不断插入表，region不断增大，当region的某个列族达到一个阈值时就会分成两个新的region。

每个region由以下信息标识：< 表名,startRowkey,创建时间>
由目录表(-ROOT-和.META.)记录该region的endRowkey
1
2
3
4
5
6

4.5、Store

每一个region由一个或多个store组成，至少是一个store，hbase会把一起访问的数据放在一个store里面，即为每个 ColumnFamily建一个store，如果有几个ColumnFamily，也就有几个Store。一个Store由一个memStore和0或者 多个StoreFile组成。 HBase以store的大小来判断是否需要切分region

1
2

4.6、MemStore

memStore 是放在内存里的。保存修改的数据即keyValues。当memStore的大小达到一个阀值（默认128MB）时，memStore会被flush到文 件，即生成一个快照。目前hbase 会有一个线程来负责memStore的flush操作

1
2

4.7、StoreFile

memStore内存中的数据写到文件后就是StoreFile，StoreFile底层是以HFile的格式保存。当storefile文件的数量增长到一定阈值后，系统会进行合并（minor、major compaction），在合并过程中会进行版本合并和删除工作（majar），形成更大的storefile。
1

4.8、HFile

hBase中KeyValue数据的存储格式，HFile是Hadoop的 二进制格式文件，实际上StoreFile就是对Hfile做了轻量级包装，即StoreFile底层就是HFile。
StoreFile 以 HFile 格式保存在 HDFS 上

1
2
3

4.9、HLog

HLog(WAL log)：WAL意为write ahead log，用来做灾难恢复使用，HLog记录数据的所有变更，一旦region server 宕机，就可以从log中进行恢复。
HLog文件就是一个普通的Hadoop Sequence File， Sequence File的value是key时HLogKey对象，其中记录了写入数据的归属信息，除了table和region名字外，还同时包括sequence number和timestamp，timestamp是写入时间，sequence number的起始值
1
2

4.10、Client

HBase 有两张特殊表：
	.META.：记录了用户所有表拆分出来的的 Region 映射信息，.META.可以有多个 Regoin
	-ROOT-：记录了.META.表的 Region 信息，-ROOT-只有一个 Region，无论如何不会分裂
Client 访问用户数据前需要首先访问 ZooKeeper，找到-ROOT-表的 Region 所在的位置，然 后访问-ROOT-表，接着访问.META.表，最后才能找到用户数据的位置去访问，中间需要多次网络操作，不过 client 端会做 cache 缓存。

1
2
3
4
5

六、RowKey设计

1. HBase相关的查询操作，95%上都是对RowKey查询。
2. 设计过程 
   2.1 复合
   2.2 查询内容作为rowkey组成
3. rowkey 64K 10--100字节唯一
4. rowkey结合自己的实际需求
   4.1  区域查询多，建议 rowkey 连续    
   4.4  区域查询少，散列 hash ---> 加密、UUID

1
2
3
4
5
6
7
8
9

七、HBase优化策略

1、解决热点效应

1. 预分区（依据 ：基于Rowkey进行预分区）
   在创建表时，不按照默认的策略，为表只创建一个Region,而是根据需要，为一张表创建多个Region,从而避免热点效应
create ‘ns:t1’,'f1','split=>['10','20','30','40']'  (分了5个分区及region，默认1个) 散列到regionServer中，保证负载均衡。XX-10,10-20,20-30,30-40，40--XX

2. 语法：
   2.1 create 't1', 'f1', SPLITS => ['10', '20', '30', '40']
   2.2 create 't1', 'f1', SPLITS_FILE => 'splits.txt'
       splits.txt
       10
       20
       30
       40
   2.3 create 't2', 'f1', {NUMREGIONS => 15, SPLITALGO => 'HexStringSplit'}  15个分区，hash散列分布
3. 根本上解决热点问题需要注意如下几点
   1. 预分区
   2. rowkey设置
   综上2者尽量解决热点问题。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

2、如何提高检索效率

1. rowkey 相对连续 那么检索效率一定高 （顺序查询 scan操作）
2. 设置Memstore大小 ， Block Cache大小 
   hbase-site.xml 设置 
   
   hbase.hregion.memstore.flush.size  128M  每一个memstore达到128M flush 
   hbase.regionserver.global.memstore.size 0.4 堆空间的40% （regionserver占用JVM 对空间）
   1. 让数据尽可能多的放置在内存中，提高检索效率
   2. 避免flush memstore 阻塞client操作
   hbase.regionserver.global.memstore.size.lower.limit 当全局flush到 memstore用量达95%不在flush
   
   hfile.block.cache.size 0.4
3. hbase内部的块数据索引，布隆过滤器
1
2
3
4
5
6
7
8
9
10
11
12

3、JVM相关的参数配置

1. JVM Java进程 
2. JVM (堆空间) HBase
   新生代 1/3                             老年代 2/3  永久代（静态，常量）
   eden survivor(from)  survivor(to)
    8      1                1
    年轻代 ParNewGC （并行快速做垃圾回收，stw少）
   老年代  ConcMarkSweepGC（标记性垃圾回收器 90%时做垃圾回收，串行）
   虚拟机默认最大占8g内存（-Xmx8g），最小占8g内存（-Xms8G），新生带128M，垃圾回收器新老，老70GC，最后为GC日志文件的保存路径。
   ”-Xmx8g -Xms8G -Xmn128m -XX:UseParNewGC  -XX:UseConcMarkSweepGC -   XX:CMSInitiatingOccupancyFraction=70  -verbose:gc -XX:+PrintGCDetails -XX:+PrintGCTimeStamps -Xloggc:$HBASE_HOME/logs/gc-${hostname}-hbase.log”

   hbase-env.sh
   export HBASE_REGIONSERVER_OPTS=”-Xmx8g -Xms8G  -Xmn128m -XX:UseParNewGC     -XX:UseConcMarkSweepGC -XX:CMSInitiatingOccupancyFraction=70  -verbose:gc -XX:+PrintGCDetails -XX:+PrintGCTimeStamps    -Xloggc:$HBASE_HOME/logs/gc-${hostname}-hbase.log”


1
2
3
4
5
6
7
8
9
10
11
12
13
14

4、mslab内存碎片

1. 防止内存碎片，内存碎片过多，内存泄露，发生FullGC,导致STW.
hbase.hregion.memstore.mslab.enabled  true
hbase.hregion.memstore.mslab.chunksize  2M -->  4,5M 6M 


1
2
3
4
5

5、自动化处理的功能变成手工处理

结合定时，shell脚本 完成处理 系统不忙的时候来处理这个操作
hbase tools 手工操作 compact split

test.sh
/opt/install/hbase-0.98.6-hadoop2/bin/hbase shell /root/hbase/test

1
2
3
4
5
6

6、HBase与MapReduce的集成

1. Hbase需要和MR集成做 HBase数据的迁移。
hadoop-env.sh 

//引入hbase中依赖
export HADOOP_CLASSPATH=$HADOOP_CLASSPATH:/opt/install/hbase-0.98.6-hadoop2/lib/*
1
2
3
4
5