HDFS 读文件流程

读到一半断线,为何不用重读?

章节

  • 0:00 开场
  • 0:29 一句话回答
  • 0:51 七步全景
  • 1:09 第一步 · open
  • 1:44 第二步 · Block 列表
  • 3:12 第三步 · 选 DataNode
  • 3:38 第四步 · Packet 与校验
  • 4:45 第五步 · 换下一个 Block
  • 5:21 第六步 · 故障处理
  • 6:36 第七步 · close
  • 6:59 完整时序图
  • 7:26 读写对比
  • 8:08 补充一 · 短路读取
  • 9:01 补充二 · 数据本地性
  • 9:50 补充三 · 并行读取
  • 10:35 一棵决策树
  • 10:58 面试回答模板
  • 11:38 高频追问
  • 13:10 回到开头

文稿

开场

读到第 50MB,DataNode 突然断线;客户端不报错,也不从头重读,换一台机器接着读。可大部分人只答得出三步:问 NameNode 要位置,去 DataNode 读,读完关闭。面试官一追问就卡住:副本列表怎么排序?客户端选哪个 DataNode?读到的数据怎么校验?读到一半节点挂了怎么办?这期按 Hadoop 3.3.6 的源码,从 Client 到 DataNode,每一步讲清楚。

一句话回答

一句话回答:客户端先向 NameNode 要文件的 Block 列表,每个 Block 的副本按距离排好序。然后按顺序逐个读 Block,每个 Block 优先连最近的 DataNode。数据按 Packet 流过来,客户端按 Chunk 逐段校验 Checksum。某个副本读失败,就换同一 Block 的其他副本;全部读完,关闭输入流。

七步全景

先看全景,一共七步:open,拿 Block 列表,选最近的 DataNode,按 Packet 读取并校验,读完换下一个 Block,重复到全部读完,最后 close。追问最多的是中间三步:怎么排序,怎么选节点,怎么校验。

第一步 · open

第一步,客户端调用 FileSystem 的 open,告诉 HDFS:我要读这个文件。open 内部先创建一个 DFSInputStream 对象。再通过 DFSClient 向 NameNode 发 RPC,调用 ClientProtocol 的 getBlockLocations。NameNode 返回的 Block 列表,缓存在客户端本地。注意:open 返回时,客户端还没连任何 DataNode,它只拿到一张地图。真正传数据,要等到调用 read 才开始。有一个例外:文件还在写,最后一个 Block 的可见长度,要先问一下 DataNode。

第二步 · Block 列表

第二步,看 NameNode 到底返回了什么。以一个 350MB 的 Parquet 文件为例,Block 大小 128MB,切成 3 个 Block。Block 0 和 Block 1 各 128MB,最后的 Block 2 只有 94MB,不满也不补齐。每个 Block 带着 3 个副本的位置:Block 0 在 DN1、DN3、DN5 上。列表里还有每个 Block 在文件里的偏移量,客户端据此算出该读哪一块。关键细节:副本列表不是随机排的。NameNode 会按客户端到每个 DataNode 的网络距离,从近到远排序。同一台机器距离 0,同机架不同节点距离 2,跨机架距离 4。这个数是拓扑树上的跳数:两端各自往上走,走到共同的祖先为止。所以它不是延迟;跨数据中心记 6,前提是拓扑里配了数据中心这一层。距离相同的副本会随机打散,分摊负载;下线或维护中的节点排到最后。就像导航软件:不只告诉你有三条路,还把最近的排在最前面。还要注意:客户端不一定一次拿到全部 Block 的位置。getBlockLocations 带偏移量和长度两个参数。3.3.6 默认一次取 10 个 Block 大小的范围,128MB 的块就是 1.28GB。文件有几千个 Block 时,先拿前面一批开始读,读出范围再向 NameNode 要下一批。

第三步 · 选 DataNode

第三步,客户端开始读第一个 Block。它从排好序的列表里,取第一个可用的 DataNode,也就是最近的那台,建立 TCP 连接。读请求带三样东西:Block ID、Block 内的起始偏移量、要读的长度。关键理解:NameNode 不参与数据传输。数据在客户端和 DataNode 之间直传,NameNode 只做调度员,不做搬运工。这和写流程的设计一致。

第四步 · Packet 与校验

第四步,DataNode 从本地磁盘读出 Block 数据,一个 Packet 一个 Packet 地发给客户端。和写流程对称,传输分三层:Block、Packet、Chunk。Block 默认 128MB,一个 Block 只从一个 DataNode 读。Packet 是传输单元,常见约 64KB,但不是固定值,也不等于一次 TCP 发送。Chunk 是校验的最小单元:每 512 字节数据,配 4 字节校验和。一个 Packet 里先是包头,再是这批 Chunk 的校验和,最后才是数据。客户端每收到一个 Packet,就逐个 Chunk 校验。取出 512 字节数据,和它对应的 4 字节校验和。对这 512 字节重新算一遍。把算出来的值和附带的值对比:一致,就继续下一个 Chunk。不一致,说明数据损坏,抛出校验异常,进入故障处理。算法要纠正一下:3.3.6 默认是 CRC32C,不是 CRC32,两者都是 4 字节。就像收快递验货:校验码对不上,就退回去,换个仓库重发。

第五步 · 换下一个 Block

第五步,第一个 Block 读完了。客户端关掉当前 Block 的读取器,从缓存的列表里取出下一个 Block,再从它的副本里挑最近的 DataNode,建立连接接着读。所以不同 Block 可能来自不同机器:Block 0 读 DN1,Block 1 读 DN2,Block 2 读 DN4。纠正一个细节:关掉读取器,不一定断开 TCP。正常读完的连接会放进缓存,下次连同一台 DataNode 可以复用。单个输入流是逐 Block 串行读的,但 Block 内部是流式的,DataNode 连续推 Packet。

第六步 · 故障处理

第六步,读的过程中出故障怎么办?先看节点宕机或网络中断。客户端正从 DN1 读 Block 0,读到第 50MB,连接断了。源码会先对同一节点重试一次,防止只是空闲连接被对端关掉。还不行,就把 DN1 记进本地的失败名单,换列表里的下一个:同机架的 DN3。并且从第 50MB 接着读,不用从头再来。DN3 也失败就试 DN5;全都失败,会重新问 NameNode 要位置,再试一轮。默认最多 3 轮,仍然拿不到,才抛出 BlockMissingException。故障二:某个 Chunk 校验不通过,说明数据损坏。客户端把 DN1 上的这个副本记下来,换到 DN3,从当前位置继续读。等别的副本读成功了,再向 NameNode 报告:DN1 上这个 Block 的副本坏了。报告的粒度是整个 Block 副本,不是某一个 Chunk。如果所有副本都读失败,多副本时反而不报告,因为可能是客户端自己出了问题。NameNode 把它标成 CORRUPT,后台从好副本复制一份到新节点,比如 DN7,再删掉坏副本。这些容错对应用通常是透明的,这就是多副本的价值;但副本全不可用时,应用照样收到异常。

第七步 · close

第七步,全部 Block 读完,调用 close,关闭 DFSInputStream。它会释放当前的 Block 读取器、缓冲区,以及本地缓存的 Block 信息。不需要通知 NameNode:读操作不改任何元数据,NameNode 不用知道你读完了。所以读流程比写流程简单得多:不需要 Lease,不需要 Pipeline,也没有 ACK 队列。

完整时序图

把所有角色串成一张时序图。客户端 open,向 NameNode 要 Block 列表,NameNode 排好序返回。客户端连 DN1 读 Block 0:DataNode 连续推 Packet,客户端逐 Chunk 校验,读完换块。Block 1 从 DN2 读;假如校验失败,就换 DN4 重读这一段,读成功后报告坏副本。Block 2 同理;最后 close,不通知 NameNode。

读写对比

再和前面专题讲过的写流程对比。和 NameNode 的交互:读通常一次 getBlockLocations 就够,大文件分批取。写要 create,每个 Block 一次 addBlock,最后 complete。读不需要 Lease,也不需要 Pipeline,只连一个 DataNode;写要独占租约,数据沿管道转发。写有 Packet 级 ACK;读没有逐包 ACK,只在一个 Block 读完时,回一个校验成功的状态码。校验:读时客户端验;写时客户端生成校验和,管道最后一个 DataNode 负责验。出故障时,读换副本继续,写重建 Pipeline 继续;关闭时读直接关,写要调 complete。

补充一 · 短路读取

补充一:短路读取,Short-Circuit Read。普通读取时,就算客户端和 DataNode 在同一台机器上,数据也要经过 DataNode 进程,走一遍本地 TCP,多出内存拷贝和上下文切换。短路读取是:客户端通过 Unix Domain Socket,从 DataNode 拿到 Block 文件和校验文件的文件描述符,然后自己直接读本地磁盘,绕开 DataNode 的数据转发。开启要客户端和 DataNode 都配:dfs.client.read.shortcircuit 设为 true,配好 dfs.domain.socket.path,还要装好 libhadoop 本地库。原稿说能减少 10% 到 30% 的延迟,还是零拷贝;这两点官方都没有承诺,收益要实测。另外,第一个副本放在写入者本机,是副本放置策略本来的规则,不是为短路读设计的。

补充二 · 数据本地性

补充二:数据本地性。很多人把它和 HDFS 读流程混在一起。HDFS 负责两件事:告诉你 Block 在哪些 DataNode 上,读的时候挑最近的副本。至于 Task 跑在哪台机器上,是 YARN、Spark 这些调度器的事。Spark 的本地性从近到远:PROCESS_LOCAL,数据就在同一个 JVM 里;NODE_LOCAL,数据在同一台机器,可能是本机 HDFS,也可能在本机另一个 Executor;NO_PREF,没有位置偏好;RACK_LOCAL,在同一个机架;ANY,在别处。调度器先等最好的级别,等不到就逐级退化,每级默认等 3 秒,由 spark.locality.wait 控制。副本放置、本地性调度、短路读取,三者配合,就是移动计算,而不是移动数据。

补充三 · 并行读取

补充三:一次只读一个 Block 太慢,怎么办?第一种是对冲读取,Hedged Read:第一个请求超过阈值还没回来,就向另一个副本再发一次,谁先回来用谁。用额外的带宽,换更低的尾延迟,防止被一个慢节点拖住。要纠正两点:3.3.6 里它只作用于按位置读的 pread,普通顺序读不走这条路;而且线程池默认是 0,等于关闭;要设成正数才开启,阈值默认 500 毫秒。第二种是计算框架层面的并行:MapReduce、Spark 把不同 Block 分给不同 Task,在不同节点上同时读。单个 DFSInputStream 是串行的,整个文件靠多 Task 并行;底层保持简单,并行交给上层。

一棵决策树

把整个流程收成一棵决策树。open 拿 Block 列表,遍历每个 Block,选最近的 DataNode,建连接读数据,逐 Chunk 校验。节点宕机,就换下一个副本,从断点续读;校验失败,就换副本重读,并报告坏副本。读成功就看还有没有下一个 Block;没有了,就 close 释放资源,不通知 NameNode。

面试回答模板

面试时,按四个阶段答:元数据获取、数据读取、故障处理、关闭。元数据获取:open 调用 getBlockLocations,副本按距离排序,大文件分批取。数据读取:逐个 Block 连最近的 DataNode,Packet 流式传输;客户端每 512 字节一个 Chunk,用 CRC32C 校验。故障处理:节点失败,换副本从断点续读;校验失败,换副本重读,再上报坏副本,由 NameNode 后台补副本。关闭:close 释放本地资源,不通知 NameNode;全程不需要 Lease 和 Pipeline,也没有逐包 ACK。

高频追问

追问一:读为什么不需要像写那样搭 Pipeline?因为读只要从一个副本读就够了;副本内容由写入时的 Pipeline 和 ACK 保证一致,读哪个都一样。读是一对一,写是一对多,复杂度天然不同。追问二:Block 列表是一次全返回,还是分批?分批。默认按 10 个 Block 大小的范围取,读出范围再取下一批。好处有两个:几千个 Block 时,不用一次传一大坨元数据;文件还在写时,后面的 Block 可能还没分配,分批取能拿到最新的。追问三:短路读取和正常读取有什么区别?正常读要经过 DataNode 进程和 TCP;短路读由 DataNode 把文件描述符交给同机客户端,客户端自己读磁盘。它是本地性优化的最后一环:调度器把 Task 放到数据所在节点,短路读让这次本地读更省。追问四:读和写,哪个更容易成为瓶颈?分析场景里常常是读:一份数据,可能被几百个 Task 反复读。读请求远多于写;但具体要看负载,不能一概而论。优化手段有四个:短路读减少本地开销,Hedged Read 避开慢节点,Parquet、ORC 列式格式加谓词下推,少读数据;还有 HDFS 集中缓存,把热点 Block 锁进 DataNode 内存。只调大 DataNode 锁定内存的参数不够,还要用 cacheadmin,建缓存池和缓存指令。

回到开头

回到开头:读到第 50MB 节点断线,客户端换一个副本,从第 50MB 接着读。记住一条主线:NameNode 只给地图,数据直连最近的 DataNode,边读边验,坏了就换。

看完去做题