– 亚秒级查询：预计算技术实现超快响应
– 标准SQL：支持ANSI SQL标准
– 多维分析：OLAP能力，支持多维聚合
– 大规模数据：支持PB级数据分析
– 可扩展性：支持水平扩展
– 安全性：支持Kerberos、LDAP等认证
– 可视化：集成Superset、Zeppelin等
– 多数据源：支持Hive、Kafka、MySQL等
– 云原生：支持对象存储和Spark Standalone
– 实时OLAP：支持流式数据摄入

Kylin架构组件：

组件 说明
REST Server REST API服务，提供查询和管理接口
Query Engine 查询引擎，基于Spark实现
Build Engine 构建引擎，负责Cube构建
Metadata Store 元数据存储，支持MySQL
Storage 存储层，Kylin 4使用Parquet
Cube 多维数据立方体，预计算结果
Model 数据模型，定义事实表和维度表

版本号 发布日期 说明
4.0.0 2021-XX-XX 最新稳定版，Parquet存储
4.0.0-beta 2021-XX-XX 测试版
4.0.0-alpha 2021-XX-XX 预览版
3.1.x 2020-XX-XX 旧版，HBase存储
3.0.x 2019-XX-XX 旧版，HBase存储

Kylin 4.0.0主要更新：
– 使用Parquet替代HBase存储
– 基于Spark的构建和查询引擎
– 支持Spark 3.1.1
– 计算存储分离架构
– 云原生支持
– 元数据升级工具
– 构建性能优化
– 查询性能优化

官方下载地址：

Kylin官网：https://kylin.apache.org/cn/
下载页面：https://kylin.apache.org/cn/download/
源码仓库：https://github.com/apache/kylin
文档中心：https://kylin.apache.org/docs40/
Docker镜像：https://hub.docker.com/r/apachekylin/kylin

下载Kylin 4.0.0（Spark 2.4.7版本）：
$ cd /fgeudb/software
$ wget https://archive.apache.org/dist/kylin/apache-kylin-4.0.0/apache-kylin-4.0.0-bin-spark2.tar.gz

输出示例如下：
–2026-04-04 10:00:00– https://archive.apache.org/dist/kylin/apache-kylin-4.0.0/apache-kylin-4.0.0-bin-spark2.tar.gz
Resolving archive.apache.org… 163.172.17.49
Connecting to archive.apache.org|163.172.17.49|:443… connected.
HTTP request sent, awaiting response… 200 OK
Length: 456789012 (435M) [application/octet-stream]
Saving to: ‘apache-kylin-4.0.0-bin-spark2.tar.gz’

apache-kylin-4.0.0-bin-spark2.tar.gz 100%[======================================================================>] 435.23M 15.6MB/s in 28s

2026-04-04 10:00:30 (15.6 MB/s) – ‘apache-kylin-4.0.0-bin-spark2.tar.gz’ saved [456789012/456789012]

下载Kylin 4.0.0（Spark 3.1.1版本）：
$ wget https://archive.apache.org/dist/kylin/apache-kylin-4.0.0/apache-kylin-4.0.0-bin-spark3.tar.gz

解压安装包：
$ tar -zxvf apache-kylin-4.0.0-bin-spark2.tar.gz -C /fgeudb/

创建软链接：
$ ln -s /fgeudb/apache-kylin-4.0.0-bin-spark2 /fgeudb/kylin

方式二：Docker容器部署

拉取官方镜像：
$ docker pull apachekylin/kylin:4.0.0

输出示例如下：
4.0.0: Pulling from apachekylin/kylin
Digest: sha256:abc123def456…
Status: Downloaded newer image for apachekylin/kylin:4.0.0

启动Kylin容器：
$ docker run –name kylin-server \
-p 7070:7070 \
-p 8080:8080 \
-v /fgeudb/kylin/conf:/opt/kylin/conf:ro \
-v /fgeudb/kylin/data:/opt/kylin/data \
-d apachekylin/kylin:4.0.0

输出示例如下：
abc123def456789…

查看容器状态：
$ docker ps | grep kylin

输出示例如下：
abc123def456 apachekylin/kylin:4.0.0 “/opt/kylin/bin/kyli…” 10 seconds ago Up 9 seconds 0.0.0.0:7070->7070/tcp, 0.0.0.0:8080->8080/tcp kylin-server

方式三：源码编译安装

下载源码：
$ git clone https://github.com/apache/kylin.git
$ cd kylin
$ git checkout kylin-4.0.0

编译源码：
$ ./build.sh

输出示例如下：
[INFO] Scanning for projects…
[INFO] ————————————————————————
[INFO] BUILD SUCCESS
[INFO] ————————————————————————
[INFO] Total time: 30:45 min
[INFO] Finished at: 2026-04-04T10:30:00+08:00
[INFO] ————————————————————————

编译产物位于：
./dist/apache-kylin-4.0.0-bin.tar.gz

安装JDK 8或11：
# yum install -y java-1.8.0-openjdk java-1.8.0-openjdk-devel

或Ubuntu/Debian：
# apt install -y openjdk-8-jdk

验证Java版本：
$ java -version

输出示例如下：
openjdk version “1.8.0_362”
OpenJDK Runtime Environment (build 1.8.0_362-b08)
OpenJDK 64-Bit Server VM (build 25.362-b08, mixed mode)

设置JAVA_HOME：
# vi /etc/profile.d/java.sh

export JAVA_HOME=/usr/lib/jvm/java-1.8.0-openjdk
export PATH=$JAVA_HOME/bin:$PATH

使配置生效：
$ source /etc/profile.d/java.sh

安装Hadoop（如果需要）：
$ cd /fgeudb/software
$ wget https://archive.apache.org/dist/hadoop/common/hadoop-3.3.1/hadoop-3.3.1.tar.gz
$ tar -zxvf hadoop-3.3.1.tar.gz -C /fgeudb/

安装Spark：
$ wget https://archive.apache.org/dist/spark/spark-2.4.7/spark-2.4.7-bin-hadoop2.7.tgz
$ tar -zxvf spark-2.4.7-bin-hadoop2.7.tgz -C /fgeudb/

安装MySQL（用于元数据存储）：
# yum install -y mysql-server
# systemctl start mysqld
# mysql -u root -p

创建Kylin数据库：
mysql> CREATE DATABASE kylin DEFAULT CHARACTER SET utf8mb4;
mysql> CREATE USER ‘kylin’@’%’ IDENTIFIED BY ‘kylin123’;
mysql> GRANT ALL PRIVILEGES ON kylin.* TO ‘kylin’@’%’;
mysql> FLUSH PRIVILEGES;

步骤2：配置Kylin环境变量

设置环境变量：
# vi /etc/profile.d/kylin.sh

export JAVA_HOME=/usr/lib/jvm/java-1.8.0-openjdk
export HADOOP_HOME=/fgeudb/hadoop-3.3.1
export SPARK_HOME=/fgeudb/spark-2.4.7-bin-hadoop2.7
export KYLIN_HOME=/fgeudb/kylin
export PATH=$JAVA_HOME/bin:$HADOOP_HOME/bin:$SPARK_HOME/bin:$KYLIN_HOME/bin:$PATH

使配置生效：
$ source /etc/profile.d/kylin.sh

步骤3：配置Kylin

修改kylin.properties：
# vi /fgeudb/kylin/conf/kylin.properties

服务器配置：
server.port=7070
server.mode=all
server.host=192.168.1.51

元数据配置：
kylin.metadata.url=kylin_metadata@jdbc,url=jdbc:mysql://192.168.1.51:3306/kylin,username=kylin,password=kylin123,maxActive=10,maxIdle=10

存储配置：
kylin.storage.url=/fgeudb/kylin/storage

Spark配置：
kylin.engine.spark-conf.spark.master=local[4]
kylin.engine.spark-conf.spark.executor.memory=4G
kylin.engine.spark-conf.spark.driver.memory=4G

查询配置：
kylin.query.memory-limit-bytes=1073741824
kylin.query.max-return-rows=500000

步骤4：启动Kylin

启动Kylin服务：
$ cd /fgeudb/kylin
$ ./bin/kylin.sh start

输出示例如下：
[2026-04-04 10:05:00,000][INFO] main org.apache.kylin.common.KylinConfig: Kylin configuration loaded from /fgeudb/kylin/conf/kylin.properties
[2026-04-04 10:05:00,100][INFO] main org.apache.kylin.rest.service.UserService: Creating default admin user
[2026-04-04 10:05:00,200][INFO] main org.apache.kylin.rest.service.UserService: Creating default modeler user
[2026-04-04 10:05:00,300][INFO] main org.apache.kylin.server.KylinServer: Kylin Server started on port 7070

查看服务状态：
$ ./bin/kylin.sh status

输出示例如下：
Kylin is running with pid 12345

停止服务：
$ ./bin/kylin.sh stop

步骤5：配置systemd服务

创建服务文件：
# vi /etc/systemd/system/kylin.service

[Unit]
Description=Apache Kylin Server
After=network.target mysql.service

[Service]
Type=forking
User=kylin
Group=kylin
Environment=”JAVA_HOME=/usr/lib/jvm/java-1.8.0-openjdk”
Environment=”KYLIN_HOME=/fgeudb/kylin”
ExecStart=/fgeudb/kylin/bin/kylin.sh start
ExecStop=/fgeudb/kylin/bin/kylin.sh stop
PIDFile=/fgeudb/kylin/logs/kylin.pid
LimitNOFILE=65535

[Install]
WantedBy=multi-user.target

重载服务配置：
# systemctl daemon-reload

启动服务：
# systemctl start kylin

设置开机自启：
# systemctl enable kylin

查看服务状态：
# systemctl status kylin

输出示例如下：
● kylin.service – Apache Kylin Server
Loaded: loaded (/etc/systemd/system/kylin.service; enabled)
Active: active (running) since Fri 2026-04-04 10:10:00 CST; 10s ago
Main PID: 12345 (java)
CGroup: /system.slice/kylin.service
└─12345 /usr/lib/jvm/java-1.8.0-openjdk/bin/java …

服务器配置：
server.port=7070 服务端口
server.mode=all 运行模式（all/query/job）
server.host=192.168.1.51 服务主机地址

元数据配置：
kylin.metadata.url=kylin_metadata@jdbc,url=jdbc:mysql://192.168.1.51:3306/kylin,username=kylin,password=kylin123

存储配置：
kylin.storage.url=/fgeudb/kylin/storage 存储路径
kylin.storage.parquet.compression=SNAPPY Parquet压缩格式

Spark配置：
kylin.engine.spark-conf.spark.master=yarn
kylin.engine.spark-conf.spark.executor.memory=8G
kylin.engine.spark-conf.spark.executor.cores=4
kylin.engine.spark-conf.spark.driver.memory=4G
kylin.engine.spark-conf.spark.executor.instances=4

查询配置：
kylin.query.memory-limit-bytes=2147483648 查询内存限制
kylin.query.max-return-rows=1000000 最大返回行数
kylin.query.security.enabled=true 启用安全认证

构建配置：
kylin.engine.default=2 构建引擎（2=Spark）
kylin.source.default=1 数据源（1=Hive）

Spark配置优化

生产环境Spark配置：
kylin.engine.spark-conf.spark.master=yarn
kylin.engine.spark-conf.spark.submit.deployMode=cluster
kylin.engine.spark-conf.spark.executor.memory=16G
kylin.engine.spark-conf.spark.executor.cores=4
kylin.engine.spark-conf.spark.driver.memory=8G
kylin.engine.spark-conf.spark.executor.instances=8
kylin.engine.spark-conf.spark.yarn.queue=kylin
kylin.engine.spark-conf.spark.dynamicAllocation.enabled=true
kylin.engine.spark-conf.spark.dynamicAllocation.maxExecutors=16
kylin.engine.spark-conf.spark.shuffle.service.enabled=true
kylin.engine.spark-conf.spark.sql.adaptive.enabled=true

访问Kylin Web UI：
打开浏览器访问：http://192.168.1.51:7070
默认用户名：ADMIN
默认密码：KYLIN

创建项目：
1. 登录Kylin Web UI
2. 点击右上角”系统” -> “项目”
3. 点击”+项目”
4. 输入项目名称：fgedu_project
5. 点击”确定”

步骤2：创建数据模型

创建数据模型：
1. 选择项目”fgedu_project”
2. 点击”建模” -> “数据模型”
3. 点击”+新建模型”
4. 选择数据源类型：Hive
5. 选择事实表：default.sales_fact
6. 选择维度表：default.dim_product, default.dim_customer
7. 定义维度列：
– 时间维度：sales_date
– 产品维度：product_id, product_name, category
– 客户维度：customer_id, customer_name, region
8. 定义度量列：
– sales_amount
– quantity
– profit
9. 点击”保存”

模型配置示例：
{
“name”: “sales_model”,
“fact_table”: “default.sales_fact”,
“lookups”: [
{
“table”: “default.dim_product”,
“join”: {
“type”: “left”,
“primary_key”: [“product_id”],
“foreign_key”: [“product_id”]
}
}
],
“dimensions”: [
{“column”: “sales_date”, “type”: “date”},
{“column”: “product_id”, “type”: “string”},
{“column”: “customer_id”, “type”: “string”}
],
“metrics”: [
{“column”: “sales_amount”, “type”: “sum”},
{“column”: “quantity”, “type”: “sum”}
]
}

步骤3：创建Cube

创建Cube：
1. 点击”建模” -> “Cube”
2. 点击”+新建Cube”
3. 选择数据模型：sales_model
4. 配置维度：
– 勾选需要预计算的维度组合
– 使用Cube Planner优化维度组合
5. 配置度量：
– SUM(sales_amount)
– COUNT(*)
– MAX(profit)
– MIN(profit)
6. 配置分区：
– 分区列：sales_date
– 分区格式：yyyy-MM-dd
7. 配置构建引擎：
– 选择Spark引擎
8. 点击”保存”

Cube配置示例：
{
“name”: “sales_cube”,
“model_name”: “sales_model”,
“dimensions”: [
{“name”: “sales_date”, “column”: “sales_date”},
{“name”: “product_id”, “column”: “product_id”},
{“name”: “customer_id”, “column”: “customer_id”}
],
“measures”: [
{“name”: “sales_amount”, “function”: “SUM”, “parameter”: “sales_amount”},
{“name”: “count”, “function”: “COUNT”, “parameter”: “1”}
],
“partition_date_column”: “sales_date”,
“partition_date_format”: “yyyy-MM-dd”
}

步骤4：构建Cube

构建Cube：
1. 选择Cube “sales_cube”
2. 点击”构建”
3. 选择数据范围：
– 开始日期：2026-01-01
– 结束日期：2026-03-31
4. 点击”提交”

查看构建进度：
1. 点击”监控” -> “任务”
2. 查看任务状态和进度

构建任务输出示例：
[2026-04-04 10:15:00] Job submitted, job_id: JOB_001
[2026-04-04 10:15:01] Step 1: Create Flat Hive Table – RUNNING
[2026-04-04 10:15:30] Step 1: Create Flat Hive Table – FINISHED
[2026-04-04 10:15:31] Step 2: Extract Fact Table – RUNNING
[2026-04-04 10:20:00] Step 2: Extract Fact Table – FINISHED
[2026-04-04 10:20:01] Step 3: Build Cube with Spark – RUNNING
[2026-04-04 10:45:00] Step 3: Build Cube with Spark – FINISHED
[2026-04-04 10:45:01] Job JOB_001 – FINISHED

执行SQL查询：
1. 点击”洞察” -> “查询”
2. 选择项目和Cube
3. 输入SQL语句：
SELECT
sales_date,
product_name,
SUM(sales_amount) as total_sales
FROM sales_cube
WHERE sales_date >= ‘2026-01-01’
GROUP BY sales_date, product_name
ORDER BY total_sales DESC
LIMIT 100

4. 点击”提交”

查询结果示例：
sales_date | product_name | total_sales
————-+————–+————-
2026-01-15 | Product A | 123456.78
2026-01-20 | Product B | 98765.43
2026-02-05 | Product C | 87654.32
…

查询耗时：0.15秒
扫描行数：0（命中Cube）

使用REST API查询

获取查询结果：
$ curl -X POST \
-H “Authorization: Basic QURNSU46S1lMSU4=” \
-H “Content-Type: application/json” \
-d ‘{
“sql”: “SELECT sales_date, SUM(sales_amount) FROM sales_cube GROUP BY sales_date”,
“project”: “fgedu_project”
}’ \
http://192.168.1.51:7070/kylin/api/query

输出示例如下：
{
“columnMetas”: [
{“label”: “SALES_DATE”, “columnType”: “char”},
{“label”: “SUM(SALES_AMOUNT)”, “columnType”: “decimal”}
],
“results”: [
[“2026-01-01”, “123456.78”],
[“2026-01-02”, “234567.89”],
[“2026-01-03”, “345678.90”]
],
“duration”: 150,
“totalScanCount”: 0
}

使用JDBC查询

下载Kylin JDBC驱动：
$ wget https://repo1.maven.org/maven2/org/apache/kylin/kylin-jdbc/4.0.0/kylin-jdbc-4.0.0.jar

Java连接示例：
import java.sql.*;

public class KylinQuery {
public static void main(String[] args) throws Exception {
String url = “jdbc:kylin://192.168.1.51:7070/fgedu_project”;
String user = “ADMIN”;
String password = “KYLIN”;

Connection conn = DriverManager.getConnection(url, user, password);
Statement stmt = conn.createStatement();

String sql = “SELECT sales_date, SUM(sales_amount) FROM sales_cube GROUP BY sales_date”;
ResultSet rs = stmt.executeQuery(sql);

while (rs.next()) {
System.out.println(rs.getString(1) + ” | ” + rs.getBigDecimal(2));
}

rs.close();
stmt.close();
conn.close();
}
}

查看进程状态：
$ ps -ef | grep kylin

输出示例如下：
kylin 12345 1 5 10:10 ? 00:00:30 /usr/lib/jvm/java-1.8.0-openjdk/bin/java …

查看端口监听：
$ netstat -tlnp | grep java

输出示例如下：
tcp6 0 0 :::7070 :::* LISTEN 12345/java

访问Web UI：
打开浏览器访问：http://192.168.1.51:7070

查看系统状态：
$ curl -u ADMIN:KYLIN http://192.168.1.51:7070/kylin/api/system/info

输出示例如下：
{
“version”: “4.0.0”,
“commit”: “abc123def”,
“status”: “GOOD”
}

查看Cube列表：
$ curl -u ADMIN:KYLIN http://192.168.1.51:7070/kylin/api/cubes?project=fgedu_project

输出示例如下：
[
{
“name”: “sales_cube”,
“status”: “READY”,
“size_kb”: 123456,
“input_records”: 10000000
}
]

性能测试

执行TPC-H测试：
1. 导入TPC-H数据到Hive
2. 创建TPC-H模型和Cube
3. 构建Cube
4. 执行查询测试

查询性能对比：
查询类型 无Cube耗时 有Cube耗时 提升倍数
简单聚合 30秒 0.1秒 300x
多表关联 120秒 0.2秒 600x
复杂分析 300秒 0.5秒 600x

症状：Cube构建任务失败

解决方案：
1. 查看构建日志：
$ tail -f /fgeudb/kylin/logs/kylin.log

2. 检查Spark任务日志：
访问Spark History Server

3. 检查数据源连接：
确保Hive表可访问

4. 检查资源：
确保YARN有足够资源

5. 检查维度组合：
减少维度组合数量

问题2：查询超时

症状：查询返回超时错误

解决方案：
1. 增加查询超时时间：
kylin.query.timeout=600

2. 检查Cube是否命中：
查看查询日志确认是否使用预计算结果

3. 优化维度组合：
添加常用查询的维度组合

4. 增加查询内存：
kylin.query.memory-limit-bytes=4294967296

问题3：存储空间不足

症状：Cube构建失败，磁盘空间不足

解决方案：
1. 清理过期Segment：
在Web UI中删除不需要的Segment

2. 启用数据压缩：
kylin.storage.parquet.compression=ZSTD

3. 优化维度组合：
减少不必要的维度组合

4. 定期清理：
运行StorageCleanupJob清理无用数据

Kylin管理命令

启动服务：
$ ./bin/kylin.sh start

停止服务：
$ ./bin/kylin.sh stop

重启服务：
$ ./bin/kylin.sh restart

查看状态：
$ ./bin/kylin.sh status

诊断检查：
$ ./bin/kylin.sh diagnose

元数据备份：
$ ./bin/metastore.sh backup

元数据恢复：
$ ./bin/metastore.sh restore /path/to/backup

清理存储：
$ ./bin/kylin.sh org.apache.kylin.tool.StorageCleanupJob

检查Cube：
$ ./bin/kylin.sh org.apache.kylin.tool.CubeMetaChecker