hdfs面试题

大数据概念

海量数据,具有高增长率、数据类型多样化、一定时间内无法使用常规软件工具进行捕捉、管理和处理的数据集合。

大数据的特征 4V

1. Volume:巨大的数据量
2. Variety:数据类型多样化
   –(1):结构化的数据
   即有固定格式和有限长度的数据。
   –(2):半结构化的数据
   是一些XML或者HTML的格式的数据。
   –(3):非结构化的数据
   现在非结构化的数据越来越多，就是不定长、无固定格式的数据，例如网页、语音，视频等。
3. Velocity: 数据增长速度快
4. Value:价值密度低

google的三篇论文

• 2003年发表的《GFS》
  基于硬盘不够大、数据存储单份的安全隐患问题，提出的分布式文件系统用于存储的理论思想。
  · 解决了如何存储大数据集的问题,核心的思想是硬盘横向扩展以及数据冗余
  GFS的优点:

• 理论上能存储无限数据，因为硬盘可以横向扩展。
• 容错性，数据冗余多份，多份数据同时损坏的概念几乎为零。
• 存储大数据的性能比传统关系型数据库好。

• 2004年发表的《MapReduce》
  基于分布式文件系统的计算分析的编程框架模型。移动计算而非移动数据，分而治之。
  · 解决了如何快速分析大数据集的问题

• 2006年发表的《BigTable》
  针对于传统型关系数据库不适合存储非结构化数据的缺点，提出了另一种适合存储大数据集的解决方案:
  基本思想:把所有数据存入一张表，通过空间换取时间。

hadoop简介

Hadoop是Apache基金会旗下一个开源的分布式存储和分析计算平台，使用java语言开发，具有很好的跨平台性，用于在由商用(廉价)硬件构建的计算机集群上对超大型数据集进行分布式存储和分布式处理.充分使用集群的高速计算和存储.

apache hadoop 和 Cloudera hadoop(cdh)的区别

Hadoop大致可分为Apache Hadoop和第三方发行版本Hadoop。
考虑到Hadoop集群部署的高效性，集群的稳定性以及后期集中的配置管理，业界大多使用Cloudera公司的发行版CDH。
目前国内用的比较多的hadoop是cdh和hdp(HortonWorks data platform)
CDH : Cloudera’s Distribution, including Apache Hadoop
apache:
• 版本管理混乱,多个版本同时再更新
• 部署过程繁琐,通常安装集群需要编写大量的配置文件，分发到每一台节点上，容易出错，效率低下；
• 兼容性差 在Hadoop生态圈中，组件的选择、使用需要大量考虑兼容性的问题
• 对集群的监控，运维，需要安装第三方的其他软件，运维难度比较大；


cdh :由Cloudera基于稳定版本的Apache Hadoop构建
• 版本划分清晰
• 在兼容性，安全性，稳定性上比Apache Hadoop有大幅度的增强；
• 运维简单方便，对于Hadoop集群提供管理，诊断，监控等功能
• CDH提供成体系的文档，很多大公司的应用案例以及商业支持等。

关于hadoop版本迭代中对jdk的支持

hadoop版本	jdk版本要求
<= 2.6	jdk 6
>=2.7.0	jdk7
>=3.0.0	jdk8

hadoop的组件

hadoop2.0 —>
Hadoop Common: 支持其他hadoop组件的基础库和工具.
Hadoop Distributed File System (HDFS™): 为应用数据提供高吞吐量访问的分布式文件系统
Hadoop YARN: 作业调度和集群资源管理框架
Hadoop MapReduce:基于yarn的大数据集并行处理系统.

hadoop3.0以后多了这两个组件
Hadoop Ozone: : hadoop对象存储
Hadoop Submarine:Hadoop的机器学习引擎

hdfs安装模式
一,本地模式
模式特点

无需启动任何守护进程（daemon），所有程序都在单个JVM上执行。使用的是本地文件系统而不是hdfs.主要用于在本地测试和调试mapreduce任务的逻辑是否正确.因此，这种模式适宜用在开发阶段.hadoop不需要做任何配置,默认就是本地模式

安装流程:

①安装jdk环境 解压,更名,配置环境变量,重新加载环境变量,测试环境变量是否配置成功
②安装hadoop 解压,更名,配置环境变量,重新加载环境变量,测试环境变量是否配置成功,wordcount案例测试

二,伪分布式模式

在一台机器上安装，使用的是分布式文件系统hdfs,而不是本地文件系统。
- Hdfs涉及到的相关守护进程(namenode,datanode,secondarynamenode)都运行在一台机器上，都是独立的java进程。增加了代码调试功能，允许检查内存使用情况，HDFS输入输出
作用:模拟一个小的集群,开发测试hadoop程序是否正确执行

安装流程:
①关闭防火墙,NetWorkManager,SELinux
②网络连接模式为NAT模式,主机使用静态ip
③设置ip和主机名的映射关系
④配置主机间的免密登录
⑤安装jdk和hadoop
⑥配置jdk和hadoop环境变量
⑦配置文件修改core-site.xml中配置文件系统为hdfs,在hdfs-site.xml中配置默认副本数为1,hadoop-env.sh中设置jdk环境变量
⑧格式化namenode
⑨启动hdfs
⑩使用jps命令查看相关的守护进程是否都起来,也可以通过namenode的web页面查看活跃节点数是否为1
11 运行wordcount案例,检测配置的伪分布式是否正常运行

三,完全分布式模式

完全分布式，指的是在真实环境下，使用多台机器，共同配合，来构建一个完整的分布式文件系统。通常为生产环境
在真实环境中，hdfs中的相关守护进程也会分布在不同的机器中，比如：
-1. namenode守护进程尽可能的单独部署在一台硬件性能相对来说比较好的机器中。
-2. 其他的每台机器上都会部署一个datanode守护进程，一般的硬件环境即可。
-3. secondarynamenode守护进程最好不要和namenode在同一台机器上。

安装流程:
①关闭防火墙,NetWorkManager,SELinux
②网络连接模式为NAT模式,主机使用静态ip
③设置ip和主机名的映射关系
④配置主机间的免密登录
⑤主机间时间同步
⑥安装jdk和hadoop
⑦配置jdk和hadoop环境变量
⑧在core-site.xml中配置默认文件系统为hdfs,在hdfs-site.xml中配置namenode元数据以及datanode块数据存放目录,默认副本数,块大小,namenode守护进程的http地址,secondarynamenode守护进程的http地址;mapred-site.xml中mapreduce作业的运行框架,mapreduce作业历史服务器地址,yarn-site.xml中配置resourceManager守护进程所在的主机名以及nodeManager的附属服务;hadoop-env.sh和yarn-env.sh中设置jdk环境变量,在slaves文件中设置datanode节点的主机名/ip
hdfs,namenode,secondary namenode,datanode,resource Manager,NodeManager的配置,涉及的配置文件core-site.xml,hdfs-site.xml,mapred-site.xml,yarn-site.xml,hadoop-env.sh,
⑨namenode格式化
⑩启动集群
11 查看所有主机的守护进程是否都起来,web页面是否正常
12 执行wordcount测试用例

hdfs的启动命令

①start-dfs.sh 启动hdfs集群守护进程的脚本
②start-yarn.sh 启动yarn守护进程的脚本
③stop-dfs.sh 停止hdfs集群守护进程的脚本
④stop-yarn.sh 停止yarn守护进程的脚本
⑤hadoop-daemon.sh 单独启/停hdfs集群当前节点某个守护进程的脚本 使用方式hadoop-daemon.sh start 守护进程名(namenode/secondarynamenode/datanode)
⑥hadoop-daemons.sh 单独启/停hdfs集群所有节点的某个守护进程,使用方式同上
⑦yarn-daemon.sh 单独启/停yarn当前节点某个守护进程的脚本 yarn-daemon.sh start/stop 使用方式 yarn-daemon.sh start/stop 守护进程名(resourcemanager/nodemanager)
⑧yarn-daemons.sh 单独启/停yarn所有节点的某个守护进程 使用方式同上

HDFS上的块大小为什么会远远大于传统文件? (Hdfs block数据块大小的设置规则)

block不能设置过大或过小
如果设置的过大,一方面磁盘传输数据的时间会明显大于寻址时间,导致程序在处理这块数据的时候,会变得很慢.另一方面,mapreduce框架会为每个块创建一个map任务,如果文件过大,运行速度也会很慢;
如果设置的过小,一方面存放大量小文件(每个块的元数据会占用150个字节)会占用namenode中大量的内存来存储元数据,而namenode的内存是有限的;另一方面,块过小,寻址时间就会增加,就会降低吞吐量
至于块大小设置为多大合适
hdfs中平均寻址时间为10ms,通常认为寻址时间占数据传输时间的1%时,性价比最高
目前机械硬盘文件顺序读写的速度为100MB/s,最佳block大小计算为:100MB/s * 1 s = 100MB,但是由于计算机是以二进制的方式进行存储的,因此容量是2的n次方,离100MB最近的就是128MB.生产环境中还是得根据使用的磁盘的读写速度适当修改block size.
hadoop关于block size的默认值
2.7.3之前默认块大小为64MB,2.7.3及之后版本默认块大小为128MB

如何提高HDFS的存储能力

①namenode的内存够用的情况下扩展datanode
②namenode的内存不够用的情况下,提供块大小

hadoop优点:

1. 高容错性（硬件故障是常态）：数据自动保存多个副本，副本丢失后，会自动恢复
2. 适合大数据集：GB、TB、甚至PB级数据、千万规模以上的文件数量，1000以上节点规模。
3. 数据访问方式为： 一次性写入，多次读取；表示一旦写入hdfs的文件就不能对其进行修改.但可以多次读取.目前,hdfs中任何时候都只能有一个写入操作,保证数据一致性,安全性
4. 构建成本低：可以构建在廉价机器上。
5. 多种软硬件平台中的可移植性
6. 高效性：Hadoop能够在节点之间动态地移动数据，并保证各个节点的动态平衡，因此处理速度非常快。
7. 高可靠性：Hadoop的存储和处理数据的能力值得人们信赖.

hadoop缺点:

1. 不适合做低延迟数据访问：
   HDFS的设计目标有一点是：处理大型数据集，高吞吐率。这一点势必要以高延迟为代价的。因此HDFS不适合处理用户要求的毫秒级的低延迟应用请求
2. 不适合小文件存取：
   一个是大量小文件需要消耗大量的寻址时间，违反了HDFS的尽可能减少寻址时间比例的设计目标。第二个是内存有限，一个block元数据大内存消耗大约为150个字节，存储一亿个block和存储一亿个小文件都会消耗20G内存。因此相对来说，大文件更省内存
3. 不适合并发写入，文件随机修改：
   HDFS上的文件只能拥有一个写者，仅仅支持append操作。不支持多用户对同一个文件的写操作，以及在文件任意位置进行修改

HDFS简介

HDFS即Hadoop分布式文件系统（Hadoop Distributed Filesystem），以流式数据访问模式来存储超大文件，运行于廉价的商用硬件集群上，是管理网络中跨多台计算机存储的文件系统。

HDFS的框架

HDFS 采用Master/Slave的架构来存储数据，这种架构主要由四个部分组成，分别为HDFS Client、NameNode、DataNode和Secondary NameNode。一个HDFS集群是由一个NameNode和一定数目的DataNode组成的。

HDFS client 提供了一个类似POSIX(Potable Operating System interface,可移植操作系统接口)的文件系统接口供用户调用,通过与namenode和datanode的交互访问hdfs中的文件

namenode:
①namenode管理文件系统的命名空间.它维护着文件系统树及整棵树内所有的文件和目录.这些信息以命名空间镜像文件(fsimage)和编辑日志文件(edits文件)的形式永久保存在本地磁盘中.
②namenode根据datanode发送的文件数据块信息在内存中维护文件,文件块与datanode的映射关系
③实施副本冗余策略,默认三个副本,包括文件块本身
④处理客户端的访问请求,比如客户端想读取一个文件的时候,namenode会告诉datanode这些文件的块在哪些datanode上
⑤心跳机制:namenode会周期型的接收心跳和块的状态报告信息,若没收到心跳信息,namenode认为datanode已经宕机,会将datanode上副本数不足的块进行复制到其他的datanode节点上.

datanode:
①以数据块的形式存储hdfs文件
②响应客户端的请求,执行数据块的读写操作
③周期型的向namenode发送心跳信息,以及所存储的数据块列表信息

SecondaryNamennode
主要是辅助namenode进行fsimage镜像文件和editlog的合并,减小editlog文件大小，以便缩短下次Namenode的重启时间，能尽快退出安全模式。

检查点机制(checkpoint)

满足下列条件之一就会触发检查点机制
①时间到了,hdfs默认间隔一小时创建一个检查点 具体时间由dfs.namenode.checkpoint.period决定,默认3600
②对hdfs执行的操作次数到了,目前的edit文件中事务数(txid)达到100万条,即使时间未到,也会创建检查点,每个60秒检查一次 具体值由dfs.namenode.checkpoint.txns决定,默认1000000,检查时间由dfs.namenode.checkpoint.check.period决定,默认60秒
③edit文件大小>64MB也会触发检查点 由fs.checkpoint.size参数决定,默认64MB,不过博主在配置文件中并没有找到这个参数,但是在java的源码中由提到这个属性

检查点的具体步骤(也就是secondary namenode的工作内容)
（1）Secondary NameNode定期询问NameNode是否需要checkpoint。并返回是否需要checkpoint的结果
（2）Secondary NameNode请求执行checkpoint。
（3）NameNode滚动正在写的edits日志(rolledit)生成 edits_inprogress_(seen_txid数值)文件,这样新的请求操作就会被记录在edits_inprogress文件中。
（4）Secondary NameNode通过http请求获取namenode中滚动前的编辑日志和镜像文件。
（5）Secondary NameNode加载编辑日志和镜像文件到内存，执行edit文件中的增删改操作进行合并,生成新的镜像文件fsimage.ckpt。
（6）通过http协议将fsimage.ckpt发送到NameNode。
（7）NameNode将fsimage.ckpt重新命名成fsimage

镜像文件fsimage

是hdfs文件系统的命名空间镜像文件,他是文件系统元数据的一个永久检查点,内部维护的是最近一次检查点的文件系统树和整棵树内部的所有目录和文件的元数据,如txid(事务id) ,type(文件类型),mtime(修改时间),atime(访问时间),permission(访问权限),replication(副本数据),numBytes(块文件实际大小 ),块id,文件的块列表信息等.
fsimage默认只保留最近两次检查点文件,也就是只保留两个fsimage镜像文件.

edit日志文件

集群正常运行时,客户端的所有更新操作(创建,删除,修改,重命名)除了在内存中维护之外,还会被直接写入edits文件,而不是fsimage镜像文件.
:在分布式文件系统中,通常fsimage镜像文件是比较庞大的,如果客户端直接将更新操作直接写入fsimage文件,性能一定会越来越差,通常edits日常比fsimage小得多,一个edits日志文件最大64M,因此将更新操作写入edits日志是非常高效的.
edits文件的内容:行为代码(关闭,创建,删除,重命名,修改权限等,),事务id,客户端信息,块id,副本数,访问时间,修改时间等

查看fsimage和editlog的方式

①查看fsimage镜像文件的方法
hdfs iov -i 输入的日志文件 -o 输出的日志文件 -p 转换后的格式
参数说明:
-i,–inputFile 输入FSImage文件.
-o,–outputFile 输出转换后的文件，如果存在，则会覆盖
-p,–processor 将FSImage文件转换成哪种格式： (Ls|XML|FileDistribution).默认为Ls.
hdfs oiv -i fsimage_0000000000000001426 /root/fsimage_log.xml -p XML
还可以将转换成.xml格式的镜像文件用nodePad++打开后,进行格式化显示,看着更方便
②查看edits日志文件的方法
hdfs -oev -i 输入的日志文件 -o 输出的日志文件 -p 转换后的格式
参数与查看fsimage镜像文件的相同
hdfs oev -i edits_0000000000000001190-0000000000000001251 -o edits_log.xml -p XML
cat /root/edits_log.xml

hdfs的写流程

①客户端调用DistributeFileSystem的create方法
②DistributeFileSystem通过DFSClient向namenode发送rpq请求,询问是否能上传文件
③namenode接收到请求后,检查文件是否不存在,客户端是否有相应的权限,检查通过,namenode会将创建文件的操作写入editlog文件中,然后返回输出流对象…FSDataOutputStream,内部封装了DFSOutputStream;检查不通过,会向客户端抛出异常
④client端按照指定的块大小默认128M切分文件
⑤client端开始将数据写入DFSOutputStream的内部缓存chunk中,当这个缓存写满会被刷到一个packet中,直到这个packet装满,会将这个packet放入data queue发送队列中
⑥DataStreamer向namenode发送写第一个block块的请求
⑦namenode根据集群中datanode的情况以及机架感知并按照远近的顺序,近的在前,远的在后,返回指定副本数的datanode节点列表到客户端
⑧DataStreamer与列表中第一个datanode建立管线pipeline,第一个datanode在与第二个datanode建立管线,此次类推,
⑧DataStreamer会将dataqueue中的packet取出并通过管线发送给第一个datanode,并放到ack queue确认队列中,第一个datanode接收数据,并将数据包发送给下一个datanode,以此类推.
⑨datanode成功接收数据后会向客户端ResponseProcessor线程和上游datanode发送ack packet.当ResponseProcessor线程接收到所有datanode返回的ack时,ResponseProcessor会将ack queue中的这个packet删除.当接收到数据块的所有packet接收成功的ack数据包回复后,DataStreamer会关闭数据块,再次向namenode申请新的数据块用于写入
⑩当客户端的数据写入完毕,会调用close方法,flush流缓存中的数据,关闭流释放资源,调用namenode的complete方法,告诉namenode,数据写入完成.
11 当任何一个datanode在写入数据时故障:
①pipeline被关闭，在确认队列中剩下的包会被添加进数据队列的起始位置上，以至于在失败的节点下游的任何节点都不会丢失任何的包。
②将一个存储在正常datanode中的当前块创建一个新的标记,并将该标记发送给namenode,以便这个故障的datanode回复后可以删除这个不完整的数据块.
③将失败节点从pipeline中移除，之后剩下来好的DataNode会组成一个新的pipeline，
④剩下的这些块(刚刚放进数据队列队首的包)会继续写进pipeline中好的DataNode中。
⑤NameNode注意到备份数小于规定的备份数，它就安排在另一个节点上创建完成备份。直到满足了备份数。如果有多个节点写入失败了，如果满足了最小备份数的设置默认为1，写入也将成功，之后剩下的备份会被集群异步的执行备份，直到满足了备份数。

读流程

①客户端通过调用DistributedFileSystem对象的open()方法发起读取(下载)请求。
②这个对象使用RPC连接到Namenode，namenode会检查文件是否存在,存在则返回文件块副本的元数据信息，包括blockid和datanode列表,datanode信息会根据集群的网络拓扑结构距离客户端的远近排序,近的在前,远的在后。
③客户端一旦接收到元数据，就会返回一个FSDataInputStream类型的对象。FSDataInputStream封装了DFSInputStream，它负责处理与DataNode和NameNode的交互。
④客户端调用流的read()方法，使DFSInputStream与列表中的第一个DataNode建立连接，客户端反复调用read()方法,循环读取第一个数据块的数据,直到读取到数据块的末尾,客户端接收到数据后会先缓存在本地,之后写入文件中。
⑤一旦一个块数据读取完毕，DFSInputStream就会关闭与datanode的连接，并继续寻找下一个块的下一个DataNode,后面的数据块读取后会追加到之前的文件末尾。
⑥一旦客户端完成了读取，它就会调用一个close()方法。
⑦注意：在读取数据的时候，如果DFSInputStream与DataNode通信时遇到错误，会尝试从这个块的最近的DataNode读取数据，并且记住那个故障的DataNode,保证后续不会反复读取该节点上后续的块。DFInputStream也会通过校验和确认从DataNode发来的数据是否完整。如果发现有损坏的块，DFSInputStream会从其他的块读取副本，并且将损坏的块通知给NameNode.

java中关于hdfs比较重要的几个类

org.apache.hadoop.hdfs.DistributedFileSystem

内部封装了一个OutputStream,创建的的时候传入了DFSOutputStream

/****************************************************************
 * Implementation of the abstract FileSystem for the DFS system.
 * This object is the way end-user code interacts with a Hadoop
 * DistributedFileSystem.
 *
 *****************************************************************/

DistributedFileSystem是抽象类FileSystem的实现类
该对象(DistributedFileSystem)是用户最终代码与hadoop分布式文件系统交互的方式

org.apache.hadoop.hdfs.DFSClient

/********************************************************
 * DFSClient can connect to a Hadoop Filesystem and 
 * perform basic file tasks.  It uses the ClientProtocol
 * to communicate with a NameNode daemon, and connects 
 * directly to DataNodes to read/write block data.
 *
 * Hadoop DFS users should obtain an instance of 
 * DistributedFileSystem, which uses DFSClient to handle
 * filesystem tasks.
 *
 ********************************************************/

DFSClient可以连接到Hadoop Filesystem并执行基本文件任务。 它使用ClientProtocol与NameNode守护程序进行通信，并直接连接到DataNode以读取/写入块数据。
Hadoop DFS用户应获取DistributedFileSystem的实例，该实例使用DFSClient处理文件系统任务。

org.apache.hadoop.hdfs.DFSOutputStream

/****************************************************************
 * DFSOutputStream creates files from a stream of bytes.
 *
 * The client application writes data that is cached internally by
 * this stream. Data is broken up into packets, each packet is
 * typically 64K in size. A packet comprises of chunks. Each chunk
 * is typically 512 bytes and has an associated checksum with it.
 *
 * When a client application fills up the currentPacket, it is
 * enqueued into dataQueue.  The DataStreamer thread picks up
 * packets from the dataQueue, sends it to the first datanode in
 * the pipeline and moves it from the dataQueue to the ackQueue.
 * The ResponseProcessor receives acks from the datanodes. When an
 * successful ack for a packet is received from all datanodes, the
 * ResponseProcessor removes the corresponding packet from the
 * ackQueue.
 *
 * In case of error, all outstanding packets and moved from
 * ackQueue. A new pipeline is setup by eliminating the bad
 * datanode from the original pipeline. The DataStreamer now
 * starts sending packets from the dataQueue.
****************************************************************/

DFSOutputStream从字节流创建文件。
客户端应用程序写入此流在内部缓存的数据。数据被分解为数据包，每个数据包的大小通常为64K。数据包包括块。每个块通常为512字节，并具有关联的校验和。
当客户端应用程序填充currentPacket时，它将排队到dataQueue中。 DataStreamer线程从dataQueue中拾取数据包，将其发送到管道中的第一个datanode，并将其从dataQueue移至ackQueue。
ResponseProcessor从数据节点接收确认。从所有数据节点接收到成功的数据包确认后，ResponseProcessor将从ackQueue中删除相应的数据包。
如果发生错误，所有未完成的数据包将从ackQueue中移出。通过从原始管道中消除错误的datanode来建立新的管道。现在，DataStreamer开始从dataQueue发送数据包。

org.apache.hadoop.hdfs.DFSOutputStream$DataStreamer

  // The DataStreamer class is responsible for sending data packets to the
  // datanodes in the pipeline. It retrieves a new blockid and block locations
  // from the namenode, and starts streaming packets to the pipeline of
  // Datanodes. Every packet has a sequence number associated with
  // it. When all the packets for a block are sent out and acks for each
  // if them are received, the DataStreamer closes the current block.

DataStreamer类负责将数据包发送到管道中的数据节点。 它从namenode
检索新的blockid和块位置，然后开始将数据包流传输到Datanodes的管道。
每个数据包都有一个与之关联的序列号。 当发送完一个数据块的所有数据
包并接收到每个数据包的确认后，DataStreamer将关闭当前数据块。

org.apache.hadoop.hdfs.DFSOutputStream$DataStreamer$ResponseProcessor

hdfs的安全模式

安全模式时HDFS所处的一种特殊状态，在这种状态下，文件系统只接受读数据请求，而不接受删除、修改等变更请求。在NameNode主节点启动时，HDFS首先进入安全模式，DataNode在启动的时候会向namenode上报心跳,可用的block的信息，当namenode接收到99.9%的块的至少一个副本信息，存活的datanode节点数符合要求,并且维持这种状态30秒后,HDFS自动离开安全模式。如果HDFS处于安全模式下，则文件block不能进行任何的副本复制操作，因此达到最小的副本数量要求是基于datanode启动时的状态来判定的，启动时不会再做任何复制。

进入和离开安全模式

--进入安全模式
hdfs dfsadmin -safemode enter
-- 查看是否再安全模式
hdfs dfsadmin -safemode get
-- 离开安全模式
hdfs dfsadmin -safemode leave

hdfs dfsadmin 命令主要用于管理hdfs集群,通常用于管理员有空进行补充

namenode格式化

①清空namenode存储元数据路径下的所有文件:dfs.namenode.name.dir,dfs.namenode.edits.dir默认这两个路径时相同的
②创建存储元数据的路径
③在该路径下创建文件:
1 fsimage存储文件和目录的元数据的序列化信息, 是namenode启动时对文件系统的快照,
2 fsimage.md5 是镜像文件fsimage的md5校验文件，用于判断镜像文件是否被修改
3 VERSION文件(存储namenode的版本信息):内部包含
clusterid : 集群的唯一标识符
namespaceID 文件系统的唯一标识符,文件系统初次格式化时生成的
cTime namenode创建时间,升级后会更新该值
storageType 表示此文件夹中保存的是哪种进程的数据结构,比如NameNode,DataNode
blockpoolID 针对每一个namespace所对应blockpool的id,该id包括其对应的namenode节点的ip地址
layoutVersion 是一个负整数,hdfs的构造版本
4 seen_txid文件,存储transactionid,格式化后是0

第一次启动namenode 不会进入安全模式,因为datanode没有数据块

①将fsimage加载到内存构建namespace在内存中的镜像
②创建edits日志文件 edits_inprogress_0000000000000000001
③创建in_use.lock 防止同一个机器开启多个相同的namenode守护进程,导致数据目录不一致(这个文件只要进程起来就会被创建,进程停止就会被删除)
④创建日志目录,将启动日志信息存入日志文件中
⑤datanode定期向namenode汇报心跳和块信息(第一次启动没有块数据)
⑥datanode块文件的修改信息会保存再edit日志文件中

第二次及以上启动namenode

①hdfs会先进入安全模式
②将滚动edit日志生成新的edits_inprogress日志文件用以记录新的对元数据的操作
③将fsimage和edit加载到内存中,重新执行edit中的事务,进行合并构建namespace在内存中的镜像,同时生成一个新的fsimage文件
④datanode定期向namenode汇报心跳和块信息
⑤当namenode接收到99.9%的块的至少一个副本信息,存活的datanode数目符合要求,并且维持这种状态指定时间后,hdfs就会退出安全模式,

第一次集群启动

会在每台机器上创建启动的相应守护进程存储数据的本地目录,以及相应的版本文件等
比如namenode会创建edits_inprogress_0000000000000000001,启动的每个守护进程都会创建一个in_use.lock文件,用于防止一台机器上启动多个相同的进程,还有生成VERSION文件包括集群的版本信息:clusterid,datanodeUuid,storageID,cTime,storageType等

滚动编辑日志

(1) 滚动编辑日志（前提必须启动集群）
1.可以强制滚动
[bigdata@hadoop102 current]$ hdfs dfsadmin -rollEdits
2.可以等到edits.inprogress满64m生成edits文件
3.可以等操作数量达到100万次
4.时间到了,默认1小时
注意:在2,3,4时发生滚动,会进行checkpoint
(2) 镜像文件什么时候产生
可以在namenode启动时加载镜像文件和编辑日志
也可以在secondarynamenode生成的fsimage.chkpoint文件重新替换namenode原来的fsimage文件时

namenode 如何判断datanode节点是否宕机？

datanode启动后,会启动一个进程用于向namenode发送心跳数据包,间隔时间默认为3秒,由dfs.heartbeat.interval决定,如果namenode连续10次没有收到datanode的汇报信息,会认为datanode由宕机的可能.但是namenode还会向datanode确认两次,每次间隔5分钟,2次确认后仍然没有结果返回,那么namenode就认为datanode宕机了
因此namenode认为datanode宕机的时间计算公式为
timeout = 10 * 心跳间隔时间 + 2 * 确认时间间隔 ===> 10min30s
心跳间隔时间 dfs.heartbeat.interval 默认3秒
检查datanode是否宕机的时间间隔:dfs.namenode.heartbeat.recheck-interval 默认300000毫秒 (5min)

IPC (Inter Process Communication) 跨进程通信

泛指进程之间任何形式的通信行为.它不仅包括各种形式的消息传递,还可以指共享资源,以及同步对象,即确保安全的并发访问共享资源(也就是防止两个或两个以上的对象同时对一个数据进行修改,从而导致数据被破坏,或者在竞争条件下同时读/写数据而导致错误的情况)

RPC (Remote Procedure Call) 远程过程调用

特指一种隐藏了过程调用时实际通信细节的IPC方法,客户端将调用一个本地方法,而这个本地方法负责与远程服务端进行过程间通信,这个本地方法会将相关参数顺序打包到一个消息中,然后把这个消息发送给服务端提供的方法,服务端的方法会从消息中取出序列化发出来的参数,然后执行,最后仍以同样的方式将方法的返回值发送给客户端.

心跳机制(datanode与namenode之间)

①hdfs是master/slaves架构,namenode作为master,多个datanode作为slaves
②namenode启动时会开启一个IPC服务,等待slave连接
③datanode启动后,会间隔指定时间,默认3秒一次主动连接IPC服务,向namenode发送心跳数据包,报告自己的状态.这个间隔一段时间连接一次的机制,称为心跳机制.master通过心跳下达命令
④namenode通过心跳得知datanode的状态
⑤当namenode长时间没有收到同一个datanode的信息时,就认为datanode挂掉了.具体多久认为datanode挂掉了,看namenode 如何判断datanode节点是否宕机？

机架感知

机架感知是一种计算不同计算节点（TT）的距离的技术，用以在任务调度过程中尽量减少网络带宽资源的消耗.
默认情况下,hadoop没有开启机架感知.所有的datanode均为同一个机架 /default-rack
如果要开启机架感知,就在core-site.xml文件中设置net.topology.script.file.name为一个可执行脚本,这样datanode在注册或者发送心跳时,会将datanode的ip传给这个脚本,脚本返回的就是该datanode的机架信息.

机架感知策略下的副本存放

第一个副本在client所处的节点上。如果客户端在集群外，随机选一个。
第二个副本与第一个副本不同机架，随机一个datanode进行存储
第三个副本与第二个副本相同机架，不同datanode。

节点动态上线步骤：
①准备工作：准备一台配置了jdk和hadoop的新主机hadoop04。如果克隆的话，别忘记删除${hadoop.tmp.dir}指定的目录和logs目录
②修改namenode节点中的hdfs-site.xml配置文件,添加下面的属性设置

# 指定文件include的全路径,include这个文件名，可以自定义。
#命名包含允许连接到namenode的主机列表的文件。必须指定文件的完整路径名。
#如果值为空，则允许所有主机
<property>
    <name>dfs.hosts</name>
    <value>/usr/local/hadoop/etc/hadoop/include</value>
</property>

③将待上线的主机名(hadoop04)添加到dfs.hosts指定的文件include内

[root@hadoop01 hadoop]# touch include 			#创建文件
[root@hadoop01 hadoop]# vi include
hadoop01
hadoop02
hadoop03
slave3	#将要上线的主机名

注意：dfs.hosts指定的文件中必须存储所有的在线主机名

④在namenode上刷新节点:

[root@hadoop01hadoop]# hdfs dfsadmin -refreshNodes。

⑤在要上线的节点中单独启动 datanode守护进程

[root@hadoop01hadoop]# hadoop-daemon.sh start datanode

⑥通过hdfs dfsadmin -report 或者web界面，可以看到， 节点已经上线。

⑦最后修改slaves，添加上刚才上线的主机名。以便集群重启时，带上此节点。

[root@hadoop01hadoop]# vi slaves
hadoop01
hadoop02
hadoop03
slave3   #添加此节点

节点动态下线步骤
①修改namenode的hdfs-site.xml配置文件中的dfs.hosts.exclude属性，指定文件exclude的全路径,dexclude这个文件名，可以自定义。

#命名包含不允许连接到namenode的主机列表的文件。必须指定文件的完整路径名。
#如果该值为空，则不排除任何主机
<property>
	<name>dfs.hosts.exclude</name>
	<value>/usr/local/hadoop/etc/hadoop/exclude</value>
</property>

②将待下线的主机名(hadoop04)加入到dfs.hosts.exclude指定的文件中

[root@hadoop01 hadoop]# touch exclude	#创建exclude文件
[root@hadoop01 hadoop]# vi exclude
hadoop04

③在namenode节点上刷新节点：

[root@hadoop01 hadoop]# hdfs dfsadmin -refreshNodes

④通过hdfs dfsadmin -report或者web界面，进行查看。

Decommissioning datanodes (1):
Name: 192.168.xxx.xxx:50010 (hadoop04)
Hostname: hadoop04
Decommission Status : Decommission in progress  #--->正在退役中
Configured Capacity: 18998099968 (17.69 GB)
DFS Used: 94208 (92 KB)
Non DFS Used: 3630915584 (3.38 GB)
DFS Remaining: 15367090176 (14.31 GB)
DFS Used%: 0.00%
DFS Remaining%: 80.89%
Configured Cache Capacity: 0 (0 B)
Cache Used: 0 (0 B)
Cache Remaining: 0 (0 B)
Cache Used%: 100.00%
Cache Remaining%: 0.00%
Xceivers: 1
Last contact: Wed Sep 16 20:35:13 CST 2020

此时，该datanode状态转化为Decommission In Progress。表示该datanode正在退役中，进行数据块的转移。
因此会花上一段时间。需要等待…
当decommission进程完成数据移动， datanode状态会转变为Decommissioned， 然后datanode会自动停止datanode进程。 然后你可以看见dead nodes下多了一个你想要下线的节点。

⑤然后删除include 和 exclude 中该节点的hosts， 在namenode上重新刷新

hdfs dfsadmin -refreshNodes  

⑥最后删除slaves中该节点的配置， 防止下次集群重启时，namenode再次启动这个退役的节点。

HDFS 2.x的新特性

①集群间数据拷贝
②小文件存档 (解决hdfs存储小文件方法之一)
HDFS存档文件或HAR文件,是一个更高效的文件存档工具,它将文件存入HDFS块,在减少namenode内存使用的同时,允许对文件进行透明的访问.具体来说,hdfs存档文件对内还是一个个独立文件,对namenode而言确实一个整体,减少namenode的内存.多个文件只占用一份元数据.

hdfs配置表 基于hadoop2.7.6
core-default.xml

属性名	属性描述	默认值
fs.defaultFS	默认文件系统的名称,包括主机名,端口号等,默认为本地模式	file:///
fs.default.name	该属性已经弃用了,目前使用fs.defaultFS 代替	file:///
io.file.buffer.size	序列化文件中使用的读/写缓冲区的大小,应该为硬件页大小的倍数	4096 (4K)
hadoop.tmp.dir	A base for other temporary directorieshadoop 文件系统依赖的基本配置，很多配置路径都依赖它,是一个临时目录,断电会丢失	/tmp/hadoop-${user.name}
io.compression.codecs
io.seqfile.compress.blocksize	block中压缩的最小大小由配置文件中，io.seqfile.compress.blocksize配置项	1000000
ipc.client.connect.max.retries	指示客户端将建立服务器连接的重试次数	10
ipc.client.connect.retry.interval	指示客户端在尝试重新建立服务器连接之前将等待的毫秒数	1000
ipc.client.connect.timeout	指示客户端等待socket建立服务器连接的毫秒数	20000
ipc.client.connect.max.retries.on.timeouts	在连接超时后，客户端连接重试次数	45
file.blocksize	块大小	67108864
ha.zookeeper.quorum	ZooKeeper服务器地址列表，以逗号分隔，它们是由ZKFailoverController在自动故障转移中使用host1/ip:2181,host2/ip2:2181,在配置高可用集群时需要配置	无默认值
hadoop.registry.zk.quorum	List of hostname:port pairs defining the zookeeper quorum binding for the registry	localhost:2181
net.topology.script.file.name	如果该值不为空,说明开启了机架感知,值通常为一个可执行的脚本,当datanode注册或者发送心跳时,namenode会把datanode的ip传入脚本,脚本返回的信息就是该datanode的机架信息; 如果没有设置,datanode统一为默认的机架/default-rack,可以打印网络拓扑信息查看节点的机架hdfs dfsadmin -printTopology	无默认值

hdfs-default.xml

属性名	属性描述	默认值
dfs.namenode.name.dir	指定dfs NameNode应该将元数据表(fsimage)存储在本地文件系统的位置.如果是逗号分隔的目录列表,那么这些元数据表会备份到以上的所有目录中以实现冗余	file://${hadoop.tmp.dir}/dfs/name
dfs.namenode.edits.dir	确定DFS NameNode 在本地文件系统上应存储事务（edits）文件的位置。 如果这是逗号分隔的目录列表，则出于冗余目的，会将事务文件复制到所有目录中。 默认值与dfs.namenode.name.dir相同	${dfs.namenode.name.dir}
dfs.datanode.data.dir	确定datanode在本地文件系统中那个位置存储器块.如果这是一个逗号分隔的目录列表,则数据将存储在所有的目录中,通常在不同的设备上.对于HDFS存储策略,应使用相应的存储类型([SSD]/[DISK]/[ARCHIVE]/[RAM_DISK]) 标记目录,如果没有显示标记存储类型,则默认为DISK.如果本地文件系统权限允许,将创建不存在的目录	file://${hadoop.tmp.dir}/dfs/data
dfs.replication	默认块备份数	3
dfs.blocksize	新文件的默认块大小，以字节为单位。 您可以使用以下后缀（不区分大小写）：k（kilo），m（mega），g（giga），t（tera），p（peta），e（exa）指定大小（例如128k，512m ，1g等），或提供完整的字节大小（例如134217728表示128 MB）	134217728 (128M)
dfs.namenode.secondary.http-address	secondary namenode的http服务的地址和端口	0.0.0.0:50090
dfs.namenode.secondary.https-address	secondary namenode的https服务的地址和端口	0.0.0.0:50091
dfs.namenode.handler.count	namenode服务器线程数	10
dfs.datanode.handler.count
dfs.namenode.shared.edits.dir	HA集群中多个namenode共享的存储目录,由active状态的namenode写入,standby状态的namenode读取,以保证命名空间同步.这个目录不需要在dfs.namenode.edits.dir中列出.在非HA集群中应该为空	默认为空
dfs.datanode.data.dir.perm	datanode在本地文件系统中存储其块的目录的权限,权限可以是八进制也可以是符号	700
dfs.replication	默认的块副本数,可以在文件创建的时候指定真实的副本数,如果在创建的时候没有指定,就会使用默认副本数	3
dfs.replication.max	512	最大的副本数
dfs.namenode.replication.min	最小的块副本数	1
dfs.namenode.fs-limits.max-blocks-per-file	每个文件的最大块数,由namenode在写入时强制执行.这样可以防止创建过大的文件,导致性能降低	1048576
dfs.namenode.fs-limits.min-block-size	最小块大小(以字节为单位),由namenode在创建时强制执行.这样可以防止意外创建具有很小块大小的文件,这会导致降低性能	1048576
dfs.namenode.safemode.threshold-pct	指定应满足dfs.namenode.replication.min定义满足的最小副本数要求的块百分比 .<= 0 的值表示退出安全模式之前，不等待任何特定百分比的块。 值 > 1将使安全模式永久生效	0.999f
dfs.namenode.safemode.min.datanodes	指定离开安全模式前必须有指定数量的datanode存活.如果值 <= 0 意味着存活的datanode的数量将不纳入是否维持安全模式的考虑范围;如果值 > 集群中的datanode数量,安全模式将永久生效	0
dfs.namenode.safemode.extension	当集群可用block比例，可用datanode数都达到要求之后，如果在extension配置的时间段之后依然能满足要求，此时集群才离开安全模式，单位为毫秒。默认为30000，也就是当满足条件并且能够维持30秒之后，离开安全模式。这个配置主要是针对集群的稳定程度做进一步的确认	30000 (30秒)
dfs.client.block.write.retries	在向应用程序发出故障信号之前，将块写入数据节点的重试次数	3
dfs.heartbeat.interval	确定datanode心跳间隔(以秒为单位)	3
dfs.namenode.heartbeat.recheck-interval	检查过期datanode的间隔时间,单位为毫秒,使用该值和dfs.heartbeat.interval计算判断一个datanode是否宕机的时间间隔	300000 (5min)
dfs.namenode.resource.check.interval	namenode资源检查器运行的时间间隔(以毫秒为单位).检查器计算可用空间>dfs.namenode.resourcedu.reserved的namenode存储磁盘的数目.如果该数据小于dfs.namenode.resource.checked.volumes.minimum指定的最小值,则进入安全模式	5000
dfs.namenode.resource.du.reserved	The amount of space to reserve/require for a NameNode storage directory in bytes. The default is 100MB. 要求为namenode存储目录保留/要求的空间量	104857600 (100M)
dfs.namenode.resource.checked.volumes.minimum	所需的冗余NameNode存储卷的最小数量
dfs.hosts	指定一个文件,该文件包含允许连接到namenode的主机列表.必须指定完整的路径,如果该值为空,则允许所有主机连接	默认为空
dfs.hosts.exclude	指定一个文件,该文件包含不允许连接到namenode的主机列表.必须指定完整的路径,如果该值为空,则没有排除任何主机	默认为空
dfs.stream-buffer-size	流文件的缓冲区大小,决定在读/写的时候缓冲的数据大小,应为硬件页大小的整数倍	4096
dfs.namenode.checkpoint.dir	确定secondary namenode在本地文件系统上应存储要合并的临时镜像文件的位置,如果是逗号分隔的目录列表,则将镜像备份到所有目录中以实现冗余	file://${hadoop.tmp.dir}/dfs/namesecondary
dfs.namenode.checkpoint.period	两个定期检查点之间的秒数	3600 (1h)
dfs.namenode.checkpoint.max-retries	secondarynamenode重试失败的检查点,如果在加载fsimage或重演edits时失败,则重试次数受此变量限制	3
dfs.namenode.num.checkpoints.retained	namenode和secondary namenode将其存储目录中保留的镜像检查点文件(fsimage_*)的数量.	2
dfs.namenode.num.extra.edits.retained	除去namenode重启所需的最小事务数之外,还应该保留的额外事务数有待理解	1000000
dfs.namenode.checkpoint.check.period	检查两次checkpoint之间操作的事务数是否达到1000000 的周期,以秒为单位	60 (1min)
dfs.image.compress	是否压缩fsima ge	fasle
dfs.namenode.support.allow.format	是否允许namenode进行格式化,在生产环境下建议改为false,杜绝格式化正在运行的dfs的可能性	true
dfs.datanode.max.transfer.threads	指定用于将数据传入和传出datanode的最大线程数	4096
dfs.datanode.scan.period.hours	如果为正,则datanode在指定的扫描周期内不会对任何一个块进行多从扫描;如果为负值,则禁用块扫描器.如果设置为0,则使用默认值504小时或3周	504
dfs.datanode.readahead.bytes	是否启用datanode的预读机制,设置为0表示禁用,设置该值可以明显的提高HDFS的读性能 ,预读开启后只有在本地库空闲时才会启动	4194304 (4M)
dfs.datanode.drop.cache.behind.reads	设置为true表示丢弃缓存的数据（需要在DataNode中配置).当同一份数据，重复读取的次数较少时，建议设置为true，使得缓存能够被其他操作使用。重复读取的次数较多时，设置为false能够提升重复读取的速度。	false
dfs.datanode.drop.cache.behind.writes	当写入hdfs的数据很大时,在操作系统的高速缓冲区中缓存用处不大,这种情况可以在datanode中设置该参数为flase,使得数据在写入磁盘之后就会从缓存中删除,以释放缓存空间可以缓存其他的数据	false
dfs.ha.automatic-failover.enabled	是否允许自动故障转移,配置高可用(HA)集群时需要配置为true	false
dfs.namenode.avoid.read.stale.datanode	指示是否避免读取“过时”的DataNode，这些DataNode的心跳消息在指定的时间间隔内未被NameNode接收。过时的数据节点（DataNode）将移动到返回供读取的节点列表的末尾。有关写入的类似设置，请参阅df.namenode.avoint.write.stale.datanode。默认值是flase，推荐设置为true	false
dfs.namenode.avoid.write.stale.datanode	是否避免在将数据写入过时的datanode节点,这个datanode节点的心跳信息超过指定的时间间隔仍未被namenode接收.写入器会避免使用过时的datanode,除非超过配置比例的datanode被标记为过时	false
dfs.namenode.stale.datanode.interval	将datanode标记为过时的(stale)的默认时间间隔,如果namenode超过这个时间间隔没有收到来自datanode的心跳信息,datanode就会被默认标记并认为其过时.这个时间间隔不能设置的太小,这样会导致过时状态更改过于频繁.因此设置了最小过时间隔时间(默认值是心跳间隔时间的3倍),并且保证过时时间间隔不能小于这个值.	30000
dfs.namenode.write.stale.datanode.ratio	当标记为过时的datanode节点数/总的datanode节点数 > 该比例时,会停止避免写入过时datanode(就是数据会写入过时datanode节点)中以防止引起热点	0.5f
dfs.journalnode.rpc-address	JournalNode rpc服务器的地址和端口	0.0.0.0:8485
dfs.journalnode.http-address	JournalNode http服务器的地址和端口	0.0.0.0:8480
dfs.journalnode.https-address	JournalNode https服务器的地址和端口	0.0.0.0:8481
dfs.client.mmap.enabled	是否执行memory-mapped reads	true
dfs.namenode.edit.log.autoroll.multiplier.threshold	用于确定active namenode什么时候滚动自己的edit log.实际的阈值(编辑(edits)的数目)是由该参数值 * dfs.namenode.checkpoint.txns,后者的默认值为1000000,因此这里默认的最大edits数为2.0*1000000 = 2000000,达到该值active namenode就会滚动edit log	2.0
dfs.namenode.edit.log.autoroll.check.interval.ms	active多久检查一次是否需要滚动其edit log(以毫秒为单位)	300000

yarn-default.xml

属性名	属性描述	默认值
yarn.nodemanager.hostname	NodeManager节点主机名	0.0.0.0
yarn.resourcemanager.ha.enabled	是否开启 RM HA	false
yarn.nodemanager.aux-services	以逗号分隔的服务列表，其中服务名称应仅包含a-zA-Z0-9_并且不能以数字开头,建议 mapreduce_shuffle	无默认值
yarn.nodemanager.pmem-check-enabled	是否对容器实施物理内存限制	true
yarn.nodemanager.vmem-check-enabled	是否对容器实施虚拟内存限制	true
yarn.resourcemanager.hostname	RM的主机名	0.0.0.0
yarn.scheduler.minimum-allocation-mb	分配给application master单个容器(Container)可申请的最小内存,申请内存低于该值会抛出InvalidResourceRequestException异常,该值可以计算一个节点最大的Container数量	1024 (M)
yarn.scheduler.maximum-allocation-m	分配给application master单个容器(Container)可申请的最大内存,申请内存高于该值会抛出InvalidResourceRequestException异常	8192 (M)
yarn.scheduler.minimum-allocation-vcores	application master上每个容器能够申请的最小虚拟cpu核数,低于这个值会抛出InvalidResourceRequestException异常	1
yarn.scheduler.maximum-allocation-vcores	application master上每个容器能够申请的最大虚拟cpu核数,高于这个值会抛出InvalidResourceRequestException异常	32
yarn.resourcemanager.zk-address	RM使用的zookeeper的host:port.在HA设置中如果使用基于zookeeper实现RM状态存储 和/或嵌入自动故障转移,就必须提供该功能	无默认值
yarn.resourcemanager.ha.enabled	是否弃用RM HA 在配置高可用集群时需要开启	false
yarn.resourcemanager.ha.automatic-failover.enabled	是否启用自动故障转移,默认情况下仅当HA被启用时才启用	true
yarn.resourcemanager.nodemanagers.heartbeat-interval-ms	集群中每个NodeManager的心跳间隔时间,毫秒为单位	1000
yarn.resourcemanager.system-metrics-publisher.dispatcher.pool-size	发送yarn系统指标数据的工作线程数	10
yarn.nodemanager.local-dirs	NodeManager的本地化目录,	${hadoop.tmp.dir}/nm-local-dir
yarn.nodemanager.log-dirs	存储容器日志的位置。 在$ {yarn.nodemanager.log-dirs} / application _ $ {appid}中可以找到应用程序的本地化日志目录。各个容器的日志目录将位于该目录下面，位于名为container _ {$ contid}的目录中。 每个容器目录将包含该容器生成的文件stderr，stdin和syslog	${yarn.log.dir}/userlogs
yarn.nodemanager.localizer.fetch.thread-count	本地化PUBLIC资源时PublicLocalizer的线程数。默认是4	4
yarn.nodemanager.localizer.cache.cleanup.interval-ms	NodeManager为避免缓存的文件过多导致磁盘空间不足,默认每间隔10分钟启动一次清理工作,清理过期的缓存文件	600000
yarn.nodemanager.resource.memory-mb	表示该节点上YARN可使用的物理内存总量，默认是8192（MB）,注意，如果你的节点内存资源不够8GB，则需要调减小这个值，而YARN不会智能的探测节点的物理内存总量	8192 (M)
yarn.nodemanager.vmem-pmem-ratio	Container可以分配的虚拟内存和物理内存的比例,比如分配100MB物理内存,最多可以使用210MB虚拟内存,但是如果使用的虚拟内存超出限制,任务进程会被kill掉	2.1
yarn.nodemanager.resource.cpu-vcores	可以为Container分配的虚拟CPU核数.RM调度程序在分配资源给Container时使用.这不用于限制YARN Container的物理核心数量	8
yarn.nodemanager.webapp.address	NodeManager http服务器地址:端口	${yarn.nodemanager.hostname}:8042

mapred-default.xml

属性名	属性描述	默认值
mapreduce.framework.name	执行MapReduce job的运行时框架,只能是以下3个中的一个 local, classic or yarn	local
mapreduce.jobhistory.address	MapReduce JobHistory Server IPC host:port	0.0.0.0:10020
mapreduce.jobhistory.webapp.address	MapReduce JobHistory Server Web UI host:port	0.0.0.0:19888
mapreduce.task.io.sort.factor	控制着mapper阶段每次合并spill文件的最大数量，默认为10,调大该参数可以减少merge spill(溢写文件)的次数，从而减少磁盘的操作	10
mapreduce.task.io.sort.mb	排序文件时要使用的缓冲内存总量，以兆字节为单位;map阶段环形缓冲区的大小,默认为100MB	100
mapreduce.map.sort.spill.percent	环形缓冲区的软限制,一旦达到该阈值就会单独启动一个溢写线程,将缓冲区的数据写入一个溢写文件到磁盘.溢写的同时可以写入,当还在溢写,时缓冲区已满,就会阻塞,直到溢写完成	0.80
mapreduce.cluster.local.dir	mapreduce存储中间数据文件的本地目录,可以是以逗号分隔的不同设备的目录列表,不存在的目录会被忽略	${hadoop.tmp.dir}/mapred/local
mapreduce.job.maps	每个作业的默认map数,当mapreduce.jobtracker.address 为 "local"时则忽略	2
mapreduce.job.reduces	每个作业默认的reduce task的数量,当 mapreduce.jobtracker.address 为 "local"时则忽略	1
mapreduce.jobtracker.jobhistory.block.size	作业历史记录文件的块大小。 由于作业恢复使用作业历史记录，因此重要的是尽快将作业历史记录存储到磁盘。 请注意，这是专家级别的参数。 默认值设置为3 MB。	3145728 (3MB)
mapreduce.map.maxattempts	框架在放弃这个任务之前,每个map task最多尝试执行的次数	4
mapreduce.reduce.maxattempts	框架在放弃这个任务之前,每个reduce task最多尝试执行的次数	4
mapreduce.reduce.shuffle.parallelcopies	在copy(shuffle)阶段,由reduce运行的拉取数据的并行线程数	5
mapreduce.map.memory.mb	每个map task向调度器请求的内存总大小	1024 (1GB)
mapreduce.map.cpu.vcores	每个map task从调度器请求的虚拟核数	1
mapreduce.reduce.memory.mb	每一个reduce task向调度器请求的内存总大小	1024 (1GB)
mapreduce.reduce.cpu.vcores	每一个reduce task向调度器请求的虚拟内核数	1
mapreduce.map.log.level	map task的日志级别. 允许下面的选择下面的级别: OFF, FATAL, ERROR, WARN, INFO, DEBUG, TRACE and ALL. 如果设置了 "mapreduce.job.log4j- properties-file"那么这里的设置将会被覆盖	INFO
mapreduce.reduce.log.level	reduce task的日志级别. 允许下面的选择下面的级别: OFF, FATAL, ERROR, WARN, INFO, DEBUG, TRACE and ALL. 如果设置了 "mapreduce.job.log4j- properties-file"那么这里的设置将会被覆盖	INFO
mapreduce.reduce.shuffle.merge.percent		0.66
mapreduce.reduce.shuffle.input.buffer.percent		0.70
mapreduce.reduce.input.buffer.percent		0.0
mapreduce.reduce.shuffle.memory.limit.percent		0.25
map.sort.class	对键(keys)进行排序的默认排序类	org.apache.hadoop.util.QuickSort
mapreduce.job.userlog.retain.hours	(job)作业完成后保留user-log(用户日志)的最长时间(以小时为单位)	24
mapreduce.client.output.filter	控制需要发送给job客户端的输出用户日志(userlog)级别: NONE, KILLED, FAILED, SUCCEEDED and ALL	FAILED
yarn.app.mapreduce.am.scheduler.heartbeat.interval-ms	MR AppMaster将心跳发送到ResourceManager的时间间隔（以毫秒为单位）	1000
yarn.app.mapreduce.am.resource.mb	MR AppMaster需要的内存总大小	1536
yarn.app.mapreduce.am.resource.cpu-vcores	MR AppMaster需要的虚拟cpu核数	1

hdfs读取数据
①客户端调用分布式文件系统的open方法,DistributeFileSystem会向namenode发送prc请求,申请读取文件
②namenode会检查文件是否存在,如果存在就将该文件部分或所有数据块的元数据发送给客户端,包括blockid和块数据副本的datanode地址,datanode信息按照集群的网络拓扑结构与客户端的远近进行排序
③客户端接收到元数据后,会返回FSDatainputStream,内部封装了DFSInputStream,负责与namenode及datanode进行交互.
④客户端调用流的read方法,DFSInputStream会与列表中第一个datanode建立socket连接,读取第一个块的数据,客户端接收的数据先缓存在本地,之后写入文件中,当读取到一个块的末尾,DFSInputStream会关闭与datanode的连接,接着寻找下一个块的下一个datanode,进行数据读取
⑤当所有块都读取完毕后,DFSInputStream会调用close方法
⑥当DFSInputStream与datanode的通信发生异常时,会尝试从该块最近的datanode上读取数据,并记住这个节点,保证后面不会再从这个节点读取后续的块.DFSInputStream会进行校验和,发现有损坏的块就会从其他的副本读取数据,并将损坏的块信息发送给namenode