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

    千次阅读 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等属性信息。
     通常直接存放在数据库表中。数据记录的每一个属性对应数据表的一个字段。
    非结构化数据
     无法用统一的结构来表示,如文本文件、图像、视频、声音、网页等信息。
     数据记录较小时(如KB级别),可考虑直接存放到数据库表中(整条记录映射到某一个列中),这样也有利于整条记录的快速检索。
     数据较大时,通常考虑直接存放在文件系统中。数据库可用来存放相关数据的索引信息。
    半结构化数据
     具有一定的结构,但又有一定的灵活可变性。典型如XML、HTML等数据。其实也是非结构化数据的一种。
     可以考虑直接转换成结构化数据进行存储。
     根据数据记录的大小和特点,选择合适的存储方式。这一点与非结构化数据的存储类似。

    行列存储:
    按行存储:
    : 数据按行存储在底层文件系统中。通常,每一行会被分配固定的空间。
     优点:有利于增加/修改整行记录等操作;有利于整行数据的读取操作;
     缺点:单列查询时,会读取一些不必要的数据。

    按列存储:
    数据以列为单位,存储在底层文件系统中。
     优点:有利于面向单列数据的读取/统计等操作。
     缺点:整行读取时,可能需要多次I/O操作。

    主键设置规则:

    这里写图片描述

    Secondary Index

     HBase是一个Key-Value类型的分布式存储数据库。每张表的数据,是按照RowKey的字典顺序排序的,因此,如果按照某个指定的RowKey去查询数据,或者指定某一个RowKey范围去扫描数据时,HBase可以快速定位到需要读取的数据位置,从而可以高效地获取到所需要的数据。
     在实际应用中,很多场景是查询某一个列值为XXX的数据。HBase提供了Filter特性去支持这样的查询,它的原理是:按照RowKey的顺序,去遍历所有可能的数据,再依次去匹配那一列的值,直到获取到所需要的数据。可以看出,可能仅仅为了获取一行数据,它却扫描了很多不必要的数据。因此,如果对于这样的查询请求非常频繁并且对查询性能要求较高,使用Filter无法满足这个需求。
    这就是HBase二级索引产生的背景。二级索引为HBase提供了按照某些列的值进行索引的能力。
    这里写图片描述
    一般HBase的查询都是通过RowKey(要把多条件组合查询的字段都拼接在RowKey中显然不太可能),或者全表扫描再结合过滤器筛选出目标数据(太低效),所以通过设计HBase的二级索引来解决这个问题。
    对于HBase而言,如果想精确地定位到某行记录,唯一的办法是通过rowkey来查询。如果不通过rowkey来查找数据,就必须逐行地比较每一列的值,即全表扫瞄。对于较大的表,全表扫瞄的代价是不可接受的。
    但是,很多情况下,需要从多个角度查询数据。例如,在定位某个人的时候,可以通过姓名、身份证号、学籍号等不同的角度来查询,要想把这么多角度的数据都放到rowkey中几乎不可能(业务的灵活性不允许,对rowkey长度的要求也不允许)。
    所以,需要secondary index来完成这件事。secondary index的原理很简单,但是如果自己维护的话则会麻烦一些。现在,Phoenix已经提供了对HBase secondary index的支持,下面将说明这样用Phoenix来在HBase中创建二级索引。
    create index my_index on example (m.c0);

    ###HBase FileStream
    HBase文件存储模块(HBase FileStream,简称HFS)是HBase的独立模块,它作为对HBase与HDFS接口的封装,应用在FusionInsight HD的上层应用,为上层应用提供文件的存储、读取、删除等功能。
    在Hadoop生态系统中,无论是HDFS,还是HBase,均在面对海量文件的存储的时候,在某些场景下,都会存在一些很难解决的问题:
     如果把海量小文件直接保存在HDFS中,会给NameNode带来极大的压力。
     由于HBase接口以及内部机制的原因,一些较大的文件也不适合直接保存到HBase中。
    HFS的出现,就是为了解决需要在Hadoop中存储海量小文件,同时也要存储一些大文件的混合的
    场景。简单来说,就是在HBase表中,需要存放大量的小文件(10MB以下),同时又需要存放一
    些比较大的文件(10MB以上)。
    HFS为以上场景提供了统一的操作接口,这些操作接口与HBase的函数接口类似。
    注意事项
     如果只有小文件,确定不会有大文件的场景下,建议使用HBase的原始接口进行操作。
     HFS接口需要同时对HBase和HDFS进行操作,所以客户端用户需要同时拥有这两个组件的操作权限。
     直接存放在HDFS中的大文件,HFS在存储时会加入一些元数据信息,所以存储的文件不是直接等于原文件的。不能直接从HDFS中移动出来使用,而需要用HFS的接口进行读取。
     使用HFS接口存储在HDFS中的数据,暂不支持备份与容灾。
    这里写图片描述

    HBASE+Solr全文检索

    背景
    某电信项目中采用HBase来存储用户终端明细数据,供前台页面即时查询。HBase无可置疑拥有其优势,但其本身只对rowkey支持毫秒级的快速检索,对于多字段的组合查询却无能为力。针对HBase的多条件查询也有多种方案,但是这些方案要么太复杂,要么效率太低,本文只对基于Solr的HBase多条件查询方案进行测试和验证。
    原理
    基于Solr的HBase多条件查询原理很简单,将HBase表中涉及条件过滤的字段和rowkey在Solr中建立索引,通过Solr的多条件查询快速获得符合过滤条件的rowkey值,拿到这些rowkey之后在HBASE中通过指定rowkey进行查询。
    这里写图片描述
    HBase与Solr系统架构设计
    使用HBase搭建结构数据存储云,用来存储海量数据;使用SolrCloud集群用来搭建搜索引擎,将要查找的结构化数据的ID查找出来,只配置它存储ID。
    这里写图片描述
    wd代表用户write data写数据,从用户提交写数据请求wd1开始,经历wd2,写入MySQL数据库,或写入结构数据存储云中,wd3,提交到Solr集群中,从而依据业务需求创建索引。
    rd代表用户read data读数据,从用户提交读数据请求rd1开始,经历rd2,直接读取MySQL中数据,或向Solr集群请求搜索服务,rd3,向Solr集群请求得到的搜索结果为ID,再向结构数据存储云中通过ID取出数据,最后返回给用户结果。

    实现方法有两种
    手工编码,直接用HBASE的API,可以参考下文
    http://www.cnblogs.com/chenz/articles/3229997.html
    可以使用HBASE/Solr的LUNA接口,就不用自己管理两者。
    这里写图片描述

    二、部署

    当我们按照hadoop完全分布式集群搭建博客搭建了hadoop以后,发现这是一个空的hadoop,只有YARN,MapReduce,HDFS,而这些实际上我们一般不会直接使用,而是需要另外部署Hadoop的其他组件,来辅助使用。比如我们需要数据库,那么hadoop提供了分布式非关系型数据库hbase,用来存储半结构化,非结构化的一些数据,供我们查询使用等,下面我们来介绍一下,如何实现在完全分布式hadoop集群之上安装hbase。

    操作步骤

    1. 下载hbase1.2.6压缩包

    hbase1.2.6下载地址
    下载后上传到管理节点的opt目录下

    2. 解压缩hbase和修改目录名

     # cd /opt
     # tar -xzvf hbase-1.2.6-bin.tar.gz
     # mv hbase-1.2.6 hbase1.2.6
     # chmod 777 -R /opt/hbase1.2.6
    

    3. 配置环境变量

     # vim /etc/profile
    
    export JAVA_HOME=/opt/jdk1.8
    export CLASSPATH=.:$JAVA_HOME/lib/dt.jar:$JAVA_HOME/lib/tools.jar
    export PATH=$PATH:$JAVA_HOME/bin
    
    export HADOOP_HOME=/opt/hadoop2.6.0
    export PATH=$HADOOP_HOME/bin:$HADOOP_HOME/sbin:$PATH
    
    export HIVE_HOME=/opt/hive2.1.1
    export HIVE_CONF_DIR=$HIVE_HOME/conf
    export CLASSPATH=.:$HIVE_HOME/lib:$CLASSPATH
    export PATH=$PATH:$HIVE_HOME/bin
    
    export SQOOP_HOME=/opt/sqoop1.4.6
    export PATH=$PATH:$SQOOP_HOME/bin
    
    export ZOOKEEPER_HOME=/opt/zookeeper3.4.10
    export PATH=$PATH:$ZOOKEEPER_HOME/bin
    
    export HBASE_HOME=/opt/hbase1.2.6
    export PATH=$PATH:$HBASE_HOME/bin           #添加最后两行,hbase的相关环境变量属性
    
     # source /etc/profile              #使环境变量配置生效
    

    4. 修改hbase-env.sh配置文件

     # vim /opt/hbase1.2.6/conf/hbase-env.sh
    
    export JAVA_HOME=/opt/jdk1.8  
    export HADOOP_HOME=/opt/hadoop2.6.0 
    export HBASE_HOME=/opt/hbase1.2.6 
    export HBASE_CLASSPATH=/opt/hadoop2.6.0/etc/hadoop  
    export HBASE_PID_DIR=/opt/hbase1.2.6/pids  
    export HBASE_MANAGES_ZK=false
    

    这里写图片描述

    5. 修改hbase-site.xml配置文件

    # 创建目录
     # mkdir  /opt/hbase1.2.6/tmp  
     # mkdir  /opt/hbase1.2.6/pids 
    
     # cd /opt/hbase1.2.6/conf/
     # vim hbase-site.xml
    
    <configuration>
      <property>
        <name>hbase.rootdir</name>
        <value>hdfs://hadoop0:9000/hbase</value>
        <description>The directory shared byregion servers.</description>
      </property>
      <property>
        <name>hbase.zookeeper.property.clientPort</name>
        <value>2181</value>
        <description>Property from ZooKeeper'sconfig zoo.cfg. The port at which the clients will connect.
        </description>
      </property>
      <property>
        <name>zookeeper.session.timeout</name>
        <value>120000</value>
      </property>
      <property>
        <name>hbase.zookeeper.quorum</name>
        <value>hadoop0,hadoop1,hadoop2</value>   
      </property>
      <property>
        <name>hbase.tmp.dir</name>
        <value>/opt/hbase1.2.6/tmp</value>
      </property>
      <property>
        <name>hbase.cluster.distributed</name>
       <value>true</value>
      </property>
    </configuration>
    

    6. 修改regionservers配置文件

     # cd /opt/hbase1.2.6/conf
     # vim regionservers        # 添加集群的三个主机名
     
    hadoop0
    hadoop1
    hadoop2
    

    7. 拷贝管理节点的hbase到其他两个节点

     # cd /opt/ 
     # scp -r hbase1.2.6 root@hadoop1:/opt/ 
     # scp -r hbase1.2.6 root@hadoop2:/opt/  
    
    # 修改环境变量添加【在其他两个节点】
    
    export HBASE_HOME=/opt/hbase1.2.6
    export PATH=$PATH:$HBASE_HOME/bin
    

    8. 启动和测试

    启动

    首先先确保,hadoop和zookeeper正常运行,然后只需要在管理节点启动Hbase即可。

     # cd /opt//hbase1.2.6/bin     
     # ./start-hbase.sh
    

    这里写图片描述

    浏览器访问:http://192.168.210.70:16010/master-status

    这里写图片描述

    测试

    在主节点命令行,输入hbase shell,启动hbase后台

    这里写图片描述

    三、注意

    在Hbase搭建完之后,本想开开心心的启动Hbase,进行测试使用hbase,但是发现启动hbase的时候,报各种各样的错误,java_home,hbase,hadoop等找不到文件或目录,no such file or directory!

    [root@hadoop0 bin]# start-hbase.sh 
    /opt/hbase1.2.6/conf/hbase-env.sh: line 50: export JAVA_HOME=/opt/jdk1.8: No such file or directory
    /opt/hbase1.2.6/conf/hbase-env.sh: line 52: export HBASE_HOME=/opt/hbase1.2.6: No such file or directory
    /opt/hbase1.2.6/conf/hbase-env.sh: line 53: export HBASE_CLASSPATH=/opt/hadoop2.6.0/etc/hadoop: No such file or directory
    /opt/hbase1.2.6/conf/hbase-env.sh: line 54: export HBASE_PID_DIR=/opt/hbase1.2.6/pids: No such file or directory
    starting master, logging to /opt/hbase1.2.6/logs/hbase-root-master-hadoop0.out
    Java HotSpot(TM) 64-Bit Server VM warning: ignoring option PermSize=128m; support was removed in 8.0
    Java HotSpot(TM) 64-Bit Server VM warning: ignoring option MaxPermSize=128m; support was removed in 8.0
    Java HotSpot(TM) 64-Bit Server VM warning: ignoring option PermSize=128m; support was removed in 8.0
    Java HotSpot(TM) 64-Bit Server VM warning: ignoring option MaxPermSize=128m; support was removed in 8.0
    Java HotSpot(TM) 64-Bit Server VM warning: ignoring option PermSize=128m; support was removed in 8.0
    Java HotSpot(TM) 64-Bit Server VM warning: ignoring option MaxPermSize=128m; support was removed in 8.0
    Java HotSpot(TM) 64-Bit Server VM warning: ignoring option PermSize=128m; support was removed in 8.0
    Java HotSpot(TM) 64-Bit Server VM warning: ignoring option MaxPermSize=128m; support was removed in 8.0
    Java HotSpot(TM) 64-Bit Server VM warning: ignoring option PermSize=128m; support was removed in 8.0
    Java HotSpot(TM) 64-Bit Server VM warning: ignoring option MaxPermSize=128m; support was removed in 8.0
    hadoop0: /opt/hbase1.2.6/conf/hbase-env.sh: line 50: export JAVA_HOME=/opt/jdk1.8: No such file or directory
    hadoop0: /opt/hbase1.2.6/conf/hbase-env.sh: line 52: export HBASE_HOME=/opt/hbase1.2.6: No such file or directory
    hadoop0: /opt/hbase1.2.6/conf/hbase-env.sh: line 53: export HBASE_CLASSPATH=/opt/hadoop2.6.0/etc/hadoop: No such file or directory
    hadoop0: /opt/hbase1.2.6/conf/hbase-env.sh: line 54: export HBASE_PID_DIR=/opt/hbase1.2.6/pids: No such file or directory
    hadoop0: +======================================================================+
    hadoop0: |                    Error: JAVA_HOME is not set                       |
    hadoop0: +----------------------------------------------------------------------+
    hadoop0: | Please download the latest Sun JDK from the Sun Java web site        |
    hadoop0: |     > http://www.oracle.com/technetwork/java/javase/downloads        |
    hadoop0: |                                                                      |
    hadoop0: | HBase requires Java 1.7 or later.                                    |
    hadoop0: +======================================================================+
    hadoop2: /opt/hbase1.2.6/conf/hbase-env.sh: line 50: export JAVA_HOME=/opt/jdk1.8: No such file or directory
    hadoop2: /opt/hbase1.2.6/conf/hbase-env.sh: line 51: export HADOOP_HOME=/opt/hadoop2.6.0: No such file or directory
    hadoop2: /opt/hbase1.2.6/conf/hbase-env.sh: line 52: export HBASE_HOME=/opt/hbase1.2.6: No such file or directory
    hadoop2: /opt/hbase1.2.6/conf/hbase-env.sh: line 53: export HBASE_CLASSPATH=/opt/hadoop2.6.0/etc/hadoop: No such file or directory
    hadoop1: /opt/hbase1.2.6/conf/hbase-env.sh: line 50: export JAVA_HOME=/opt/jdk1.8: No such file or directory
    hadoop1: /opt/hbase1.2.6/conf/hbase-env.sh: line 51: export HADOOP_HOME=/opt/hadoop2.6.0: No such file or directory
    hadoop2: /opt/hbase1.2.6/conf/hbase-env.sh: line 54: export HBASE_PID_DIR=/opt/hbase1.2.6/pids: No such file or directory
    hadoop1: /opt/hbase1.2.6/conf/hbase-env.sh: line 52: export HBASE_HOME=/opt/hbase1.2.6: No such file or directory
    hadoop1: /opt/hbase1.2.6/conf/hbase-env.sh: line 53: export HBASE_CLASSPATH=/opt/hadoop2.6.0/etc/hadoop: No such file or directory
    hadoop2: /opt/hbase1.2.6/conf/hbase-env.sh: line 55: $'export\302\240HBASE_MANAGES_ZK=false': command not found
    hadoop1: /opt/hbase1.2.6/conf/hbase-env.sh: line 54: export HBASE_PID_DIR=/opt/hbase1.2.6/pids: No such file or directory
    hadoop1: /opt/hbase1.2.6/conf/hbase-env.sh: line 55: $'export\302\240HBASE_MANAGES_ZK=false': command not found
    hadoop2: +======================================================================+
    hadoop2: |                    Error: JAVA_HOME is not set                       |
    hadoop2: +----------------------------------------------------------------------+
    hadoop2: | Please download the latest Sun JDK from the Sun Java web site        |
    hadoop2: |     > http://www.oracle.com/technetwork/java/javase/downloads        |
    hadoop2: |                                                                      |
    hadoop2: | HBase requires Java 1.7 or later.                                    |
    hadoop2: +======================================================================+
    hadoop1: +======================================================================+
    hadoop1: |                    Error: JAVA_HOME is not set                       |
    hadoop1: +----------------------------------------------------------------------+
    hadoop1: | Please download the latest Sun JDK from the Sun Java web site        |
    hadoop1: |     > http://www.oracle.com/technetwork/java/javase/downloads        |
    hadoop1: |                                                                      |
    hadoop1: | HBase requires Java 1.7 or later.                                    |
    hadoop1: +======================================================================+
    

    解决方案

    # 查看hbase-env.sh文件
    
     # cd /opt/hbase1.2.6/conf
     # vim hbase-env.sh
    
    export HBASE_MANAGES_ZK=false
    export JAVA_HOME="/opt/jdk1.8"
    export HADOOP_HOME="/opt/hadoop2.6.0"
    export HBASE_HOME="/opt/hbase1.2.6"
    export HBASE_CLASSPATH="/opt/hadoop2.6.0/etc/hadoop"
    export HBASE_PID_DIR="/opt/hbase1.2.6/pids"
    
    # 上面这一块配置,全部重新手写,不要从网上复制过来直接黏贴,其中可能有中文字符,导致找不到环境变量
    

    修改后直接在主节点启动Hbase

     # start-hbase.sh    
    

    注:只需要在主节点上启动,从节点会自动全部开启hbase服务

    这里写图片描述

    这里写图片描述

    这里写图片描述

    四、自动关闭

    HBase启动后HMaster进程启动几秒后自动关闭
    产生错误的原因:zookeeper 链接信息过期了

    解决办法:进入zookeeper 删除hbase (rmr /hbase )重启zookeeper即可

    具体步骤:

    • 1、停止hbase(./stop-hbase.sh)
    • 2、hbase zkcli
    • 3、 ls / #扫描zookeeper中的数据
    • 4、 rmr / hbase #删除zookeeper中的hbase数据
    • 5、重新启动hbase即可

    五、python连hbase

    开启thrift:

    hbase thrift -p 9090 start
    ./hbase-daemons.sh start thrift

    代码测试

    from thrift.transport import TSocket,TTransport
    from thrift.protocol import TBinaryProtocol
    from hbase import Hbase
    
    # thrift默认端口是9090
    socket = TSocket.TSocket('192.168.186.48',9090)
    socket.setTimeout(5000)
    print("连接成功!")
    
    transport = TTransport.TBufferedTransport(socket)
    protocol = TBinaryProtocol.TBinaryProtocol(transport)
    
    client = Hbase.Client(protocol)
    socket.open()
    print(client.getTableNames())
    print(client.get('xmstest','xms','f1:name'))
    
    socket.close()
    
    展开全文
  • HBase

    千次阅读 2019-12-28 20:30:58
    Hbase全称为Hadoop Database(基于HDFS的数据库),设计来源Google 的bigtable,Hbase 仿照 bigtable设计基于HDFS上的一款数据库。 1.1 CAP原则 CAP原则又称之为CAP原理,指的是在分布式系统当中,一致性、可用性、...

    一、概述

    Hbase全称为Hadoop Database(基于HDFS的数据库),设计来源Google 的bigtable,Hbase 仿照 bigtable设计基于HDFS上的一款数据库。

    在这里插入图片描述

    1.1 CAP原则

    CAP原则又称之为CAP原理,指的是在分布式系统当中,一致性、可用性、分区容错性,三者不可兼得

    在这里插入图片描述

    HBase 是保证CP

    1.2 什么是基于列式存储?

    HBase 是基于列式存储的NoSql

    这个概念和RDBMS作对比,传统的数据库对数据的操作单位是一行(若干字段)

    select username ,pass from user where id = 1update  user set username ="gjf " where id =1; 
    

    即使操纵的是某一行记录当中的字段,其实RDBMS是查询了整行的内容加载完后完成对数据的修改

    行存储问题

    在这里插入图片描述

    列存储

    在这里插入图片描述

    1.3 HBase

    https://hbase.apache.org/

    Hbase 是基于列式存储的分布式的、面向列、基于HDFS的数据库,在需要实时读写,需要访问超大规模数据时,可以使用HBASE。

    1.3.1 特点:

    • 大 : 一个表可以有上亿行,可有上百万列
    • 面向列:可以支持稀疏存储
    • 无模式:表的结构灵活,可以任意增加和减少字段
    • 数据多版本:每个cell中的数据可以用多个版本,在默认情况下,版本号自动分配,版本的个数可以自己设置
    • 数据类型单一:Hbase中的数据都是字符串,没有类型

    1.3.2 名词解释

    • RowKey :与NoSQL数据库一样,rowkey是用来检索记录的主键
    • 列簇:列的合计,列簇必须在使用前进行定义
    • 时间戳:主要为版本提供方便
    • Cell单元格:由{rowkey,列名,列簇,时间戳}

    1.3.3 Hbase和关系型数据库的区别

    • 数据库类型:HBase中数据库类型都是字符串类型(String)
    • 数据操作:Hbase只有普通的增删查改等操作,没有表之间的关联查询
    • 存储模式:Hbase是基于列式存储的,而RDBMS是基于行式存储的
    • 应用场景:Hbase适合存储大容量数据,查询效率极高

    二、Hbase 环境搭建-单机

    2.1 环境

    • Hadoop
    • ZK

    2.2 下载安装

    [root@HadoopNode00 ~]# mkdir /home/hbase
    [root@HadoopNode00 ~]# tar -zxvf hbase-1.2.4-bin.tar.gz -C /home/hbase/
    [root@HadoopNode00 ~]# vi .bashrc
    export HBASE_HOME=/home/hbase/hbase-1.2.4
    export HBASE_MANAGES_ZK=false
    export PATH=$PATH:$HBASE_HOME/bin
    
    [root@HadoopNode00 ~]# vi /home/hbase/hbase-1.2.4/conf/hbase-site.xml
    
    <property>
         <name>hbase.rootdir</name>
         <value>hdfs://HadoopNode00:9000/hbase</value>
    </property>
    
    <property>
    	<name>hbase.zookeeper.quorum</name>
    	<value>HadoopNode00</value>
    </property>
    
    <property>
    	<name>hbase.zookeeper.property.clientPort</name>
    	<value>2181</value>
    </property>
    
    <property>
            <name>hbase.cluster.distributed</name>
            <value>true</value>
    </property>
    [root@HadoopNode00 ~]# vi /home/hbase/hbase-1.2.4/conf/regionservers
    HadoopNode00
    

    2.3 启动

    # 保证zk和hdfs启动成功
    [root@HadoopNode00 zookeeper-3.4.6]# start-hbase.sh
    starting master, logging to /home/hbase/hbase-1.2.4/logs/hbase-root-master-HadoopNode00.out
    Java HotSpot(TM) 64-Bit Server VM warning: ignoring option PermSize=128m; support was removed in 8.0
    Java HotSpot(TM) 64-Bit Server VM warning: ignoring option MaxPermSize=128m; support was removed in 8.0
    HadoopNode00: starting regionserver, logging to /home/hbase/hbase-1.2.4/logs/hbase-root-regionserver-HadoopNode00.out
    HadoopNode00: Java HotSpot(TM) 64-Bit Server VM warning: ignoring option PermSize=128m; support was removed in 8.0
    HadoopNode00: Java HotSpot(TM) 64-Bit Server VM warning: ignoring option MaxPermSize=128m; support was removed in 8.0
    [root@HadoopNode00 zookeeper-3.4.6]# jps
    2257 QuorumPeerMain
    2642 HRegionServer
    1906 DataNode
    1811 NameNode
    2485 HMaster
    2121 SecondaryNameNode
    2938 Jps
    
    

    web界面 : http://hadoopnode00:16010/master-status

    2.4 连接

    [root@HadoopNode00 zookeeper-3.4.6]# hbase shell
    

    三、Shell操作

    3.1 常见命令

    hbase(main):001:0> status
    1 active master, 0 backup masters, 1 servers, 0 dead, 2.0000 average load
    
    hbase(main):003:0> version
    1.2.4, rUnknown, Wed Feb 15 18:58:00 CST 2017
    
    hbase(main):004:0> whoami
    root (auth:SIMPLE)
        groups: root
    

    3.2 命名空间操作

    namespace 相当于MySQL中的数据库

    # 创建一个普通的命名空间
    hbase(main):006:0> create_namespace "baizhi"
    0 row(s) in 0.0870 seconds
    
    # 创建带属性的命名空间
    hbase(main):007:0> create_namespace "shahe",{'subway'=>'shahezhan'}
    0 row(s) in 0.0130 seconds
    
    #删除命名空间
    hbase(main):001:0> drop_namespace 'baizhi'
    0 row(s) in 0.1440 seconds
    
    # 描述命名空间
    hbase(main):001:0> describe_namespace 'shahe'
    DESCRIPTION
    {NAME => 'shahe', subway => 'shahezhan'}
    1 row(s) in 0.1300 seconds
    
    # 修改命名空间
    hbase(main):003:0> alter_namespace 'shahe',{METHOD => 'set', 'subway'=>'gonghuacheng'}
    0 row(s) in 0.0240 seconds
    
    hbase(main):004:0> describe_namespace 'shahe'
    DESCRIPTION
    {NAME => 'shahe', subway => 'gonghuacheng'}
    1 row(s) in 0.0060 seconds
    
    # 列出所有命名空间
    hbase(main):005:0> list_namespace
    NAMESPACE
    default
    hbase
    shahe
    3 row(s) in 0.0160 seconds
    
    

    3.3 表操作(DDL 数据定义语言)

    # 创建命名空间为baizhi
    hbase(main):007:0> create_namespace 'baizhi'
    0 row(s) in 0.0230 seconds
    
    # 创建baizhi namespace的下的表叫做 t_user,有两个列簇叫做 cf1 cf2
    hbase(main):008:0> create 'baizhi:t_user','cf1','cf2'
    0 row(s) in 2.2930 seconds
    
    => Hbase::Table - baizhi:t_user
    
    hbase(main):001:0> describe 'baizhi:t_user'
    Table baizhi:t_user is ENABLED
    baizhi:t_user
    COLUMN FAMILIES DESCRIPTION
    {NAME => 'cf1', BLOOMFILTER => 'ROW', VERSIONS => '1', IN_MEMORY => 'false', KEEP_DELETED_CELLS => 'FALSE', DATA_BL
    CODING => 'NONE', TTL => 'FOREVER', COMPRESSION => 'NONE', MIN_VERSIONS => '0', BLOCKCACHE => 'true', BLOCKSIZE =>
    ', REPLICATION_SCOPE => '0'}
    {NAME => 'cf2', BLOOMFILTER => 'ROW', VERSIONS => '1', IN_MEMORY => 'false', KEEP_DELETED_CELLS => 'FALSE', DATA_BL
    CODING => 'NONE', TTL => 'FOREVER', COMPRESSION => 'NONE', MIN_VERSIONS => '0', BLOCKCACHE => 'true', BLOCKSIZE =>
    ', REPLICATION_SCOPE => '0'}
    2 row(s) in 0.1930 seconds
    
    
    
    # 直接删除无法删除,需要将其先disable掉
    hbase(main):002:0> drop 'baizhi:t_user'
    
    ERROR: Table baizhi:t_user is enabled. Disable it first.
    
    Here is some help for this command:
    Drop the named table. Table must first be disabled:
      hbase> drop 't1'
      hbase> drop 'ns1:t1'
    
    # disable 表 (禁用表)
    hbase(main):003:0> disable
    disable                     disable_all                 disable_peer                disable_table_replication
    hbase(main):003:0> disable 'baizhi:t_user'
    0 row(s) in 2.2570 seconds
    
    # 删除表
    hbase(main):004:0> drop 'baizhi:t_user'
    0 row(s) in 1.2370 seconds
    
    
    hbase(main):001:0> create 'baizhi:t_user','cf1','cf2'
    0 row(s) in 1.3470 seconds
    
    => Hbase::Table - baizhi:t_user
    
    # 列出所有的表
    hbase(main):002:0> list
    TABLE
    baizhi:t_user
    1 row(s) in 0.0120 seconds
    
    => ["baizhi:t_user"]
    
    # 列出某个命名空间下的表
    hbase(main):003:0> list_namespace_tables 'baizhi'
    TABLE
    t_user
    1 row(s) in 0.0130 seconds
    
    
    

    3.4 数据操作(数据管理语言 DML)

    3.4.1 put

    # 最普通的插入语句的方式
    hbase(main):005:0> put 'baizhi:t_user','1','cf1:name','zhangsan'
    0 row(s) in 0.1010 seconds
    
    
    # 将表对象复制给变量t
    hbase(main):006:0> t = get_table 'baizhi:t_user'
    0 row(s) in 0.0010 seconds
    
    => Hbase::Table - baizhi:t_user
    
    # 使用复制对象t 对表进行操作
    hbase(main):007:0> t.put '1','cf1:age',18
    0 row(s) in 0.0110 seconds
    
    # 覆盖操作和put插入相似 写入相同的条件  写入值就可覆盖
    hbase(main):008:0> t.put '1','cf1:age',19
    0 row(s) in 0.0070 seconds
    # 扫描 当前的表
    hbase(main):009:0> t.scan
    ROW                           COLUMN+CELL
     1                            column=cf1:age, timestamp=1569278257582, value=19
     1                            column=cf1:name, timestamp=1569277976093, value=zhangsan
    1 row(s) in 0.0180 seconds
    
    

    3.4.2 get

    
    # 获取baizhi:t_user 下的rowk为1 的所有的cell
    hbase(main):013:0> get 'baizhi:t_user' ,'1'
    COLUMN                        CELL
     cf1:age                      timestamp=1569278257582, value=19
     cf1:name                     timestamp=1569277976093, value=zhangsan
    2 row(s) in 0.0120 seconds
    
    hbase(main):014:0> t.get '1'
    COLUMN                        CELL
     cf1:age                      timestamp=1569278257582, value=19
     cf1:name                     timestamp=1569277976093, value=zhangsan
    2 row(s) in 0.0030 seconds
    # 发现获取版本只有一个,是因为表目前不支持多版本
    hbase(main):015:0> t.get '1',{COLUMN=>'cf1:name',VERSIONS=>3}
    
    
    # 创建一个最多有三个版本的表
    hbase(main):001:0> create 'baizhi:t_user',{NAME=>'cf1',VERSIONS=>3}
    0 row(s) in 1.3510 seconds
    
    => Hbase::Table - baizhi:t_user
    
    hbase(main):006:0> t.get '1',{COLUMN=>'cf1:name',VERSIONS=>3}
    COLUMN                        CELL
     cf1:name                     timestamp=1569279103046, value=zs
     cf1:name                     timestamp=1569279081528, value=zhangsan
    2 row(s) in 0.0090 seconds
    
    

    3.4.3 delete /deleteall

    hbase(main):009:0> t.delete '1','cf1:name'
    0 row(s) in 0.0270 seconds
    hbase(main):010:0> t.scan
    ROW                           COLUMN+CELL
     1                            column=cf1:age, timestamp=1569279066158, value=18
    1 row(s) in 0.0090 seconds
    
    
    
    # 根据时间戳进行删除
    hbase(main):012:0> t.get '1',{COLUMN=>'cf1:age',VERSIONS=>3}
    COLUMN                        CELL
     cf1:age                      timestamp=1569279425168, value=19
     cf1:age                      timestamp=1569279066158, value=18
    2 row(s) in 0.0080 seconds
    hbase(main):013:0> t.delete '1','cf1:age',1569279066158
    0 row(s) in 0.0060 seconds
    hbase(main):014:0> t.get '1',{COLUMN=>'cf1:age',VERSIONS=>3}
    COLUMN                        CELL
     cf1:age                      timestamp=1569279425168, value=19
    1 row(s) in 0.0030 seconds
    
    hbase(main):002:0> deleteall 'baizhi:t_user','1'
    0 row(s) in 0.1600 seconds
    
    hbase(main):003:0> scan 'baizhi:t_user'
    ROW                           COLUMN+CELL
    0 row(s) in 0.0120 seconds
    
    
    

    3.4.4 scan

    #  查询列簇为cf1 从第一行开始
    hbase(main):019:0> scan 'baizhi:t_user',{COLUMNS=>['cf1'],STARTROW=>'1'}
    ROW                           COLUMN+CELL
     1                            column=cf1:age, timestamp=1569279798830, value=20
     1                            column=cf1:name, timestamp=1569279748288, value=zhangsan
     2                            column=cf1:age, timestamp=1569279809118, value=22
     2                            column=cf1:name, timestamp=1569279779869, value=wangwubaizhi
    2 row(s) in 0.0100 seconds
    
    #  查询列簇为cf1 从第二行开始
    hbase(main):020:0> scan 'baizhi:t_user',{COLUMNS=>['cf1'],STARTROW=>'2'}
    ROW                           COLUMN+CELL
     2                            column=cf1:age, timestamp=1569279809118, value=22
     2                            column=cf1:name, timestamp=1569279779869, value=wangwubaizhi
    1 row(s) in 0.0080 seconds
    
    #  查询列簇为cf1 从第三行开始
    hbase(main):021:0> scan 'baizhi:t_user',{COLUMNS=>['cf1'],STARTROW=>'3'}
    ROW                           COLUMN+CELL
    0 row(s) in 0.0040 seconds
    
    #  查询列簇为cf1 从第一行开始 只显示一行
    hbase(main):022:0> scan 'baizhi:t_user',{COLUMNS=>['cf1'],STARTROW=>'1',LIMIT=>1}
    ROW                           COLUMN+CELL
     1                            column=cf1:age, timestamp=1569279798830, value=20
     1                            column=cf1:name, timestamp=1569279748288, value=zhangsan
    1 row(s) in 0.0070 seconds
    #  查询列簇为cf1 从第一行开始 只显示两行
    hbase(main):023:0> scan 'baizhi:t_user',{COLUMNS=>['cf1'],STARTROW=>'1',LIMIT=>2}
    ROW                           COLUMN+CELL
     1                            column=cf1:age, timestamp=1569279798830, value=20
     1                            column=cf1:name, timestamp=1569279748288, value=zhangsan
     2                            column=cf1:age, timestamp=1569279809118, value=22
     2                            column=cf1:name, timestamp=1569279779869, value=wangwubaizhi
    2 row(s) in 0.0260 seconds
    
    

    3.4.5 count

    hbase(main):025:0> count 'baizhi:t_user'
    2 row(s) in 0.0130 seconds
    
    => 2
    
    

    3.4.6 append

    hbase(main):026:0> append 'baizhi:t_user','1','cf1:name','110'
    0 row(s) in 0.0070 seconds
    
    hbase(main):027:0> scan 'baizhi:t_user'
    ROW                           COLUMN+CELL
     1                            column=cf1:age, timestamp=1569279798830, value=20
     1                            column=cf1:name, timestamp=1569280127798, value=zhangsan110
     2                            column=cf1:age, timestamp=1569279809118, value=22
     2                            column=cf1:name, timestamp=1569279779869, value=wangwubaizhi
    2 row(s) in 0.0090 seconds
    
    
    

    3.4.7 truncate

    清空数据

    hbase(main):028:0> truncate 'baizhi:t_user'
    Truncating 'baizhi:t_user' table (it may take a while):
     - Disabling table...
     - Truncating table...
    0 row(s) in 3.4400 seconds
    
    hbase(main):001:0> scan 'baizhi:t_user'
    ROW                           COLUMN+CELL
    0 row(s) in 0.1550 seconds
    
    

    四、Java API

    4.1 依赖

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

    4.2 核心操作

    获取客户端对象和连接对象

    
        @Before
        public void getClient() throws Exception {
            configuration = new Configuration();
    
            configuration.set("hbase.zookeeper.quorum", "HadoopNode00");
            configuration.set("hbase.zookeeper.property.clientPort", "2181");
            conn = ConnectionFactory.createConnection(configuration);
            admin = conn.getAdmin();
    
        }
        
    
        @After
        public void close() throws Exception {
            admin.close();
            conn.close();
    
        }
    

    4.3 namespace常规操作

     @Test
        public void createNameSpace() throws Exception {
            NamespaceDescriptor namespaceDescriptor = NamespaceDescriptor.create("baizhi123").addConfiguration("admin", "gjf").build();
            admin.createNamespace(namespaceDescriptor);
        }
    
        @Test
        public void listNameSpace() throws Exception {
    
            NamespaceDescriptor[] listNamespaceDescriptors = admin.listNamespaceDescriptors();
    
            for (NamespaceDescriptor listNamespaceDescriptor : listNamespaceDescriptors) {
                System.out.println(listNamespaceDescriptor.getName());
            }
    
    
        }
    
        @Test
        public void modifyNameSpace() throws Exception {
            NamespaceDescriptor namespaceDescriptor = NamespaceDescriptor.create("baizhi123").addConfiguration("aa", "bb").removeConfiguration("admin").build();
            admin.modifyNamespace(namespaceDescriptor);
    
    
        }
    
        @Test
        public void deleteNameSpace() throws Exception{
            admin.deleteNamespace("baizhi123");
    
        }
    

    4.4 表常规操作

    参考 http://hbase.apache.org/apidocs/org/apache/hadoop/hbase/

    @Test
        public void createTables() throws Exception {
    
            /*
            创建表名的对象(封装表名字)
            * */
            TableName tableName = TableName.valueOf("baizhi:t_user1");
    
    
            /*
             * 封装  表 的相关信息
             * */
    
    
            HTableDescriptor hTableDescriptor = new HTableDescriptor(tableName);
    
            /*
             * 封装列簇的相关信息
             * */
            HColumnDescriptor cf1 = new HColumnDescriptor("cf1");
            cf1.setMaxVersions(3);
    
    = 
            /*
             *
             * */
            HColumnDescriptor cf2 = new HColumnDescriptor("cf2");
            cf2.setMaxVersions(3);
    
            /*
             * 在hTableDescriptor 对象中添加列簇描述对象
             * */
    
    
            hTableDescriptor.addFamily(cf1);
            hTableDescriptor.addFamily(cf2);
    
    
            /*
             * 创建 table
             * */
            admin.createTable(hTableDescriptor);
    
        }
    
        @Test
    
        public void dropTable() throws Exception {
    
    
            TableName tableName = TableName.valueOf("baizhi:t_user1");
            admin.disableTable(tableName);
            admin.deleteTable(tableName);
        }
    
    

    4.5 CURD

    4.5.1 put

    更新单个记录

    @Test
        public void testPutOne() throws Exception {
    
            TableName tableName = TableName.valueOf("baizhi:t_user");
            /*
             * 通过conn对象获得table的操作对象
             * */
            Table table = conn.getTable(tableName);
    
            Put put1 = new Put("1".getBytes());
            put1.addColumn("cf1".getBytes(), "name".getBytes(), "zhangsan".getBytes());
            put1.addColumn("cf1".getBytes(), "age".getBytes(), "18".getBytes());
            put1.addColumn("cf1".getBytes(), "sex".getBytes(), "false".getBytes());
    
           
            table.put(put1);
            table.close();
    
        }
    

    插入多个记录

     @Test
        public void testPutList() throws Exception {
    
            TableName tableName = TableName.valueOf("baizhi:t_user");
            BufferedMutator bufferedMutator = conn.getBufferedMutator(tableName);
    
    
            Put put1 = new Put("4".getBytes());
            put1.addColumn("cf1".getBytes(), "name".getBytes(), "zhangsan".getBytes());
            put1.addColumn("cf1".getBytes(), "age".getBytes(), "18".getBytes());
            put1.addColumn("cf1".getBytes(), "sex".getBytes(), "false".getBytes());
    
            Put put2 = new Put("5".getBytes());
            put2.addColumn("cf1".getBytes(), "name".getBytes(), "zhangsan".getBytes());
            put2.addColumn("cf1".getBytes(), "age".getBytes(), "18".getBytes());
            put2.addColumn("cf1".getBytes(), "sex".getBytes(), "false".getBytes());
    
            Put put3 = new Put("6".getBytes());
            put3.addColumn("cf1".getBytes(), "name".getBytes(), "zhangsan".getBytes());
            put3.addColumn("cf1".getBytes(), "age".getBytes(), "18".getBytes());
            put3.addColumn("cf1".getBytes(), "sex".getBytes(), "false".getBytes());
    
            ArrayList<Put> puts = new ArrayList<Put>();
            puts.add(put1);
            puts.add(put2);
            puts.add(put3);
    
            bufferedMutator.mutate(puts);
    
            bufferedMutator.close();
    
        }
    
    

    4.5.2 delete

    单个删除

    
        @Test
        public void tetsDelete() throws Exception {
    
            TableName tableName = TableName.valueOf("baizhi:t_user");
            Table table = conn.getTable(tableName);
            Delete delete = new Delete("6".getBytes());
    
            table.delete(delete);
            table.close();
    
        }
    
    

    批量删除

    
        @Test
        public void testDeleteList() throws Exception{
    
    
            TableName tableName = TableName.valueOf("baizhi:t_user");
            BufferedMutator bufferedMutator = conn.getBufferedMutator(tableName);
    
            Delete delete1 = new Delete("1".getBytes());
            Delete delete2 = new Delete("2".getBytes());
            Delete delete3 = new Delete("3".getBytes());
    
            ArrayList<Delete> deletes = new ArrayList<Delete>();
    
            deletes.add(delete1);
            deletes.add(delete2);
            deletes.add(delete3);
    
            bufferedMutator.mutate(deletes);
    
            bufferedMutator.close();
    
    
        }
    

    4.5.3 get

    
    
    
        @Test
    
        public void testGet() throws Exception {
    
            TableName tableName = TableName.valueOf("baizhi:t_user");
            Table table = conn.getTable(tableName);
    
            Get get = new Get("4".getBytes());
    
    
            Result result = table.get(get);
    
            byte[] name = result.getValue("cf1".getBytes(), "name".getBytes());
            byte[] age = result.getValue("cf1".getBytes(), "age".getBytes());
            byte[] sex = result.getValue("cf1".getBytes(), "sex".getBytes());
    
            System.out.println(new String(name) + "-" + new String(age) + "-" + new String(sex));
    
        }
    
    
        @Test
        public void testGet02() throws Exception {
            /*
            *
            * hbase(main):012:0>  t.get '4',{COLUMN=>'cf1:name',VERSIONS=>3}
                COLUMN                        CELL
                cf1:name                     timestamp=1569284691440, value=zs
                cf1:name                     timestamp=1569283965094, value=zhangsan
    
            * */
    
            TableName tableName = TableName.valueOf("baizhi:t_user");
            Table table = conn.getTable(tableName);
    
            Get get = new Get("4".getBytes());
            get.setMaxVersions(2);
    
            get.addColumn("cf1".getBytes(), "name".getBytes());
    
            Result result = table.get(get);
    
            List<Cell> cellList = result.getColumnCells("cf1".getBytes(), "name".getBytes());
    
    
            for (Cell cell : cellList) {
                /*
                 * rowkey 列名  列值  时间戳
                 * */
    
    
                byte[] rowkey = CellUtil.cloneRow(cell);
                byte[] cf = CellUtil.cloneFamily(cell);
                byte[] qualifier = CellUtil.cloneQualifier(cell);
                byte[] value = CellUtil.cloneValue(cell);
                long timestamp = cell.getTimestamp();
    
                System.out.println(new String(rowkey) + "--" + new String(cf) + "--" + new String(qualifier) + "--" + new String(value) +"--" +timestamp);
    
    
            }
    
    
    

    4.5.4 scan

     @Test
        public void testScan() throws Exception {
    
            TableName tableName = TableName.valueOf("baizhi:t_user");
            Table table = conn.getTable(tableName);
    
            Scan scan = new Scan();
    
    
            PrefixFilter prefixFilter1 = new PrefixFilter("4".getBytes());
            PrefixFilter prefixFilter2 = new PrefixFilter("5".getBytes());
    
            FilterList list = new FilterList(FilterList.Operator.MUST_PASS_ONE,prefixFilter1, prefixFilter2);
            scan.setFilter(list);
    
    
            ResultScanner results = table.getScanner(scan);
    
            for (Result result : results) {
    
                byte[] row = result.getRow();
                byte[] name = result.getValue("cf1".getBytes(), "name".getBytes());
                byte[] age = result.getValue("cf1".getBytes(), "age".getBytes());
                byte[] sex = result.getValue("cf1".getBytes(), "sex".getBytes());
    
                System.out.println(new String(row) + "--" + new String(name) + "-" + new String(age) + "-" + new String(sex));
            }
    
    
        }
    
    

    五、MapReduce on Hbase

    5.1 依赖

    <dependency>
        <groupId>org.apache.hadoop</groupId>
        <artifactId>hadoop-hdfs</artifactId>
        <version>2.6.0</version>
    </dependency>
    <dependency>
        <groupId>org.apache.hadoop</groupId>
        <artifactId>hadoop-common</artifactId>
        <version>2.6.0</version>
    </dependency>
    
    <dependency>
        <groupId>org.apache.hadoop</groupId>
        <artifactId>hadoop-mapreduce-client-core</artifactId>
        <version>2.6.0</version>
    </dependency>
    <dependency>
        <groupId>org.apache.hadoop</groupId>
        <artifactId>hadoop-mapreduce-client-jobclient</artifactId>
        <version>2.6.0</version>
    </dependency>
    
    <dependency>
        <groupId>org.apache.hbase</groupId>
        <artifactId>hbase-client</artifactId>
        <version>1.2.4</version>
    </dependency>
    <dependency>
        <groupId>org.apache.hbase</groupId>
        <artifactId>hbase-server</artifactId>
        <version>1.2.4</version>
    </dependency>
    
    

    5.2 模拟问题

    HBase中有相关的数据 
    书写MR 程序
    运行
    
    baidu sina ali
    rowkey  salary  name age 
    
    package com.baizhi.mr;
    
    import org.apache.hadoop.conf.Configuration;
    import org.apache.hadoop.hbase.client.Scan;
    import org.apache.hadoop.hbase.mapreduce.TableInputFormat;
    import org.apache.hadoop.hbase.mapreduce.TableMapReduceUtil;
    import org.apache.hadoop.hbase.mapreduce.TableOutputFormat;
    import org.apache.hadoop.io.DoubleWritable;
    import org.apache.hadoop.io.Text;
    import org.apache.hadoop.mapreduce.Job;
    import org.apache.hadoop.mapreduce.MRJobConfig;
    
    import javax.swing.*;
    
    public class JobRunner {
        public static void main(String[] args) throws Exception {
            System.setProperty("HADOOP_USER_NAME", "root");
    
            Configuration configuration = new Configuration();
    
            configuration.set("hbase.zookeeper.quorum", "HadoopNode00");
            configuration.set("hbase.zookeeper.property.clientPort", "2181");
    
            configuration.addResource("conf2/core-site.xml");
            configuration.addResource("conf2/hdfs-site.xml");
            configuration.addResource("conf2/mapred-site.xml");
            configuration.addResource("conf2/yarn-site.xml");
            configuration.set(MRJobConfig.JAR, "G:\\IDEA_WorkSpace\\BigData\\HBase_Test\\target\\HBase_Test-1.0-SNAPSHOT.jar");
            configuration.set("mapreduce.app-submission.cross-platform", "true");
    
            Job job = Job.getInstance(configuration);
            job.setJarByClass(JobRunner.class);
    
            /*
             *
             * */
            job.setInputFormatClass(TableInputFormat.class);
            job.setOutputFormatClass(TableOutputFormat.class);
    
    
    
            /*
             *
             * 设置mapper 相关
             * */
            TableMapReduceUtil.initTableMapperJob(
                    "baizhi:t_user1",
                    new Scan(),
                    UserMapper.class,
                    Text.class,
                    DoubleWritable.class,
                    job
            );
    
    
            TableMapReduceUtil.initTableReducerJob(
                    "baizhi:t_result",
                    UserReducer.class,
                    job);
    
    
            job.waitForCompletion(true);
        }
    }
    
    
    package com.baizhi.mr;
    
    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;
    import org.apache.hadoop.io.DoubleWritable;
    import org.apache.hadoop.io.Text;
    
    import java.io.IOException;
    
    public class UserMapper extends TableMapper<Text, DoubleWritable> {
        @Override
        protected void map(ImmutableBytesWritable key, Result value, Context context) throws IOException, InterruptedException {
    
    
            byte[] bytes = key.get();
            String rowkey = Bytes.toString(bytes);
    
            String company = rowkey.split(":")[0];
    
            byte[] salaryByte = value.getValue("cf1".getBytes(), "salary".getBytes());
    
            double salary = Bytes.toDouble(salaryByte);
    
    
            context.write(new Text(company), new DoubleWritable(salary));
    
    
        }
    }
    
    
    package com.baizhi.mr;
    
    
    import org.apache.hadoop.hbase.client.Put;
    import org.apache.hadoop.hbase.mapreduce.TableReducer;
    import org.apache.hadoop.io.DoubleWritable;
    import org.apache.hadoop.io.NullWritable;
    import org.apache.hadoop.io.Text;
    
    import java.io.IOException;
    
    public class UserReducer extends TableReducer<Text, DoubleWritable, NullWritable> {
    
        @Override
        protected void reduce(Text key, Iterable<DoubleWritable> values, Context context) throws IOException, InterruptedException {
            double totalSalary = 0.0;
    
            int count = 0;
    
    
            for (DoubleWritable value : values) {
                totalSalary += value.get();
                count++;
    
            }
    
            Put put = new Put(key.getBytes());
    
            put.addColumn("cf1".getBytes(), "avgSalary".getBytes(), (totalSalary / count + "").getBytes());
    
    
            context.write(NullWritable.get(), put);
    
    
        }
    }
    
    

    5.3 最终结果

    在这里插入图片描述

    六、HBase 架构 (重点)

    6.1 名词解释

    (1)ZooKeeper

    • HBase 通过ZK来做Master 的高可用,如果Master异常,通过竞争选举产生新的Master 提供服务
    • HBase 通过ZK 来做 RegionServer的监控,当RegionServer异常时,调用的相关的容错机制
    • 元数据的入口和集群配置的维护工作,通过zk做外部统一入口

    (2)HMaster

    • 为RegionServer分配Region
    • 维护整个集群的负载均衡
    • 维护集群的元数据信息
    • 发现失效的Region,将失效的Region分配给正常的RegionServer
    • 当RegionServer失效时,协调对应的HLog拆分

    (3)HRegionServer

    • HRegionServer直接对接用户的读写请求
    • 管理Master 为其分配的Region
    • 处理来自客户端的请求,负责与HDFS 做交互,存储到HDFS
    • 负责对Region(变大)的拆分

    1)Region

    • Regions代表着一个表所有的数据
    • Region往往会做拆分,因为一个Region是无法存储Hbase 表中所有的数据
      • 拆分机制|切割条件:数据大小>=N^2 * 128MB,N 是Region的数量,当N=9 时,一般大小会超过10GB,此时以后按照10Gb进行拆分
    • Region 由Store组成
    • Region会分配到集群中称之为"RegionServer"的节点

    2)Store

    • 每一个Region有一个或者多个Store,至少有一个
    • 使用列簇划分Store,有几个列簇就有几个Stroe
    • 一个Store由一个MemStore和0或者多个HFile(StoreFile)组成

    3)MemStore

    • 写缓存,数据先写到MemStore中,在Flush到磁盘中
    • 以key value形式存储到磁盘中
    • MemStore flush 触发机制
      • MemStore级别限制:当Region中任意一个MemStore大小达到上限(hbase.region.master.flush.size 默认128MB)
      • Region级别限制:当Region中给所有的MemStore的大小总和达到了256MB(hbase.hregion.memstore.block.multiplier * hbase.hregion.memstore.flush.size,默认 2* 128M = 256M)
      • RegionServer 级别:当一个RegionServer中所有的MemStore大小总和上限到了(hbase.regionserver.global.memstore.upperLimit * hbase_heapsize,默认 40%的JVM内存使用量)
      • 当一个RegionServer中HLog数量达到上限(可通过参数hbase.regionserver.maxlogs配置),系统会选取最早的一个 HLog对应的一个或多个Region进行flush
      • Hbase 定时刷新:默认一个小时,确保数据不会长时间停留在内存中
      • 手动Flush:用户可以通过shell命令 flush ‘tablename’或者flush ‘region name’分别对一个表或者一个Region进行flush。

    4)HLog|WAL

    • 一个文件

    • 0.94之前叫做HLog,0.94 之后叫做WAL

    • 记录RegionServer上所有的编辑信息(Put、Deletes操作属于那个Region),在数据写入MemStore之前

    • 默认为一个WAL 日志,操作为串行操作,可能造成性能瓶颈,可以配置多个WAL 实例,进行并行写入(但是并行化是通过对多个Region进行分区实现的,如果只有一个Region那么该方案无效)

      • hbase-site.xml
        
        <property>   
          <name>hbase.wal.provider</name>   
          <value>multiwal</value> 
        </property>
        
    • RegionServer 宕机时 ,实现数据恢复

    5)HFile| StoreFile

    HFile( StoreFile)用于存储HBase 的数据,在HBase中数据是按照Rowkey|ColumnFamily|Column 排序。对与相同的Cell按照时间戳进行排序

    (4)HDFS

    HDFS 为HBase 存储提供服务,理论上Hbase 是可以无限扩容的,不用担心容量和容灾的问题,只需要保证其自身的高可用即可,不用去考虑存储系统的相关的问题

    6.2 HBase 架构图

    在这里插入图片描述

    七、集群搭建

    在这里插入图片描述

    HadoopNode01 HadoopNode02 HadoopNode03
    nn1 nn2
    journal node journal node journal node
    zkfc zkfc
    datanode datanode datanode
    zk01 zk02 zk03
    rm1 rm2
    nodemanager nodemanager nodemanager
    hregionserver hregionserver hregionserver
    hmaster hmaster hmaster
    • 必须安装Hadoop环境,并且HADOOP_HOME,因为HBase 会自动读取HDFS
    • 安装ZK集群(伪集群|单节点),保证其正常启动
    • 安装Hbase
    # 首先在三台zk节点中保证ZK成功启动
    
    [root@ZK01 ~]# /home/zk/zookeeper-3.4.6/bin/zkServer.sh start /home/zk/zookeeper-3.4.6/conf/zk.conf
    JMX enabled by default
    Using config: /home/zk/zookeeper-3.4.6/conf/zk.conf
    Starting zookeeper ... STARTED
    [root@ZK01 ~]# /home/zk/zookeeper-3.4.6/bin/zkServer.sh status /home/zk/zookeeper-3.4.6/conf/zk.conf
    JMX enabled by default
    Using config: /home/zk/zookeeper-3.4.6/conf/zk.conf
    Mode: follower
    
    
    # 配置安装Hbase 
    [root@HadoopNodeX ~]# mkdir /home/hbase
    [root@HadoopNodeX ~]# tar -zxvf hbase-1.2.4-bin.tar.gz -C /home/hbase/
    
    # 配置环境比变量
    
    [root@HadoopNodeX ~]# vi .bashrc
    export HBASE_HOME=/home/hbase/hbase-1.2.4
    export HBASE_MANAGES_ZK=false
    export PATH=$PATH:$HBASE_HOME/bin
    # 环境变量生效
    [root@HadoopNodeX ~]# source .bashrc
    
    
    [root@HadoopNodeX ~]# vi /home/hbase/hbase-1.2.4/conf/hbase-site.xml
    
    <property>
         <name>hbase.rootdir</name>
         <value>hdfs://mycluster/hbase</value>
    </property>
    
    <property>
    	<name>hbase.zookeeper.quorum</name>
    	<value>ZK01,ZK02,ZK03</value>
    </property>
    
    <property>
    	<name>hbase.zookeeper.property.clientPort</name>
    	<value>2181</value>
    </property>
    
    <property>
            <name>hbase.cluster.distributed</name>
            <value>true</value>
    </property>
    [root@HadoopNodeX ~]# vi /home/hbase/hbase-1.2.4/conf/regionservers
    HadoopNode01
    HadoopNode02
    HadoopNode03
    
    [root@HadoopNodeX ~]# hbase-daemon.sh start master
    [root@HadoopNodeX ~]# hbase-daemon.sh start regionserver
    

    八 、HBase 读写流程

    8.1 读流程

    在这里插入图片描述

    HBase读数据流程
    1 Client先访问zookeeper,从meta表读取region的位置,然后读取meta表中的数据。meta中又存储了用户表的region信息。
    2 根据namespace、表名和rowkey在meta表中找到对应的region信息
    3 找到这个region对应的regionserver
    4 查找对应的region
    5 先从MemStore找数据,如果没有,再到StoreFile上读(为了读取的效率)
    

    8.2 写流程

    在这里插入图片描述

    (1)Client向HRedgionServer  发送请求
    (2)HRegionServer将数据写到HLog(write ahead log)。为了数据的持久化和恢复;
    (3)HRegionServer将数据写到内存(MEMStroe)
    (4)反馈Client 写成功。
    
    HBase写数据流程
    1 Client首先访问zookeeper,从meta表获取相应region信息,然后找到meta表的数据
    2 根据namespace、表名和rowkey根据meta表的数据找到写入数据对应的region信息
    3 找到对应的regionserver
    4 把数据分别写到HLog和MemStore上一份
    4 MemStore达到一个阈值后则把数据刷成一个StoreFile文件。(若MemStore中的数据有丢失,则可以从HLog上恢复)
    5 当多个StoreFile文件达到一定的大小后,会触发Compact合并操作,合并为一个StoreFile,(这里同时进行版本的合并和数据删除。)
    6 当Storefile大小超过一定阈值后,会把当前的Region分割为两个(Split),并由Hmaster分配到相应的HRegionServer,实现负载均衡
    

    cluster.distributed
    true

    [root@HadoopNodeX ~]# vi /home/hbase/hbase-1.2.4/conf/regionservers
    HadoopNode01
    HadoopNode02
    HadoopNode03

    [root@HadoopNodeX ~]# hbase-daemon.sh start master
    [root@HadoopNodeX ~]# hbase-daemon.sh start regionserver

    
    
    
    
    
    
    
    # 八 、HBase 读写流程
    
    
    
    ## 8.1 读流程
    
    [外链图片转存中...(img-I6CAAwGz-1577535780190)]
    
    
    
    
    
    

    HBase读数据流程
    1 Client先访问zookeeper,从meta表读取region的位置,然后读取meta表中的数据。meta中又存储了用户表的region信息。
    2 根据namespace、表名和rowkey在meta表中找到对应的region信息
    3 找到这个region对应的regionserver
    4 查找对应的region
    5 先从MemStore找数据,如果没有,再到StoreFile上读(为了读取的效率)

    
    
    
    ## 8.2 写流程
    
    
    
    [外链图片转存中...(img-R2BGtO7h-1577535780190)]
    
    

    (1)Client向HRedgionServer 发送请求
    (2)HRegionServer将数据写到HLog(write ahead log)。为了数据的持久化和恢复;
    (3)HRegionServer将数据写到内存(MEMStroe)
    (4)反馈Client 写成功。

    
    

    HBase写数据流程
    1 Client首先访问zookeeper,从meta表获取相应region信息,然后找到meta表的数据
    2 根据namespace、表名和rowkey根据meta表的数据找到写入数据对应的region信息
    3 找到对应的regionserver
    4 把数据分别写到HLog和MemStore上一份
    4 MemStore达到一个阈值后则把数据刷成一个StoreFile文件。(若MemStore中的数据有丢失,则可以从HLog上恢复)
    5 当多个StoreFile文件达到一定的大小后,会触发Compact合并操作,合并为一个StoreFile,(这里同时进行版本的合并和数据删除。)
    6 当Storefile大小超过一定阈值后,会把当前的Region分割为两个(Split),并由Hmaster分配到相应的HRegionServer,实现负载均衡

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

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

     

    • 概述
     



    HBase是一个构建在HDFS上的分布式列存储系统;
    HBase是基于Google BigTable模型开发的,典型的key/value系统;
    HBase是Apache Hadoop生态系统中的重要一员,主要用于海量结构化数据存储;
    从逻辑上讲,HBase将数据按照表、行和列进行存储。
    与hadoop一样,Hbase目标主要依靠横向扩展,通过不断增加廉价的商用服务器,来增加计算和存储能力。
    Hbase表的特点
    大:一个表可以有数十亿行,上百万列
    无模式:每行都有一个可排序的主键和任意多的列,列可以根据需要动态的增加,同一张表中不同的行可以有截然不同的列
    面向列:面向列(族)的存储和权限控制,列(族)独立检索
    稀疏:空(null)列并不占用存储空间,表可以设计的非常稀疏;
    数据多版本:每个单元中的数据可以有多个版本,默认情况下版本号自动分配,是单元格插入时的时间戳;
    数据类型单一:Hbase中的数据都是字符串,没有类型。

    • Hbase数据模型

    Hbase逻辑视图

     

    注意上图中的英文说明

    Hbase基本概念

    RowKey:是Byte array,是表中每条记录的“主键”,方便快速查找,Rowkey的设计非常重要。
    Column Family:列族,拥有一个名称(string),包含一个或者多个相关列
    Column:属于某一个columnfamily,familyName:columnName,每条记录可动态添加
    Version Number:类型为Long,默认值是系统时间戳,可由用户自定义
    Value(Cell):Byte array
    • Hbase物理模型

    每个column family存储在HDFS上的一个单独文件中,空值不会被保存。
    Key 和 Version number在每个 column family中均有一份;
    HBase 为每个值维护了多级索引,即:<key, column family, column name, timestamp>

    物理存储:
    1、Table中所有行都按照row key的字典序排列;
    2、Table在行的方向上分割为多个Region;
    3、Region按大小分割的,每个表开始只有一个region,随着数据增多,region不断增大,当增大到一个阈值的时候,region就会等分会两个新的region,之后会有越来越多的region;
    4、Region是Hbase中分布式存储和负载均衡的最小单元,不同Region分布到不同RegionServer上。

    5、Region虽然是分布式存储的最小单元,但并不是存储的最小单元。Region由一个或者多个Store组成,每个store保存一个columns family;每个Strore又由一个memStore和0至多个StoreFile组成,StoreFile包含HFile;memStore存储在内存中,StoreFile存储在HDFS上。

     

    • HBase架构及基本组件

     

    Hbase基本组件说明:

     

    Client

    包含访问HBase的接口,并维护cache来加快对HBase的访问,比如region的位置信息

    Master

    为Region server分配region

    负责Region server的负载均衡

    发现失效的Region server并重新分配其上的region

    管理用户对table的增删改查操作

    Region Server

    Regionserver维护region,处理对这些region的IO请求

    Regionserver负责切分在运行过程中变得过大的region

    Zookeeper作用

    通过选举,保证任何时候,集群中只有一个master,Master与RegionServers 启动时会向ZooKeeper注册

    存贮所有Region的寻址入口

    实时监控Region server的上线和下线信息。并实时通知给Master

    存储HBase的schema和table元数据

    默认情况下,HBase 管理ZooKeeper 实例,比如, 启动或者停止ZooKeeper

    Zookeeper的引入使得Master不再是单点故障

     

    Write-Ahead-Log(WAL)

    该机制用于数据的容错和恢复:

    每个HRegionServer中都有一个HLog对象,HLog是一个实现Write Ahead Log的类,在每次用户操作写入MemStore的同时,也会写一份数据到HLog文件中(HLog文件格式见后续),HLog文件定期会滚动出新的,并删除旧的文件(已持久化到StoreFile中的数据)。当HRegionServer意外终止后,HMaster会通过Zookeeper感知到,HMaster首先会处理遗留的 HLog文件,将其中不同Region的Log数据进行拆分,分别放到相应region的目录下,然后再将失效的region重新分配,领取 到这些region的HRegionServer在Load Region的过程中,会发现有历史HLog需要处理,因此会Replay HLog中的数据到MemStore中,然后flush到StoreFiles,完成数据恢复

    HBase容错性
    Master容错:Zookeeper重新选择一个新的Master
    无Master过程中,数据读取仍照常进行;
    无master过程中,region切分、负载均衡等无法进行;
    RegionServer容错:定时向Zookeeper汇报心跳,如果一旦时间内未出现心跳,Master将该RegionServer上的Region重新分配到其他RegionServer上,失效服务器上“预写”日志由主服务器进行分割并派送给新的RegionServer
    Zookeeper容错:Zookeeper是一个可靠地服务,一般配置3或5个Zookeeper实例
    Region定位流程:

    寻找RegionServer

    ZooKeeper--> -ROOT-(单Region)--> .META.--> 用户表

    -ROOT-
    表包含.META.表所在的region列表,该表只会有一个Region;

    Zookeeper中记录了-ROOT-表的location。

    .META.

    表包含所有的用户空间region列表,以及RegionServer的服务器地址。

    • Hbase使用场景

    storing large amounts  of data(100s of TBs)
    need high write throughput
    need efficient random access(key lookups) within large data sets
    need to scale gracefully with data
    for structured and semi-structured data
    don't need fullRDMS capabilities(cross row/cross table transaction, joins,etc.)

    大数据量存储,大数据量高并发操作

    需要对数据随机读写操作

    读写访问均是非常简单的操作

    • Hbase与HDFS对比

    两者都具有良好的容错性和扩展性,都可以扩展到成百上千个节点;
    HDFS适合批处理场景
    不支持数据随机查找
    不适合增量数据处理

    不支持数据更新

     

    • 参考文档:

    1、http://www.alidata.org/archives/1509(存储模型比较详细)

    2、http://www.searchtb.com/2011/01/understanding-hbase.html(技术框架以及存储模型)

    3、http://wenku.baidu.com/view/b46eadd228ea81c758f578f4.html(读和写的流程比较详细)

    展开全文
  • 1HBase是一种 数据库A.列式数据库 B.键值数据库 C.文档数据库 D.关系数据库 2下列对HBase数据模型的描述错误的是A.HBase中执行更新操作时,会删除数据旧的版本,并生成一个新的版本 B.每个HBase表都由若干行组成,...

    1HBase是一种    数据库
    A.列式数据库
    B.键值数据库
    C.文档数据库
    D.关系数据库

    2下列对HBase数据模型的描述错误的是
    A.HBase中执行更新操作时,会删除数据旧的版本,并生成一个新的版本
    B.每个HBase表都由若干行组成,每个行由行键(row key)来标识
    C.HBase列族支持动态扩展,可以很轻松地添加一个列族或列
    D.HBase是一个稀疏、多维度、排序的映射表,这张表的索引是行键、列族、列限定符和时间戳

    3下列说法正确的是
    A.Zookeeper是一个集群管理工具,常用于分布式计算,提供配置维护、域名服务、分布式同步等。
    B.如果不启动Hadoop,则HBase完全无法使用
    C.如果通过HBase Shell插入表数据,可以插入一行数据或一个单元格数据。
    D.HBase的实现包括的主要功能组件是库函数,一个Master主服务器和一个Region服务器

    4每个Region的建议最佳大小是
    A.2GB-4GB
    B.1GB-2GB
    C.100MB-200MB
    D.500MB-1000MB

    5HBase三层结构的顺序是
    A.-ROOT-表,Zookeeper文件,.MEATA.表
    B..MEATA.表,Zookeeper文件,-ROOT-表
    C.Zookeeper文件,.MEATA.表,-ROOT-表
    D.Zookeeper文件,-ROOT-表,.MEATA.表

    6客户端是通过    级寻址来定位Region
    A.一
    B.二
    C.四
    D.三


    7关于HBase Shell命令解释错误的是
    A.list:显示表的所有数据
    B.create:创建表
    C.get:通过表名、行、列、时间戳、时间范围和版本号来获得相应单元格的值
    D.put:向表、行、列指定的单元格添加数据

    8下列对HBase的理解正确的是
    A.HBase是一种关系型数据库,现成功应用于互联网服务领域
    B.HBase是一个行式分布式数据库,是Hadoop生态系统中的一个组件
    C.HBase多用于存储非结构化和半结构化的松散数据
    D.HBase是针对谷歌BigTable的开源实现

    9HBase和传统关系型数据库的区别在于
    A.数据操作
    B.可伸缩性
    C.数据模型
    D.数据索引


    10访问HBase表中的行,有哪些方式
    A.全表扫描
    B.通过一个行健的区间来访问
    C.通过单个行健访问

    D.通过某列的值区间

     

     

    展开全文
  • 2016-04-05 08:53:06,331 WARN [main] zookeeper.ZKUtil: hconnection-0x1f6917fb0x0, quorum=salve1:2181,master:2181,salve2:2181, baseZNode=/hbase Unable to set watcher on znode (/hbase/hbaseid) ...
  • 一、部署准备 1. 依赖框架 大数据Hadoop系列之Hadoop分布式集群部署:https://blog.csdn.net/volitationLong/article/details/80285123 大数据Zookeeper系列之Zookeeper集群部署:...2. ...
  • HBase Shell命令大全

    万次阅读 多人点赞 2019-03-18 20:55:18
    HBase关键名称: Row Key 列族 column family 单元 Cell 时间戳 timestamp HBase Shell 是官方提供的一组命令,用于操作HBase。如果配置了HBase的环境变量了,就可以知己在命令行中输入hbase shell 命令进入命令行。...
  • hbase我的是单机版的,不上集群,版本是1.2.6 使用Java代码对HBASE数据库进行查询期间没有报错,但就是不管为查询多少条数据都是花了20s 在 hbase-env.sh文件里面加了下面配置: export JAVA_HOME=/usr/local/jdk1.8...
  • HBase详解(很全面)

    万次阅读 多人点赞 2018-06-08 16:12:32
    【转自:http://jiajun.iteye.com/blog/899632】一、简介historystarted by chad walters and jim2006.11 G release paper on BigTable2007.2 inital HBase prototype created as Hadoop contrib2007.10 First ...
  • 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...
  • + exec /opt/cloudera/parcels/CDH-5.7.2-1.cdh5.7.2.p0.18/lib/hbase/../../bin/hbase --config /var/run/cloudera-scm-agent/process/469-hbase-REGIONSERVER regionserver start + znode_cleanup regionserver ++...
  • 一篇文章让你了解Hive和HBase的区别

    万次阅读 多人点赞 2018-08-07 09:41:38
    相信做大数据开发的朋友对hive和HBase一定不会陌生。 HBASE 想了解更多大数据相关知识可以点击“了解更多” Hive是基于Hadoop的一个数据仓库工具,可以将结构化的数据文件映射为一张数据库表,并提供简单的sql...
  • 我的Hadoop环境是Hadoop2.4.0,HBaseHBase-0.9.60-hadoo2,今天使用HBase API编写了一个程序,运行的时候曝下面的错误: 2014-09-01 18:16:00,247 WARN [main] util.NativeCodeLoader (NativeCodeLoader.java:(62...
  • 大数据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 显示所有表 ...
  • 本人小白一枚,现在有个项目是用Java项目连接hbase。我用的是windows下的Java项目连接linux虚拟机上的hbasehbase开启之后连接提示连接超时(ps:主机之间可互通),求助。。。 log4j:WARN No appenders could be ...
  • HBase Java API: hbase-client

    千次阅读 2019-03-12 22:06:48
    hbase-client 是hbase的api 二:API package org.apache.hadoop.hbase.client; public class ConnectionFactory { /* * 创建连接 * @param conf hbase属性配置 */ public static Connection createConnection...
  • windows 下启动hbase报错

    2018-11-03 02:21:26
    D:\TSBrowserDownloads\db\hbase-2.1.0-bin\hbase-2.1.0\bin>start-hbase.cmd Exception in thread "main" java.lang.NoClassDefFoundError: org/apache/commons/logging/LogFactory at org.apache.hadoop.conf....
  • hbase集群启动通过ssh启动会爆下面这个错 java.lang.RuntimeException: Failed construction of Regionserver: class org.apache.hadoop.hbase.regionserver.HRegionServer at org.apache.hadoop.hbase....
  • public class extract_hbase_job { private static Configuration hconf = null; static{ Configuration conf = new Configuration(); conf.set("hbase.zookeeper.quorum", "tb86-es01,tb87-es02,tb88-es03...
  • at org.springframework.data.hadoop.hbase.HbaseTemplate$2.doInTable(HbaseTemplate.java:182) at org.springframework.data.hadoop.hbase.HbaseTemplate.execute(HbaseTemplate.java:58) at org.spring...
  • hbase菜鸟,工作需要,请大神帮忙。java连接hbase出现的错误error如下: log4j:WARN No appenders could be found for logger (org.apache.hadoop.metrics2.lib.MutableMetricsFactory). log4j:WARN Please ...
  • 在virtualbox里安装了ubuntu,然后装了了hadoop2.7.5,hbase1.3.1,然后hadoop和hbase的环境都配置好了 启动了hbase,然后本机里通过scala访问虚拟机里的hbase时,connection能获取到,但是在执行tableExists时,...
  • 我们可以利用 Hbase-shell 进行版本的查看 进入Hbase-shell 后可以看到 hbase版本 [root@cdh-manager ~]# hbase shell Java HotSpot(TM) 64-Bit Server VM warning: Using incremental CMS is deprecated and ...
  • java 调用hbase api创建hbase分区表 运行环境:idea16+jdk-1.7+hbase-cdh-1.2.0+cdh-5.8.0   一、新建maven项目,编写pom.xml文件 &lt;?xml version="1.0" encoding="UTF-8"?&gt;...
  • hbase笔记

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

空空如也

1 2 3 4 5 ... 20
收藏数 80.510
精华内容 32.204
关键字:

hbase