CDH5.10 配置

HDFS:

dfs.datanode.du.reserved 100g （计算方法 磁盘总容量*0.05+50g）其中50g适量即可

其他参数指定一些日志目录和datanode目录

rebalance阈值 2

不启用hdfs权限

启用zookeeper

还有一些进程的内存限制大小

记得配置HA

dfs.datanode.handler.count=30

dfs.namenode.handler.count=70

HBASE:

配置master和regionserver的内存限制即可

zookeeper.session.timeout=240000

HIVE:

hive.exec.reducers.bytes.per.reducer =1g

hive.merge.mapredfiles = true //输出合并

hive.merge.smallfiles.avgsize = 64m //输出合并

hive.fetch.task.conversion = more

hive.exec.compress.output=true (如果impala需要访问结果表，可以不压缩)

mapred.output.compression.codec=org.apache.hadoop.io.compress.GzipCodec(与上条结合使用)

hive.exec.compress.intermediate = true

hive.intermediate.compression.codec=org.apache.hadoop.io.compress.SnappyCodec(与上条结合使用)

hive.map.aggr=true

hive.exec.parallel =true
mapred.max.split.size=256000000 //输入合并
mapred.min.split.size.per.node=100000000 //输入合并 
mapred.min.split.size.per.rack=100000000 //输入合并
hive.input.format=org.apache.hadoop.hive.ql.io.CombineHiveInputFormat //输入合并

java客户端参数

-XX:MaxPermSize=512M -Djava.net.preferIPv4Stack=true

YARN:

yarn.app.mapreduce.am.resource.mb=2000 

AM最大堆堆栈 1.5g

NM最大堆内存 2g

RM最大堆内存 4g

jobhistory server最大堆内存 2g

客户端java堆内存 1.5g

mapreduce.map.memory.mb=4000

mapreduce.reduce.memory.mb=8000

mapreduce.map.java.opts.max.heap=3435973837

mapreduce.reduce.java.opts.max.heap=6871947674

yarn.nodemanager.resource.memory-mb=136g //单个nm全部可分配给容器的最大内存

yarn.nodemanager.resource.cpu-vcores=17//单个nm可分配给容器的最多cpu

yarn.scheduler.minimum-allocation-mb=2000 //最小容器内存

yarn.scheduler.increment-allocation-mb=1000//容器内存增量
yarn.scheduler.maximum-allocation-mb=8000 //最大容器内存

yarn.scheduler.maximum-allocation-vcores=4 //最大容器核数

yarn.nodemanager.vmem-check-enabled=false

mapreduce.shuffle.port=23526

 

内存配置

关于 内存 相关的配置可以参考hortonwork公司的文档 Determine HDP Memory Configuration Settings 来配置你的集群。

YARN以及MAPREDUCE所有可用的内存资源应该要除去系统运行需要的以及其他的hadoop的一些程序，总共保留的内存=系统内存+HBASE内存。

可以参考下面的表格确定应该保留的内存：

每台机子内存	系统需要的内存	HBase需要的内存
4GB	1GB	1GB
8GB	2GB	1GB
16GB	2GB	2GB
24GB	4GB	4GB
48GB	6GB	8GB
64GB	8GB	8GB
72GB	8GB	8GB
96GB	12GB	16GB
128GB	24GB	24GB
255GB	32GB	32GB
512GB	64GB	64GB

计算每台机子最多可以拥有多少个container，可以使用下面的公式:

containers = min (2*CORES, 1.8*DISKS, (Total available RAM) / MIN_CONTAINER_SIZE)

说明：

• CORES 为机器CPU核数
• DISKS 为机器上挂载的磁盘个数
• Total available RAM 为机器总内存
• MIN_CONTAINER_SIZE 是指container最小的容量大小，这需要根据具体情况去设置，可以参考下面的表格：

每台机子可用的RAM	container最小值
小于4GB	256MB
4GB到8GB之间	512MB
8GB到24GB之间	1024MB
大于24GB	2048MB

每个container的平均使用内存大小计算方式为：

RAM-per-container = max(MIN_CONTAINER_SIZE, (Total Available RAM) / containers))

通过上面的计算，YARN以及MAPREDUCE可以这样配置：

配置文件	配置设置	默认值	计算值
yarn-site.xml	yarn.nodemanager.resource.memory-mb	8192 MB	= containers * RAM-per-container
yarn-site.xml	yarn.scheduler.minimum-allocation-mb	1024MB	= RAM-per-container
yarn-site.xml	yarn.scheduler.maximum-allocation-mb	8192 MB	= containers * RAM-per-container
yarn-site.xml (check)	yarn.app.mapreduce.am.resource.mb	1536 MB	= 2 * RAM-per-container
yarn-site.xml (check)	yarn.app.mapreduce.am.command-opts	-Xmx1024m	= 0.8 * 2 * RAM-per-container
mapred-site.xml	mapreduce.map.memory.mb	1024 MB	= RAM-per-container
mapred-site.xml	mapreduce.reduce.memory.mb	1024 MB	= 2 * RAM-per-container
mapred-site.xml	mapreduce.map.java.opts		= 0.8 * RAM-per-container
mapred-site.xml	mapreduce.reduce.java.opts		= 0.8 * 2 * RAM-per-container

举个例子：对于128G内存、32核CPU的机器，挂载了7个磁盘，根据上面的说明，系统保留内存为24G，不适应HBase情况下，系统剩余可用内存为104G，计算containers值如下：

containers = min (2*32, 1.8* 7 , (128-24)/2) = min (64, 12.6 , 51) = 13

计算RAM-per-container值如下：

RAM-per-container = max (2, (124-24)/13) = max (2, 8) = 8

这样集群中下面的参数配置值如下：

配置文件	配置设置	计算值
yarn-site.xml	yarn.nodemanager.resource.memory-mb	= 13 * 8 =104 G
yarn-site.xml	yarn.scheduler.minimum-allocation-mb	= 8G
yarn-site.xml	yarn.scheduler.maximum-allocation-mb	= 13 * 8 = 104G
yarn-site.xml (check)	yarn.app.mapreduce.am.resource.mb	= 2 * 8=16G
yarn-site.xml (check)	yarn.app.mapreduce.am.command-opts	= 0.8 * 2 * 8=12.8G
mapred-site.xml	mapreduce.map.memory.mb	= 8G
mapred-site.xml	mapreduce.reduce.memory.mb	= 2 * 8=16G
mapred-site.xml	mapreduce.map.java.opts	= 0.8 * 8=6.4G
mapred-site.xml	mapreduce.reduce.java.opts	= 0.8 * 2 * 8=12.8G

 

IMPALA:

 

mem_limit = -1b

KAFKA:

broker_max_heap_size = 2g

KUDU:

memory_limit_hard_bytes=200g

block_cache_capacity_mb = 2g

maintenance_manager_num_threads = 2

-max_clock_sysn_error_usec=120000000

OOZIE:

oozie.processing_timezone=GMT+0800

SPARK:

spark.kryoserializer.buffer.max = 2047m

spark.network.timeout = 6000s

spark.executor.extraJavaOptions=-XX:MaxDirectMemorySize=4096m

 

num-executors

　　参数说明：该参数用于设置Spark作业总共要用多少个Executor进程来执行。Driver在向YARN集群管理器申请资源时，YARN集群管理器会尽可能按照你的设置来在集群的各个工作节点上，启动相应数量的Executor进程。这个参数非常之重要，如果不设置的话，默认只会给你启动少量的Executor进程，此时你的Spark作业的运行速度是非常慢的。

　　参数调优建议：每个Spark作业的运行一般设置50~100个左右的Executor进程比较合适，设置太少或太多的Executor进程都不好。设置的太少，无法充分利用集群资源；设置的太多的话，大部分队列可能无法给予充分的资源。

executor-memory

　　参数说明：该参数用于设置每个Executor进程的内存。Executor内存的大小，很多时候直接决定了Spark作业的性能，而且跟常见的JVM OOM异常，也有直接的关联。

　　参数调优建议：每个Executor进程的内存设置4G~8G较为合适。但是这只是一个参考值，具体的设置还是得根据不同部门的资源队列来定。可以看看自己团队的资源队列的最大内存限制是多少，num-executors乘以executor-memory，就代表了你的Spark作业申请到的总内存量（也就是所有Executor进程的内存总和），这个量是不能超过队列的最大内存量的。此外，如果你是跟团队里其他人共享这个资源队列，那么申请的总内存量最好不要超过资源队列最大总内存的1/3~1/2，避免你自己的Spark作业占用了队列所有的资源，导致别的同学的作业无法运行。

executor-cores

　　参数说明：该参数用于设置每个Executor进程的CPU core数量。这个参数决定了每个Executor进程并行执行task线程的能力。因为每个CPU core同一时间只能执行一个task线程，因此每个Executor进程的CPU core数量越多，越能够快速地执行完分配给自己的所有task线程。

　　参数调优建议：Executor的CPU core数量设置为2~4个较为合适。同样得根据不同部门的资源队列来定，可以看看自己的资源队列的最大CPU core限制是多少，再依据设置的Executor数量，来决定每个Executor进程可以分配到几个CPU core。同样建议，如果是跟他人共享这个队列，那么num-executors * executor-cores不要超过队列总CPU core的1/3~1/2左右比较合适，也是避免影响其他同学的作业运行。

driver-memory

　　参数说明：该参数用于设置Driver进程的内存。

　　参数调优建议：Driver的内存通常来说不设置，或者设置1G左右应该就够了。唯一需要注意的一点是，如果需要使用collect算子将RDD的数据全部拉取到Driver上进行处理，那么必须确保Driver的内存足够大，否则会出现OOM内存溢出的问题。

spark.default.parallelism

　　参数说明：该参数用于设置每个stage的默认task数量。这个参数极为重要，如果不设置可能会直接影响你的Spark作业性能。

　　参数调优建议：Spark作业的默认task数量为500~1000个较为合适。很多同学常犯的一个错误就是不去设置这个参数，那么此时就会导致Spark自己根据底层HDFS的block数量来设置task的数量，默认是一个HDFS block对应一个task。通常来说，Spark默认设置的数量是偏少的（比如就几十个task），如果task数量偏少的话，就会导致你前面设置好的Executor的参数都前功尽弃。试想一下，无论你的Executor进程有多少个，内存和CPU有多大，但是task只有1个或者10个，那么90%的Executor进程可能根本就没有task执行，也就是白白浪费了资源！因此Spark官网建议的设置原则是，设置该参数为num-executors * executor-cores的2~3倍较为合适，比如Executor的总CPU core数量为300个，那么设置1000个task是可以的，此时可以充分地利用Spark集群的资源。

spark.storage.memoryFraction

　　参数说明：该参数用于设置RDD持久化数据在Executor内存中能占的比例，默认是0.6。也就是说，默认Executor 60%的内存，可以用来保存持久化的RDD数据。根据你选择的不同的持久化策略，如果内存不够时，可能数据就不会持久化，或者数据会写入磁盘。

　　参数调优建议：如果Spark作业中，有较多的RDD持久化操作，该参数的值可以适当提高一些，保证持久化的数据能够容纳在内存中。避免内存不够缓存所有的数据，导致数据只能写入磁盘中，降低了性能。但是如果Spark作业中的shuffle类操作比较多，而持久化操作比较少，那么这个参数的值适当降低一些比较合适。此外，如果发现作业由于频繁的gc导致运行缓慢（通过spark web ui可以观察到作业的gc耗时），意味着task执行用户代码的内存不够用，那么同样建议调低这个参数的值。

spark.shuffle.memoryFraction

　　参数说明：该参数用于设置shuffle过程中一个task拉取到上个stage的task的输出后，进行聚合操作时能够使用的Executor内存的比例，默认是0.2。也就是说，Executor默认只有20%的内存用来进行该操作。shuffle操作在进行聚合时，如果发现使用的内存超出了这个20%的限制，那么多余的数据就会溢写到磁盘文件中去，此时就会极大地降低性能。

　　参数调优建议：如果Spark作业中的RDD持久化操作较少，shuffle操作较多时，建议降低持久化操作的内存占比，提高shuffle操作的内存占比比例，避免shuffle过程中数据过多时内存不够用，必须溢写到磁盘上，降低了性能。此外，如果发现作业由于频繁的gc导致运行缓慢，意味着task执行用户代码的内存不够用，那么同样建议调低这个参数的值。
资源参数的调优，没有一个固定的值，需要同学们根据自己的实际情况（包括Spark作业中的shuffle操作数量、RDD持久化操作数量以及spark web ui中显示的作业gc情况），同时参考本篇文章中给出的原理以及调优建议，合理地设置上述参数。

 

SQOOP:

 

export HADOOP_COMMON_HOME=/opt/cloudera/parcels/CDH/lib/hadoop

export HAOOP_MAPRED_HOME=/opt/cloudera/parcels/CDH/lib/hadoop-mapreduce

export HBASE_HOME=/opt/cloudera/parcels/CDH/lib/hbase

export HIVE_HOME=/opt/cloudera/parcels/CDH/lib/hive

export ZOOCFGDIR=/opt/cloudera/parcels/CDH/lib/zookeeper

export HIVE_CONF_DIR=/opt/cloudera/parcels/CDH/lib/hive/conf/

export HADDOP_CLASSPATH=$HADOOP_CLASSPATH:/opt/cloudera/parcels/CDH/lib/hive/lib/*

ZOOKEEPER:

maxSessionTimeout=240000

minSessionTimeout=12000

tickTime=6000

zookeeper server的java堆栈大小 10g