部署hadoop最低配置 hadoop最小配置

HDFS核心参数建议配置

NameNode

内存

• Hadoop2.x:

• NameNode 内存默认2000m，如果服务器内存4G，NameNode内存可以配置3g。在hadoop-env.sh 文件中配置如下。

HADOOP_NAMENODE_OPTS=-Xmx3072m

• Hadoop3.x

• hadoop-env.sh 中描述 Hadoop 的内存是动态分配的
• 建议配置:

• NameNode最小值为1G,每增加1000000个Block增加1G内存
• DataNode最小值为4G,每增加1000000个Block增加1G内存

export HDFS_NAMENODE_OPTS="-Dhadoop.security.logger=INFO,RFAS -Xmx1024m"
export HDFS_DATANODE_OPTS="-Dhadoop.security.logger=ERROR,RFAS -Xmx1024m"

心跳并发

• hdfs-site.xml

<property>
	<name>dfs.namenode.handler.count</name> 
    <value>21</value>
	<description>NameNode 有一个工作线程池，用来处理不同  DataNode 的并发心跳以及客户端并发的元数据操作。对于大集群或者有大量客户端的集群来说，通常需要增大该参数。默认值是 10。</description>
</property>

dfs.namenode.handler.count=20 ×$log_e^{集群规模}$
比如集群规模（DataNode 台数）为 3 台时，此参数设置为 21。可通过简单的 python 代码计算该值，代码如下。

>>> import math >>> print int(20*math.log(3)) >>> quit()

回收站配置

开启回收站功能，可以将删除的文件在不超时的情况下，恢复原数据，起到防止误删除、 备份等作用。

参数说明

• 默认值 fs.trash.interval = 0，0 表示禁用回收站；其他值表示设置文件的存活时间。
• 默认值 fs.trash.checkpoint.interval = 0，检查回收站的间隔时间。如果该值为 0，则该值设置和 fs.trash.interval 的参数值相等。
• 要求 fs.trash.checkpoint.interval <= fs.trash.interval。

使用：

通过命令行hadoop /user/atguigu/input fs -rm -r 删除的文件会进入回收站

通过JavaClient调用Trash trash = New Trash(conf); trash.moveToTrash(path);删除文件会进入回收站

其他通过NameNode网页或者直接调用程序删除不会进入回收站

HDFS集群压测

HDFS 的读写性能主要受网络和磁盘影响。

写性能测试

hadoop jar /opt/module/hadoop- 3.1.3/share/hadoop/mapreduce/hadoop-mapreduce-client- jobclient-3.1.3-tests.jar  TestDFSIO  -write  -nrFiles  10  -fileSize 128MB

参数说明：

nrFiles n ： 生成 mapTask 的数量，生产环境一般可通过 查看 CPU核数，设置为（CPU 核数 - 1）

输出结果说明：

Total MBytes processed： 单个 map 处理的文件大小

Throughput mb/sec： 单个 mapTak 的吞吐量, 计算方式：处理的总文件大小/每一个 mapTask 写数据的时间累加 集群整体吞吐量：生成 mapTask 数量*单个 mapTak 的吞吐量

Average IO rate mb/sec： 平均 mapTak 的吞吐量，计算方式：每个 mapTask 处理文件大小/每一个 mapTask 写数据的时间全部相加除以 task 数量

IO rate std deviation： 方差、反映各个 mapTask 处理的差值，越小越均衡

如果测试过程中，出现异常

设置yarn-site.xml

<!--是否启动一个线程检查每个任务正使用的虚拟内存量，如果任务超出分配值，则 直接将其杀掉，默认是 true -->
<property>
	<name>yarn.nodemanager.vmem-check-enabled</name> 
    <value>false</value>
</property>

读性能测试

hadoop jar /opt/module/hadoop- 3.1.3/share/hadoop/mapreduce/hadoop-mapreduce-client- jobclient-3.1.3-tests.jar  TestDFSIO  -read  -nrFiles  10  -fileSize 128MB

• 删除测试数据

hadoop jar /opt/module/hadoop- 3.1.3/share/hadoop/mapreduce/hadoop-mapreduce-client- jobclient-3.1.3-tests.jar TestDFSIO -clean

HDFS多目录配置

NameNode

本地目录可以配置成多个，且每个目录存放内容相同，增加了可靠性

hdfs-site.xml

<property>
	<name>dfs.namenode.name.dir</name>
	<value>file://${hadoop.tmp.dir}/dfs/name1,file://${hadoop.tmp. dir}/dfs/name2</value>
</property>

DataNode

配置成多个目录，每个目录存储的数据不一样

hdfs-site.xml

<property>
	<name>dfs.datanode.data.dir</name>
	<value>file://${hadoop.tmp.dir}/dfs/data1,file://${hadoop.tmp. dir}/dfs/data2</value>
</property>

磁盘间数据均衡

生产环境，由于硬盘空间不足，往往需要增加一块硬盘。刚加载的硬盘没有数据时，可 以执行磁盘数据均衡命令。（Hadoop3.x 新特性）

# 生成均衡计划,多磁盘才会生效
hdfs diskbalancer -plan localhost
# 执行均衡计划
hdfs diskbalancer -execute localhost.plan.json
# 查看当前均衡任务的执行情况
hdfs diskbalancer -query localhost
# 取消均衡任务
hdfs diskbalancer -cancel localhost.plan.json

HDFS集群扩容与缩容

黑白名单

1. 在 NameNode 节点的/opt/module/hadoop-3.1.3/etc/hadoop 目录下分别创建 whitelist 和blacklist 文件

在 whitelist 中添加主机名称为白名单，blacklist 中添加为黑名单

1. 在 hdfs-site.xml 配置文件中增加 dfs.hosts 配置参数

<!-- 白名单 -->
<property>
    <name>dfs.hosts</name>
    <value>/opt/module/hadoop-3.1.3/etc/hadoop/whitelist</value>
</property>
<!-- 黑名单 -->
<property>
    <name>dfs.hosts.exclude</name>
    <value>/opt/module/hadoop-3.1.3/etc/hadoop/blacklist</value>
</property>

1. 第一次配置黑白名单必须重启集群，之后只需要刷新NameNode节点即可

# 刷新NameNode
hdfs dfsadmin -refreshNodes Refresh nodes successful

扩容

1. 新增一台Hadoop服务器，将集群内配置文件分发到新服务器上，直接启动dataNode即可关联到集群

hdfs --daemon start datanode
yarn --daemon start nodemanager

2. 将新服务器添加到白名单
3. 将新服务器添加到worker中

服务器见数据均衡

# 10，代表的是集群中各个节点的磁盘空间利用率相差不超过10%，可根据实际情况进行调整
sbin/start-balancer.sh  - threshold 10
# 停止服务均衡
sbin/stop-balancer.sh

由于 HDFS 需要启动单独的 Rebalance Server 来执行 Rebalance 操作，所以尽量 不要在 NameNode 上执行 start-balancer.sh，而是找一台比较空闲的机器

缩容

将需要退出的服务器添加到黑名单上即可

HDFS存储优化

纠删码

HDFS 默认情况下，一个文件有 3 个副本，这样提高了数据的可靠性，但也带来了 2 倍的冗余开销。Hadoop3.x 引入了纠删码，采用计算的方式可以节省约 50％左右的存储空间。将一份文件按照纠删码策略将其拆分为数据单元和校验单元, 每个单元都可以由其它单元计算得来

相关命令

# 查看所有策略
hdfs ec -listPolicies
# 添加新策略
hdfs ec -addPolicies -policyFile <file>
# 获取路径上设置的策略
hdfs ec -getPolicy -path <path>
# 删除策略
hdfs ec -removePolicy -policy <policy>
# 给文件夹设置策略
hdfs ec -setPolicy -path <path> [-policy <policy>] [-replicate]
# 取消策略
hdfs ec -unsetPolicy -path <path>
# 启用某一个纠删码策略
hdfs ec -enablePolicy -policy <policy>
# 关闭某一个纠删码策略
hdfs ec -disablePolicy -policy <policy>

纠删码策略名称解释:

RS-3-2-1024k

RS->使用RS编码

3->三个数据单元

2->两个校验单元

1024k->每个单元大小为1M

编码类型还有:RS-LEGACY, XOR(比RS快)

异构存储

存储类型:

• RAM_DISK：（内存镜像文件系统）
• SSD：（SSD固态硬盘）
• DISK：（普通磁盘，在HDFS中，如果没有主动声明数据目录存储类型默认都是DISK）
• ARCHIVE：（没有特指哪种存储介质，主要的指的是计算能力比较弱而存储密度比较高的存储介质，用来解决数据量的 容量扩增的问题，一般用于归档）

存储策略:

从Lazy_Persist到Cold，分别代表了设备的访问速度从快到慢

策略ID策略名称副本分布说明15Lazy_PersistRAM_DISK:1, DISK:N-1一个副本在RAM_DISK,其它在磁盘12All_SSDSSD: N所有副本在SSD中10One_SSDSSD: 1, DISK: N-1一个副本在SSD,其它在磁盘7Hot(default)DISK: N所有副本在磁盘中5WarmDISK: 1, ARCHIVE: N-1一个副本在磁盘中, 其它在归档存储上2ColdARCHIVE: N所有副本在归档存储上

命令

# 查看存储策略
hdfs storagepolicies -listPolicies
# 为指定路径设置存储策略
hdfs storagepolicies -setStoragePolicy -path xxx -policy xxx
# 获取指定路径（数据存储目录或文件）的存储策略
hdfs storagepolicies -getStoragePolicy -path xxx
# 取消存储策略；执行改命令之后该目录或者文件，以其上级的目录为准，如果是根 目录，那么就是  HOT
hdfs storagepolicies -unsetStoragePolicy -path xxx
# 查看文件块的分布
bin/hdfs fsck xxx -files -blocks -locations
#查看集群节点
hadoop dfsadmin -report

• 指定磁盘是SSD还是DISK,hdfs-site.xml

<property>
	<name>dfs.replication</name> 
    <value>2</value>
</property> <property>
	<name>dfs.storage.policy.enabled</name>
    <value>true</value>
</property> 
<property>
	<name>dfs.datanode.data.dir</name> 
    <value>[SSD]file:///opt/module/hadoop-3.1.3/hdfsdata/ssd[RAM_DISK]file:///opt/module/hadoop-3.1.3/hdfsdata/ram_disk</value>
    <description>存储路径前加上[SSD]或其它标识即可.默认DISK</description>
</property>

LAZY_PERSIST策略注意事项:

配置LAZY_PERSIST策略,还需要配置“dfs.datanode.max.locked.memory”， “dfs.block.size”参数才可以生效.

存储策略为LAZY_PERSIST 时，文件块副本都存储在DISK 上的原因有如下两点：
（1）当客户端所在的DataNode节点没有 RAM_DISK 时，则会写入客户端所在的DataNode 节点的 DISK 磁盘，其余副本会写入其他节点的 DISK 磁盘。
（2）当客户端所在的 DataNode 有 RAM_DISK，但“dfs.datanode.max.locked.memory” 参数值未设置或者设置过小（小于“dfs.block.size”参数值）时，则会写入客户端所在的 DataNode 节点的 DISK 磁盘，其余副本会写入其他节点的 DISK 磁盘。
但是由于虚拟机的“max locked memory”为 64KB，所以，如果参数配置过大，还会报错,具体修改自行查找

HDFS故障处理

NameNode故障处理

如果集群运行过程中,NameNode出现故障,其存储数据丢失,如何恢复NameNode.

拷贝 SecondaryNameNode 中数据到原 NameNode 存储数据目录

scp -r atguigu@hadoop104:/opt/module/hadoop- 3.1.3/data/dfs/namesecondary/* ./name/

重新启动 NameNode即可

集群安全模式&磁盘修复

• 安全模式：文件系统只接受读数据请求，而不接受删除、修改等变更请求
• 进入安全模式场景
  ➢ NameNode 在加载镜像文件和编辑日志期间处于安全模式；
  ➢ NameNode 再接收 DataNode 注册时，处于安全模式
• 退出安全模式条件

• dfs.namenode.safemode.min.datanodes:最小可用 datanode 数量，默认 0
• dfs.namenode.safemode.threshold-pct:副本数达到最小要求的 block 占系统总 block 数的 百分比，默认 0.999f。（只允许丢一个块）
• dfs.namenode.safemode.extension:稳定时间，默认值 30000 毫秒，即 30 秒

• 命令

# （功能描述：查看安全模式状态）
bin/hdfs dfsadmin -safemode get 
# （功能描述：进入安全模式状态）
bin/hdfs dfsadmin -safemode enter 
# （功能描述：离开安全模式状态）
bin/hdfs dfsadmin -safemode leave
# （功能描述：等待安全模式状态）,可以使用此命令在集群启动后运行一些如下脚本
bin/hdfs dfsadmin -safemode wait

#!/bin/bash
hdfs dfsadmin -safemode wait
hdfs dfs -put /opt/module/hadoop-3.1.3/README.txt /

• 文件修复: 如果集群中某一服务器上文件的块丢失, 集群会自动将文件找回, 但如果文件所有备份都缺失某个块的信息, 集群会进入安全模式

• 手动离开后, 也会提示某些块缺失, 这些文件只能通过磁盘修复去找回了

慢磁盘

“慢磁盘”指的时写入数据非常慢的一类磁盘。其实慢性磁盘并不少见，当机器运行时间长了，上面跑的任务多了，磁盘的读写性能自然会退化，严重时就会出现写入数据延时的.

如何发现慢磁盘？
正常在 HDFS 上创建一个目录，只需要不到 1s 的时间。如果你发现创建目录超过1分钟及以上，而且这个现象并不是每次都有。只是偶尔慢了一下，就很有可能存在慢磁盘。 可以采用如下方法找出是哪块磁盘慢：

• 通过心跳未联系时间。

一般出现慢磁盘现象，会影响到 DataNode 与 NameNode 之间的心跳。正常情况心跳时 间间隔是 3s。超过 3s 说明有异常。

• fio 命令，测试磁盘的读写性能

sudo yum install -y fio
# 顺序读测试
sudo fio -
filename=/home/atguigu/test.log -direct=1 -iodepth 1 -thread -rw=read -ioengine=psync -bs=16k -size=2G -numjobs=10 - runtime=60 -group_reporting -name=test_r
# 顺序写测试
sudo fio -
filename=/home/atguigu/test.log -direct=1 -iodepth 1 -thread -rw=write -ioengine=psync -bs=16k -size=2G -numjobs=10 - runtime=60 -group_reporting -name=test_w
# 随机写测试
sudo fio -
filename=/home/atguigu/test.log -direct=1 -iodepth 1 -thread -rw=randwrite -ioengine=psync -bs=16k -size=2G -numjobs=10 - runtime=60 -group_reporting -name=test_randw
# 混合随机读写
sudo fio -
filename=/home/atguigu/test.log -direct=1 -iodepth 1 -thread - rw=randrw -rwmixread=70 -ioengine=psync -bs=16k -size=2G - numjobs=10 -runtime=60 -group_reporting -name=test_r_w - ioscheduler=noop

小文件归档

HDFS 存储小文件弊端

每个文件均按块存储，每个块的元数据存储在 NameNode 的内存中，因此 HDFS 存储小文件会非常低效。因为大量的小文件会耗尽 NameNode 中的大部分内存。但注意，存储小文件所需要的磁盘容量和数据块的大小无关。例如，一个 1MB 的文件设置为128MB 的块 存储，实际使用的是 1MB 的磁盘空间，而不是128MB。

解决存储小文件办法之一

HDFS 存档文件或 HAR 文件，是一个更高效的文件存档工具，它将文件存入HDFS 块， 在减少NameNode内存使用的同时，允许对文件进行透明的访问。具体说来，HDFS 存档文件对内还是一个一个独立文件，对 NameNode 而言却是一个整体，减少了 NameNode 的内存。

# 归档文件
hadoop archive -archiveName input.har -p /input  /output
# 查看归档
hadoop fs -ls har:///output/input.har
# 解归档文件
hadoop fs -cp har:///output/input.har/*   /

HDFS集群迁移

Apache 和 Apache 集群间数据拷贝,使用distcp命令实现两个Hadoop 集群之间的递归数据复制

bin/hadoop distcp hdfs://hadoop102:8020/user/atguigu/hello.txt
hdfs://hadoop105:8020/user/atguigu/hello.txt

MapReduce相关

MapReduce 跑的慢的原因

• 计算机性能:CPU、内存、磁盘、网络
• I/O 操作优化:

• 数据倾斜
• Map 运行时间太长，导致 Reduce 等待过久
• 小文件过多

常用调优参数

Map

• 自定义分区，减少数据倾斜;

• 定义类，继承Partitioner接口，重写getPartition方法

• 减少溢写的次数

• Shuffle的环形缓冲区大小，默认100m，可以提高到200m
• mapreduce.map.sort.spill.percent环形缓冲区溢出的阈值，默认80% ，可以提高的90%

• 增加每次Merge合并次数

• mapreduce.task.io.sort.factor默认10，可以提高到20

• 在不影响业务结果的前提条件下可以提前采用Combiner

• job.setCombinerClass(xxxReducer.class);

• 为了减少磁盘IO，可以采用Snappy或者LZO压缩

• conf.setBoolean(“mapreduce.map.output.compress”, true);
• conf.setClass(“mapreduce.map.output.compress.codec”,SnappyCodec.class,CompressionCodec.class);

• mapreduce.map.memory.mb

• 默认MapTask内存上限1024MB。 可以根据128m数据对应1G内存原则提高该内存。

• mapreduce.map.java.opts

• 控制MapTask堆内存大小。（如果内存不够， 报：java.lang.OutOfMemoryError）

• mapreduce.map.cpu.vcores

• 默认MapTask的CPU核数1。计算密集型任务可以增加CPU核数

• 异常重试

• mapreduce.map.maxattempts每个Map Task最大重试次数，一旦重试 次数超过该值，则认为Map Task运行失败，默认值：4。根据机器 性能适当提高。

Reduce

• mapreduce.reduce.shuffle.parallelcopies

• 每个Reduce去Map 中拉取数据的并行数，默认值是5。可以提高到10。

• mapreduce.reduce.shuffle.input.buffer.percent

• Buffer大小占Reduce可用内存的比例，默认值0.7。可以提高到0.8

• mapreduce.reduce.shuffle.merge.percent

• Buffer中的数据达到多少比例 开始写入磁盘，默认值0.66。可以提高到0.75

• mapreduce.reduce.memory.mb

• 默认ReduceTask内存上限1024MB， 根据128m数据对应1G内存原则，适当提高内存到4-6G

• mapreduce.reduce.java.opts：

• 控制ReduceTask堆内存大小。（如果内 存不够，报：java.lang.OutOfMemoryError）

• mapreduce.reduce.cpu.vcores

• 默认ReduceTask的CPU核数1个。可 以提高到2-4个

• mapreduce.reduce.maxattempts

• 每个Reduce Task最大重试次数， 一旦重试次数超过该值，则认为Map Task运行失败，默认值：4

• mapreduce.job.reduce.slowstart.completedmaps

• 当MapTask完成的 比 例达到该值后才会为ReduceTask申请资源。默认是0.05。

• mapreduce.task.timeout

• 如果一个Task在一定时间内没有任何进入， 即不会读取新的数据，也没有输出数据，则认为该Task处于Block状态， 可能是卡住了，也许永远会卡住，为了防止因为用户程序永远Block住 不退出，则强制设置了一个该超时时间（单位毫秒），默认是600000 （10分钟）。如果你的程序对每条输入数据的处理时间过长，建议将 该参数调大。

• 如果可以不用Reduce，尽可能不用

数据倾斜问题

• 数据频率倾斜——某一个区域的数据量要远远大于其他区域。
• 数据大小倾斜——部分记录的大小远远大于平均值。

减少数据倾斜的方法

1. 首先检查是否空值过多造成的数据倾斜
   生产环境，可以直接过滤掉空值；如果想保留空值，就自定义分区，将空值加随机数打散。最后再二次聚合。
2. 能在 map 阶段提前处理，最好先在 Map 阶段处理。如：Combiner、MapJoin
3. 设置多个 reduce 个数

Yarn相关

常用的调优参数

• yarn.resourcemanager.scheduler.client.thread-count

• ResourceManager 处理调度 器请求的线程数量

• yarn.resourcemanager.scheduler.class

• 配置调度器

• yarn.nodemanager.resource.memory-mb
  yarn.nodemanager.resource.system-reserved-memory-mb

• NodeManager为系统保留 多少内存，和上一个参数二者取一即可

• yarn.nodemanager.resource.cpu-vcores

• NodeManager使用 CPU核数

• yarn.nodemanager.resource.count-logical-processors-as-cores

• 是否将虚拟核 数当作 CPU核数

• yarn.nodemanager.resource.pcores-vcores-multiplier

• 虚拟核数和物理核数乘数，例 如：4核 8线程，该参数就应设为 2

• yarn.nodemanager.resource.detect-hardware-capabilities

• 是否让 yarn 自己检测硬 件进行配置

• yarn.nodemanager.pmem-check-enabled

• 是否开启物理内存检查限制 container

• yarn.nodemanager.vmem-check-enabled

• 是否开启虚拟内存检查限制 container

• yarn.nodemanager.vmem-pmem-ratio

• 虚拟内存物理内存比例

• yarn.scheduler.minimum-allocation-mb

• 容器最小内存

• yarn.scheduler.maximum-allocation-mb

• 容器最大内存

• yarn.scheduler.minimum-allocation-vcores

• 容器最小核数

• yarn.scheduler.maximum-allocation-vcores

• 容器最大核数

• 参数具体使用案例看Hadoop学习-Yarn

综合调优

小文件解决方案

1. 在数据采集的时候，就将小文件或小批数据合成大文件再上传 HDFS（数据源头）
2. Hadoop Archive（存储方向）,将小文件放入 HDFS 块中的文件存档工具，能够将多个小文件打包成一 个 HAR 文件，从而达到减少 NameNode 的内存使用
3. CombineTextInputFormat（计算方向）,将多个小文件在切片过程中生成一个单独的切片或者少 量的切片。
4. 开启 uber 模式，实现 JVM 重用（计算方向）
   默认情况下，每个 Task 任务都需要启动一个 JVM 来运行，如果 Task 任务计算的数据 量很小，我们可以让同一个 Job 的多个 Task 运行在一个 JVM 中，不必为每个 Task 都开启 一个 JVM。

<!--开启 uber 模式，在 mapred-site.xml 中添加如下配置-->
<!-- 开启  uber模式，默认关闭   -->
<property>
	<name>mapreduce.job.ubertask.enable</name>
    <value>true</value>
</property>
<!-- uber模式中最大的 mapTask数量，可向下修改       --> 
<property>
	<name>mapreduce.job.ubertask.maxmaps</name> 
    <value>9</value>
</property>
<!-- uber模式中最大的 reduce数量，可向下修改   -->
<property>
	<name>mapreduce.job.ubertask.maxreduces</name> 
    <value>1</value>
</property>
<!-- uber模式中最大的输入数据量，默认使用 dfs.blocksize 的值，可向下修 改    -->
<property>
	<name>mapreduce.job.ubertask.maxbytes</name> 
    <value></value>
</property>

测试 MapReduce 计算性能

使用 Sort 程序评测 MapReduce,一个虚拟机不超过 150G 磁盘尽量不要执行这段代码

# 使用  RandomWriter 来产生随机数，每个节点运行  10 个  Map 任务，每个  Map 产 生大约 1G 大小的二进制随机数
hadoop jar /opt/module/hadoop-3.1.3/share/hadoop/mapreduce/hadoop-mapreduce-examples-3.1.3.jar randomwriter random-data
# 执行 Sort 程序
hadoop jar /opt/module/hadoop-3.1.3/share/hadoop/mapreduce/hadoop-mapreduce-examples-3.1.3.jar sort random-data sorted-data
# 验证数据
hadoop jar /opt/module/hadoop-3.1.3/share/hadoop/mapreduce/hadoop-mapreduce-client- jobclient-3.1.3-tests.jar testmapredsort -sortInput random-data -sortOutput sorted-data

生产环境需要调优参数总结

服务器 3 台，每台配置 4G 内存，4 核 CPU，4 线程。数据1G

1G / 128m = 8 个 MapTask；1 个 ReduceTask；1 个 mrAppMaster 平均每个节点运行 10 个 / 3 台 ≈ 3 个任务（4 3 3）

• hadoop-env.sh

export HDFS_NAMENODE_OPTS="-Dhadoop.security.logger=INFO,RFAS -Xmx1024m"
export HDFS_DATANODE_OPTS="-Dhadoop.security.logger=ERROR,RFAS -Xmx1024m"

• hdfs-site.xml

<!-- NameNode有一个工作线程池，默认值是 10 -->
<property>
	<name>dfs.namenode.handler.count</name> 
    <value>21</value>
</property>

• core-site.xml

<!-- 配置垃圾回收时间为  60分钟   -->
<property>
	<name>fs.trash.interval</name>
    <value>60</value>
</property>

• mapred-site.xml

<!-- 环形缓冲区大小，默认  100m -->
<property>
	<name>mapreduce.task.io.sort.mb</name> 
    <value>100</value>
</property>
<!-- 环形缓冲区溢写阈值，默认  0.8 -->
<property>
	<name>mapreduce.map.sort.spill.percent</name> 
    <value>0.80</value>
</property>
<!-- merge合并次数，默认 10个   -->
<property>
	<name>mapreduce.task.io.sort.factor</name>
    <value>10</value>
</property>
<!-- maptask 内 存 ， 默 认    1g；        maptask 堆 内 存 大 小 默 认 和 该 值 大 小 一 致 mapreduce.map.java.opts -->
<property>
	<name>mapreduce.map.memory.mb</name>
    <value>-1</value>
</property>
<!-- matask的  CPU核数，默认 1个   -->
<property>
	<name>mapreduce.map.cpu.vcores</name>
    <value>1</value>
</property>
<!-- matask异常重试次数，默认 4次   -->
<property>
	<name>mapreduce.map.maxattempts</name> 
    <value>4</value>
</property>
<!-- 每个  Reduce去 Map中拉取数据的并行数。默认值是 5 -->
<property>
	<name>mapreduce.reduce.shuffle.parallelcopies</name>
    <value>5</value> 
</property>
<!-- Buffer大小占  Reduce可用内存的比例，默认值 0.7 -->
<property>
	<name>mapreduce.reduce.shuffle.input.buffer.percent</name>
    <value>0.70</value>
</property>
<!-- Buffer中的数据达到多少比例开始写入磁盘，默认值 0.66。   -->
<property>
	<name>mapreduce.reduce.shuffle.merge.percent</name>
    <value>0.66</value>
</property>
<!-- reducetask 内存，默认   1g；reducetask 堆内存大小默认和该值大小一致 mapreduce.reduce.java.opts -->
<property>
	<name>mapreduce.reduce.memory.mb</name> 
    <value>-1</value>
</property>
<!-- reducetask的 CPU核数，默认 1个   -->
<property>
	<name>mapreduce.reduce.cpu.vcores</name> 
    <value>2</value>
</property>
<!-- reducetask失败重试次数，默认  4次   -->
<property>
	<name>mapreduce.reduce.maxattempts</name> 
    <value>4</value>
</property>
<!-- 当 MapTask完成的比例达到该值后才会为 ReduceTask申请资源。默认是 0.05 -->
<property>
	<name>mapreduce.job.reduce.slowstart.completedmaps</name>
    <value>0.05</value>
</property>
<!-- 如果程序在规定的默认  10分钟内没有读到数据，将强制超时退出   -->
<property>
	<name>mapreduce.task.timeout</name>
    <value>600000</value>
</property>

• yarn-site.xml

<!-- 选择调度器，默认容量    -->
<property>
	<name>yarn.resourcemanager.scheduler.class</name>
	<value>org.apache.hadoop.yarn.server.resourcemanager.scheduler.capaci ty.CapacityScheduler</value>
</property>
<!-- ResourceManager处理调度器请求的线程数量,默认  50；如果提交的任务数大于  50，可以 增加该值，但是不能超过  3台   * 4线程   = 12线程（去除其他应用程序实际不能超过  8）   -->
<property>
	<name>yarn.resourcemanager.scheduler.client.thread-count</name> 
    <value>8</value>
</property>
<!-- 是否让  yarn自动检测硬件进行配置，默认是  false，如果该节点有很多其他应用程序，建议 手动配置。如果该节点没有其他应用程序，可以采用自动   -->
<property>
	<name>yarn.nodemanager.resource.detect-hardware-capabilities</name> 	
    <value>false</value>
</property>
<!-- 是否将虚拟核数当作  CPU核数，默认是  false，采用物理  CPU核数   -->
<property>
	<name>yarn.nodemanager.resource.count-logical-processors-as- cores</name>
	<value>false</value> 
</property>
<!-- 虚拟核数和物理核数乘数，默认是  1.0 -->
<property>
	<name>yarn.nodemanager.resource.pcores-vcores-multiplier</name> 
    <value>1.0</value>
</property>
<!-- NodeManager使用内存数，默认  8G，修改为  4G内存    -->
<property>
    <name>yarn.nodemanager.resource.memory-mb</name>
    <value>4096</value>
</property>
<!-- nodemanager的  CPU核数，不按照硬件环境自动设定时默认是  8个，修改为  4个   -->
<property>
    <name>yarn.nodemanager.resource.cpu-vcores</name>
    <value>4</value> 
</property>
<!-- 容器最小内存，默认  1G -->
<property>
	<name>yarn.scheduler.minimum-allocation-mb</name>
    <value>1024</value>
</property>
<!-- 容器最大内存，默认  8G，修改为  2G -->
<property>
	<name>yarn.scheduler.maximum-allocation-mb</name>
    <value>2048</value>
</property>
<!-- 容器最小  CPU核数，默认  1个   -->
<property>
	<name>yarn.scheduler.minimum-allocation-vcores</name>
    <value>1</value>
</property>
<!-- 容器最大  CPU核数，默认  4个，修改为  2个   -->
<property>
	<name>yarn.scheduler.maximum-allocation-vcores</name>
    <value>2</value>
</property>
<!-- 虚拟内存检查，默认打开，修改为关闭    -->
<property>
	<name>yarn.nodemanager.vmem-check-enabled</name>
    <value>false</value>
</property>
<!-- 虚拟内存和物理内存设置比例,默认  2.1 -->
<property>
	<name>yarn.nodemanager.vmem-pmem-ratio</name> 
    <value>2.1</value>
</property>