Spark 操作hbase(构建一个支持更新和快速检索的数据库)

一、背景

在用户画像的系统中，需要将用户ID的拉通结果表和用户标签的结果表存入Hbase中。
组件如下：

  1. Spark 2.0
  2. hbase 1.2 
  3. hadoop 2.6

因而提出以下几个问题：

1. 如何使用Spark 大批量地、快速地导入初始化数据？
2. 如何从Hbase 快速地、大批量地查询数据？
3. Hbase 的的存取效率和RowKey 设计，Region个数之间的关系？
4. 如何根据RowKey快速地、大批量地删除数据？
5. 如何解决版本兼容问题？
6. 如何实现Hbase Join 运算？

Spark 作为内存计算引擎强于计算，Hbase作为KV 数据存储强于存储。在数据仓库项目中，一般会将数据存储为parquet 来支持数据查询分析和后续应用，但包括hive,parquet 以及Spark 本身不支持对数据更新。因此，是否可以将Spark 视为数据库计算引擎，而Hbase 视为数据库底层的数据存储结构。从而实现一个基于Spark+Hbase 的支持数据更新和快速检索的“关系型数据库”？

二、实现

1. 使用Spark 批量导入数据到Hbase

  方案一：使用BulkPut, 通过Spark partition 并发的put 数据到Hbase
  方案二：使用Spark rdd 算子：saveAsNewAPIHadoopDataset
  方案三：预生成Hfile 文件，使用doBulkLoad 加载到Hbase Region

3.0 版本的Hbase 由于已经集成了Spark-on hbase。同时支持方案一和方案二。
若是sbt 项目，可再build.sbt 中配置如下依赖
"org.apache.hbase" % "hbase-spark" % "2.0.0-alpha3"
然后调用对应的API即可。或者参考https://mvnrepository.com/artifact/org.apache.hbase/hbase-spark/2.0.0-alpha3 路径配置最新的依赖。

但是可能会存在问题：

1. 当前hbase 集群版本为 1.2.0 。在集成Spark On Hbase 包之后，该依赖包最低支持的hbase 2.0.0-alpha-1 因此会存在版本兼容的问题。
2. spark On hbase 引用了hbase 服务端的类，这些类通过依赖无法下载
3. spark on hbase 是用Logging 类spark 1.3 以后的版本已经不在支持。
4. 目前不需要应用spark-stream on hbase, 代码和依赖很冗余

因此需要对 hbase-Spark 进行改造，以便支持在目前的版本下运行。
从hbase-spark 源码和实例中可看到批量的操作都基于一个类：
因而重写HbaseContext

2. Spark 从Hbase 快速检索的方法

  方案一：通过并发得Get 检索数据，Spark 对数据分区，创建Get,获取数据
  方案二：通过Scan 全表扫描Hbase 数据

BulkGet 的思路是对Spark RDD 数据分区，构建检索的Hbase RowKey,
再充分利用Spark天然的分布式内存计算优势，并发的Get 数据。当需要平衡好 从Hbase 中没批返回得数据量。过多会造成网络拥塞，过少会造成频繁得创建Hbase RPC，数据返回缓慢。
Scan 得思路是创建和Hbase 表region 个数一致的 spark 分区，每个分区接受一个region 的数据。通过关闭Scan 过程 参数setCacheBlocks(false) 达到近视直接扫描Hbase 底层Hfile 文件的性能。

3. Hbase Join 的问题

  方案一：通过bulkGet 获取指定数据嵌套循环或广播
  方案二：通过快速Scan 利用SparkSQL 实现Join 运算

如果Scan的足够快，读取Hbase 数据如同读取parquet. 因此，提高Scan 速度，再转换为Spark SQL 就可以解决Hbase 不支持join 运算的问题

封装HbaseETL

功能特色

1. Spark 快速大批量得存取 Hbase
2. 支持隐式的RDD 调用
3. Hbase的快速扫描和SparkSQL 实现Hbase Join

性能说明：

在一个 3台 64c,128G 内存上的hbase 集群上测试：

1. BulkLoad 一个40G 文件 4分钟（regions = 50实际时间和region 个数有关）
2. bulkGet 10000000 条数据从1 的表中时间为 1 分钟
3. bulkDelete 10000000 调数据从1 的表中时间为 1 分钟

使用方法

sbt 打包引入到项目中，参照 HbaseSuit 实现

使用场景

1. Hbase 作为前端数据快速检索的数据库
   • 数据源为hive 表
   • 数据源为关系型数据库
   • 参考DataBaseSuit.scala 实现

例如将hive 表的数据增量写入到Hbase

  def insertOrUpdate = {
    val rdd = spark.read.table("").rdd
    hc.bulkLoadThinRows[Row](rdd,
      tableName,
      r => {
        val rawPK = new StringBuilder
        for(c<- table_PK) rawPK.append(r.getAs[String](c))
        val rk = rowKeyByMD5(rawPK.toString)
        val familyQualifiersValues = new FamiliesQualifiersValues
        val fq = familyQualifierToByte
        for(c<- fq) {
          val family = c._1
          val qualifier = c._2
          val value = Bytes.toBytes(r.getAs[String](c._3))
          familyQualifiersValues += (family, qualifier, value)
        }
        (new ByteArrayWrapper(rk), familyQualifiersValues)
      },
      10)
  }

2. Hbase 作为支持数据检索、更新的Spark运行数据库
   • bulkLoad 更新
   • bulkGet 查询，Spark SQL Join 解决Hbase 不支持Join 的问题
   • BulkDelete 数据删除
   • 参考 HbaseSuit.scala 实现

例如向Hbase 批量导入数据

def initDate() = {
    // 清空，并重新创建表
    createTable
    // 准备数据，rdd 处理
    import spark.implicits._
    val rdd = spark.sql("select * from hive.graph").map(x => {
      val sid = x.getString(0)
      val id = x.getString(1)
      val idType = x.getString(3)
      (sid, id, idType)
    }).rdd
    // bulk load
    hc.bulkLoadThinRows[(String, String, String)](rdd,
      "lenovo:GRAPH",
      t => {
        val rowKey = rowKeyByMD5(t._2, t._3)
        val familyQualifiersValues = new FamiliesQualifiersValues
        val pk = t._2 + "|" + t._3
        // Hbase 存入两列，一列 PK 存 业务主键，一列 s 存 superid
        val column = List(("pk", pk), ("s", t._1))
        column.foreach(f => {
          val family: Array[Byte] = Bytes.toBytes(columnFamily.head)
          val qualifier = Bytes.toBytes(f._1)
          val value: Array[Byte] = Bytes.toBytes(f._2)
          familyQualifiersValues += (family, qualifier, value)
        })
        (new ByteArrayWrapper(rowKey), familyQualifiersValues)
      },
      10
    )
  }

3. ETL工具
   • 封装的初始程序
   • bulkGet
   • bulkDelete

例如作为ETL工具操作Hbase

// Hbase 表定义
  val nameSpace = "lenovo"
  val tableName = "GRAPH"
  val columnFamily = Seq("cf")
  // 获取源表得Schema 信息
  val columns = spark.sql("select * from hive.graph").schema.map(_.name)
  val schema = Schema(nameSpace,tableName,columnFamily,columns,50)
  val data = spark.sql("select * from hive.graph").rdd
  // (sid:String,id:String,idType:String)
  // 创建Hbase Table 实例
   val ht = HbaseTable(spark,hc,schema)
  // 初始化数据测试
  ht.tableInit[Row](data,mkRowKey,mkHbaseRow)
  // 构造HbaseTable的rowkey 规则
  def mkRowKey(r:Row):Array[Byte] = {
    // 业务要求 id+idtype 的Md5 作为主键
    val rawRK = r.getAs[String]("id") + r.getAs[String]("idType")
    rowKeyByMD5(rawRK)
  }
  // 构造HbaseTable的row的规则
  def mkHbaseRow(r:Row):FamiliesQualifiersValues = {
    val rk = this.mkRowKey(r)
    val familyQualifiersValues = new FamiliesQualifiersValues
    var i = 0
    for(c<-schema.familyQualifierToByte.toList) {
      val family = c._1
      val qualifier = c._2
      val value: Array[Byte] = schema.strToBytes(r.getString(i))
      familyQualifiersValues += (family, qualifier, value)
      i = i + 1
    }
    familyQualifiersValues
  }

4. Hbase Join 问题
   • 快速的Scan
   • 使用Spark SQL解决Hbase Join 问题

例如

 // 快速Scan 获取Hbase 数据
 ht.tableInit[Row](data, mkRowKey, mkHbaseRow)
  
 //SparkSQL 实现 Join 
  import spark.implicits._
  // fixme Scan 返回得结构为SparkRow
  val t1 = ht.hbaseScan.toDF("id","idtype")
  val t2 = spark.sql("select * from t1")
  
  val join = t1.join(t2,Seq("id","idtype"))

声明

1. 该ETL工具改造自 hbase-Spark 并对其中BulkLoad 方法重新实现
2. 如有任务问题请联系作者邮箱 [email protected]

Github 上实现：https://github.com/Smallhi/example