大数据开发工程师-第十三周 综合项目:电商数据仓库之商品订单数仓2

发表于 | 分类于 ， | 浏览 次
字数统计: 5.8k | 阅读时长 ≈ 23

第十三周 综合项目:电商数据仓库之商品订单数仓2

拉链表

什么是拉链表

1
2
3
4
针对订单表、订单商品表，流水表，这些表中的数据是比较多的，如果使用全量的方式，会造成大量的数据冗余，浪费磁盘空间。
所以这种表，一般使用增量的方式，每日采集新增的数据。

在这注意一点：针对订单表，如果单纯的按照订单产生时间增量采集数据，是有问题的，因为用户可能今天下单，明天才支付，但是Hive是不支持数据更新的，这样虽然MySQL中订单的状态改变了，但是Hive中订单的状态还是之前的状态。
1
2
3
4
想要解决这个问题，一般有这么几种方案：
第一种：每天全量导入订单表的数据，这种方案在项目启动初期是没有多大问题的，因为前期数据量不大，但是随着项目的运营，订单量暴增，假设每天新增1亿订单，之前已经累积了100亿订单，如果每天都是全量导入的话，那也就意味着每天都需要把数据库中的100多亿订单数据导入到HDFS中保存一份，这样会极大的造成数据冗余，太浪费磁盘空间了。
第二种：只保存当天的全量订单表数据，每次在导入之前，删除前一天保存的全量订单数据，这种方式虽然不会造成数据冗余，但是无法查询订单的历史状态，只有当前的最新状态，也不太好。
第三种：拉链表，这种方式在普通增量导入方式的基础之上进行完善，把变化的数据也导入进来，这样既不会造成大量的数据冗余，还可以查询订单的历史状态。
1
2
3
拉链表是针对数据仓库设计中表存储数据的方式而定义的，顾名思义，所谓拉链，就是记录历史。记录一个事物从开始，一直到当前状态的所有历史变化的信息。

下面就是一张拉链表，存储的是用户的最基本信息以及每条记录的生命周期。我们可以使用这张表拿到当天的最新数据以及之前的历史数据

image-20230406151532551

1
2
3
4
5
6
7
8
9
10
11
说明：
start_time表示该条记录的生命周期开始时间，end_time 表示该条记录的生命周期结束时间；
end_time = '9999-12-31'表示该条记录目前处于有效状态；

如果查询当前所有有效的记录，则使用 SQL
select * from user where end_time ='9999-12-31'

如果查询2026-01-02的历史快照【获取指定时间内的有效数据】，则使用SQL
select * from user where start_time <= '2026-01-02' and end_time >= '2026-01-02'

这就是拉链表。

如何制作拉链表

1
2
3
4
5
6
7
8
9
10
11
12
那针对我们前面分析的订单表，希望使用拉链表的方式实现数据采集，因为每天都保存全量订单数据比较浪费磁盘空间，但是只采集增量的话无法反应订单的状态变化。
所以需要既采集增量，还要采集订单状态变化了的数据。
针对订单表中的订单状态字段有这么几个阶段
未支付
已支付
未发货
已发货
在这我们先分析两种状态：未支付和已支付。

我们先举个例子：
假设我们的系统是2026年3月1日开始运营的
那么到3月1日结束订单表所有数据如下：

image-20230406152722507

image-20230406152831907

1
2
3
4
5
6
基于订单表中的这些数据如何制作拉链表？

实现思路
1：首先针对3月1号中的订单数据构建初始的拉链表，拉链表中需要有一个start_time(数据生效开始时间)和end_time(数据生效结束时间)，默认情况下start_time等于表中的创建时间，end_time初始化为一个无限大的日期9999-12-31
将3月1号的订单数据导入到拉链表中。
此时拉链表中数据如下：

image-20230406153103346

1
2
3
4
5
6
7
2：在3月2号的时候，需要将订单表中发生了变化的数据和新增的订单数据 整合到之前的拉链表中
此时需要先创建一个每日更新表，将每日新增和变化了的数据保存到里面

然后基于拉链表和这个每日更新表进行left join，根据订单id进行关联，如果可以关联上，就说明这个订单的状态发生了变化，然后将订单状态发生了变化的数据的end_time改为2026-03-01(当天日期-1天)
然后再和每日更新表中的数据执行union all操作，将结果重新insert到拉链表中

最终拉链表中的数据如下：

image-20230406153453757

1
2
3
4
解释：
因为在3月2号的时候，订单id为001的数据的订单状态发生了变化，所以拉链表中订单id为001的原始数据的end_time需要修改为2026-03-01，
然后需要新增一条订单id为001的数据，订单状态为已支付，start_time为2026-03-02，end_time为9999-12-31。
还需要将3月2号新增的订单id为003的数据也添加进来。

【实战】基于订单表的拉链表实现

1
2
3
4
5
6
下面我们开始实现：
1：首先初始化2026-03-01、2026-03-02和2026-03-03的订单表新增和变化的数据，ods_user_order(直接将数据初始化到HDFS中)，这个表其实就是前面我们所说的每日更新表

注意：这里模拟使用sqoop从mysql中抽取新增和变化的数据，根据order_date和update_time这两个字段获取这些数据，所以此时ods_user_order中的数据就是每日的新增和变化了的数据。

执行代码生成数据：
1
ods_user_order在前面已经使用过，所以在这只需要将2026-03-01、2026-03-02和2026-03-03的数据加载进去即可

image-20230406154210239

image-20230406154346557

image-20230406154427193

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
27
28
29
30
31
32
33
34
35
36
insert overwrite table dwd_mall.dwd_user_order partition(dt='20260301')  select 
   order_id,
   order_date,
   user_id,
   order_money,
   order_type,
   order_status,
   pay_id,
   update_time
from ods_mall.ods_user_order
where dt = '20260301' and order_id is not null;

insert overwrite table dwd_mall.dwd_user_order partition(dt='20260302')  select 
   order_id,
   order_date,
   user_id,
   order_money,
   order_type,
   order_status,
   pay_id,
   update_time
from ods_mall.ods_user_order
where dt = '20260302' and order_id is not null;


insert overwrite table dwd_mall.dwd_user_order partition(dt='20260303')  select 
   order_id,
   order_date,
   user_id,
   order_money,
   order_type,
   order_status,
   pay_id,
   update_time
from ods_mall.ods_user_order
where dt = '20260303' and order_id is not null;

image-20230406155251457

image-20230406155334317

image-20230406155350251

1
2
2：创建拉链表，基于每日更新订单表构建拉链表中的数据
创建拉链表：dws_user_order_zip
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
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
create external table if not exists dws_mall.dws_user_order_zip(
   order_id    bigint,
   order_date    string,
   user_id    bigint,
   order_money    double,
   order_type    int,
   order_status    int,
   pay_id    bigint,
   update_time    string,
   start_time    string,
   end_time    string
)row format delimited  
 fields terminated by '\t'
 location 'hdfs://bigdata01:9000/data/dws/user_order_zip/';


insert overwrite table dws_mall.dws_user_order_zip
select *
from 
(
    select
       duoz.order_id,
       duoz.order_date,
       duoz.user_id,
       duoz.order_money,
       duoz.order_type,
       duoz.order_status,
       duoz.pay_id,
       duoz.update_time,
       duoz.start_time,
       case
           when duoz.end_time = '9999-12-31' and duo.order_id is not null then date_add('2026-03-01',-1)
           else duoz.end_time
       end as end_time
    from dws_mall.dws_user_order_zip as duoz
    left join
    (
        select order_id from dwd_mall.dwd_user_order
        where dt = '20260301'
    ) as duo
    on duoz.order_id = duo.order_id
union all
   select
       duo.order_id,
       duo.order_date,
       duo.user_id,
       duo.order_money,
       duo.order_type,
       duo.order_status,
       duo.pay_id,
       duo.update_time,
       '2026-03-01' as start_time,
       '9999-12-31' as end_time
   from dwd_mall.dwd_user_order as duo
   where duo.dt = '20260301'
) as t;
1
在windows中编写sql语句，回车时可能会有tab制表符，这样的sql复制到hive中执行会报错；对于复制到hive中连成一行无法解析的情况，可以在复制前给每一行的最后添加一个空格

image-20230406163700653

image-20230406164241911

1
sql语句里的时间改成20260302后再执行

image-20230406164129176

image-20230406164251390

image-20230406164509353

1
sql语句里的时间改成20260303后再执行

image-20230406164804417

image-20230406164904719

1
2
3
4
5
6
7
8
查询3月1日的切片数据

hive (default)>  select * from dws_mall.dws_user_order_zip where start_time<='2026-03-01' and end_time>='2026-03-01';
OK
30001   2026-03-01 10:10:10     10096   200.0   1       0       NULL NULL     2026-03-01      2026-03-02
30002   2026-03-01 10:10:10     10096   200.0   1       0       NULL NULL     2026-03-01      2026-03-01
30003   2026-03-01 10:10:10     10096   200.0   1       1       400012026-03-01 11:11:11      2026-03-01      9999-12-31
Time taken: 0.328 seconds, Fetched: 3 row(s)

image-20230406171011072

1
查询3月2日的切片数据

image-20230406171046707

1
2
3
4
5
6
7
8
9
10
11
12
查询3月3日的切片数据

hive (default)>  select * from dws_mall.dws_user_order_zip where start_time<='2026-03-03' and end_time>='2026-03-03';
OK
30003   2026-03-01 10:10:10     10096   200.0   1       1       400012026-03-01 11:11:11      2026-03-01      9999-12-31
30002   2026-03-01 10:10:10     10096   200.0   1       1       400022026-03-02 11:11:11      2026-03-02      9999-12-31
30005   2026-03-02 10:10:10     10096   200.0   1       1       400032026-03-02 11:11:11      2026-03-02      9999-12-31
30001   2026-03-01 10:10:10     10096   200.0   1       1       400042026-03-03 11:11:11      2026-03-03      9999-12-31
30004   2026-03-02 10:10:10     10096   200.0   1       1       400052026-03-03 11:11:11      2026-03-03      9999-12-31
30006   2026-03-03 10:10:10     10096   200.0   1       1       400062026-03-03 11:11:11      2026-03-03      9999-12-31
30007   2026-03-03 10:10:10     10096   200.0   1       0       NULL NULL     2026-03-03      9999-12-31
Time taken: 0.195 seconds, Fetched: 7 row(s)
1
2
3
查询有效数据
查询切片数据
查询一条订单历史记录
1
2
3
4
5
6
此时，如果想要翻旧账，查看某一个订单的历史变化情况，可以这样查询

hive (default)>  select * from dws_mall.dws_user_order_zip where order_id = '30001';
OK
30001   2026-03-01 10:10:10     10096   200.0   1       0       NULL NULL     2026-03-01      2026-03-02
30001   2026-03-01 10:10:10     10096   200.0   1       1       400042026-03-03 11:11:11      2026-03-03      9999-12-31

image-20230406165823692

拉链表的性能问题(面试爱问)

1
2
3
4
拉链表也会遇到查询性能的问题，假设我们存放了5年的拉链数据，那么这张表势必会比较大，当查询的时候性能就比较低了
可以用以下思路来解决：
1. 可以尝试对start_time和end_time做索引，这样可以提高一些性能。
2. 保留部分历史数据，我们可以在一张表里面存放全量的拉链表数据，然后再对外暴露一张只提供近3个月数据的拉链表。
1
还有什么是拉链表，如何制作拉链表也爱问

商品订单数据数仓总结

数据库和表梳理

image-20230406210206233

任务脚本梳理

image-20230406210336400

数据可视化和任务调度实现

数据可视化

1
2
3
4
数据可视化这块不是项目的重点，不过为了让大家能有一个更加直观的感受，我们可以选择一些现成的数据可视化工具实现。
咱们前面分析过，想要查询hive中的数据可以使用hue，不过hue无法自动生成图表。
所以我们可以考虑使用Zeppelin(还可以操作spark,flink)
针对一些复杂的图表，可以选择定制开发，使用echarts等组件实现

Zeppelin安装部署

1
2
注意：不要使用Zeppelin0.8.2版本，这个版本有bug，无法使用图形展现数据。
在这我们使用zeppelin-0.9.0-preview1这个版本
1
2
3
4
5
6
7
8
9
10
11
12
13
14
把下载好的安装包上传到bigdata04的/data/soft目录中
1：解压

2：修改配置
[root@bigdata04 soft]# cd zeppelin-0.9.0-preview1-bin-all/conf
[root@bigdata04 conf]# mv zeppelin-env.sh.template zeppelin-env.sh
[root@bigdata04 conf]# mv zeppelin-site.xml.template zeppelin-site.xml
[root@bigdata04 conf]# vi zeppelin-site.xml
# 将默认的127.0.0.1改为0.0.0.0 否则默认情况下只能在本机访问zeppline
<property>
 <name>zeppelin.server.addr</name>
 <value>0.0.0.0</value>
 <description>Server binding address</description>
</property>
1
2
3
4
3：增加Hive依赖jar包
由于我们需要使用Zepplien连接hive，它里面默认没有集成Hive的依赖jar包，所以最简单的方式就是将Hive的lib目录中的所有jar包全复制到Zeppline中的interpreter/jdbc目录中
[root@bigdata04 zeppelin-0.9.0-preview1-bin-all]# cd interpreter/jdbc
[root@bigdata04 jdbc]# cp /data/soft/apache-hive-3.1.2-bin/lib/*.jar .
1
2
3
4
4：启动
[root@bigdata04 zeppelin-0.9.0-preview1-bin-all]# bin/zeppelin-daemon.sh start
5：停止【需要停止的时候传递stop命令即可】
[root@bigdata04 zeppelin-0.9.0-preview1-bin-all]# bin/zeppelin-daemon.sh stop

Zepplin的界面参数配置

1
2
3
4
Zepplin启动之后可以通过8080端口进行访问
http://bigdata04:8080/

在使用之前需要先配置hive的基本信息

image-20230406211509288

1
2
3
搜索jdbc

点击edit修改里面的参数信息

image-20230406211538750

1
修改这四项的内容即可，这里的内容其实就是我们之前学习hive的jdbc操作时指定的参数

image-20230406211809935

1
2
3
4
5
注意：需要在192.168.182.103这台机器上启动hiveserver2服务，否则在zeppline中连不上hive
最后点save按钮即可Zepplin的使用
创建一个note，类似于工作台的概念
[root@bigdata04 ~]# cd /data/soft/apache-hive-3.1.2-bin
[root@bigdata04 apache-hive-3.1.2-bin]# bin/hiveserver2

Zepplin的使用

1
创建一个note，类似于工作台的概念

image-20230406211917306

1
2
此时就可以在里面写SQL了。
如果以图形的形式展示结果，则点击这里面对应图形的图标即可。

image-20230406212125211

image-20230406212432043

1
对于想制作一些复杂的图表，可以用sqoop导出到mysql，让前端的人去制作。这里当然也很方便直接与hive交互

任务调度

1
2
针对数据仓库中的任务脚本我们前面已经整理过了，任务脚本还是比较多的，针对初始化表的脚本只需要
执行一次即可，其它的脚本需要每天都执行一次，这个时候就需要涉及到任务定时调度了。

Crontab调度器的使用

1
2
3
4
5
6
7
8
9
10
11
12
13
咱们前面在学习Linux的时候学过一个crontab调度器，通过它可以实现定时执行指定的脚本。
针对我们这个数据仓库中的这些脚本使用crontab进行调度是可以的
但是需要注意一点：这些任务之间是有一些依赖关系的，从大的层面上来说，dwd层的任务需要等ods层的任务执行成功之后才能开始执行

那crontab如何知道任务之间的依赖关系呢？
crontab是无法知道任务之间的依赖关系的，我们只能间接实现
举个例子：针对MapReduce任务和Spark任务，任务执行成功之后，在输出目录中会有一个success标记文件，这个文件表示这个任务成功的执行结束了。

此时如果我们使用crontab调度两个job，一个jobA，一个jobB，先执行jobA，jobA成功执行结束之后才能执行jobB，这个时候我们就需要在脚本中添加一个判断，判断jobA的结果输出目录中是否存在success文件，如果存在则继续执行jobB，否则不执行，并且告警，提示jobA任务执行失败。

那我们现在执行的是hive的sql任务，sql任务最终不会在输出目录中产生success文件，所以没有办法使用这个标记文件进行判断，不过sql任务会产生数据文件，数据文件的文件名是类似000000_0这样的，可能会有多个，具体的个数是由任务中的reduce的个数决定的，我们也可以选择判断这个数据文件是否存在来判断任务是否成功执行结束。

注意了：针对SQL任务虽然可以通过判断数据文件来判定任务是否执行成功，不过这种方式不能保证100%的准确率，有可能会存在这种情况，任务确实执行成功了，但是在向结果目录中写数据文件的时候，写了一半，由于网络原因导致数据没有写完，但是我们过来判断000000_0这个文件肯定是存在的，那我们就误以为这个任务执行成功了，其实它的数据是缺失一部分的，不过这种情况的概率极低，可以忽略不计。
1
2
3
此时使用crontab调度两个有依赖关系的任务，脚本该如何实现呢？
在bigdata04机器中创建 /data/soft/warehouse_job 目录
创建脚本： crontab_job_schedule.sh
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
27
28
29
30
31
32
33
34
35
36
37
38
#!/bin/bash

# 默认获取昨天的日期，也支持传参指定一个日期
if [ "z$1" = "z" ]
then
dt=`date +%Y%m%d --date="1 days ago"`
else
dt=$1
fi

# 执行jobA
# 先删除jobA的输出目录
hdfs dfs -rm -r hdfs://bigdata01:9000/data/dwd/user_addr/dt=${dt}


hive -e "
insert overwrite table dwd_mall.dwd_user_addr partition(dt='${dt}')  select 
   addr_id,
   user_id,
   addr_name,
   order_flag,
   user_name,
   mobile
from ods_mall.ods_user_addr
where dt = '${dt}' and addr_id is not null;
"

#如果jobA执行成功，这条查询命令就可以成功执行，否则在执行的时候会报错
hdfs dfs -ls hdfs://bigdata01:9000/data/dwd/user_addr/dt=${dt}/000000_0

# 在这里通过$?来判断上一条命令是否成功执行，如果$?的返回值为0，则表示jobA执行成功，否则表示jobA执行失败
if [ $? = 0 ]
then
    echo "执行jobB"
else
    # 可以在这里发短息或者发邮件
    echo "jobA执行失败，请处理..."
fi
1
2
3
4
5
如果jobA成功执行，则jobB也可以执行，如果jobA执行失败，则jobB不会执行，脚本会生成告警信息。

这就是使用crontab调度器如何实现任务依赖的功能。
如果项目中的定时任务有很多，使用crontab虽然可以实现任务依赖的功能，但是管理起来不方便，crontab没有提供图形化的界面，使用起来比较麻烦
针对一些简单的定时任务的配置，并且任务比较少的情况下使用crontab是比较方便的。

Azkaban调度器的使用

1
对于定时执行的脚本很多，可以使用可视化管理界面的任务调度工具进行管理：azkaban(轻量级),Ooize(重量级)
Azkaban介绍
1
2
3
4
5
6
7
在实际工作中如果需要配置很多的定时任务，一般会采用一些支持界面操作的调度器，例如：Azkaban、Ooize
Azkaban是一个轻量级的调度器，使用起来比较简单，容易上手。
Ooize是一个重量级的调度器，使用起来相对比较复杂。
在这里我们主要考虑易用性，所以我们选择使用Azkaban。
下面我们来快速了解一下Azkaban，以及它的用法。
Azkaban是由Linkedin开源的一个批量工作流任务调度器。用于在一个工作流内以一个特定的顺序运行一组工作和流程。
Azkaban定义了一种KV文件格式来建立任务之间的依赖关系，并提供一个易于使用的web用户界面维护和跟踪你的工作流。
1
2
3
4
5
6
7
8
9
10
那我们首先把Azkaban安装部署起来
官网下载的Azkaban是源码，需要编译，编译过程会非常慢，主要是由于国外网络原因导致的。
在这我给大家直接提供一个编译好的Azkaban。
为了简化Azakan的安装过程，不让大家在工具的安装上花费太多时间，在这里我们就使用Azkaban的solo模式部署。

solo模式属于单机模式，那对应的Azkaban也支持在多台机器上运行。
solo模式的优点：
易于安装：无需MySQL示例。它将H2打包为主要的持久存储。
易于启动：Web服务器和执行程序服务器都在同一个进程中运行。
全功能：它包含所有Azkaban功能。
Azkaban安装部署
1
2
3
4
5
6
7
8
9
10
11
把编译后的Azkaban安装包 azkaban-solo-server-0.1.0-SNAPSHOT.tar.gz 上传到bigdata04的/data/soft目录下
1：解压

2：修改Azkaban的时区为上海时区
我们的bigdata04机器在创建的时候已经指定了时区为上海时区
要保证bigdata04机器的时区和Azkaban的时区是一致的。
[root@bigdata04 azkaban-solo-server-0.1.0-SNAPSHOT]# cd conf/
[root@bigdata04 conf]# vi azkaban.properties
......
default.timezone.id=Asia/Shanghai
......
1
2
3
4
5
3：启动
[root@bigdata04 azkaban-solo-server-0.1.0-SNAPSHOT]# bin/azkaban-solo-start.sh

4：停止
[root@bigdata04 azkaban-solo-server-0.1.0-SNAPSHOT]# bin/azkaban-solo-stop.sh
1
2
启动成功之后，azkaban会启动一个web界面，监听的端口是8081
http://bigdata04:8081/

image-20230406215038265

1
用户名和密码默认都是 azkaban
提交独立任务
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
如何向Azkaban中提交任务呢？
1：先创建一个Project

2：向test项目中提交任务
先演示一个独立的任务
创建一个文件hello.job，文件内容如下：
# hello.job
type=command
command=echo "Hello World!

这里面的#号开头表示是注释
type：任务类型，这里的command表示这个任务执行的是一个命令
command：这里的command是指具体的命令
将hello.job文件添加到一个zip压缩文件中，hello.zip。

将hello.zip压缩包提交到刚才创建的test项目中

image-20230406215538918

1
此时test项目中就包含hello这个任务，点击execute flow执行

image-20230406215604662

image-20230406215635048

image-20230406215648313

1
2
此时这个任务执行一次就结束了，如果想要让任务定时执行，可以在这配置。
先进入test项目中

image-20230406220045801

image-20230406220101356

1
点击Schedule，进入配置定时信息

image-20230406220133705

image-20230406220150848

1
2
3
4
5
这就将test项目中的hello.job配置了定时任务。
其实我们会发现这里面的定时任务的配置格式和crontab中的一样。
后期如果想查看这个定时任务的执行情况可以点击hello

点击executions查看任务的执行列表

image-20230406220233640

image-20230406220252870

1
如果想查看某一次任务的具体执行情况，可以点击execution id
1
这是一个基本的独立任务的执行，如果是有依赖的多个任务，如何配置呢？
提交依赖任务
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
下面再看一个例子：
1：先创建一个project：depen_test

2：向depen_test项目中提交任务
先创建一个文件first.job
# first.job
type=command
command=echo "Hello First!"
再创建一个文件second.job
# second.job
type=command
dependencies=first
command=echo "Hello Second!"

这里面通过dependencies属性指定了任务的依赖关系，后面的first表示依赖的任务的文件名称

最后将这两个job文件打成一个zip压缩包
将这个压缩包上传到项目里面

image-20230406220617754

1
2
点击Execute Flow，也可以看到任务之间的依赖关系
点击Execute

image-20230406220640754

1
最后查看jobList，可以看到这个项目中的两个任务的执行顺序

image-20230406220807410

1
这就是带依赖的任务的任务调度。
在数仓中使用Azkaban
1
2
3
4
5
6
7
8
下面我们来看一下针对数仓中的多级任务依赖，如何使用Azkaban实现
以统计电商GMV为例：
这个指标需要依赖于这个流程 MySQL-->HDFS-->ODS-->DWD-->APP
MySQL–>HDFS需要使用Sqoop脚本
HDFS–>ODS需要使用hive alter命令
ODS–>DWD需要使用hive的SQL
DWD–>APP需要使用hive的SQL
接下来开发对应的azkaban job
collect.job
1
2
3
4
# collect.job
# 采集MySQL中的数据至HDFS
type=command
command=sh /data/soft/warehouse_job/collect_mysql.sh
ods.job
1
2
3
4
5
# ods.job
# 关联ods层的数据
type=command
dependencies=collect
command=sh /data/soft/warehouse_job/ods_mall_add_partition.sh
dwd.job
1
2
3
4
5
# dwd.job
# 生成dwd层的数据
type=command
dependencies=ods
command=sh /data/soft/warehouse_job/dwd_mall_add_partition.sh
app.job
1
2
3
4
5
# app.job
# 生成app层的数据
type=command
dependencies=dwd
command=sh /data/soft/warehouse_job/app_mall_add_partition_2.sh

image-20230406221808936

1
2
3
还要把job文件里涉及的sh脚本上传到linux上指定目录

然后配置定时任务

项目优化

1
2
3
4
5
6
7
8
9
Sqoop数据采集参数调优，它只会生成一个map任务，性能较低

集群Queue队列优化

避免任务启动时间过于集中

Hive on Tez

Impala提供快速交互查询

本文标题:大数据开发工程师-第十三周 综合项目:电商数据仓库之商品订单数仓2

文章作者:TTYONG

发布时间:2023年04月05日 - 22:04

最后更新:2023年06月19日 - 15:06

原始链接:http://tianyong.fun/%E5%A4%A7%E6%95%B0%E6%8D%AE%E5%BC%80%E5%8F%91%E5%B7%A5%E7%A8%8B%E5%B8%88-%E7%AC%AC%E5%8D%81%E4%B8%89%E5%91%A8-%E7%BB%BC%E5%90%88%E9%A1%B9%E7%9B%AE-%E7%94%B5%E5%95%86%E6%95%B0%E6%8D%AE%E4%BB%93%E5%BA%93%E4%B9%8B%E5%95%86%E5%93%81%E8%AE%A2%E5%8D%95%E6%95%B0%E4%BB%932.html

许可协议: 转载请保留原文链接及作者。

多少都是爱
0%