大数据最佳实践-Kylin

概述

Apache Kylin是一个开源的分布式分析引擎，提供Hadoop/Spark之上的SQL查询接口及多维分析（OLAP）能力以支持超大规模数据，最初由eBay开发并贡献至开源社区。它能在亚秒内查询巨大的Hive表。
Apache Kylin 是一个开源的分布式分析引擎，提供 Hadoop/Spark 之上的 SQL 查询接口
及多维分析（OLAP）能力以支持超大规模数据，最初由 eBay Inc 开发并贡献至开源社区。
它能在亚秒内查询巨大的 Hive 表。

特点

Kylin的主要特点包括支持SQL接口、支持超大规模数据集、亚秒级响应、可伸缩性、高吞吐率、BI工具集成等。
1）标准SQL接口：Kylin是以标准的SQL作为对外服务的接口。
2）支持超大数据集：Kylin对于大数据的支撑能力可能是目前所有技术中最为领先的。早在2015年eBay的生产环境中就能支持百亿记录的秒级查询，之后在移动的应用场景中又有了千亿记录秒级查询的案例。
3）亚秒级响应：Kylin拥有优异的查询相应速度，这点得益于预计算，很多复杂的计算，比如连接、聚合，在离线的预计算过程中就已经完成，这大大降低了查询时刻所需的计算量，提高了响应速度。
4）可伸缩性和高吞吐率：单节点Kylin可实现每秒70个查询，还可以搭建Kylin的集群。
5）BI工具集成
Kylin可以与现有的BI工具集成，具体包括如下内容。
ODBC：与Tableau、Excel、PowerBI等工具集成
JDBC：与Saiku、BIRT等Java工具集成
RestAPI：与JavaScript、Web网页集成
Kylin开发团队还贡献了Zepplin的插件，也可以使用Zepplin来访问Kylin服务。
缺点：随着维度增多cuboid 会指数级增长，需要对cube进行剪枝优化

分层

架构

REST Server

REST Server 是一套面向应用程序开发的入口点，旨在实现针对 Kylin 平台的应用开发
工作。 此类应用程序可以提供查询、获取结果、触发 cube 构建任务、获取元数据以及获取
用户权限等等。另外可以通过 Restful 接口实现 SQL 查询。

Query Engine

当 cube 准备就绪后，查询引擎就能够获取并解析用户查询。它随后会与系统中的其它
组件进行交互，从而向用户返回对应的结果。

Routing

在最初设计时曾考虑过将 Kylin 不能执行的查询引导去 Hive 中继续执行，但在实践后
发现 Hive 与 Kylin 的速度差异过大，导致用户无法对查询的速度有一致的期望，很可能大
多数查询几秒内就返回结果了，而有些查询则要等几分钟到几十分钟，因此体验非常糟糕。
最后这个路由功能在发行版中默认关闭。□×▶

元数据管理工具（Metadata）

Kylin 是一款元数据驱动型应用程序。元数据管理工具是一大关键性组件，用于对保存
在 Kylin 当中的所有元数据进行管理，其中包括最为重要的 cube 元数据。其它全部组件的
正常运作都需以元数据管理工具为基础。 Kylin 的元数据存储在 hbase 中。

任务引擎（Cube Build Engine）

这套引擎的设计目的在于处理所有离线任务，其中包括 shell 脚本、Java API 以及 MapReduce 任务等等。任务引擎对 Kylin 当中的全部任务加以管理与协调，从而确保每一项任务
都能得到切实执行并解决其间出现的故障。

Kylin 特点

Kylin 的主要特点包括支持 SQL 接口、支持超大规模数据集、亚秒级响应、可伸缩性、
高吞吐率、BI 工具集成等。
1）标准 SQL 接口：Kylin 是以标准的 SQL 作为对外服务的接口。
2）支持超大数据集：Kylin 对于大数据的支撑能力可能是目前所有技术中最为领先的。
早在 2015 年 eBay 的生产环境中就能支持百亿记录的秒级查询，之后在移动的应用场景中
又有了千亿记录秒级查询的案例。
3）亚秒级响应：Kylin 拥有优异的查询相应速度，这点得益于预计算，很多复杂的计算，
比如连接、聚合，在离线的预计算过程中就已经完成，这大大降低了查询时刻所需的计算量，
提高了响应速度。
4）可伸缩性和高吞吐率：单节点 Kylin 可实现每秒 70 个查询，还可以搭建 Kylin 的集
群。
5）BI 工具集成
Kylin 可以与现有的 BI 工具集成，具体包括如下内容。
ODBC：与 Tableau、Excel、PowerBI 等工具集成
JDBC：与 Saiku、BIRT 等 Java 工具集成
RestAPI：与 JavaScript、Web 网页集成
Kylin 开发团队还贡献了 Zepplin 的插件，也可以使用 Zepplin 来访问 Kylin 服务。

Kylin 依赖环境

安装 Kylin 前需先部署好 Hadoop、Hive、Zookeeper、HBase，并且需要在/etc/profile 中
配置以下环境变量 HADOOP_HOME，HIVE_HOME，HBASE_HOME，记得 source 使其生
效。

Kylin 依赖于 Hadoop 集群处理大量的数据集。您需要准备一个配置好 HDFS，YARN，MapReduce，Hive， HBase，Zookeeper 和其他服务的 Hadoop 集群供 Kylin 运行。
Kylin 可以在 Hadoop 集群的任意节点上启动。方便起见，您可以在 master 节点上运行 Kylin。但为了更好的稳定性，我们建议您将 Kylin 部署在一个干净的 Hadoop client 节点上，该节点上 Hive，HBase，HDFS 等命令行已安装好且 client 配置（如 core-site.xml，hive-site.xml，hbase-site.xml及其他）也已经合理的配置且其可以自动和其它节点同步。
运行 Kylin 的 Linux 账户要有访问 Hadoop 集群的权限，包括创建/写入 HDFS 文件夹，Hive 表， HBase 表和提交 MapReduce 任务的权限。

Kylin 搭建

1）上传 Kylin 安装包 apache-kylin-3.0.1-bin.tar.gz
2）解压 apache-kylin-3.0.1-bin.tar.gz 到/opt/module
[atguigu@hadoop102 sorfware]$ tar -zxvf apache-kylin-3.0.1-
bin.tar.gz -C /opt/module/
[atguigu@hadoop102 module]$ mv /opt/module/apache-kylin-3.0.1-bin
/opt/module/kylin

Kylin 兼容性问题解决

1.kylin 启动时会从 hbase classpath 命令的输出中寻找 hbase-common-.jar。但是自 hbase2.1
之后，hbase classpath 的输出不在包含 hbase-common-.jar，取而代之的是 hbase-shadedclient*.jar，故需要做以下修改。
1）修改/opt/module/kylin/bin/find-hbase-dependency.sh
[atguigu@hadoop102 sorfware]$ vim /opt/module/kylin/bin/findhbase-dependency.sh
修改内容如下：

arr=(`echo $hbase_classpath | cut -d ":" -f 1- | sed 's/:/ /g'`)
hbase_common_path=
for data in ${arr[@]}
do
	result=`echo $data | grep -E 'hbase-(common|shaded\-client)[a-z0-9A-Z\.-]*jar' | grep -v tests`
	 if [ $result ]
	 then
		 hbase_common_path=$data
	 fi
done

2.Kylin 启动之后的 classpath 会包含 hbase lib 目录下的所有 jar 包，由于之前安装 phoenix
时，向 hbase 的 lib 目录中加入了 phoenix 的 jar 包，导致 kylin 与其发生冲突，故需要做以
下修改，将 phoenix 的 jar 包排除在 kylin 的 classpath 之外。
1）复制/opt/module/hbase/bin/hbase 脚本，命名为 hbase_kylin
cp /opt/module/hbase/bin/hbase /opt/module/hbase/bin/hbase_kylin
2）修改/opt/module/hbase/bin/hbase_kylin，内容如下
270 else
271 for f in $HBASE_HOME/lib/*.jar; do
272 result=echo $f | grep -v phoenix
273 if [ $result];then274CLASSPATH=${CLASSPATH}:$f;
275 fi
276 done
277 # make it easier to check for shaded/not later on.

3）修改/opt/module/kylin/bin/kylin.sh
start_command="hbase_kylin ${KYLIN_EXTRA_START_OPTS} \

2.2.4 Kylin 启动

（1）启动 Kylin 之前，需先启动 Hadoop（hdfs，yarn，jobhistoryserver）、Zookeeper、Hbase
（2）启动 Kylin
[atguigu@hadoop102 kylin]$ bin/kylin.sh start
启动之后查看各个节点进程：

• hadoop102 ----------------
  3360 JobHistoryServer
  31425 HMaster
  3282 NodeManager
  3026 DataNode
  53283 Jps
  2886 NameNode
  44007 RunJar
  2728 QuorumPeerMain
  31566 HRegionServer
  --------------------- hadoop103 ----------------
  5040 HMaster
  2864 ResourceManager
  9729 Jps
  2657 QuorumPeerMain
  4946 HRegionServer
  2979 NodeManager
  2727 DataNode
  --------------------- hadoop104 ----------------
  4688 HRegionServer
  2900 NodeManager
  9848 Jps
  2636 QuorumPeerMain
  2700 DataNode
  2815 SecondaryNameNode

在 http://hadoop102:7070/kylin 查看 Web 页面

用户名为：ADMIN，密码为：KYLIN
5）关闭 Kylin
[atguigu@hadoop102 kylin]$ bin/kylin.sh stop

Kafka 流构建 Cube

(Near RT Streaming)

1. 这是由于Kylin 会记录每一个 build 的 offsets；当收到一个 build 请求，它将会从上一个结束的位置开始，然后从 Kafka 获取最新的 offsets。第一次没有数据时，没有offset则会报错

缺点：无法在消费时进行过滤，消费数据必须是配置好的json数据，格式或者字段改变会报Error: java.lang.RuntimeException: org.apache.kylin.job.shaded.com.fasterxml.jackson.databind.exc.MismatchedInputException
Kafka 里已经有一组历史 message 且您不想从最开始 build，您可以触发一个调用来将当前的结束位置设为 cube 的开始:

curl -X PUT --user ADMIN:KYLIN -H “Content-Type: application/json;charset=utf-8” -d ‘{ “sourceOffsetStart”: 0, “sourceOffsetEnd”: 9223372036854775807, “buildType”: “BUILD”}’ http://localhost:7070/kylin/api/cubes/{your_cube_name}/init_start_offsets

任务执行出现异常时

Kafka数据查询
1.粒度查询（可查询分钟、小时、日、周、月、年）根据消息数据携带的timestamp划分

数据存储
基于mapreduce计算引擎的任务会根据kylin中创建的model在hive建表

Hbase表

维度和度量

增量构建

使用

以 gmall 数 据 仓 库 中 的 dwd_payment_info 作 为 事 实 表 ， dwd_order_info_his 、
dwd_user_info 作为维度表，构建星型模型，并演示如何使用 Kylin 进行 OLAP 分析。

创建工程
1）点击下图中的"+"。

2）填写项目名称和描述信息，并点击 Submit 按钮提交。

2.2.2 获取数据源
1）点击 DataSource

2）点击下图按钮导入 Hive 表

3）选择所需数据表，并点击 Sync 按钮

2.2.3 创建 model
1）点击 Models，点击"+New"按钮，点击"★New Model"按钮

2）填写 Model 信息，点击 Next

3）指定事实表

4）选择维度表，并指定事实表和维度表的关联条件，点击 Ok

维度表添加完毕之后，点击 Next

5）指定维度字段，并点击 Next

6）指定度量字段，并点击 Next

7）指定事实表分区字段（仅支持时间分区），点击 Save 按钮，model 创建完毕

构建 cube
1）点击 new， 并点击 new cube

2）填写 cube 信息，选择 cube 所依赖的 model，并点击 next

3）选择所需的维度，如下图所示

4）选择所需度量值，如下图所示

4）cube 自动合并设置，cube 需按照日期分区字段每天进行构建，每次构建的结果会保存在
Hbase 中的一张表内，为提高查询效率，需将每日的 cube 进行合并，此处可设置合并周期。
5）Kylin 高级配置（优化相关，暂时跳过）

6）Kylin 相关属性配置覆盖

7）Cube 信息总览，点击 Save，Cube 创建完成

8）构建 Cube（计算），点击对应 Cube 的 action 按钮，选择 build
9）选择要构建的时间区间，点击 Submit

10）点击 Monitor 查看构建进度

使用进阶

1）每日全量维度表及拉链维度表重复 Key 问题如何处理
按照上述流程，会发现，在 cube 构建流程中出现以下错误

错误原因分析：
上述错误原因是 model 中的维度表 dwd_dim_user_info_his 为拉链表、dwd_dim_sku_info
为每日全量表，故使用整张表作为维度表，必然会出现订单表中同一个 user_id 或者 sku_id
对应多条数据的问题，针对上述问题，有以下两种解决方案。
方案一：在 hive 中创建维度表的临时表，该临时表中只存放维度表最新的一份完整的
数据，在 kylin 中创建模型时选择该临时表作为维度表。
方案二：与方案一思路相同，但不使用物理临时表，而选用视图（view）实现相同的功
能。

此处采用方案二：
（1）创建维度表视图
（2）在 DataSource 中导入新创建的视图，之前的维度表，可选择性删除。

（3）重新创建 model、cube。
（4）查询结果

2）如何实现每日自动构建 cube
Kylin 提供了 Restful API，因次我们可以将构建 cube 的命令写到脚本中，将脚本交给
azkaban 或者 oozie 这样的调度工具，以实现定时调度的功能。
脚本如下:

#!/bin/bash
cube_name=order_cube
do_date=`date -d '-1 day' +%F`
#获取 00:00 时间戳
start_date_unix=`date -d "$do_date 08:00:00" +%s`
start_date=$(($start_date_unix*1000))
#获取 24:00 的时间戳
stop_date=$(($start_date+86400000))
curl -X PUT -H "Authorization: Basic QURNSU46S1lMSU4=" -H 
'Content-Type: application/json' -d '{"startTime":'$start_date', 
"endTime":'$stop_date', "buildType":"BUILD"}' 
http://hadoop102:7070/kylin/api/cubes/$cube_name/build

Kylin Cube 构建原理

维度和度量
维度：即观察数据的角度。比如员工数据，可以从性别角度来分析，也可以更加细化，
从入职时间或者地区的维度来观察。维度是一组离散的值，比如说性别中的男和女，或者时
间维度上的每一个独立的日期。因此在统计时可以将维度值相同的记录聚合在一起，然后应
用聚合函数做累加、平均、最大和最小值等聚合计算。
度量：即被聚合（观察）的统计值，也就是聚合运算的结果。比如说员工数据中不同性
别员工的人数，又或者说在同一年入职的员工有多少。

Cube 和 Cuboid
有了维度跟度量，一个数据表或者数据模型上的所有字段就可以分类了，它们要么是维
度，要么是度量（可以被聚合）。于是就有了根据维度和度量做预计算的 Cube 理论。
给定一个数据模型，我们可以对其上的所有维度进行聚合，对于 N 个维度来说，组合`
的所有可能性共有 2
n 种。对于每一种维度的组合，将度量值做聚合计算，然后将结果保存
为一个物化视图，称为 Cuboid。所有维度组合的 Cuboid 作为一个整体，称为 Cube。
下面举一个简单的例子说明，假设有一个电商的销售数据集，其中维度包括时间[time]、
商品[item]、地区[location]和供应商[supplier]，度量为销售额。那么所有维度的组合就有 2
4 =
16 种，如下图所示：
二维度（2D）的组合有：[time, item]、[time, location]、[time,supplier]、[item, location]、
[item, supplier]、[location, supplier]3 种；
三维度（3D）的组合也有 4 种；
最后还有零维度（0D）和四维度（4D）各有一种，总共 16 种。

每一种维度组合就是一个 Cuboid，16 个 Cuboid 整体就是一个 Cube。

Cube 存储原理

Cube 构建算法

1）逐层构建算法（layer）

我们知道，一个 N 维的 Cube，是由 1 个 N 维子立方体、N 个(N-1)维子立方体、N*(N-
1)/2 个(N-2)维子立方体、…、N 个 1 维子立方体和 1 个 0 维子立方体构成，总共有 2^N 个
子立方体组成，在逐层算法中，按维度数逐层减少来计算，每个层级的计算（除了第一层，
它是从原始数据聚合而来），是基于它上一层级的结果来计算的。比如，[Group by A, B]的
结果，可以基于[Group by A, B, C]的结果，通过去掉 C 后聚合得来的；这样可以减少重复计
算；当 0 维度 Cuboid 计算出来的时候，整个 Cube 的计算也就完成了。
每一轮的计算都是一个 MapReduce 任务，且串行执行；一个 N 维的 Cube，至少需要 N
次 MapReduce Job。

Cube 逐层构建算法

算法优点：
1）此算法充分利用了 MapReduce 的优点，处理了中间复杂的排序和 shuffle 工作，故而
算法代码清晰简单，易于维护；
2）受益于 Hadoop 的日趋成熟，此算法非常稳定，即便是集群资源紧张时，也能保证最
终能够完成。

算法缺点：
1）当 Cube 有比较多维度的时候，所需要的 MapReduce 任务也相应增加；由于 Hadoop
的任务调度需要耗费额外资源，特别是集群较庞大的时候，反复递交任务造成的额外开销会
相当可观；
2）由于 Mapper 逻辑中并未进行聚合操作，所以每轮 MR 的 shuffle 工作量都很大，导
致效率低下。
3）对 HDFS 的读写操作较多：由于每一层计算的输出会用做下一层计算的输入，这些
Key-Value 需要写到 HDFS 上；当所有计算都完成后，Kylin 还需要额外的一轮任务将这些
文件转成 HBase 的 HFile 格式，以导入到 HBase 中去；
总体而言，该算法的效率较低，尤其是当 Cube 维度数较大的时候。

2）快速构建算法（inmem）

也被称作“逐段”(By Segment) 或“逐块”(By Split) 算法，从 1.5.x 开始引入该算法，该算
法的主要思想是，每个 Mapper 将其所分配到的数据块，计算成一个完整的小 Cube 段（包
含所有 Cuboid）。每个 Mapper 将计算完的 Cube 段输出给 Reducer 做合并，生成大 Cube，
也就是最终结果。如图所示解释了此流程。

与旧算法相比，快速算法主要有两点不同：
1）Mapper 会利用内存做预聚合，算出所有组合；Mapper 输出的每个 Key 都是不同的，
这样会减少输出到 Hadoop MapReduce 的数据量，Combiner 也不再需要；
2）一轮 MapReduce 便会完成所有层次的计算，减少 Hadoop 任务的调配。

Kylin Cube 构建优化

使用衍生维度（derived dimension）
衍生维度用于在有效维度内将维度表上的非主键维度排除掉，并使用维度表的主键（其
实是事实表上相应的外键）来替代它们。Kylin 会在底层记录维度表主键与维度表其他维度
之间的映射关系，以便在查询时能够动态地将维度表的主键“翻译”成这些非主键维度，并
进行实时聚合。

虽然衍生维度具有非常大的吸引力，但这也并不是说所有维度表上的维度都得变成衍生
维度，如果从维度表主键到某个维度表维度所需要的聚合工作量非常大，则不建议使用衍生
维度。

使用聚合组（Aggregation group）

聚合组（Aggregation Group）是一种强大的剪枝工具。聚合组假设一个 Cube 的所有维
度均可以根据业务需求划分成若干组（当然也可以是一个组），由于同一个组内的维度更可
能同时被同一个查询用到，因此会表现出更加紧密的内在关联。每个分组的维度集合均是
Cube 所有维度的一个子集，不同的分组各自拥有一套维度集合，它们可能与其他分组有相
同的维度，也可能没有相同的维度。每个分组各自独立地根据自身的规则贡献出一批需要被
物化的 Cuboid，所有分组贡献的 Cuboid 的并集就成为了当前 Cube 中所有需要物化的 Cuboid
的集合。不同的分组有可能会贡献出相同的 Cuboid，构建引擎会察觉到这点，并且保证每一
个 Cuboid 无论在多少个分组中出现，它都只会被物化一次。

对于每个分组内部的维度，用户可以使用如下三种可选的方式定义，它们之间的关系，
具体如下。
1）强制维度（Mandatory），如果一个维度被定义为强制维度，那么这个分组产生的所
有 Cuboid 中每一个 Cuboid 都会包含该维度。每个分组中都可以有 0 个、1 个或多个强制维
度。如果根据这个分组的业务逻辑，则相关的查询一定会在过滤条件或分组条件中，因此可
以在该分组中把该维度设置为强制维度。

2）层级维度（Hierarchy），每个层级包含两个或更多个维度。假设一个层级中包含 D1，
D2…Dn 这 n 个维度，那么在该分组产生的任何 Cuboid 中，这 n 个维度只会以（），（D1），
（D1，D2）…（D1，D2…Dn）这 n+1 种形式中的一种出现。每个分组中可以有 0 个、1 个
或多个层级，不同的层级之间不应当有共享的维度。如果根据这个分组的业务逻辑，则多个
维度直接存在层级关系，因此可以在该分组中把这些维度设置为层级维度。

3）联合维度（Joint），每个联合中包含两个或更多个维度，如果某些列形成一个联合，
那么在该分组产生的任何 Cuboid 中，这些联合维度要么一起出现，要么都不出现。每个分
组中可以有 0 个或多个联合，但是不同的联合之间不应当有共享的维度（否则它们可以合并
成一个联合）。如果根据这个分组的业务逻辑，多个维度在查询中总是同时出现，则可以在
该分组中把这些维度设置为联合维度。

这些操作可以在 Cube Designer 的 Advanced Setting 中的 Aggregation Groups 区域完成，
如下图所示。
聚合组的设计非常灵活，甚至可以用来描述一些极端的设计。假设我们的业务需求非常
单一，只需要某些特定的 Cuboid，那么可以创建多个聚合组，每个聚合组代表一个 Cuboid。
具体的方法是在聚合组中先包含某个 Cuboid 所需的所有维度，然后把这些维度都设置为强
制维度。这样当前的聚合组就只能产生我们想要的那一个 Cuboid 了。
再比如，有的时候我们的 Cube 中有一些基数非常大的维度，如果不做特殊处理，它就
会和其他的维度进行各种组合，从而产生一大堆包含它的 Cuboid。包含高基数维度的 Cuboid

在行数和体积上往往非常庞大，这会导致整个 Cube 的膨胀率变大。如果根据业务需求知道
这个高基数的维度只会与若干个维度（而不是所有维度）同时被查询到，那么就可以通过聚
合组对这个高基数维度做一定的“隔离”。我们把这个高基数的维度放入一个单独的聚合组，
再把所有可能会与这个高基数维度一起被查询到的其他维度也放进来。这样，这个高基数的
维度就被“隔离”在一个聚合组中了，所有不会与它一起被查询到的维度都没有和它一起出现
在任何一个分组中，因此也就不会有多余的 Cuboid 产生。这点也大大减少了包含该高基数
维度的 Cuboid 的数量，可以有效地控制 Cube 的膨胀率。

Row Key 优化

Kylin 会把所有的维度按照顺序组合成一个完整的 Rowkey，并且按照这个 Rowkey 升序
排列 Cuboid 中所有的行。
设计良好的 Rowkey 将更有效地完成数据的查询过滤和定位，减少 IO 次数，提高查询
速度，维度在 rowkey 中的次序，对查询性能有显著的影响。
1）被用作过滤的维度放在前边。

2）基数大的维度放在基数小的维度前边。

并发粒度优化

当 Segment 中某一个 Cuboid 的大小超出一定的阈值时，系统会将该 Cuboid 的数据分片
到多个分区中，以实现 Cuboid 数据读取的并行化，从而优化 Cube 的查询速度。具体的实现
方式如下：构建引擎根据 Segment 估计的大小，以及参数“kylin.hbase.region.cut”的设置决定
Segment 在存储引擎中总共需要几个分区来存储，如果存储引擎是 HBase，那么分区的数量
就对应于 HBase 中的 Region 数量。kylin.hbase.region.cut 的默认值是 5.0，单位是 GB，也就
是说对于一个大小估计是 50GB 的 Segment，构建引擎会给它分配 10 个分区。用户还可以
通过设置kylin.hbase.region.count.min（默认为1）和kylin.hbase.region.count.max（默认为500）
两个配置来决定每个 Segment 最少或最多被划分成多少个分区

由于每个 Cube 的并发粒度控制不尽相同，因此建议在 Cube Designer 的 Configuration
Overwrites（上图所示）中为每个 Cube 量身定制控制并发粒度的参数。假设将把当前 Cube
的 kylin.hbase.region.count.min 设置为 2，kylin.hbase.region.count.max 设置为 100。这样无论
Segment 的大小如何变化，它的分区数量最小都不会低于 2，最大都不会超过 100。相应地，
这个 Segment 背后的存储引擎（HBase）为了存储这个 Segment，也不会使用小于两个或超
过 100 个的分区。我们还调整了默认的 kylin.hbase.region.cut，这样 50GB 的 Segment 基本上
会被分配到 50 个分区，相比默认设置，我们的 Cuboid 可能最多会获得 5 倍的并发量

Kylin BI 工具集成

可以与 Kylin 结合使用的可视化工具很多，例如：
ODBC：与 Tableau、Excel、PowerBI 等工具集成
JDBC：与 Saiku、BIRT 等 Java 工具集成
RestAPI：与 JavaScript、Web 网页集成
Kylin 开发团队还贡献了 Zepplin 的插件，也可以使用 Zepplin 来访问 Kylin 服务。

JDBC
1）新建项目并导入依赖


org.apache.kylin
kylin-jdbc
2.5.1


2）编码

package com.atguigu;
import java.sql.*;
public class TestKylin {
 public static void main(String[] args) throws Exception {
 //Kylin_JDBC 驱动
 String KYLIN_DRIVER = "org.apache.kylin.jdbc.Driver";
 //Kylin_URL
 String KYLIN_URL = 
"jdbc:kylin://hadoop102:7070/FirstProject";
 //Kylin 的用户名
 String KYLIN_USER = "ADMIN";
 //Kylin 的密码
 String KYLIN_PASSWD = "KYLIN";
 //添加驱动信息
 Class.forName(KYLIN_DRIVER);
 //获取连接
 Connection connection = 
DriverManager.getConnection(KYLIN_URL, KYLIN_USER, KYLIN_PASSWD);
 //预编译 SQL
 PreparedStatement ps = connection.prepareStatement("SELECT 
sum(sal) FROM emp group by deptno");
 //执行查询
 ResultSet resultSet = ps.executeQuery();
 //遍历打印
 while (resultSet.next()) {
 System.out.println(resultSet.getInt(1));
 }
 }
}

Zepplin

1）Zepplin 安装与启动
（1）将 zeppelin-0.8.0-bin-all.tgz 上传至 Linux
（2）解压 zeppelin-0.8.0-bin-all.tgz 之/opt/module
[atguigu@hadoop102 sorfware]$ tar -zxvf zeppelin-0.8.0-bin-all.tgz
-C /opt/module/
（3）修改名称
[atguigu@hadoop102 module]$ mv zeppelin-0.8.0-bin-all/ zeppelin
（4）启动
[atguigu@hadoop102 zeppelin]$ bin/zeppelin-daemon.sh start
可登录网页查看，web 默认端口号为 8080
可登录网页查看，web 默认端口号为 8080
http://hadoop102:8080

2）配置 Zepplin 支持 Kylin
（1）点击右上角 anonymous 选择 Interpreter

（2）搜索 Kylin 插件并修改相应的配置

（3）修改完成点击 Save 完成

3）案例实操
需求：查询员工详细信息，并使用各种图表进行展示
（1）点击 Notebook 创建新的 note

（2）填写 Note Name 点击 Create


（3）执行查询

（4）结果展示

（5）其他图表格式

kylin剪枝优化的两种方式

1.衍生维度。

在kylin中，如果某些维度都属于同一种类型，且数量较多，可以考虑做成衍生维度。

衍生维度就是将一批维度做成一张维度表，只在源表中保留这张表的外键，这样预处理的时候，就只会处理这个外键，而不会去处理维度表中的维度，降低cuboid的数量。

衍生维度用于在有效维度内将维度表上的非主键维度排除掉，在查询的时候实时进行聚合。

用衍生维度需要注意的一点是：如果从维度表主键到某个维度表维度所需要的聚合工作量非常大，那就不适合做衍生维度，实时进行聚合的时候会等待过长的时间。

2.使用聚合组

聚合组是一种强大的剪枝工具。系统会按照聚合组去预处理cuboid，不在聚合组或跨组的cuboid都不会产生。

每个分组维度集合均是cube所有维度的一个子集。

所有分组贡献的cuboid就是当前cube所有需要物化的cuboid。

由于聚合组内的维度可以重复，因此不同的聚合组会产生相同的cuboid，kylin引擎会保证他们只物化一次。

在聚合组内，你可以对维度进行以下设置：

1.设置成强制维度。这样该聚合组产生的cuboid都要有这个维度。

打个比方，该聚合组里有a,b,c三个维度，将a设置成强制维度，则该聚合组会产生 a，ab，ac,abc 4种cuboid，

而不会产生b , c , bc 这三个cuboid，减少了3个。

2.设置成层级维度。如果一个聚合组的维度中有层级关系，比如省–市–区–街道，就可以设置层级维度。

层级维度不允许子层级出现的时候父层级不出现，比如，你可以 group by 省，市 但是你不能 group by 市， 也不能 group by 省 ，区

举例，该聚合组有 a b c 三个维度 且设置成层级维度 a>b>c. 则该聚合组会产生 a, ab, abc 三个cuboid

不会产生 b，c，bc，ac 这4个cuboid，减少了4个。

3.设置成联合维度，这些维度要么一起出现，要么都不出现。

举例，该聚合组有 a b c 三个维度，且设置 ab为联合维度，则该聚合组会产生 c，ab，abc 三个cuboid

而不会产生 a，b ，ac，bc， 减少了4个。

Rowkey编码