精华内容
下载资源
问答
  • HDFS面试题

    2020-10-26 15:24:09
    HDFS面试题 1、Hdfs的block和spark的partition有什么区别吗? 在hdfs中的block是分布式存储的最小单元,等分,并且可以设置冗余,这样设计会出现一部分磁盘空间的浪费,但是整齐的block大小,便于快速找到,读取...

    HDFS面试题

    1、Hdfs的block和spark的partition有什么区别吗?

    1. 在hdfs中的block是分布式存储的最小单元,等分,并且可以设置冗余,这样设计会出现一部分磁盘空间的浪费,但是整齐的block大小,便于快速找到,读取对应的内容,例如快手利用hdfs来进行存储视频。
    2. Spark中的parition是弹性分布式数据集中rdd的最小单元,rdd是由分布在各个节点上的partition组成的。partition是指在spark计算过程中,生成的数据在计算空间内的最小单元,同一份数据,parition 大小不一,数量不定,是根据app的算子和最初读取的数据分块数量来决定的,例如spark读取hdfs的数据,这个时候调用的是hadoop底层的inputformat所以,一个快就是一个partition。
    3. block位于存储,partition位于计算,block大小是固定的,parition的大小是不固定的。

    2、Mapreduce和spark都是并行计算,他们之间有什么区别吗?

    1. mapreduce只有一个map和reduce方法,但是spark有很多多种多样的算子,表达性好
    2. spark可以进行迭代计算,mapreduce需要进行手动操作
    3. hadoop的一个作业叫做job,job分为maptask和reducetask,每个task都是在自己的进程中执行,当task结束的时候,进程也会结束
    4. spark的作业叫做application,一个app对应了一个sparkcontext,一个app中对应了多个job,每个action算子都会产生一个job,一个job中有多个stage,这些stage是根据划分shufflfle的stagescheduler来进行划分的,依据的是血缘关系,每个stage中有多个task然后把这些task组成taskset然后通过taskscheduler来发送到各个executor中进行执行,exector中生命周期是和app一样的,计算没有job执行,这些exector也是存在。
    5. spark的迭代计算的。可以通过dag来进行容错,但是mapreduce的迭代计算是需要手动的。

    3、Spark比Mapreduce快?为什么快呢?快在哪里呢?

    1. 基于内存计算,减少低效的磁盘交互
    2. 高效的调度算法,基于DAG
    3. 容错机制Lingage,主要是DAG和Lianage,即使spark不适用内存技术,也大大快于mapreduce

    4、HDFS写数据流程

    1. 往hdfs目录树中添加INodeFile
    2. 添加契约,也就是当前仅有一个客户端可以操作这个文件(后台会有一个线程来实时监控契约队列,会有一个续约操作)
    3. 启动DataStreamer来进行写数据的操作,启动续约线程。
    4. 然后将我们的文件是一个个的shunk的写入到packet里面,然后将packet放入到dataqueue里面等待发送
    5. 向namenode去申请block,也就是返回可用的datanode节点(数据的负载均衡,也就是机架感知和其他的一些策略)
    6. 建立datanode之间的数据管道
    7. 先把要写出的数据添加到ackqueue上,然后写数据,移除dataqueue中的packet,假如这个时候写数据失败了,就把ack中的数据添加到dataqueue上重新写
    8. 然后datanode会初始化一个packetResponder的线程,进行将我们的数据写入到ack队列,这个是datanode中的队列,同事会获取到其他datanode的处理结果,将数据写入磁盘,然后依次层层上报给我们的客户端,写失败了,还是有ack机制,重新发送。
    9. 如果数据管道建立失败了。就删除向namnode申请的block,然后重新建立block和建立数据管道
    10. 假如在datanode写数据流程中出问题,那么这个时候会分为两个流程,先判断是几个副本写失败了,如果是3个副本的情况下,》=2的时候这个时候就会删除block,然后重新建立管道,如果是一个的话,那么这个时候没事,重新建立管道,这个时候抛弃那一台坏的,好的留下。

    5、有一个很大的文件,内存装不下,如何实现去重?

    1、首先对每一行数据进行hash

    2、将每行数据hash出来之后然后%1000。

    3、针对每个文件进行去重这个时候应该就可以了。

    6、HDFS的压缩算法

    1、SNAPPY

    优点:高速压缩速度和合理的压缩率

    缺点:不支持split;压缩率比gzip要低;hadoop本身不支持,需要安装;当mapreduce作业的map输出的数据比较大的时候,作为map到reduce中间的数据的压缩格式,或者作为mareduce作业的输出和另外一个mapreduce作业的输入

    2、LZO

    优点:压缩/解压速度也比较快,合理的压缩率。支持split,是hadoop中最流行的压缩格式。可以再linux系统下安装lzop命令,使用方便

    缺点:压缩率比gzip要低一些;hadoop本身不支持,需要安装;在应用中对lazo格式的文件需要做一些特殊处理(为了支持split需要建索引,还需要指定inputformat为lzo格式)。

    应用场景:一个很大的文本文件,压缩之后还大于200M以上的可以考虑,而且单个文件越大的有点也越明显

    7、datanode在什么情况下不会备份

    如果设置副本数为1,则不会进行备份。

    8、三个datanode当有一个datanode出现错误会怎么样?

    出现错误的时候无法和namenode进行通信,namenode要去确认namenode是不是宕机了,这段时间称为超时时长,hdfs默认时间是10分钟30秒,确认该datanode宕机后,hdfs的副本数会减1,然后namenode会将宕机的datanode的数据复制到其他机器上

    9、有一个200M的文件写入hdfs是先写128M复制完之后再写72M还是全部写完再复制?

    HDFS上在写入数据的时候,首先会对数据切块,然后从客户端到datanode形成一个管道,在至少将一个文件写入hdfs上后,表示文件写入成功,然后进行复制备份操作,所以是全部写完再复制

    10、HDFS里面的edits和fsimage作用?

    1. fsimage文件其实是hadoop文件系统元数据的一个永久性的检查点,其中包含hadoop文件系统所有目录和inode的序列化信息,也就是目录树
    2. edits文件存放的是hadoop文件系统的所有更新操作的路径,文件系统客户端执行的所以写操作会被记录到edits文件中。

    fsimage和edits文件都是经过序列化的,在namenode启动的时候,它会将fsimage文件中的内容加载到内存中,之后再执行edits文件中的各项操作,使得内存中的元数据和实际的同步,存在内存中的元数据支持客户端的读操作。

    namenode起来之后,hdfs中的更新操作会重新写到edits文件中,因为fsimage文件一般都很大(GB级别的很常见),如果所有的更新操作都会往fsimage文件中添加,这样会导致系统运行的十分缓慢,但是如果往edits文件里面写就不会这样,每次执行写操作之后,且在向客户端发送成功代码之前,edits文件都需要同步更新。如果一个文件比较大,使得写操作需要向多台机器进行操作,只有当所有的写数据都执行完毕之后,写操作才会返回成功,这样的好处是任何的操作都不会因为机器的故障而导致元数据的不同步。

    11、当小文件数量过多时,如何解决小文件问题

    当每个小文件数据量比较小的时候,可以通过命令的方式进行小文件的合并如:hadoop fs -cat

    hdfs://cdh5/tmp/lxw1234/*.txt | hadoop fs -appendToFile - hdfs://cdh5/tmp/hdfs_largefile.txt,当

    数据量比较大的时候建议使用MR进行小文件的合并

    12、介绍一下hadoop中的rpc协议,以及底层采用什么来进行封装的

    用户将用户请求中的参数或者应答转换成字节流以便跨机传输。

    函数调用层:函数调用层主要功能是定位要调用的函数,并执行该函数,hadoop采用了java的反射机制和动态代理实现了函数的调用。

    网络传输层:网络传输层描述了client和server之间消息的传输方式,hadoop采用了基于tcp/ip的socket机制。

    13、hadoop出现文件块丢失怎么处理?

    首先要定位到哪的文件块丢失,可以通过查看日志进行检查和排除,找到文件块丢失的位置后,如果文件不是很重要可以直接删除,如果删除不了,每个集群都会有备份,可以通过心跳来进行恢复

    14、Namenode的职责

    主节点,存储文件的元数据(文件名,目录树,文件属性,生成属性,副本数,文件权限)以及每个文件的块的对应关系,以及块在那些datanode上的信息等。周期性的接受心跳和快的状态报告信息。包含该datanode上所有数据块的列表

    若接受到心跳信息,nn认为dn工作正常,如果10分30秒后海接受不到dn的心跳,那么nn认为dn已经宕机。这个时候nn准备要把dn上的数据进行重新的复制。块的状态报告包含了一个dn上所有数据块的列表,block report每个小时发送一次。

    15、HDFS的存储机制

    1. 数据块

    每个磁盘都有默认的数据块大小,这是磁盘进行读写的基本单位,构建于单个磁盘智商的文件系统通过磁盘块来管理文件系统中的块。该文件系统中的块,一般为磁盘块的整数倍,磁盘块一般为512字节,hdfs也有块的概念,默认为128M,HDFS上的数据被均匀分布到多个分块中。与其他文件系统不同的是,hdfs中小于一个快大小的文件不会占据整个块的空间。

    HDFS用块存储带来的第一个明显的好处 一个文件的大小可以大于网络中任意一个磁盘的容量。数据块可以利用磁盘中任意一个磁盘进行存储,第二个简化了系统的设计,将控制单元设置为块,可简化存储管理,计算单个磁盘能存储多少块就相对容易,同时也消除了对元数据的顾虑,如权限信息,可以由其他系统单独管理。

    1. datanode节点

    datanode是hdfs文件系统的工作节点,他们根据需要存储并且所数据块,受namenode节点调度,并且定期向namenode发送她们所存储的块的列表

    1. namenode节点

    namenode管理hdfs文件系统的命名空间,它维护者文件系统树以及整棵树所有的文件和目录,这些文件一两种形式永久保存在本地磁盘上。

    展开全文
  • hdfs面试题

    2020-09-18 19:32:01
    HDFS的框架 HDFS 采用Master/Slave的架构来存储数据,这种架构主要由四个部分组成,分别为HDFS Client、NameNode、DataNode和Secondary NameNode。一个HDFS集群是由一个NameNode和一定数目的DataNode组成的。 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.6jdk 6
    >=2.7.0jdk7
    >=3.0.0jdk8

    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.dirA base for other temporary directorieshadoop
    文件系统依赖的基本配置,很多配置路径都依赖它,是一个临时目录,断电会丢失
    /tmp/hadoop-${user.name}
    io.compression.codecs
    io.seqfile.compress.blocksizeblock中压缩的最小大小由配置文件中,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.quorumZooKeeper服务器地址列表,以逗号分隔,它们是由ZKFailoverController在自动故障转移中使用host1/ip:2181,host2/ip2:2181,在配置高可用集群时需要配置无默认值
    hadoop.registry.zk.quorumList of hostname:port pairs defining the zookeeper quorum binding for the registrylocalhost: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-addresssecondary namenode的http服务的地址和端口0.0.0.0:50090
    dfs.namenode.secondary.https-addresssecondary namenode的https服务的地址和端口0.0.0.0:50091
    dfs.namenode.handler.countnamenode服务器线程数10
    dfs.datanode.handler.count
    dfs.namenode.shared.edits.dirHA集群中多个namenode共享的存储目录,由active状态的namenode写入,standby状态的namenode读取,以保证命名空间同步.这个目录不需要在dfs.namenode.edits.dir中列出.在非HA集群中应该为空默认为空
    dfs.datanode.data.dir.permdatanode在本地文件系统中存储其块的目录的权限,权限可以是八进制也可以是符号700
    dfs.replication默认的块副本数,可以在文件创建的时候指定真实的副本数,如果在创建的时候没有指定,就会使用默认副本数3
    dfs.replication.max512最大的副本数
    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.intervalnamenode资源检查器运行的时间间隔(以毫秒为单位).检查器计算可用空间>dfs.namenode.resourcedu.reserved的namenode存储磁盘的数目.如果该数据小于dfs.namenode.resource.checked.volumes.minimum指定的最小值,则进入安全模式5000
    dfs.namenode.resource.du.reservedThe 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-retriessecondarynamenode重试失败的检查点,如果在加载fsimage或重演edits时失败,则重试次数受此变量限制3
    dfs.namenode.num.checkpoints.retainednamenode和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 gefasle
    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)集群时需要配置为truefalse
    dfs.namenode.avoid.read.stale.datanode指示是否避免读取“过时”的DataNode,这些DataNode的心跳消息在指定的时间间隔内未被NameNode接收。过时的数据节点(DataNode)将移动到返回供读取的节点列表的末尾。有关写入的类似设置,请参阅df.namenode.avoint.write.stale.datanode。默认值是flase,推荐设置为truefalse
    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-addressJournalNode rpc服务器的地址和端口0.0.0.0:8485
    dfs.journalnode.http-addressJournalNode http服务器的地址和端口0.0.0.0:8480
    dfs.journalnode.https-addressJournalNode https服务器的地址和端口0.0.0.0:8481
    dfs.client.mmap.enabled是否执行memory-mapped readstrue
    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 log2.0
    dfs.namenode.edit.log.autoroll.check.interval.msactive多久检查一次是否需要滚动其edit log(以毫秒为单位)300000

    yarn-default.xml

    属性名属性描述默认值
    yarn.nodemanager.hostnameNodeManager节点主机名0.0.0.0
    yarn.resourcemanager.ha.enabled是否开启 RM HAfalse
    yarn.nodemanager.aux-services以逗号分隔的服务列表,其中服务名称应仅包含a-zA-Z0-9_并且不能以数字开头,建议 mapreduce_shuffle无默认值
    yarn.nodemanager.pmem-check-enabled是否对容器实施物理内存限制true
    yarn.nodemanager.vmem-check-enabled是否对容器实施虚拟内存限制true
    yarn.resourcemanager.hostnameRM的主机名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-vcoresapplication master上每个容器能够申请的最小虚拟cpu核数,低于这个值会抛出InvalidResourceRequestException异常1
    yarn.scheduler.maximum-allocation-vcoresapplication master上每个容器能够申请的最大虚拟cpu核数,高于这个值会抛出InvalidResourceRequestException异常32
    yarn.resourcemanager.zk-addressRM使用的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-dirsNodeManager的本地化目录,${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的线程数。默认是44
    yarn.nodemanager.localizer.cache.cleanup.interval-msNodeManager为避免缓存的文件过多导致磁盘空间不足,默认每间隔10分钟启动一次清理工作,清理过期的缓存文件600000
    yarn.nodemanager.resource.memory-mb表示该节点上YARN可使用的物理内存总量,默认是8192(MB),注意,如果你的节点内存资源不够8GB,则需要调减小这个值,而YARN不会智能的探测节点的物理内存总量8192 (M)
    yarn.nodemanager.vmem-pmem-ratioContainer可以分配的虚拟内存和物理内存的比例,比如分配100MB物理内存,最多可以使用210MB虚拟内存,但是如果使用的虚拟内存超出限制,任务进程会被kill掉2.1
    yarn.nodemanager.resource.cpu-vcores可以为Container分配的虚拟CPU核数.RM调度程序在分配资源给Container时使用.这不用于限制YARN Container的物理核心数量8
    yarn.nodemanager.webapp.addressNodeManager http服务器地址:端口${yarn.nodemanager.hostname}:8042

    mapred-default.xml

    属性名属性描述默认值
    mapreduce.framework.name执行MapReduce job的运行时框架,只能是以下3个中的一个
    local, classic or yarn
    local
    mapreduce.jobhistory.addressMapReduce JobHistory Server IPC host:port0.0.0.0:10020
    mapreduce.jobhistory.webapp.addressMapReduce JobHistory Server Web UI host:port0.0.0.0:19888
    mapreduce.task.io.sort.factor控制着mapper阶段每次合并spill文件的最大数量,默认为10,调大该参数可以减少merge spill(溢写文件)的次数,从而减少磁盘的操作10
    mapreduce.task.io.sort.mb排序文件时要使用的缓冲内存总量,以兆字节为单位;map阶段环形缓冲区的大小,默认为100MB100
    mapreduce.map.sort.spill.percent环形缓冲区的软限制,一旦达到该阈值就会单独启动一个溢写线程,将缓冲区的数据写入一个溢写文件到磁盘.溢写的同时可以写入,当还在溢写,时缓冲区已满,就会阻塞,直到溢写完成0.80
    mapreduce.cluster.local.dirmapreduce存储中间数据文件的本地目录,可以是以逗号分隔的不同设备的目录列表,不存在的目录会被忽略${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.levelmap task的日志级别. 允许下面的选择下面的级别:
    OFF, FATAL, ERROR, WARN, INFO, DEBUG, TRACE and ALL.
    如果设置了 "mapreduce.job.log4j- properties-file"那么这里的设置将会被覆盖
    INFO
    mapreduce.reduce.log.levelreduce task的日志级别. 允许下面的选择下面的级别:
    OFF, FATAL, ERROR, WARN, INFO, DEBUG, TRACE and ALL.
    如果设置了 "mapreduce.job.log4j- properties-file"那么这里的设置将会被覆盖
    INFO
    mapreduce.reduce.shuffle.merge.percent0.66
    mapreduce.reduce.shuffle.input.buffer.percent0.70
    mapreduce.reduce.input.buffer.percent0.0
    mapreduce.reduce.shuffle.memory.limit.percent0.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-msMR AppMaster将心跳发送到ResourceManager的时间间隔(以毫秒为单位)1000
    yarn.app.mapreduce.am.resource.mbMR AppMaster需要的内存总大小1536
    yarn.app.mapreduce.am.resource.cpu-vcoresMR 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

    展开全文
  • HDFS 面试题

    2020-07-18 15:30:29
    HDFS1. 如何理解 Hadoop2. HDFS 整体架构3. HDFS 写数据流程4. HDFS 读数据流程5. HDFS 副本存放机制/机架感知 (写数据时)6. HDFS 数据完整性如何保证7. DataNode 的工作机制8. HDFS 中大量小文件带来的问题及解决...

    1. 如何理解 Hadoop

    1. 广义上 Hadoop 是指与 Hadoop 相关的大数据生态圈, 包括 hive, spark, hbase 等
    2. 狭义上 Hadoop 是指 Apache 的开源框架.有三个核心组件:
      hdfs: 分布式文件存储系统
      yarn: 分布式资源管理调度平台
      MR: 分布式计算引擎

    2. HDFS 整体架构

    1. Client: 客户端
      (1) 文件切分
      (2) 与 NameNode 交互, 获取文件的位置信息
      (3) 与 DataNode 交互, 读取或者写入数据
      (4) Client 提供一些命令来管理 HDFS

    2. NameNode: Master
      (1) 管理 HDFS 的名称空间,
      (2) 管理数据块的映射信息
      (3) 配置副本策略(默认是 3)
      (4) 处理客户端读写请求

    3. DataNode: Slave
      (1) 存储实际的数据块
      (2) 执行数据块的读写操作

    4. SecondaryNameNode:
      (1) 辅助 NameNode, 分担其工作量
      (2) 定期合并 Fsimage 和 Edits , 并推送给 NameNode
      (3) 在紧急情况下, 可以辅助回复 NameNode

    3. HDFS 写数据流程

    在这里插入图片描述

    1. 客户端通过Distributed FileSystem模块向NameNode请求上传文件,NameNode检查目标文件是否已存在,父目录是否存在。
    2. NameNode返回是否可以上传。
    3. 客户端请求第一个 Block上传到哪几个DataNode服务器上。
    4. NameNode返回3个DataNode节点,分别为dn1、dn2、dn3。
    5. 客户端通过FSDataOutputStream模块请求dn1上传数据,dn1收到请求会继续调用dn2,然后dn2调用dn3,将这个通信管道建立完成。
    6. dn1、dn2、dn3逐级应答客户端。
    7. 客户端开始往dn1上传第一个Block(先从磁盘读取数据放到一个本地内存缓存),以Packet为单位,dn1收到一个Packet就会传给dn2,dn2传给dn3;dn1每传一个packet会放入一个应答队列等待应答。
    8. 当一个Block传输完成之后,客户端再次请求NameNode上传第二个Block的服务器。(重复执行3-7步)。

    4. HDFS 读数据流程

    在这里插入图片描述

    1. 客户端通过Distributed FileSystem向NameNode请求下载文件,NameNode通过查询元数据,找到文件块所在的DataNode地址。
    2. 挑选一台DataNode(就近原则,然后随机)服务器,请求读取数据。
    3. DataNode开始传输数据给客户端(从磁盘里面读取数据输入流,以Packet为单位来做校验)。
    4. 客户端以Packet为单位接收,先在本地缓存,然后写入目标文件。

    5. HDFS 副本存放机制/机架感知 (写数据时)

    1. 第一个副本存在在客户端, 如果客户端不在集群内, 就在集群内随机挑选一个合适的节点进行存放
    2. 第二个副本存在与第一个副本同机架, 且不同节点, 按照一定的规则挑选一个合适的节点进行存放
    3. 第三个副本存在与第一二副本不同机架且距第一个副本逻辑距离最短的机架, 按照一定的规则挑选一个合适的节点进行存放.

    6. HDFS 数据完整性如何保证

    1. 当DataNode读取Block的时候,它会计算CheckSum。
    2. 如果计算后的CheckSum,与Block创建时值不一样,说明Block已经损坏。
    3. Client读取其他DataNode上的Block。
    4. DataNode在其文件创建后周期验证CheckSum。

    7. DataNode 的工作机制

    在这里插入图片描述

    1. 一个数据块在DataNode上以文件形式存储在磁盘上,包括两个文件,一个是数据本身,一个是元数据包括数据块的长度,块数据的校验和,以及时间戳。
    2. DataNode启动后向NameNode注册,通过后,周期性(1小时)的向NameNode上报所有的块信息
    3. 心跳是每3秒一次,心跳返回结果带有NameNode给该DataNode的命令如复制块数据到另一台机器,或删除某个数据块。如果超过10分钟没有收到某个DataNode的心跳,则认为该节点不可用。
    4. 集群运行中可以安全加入和退出一些机器。

    8. HDFS 中大量小文件带来的问题及解决方法

    1. 问题:
      hadoop中目录,文件和块都会以对象的形式保存在namenode的内存中, 大概每个对象会占用150bytes. 小文件数量多会大量占用namenode的内存; 使namenode读取元数据速度变慢, 启动时间延长; 还因为占用内存过大, 导致gc时间增加等.
    2. 解决办法:
      (1) 从数据来源入手, 如每小时抽取一次改为每天抽取一次等方法来积累数据量.
      (2) 如果小文件无可避免, 一般就采用合并的方式解决. 可以写一个MR任务读取某个目录下的所有小文件, 并重写为一个大文件.
    展开全文
  • Hdfs面试题

    2019-09-29 20:06:06
    =HDFS== hadoop fs -put localpath hdfspath 上传文件 hadoop fs -get hdfspath localpath 下载文件 hadoop fs -getmerge hdfspath localpath hadoop fs -rm -r hdfspath 删除 hadoop fs -mv(-cp) hadfspath1 ...

    =HDFS==
    hadoop fs -put localpath hdfspath 上传文件
    hadoop fs -get hdfspath localpath 下载文件
    hadoop fs -getmerge hdfspath localpath
    hadoop fs -rm -r hdfspath 删除
    hadoop fs -mv(-cp) hadfspath1 hafspath2 移动
    hadoop fs -cat(-text) hdfspath 查看文件详情
    hadoop fs -ls hdfspath 查看文件总目录

    1. 文件大小默认为 64M,改为 128M 有啥影响?
      增加文件块大小,需要增加磁盘的传输速率。
      1.2.8 HDFS的存储机制
      HDFS存储机制,包括HDFS的写入过程和读取过程两个部分
      1)客户端向namenode请求上传文件,namenode检查目标文件是否已存在,父目录是否存在。
      2)namenode返回是否可以上传。
      3)客户端请求第一个 block上传到哪几个datanode服务器上。
      4)namenode返回3个datanode节点,分别为dn1、dn2、dn3。
      5)客户端请求dn1上传数据,dn1收到请求会继续调用dn2,然后dn2调用dn3,将这个通信管道建立完成
      6)dn1、dn2、dn3逐级应答客户端
      7)客户端开始往dn1上传第一个block(先从磁盘读取数据放到一个本地内存缓存),以packet为单位,dn1收到一个packet就会传给dn2,dn2传给dn3;dn1每传一个packet会放入一个应答队列等待应答
      8)当一个block传输完成之后,客户端再次请求namenode上传第二个block的服务器。(重复执行3-7步)
      1)客户端向namenode请求下载文件,namenode通过查询元数据,找到文件块所在的datanode地址。
      2)挑选一台datanode(就近原则,然后随机)服务器,请求读取数据。
      3)datanode开始传输数据给客户端(从磁盘里面读取数据放入流,以packet为单位来做校验)。
      4)客户端以packet为单位接收,先在本地缓存,然后写入目标文件。
      1.2.9 secondarynamenode工作机制
      1)第一阶段:namenode启动
      (1)第一次启动namenode格式化后,创建fsimage和edits文件。如果不是第一次启动,直接加载编辑日志和镜像文件到内存。
      (2)客户端对元数据进行增删改的请求
      (3)namenode记录操作日志,更新滚动日志。
      (4)namenode在内存中对数据进行增删改查
      2)第二阶段:Secondary NameNode工作
      (1)SecondaryNameNode询问namenode是否需要checkpoint。直接带回namenode是否检查结果。
      (2)SecondaryNameNode请求执行checkpoint。
      (3)namenode滚动正在写的edits日志
      (4)将滚动前的编辑日志和镜像文件拷贝到Secondary NameNode
      (5)SecondaryNameNode加载编辑日志和镜像文件到内存,并合并。
      (6)生成新的镜像文件fsimage.chkpoint
      (7)拷贝fsimage.chkpoint到namenode
      (8)namenode将fsimage.chkpoint重新命名成fsimage
      1.2.10 NameNode与SecondaryNameNode 的区别与联系?
      1)机制流程同上;
      2)区别
      (1)NameNode负责管理整个文件系统的元数据,以及每一个路径(文件)所对应的数据块信息。
      (2)SecondaryNameNode主要用于定期合并命名空间镜像和命名空间镜像的编辑日志。
      3)联系:
      (1)SecondaryNameNode中保存了一份和namenode一致的镜像文件(fsimage)和编辑日志(edits)。
      (2)在主namenode发生故障时(假设没有及时备份数据),可以从SecondaryNameNode恢复数据。
      1.2.15namenode ha高可用源码实现方式
      1)HealthMonitor初始化完成后通过内部线程调用NameNode的RPC接口对其进行健康检查
      2)如果检查到NameNode状态异常,会回调ZKFailoverContorller注册的回调函数进行相应的处理
      3)如果ZKFailoverController发现集群需要进行主备选举,会使用ActiveStanbyElector和zookeeper集群通信完成主备切换
      4)ActiveStanbyElector在完成主备切换后,回调ZKFailoverController注册的方法使NameNode变成active或者stanby状态
    2. datanode什么情况下不会备份?
      设置备份数为1时, 就不会备份了.
      延申—Hadoop中在哪里设置备份数, 是哪个字段?
      在hdfs-site.xml中的dfs.replication变量.
    3. HDFS中大量小文件带来的问题以及解决方法
      问题:
      hadoop中目录,文件和块都会以对象的形式保存在namenode的内存中, 大概每个对象会占用150bytes. 小文件数量多会大量占用namenode的内存; 使namenode读取元数据速度变慢, 启动时间延长; 还因为占用内存过大, 导致gc时间增加等.
      解决办法:
      两个角度, 一是从根源解决小文件的产生, 二是解决不了就选择合并.
      从数据来源入手, 如每小时抽取一次改为每天抽取一次等方法来积累数据量.
      如果小文件无可避免, 一般就采用合并的方式解决. 可以写一个MR任务读取某个目录下的所有小文件, 并重写为一个大文件.
    4. HDFS的三个核心组件是什么, 有什么作用?
      NameNode. 集群的核心, 是整个文件系统的管理节点. 维护着
      a) 文件系统的文件目录结构和元数据信息
      b) 文件与数据块列表的对应关系
      DataNode. 存放具体数据块的节点, 主要负责数据的读写, 定期向NameNode发送心跳
      SecondaryNameNode. 辅助节点, 同步NameNode中的元数据信息, 辅助NameNode对fsimage和editsLog进行合并.
    5. Linux中的块大小为4KB, 为什么HDFS中块大小为64MB或128MB?
      块是存储在文件系统中的数据的最小单元. 如果采用4kb的块大小来存放存储在Hadoop中的数据, 就会需要大量的块, 大大增加了寻找块的时间, 降低了读写效率.
      并且, 一个map或者一个reduce都是以一个块为单位处理, 如果块很小, mapreduce任务数就会很多, 任务之间的切换开销变大, 效率降低.
    6. 并发写入HDFS文件可行吗?
      不行, 因为客户端通过namenode接收到在数据块上写入的许可后, 那个块会锁定直到写入操作完成, 所以不能在同一个块上写入.
      一个datanode 宕机,怎么恢复?
      Datanode宕机了后,如果是短暂的宕机,可以实现写好脚本监控,将它启动起来。如果是长时间宕机了,那么datanode上的数据应该已经被备份到其他机器了,那这台datanode就是一台新的datanode了,删除他的所有数据文件和状态文件,重新启动。
      心跳!
      Hadoop 的 namenode 宕机,怎么解决?
      先分析宕机后的损失,宕机后直接导致client无法访问,内存中的元数据丢失,但是硬盘中的元数据应该还存在,如果只是节点挂了,重启即可,如果是机器挂了,重启机器后看节点是否能重启,不能重启就要找到原因修复了。
      但是最终的解决方案应该是在设计集群的初期就考虑到这个问题,做namenode的HA。
      提高容错:第一种方式是将持久化存储在本地硬盘的文件系统元数据备份。
      第二种方式是运行一个辅助的NameNode(Secondary Namenode)。
      第三种 zookeeper提供的高可用(ha)机制。
      副本存放
      第一个block副本放在client结点所在机架的datanode里(如果client不在集群范围内,则这第一个node是随机选取的,当然系统会尝试不选择哪些太满或者太忙的node)。
      第二个block副本放置在与第一个datanode节点相同的机架中的另一个datanode中(随机选择)。
      第三个block副本放置于另一个随机远端机架的一个随机datanode中。
      简述Combine和partition
      combine分为map端和reduce端,作用是把同一个key的键值对合并在一起,可以自定义的。combine函数把一个map函数产生的<key,value>对(多个key,value)合并成一个新的<key2,value2>.将新的<key2,value2>作为输入到reduce函数中
      这个value2亦可称之为values,因为有多个。这个合并的目的是为了减少网络传输。
      map与reduce的例子
      map理解为销售人员,reduce理解为销售经理。
      每个人(map)只管销售,赚了多少钱销售人员不统计,也就是说这个销售人员没有Combine,那么这个销售经理就累垮了,因为每个人都没有统计,它需要统计所有人员卖了多少件,赚钱了多少钱。
      这样是不行的,所以销售经理(reduce)为了减轻压力,每个人(map)都必须统计自己卖了多少钱,赚了多少钱(Combine),然后经理所做的事情就是统计每个人统计之后的结果。这样经理就轻松多了。所以Combine在map所做的事情,减轻了reduce的事情。
      partition是分割map每个节点的结果,按照key分别映射给不同的reduce,也是可以自定义的。这里其实可以理解归类。
      我们对于错综复杂的数据归类。比如在动物园里有牛羊鸡鸭鹅,他们都是混在一起的,但是到了晚上他们就各自牛回牛棚,羊回羊圈,鸡回鸡窝。partition的作用就是把这些数据归类。只不过在写程序的时候,mapreduce使用哈希HashPartitioner帮我们归类了。这个我们也可以自定义。
      shuffle就是map和reduce之间的过程,包含了两端的combine和partition。
      有200M的文件 写入HDFS是先写128M 复制完之后再写72M 还是全部写完再复制
      HDFS上在写入数据的时候,首先会对数据切块,然后从客户端到datanode形成一个管道,在至少将一个文件写入hdfs上后,表示文件写入成功,然后进行复制备份操作,所以是全部写完再复制。
      hdfs里的 edits和 fsimage作用
      1)、fsimage文件其实是Hadoop文件系统元数据的一个永久性的检查点,其中包含Hadoop文件系统中的所有目录和文件idnode的序列化信息;
      2)、edits文件存放的是Hadoop文件系统的所有更新操作的路径,文件系统客户端执行的所以写操作首先会被记录到edits文件中。
      fsimage和edits文件都是经过序列化的,在NameNode启动的时候,它会将fsimage文件中的内容加载到内存中,之后再执行edits文件中的各项操作,使得内存中的元数据和实际的同步,存在内存中的元数据支持客户端的读操作。
      NameNode起来之后,HDFS中的更新操作会重新写到edits文件中,因为fsimage文件一般都很大(GB级别的很常见),如果所有的更新操作都往fsimage文件中添加,这样会导致系统运行的十分缓慢,但是如果往edits文件里面写就不会这样,每次执行写操作之后,且在向客户端发送成功代码之前,edits文件都需要同步更新。如果一个文件比较大,使得写操作需要向多台机器进行操作,只有当所有的写操作都执行完成之后,写操作才会返回成功,这样的好处是任何的操作都不会因为机器的故障而导致元数据的不同步。
      介绍一下RPC通信的逻辑实现
      Proxy和Impl是对同一个RPC调用接口的实现类,当Proxy中的接口被调用时,通过Client发送消息到 Server ,Server 会按照标准数据格式进行解析,再调用Server侧的 Impl方法进行执行,并返回结果数据。
    展开全文
  • HDFS面试题总结

    2020-02-21 23:09:47
    文章目录HDFS面试题一、选择题1、下列哪项通常是集群的最主要瓶颈(C)2、下列哪项可以作为集群的管理?(B)3、下列哪个是Hadoop运行的模式?(ABC)4、HDFS 中的 block 默认保存几份?(A)5、HDFS 默认 BlockSize...
  • 原文地址: 【大数据面试宝典】 第二篇 HDFS 面试题 HDFS 写文件 网络拓扑-节点距离计算 HDFS读流程 NN和2NN工作机制 Fsimage和Edits解析 CheckPoint时间设置 NameNode故障后的数据恢复 HDFS 数据流 HDFS 写文件 ...
  • 最近工作太忙,没来得及更文,今天整理一篇关于HDFS由浅入深面试相关的内容,以及附上答案,希望对大家...还有就是再我们回答面试题的时候,最好就是回答的内容是将面试官引导到自己所熟悉的知识点上,而不是给自己挖坑
  • Hadoop,MapReduce,HDFS面试题 1.什么是hadoop 答:是google的核心算法MapReduce的一个开源实现。用于海量数据的并行处理。 hadoop的核心主要包含:HDFS和MapReduce HDFS是分布式文件系统,用于分布式存储海量...
  • HDFS面试题(详解)

    2021-05-07 11:08:57
    本文会对HDFS常见面试题进行详解,并且后续持续更新 本次内容: 1.hdfs写流程 2.hdfs读流程 3.hdfs的体系结构 4.一个datanode 宕机,怎么一个流程恢复 5.hadoop 的 namenode 宕机,怎么解决 6.namenode对元数据的...
  • HDFS面试题汇总大全

    2021-03-12 19:53:45
    1 HDFS 1.0 架构 NameNode NameNode 负责管理整个分布式系统的元数据,主要包括: 目录树结构; 文件到数据库 Block 的映射关系; Block 副本及其存储位置等管理数据; DataNode 的状态监控,两者通过段时间间隔的...
  • Hadoop之HDFS面试题整理

    万次阅读 2018-04-28 19:28:56
    1.2HDFS(☆☆☆)1.2.1 HDFS 中的 block 默认保存几份?(A)A.3 份B.2 份C.1 份D.不确定1.2.2HDFS 默认 BlockSize 是(C)A.32MBB.64MB(2.7.2版本,本地模式)C.128MB(2.7.2版本,分布式模式)1.2.3 Client 端...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 5,381
精华内容 2,152
关键字:

hdfs面试题