精华内容
下载资源
问答
  • 大数据技术之_11_HBase学习_01_HBase 简介+HBase 安装+HBase Shell 操作+HBase 数据结构+HBase 原理

    第1章 HBase 简介

    1.1 什么是 HBase

      HBase 的原型是 Google 的 BigTable 论文,受到了该论文思想的启发,目前作为 Hadoop 的子项目来开发维护,主要用于支持结构化的数据存储,当然也可以支持存储非结构化数据,因为 Hbase 是 NoSQL 数据库(NoSQL= Not only SQL)。
      官方网站:http://hbase.apache.org
      – 2006 年 Google 发表 BigTable 白皮书
      – 2006 年开始开发 HBase
      – 2008 年北京成功开奥运会,程序员默默地将 HBase 弄成了 Hadoop 的子项目
      – 2010 年 HBase 成为 Apache 顶级项目
      – 现在很多公司二次开发出了很多发行版本,你也开始使用了。
      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 实现了在 HDFS 上随机读写。

    1.2 HBase 特点

    1)海量存储
      Hbase 适合存储 PB 级别的海量数据,在 PB 级别的数据以及采用廉价 PC 存储的情况下,能在几十到百毫秒内返回数据。这与 Hbase 的极易扩展性息息相关。正式因为 Hbase 良好的扩展性,才为海量数据的存储提供了便利。
    2)列式存储
      这里的列式存储其实说的是列族存储,Hbase 是根据列族来存储数据的。列族下面可以有非常多的列,列族在创建表的时候就必须指定
    3)极易扩展
      Hbase 的扩展性主要体现在两个方面,一个是基于上层处理能力(RegionServer)的扩展,一个是基于存储的扩展(HDFS)。
      通过横向添加 RegionSever 的机器,进行水平扩展,提升 Hbase 上层的处理能力,提升 Hbsae 服务更多 Region 的能力。
      备注:RegionServer 的作用是管理 region、承接业务的访问,这个后面会详细的介绍通过横向添加 DataNode 的机器,进行存储层扩容,提升 Hbase 的数据存储能力和提升后端存储的读写能力。
    4)高并发
      由于目前大部分使用 Hbase 的架构,都是采用的廉价 PC,因此单个IO的延迟其实并不小,一般在几十到上百ms之间。这里说的高并发,主要是在并发的情况下,Hbase 的单个IO延迟下降并不多。能获得高并发、低延迟的服务。
    5)稀疏
      稀疏主要是针对 Hbase 列的灵活性,在列族中,你可以指定任意多的列,在列数据为空的情况下,是不会占用存储空间的

    1.3 HBase 架构

    HBase 是基于 HDFS 的一个存储框架。
    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
      master 节点的主要职责如下:
      为 RegionServer 分配 Region。
      维护整个集群的负载均衡。
      维护集群的元数据信息。
      发现失效的 Region,并将失效的 Region 分配到正常的 RegionServer 上。
      当 RegionSever 失效的时候,协调对应 Hlog 的拆分。

    4)HregionServer
      HregionServer 直接对接用户的读写请求,是真正的“干活”的节点。它的功能概括如下:
      管理 master 为其分配的 Region。
      处理来自客户端的读写请求。
      负责和底层 HDFS 的交互,存储数据到 HDFS。
      负责 Region 变大以后的拆分。
      负责 StoreFile 的合并工作。

    5)HDFS
      HDFS 为 Hbase 提供最终的底层数据存储服务,同时为 HBase 提供高可用(Hlog 存储在 HDFS)的支持,具体功能概括如下:
      提供元数据和表数据的底层分布式存储服务。
      数据多副本,保证的高可靠和高可用性。

    注意:官方建议一张表建一个列族。因为一个列族很大,有很多个列,够存数据了。如果一张表有多个列族,数据的存储是不平均的,当数据切分的时候会出现数据倾斜,在 HDFS 上还会出现很多小文件,而文件的合并级别是 Store 级别的。

    1.3 HBase 中的角色

    1.3.1 HMaster

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

    1.3.2 RegionServer

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

    1.3.3 其他组件

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

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

    3.Store
      HFile 存储在 Store 中,一个 Store 对应 HBase 表中的一个列族,一个列族可以切分成多个 Store

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

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

    第2章 HBase 安装

    2.1 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
    

    2.2 Hadoop 正常部署

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

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

    2.3 HBase 的解压

    解压HBase到指定目录:

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

    修改解压后的hbase-1.3.1文件夹名称为hbase

    [atguigu@hadoop102 module]$ mv hbase-1.3.1/ hbase
    

    2.4 HBase 的配置文件

    修改 HBase 对应的配置文件。
    1)hbase-env.sh 修改内容:

    [atguigu@hadoop102 conf]$ pwd
    /opt/module/hbase/conf
    [atguigu@hadoop102 conf]$ vim hbase-env.sh
    
    修改JAVA_HOME
    export JAVA_HOME=/opt/module/jdk1.8.0_144
    
    注释掉以下部分:
    # Configure PermSize. Only needed in JDK7. You can safely remove it for JDK8+
    # export HBASE_MASTER_OPTS="$HBASE_MASTER_OPTS -XX:PermSize=128m -XX:MaxPermSize=128m"
    # export HBASE_REGIONSERVER_OPTS="$HBASE_REGIONSERVER_OPTS -XX:PermSize=128m -XX:MaxPermSize=128m"
    
    是否启动HBase自己的Zookeeper,默认是true,改为false
    export HBASE_MANAGES_ZK=false
    

    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,默认端口为16000 -->
        <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:

    [atguigu@hadoop102 conf]$ vim regionservers 
    
    hadoop102
    hadoop103
    hadoop104
    

    4)软连接 hadoop 配置文件到 hbase:(因为 hbase集群 是依赖于 hadoop集群 的)

    [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
    

    2.5 HBase 远程发送到其他集群

    [atguigu@hadoop102 module]$ xsync hbase/
    

    2.6 HBase 服务的启动

    1.启动方式1(单个启动)

    以hadoop102为HMaster
    [atguigu@hadoop102 hbase]$ bin/hbase-daemon.sh start master
    
    [atguigu@hadoop102 hbase]$ bin/hbase-daemon.sh start regionserver
    
    [atguigu@hadoop103 hbase]$ bin/hbase-daemon.sh start regionserver
    
    [atguigu@hadoop104 hbase]$ bin/hbase-daemon.sh start regionserver
    

    提示:如果集群之间的节点时间不同步,会导致 regionserver 无法启动,抛出 ClockOutOfSyncException异常(时钟同步异常)
    修复提示
    a、同步时间服务
      请参看帮助文档:https://www.cnblogs.com/chenmingjun/p/10545638.html
    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
    

    2.7 查看 HBase 页面

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

    注意:HMaster的服务端口是16000,HMaster的web端口是16010。

    第3章 HBase Shell 操作

    3.1 基本操作

    1.进入 HBase 客户端命令行

    [atguigu@hadoop102 hbase]$ bin/hbase shell
    

    2.查看帮助命令

    hbase(main):001:0> help
    

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

    hbase(main):002:0> list
    

    3.2 表的操作

    1.创建表

    hbase(main):002:0> create 'student','info'
    
    注意:删除字符的按键BackSpace的删除顺序是反过来的,即从左往右删。
    

    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','1002','info:name'
    

    7.统计表数据行数

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

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

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

    注意:删除操作默认的时间戳是当前时间。在 HBase 中,增删改数据都是打时间戳!!!
    删除某rowkey的某一列数据:

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

    注意:shell删除操作会将数据的所有版本都删除掉。但是在 HBase 的 API 操作中可以细粒度的控制删除哪一个版本。

    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}
    

    第4章 HBase 数据结构

    4.1 RowKey(核心)

      与 nosql 数据库们一样,RowKey 是用来检索记录的主键。访问 HBASE table 中的行,只有三种方式:
        1. 通过单个 RowKey 访问
        2. 通过 RowKey 的 range(正则)
        3. 全表扫描
      RowKey 行键 (RowKey)可以是任意字符串(最大长度是64KB,实际应用中长度一般为 10-100bytes),在 HBASE 内部,RowKey 保存为字节数组。存储时,数据按照 RowKey 的字典序(byte order)排序存储。设计 RowKey 时,要充分利用排序存储这个特性,将经常一起读取的行存储放到一起。(位置相关性)面试相关。

    4.2 Column Family

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

    4.3 Cell

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

    4.4 Time Stamp

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

    4.5 命名空间

    Hbase 的命名空间就相当于 MySQL 中的 Database。
    Hbase 的命名空间的主要作用是:使用命名空间来管理(区分)不同业务线上的表的问题。
    命名空间的结构:

      1) Tables:表,所有的表都是命名空间的成员,即表必属于某个命名空间,如果没有指定,则在 default 默认的命名空间中。
      2) RegionServer Group:一个命名空间包含了默认的 RegionServer Group。
      3) Permission:权限,命名空间能够让我们来定义访问控制列表ACL(Access Control List)。例如,创建表,读取表,删除,更新等等操作。
      4) Quota:限额,可以强制一个命名空间可包含的 Region 的数量。

    案列实操:

    查看命名空间列表
    hbase(main):007:0> list_namespace
    
    创建新的命名空间
    hbase(main):008:0> create_namespace 'bigdata'
    
    在新的命名空间中创建表
    hbase(main):009:0> create 'bigdata:student','info'
    
    删除新的命名空间
    hbase(main):008:0> drop_namespace 'bigdata'
    注意:删除命名空间之前,该命名空间中要不存在任何表。否则,不能删除!
    

    第5章 HBase 原理

    5.1 读流程

    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,再返回给客户端
    • 注意:新版本的 HBase 中没有 ROOT 表。

    5.2 写流程

    Hbase 写流程如下图所示:

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

    5.3 数据 Flush 过程

    • 1)当 MemStore 数据达到阈值(默认是128M,老版本是64M),将数据刷写到硬盘,将内存中的数据删除,同时删除 HLog 中的历史数据;
    • 2)并将数据存储到 HDFS 中;
    • 3)在 HLog 中做标记点。
    • 注意:HBase 数据 Flush 触发时机:
      • (1) 当 MemStore 数据达到阈值(默认是128M,老版本是64M)。即单个 Region 里 Memstore 的缓存大小,超过那么整个 HRegion 就会 flush,默认 128M。
      • (2) RegionServer 的全局 Memstore 的大小,超过该大小会触发 flush 到磁盘的操作,默认是堆大小的 40%,而且 Regionserver 级别的 flush 会阻塞客户端读写。
      • (3) 内存中的文件在自动刷新之前能够存活的最长时间,默认是1h。
      • (4) HLog 日志文件的大小达到 1G 时也会触发 flush 到磁盘的操作。

    5.4 数据合并过程

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

    我的GitHub地址:https://github.com/heizemingjun
    我的博客园地址:https://www.cnblogs.com/chenmingjun
    我的蚂蚁笔记博客地址:https://blog.leanote.com/chenmingjun
    Copyright ©2018~2019 黑泽君
    【转载文章务必保留出处和署名,谢谢!】

    展开全文
  • HBase 基本原理

    2018-06-14 11:49:07
    HBase 基本原理,出版于 2014,HBase is a NoSQL database that primarily works on top of Hadoop. HBase is based on the storage architecture followed by the BigTable. HBase inherits the storage design ...
  • hbase架构原理及其安装部署

    一、什么是HBase

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

     HBase 是Google Bigtable 的开源实现,与Google Bigtable 利用GFS作为其文件存储系统类似, HBase 利用Hadoop HDFS 作为其文件存储系统;Google 运行MapReduce 来处理Bigtable中的海量数据, HBase 同样利用hadoop MapReduce来处理HBase中的海量数据;Google Bigtable 利用Chubby作为协同服务, HBase 利用Zookeeper作为对应。

    二、HBase 设计模型

       HBase 中的每一张表就是所谓的 BigTable。BigTable 会存储一系列的行记录,行记录有三个基本类型的定义:Row Key、Time Stamp、Column。

    1、Row Key 是行在 BigTable 中的唯一标识。

    2、Time Stamp 是每次数据操作对应关联的时间戳,可以看做 SVN 的版本。

    3、Column 定义为< family>:< label>,通过这两部分可以指定唯一的数据的存储列,family 的定义和修改需要 对 HBase 进行类似于 DB 的 DDL 操作,而 label ,不需要定义直接可以使用,这也为动态定制列提供了一种手段 。family 另一个作用体现在物理存储优化读写操作上,同 family 的数据物理上保存的会比较临近,因此在业务设计的过程中可以利用这个特性。

    1、逻辑存储模型

       HBase 以表的形式存储数据。表由行和列组成。列划分为若干个列族(row family),如下图所示。 
            这里写图片描述

    下面是对表中元素的详细解析: 
    Row Key

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

    1 通过单个row key访问

    2 通过row key的range

    3 全表扫描

    Row key行键 (Row key)可以是任意字符串(最大长度是 64KB,实际应用中长度一般为 10-100bytes),在hbase内部,row key保存为字节数组。

    存储时,数据按照Row key的字典序(byte order)排序存储。设计key时,要充分排序存储这个特性,将经常一起读取的行存储放到一起。(位置相关性)

    注意: 
    1、字典序对int排序的结果是1,10,100,11,12,13,14,15,16,17,18,19,2,20,21,…,9,91,92,93,94,95,96,97,98,99。要保持整形的自然序,行键必须用0作左填充。 
    2、行的一次读写是原子操作 (不论一次读写多少列)。

    列族

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

      访问控制、磁盘和内存的使用统计都是在列族层面进行的。实际应用中,列族上的控制权限能 帮助我们管理不同类型的应用:我们允许一些应用可以添加新的基本数据、一些应用可以读取基本数据并创建继承的列族、一些应用则只允许浏览数据(甚至可能因 为隐私的原因不能浏览所有数据)。

    时间戳

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

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

    Cell

    由{row key, column( = + 

    2、物理存储模型

      Table 在行的方向上分割为多个HRegion,每个HRegion分散在不同的RegionServer中。 
          这里写图片描述 
      每个HRegion由多个Store构成,每个Store由一个memStore和0或多个StoreFile组成,每个Store保存一个Columns Family  
          这里写图片描述

    StoreFile以HFile格式存储在HDFS中。

    三、HBase 存储架构

      从HBase的架构图上可以看出,HBase中的存储包括HMaster、HRegionServer、HRegion、Store、MemStore、StoreFile、HFile、HLog等, 以下是 HBase 存储架构图: 
       
    这里写图片描述  

      HBase中的每张表都通过行键按照一定的范围被分割成多个子表(HRegion),默认一个HRegion超过256M就要被分割成两个,这个过程由HRegionServer管理,而HRegion的分配由HMaster管理。

    HMaster的作用: 
       1、 为Region server分配region。 
       
       2、 负责Region server的负载均衡。

       3、发现失效的Region server并重新分配其上的region。

      4、 HDFS上的垃圾文件回收。

       5、 处理schema更新请求。

    HRegionServer作用: 
       
       1、 维护master分配给他的region,处理对这些region的io请求。

       2、 负责切分正在运行过程中变的过大的region。

       可以看到,client访问hbase上的数据并不需要master参与(寻址访问zookeeper和region server,数据读写访问region server),master仅仅维护table和region的元数据信息(table的元数据信息保存在zookeeper上),负载很低。 HRegionServer存取一个子表时,会创建一个HRegion对象,然后对表的每个列族创建一个Store实例,每个Store都会有一个MemStore和0个或多个StoreFile与之对应,每个StoreFile都会对应一个HFile, HFile就是实际的存储文件。因此,一个HRegion有多少个列族就有多少个Store。 一个HRegionServer会有多个HRegion和一个HLog。

    HRegion

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

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

       1、< 表名,startRowkey,创建时间>

       2、由目录表(-ROOT-和.META.)记录该region的endRowkey

       HRegion定位:Region被分配给哪个Region Server是完全动态的,所以需要机制来定位Region具体在哪个region server。 
       HBase使用三层结构来定位region:

       1、 通过zk里的文件/hbase/rs得到-ROOT-表的位置。-ROOT-表只有一个region。

      2、通过-ROOT-表查找.META.表的第一个表中相应的region的位置。其实-ROOT-表是.META.表的第一个region;.META.表中的每一个region在-ROOT-表中都是一行记录。 
       
     3、通过.META.表找到所要的用户表region的位置。用户表中的每个region在.META.表中都是一行记录。

       -ROOT-表永远不会被分隔为多个region,保证了最多需要三次跳转,就能定位到任意的region。client会将查询的位置信息保存缓存起来,缓存不会主动失效,因此如果client上的缓存全部失效,则需要进行6次网络来回,才能定位到正确的region,其中三次用来发现缓存失效,另外三次用来获取位置信息。 
       
    Store 
       
      每一个region由一个或多个store组成,至少是一个store,hbase会把一起访问的数据放在一个store里面,即为每个ColumnFamily建一个store,如果有几个ColumnFamily,也就有几个Store。一个Store由一个memStore和0或者多个StoreFile组成。 HBase以store的大小来判断是否需要切分region。  
       
    MemStore

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

       memStore内存中的数据写到文件后就是StoreFile,StoreFile底层是以HFile的格式保存。 
    HFile

       HBase中KeyValue数据的存储格式,是hadoop的二进制格式文件。 首先HFile文件是不定长的,长度固定的只有其中的两块:Trailer和FileInfo。Trailer中有指针指向其他数据块的起始点,FileInfo记录了文件的一些meta信息。 Data Block是hbase io的基本单元,为了提高效率,HRegionServer中有基于LRU的block cache机制。每个Data块的大小可以在创建一个Table的时候通过参数指定(默认块大小64KB),大号的Block有利于顺序Scan,小号的Block利于随机查询。每个Data块除了开头的Magic以外就是一个个KeyValue对拼接而成,Magic内容就是一些随机数字,目的是防止数据损坏,结构如下。 
     这里写图片描述 
    HFile结构图如下: 
    这里写图片描述

      Data Block段用来保存表中的数据,这部分可以被压缩。 Meta Block段(可选的)用来保存用户自定义的kv段,可以被压缩。 FileInfo段用来保存HFile的元信息,不能被压缩,用户也可以在这一部分添加自己的元信息。 Data Block Index段(可选的)用来保存Meta Blcok的索引。 Trailer这一段是定长的。保存了每一段的偏移量,读取一个HFile时,会首先读取Trailer,Trailer保存了每个段的起始位置(段的Magic Number用来做安全check),然后,DataBlock Index会被读取到内存中,这样,当检索某个key时,不需要扫描整个HFile,而只需从内存中找到key所在的block,通过一次磁盘io将整个 block读取到内存中,再找到需要的key。DataBlock Index采用LRU机制淘汰。 HFile的Data Block,Meta Block通常采用压缩方式存储,压缩之后可以大大减少网络IO和磁盘IO,随之而来的开销当然是需要花费cpu进行压缩和解压缩。(备注: DataBlock Index的缺陷。 a) 占用过多内存 b) 启动加载时间缓慢)

    HLog 
      HLog(WAL log):WAL意为write ahead log,用来做灾难恢复使用,HLog记录数据的所有变更,一旦region server 宕机,就可以从log中进行恢复。 
    LogFlusher 
      定期的将缓存中信息写入到日志文件中 
    LogRoller  
       对日志文件进行管理维护  

    四、Hbase 的部署安装步骤

    安装 HBase 有两种方式,单机安装和分布式安装。 

    1、 单机安装

       HBase 需要再 Hadoop 环境运行,因此安装HBase 的前提是必须安装 Hadoop 环境。Hadoop 环境的安装可以参考 http://blog.csdn.net/u010330043/article/details/51235373 。下载与Hadoop2.2.0 相匹配的hbase-0.98.11-hadoop2-bin.tar.gz 软件包。 
       
    HBase 的安装步骤如下所示。

    步骤一 解压hbase-0.98.11-hadoop2-bin.tar.gz 到指定的目录下(这里是在/usr/Java),并将权限分配给hadoop用户(运行hadoop的账户)。

    这里下载的是hbase-0.98.11-hadoop2,Hadoop集群使用的是2.2.0,将其解压到/usr/java下并重命名为 hbase

    [root@cs0 java]$ tar -zxvf hbase-0.98.11-hadoop2-bin.tar.gz
    [root@cs0 java]$ mv hbase-0.98.11-hadoop2 hbase
    [root@cs0 java]$ chown -R hadoop:hadoop hbase
     
    • 1
    • 2
    • 3
    • 1
    • 2
    • 3

    步骤二 配置 HBase 的环境变量到 /etc/profile 文件中。

    [root@cs0 java]$ vi /etc/profile
    HBASE_HOME=/usr/java/hbase
    PATH=$JAVA_HOME/bin:$HIVE_HOME/bin:$HADOOP_HOME/bin:$HBASE_HOME/bin:$PATH
     
    • 1
    • 2
    • 3
    • 1
    • 2
    • 3

    使配置文件立即生效。

    [root@cs0 tmp]# source /etc/profile
     
    • 1
    • 1

    步骤三 修改 conf/hbase-env.sh。

           1) 去掉 JAVA_HOME 前的 “#”,并将其修改成自己安装的 Java 路径。
    
            2) 去掉 HBASE_MANAGES_ZK 前的 “#”,并设置其值为 true(HBase 管理自己的 ZooKeeper,这样就不需要安装 ZooKeeper)。
     
    • 1
    • 2
    • 3
    • 1
    • 2
    • 3

    步骤四 打开 conf/hbase-site.xml,添加如下内容。

      hbase.rootdir 需要与之前安装的 Hadoop 目录下 conf/core-site.xml 文件中的 fs.default.name 属性值对应。

    fs.default.name 设置为hdfs://ywendeng:9000/
    hbase.rootdir 设置为hdfs://ywendeng:9000/hbase
    hbase.ZooKeeper.quorum 设置为 ywendeng
    hbase.tmp.dir 设置为之前创建的 tmp 目录:/usr/java/hbase/tmp
    
    代码如下:
    <configuration>
    <property>
        <name>fs.default.name</name>
        <value>hdfs://cs:9000/</value>
    </property>
    <property>
        <name>hbase.rootdir</name>
        <value>hdfs://cs:9000/hbase</value>
    </property>
    <property>
        <name>hbase.ZooKeeper.quorum</name>
        <value>cs</value>
    </property>
    <property>
        <name>hbase.tmp.dir</name>
        <value>/home/hadoop/data/hbase_${user.name}</value>
    </property>
    </configuration>
    
    
     
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26

    步骤五 启动HBase(前提已经启动 Hadoop)。

    [hadoop@cs0 conf]$ start-hbase.sh
     
    • 1
    • 1

    步骤六 在Hbase启动成功之后,在浏览器中输入网址 192.168.80.128:60010(备注: 192.168.1.128 为安装HBase 虚拟机的IP地址)

    2、分布式安装

    步骤一 上传hbase安装包

    步骤二 解压

    步骤三 配置hbase集群,要修改3个文件(首先zk集群已经安装好了) 
    注意:要把hadoop的hdfs-site.xml和core-site.xml 放到hbase/conf下

    
        1、vim hbase-env.sh
        export JAVA_HOME=/usr/java/jdk1.7.0_55
        //告诉hbase使用外部的zk
        export HBASE_MANAGES_ZK=false
    
     
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    2、vim hbase-site.xml
        <configuration>
            <!-- 指定hbase在HDFS上存储的路径 -->
            <property>
                    <name>hbase.rootdir</name>
                    <value>hdfs://ns1/hbase</value>
            </property>
            <!-- 指定hbase是分布式的 -->
            <property>
                    <name>hbase.cluster.distributed</name>
                    <value>true</value>
            </property>
            <!-- 指定zk的地址,多个用“,”分割 -->
            <property>
                    <name>hbase.zookeeper.quorum</name>
                    <value>cs3:2181,cs4:2181,cs5:2181</value>
            </property>
        </configuration>
     
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    3、vim regionservers
        cs3
        cs4
        cs5
    
     
    • 1
    • 2
    • 3
    • 4
    • 5
    • 1
    • 2
    • 3
    • 4
    • 5
    4、拷贝hbase到其他节点
            scp -r  app/hbase-0.96.2-hadoop2/ cs2:/home/hadoop/app/
            scp -r app/hbase-0.96.2-hadoop2/  cs3: /home/hadoop/app/
            scp -r app/hbase-0.96.2-hadoop2/  cs4: /home/hadoop/app/
            scp -r app/hbase-0.96.2-hadoop2/  cs5: /home/hadoop/app/
     
    • 1
    • 2
    • 3
    • 4
    • 5
    • 1
    • 2
    • 3
    • 4
    • 5

    步骤四 启动所有的hbase

    分别启动zk
    ./zkServer.sh start
    启动hbase集群
    start-dfs.sh
    启动hbase,在主节点上运行:
    start-hbase.sh
     
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6

    步骤五 通过浏览器访问hbase管理页面

    192.168.80.128:60010
     
    • 1
    • 1

    步骤六 为保证集群的可靠性,要启动多个HMaster

     hbase-daemon.sh start master
    展开全文
  • 文章目录`HBase`存储原理、读写原理`HBase`存储原理(架构)`HBase`读原理`HBase`写原理 HBase存储原理(架构) HBase依赖于Zookeeper和Hadoop的,所以在启动HBase前需要启动Zookeeper和Hadoop。 HMaster用于管理...

    HBase存储原理、读写原理

    HBase存储原理(架构)

    外链图片转在这里插入图片描述存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ivJ3dS8b-1598538590608)(E:\003 NZ203\第二阶段\hbase\hbase.assets\004.png)

    HBase依赖于ZookeeperHadoop的,所以在启动HBase前需要启动ZookeeperHadoop

    HMaster用于管理整个HBase集群,即管理每个HRegionServer,它掌握着整个集群的元数据信息,同时会将相应的数据存储到Zookeeper(元数据信息、高可用信息等)。

    • HMaster的职责:
    • 1)管理用户对Table的增、删、改、查操作;
    • 2)记录 region在哪台 Hregion server 上;
    • 3)Region Split 后,负责新 Region 的分配;
    • 4)新机器加入时,管理 HRegion Server 的负载均衡,调整Region分布;
    • 5)HRegion Server 宕机后,负责失效 HRegion Server 上的Regions 迁移。

    HRegionServer是每台机器上的一个Java进程(一台机器只有一个HRegionServer进程),用来处理客户端的读写请求(和HadoopDataNode类似),并维护着元数据信息。

    • HRegionServer的职责:
    • 1) HRegion Server 主要负责响应用户I/O请求,向HDFS文件系统中读写数据,是 HBASE中最核心的模块。
    • 2) HRegion Server 管理了很多 table 的分区,也就是region

    每个HRegionServer有一个HLog(有且仅有一个)。HLog是操作日志,用来做灾难恢复的,当客户端发起一个写请求时,会先往HLog中写再往Memory Store中写。假设没有HLog,我们进行一个写请求,会首先写到Memory Store上,等到Memory Store到达一定容量后,才会flushStoreFile中。但是如果在这之前主机断电了呢?那这部分操作的数据全丢失了。这显然不是我们想到的结果,于是就有了HLog

    每个HRegionServer里面有多个HRegion,一个HRegion对应于HBase的一张表(也可能是表的一部分,因为表太大了会切分,表和HRegion的对应关系是一对多),当这张表到一定大小的时候会进行切分,切分成两个HRegion,切分出来的新的HRegion会保存到另一台机器上。每个HRegionServer里面有多个HRegion,可以理解为有多张表。

    每个HRegion里面有多个Store(一张表中有多个列族),一个Store对应于HBase一张表的一个列族,。按照这个原理,我们在设计列族的时候,可以把经常查询的列放在同一个列族,这样可以提高效率,因为同一个列族在同一个文件里面(不考虑切分)。

    每个Store有一个内存级别的存储Memory Store(有且仅有一个)。当Memory Store达到一定大小或一定时间后会进行数据刷写(flush),写到磁盘中(即HFile)。

    每个Store有多个磁盘级别的存储StoreFileMemory Store每刷写一次就形成一个StoreFileHFileStoreFileHDFS上的存储格式。

    HBase读原理

    在这里插入图片描述

    在上图中,我们模拟一下客户端读取数据过程,假设Zookeeper存放的meta表在RS1机器上,meta表存放的内容如下,Student表行键范围在1~100的存放在RS4上,在101~200的存放在RS3上,等等。

    外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-1o8Ap9F6-1598538590617)(C:\Users\Administrator\Desktop\1598538413702.png)

    客户端现在要读取Student表的第100行,具体步骤如下:

    1. 客户端向Zookeeper发起请求,请求元数据所在RegionServerZookeeper集群存放的是HBasemeta表所在位置。

    2. Zookeeper返回给客户端元数据所在RegionServer(即RS1)。

    3. 客户端收到应答后去请求RS1,请求查询Student表的rowkey=100数据所在位置。

    4.RS1上查询meta表可知该数据在RS4机器上,即返回给客户端rowkey所在位置(RS4)。

    5. 客户端收到应答后去请求RS4读数据。

    6. RS4查询数据返回给客户端。查询时先去内存(MemStore)查找,因为内存是最新的数据,如果找到了就返回结果,如果没找到则去缓存(cache)找,如果找到了就返回结果,如果还没找到就去磁盘(StoreFile)找,如果在磁盘找到了,则先将结果写入缓存(cache),再返回给客户端,写入缓存是为了下次查询提高效率。

    可以发现,在整个读过程中HMaster并没有参与,即读流程与HMaster无关,所以如果HMaster挂了,也是可以读数据的。

    HBase写原理

    外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-bCzezzCg-1598538590620)(C:\Users\Administrator\Desktop\1598538495780.png)

    HBase的写是比读快的,为什么呢,看下面的写过程,同样假设Zookeeper存放的meta表在RS1机器上,meta表存放的内容如下,Student表行键范围在1~100的存放在RS4上,在101~200的存放在RS3上,等等。

    外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-8meG2xl6-1598538590623)(C:\Users\Administrator\Desktop\1598538542043.png)

    客户端现在要插入数据给Student表,其中rowkey=100,具体步骤如下:

    1. 客户端向Zookeeper发起请求,请求元数据所在RegionServerZookeeper集群存放的是HBasemeta表所在位置。

    2. Zookeeper返回给客户端元数据所在RegionServer(即RS1)。

    3. 客户端收到应答后去请求RS1,请求查询Student表的rowkey=100数据所在位置。

    4.RS1上查询meta表可知该数据在RS2机器上,即返回给客户端rowkey所在位置(RS2)。

    5. 客户端收到应答后去请求RS4写入数据。

    6. RS2收到请求,先将数据写入HLog,再将数据写入MemStore,写入MemStore后就返回给客户端写入成功信息,此时,客户端的写流程完成了。

    因为写入内存就结束了写流程,不用访问磁盘,所以总体比读流程是快一点的。

    同样,在整个写流程中HMaster也没有参与,所以如果HMaster挂了,也是可以进行写数据的。但是,如果时间长了,表的大小一直变大,而HMaster却挂了,即不会触发Region切分,这样就会导致数据倾斜,系统就变得不安全了。

    以进行写数据的。但是,如果时间长了,表的大小一直变大,而HMaster却挂了,即不会触发Region切分,这样就会导致数据倾斜,系统就变得不安全了。**

    展开全文
  • HBase技术原理

    2021-02-23 22:36:10
    BigTable是一个分布式存储系统,BigTable起初...HBase是一个高可靠、高性能、面向列、可伸缩的分布式数据库,是谷歌BigTable的开源实现,主要用来存储非结构化和半结构化的松散数据。HBase的目标是处理非常庞大的表,可
  • HBase架构原理

    2020-12-21 23:15:17
    HBase一、HBase原理1.1 什么是NoSQL1.2 NoSQL和关系型数据库对比二、HBase概述2.1 特点三、HBase架构原理3.1 HBase架构三、数据存储结构四、HBase数据存储结构4.1 Rowkey四、数据读写流程 一、HBase原理 1.1 什么是...

    一、HBase原理

    1.1 什么是NoSQL

    NoSQL:not only SQL,非关系型数据库
    NoSQL是一个通用术语

    1. 指不遵循传统RDBMS模型的数据库
    2. 数据是非关系的,且不使用SQL作为主要查询语言
    3. 解决数据库的可伸缩性和可用性问题
    4. 不针对原子性或一致性问题

    1.2 NoSQL和关系型数据库对比

    主要有以下区别:
    在这里插入图片描述

    二、HBase概述

    HBase是一个领先的NoSQL数据库
    是一个面向列存储的NoSQL数据库
    是一个分布式Hash Map,底层数据是Key-Value格式
    使用HDFS作为存储并利用其可靠性

    2.1 特点

    1. 数据访问速度快,响应时间约2-20毫秒
    2. 支持随机读写,每个节点20k~100k+ ops/s
    3. 可扩展性,可扩展到20,000+节点
    4. 高并发

    三、HBase架构原理

    3.1 HBase架构

    HBase也是Master/slave架构,HBase安装成功后,是有一个HMaster,多个HResgionServer进程。 Master/slave架构的有:HDFS、YARN、Zookeeper、HBase,HBase架构如下所示:
    在这里插入图片描述

    从图中可以看出,HBase是由Client、Zookeeper、HMaster(主节点)、HRegionServer(从节点)、HDFS等几个组件组成。可以看出HBase底层是在HDFS上存储。

    1. Client:客户端,用来操作HBase的
    2. HMaster
      ①、主节点,一个集群中一般只有一个活跃的HMaster,多个HRegionServer
      ②、负责处理ResgionServer的故障转移,它会把这台RegionServer的数据转移给另外一台RegionServer,数据是存储在HDFS上,RegionServer其实是存储的地址,这些地址在HMaster上是有存储的,而HMaster只需要把这些存储的地址放到另外一台上就行。
      ③、负责region分裂后的分配,达到负载均衡,防止某一台RegionServer上的数据过多,别的节点数据很少。
      ④、维护了一部分的元数据,处理元数据的变更,类似于NameNode。
    3. RegionServer
      ①、负责处理客户端对数据的读写请求(实际干活的节点,响应客户端的读写),负责跟HDFS交互
      ②、处理HMaster分配给它的region,管理维护Region,负责存储,维护HLog
      ③、一个RegionServer包含一个WAL、一个BlockCache(读缓存)和多个Region
    4. HRegion
      ①、HRegion是HBase集群分布数据的最小单位,比如:一张表很大,可以分成很多,一个分片放在一个Region上,类似于HDFS中的Block
      ②、一个HRegion只能分配给一个RegionServer,不能跨多个 HRegionServer,可以类比于一个Block块只能放在一个DataNode上
      ③、一个Region中划分多个Store,这个Store可以理解为对应多个列族
      ④、MemStore:,可以理解为内存。写数据时,会先写到MemStore(128M)中,然后根据对应的列族找到相应的Store,超过128M会溢写到磁盘,形成一个一个StoreFile,底层是一个一个HFile。一个StoreFile在HDFS上对应一个HFile和一个列族
    5. Zookeeper
      ①、负责HRegionServer的监控的状态,看它有没有荡机或者变动。
      ②、客户端通过zookeeper获取存储在HBase上的元数据地址,看元数据在哪个HRegionServer上。
      ③、个人理解:如果有一个RegionServer荡机了,它只能监控,不能处理,所以它需要和HMaster保持通信,交由HMaster处理。
      6、Store:
      每一个Region内部,又分为多个Store,一个 Store 对应表中的一个列族。
      也就是说一个 Store 存储了对应表该列族下的部分数据。
      7、MemStore:
      顾名思义,就是内存存储,位于内存中,用来保存当前的数据操作,所以当数据保存在 WAL 中之后,HRegsionServer 会在内存中存储键值对。
      8、HFile
      这是在磁盘上保存原始数据的实际的物理文件,是实际的存储文件。StoreFile是以 HFile 的形式存储在 HDFS 的。文件内容是二进制。
      在这里插入图片描述

    三、HBase元数据管理

    1. 系统目录表:hbase:meta -> 存储元数据
      zookeeper也会存储一部分元数据信息,存储hbase:meta表的位置信息
    2. HBASE实际数据存储在HDFS上

    在这里插入图片描述
    图中有多个region,一个region中有多个列族,元数据信息都存储在系统目录表hbase.meta中,HBASE表存储在RegionServer上
    **打开HBASE网页
    **打开网页上的HBASE:xxxx.60010
    在这里插入图片描述
    hbase:meta表是存储元数据信息的
    hbase:namespace是存储命名空间的

    HBASE在HDFS上的目录结构
    从图中可以看出,元数据表是存储在RegionServer上的
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述

    四、HBase常用命令

    ##在hbase中输入错误删除是Ctrl+退格键
    命名空间类似hive中的数据库
    1、hbase shell:进入hbase

    hbase shell
    

    2、help:查看系统命令

    help
    

    3、version:查看版本

    version
    1.2.0-cdh5.14.2, rUnknown, Tue Mar 27 13:31:54 PDT 2018
    

    4、whoiam

    whoami
    root (auth:SIMPLE)
        groups: root
    

    5、status:查看进行的状态

    status
    => 1 active master, 0 backup masters, 1 servers, 0 dead, 6.0000 average load
    

    6、list:查看库和表

    list
    

    在这里插入图片描述
    7、create_namespace 库名

    create_namespace 'test'
    

    在这里插入图片描述
    8、create ‘库名:表名’,‘列族1’,‘列族2’

    create 'test:student','stu_info','basicinfo'
    

    在这里插入图片描述
    9、PUT ‘NAMESPACE:TABLE’,‘ROW_KEY_UNIQUE’,‘FAMILY:COLUMN’,‘VALUE’:导入数据

    put 'test:student','1','stu_info:name','lisi'
    

    10、get ‘NAMESPACE:TABLE’,‘FAMILY:COLUMN’:查看数据

    get 'test:student','1','stu_info:name'
    

    在这里插入图片描述
    问题:为什么hdfs下的hbase中这个列族下没有数据呢?
    原因:因为一开始数据写到MemStore中,没有达到一定的阈值,不会往磁盘里写,只写到内存,达到一定大小后会往磁盘里写。
    或者我们可以自动往磁盘里刷写,用flush

    在这里插入图片描述
    10、flush ‘NAMESPACE:TABLE’ :手动往磁盘里写数据

    flush 'test:student'
    

    这个时候,stu_info下就有数据了
    在这里插入图片描述
    11、hbase hfile -v -p -f hdfs下的路径到文件夹:如何去查看列族下这个文件

    hbase hfile -v -p -f /hbase/data/test/student/024f7320b31ce4b4ab49605d13cbffda/stu_info/41a2dae93aa74d098118f1beb47788ac
    

    在这里插入图片描述
    12、desc ‘NAMESPACE:TABLE’:查看表的信息

    desc 'test:student'
    

    在这里插入图片描述
    12、scan ‘NAMESPACE:TABLE’:扫描表数据

    put 'test:student','2','stu_info:name','lisi'
    scan 'test:student'
    

    在这里插入图片描述
    13、alter ‘库名:表名’,{列族,修改项}

    alter 'test:student',{stu_info=>'name',VERSION=>5}
    

    14、drop_namespace 命名空间

    drop namespace 'test'
    

    enabled说明这张表正在使用,要删除首先要disabled
    在这里插入图片描述
    15、count ‘命名空间:表’ :统计表数据行数

    count 'test:student'
    

    16、delete ‘命名空间:表’:删除数据

    deleteall 'test:student','1'    // 指定的rowkey
    

    只剩一条数据了
    在这里插入图片描述
    16、truncate 命名空间:表

    truncate 'test:student'
    

    先禁用,再清空
    在这里插入图片描述
    17、is_disabled:查看表是否处于禁用状态

    is_disabled 'test:student'
    

    说明清空完数据后它又把表enable打开了
    在这里插入图片描述
    18、drop ‘namespace:table’
            需要手动disabled

    drop 'test:student'
    

    在这里插入图片描述

    五、数据读写流程

    1、读数据流程:
    在这里插入图片描述

    1. 客户端向zookeeper发送请求,获取元数据所在的RegionServer。
    2. 返回客户端meta所在RegionServer位置信息
    3. 请求rowkey所在region,这个region在哪个RegionServer上(因为一张表分成了多个region,多个region可能在多个RegionServer上)
    4. 返回给客户端所在rowkey在哪个RegionServer上
    5. 客户端发送读请求给对应的RegionServer
      读数据中的一些细节:
      首先在Memstore中找数据,如果Memstore中没有找到,就去bloockcache中找数据,如果blockcache中还没有数据,说明就是落盘了,去StoreFile中读取数据。读到数据后,不会立即返回给客户端,加载到blockcache缓存中,再返回给客户端,下次直接从缓存中访问。

    在这里插入图片描述


    不建议使用scan
    原因:scan是把整张表往缓存中加,但是缓存是有限的,新数据加载到缓存中,原有数据可能因为内存原因被替换掉一部分

    2、写数据流程:
    在这里插入图片描述

    1. Client 访问 ZooKeeper,获取 元数据位置信息(hbase:meta)
    2. 返回客户端元数据位置信息
    3. 访问 Meta 表,然后读取 Meta 表中的数据。
    4. 根据 namespace(类似与关系型数据库中的数据库)表名和 RowKey 在 Meta 表中找到该 RowKey 应该写入到哪个Region。
    5. 找到这个 Region 对应的 RegionServer,并发送写数据请求
    6. HRegionServer 将数据先写到 HLog(Write Ahead Log)。为了数据的持 久化和恢复;HLog是先写到内存,logsync(同步进程)是每一秒把内存中的内存写到磁盘。
    7. HRegionServer 将数据写到内存(MemStore);
    8. 反馈 Client 写成功。
    9. 写数据这一块也可以看出,HBase 将数据写入到内存中后,就返回给客户端写入成功,响应非常快。这也是为什么 HBase
      写数据速度快的原因。
      (整个的读写流程和HMaster无关,比如:kill掉HMaster进程,读写数据都是可以的)

    六、数据Flush过程

    1. HBase写数据写入到MemStore内存就会返回客户端,没有直接落盘,因此磁盘IO小插入数据速度快
    2. 但当MenStore数据达到阀值(128M)时,HRS将数据刷到HDFS上生成HFile,然后将内存中的数据删除,同时删除HLog中的历史数据。
    3. 该操作由HRS自己完成。
    展开全文
  • 详解HBase架构原理

    2021-02-24 23:20:00
    HBase是一个高可靠、高性能、面向列、可伸缩的分布式存储系统,利用HBase技术可在廉价的PCServer上搭建大规模结构化存储集群。HBase是GoogleBigTable的开源实现,与GoogleBigTable利用GFS作为其文件存储系统类似,...
  • HBase底层原理

    千次阅读 2019-12-13 20:37:57
    HBase底层原理 系统架构: Client: 1 包含访问hbase的接口,client维护着一些cache来加快对hbase的访问,比如regione的位置信息。 Zookeeper: 1、zk的选举机制 保证任何时候,集群中只有一个master 2、 实时监控...
  • 客户端2.ZooKeeper3.HMaster4.HRegionServer5.HDFS6.Write-Ahead Logs7.HRegion8.Store9.MemStore10.HFile二.HBase数据存储结构1.RowKey2.Column Family3.Cell4.Time Stamp三.HBase原理1.元数据存储2.读流程3.写流程...
  • nosql&hbase;原理

    2018-08-03 14:45:56
    Nosql&hbase;原理,深度分析了为什么要用hbasehbase的优缺点,适用场景
  • 文章目录`HBase`存储原理、读写原理以及`flush`和合并过程`HBase`存储原理(架构)`HBase`读原理`HBase`写原理`HBase`数据`flush`刷写过程`HBase`数据`compaction`合并过程 HBase存储原理(架构) HBase依赖于...
  • HBase核心原理

    千次阅读 2020-06-25 16:08:41
    HBase的学习笔记 从集群搭建到理论知识,从理论知识到框架原理,从框架原理到项目实战 深入源码解析原理
  • hbase 学习 hbase原理 hbase资料 ,呕心沥血整理的。很实用,不适用可拍砖。。
  • HBase架构和原理 HBase 是列式存储,和 MySQL 的行式存储不一样。相比较而言,列式存储不会存储空数据,每行数据以key-value形式存储,可以同时存储上百万行 HBase 中有列簇概念,同一个列簇下的列存储在一起,在 ...
  • 深入HbaseHBase底层原理

    万次阅读 2020-03-23 15:56:16
    系统架构 Client 1.包含访问hbase的接口,client维护着一些cache
  • HBase StoreFile原理总结

    千次阅读 2020-09-01 17:20:52
    HBase StoreFile原理总结 1. StoreFile是什么 在hbase架构设计中,本身hbase基于hdfs进行数据存储。同时为了提升效率,数据会有一个memstore、block cache来做数据缓存,使用wal日志文件来防止内存数据丢失。但最终...
  • Hbase 原理 及其安装

    2016-11-27 10:02:50
    Hbase 基本原理 Hbase? HBase – Hadoop Database,是一个高可靠性、高性能、面向列、可伸缩的分布式存储系统,它存储的是松散型数据,具体来说,HBase存储的数据介于映射(key/value)和关系型数据之间。同时利用...
  • hbase存储原理

    千次阅读 2016-10-19 11:28:59
    Hbase 表结构设计注意问题: 见过程经验积累--数据库问题   Hbase每个cell插入时都会写入...HBase写入原理 1 客户端写入请求-->MemStore同时会写入Hlog,类似于Commit log,做数据恢复用 2 MemStore满足条件后刷入Stor
  • HBase安装

    2018-11-22 10:12:00
    HBase安装 目的 1.了解HBase安装流程 2.了解HBase的工作原理 原理 HBase是一个分布式的,面向列的开源数据库,该技术来源于Fay Chang所撰写的Google论文”Bigtable:一个结构化数据的分布式...
  • HBase: HBase底层原理

    千次阅读 2019-12-16 22:16:26
    Client : 包含访问hbase的接口,client维护着一些cache来加快对hbase的访问,比如regione的位置信息。 Zookeeper: 保证任何时候,集群中只有一个master 存贮所有Region的寻址入口 实时监控Region Server的状态,...
  • Hbase底层原理

    万次阅读 多人点赞 2019-12-17 18:13:38
    HBase基本介绍 简介 hbase是bigtable的开源java版本。是建立在hdfs之上,提供高可靠性、高性能、列存储、可伸缩、实时读写nosql的数据库系统。 它介于nosql和RDBMS之间,仅能通过主键(row key)和主键的range来检索...
  • Hbase内部原理

    千次阅读 2018-03-13 23:41:13
    系统架构Client: 包含访问hbase的接口,client维护着一些cache来加快对hbase的访问,比如region的位置信息。Zookeeper:1 保证任何时候,集群中只有一个master2 存贮所有Region的寻址入口----root表在哪台服务器上。...
  • 详解HBase架构原理安装部署步骤

    千次阅读 2016-05-02 10:34:41
    一、什么是HBase HBase 是一个高可靠、高性能、面向列、可伸缩的分布式存储系统,利用Hbase技术可在廉价PC Server上搭建 大规模结构化存储集群。 HBase 是Google Bigtable 的开源实现,与Google Bigtable 利用GFS...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 41,210
精华内容 16,484
关键字:

hbase安装的原理