大数据学习_Hive_调优策略/_Hue的安装和使用

最新推荐文章于 2024-06-25 11:05:24 发布

Shawlizao

最新推荐文章于 2024-06-25 11:05:24 发布

阅读量762

点赞数

分类专栏： Hive 大数据

本文链接：https://blog.csdn.net/qq_41612830/article/details/113848063

版权

大数据同时被 2 个专栏收录

23 篇文章 0 订阅

订阅专栏

Hive

4 篇文章 0 订阅

订阅专栏

1 Hive调优策略

Hive作为大数据领域常用的数据仓库组件，在设计和开发阶段需要注意效率。
影响Hive效率的不仅仅是数据量过大；数据倾斜、数据冗余、job或I/O过多、MapReduce分配不合理等因素都对Hive的效率有影响。
对Hive的调优既包含对HiveQL语句本身的优化，也包含Hive配置项和MR方面的调整。

从以下三个方面展开：
架构优化
参数优化
SQL优化

1.1 架构优化

执行引擎
Hive支持多种执行引擎，分别是 MapReduce、Tez、Spark、Flink。可以通过hive-site.xml文件中的hive.execution.engine属性控制。
Tez是一个构建于YARN之上的支持复杂的DAG（有向无环图）任务的数据处理框架。由Hontonworks开源，将MapReduce的过程拆分成若干个子过程，同时可以把多个mapreduce任务组合成一个较大的DAG任务，减少了MapReduce之间的文件存储，同时合理组合其子过程从而大幅提升MR作业的性能。
在这里插入图片描述
优化器
与关系型数据库类似，Hive会在真正执行计算之前，生成和优化逻辑执行计划与物理执行计划。Hive有两种优化器：Vectorize(向量化优化器) 与 Cost-BasedOptimization (CBO 成本优化器)。

矢量化查询执行
矢量化查询(要求执行引擎为Tez)执行通过一次批量执行1024行而不是每行一行来提高扫描，聚合，过滤器和连接等操作的性能，这个功能一显着缩短查询执行时间。

set hive.vectorized.execution.enabled = true; -- 默认 false
set hive.vectorized.execution.reduce.enabled = true; -- 默认 false

备注：要使用矢量化查询执行，必须用ORC格式存储数据

成本优化器(大小表join等…)
Hive的CBO是基于apache Calcite的，Hive的CBO通过查询成本(有analyze收集的统计信息)会生成有效率的执行计划，最终会减少执行的时间和资源的利用，使用CBO的配置如下：

SET hive.cbo.enable=true; --从 v0.14.0 默认true
SET hive.compute.query.using.stats=true; -- 默认false
SET hive.stats.fetch.column.stats=true; -- 默认false
SET hive.stats.fetch.partition.stats=true; -- 默认true

需要定期执行表（analyze）的分析，分析后的数据放在元数据库中。

分区表
对于一张比较大的表，将其设计成分区表可以提升查询的性能，对于一个特定分区的查询，只会加载对应分区路径的文件数据，所以执行速度会比较快。
分区字段的选择是影响查询性能的重要因素，尽量避免层级较深的分区，这样会造成太多的子文件夹。一些常见的分区字段可以是：

日期或时间。如year、month、day或者hour，当表中存在时间或者日期字段时
地理位置。如国家、省份、城市等
业务逻辑。如部门、销售区域、客户等等

分桶表
与分区表类似，分桶表的组织方式是将HDFS上的文件分割成多个文件。
分桶可以加快数据采样，也可以提升join的性能(join的字段是分桶字段)，因为分桶可以确保某个key对应的数据在一个特定的桶内(文件)，巧妙地选择分桶字段可以大幅度提升join的性能。
通常情况下，分桶字段可以选择经常用在过滤操作或者join操作的字段。
文件格式选择
在HiveQL的create table语句中，可以使用 stored as … 指定表的存储格式。
Hive表支持的存储格式有TextFile、SequenceFile、RCFile、ORC、Parquet等。
存储格式一般需要根据业务进行选择，生产环境中绝大多数表都采用TextFile、ORC、Parquet存储格式之一。
TextFile是最简单的存储格式，它是纯文本记录，也是Hive的默认格式。其磁盘开销大，查询效率低，更多的是作为跳板来使用。RCFile、ORC、Parquet等格式的表都不能由文件直接导入数据，必须由TextFile来做中转。
Parquet和ORC都是Apache旗下的开源列式存储格式。列式存储比起传统的行式存储更适合批量OLAP查询，并且也支持更好的压缩和编码。选择Parquet的原因主要是它支持Impala查询引擎，并且对update、delete和事务性操作需求很低。
数据压缩
压缩技术可以减少map与reduce之间的数据传输，从而可以提升查询性能，关于压缩的配置可以在hive的命令行中或者hive-site.xml文件中进行配置。

SET hive.exec.compress.intermediate=true

开启压缩之后，可以选择下面的压缩格式：
在这里插入图片描述
关于压缩的编码器可以通过mapred-site.xml, hive-site.xml进行配置，也可以通过命令行进行配置，如：

-- 中间结果压缩
SET hive.intermediate.compression.codec=org.apache.hadoop.io.compress.SnappyCodec;
-- 输出结果压缩
SET hive.exec.compress.output=true;
SET mapreduce.output.fileoutputformat.compress.codec =org.apache.hadoop.io.compress.SnappyCodc

小结，在设计阶段需要考虑何种执行引擎？何种优化器？分区分桶方法？何种文件格式？数据压缩与否？这些优化问题。

1.2 参数优化

本地模式：
当Hive处理的数据量较小时，启动分布式去处理数据会有点浪费，因为可能启动的时间比数据处理的时间还要长。Hive支持将作业动态地转为本地模式，需要使用下面的配置：

SET hive.exec.mode.local.auto=true; -- 默认 false
SET hive.exec.mode.local.auto.inputbytes.max=50000000;
SET hive.exec.mode.local.auto.input.files.max=5; -- 默认 4

一个作业只要满足下面的条件，会启用本地模式

输入文件的大小小于 hive.exec.mode.local.auto.inputbytes.max 配置的大小
map任务的数量小于 hive.exec.mode.local.auto.input.files.max 配置的大小
reduce任务的数量是1或者0
严格模式
所谓严格模式，就是强制不允许用户执行3种有风险的HiveQL语句，一旦执行会直接
失败。这3种语句是：
查询分区表时不限定分区列的语句(设定了分区条件而不去用)；
两表join产生了笛卡尔积的语句(select * from a,b;)；
用order by来排序，但没有指定limit的语句。

要开启严格模式，需要将参数 hive.mapred.mode 设为strict(缺省值)。
该参数可以不在参数文件中定义，在执行SQL之前设置(set hive.mapred.mode=nostrict )
JVM重用
默认情况下，Hadoop会为为一个map或者reduce启动一个JVM，这样可以并行执行map和reduce。
当map或者reduce是那种仅运行几秒钟的轻量级作业时，JVM启动进程所耗费的时间会比作业执行的时间还要长。Hadoop可以重用JVM，通过共享JVM以串行而非并行的方式运行map或者reduce。
JVM的重用适用于同一个作业的map和reduce，对于不同作业的task不能够共享JVM。如果要开启JVM重用，需要配置一个作业最大task数量，默认值为1，如果设置为-1，则表示不限制：

# 代表同一个MR job中顺序执行的5个task重复使用一个JVM，减少启动和关闭的开销
SET mapreduce.job.jvm.numtasks=5;

这个功能的缺点是，开启JVM重用将一直占用使用到的task插槽，以便进行重用，直到任务完成后才能释放。如果某个“不平衡的”job中有某几个reduce task执行的时间要比其他Reduce task消耗的时间多的多的话，那么保留的插槽就会一直空闲着却无法被其他的job使用，直到所有的task都结束了才会释放。
并行执行
Hive的查询通常会被转换成一系列的stage，这些stage之间并不是一直相互依赖的，可以并行执行这些stage，通过下面的方式进行配置：

SET hive.exec.parallel=true; -- 默认false
SET hive.exec.parallel.thread.number=16; -- 默认8

并行执行可以增加集群资源的利用率，如果集群的资源使用率已经很高了，那么并行执行的效果不会很明显。
在这里插入图片描述

推测执行
在分布式集群环境下，因为程序Bug、负载不均衡、资源分布不均等原因，会造成同一个作业的多个任务之间运行速度不一致，有些任务的运行速度可能明显慢于其他任务（比如一个作业的某个任务进度只有50%，而其他所有任务已经运行完毕），则这些任务会拖慢作业的整体执行进度。
为了避免这种情况发生，Hadoop采用了推测执行机制，它根据一定的规则推测出“拖后腿”的任务，并为这样的任务启动一个备份任务，让该任务与原始任务同时处理同一份数据，并最终选用最先成功运行完成任务的计算结果作为最终结果。

set mapreduce.map.speculative=true
set mapreduce.reduce.speculative=true
set hive.mapred.reduce.tasks.speculative.execution=true

合并小文件

在map执行前合并小文件，减少map数

# 缺省参数
set hive.input.format=org.apache.hadoop.hive.ql.io.CombineHiveInputFormat;

在Map-Reduce的任务结束时合并小文件

# 在 map-only 任务结束时合并小文件，默认true
SET hive.merge.mapfiles = true;
# 在 map-reduce 任务结束时合并小文件，默认false
SET hive.merge.mapredfiles = true;
# 合并文件的大小，默认256M(适当调整)
SET hive.merge.size.per.task = 268435456;
# 当输出文件的平均大小小于该值时，启动一个独立的map-reduce任务进行文件merge
SET hive.merge.smallfiles.avgsize = 16777216;

Fetch模式
Fetch模式是指Hive中对某些情况的查询可以不必使用MapReduce计算。select col1, col2 from tab ;
可以简单地读取表对应的存储目录下的文件，然后输出查询结果到控制台。在开启fetch模式之后，在全局查找、字段查找、limit查找等都不启动 MapReduce 。

# Default Value: minimal in Hive 0.10.0 through 0.13.1, more in Hive 0.14.0 and later
hive.fetch.task.conversion=more

Hive 参数说明的官方文档：
https://cwiki.apache.org/confluence/display/Hive/Configuration+Properties

1.3 SQL优化

列裁剪和分区裁剪
列裁剪是在查询时只读取需要的列；分区裁剪就是只读取需要的分区。
简单的说：select 中不要有多余的列，坚决避免 select * from tab;
查询分区表，不读多余的数据；

select uid, event_type, record_data
from calendar_record_log
where pt_date >= 20190201 and pt_date <= 20190224
and status = 0;

sort by 代替 order by
HiveQL中的order by与其他关系数据库SQL中的功能一样，是将结果按某字段全局排序，这会导致所有map端数据都进入一个reducer中，在数据量大时可能会长时间计算不完。
如果使用sort by，那么还是会视情况启动多个reducer进行排序，并且保证每个reducer内局部有序。为了控制map端数据分配到reducer的key，往往还要配合distribute by 一同使用。如果不加 distribute by 的话，map端数据就会随机分配到reducer。
原理理解举例子：https://blog.csdn.net/qq_40795214/article/details/82190827
group by 代替 count(distinct)
当要统计某一列的去重数时，如果数据量很大，count(distinct) 会非常慢。原因与order by类似，count(distinct)逻辑只会有很少的reducer来处理。此时可以用group by 来改写：

-- 原始SQL
select count(distinct uid)
	from tab;
-- 优化后的SQL
select count(1)
	from (select uid
		from tab
			group by uid) tmp;

这样写会启动两个MR job（单纯distinct只会启动一个），所以要确保数据量大到启动job的overhead远小于计算耗时，才考虑这种方法。当数据集很小或者key的倾斜比较明显时，group by还可能会比distinct慢。
group by 配置调整

map端预聚合
group by时，如果先起一个combiner在map端做部分预聚合，可以有效减少shuffle数据量。

-- 默认为true
set hive.map.aggr = true

Map端进行聚合操作的条目数

set hive.groupby.mapaggr.checkinterval = 100000

通过 hive.groupby.mapaggr.checkinterval 参数也可以设置map端预聚合的行数阈值，超过该值就会分拆job，默认值10W。

倾斜均衡配置项
group by时如果某些key对应的数据量过大，就会发生数据倾斜。Hive自带了一个均衡数据倾斜的配置项 hive.groupby.skewindata ，默认值false。
其实现方法是在group by时启动两个MR job。第一个job会将map端数据随机输入reducer，每个reducer做部分聚合，相同的key就会分布在不同的reducer中。第二个job再将前面预处理过的数据按key聚合并输出结果，这样就起到了均衡的效果。
但是，配置项毕竟是死的，单纯靠它有时不能根本上解决问题，建议了解数据倾斜的细节，并优化查询语句。

join 基础优化
Hive join的三种方式
1、common join
普通连接，在SQL中不特殊指定连接方式使用的都是这种普通连接。
原理：在join前首先做一次shuffle，主要是该阶段耗费时间
优点：操作简单，普适性强
缺点：性能较差(要将数据分区，有shuffle)
在这里插入图片描述
2、map join
map端连接，与普通连接的区别是这个连接中不会有reduce阶段存在，连接在map端完成
适用场景：大表与小表连接，小表数据量应该能够完全加载到内存，否则不适用
原理：小表存储在内存中，直接跟大表的每个分区数据进行比对关联，不需要shuffle/reduce，性能非常高。
优点：在大小表连接时性能提升明显
备注：Hive 0.6 的时候默认认为写在select 后面的是大表，前面的是小表，或者使用 /+mapjoin(map_table) / 提示进行设定。select a., b. from a join b on a.id =b.id【要求小表在前，大表之后】
hive 0.7 的时候这个计算是自动化的，它首先会自动判断哪个是小表，哪个是大表，这个参数由（hive.auto.convert.join=true）来控制，然后控制小表的大小由（hive.smalltable.filesize=25000000）参数控制（默认是25M），当小表超过这个大小，hive 会默认转化成common join。
Hive 0.8.1，hive.smalltable.filesize => hive.mapjoin.smalltable.filesize
缺点：使用范围较小，只针对大小表且小表能完全加载到内存中的情况。
3、bucket map join
分桶连接：Hive 建表的时候支持hash 分区通过指定clustered by (col_name,xxx )into number_buckets buckets 关键字.当连接的两个表的join key 就是bucket column 的时候，就可以通过设置hive.optimize.bucketmapjoin= true 来执行优化。
原理：通过两个表分桶在执行连接时会将小表的每个分桶映射成hash表，每个task节点都需要这个小表的所有hash表，但是在执行时只需要加载该task所持有大表分桶对应的小表部分的hash表就可以，所以对内存的要求是能够加载小表中最大的hash块即可。

1.4 优化小结

深入理解 Hadoop 的核心能力，对Hive优化很有帮助。Hadoop/Hive 处理数据过程，有几个显著特征：

不怕数据多，就怕数据倾斜，
对 job 数比较多的作业运行效率相对比较低，比如即使有几百行的表，多次关联多次汇总，产生十几个jobs，执行也需要较长的时间。MapReduce 作业初始化的时间是比较长的
对sum、count等聚合操作而言，不存在数据倾斜问题
count(distinct) 效率较低，数据量大容易出问题

从大的方面来说，优化可以从几个方面着手：

好的模型设计，事半功倍
解决数据倾斜问题。仅仅依靠参数解决数据倾斜，是通用的优化手段，收获有限。开发人员应该熟悉业务，了解数据规律，通过业务逻辑解决数据倾斜往往更可靠
减少 job 数
设置合理的map、reduce task数
对小文件进行合并，是行之有效的提高Hive效率的方法
优化把握整体，单一作业的优化不如整体最优

1.5 优化实战

执行计划
在这里插入图片描述
包含MR的STAGE最耗费资源，调优也是最关注这些STAGE。
SQL优化
当两个查询数据来自同一个表时，可以将from语句拿到开头。这样可以减少一次stage，减少一次表的扫描。
文件格式优化

2 Hive案例

2.1 需求描述

针对销售数据，完成统计：

按年统计销售额
销售金额在 10W 以上的订单
每年销售额的差值
年度订单金额前10位（年度、订单号、订单金额、排名）
季度订单金额前10位（年度、季度、订单id、订单金额、排名）
求所有交易日中订单金额最高的前10位
每年度销售额最大的交易日
年度最畅销的商品(即每年销售金额最大的商品)

2.2 数据说明

在这里插入图片描述

2.3 实现

步骤一：创建表
将数据存放在ORC文件中

-- createtable.hql
drop database sale cascade;
create database if not exists sale;
create table sale.dimdate_ori(
	dt date,
	yearmonth int,
	year smallint,
	month tinyint,
	day tinyint,
	week tinyint,
	weeks tinyint,
	quat tinyint,
	tendays tinyint,
	halfmonth tinyint
) 
row format delimited
fields terminated by ",";

create table sale.sale_ori(
	orderid string,
	locationid string,
	dt date
) 
row format delimited
fields terminated by ",";

create table sale.saledetail_ori(
	orderid string,
	rownum int,
	goods string,
	num int,
	price double,
	amount double
) 
row format delimited
fields terminated by ",";

create table sale.dimdate(
	dt date,
	yearmonth int,
	year smallint,
	month tinyint,
	day tinyint,
	week tinyint,
	weeks tinyint,
	quat tinyint,
	tendays tinyint,
	halfmonth tinyint
) stored as orc;

create table sale.sale(
	orderid string,
	locationid string,
	dt date
) stored as orc;

create table sale.saledetail(
	orderid string,
	rownum int,
	goods string,
	num int,
	price double,
	amount double
)stored as orc;

## 将上述建表语句复制到createtable.hql 接着执行下面
hive -f createtable.hql

步骤二：导入数据

-- 加载数据
use sale;
load data local inpath "/root/data/tbDate.dat" overwrite into table dimdate_ori;
load data local inpath "/root/data/tbSale.dat" overwrite into table sale_ori;
load data local inpath "/root/data/tbSaleDetail.dat" overwrite into table saledetail_ori;
-- 导入数据
insert into table dimdate select * from dimdate_ori;
insert into table sale select * from sale_ori;
insert into table saledetail select * from saledetail_ori;

hive -f loaddata.hql

步骤三：SQL实现
在hue中不兼容中文
1、按年统计销售额

SELECT year(B.dt) year, round(sum(A.amount)/10000, 2) amount
	FROM saledetail A join sale B on A.orderid=B.orderid
		group by year(B.dt);

2、销售金额在 10W 以上的订单

SELECT orderid, round(sum(amount), 2) amount
	FROM saledetail
group by orderid
having sum(amount) > 100000

3、每年销售额的差值

SELECT year, round(amount, 2) amount, 
round(lag(amount) over(ORDER BY year), 2) prioramount
,round(amount - lag(amount) over (ORDER BY year), 2) diff
from (SELECT year(B.dt) year, sum(A.amount) amount
		from saledetail A join sale B on A.orderid=B.orderid
	group by year(B.dt)
	) tmp;

4、年度订单金额前10位（年度、订单号、订单金额、排名）

-- 方法一
SELECT dt, orderid, amount, rank
	from (SELECT dt, orderid, amount,
		dense_rank() over(PARTITION BY dt ORDER BY amount desc) rank
		from (SELECT year(B.dt) dt, A.orderid, sum(A.amount) amount
			from saledetail A join sale B on A.orderid=B.orderid
				GROUP BY year(B.dt), A.orderid) tmp1
		) tmp2
where rank <= 10；

-- 方法二
with tmp as (
SELECT year(B.dt) dt, A.orderid, sum(A.amount) amount
	from saledetail A join sale B on A.orderid=B.orderid
		GROUP BY year(B.dt), A.orderid) 
	SELECT dt, orderid, amount, rank
		from (SELECT dt, orderid, amount,
			dense_rank() over(PARTITION BY dt ORDER BY amount desc) rank
			from tmp) tmp2
				where rank <= 10;

5、季度订单金额前10位（年度、季度、订单id、订单金额、排名）
group by 不能用全名字。

-- 方法一
with tmp as (
select C.year, C.quat, A.orderid, round(sum(B.amount), 2) amount
	from sale A join saledetail B on A.orderid=B.orderid
				join dimdate C on A.dt=C.dt
	group by C.year, C.quat, A.orderid
) 
select year, quat, orderid, amount, rank
from (select year, quat, orderid, amount,
	dense_rank() over (partition by year, quat order by amount desc) rank
		from tmp
) tmp1
where rank <= 10;

-- 方法二
with tmp as(
	select year(A.dt) year,
		case when month(A.dt) <= 3 then 1
		 	 when month(A.dt) <= 6 then 2
		 	 when month(A.dt) <= 9 then 3
	else 4 end quat,
	A.orderid, round(sum(B.amount), 2) amount
	from sale A join saledetail B on A.orderid = B.orderid
group by year(A.dt),
		case when month(A.dt) <= 3 then 1
			 when month(A.dt) <= 6 then 2
			 when month(A.dt) <= 9 then 3
		else 4 end,
	A.orderid) 
select year, quat, orderid, amount, rank
from (select year, quat, orderid, amount,
dense_rank() over (partition by year, quat order by amount desc) rank
from tmp
) tmp1
where rank <= 10;

-- 方法三。求季度方法(向下取整+1)
select floor(month(dt/3.1)) + 1;

with tmp as (
	select year(A.dt) year, floor(month(A.dt)/3.1) + 1 quat, A.orderid,
	round(sum(B.amount), 2) amount
		from sale A join saledetail B on A.orderid=B.orderid
	group by year(A.dt), floor(month(A.dt)/3.1) + 1, A.orderid) 
	select year, quat, orderid, amount, rank
		from (select year, quat, orderid, amount,
		dense_rank() over (partition by year, quat order by amount desc) rank
			from tmp
	) tmp1
	where rank <= 10;

6、求所有交易日中订单金额最高的前10位

-- topN问题：
-- 1、基础数据
-- 2、上排名函数
-- 3、解决N的问题
with tmp as (
	select A.dt, A.orderid, round(sum(B.amount), 2) amount
		from sale A join saledetail B on A.orderid=B.orderid
	group by A.dt, A.orderid) 
select dt, orderid, amount, rank
	from (select dt, orderid, amount, 
	dense_rank() over(order by amount desc) rank
		from tmp
	) tmp1
where rank <= 10;

7、每年度销售额最大的交易日

with tmp as (
	select A.dt, round(sum(B.amount), 2) amount
		from sale A join saledetail B on A.orderid=B.orderid
	group by A.dt) 
	
select year(dt) year, max(amount) dayamount 
	from tmp
group by year(dt);

8、年度最畅销的商品(即每年销售金额最大的商品)

with tmp as (
select year(B.dt) year, goods, round(sum(amount),2) amount
    from saledetail A join sale B on A.orderid=B.orderid
group by year(B.dt), goods
)
select year, goods, amount
 from (select year, goods, amount, dense_rank() over (partition by year order by amount desc) rank
    from tmp) tmp1
where rank = 1;

3 数据交互工具 – HUE

3.1 Hue概述

Hue(Hadoop User Experience)是一个开源的 Apache Hadoop UI 系统，最早是由Cloudera Desktop 演化而来，由 Cloudera 贡献给开源社区，它是基于 Python Web 框架 Django 实现的。通过使用 Hue 可以在浏览器端的 Web 控制台上与Hadoop 集群进行交互来分析处理数据，例如操作 HDFS 上的数据，运行MapReduce Job 等等。Hue所支持的功能特性集合：

默认基于轻量级sqlite数据库管理会话数据，用户认证和授权，可以自定义为MySQL、Postgresql，以及Oracle
基于文件浏览器（File Browser）访问HDFS
基于Hive编辑器来开发和运行Hive查询
支持基于Solr进行搜索的应用，并提供可视化的数据视图，以及仪表板（Dashboard）
支持基于Impala的应用进行交互式查询
支持Spark编辑器和仪表板（Dashboard）
支持Pig编辑器，并能够提交脚本任务
支持Oozie编辑器，可以通过仪表板提交和监控Workflow、Coordinator和Bundle
支持HBase浏览器，能够可视化数据、查询数据、修改HBase表
支持Metastore浏览器，可以访问Hive的元数据，以及HCatalog
支持Job浏览器，能够访问MapReduce Job（MR1/MR2-YARN）
支持Job设计器，能够创建MapReduce/Streaming/Java Job
支持Sqoop 2编辑器和仪表板（Dashboard）
支持ZooKeeper浏览器和编辑器
支持MySql、PostGresql、Sqlite和Oracle数据库查询编辑器

一句话总结：Hue是一个友好的界面集成框架，可以集成我们各种学习过的以及将要学习的框架，一个界面就可以做到查看以及执行所有的框架。

3.2 Hue编译安装

Hue官方网站：https://gethue.com/
HUE官方用户手册：https://docs.gethue.com/
官方安装文档：https://docs.gethue.com/administrator/installation/install/
HUE下载地址：https://docs.gethue.com/releases/
Hue的安装并不是那么简单，官方并没有编译好的软件包，需要从github上下载源码、安装依赖、编译安装。以下详细讲解Hue下载、编译、安装的操作过程。
安装Hue的节点上最好没有安装过MySQL，否则可能有版本冲突，这里选择将Hue安装在 linux122 上。

下载软件包
到官方网站下载 hue-release-4.3.0.zip；上传至服务器，并解压缩

yum install unzip
unzip hue-release-4.3.0.zip

安装依赖

# 需要Python支持(Python 2.7+ / Python 3.5+)
python --version
# 在 CentOS 系统中安装编译 Hue 需要的依赖库
yum install ant asciidoc cyrus-sasl-devel cyrus-sasl-gssapi
cyrus-sasl-plain gcc gcc-c++ krb5-devel libffi-devel libxml2-
devel libxslt-devel make mysql mysql-devel openldap-devel pythondevel sqlite-devel gmp-devel
yum install -y rsync

备注：
以上依赖仅适用CentOS/RHEL 7.X，其他情况请参考https://docs.gethue.com/administrator/installation/dependencies/安装Hue的节点上最好没有安装过MySQL，否则可能有版本冲突
安装过程中需要联网，网络不好会有各种奇怪的问题

安装Maven
编译 Hue 还需要 Maven 环境，因此在编译前需要安装 Maven。
下载 apache-maven-3.6.3-bin.tar.gz，上传虚拟机解压缩，添加环境变量

vi /etc/profile
# 添加环境变量
export MAVEN_HOME=/opt/lagou/servers/apache-maven-3.6.3
export PATH=$PATH:$MAVEN_HOME/bin
source /etc/profile
# 验证安装
mvn --version

编译hue

# 进入 hue 源码目录，进行编译。 使用 PREFIX 指定安装 Hue 的路径
cd /opt/lagou/software/hue-release-4.3.0
PREFIX=/opt/lagou/servers make install
cd /opt/lagou/servers
# 如果想把HUE从移动到另外一个地方，由于HUE使用了Python包的一些绝对路径,移动之
后则必须执行以下命令：
# 这里不要执行
rm app.reg
rm -r build
make apps

此时如果报错：
Error: must have python development packages for 2.6 or 2.7. Could not find Python.h. Please install python2.6-devel or python2.7-devel"。
解决办法：

yum search python | grep -i devel
## 找到对应的python-devel，然后安装，我对应的如下安装
yum  install python-devel.x86_64

修改 Hadoop 配置文件
在 hdfs-site.xml 中增加配置

<!-- HUE -->
	<property>
		<name>dfs.webhdfs.enabled</name>
		<value>true</value>
	</property>
	<property>
		<name>dfs.permissions.enabled</name>
		<value>false</value>
	</property>

在 core-site.xml 中增加配置

<!-- HUE -->
	<property>
		<name>hadoop.proxyuser.hue.hosts</name>
		<value>*</value>
	</property>
	<property>
		<name>hadoop.proxyuser.hue.groups</name>
		<value>*</value>
	</property>
	<property>
		<name>hadoop.proxyuser.hdfs.hosts</name>
		<value>*</value>
	</property>
	<property>
		<name>hadoop.proxyuser.hdfs.groups</name>
		<value>*</value>
	</property>

增加 httpfs-site.xml 文件，加入配置

<configuration>
<!-- HUE -->
	<property>
		<name>httpfs.proxyuser.hue.hosts</name>
		<value>*</value>
	</property>
	<property>
		<name>httpfs.proxyuser.hue.groups</name>
		<value>*</value>
	</property>
</configuration>

备注：修改完HDFS相关配置后，需要把配置scp给集群中每台机器，重启hdfs服务。

Hue配置

# 进入 Hue 安装目录
cd /opt/lagou/servers/hue
# 进入配置目录
cd desktop/conf
# 复制一份HUE的配置文件，并修改复制的配置文件
cp pseudo-distributed.ini.tmpl pseudo-distributed.ini
vi pseudo-distributed.ini

####修改内容
# [desktop]
http_host=linux122
http_port=8000
is_hue_4=true
time_zone=Asia/Shanghai
dev=true
server_user=hue
server_group=hue
default_user=hue
# 211行左右。禁用solr，规避报错
app_blacklist=search
# [[database]]。Hue默认使用SQLite数据库记录相关元数据，替换为mysql
engine=mysql
host=linux123
port=3306
user=hive
password=12345678
name=hue
# 1003行左右，Hadoop配置文件的路径
hadoop_conf_dir=/opt/lagou/servers/hadoop-2.9.2/etc/hadoop

###在mysql所在的服务器上创建数据库hue，用来存放元数据
mysql -uhive -p12345678
mysql> create database hue;
# 初始化数据库
cd build/env/bin
./hue syncdb
cd build/env/bin
./hue migrate
# 检查数据

启动 Hue 服务

# 增加 hue 用户和用户组
groupadd hue
useradd -g hue hue
# 在hue安装路径下执行
build/env/bin/supervisor

在浏览器中输入：centos7-2:8000，可以看见以下画面，说明安装成功。
第一次访问的时候，需要设置超级管理员用户和密码。记住它(hue/123456)。

3.3 Hue整合Hadoop、Hive

修改参数文件 /opt/lagou/servers/hue/desktop/conf/pseudo-distributed.ini

集成HDFS、YARN

# 211 行。 没有安装 Solr，禁用，否则一直报错
app_blacklist=search
# [hadoop] -- [[hdfs_clusters]] -- [[[default]]]
# 注意端口号。下面语句只要一个
# fs_defaultfs=hdfs://linux121:8020
fs_defaultfs=hdfs://
webhdfs_url=http://linux121:50070/webhdfs/v1
# 211 行
hadoop_conf_dir=/opt/lagou/servers/hadoop-2.9.2/etc/hadoop
# [hadoop] -- [[yarn_clusters]] -- [[[default]]]
resourcemanager_host=linux123
resourcemanager_port=8032
submit_to=True
resourcemanager_api_url=http://linux123:8088
proxy_api_url=http://linux123:8088
history_server_api_url=http://linux123:19888

集成Hive
集成Hive需要启动 Hiveserver2 服务，在linux123节点上启动 Hiveserver2

# [beeswax]
hive_server_host=linux123
hive_server_port=10000
hive_conf_dir=/opt/lagou/servers/hive-2.3.7/conf

最后重启hue，登录端口，可以发现数据库已经正常显示。
在这里插入图片描述

Shawlizao

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
大数据学习_Hive_调优策略/_Hue的安装和使用

目录1 Hive调优策略1.1 架构优化1.2 参数优化1.3 SQL优化1 Hive调优策略Hive作为大数据领域常用的数据仓库组件，在设计和开发阶段需要注意效率。影响Hive效率的不仅仅是数据量过大；数据倾斜、数据冗余、job或I/O过多、MapReduce分配不合理等因素都对Hive的效率有影响。对Hive的调优既包含对HiveQL语句本身的优化，也包含Hive配置项和MR方面的调整。从以下三个方面展开：架构优化参数优化SQL优化1.1 架构优化执行引擎Hive支持多种执行引
复制链接

扫一扫

专栏目录