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等属性信息。
     通常直接存放在数据库表中。数据记录的每一个属性对应数据表的一个字段。
    非结构化数据
     无法用统一的结构来表示,如文本文件、图像、视频、声音、网页等信息。
     数据记录较小时(如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原理、基本概念、基本架构

    万次阅读 多人点赞 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(读和写的流程比较详细)

    展开全文
  • 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详解(很全面)

    万次阅读 多人点赞 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 ...
  • 一篇文章让你了解Hive和HBase的区别

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

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

    万人学习 2015-10-16 09:47:47
    通过学习hbase,掌握hbase的体系结构,集群安装,使用hbase shell访问hbase中的数据,使用hbase Java访问hbase,使用mapreduce把数据从HDFS中导入到hbase中,掌握过滤器等工具。
  • 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) ...
  • HBase 面试题

    万次阅读 2019-12-17 17:33:09
    文章目录HBase的基本介绍HBASE的适用场景Hbase和Hadoop之间的关系Hbase与RDBMS的关系Hbase特征简要说明hbase的基础架构HBase的底层原理HBase的表数据模型Row Key列族Column Family列 Column时间戳Cell存储数据的最小...
  • Review HBase

    千次阅读 2020-04-12 11:13:10
    hbase 的安装部署 1、软件包上传解压 2、 配置hbase.env.sh 配置java_home 使用外部zookeeper(自己独立安装的zookeeper) 3、配置 hbase-site.xml 见讲义 hbase.zookeeper.property.dataDir必须是zookeeper存储数据...
  • HBase:Sqoop整合HBase

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

    万次阅读 2019-12-13 20:25:36
    hbase 的安装部署 1、软件包上传解压 所有关于CDH版本的软件包下载地址如下 http://archive.cloudera.com/cdh5/cdh/5/ HBase对应的版本下载地址如下 ...
  • HBase详解

    千次阅读 2019-12-12 16:02:49
    Hbase的安装部署 ​ 1、软件包的上传解压 ​ 2、修改hbase.env.sh 文件 ​ 配置JAVA_HOME ​ 设置hbase使用外部zppkeeper ​ export HBASE_MANAGES_ZK=false ​ 配置 hbase-site.xml <configuration> <...
  • 大数据技术之_11_HBase学习_01_HBase 简介+HBase 安装+HBase Shell 操作+HBase 数据结构+HBase 原理
  • HBaseHBase的eclipse开发环境搭建

    千次阅读 2016-02-25 19:56:44
    hbase
  • HBase教程

    2019-01-21 10:38:32
    Hbase教程 HBase概述 HBase体系结构 HBase安装 HBase Shell HBase通用命令 HBase管理API HBase创建表 HBase清单表 HBase禁用表 HBase启用表 HBase描述和修改 HBase判断表是否存在 HBase删除表 HBase退出 HBase...
  • hbase 详解

    千次阅读 2019-07-04 17:40:18
    1.hbase简介 1.1.什么是hbaseHBASE是一个高可靠性、高性能、面向列、可伸缩的分布式存储系统,利用HBASE技术可在廉价PC Server上搭建起大规模结构化存储集群。   HBASE的目标是存储并处理大型的数据,更具体来...
  • HBaseHBase入门详解(一)

    万次阅读 多人点赞 2019-11-30 12:55:55
    1.HBase简介 1.1 什么是HBase HBASE是一个高可靠性、高性能、面向列、可伸缩的分布式存储系统,利用HBASE技术可在廉价PC Server上搭建起大规模结构化存储集群。 HBASE的目标是存储并处理大型的数据,更具体来...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 94,368
精华内容 37,747
关键字:

hbase