Hadoop3.1.3入门、使用、调优、源码解析等相关知识
参考：尚硅谷视频教程
data:2022-07-31
一、简介、入门
1.Hadoop组成
1.1 HDFS架构概述
Hadoop Distributed File System，简称HDFS，是一个分布式文件系统。
1.2 YARN架构概述
Yet Another Resource Negotiator简称YARN ，另一种资源协调者，是Hadoop的资源管理器。
1.3 MapReduce架构概述
MapReduce将计算过程分为两个阶段：Map和Reduce
1）Map阶段并行处理输入数据
2）Reduce阶段对Map结果进行汇总
1.4HDFS、YARN、MapReduce三者关系
1.5 大数据技术生态体系
1）Sqoop：Sqoop是一款开源的工具，主要用于在Hadoop、Hive与传统的数据库（MySQL）间进行数据的传递，可以将一个关系型数据库（例如 ：MySQL，Oracle 等）中的数据导进到Hadoop的HDFS中，也可以将HDFS的数据导进到关系型数据库中。
2）Flume：Flume是一个高可用的，高可靠的，分布式的海量日志采集、聚合和传输的系统，Flume支持在日志系统中定制各类数据发送方，用于收集数据；
3）Kafka：Kafka是一种高吞吐量的分布式发布订阅消息系统；
4）Spark：Spark是当前最流行的开源大数据内存计算框架。可以基于Hadoop上存储的大数据进行计算。
5）Flink：Flink是当前最流行的开源大数据内存计算框架。用于实时计算的场景较多。
6）Oozie：Oozie是一个管理Hadoop作业（job）的工作流程调度管理系统。
7）Hbase：HBase是一个分布式的、面向列的开源数据库。HBase不同于一般的关系数据库，它是一个适合于非结构化数据存储的数据库。
8）Hive：Hive是基于Hadoop的一个数据仓库工具，可以将结构化的数据文件映射为一张数据库表，并提供简单的SQL查询功能，可以将SQL语句转换为MapReduce任务进行运行。其优点是学习成本低，可以通过类SQL语句快速实现简单的MapReduce统计，不必开发专门的MapReduce应用，十分适合数据仓库的统计分析。
9）ZooKeeper：它是一个针对大型分布式系统的可靠协调系统，提供的功能包括：配置维护、名字服务、分布式同步、组服务等。
2.虚拟机、Linux系统安装、JDK安装、Hadoop安装
（略）
3.Hadoop运行模式
1.本地模式（略）
2.完全分布式
前置分析：
1）准备3台客户机（关闭防火墙、静态IP、主机名称）
2）安装JDK
3）配置环境变量
4）安装Hadoop
5）配置环境变量
6）配置集群
7）单点启动
8）配置ssh
9）群起并测试集群
2.1虚拟机准备（略）
2.2编写集群分发脚本xsync
1）scp（secure copy）安全拷贝
（1）scp定义
scp可以实现服务器与服务器之间的数据拷贝。（from server1 to server2）
（2）基本语法
scp -r $pdir/$fname $user@$host:$pdir/$fname
命令 递归 要拷贝的文件路径/名称 目的地用户@主机:目的地路径/名称
（3）案例实操
前提：在linux201、linux202、linux203都已经创建好的/opt/module、 /opt/software两个目录，并且已经把这两个目录修改为fuhong:fuhong
[fuhong@linux201~]$ sudo chown fuhong:fuhong -R /opt/module
（a）在linux201上，将linux201中/opt/module/jdk1.8.0_212目录拷贝到linux202上。
[fuhong@linux201~]$ scp -r /opt/module/jdk1.8.0_212 fuhong@linux203:/opt/module
（b）在linux202上，将linux201中/opt/module/hadoop-3.1.3目录拷贝到linux202上。
[fuhong@linux202~]$ scp -r fuhong@linux201:/opt/module/hadoop-3.1.3 /opt/module/
（c）在linux202上操作，将linux201中/opt/module目录下所有目录拷贝到linux203上。
[fuhong@linux202opt]$ scp -r fuhong@linux201:/opt/module/* fuhong@linux203:/opt/module
2）rsync远程同步工具
rsync主要用于备份和镜像。具有速度快、避免复制相同内容和支持符号链接的优点。
rsync和scp区别：用rsync做文件的复制要比scp的速度快，rsync只对差异文件做更新。scp是把所有文件都复制过去。
（1）基本语法
rsync -av $pdir/$fname $user@$host:$pdir/$fname
命令 选项参数 要拷贝的文件路径/名称 目的地用户@主机:目的地路径/名称
选项参数说明
| 选项 | 功能 |
|---|---|
| -a | 归档拷贝 |
| -v | 显示复制过程 |
（2）案例实操
（a）删除linux201中/opt/module/hadoop-3.1.3/wcinput
[fuhong@linux201hadoop-3.1.3]$ rm -rf wcinput/
（b）同步linux201中的/opt/module/hadoop-3.1.3到linux202
[fuhong@linux201 module]$ rsync -av hadoop-3.1.3/ fuhong@linux202:/opt/module/hadoop-3.1.3/
3）xsync集群分发脚本
（1）需求：循环复制文件到所有节点的相同目录下
（2）需求分析：
（a）rsync命令原始拷贝：
rsync -av /opt/module fuhong@linux202:/opt/
（b）期望脚本：
xsync要同步的文件名称
（c）期望脚本在任何路径都能使用（脚本放在声明了全局环境变量的路径）
[fuhong@linux201~]$ echo $PATH
/usr/local/bin:/usr/bin:/usr/local/sbin:/usr/sbin:/home/fuhong/.local/bin:/home/fuhong/bin:/opt/module/jdk1.8.0_212/bin
（3）脚本实现
（a）在/home/fuhong/bin目录下创建xsync文件
[fuhong@linux201 opt]$ cd /home/fuhong
[fuhong@linux201 ~]$ mkdir bin
[fuhong@linux201 ~]$ cd bin
[fuhong@linux201 bin]$ vim xsync
在该文件中编写如下代码
#!/bin/bash
#1. 判断参数个数
if [ $# -lt 1 ]
then
echo Not Enough Arguement!
exit;
fi
#2. 遍历集群所有机器
for host in linux202 linux203 linux201
do
echo ==================== $host ====================
#3. 遍历所有目录，挨个发送
for file in $@
do
#4. 判断文件是否存在
if [ -e $file ]
then
#5. 获取父目录
pdir=$(cd -P $(dirname $file); pwd)
#6. 获取当前文件的名称
fname=$(basename $file)
ssh $host "mkdir -p $pdir"
rsync -av $pdir/$fname $host:$pdir
else
echo $file does not exists!
fi
done
done
（b）修改脚本 xsync 具有执行权限
[fuhong@linux201 bin]$ chmod +x xsync
（c）测试脚本
[fuhong@linux201 ~]$ xsync /home/fuhong/bin
（d）将脚本复制到/bin中，以便全局调用
[fuhong@linux201 bin]$ sudo cp xsync /bin/
（e）同步环境变量配置（root所有者）
[fuhong@linux201 ~]$ sudo ./bin/xsync /etc/profile.d/my_env.sh
注意：如果用了sudo，那么xsync一定要给它的路径补全。
让环境变量生效
[fuhong@linux202 bin]$ source /etc/profile
[fuhong@linux203 opt]$ source /etc/profile
3.SSH无密登录配置
1）配置ssh
（1）基本语法
ssh另一台电脑的IP地址
（2）ssh连接时出现Host key verification failed的解决方法
[fuhong@linux201 ~]$ ssh linux202
如果出现如下内容
Are you sure you want to continue connecting (yes/no)?
输入yes，并回车
（3）退回到linux201
[fuhong@linux202 ~]$ exit
2）无密钥配置
（1）免密登录原理
查看所以隐藏文件
[root@linux201 ~]$ ls -al
生成公钥、私钥
[root@linux201 .ssh]$ ssh-keygen -t rsa
然后敲（三个回车），就会生成两个文件id_rsa（私钥）、id_rsa.pub（公钥）
将公钥拷贝到要免密登录的目标机器上
[root@linux201 .ssh]$ ssh-copy-id linux201
[root@linux201 .ssh]$ ssh-copy-id linux202
[root@linux201 .ssh]$ ssh-copy-id linux203
注意：
还需要在linux202上采用fuhong账号配置一下无密登录到linux201、linux202、linux203服务器上。
还需要在linux203上采用fuhong账号配置一下无密登录到linux201、linux202、linux203服务器上。
还需要在linux201上采用root账号，配置一下无密登录到linux201、linux202、linux203；
3）.ssh文件夹下（~/.ssh）的文件功能解释
| known_hosts | 记录ssh访问过计算机的公钥（public key） |
|---|---|
| id_rsa | 生成的私钥 |
| id_rsa.pub | 生成的公钥 |
| authorized_keys | 存放授权过的无密登录服务器公钥 |
4.集群配置
1）集群部署规划
注意：
NameNode和SecondaryNameNode不要安装在同一台服务器
ResourceManager也很消耗内存，不要和NameNode、SecondaryNameNode配置在同一台机器上。
| linux201 | linux202 | linux203 | |
|---|---|---|---|
| HDFS | NameNode DataNode | DataNode | SecondaryNameNode DataNode |
| YARN | NodeManager | ResourceManager NodeManager | NodeManager |
2）配置文件说明
Hadoop配置文件分两类：默认配置文件和自定义配置文件，只有用户想修改某一默认配置值时，才需要修改自定义配置文件，更改相应属性值。
（1）默认配置文件：
| 要获取的默认文件 | 文件存放在Hadoop的jar包中的位置 |
|---|---|
| [core-default.xml] | hadoop-common-3.1.3.jar/core-default.xml |
| [hdfs-default.xml] | hadoop-hdfs-3.1.3.jar/hdfs-default.xml |
| [yarn-default.xml] | hadoop-yarn-common-3.1.3.jar/yarn-default.xml |
| [mapred-default.xml] | hadoop-mapreduce-client-core-3.1.3.jar/mapred-default.xml |
（2）自定义配置文件：
core-site.xml、hdfs-site.xml、yarn-site.xml、mapred-site.xml四个配置文件存放在$HADOOP_HOME/etc/hadoop这个路径上，用户可以根据项目需求重新进行修改配置。
3）配置集群
（1）核心配置文件
配置core-site.xml
[fuhong@linux201 ~]$ cd $HADOOP_HOME/etc/hadoop
[fuhong@linux201 hadoop]$ vim core-site.xml
文件内容如下：
<?xml version="1.0" encoding="UTF-8"?>
<?xml-stylesheet type="text/xsl" href="configuration.xsl"?>
<configuration>
<!-- 指定NameNode的地址 -->
<property>
<name>fs.defaultFS</name>
<value>hdfs://linux201:8020</value>
</property>
<!-- 指定hadoop数据的存储目录 -->
<property>
<name>hadoop.tmp.dir</name>
<value>/opt/module/hadoop-3.1.3/data</value>
</property>
<!-- 配置HDFS网页登录使用的静态用户为fuhong-->
<property>
<name>hadoop.http.staticuser.user</name>
<value>fuhong</value>
</property>
</configuration>
（2）HDFS配置文件
配置hdfs-site.xml
[fuhong@linux201 hadoop]$ vim hdfs-site.xml
文件内容如下：
<?xml version="1.0" encoding="UTF-8"?>
<?xml-stylesheet type="text/xsl" href="configuration.xsl"?>
<configuration>
<!-- nn web端访问地址-->
<property>
<name>dfs.namenode.http-address</name>
<value>linux201:9870</value>
</property>
<!-- 2nn web端访问地址-->
<property>
<name>dfs.namenode.secondary.http-address</name>
<value>linux203:9868</value>
</property>
</configuration>
（3）YARN配置文件
配置yarn-site.xml
[fuhong@linux201 hadoop]$ vim yarn-site.xml
文件内容如下：
后面搭建集群遇到报错记录：
1.问题
[2022-01-10 22:41:15.848]Container killed on request. Exit code is 143
[2022-01-10 22:41:15.867]Container exited with a non-zero exit code 143.
2.解决，添加配置
<?xml version="1.0" encoding="UTF-8"?>
<?xml-stylesheet type="text/xsl" href="configuration.xsl"?>
<configuration>
<!-- 指定MR走shuffle -->
<property>
<name>yarn.nodemanager.aux-services</name>
<value>mapreduce_shuffle</value>
</property>
<!-- 指定ResourceManager的地址-->
<property>
<name>yarn.resourcemanager.hostname</name>
<value>linux202</value>
</property>
<!-- 环境变量的继承 -->
<property>
<name>yarn.nodemanager.env-whitelist</name>
<value>JAVA_HOME,HADOOP_COMMON_HOME,HADOOP_HDFS_HOME,HADOOP_CONF_DIR,CLASSPATH_PREPEND_DISTCACHE,HADOOP_YARN_HOME,HADOOP_MAPRED_HOME</value>
</property>
<property>
<description>Whether virtual memory limits will be enforced for
containers.</description>
<name>yarn.nodemanager.vmem-check-enabled</name>
<value>false</value>
</property>
</configuration>
（4）MapReduce配置文件
配置mapred-site.xml
[fuhong@linux201 hadoop]$ vim mapred-site.xml
文件内容如下：
<?xml version="1.0" encoding="UTF-8"?>
<?xml-stylesheet type="text/xsl" href="configuration.xsl"?>
<configuration>
<!-- 指定MapReduce程序运行在Yarn上 -->
<property>
<name>mapreduce.framework.name</name>
<value>yarn</value>
</property>
<property>
<name>yarn.app.mapreduce.am.env</name>
<value>HADOOP_MAPRED_HOME=/opt/module/hadoop-3.1.3</value>
</property>
<property>
<name>mapreduce.map.env</name>
<value>HADOOP_MAPRED_HOME=/opt/module/hadoop-3.1.3</value>
</property>
<property>
<name>mapreduce.reduce.env</name>
<value>HADOOP_MAPRED_HOME=/opt/module/hadoop-3.1.3</value>
</property>
</configuration>
4）在集群上分发配置好的Hadoop配置文件
[fuhong@linux201 etc]$ xsync /opt/module/hadoop-3.1.3/etc/hadoop/
5）去103和104上查看文件分发情况
[fuhong@linux202 ~]$ cat /opt/module/hadoop-3.1.3/etc/hadoop/core-site.xml
[fuhong@linux203 ~]$ cat /opt/module/hadoop-3.1.3/etc/hadoop/core-site.xml
5 群起集群
1）配置workers
[fuhong@linux201 ~]$ vim /opt/module/hadoop-3.1.3/etc/hadoop/workers
在该文件中增加如下内容：
linux201
linux202
linux203
注意：该文件中添加的内容结尾不允许有空格，文件中不允许有空行。
同步所有节点配置文件
[fuhong@linux201 ~]$ xsync /opt/module/hadoop-3.1.3/etc
2）启动集群
（1）如果集群是第一次启动，需要在linux201节点格式化NameNode（注意：格式化NameNode，会产生新的集群id，导致NameNode和DataNode的集群id不一致，集群找不到已往数据。如果集群在运行过程中报错，需要重新格式化NameNode的话，一定要先停止namenode和datanode进程，并且要删除所有机器的data和logs目录，然后再进行格式化。）
[fuhong@linux201 ~]$ hdfs namenode -format
#初始化完毕多一个data文件夹
[fuhong@linux201 hadoop-3.1.3]$ cd data/dfs/name/current/
[fuhong@linux201 current]$ vim VERSION
（2）启动HDFS
[fuhong@linux201 hadoop-3.1.3]$ sbin/start-dfs.sh
#查看启动状态
[fuhong@linux201 current]$ jps
（3）Web端查看HDFS的NameNode
（a）浏览器中输入：http://linux201:9870
（b）查看HDFS上存储的数据信息
（4）在配置了ResourceManager的节点（linux202）启动YARN
[fuhong@linux202 hadoop-3.1.3]$ sbin/start-yarn.sh
（5）Web端查看YARN的ResourceManager
（a）浏览器中输入：http://linux202:8088
（b）查看YARN上运行的Job信息
3）集群基本测试
（1）上传文件到集群
上传小文件到/wcinput目录
#创建文件夹
[fuhong@linux201 hadoop-3.1.3]$ hadoop fs -mkdir /wcinput
#上传文件
[fuhong@linux201 hadoop-3.1.3]$ hadoop fs -put test/word.txt /wcinput
上传大文件到根目录
[fuhong@linux201 hadoop-3.1.3]$ hadoop fs -put /opt/software/jdk-8u212-linux-x64.tar.gz /
（2）上传文件后查看文件存放在什么位置
查看HDFS文件存储路径
[fuhong@linux201 hadoop-3.1.3]$ cd data/dfs/data/current/BP-253814018-192.168.10.201-1641821585874/current/finalized/subdir0/subdir0/
查看HDFS在磁盘存储文件内容
#查看数据
[fuhong@linux201 subdir0]$ cat blk_1073741825
（3）拼接分包压缩
-rw-rw-r--. 1 fuhong fuhong 134217728 1月 10 22:13 blk_1073741826
-rw-rw-r--. 1 fuhong fuhong 1048583 1月 10 22:13 blk_1073741826_1002.meta
-rw-rw-r--. 1 fuhong fuhong 60795424 1月 10 22:13 blk_1073741827
-rw-rw-r--. 1 fuhong fuhong 474975 1月 10 22:13 blk_1073741827_1003.meta
[fuhong@linux201 subdir0]$ cat blk_1073741826 >> tmp.tar.gz
[fuhong@linux201 subdir0]$ cat blk_1073741827 >> tmp.tar.gz
[fuhong@linux201 subdir0]$ tar -zxvf tmp.tar.gz
（4）副本有三份
在linux202,linux203同样有数据，体现hadoop高可用，如果有四台服务器，也是任意选择三台存储
（4）下载
[fuhong@hadoop104 software]$ hadoop fs -get /jdk-8u212-linux-x64.tar.gz ./
（5）执行wordcount程序
[fuhong@linux201 hadoop-3.1.3]$ hadoop jar share/hadoop/mapreduce/hadoop-mapreduce-examples-3.1.3.jar wordcount /wcinput /output
6 配置历史服务器
为了查看程序的历史运行情况，需要配置一下历史服务器。具体配置步骤如下：
1）配置mapred-site.xml
[fuhong@linux201 hadoop]$ vim mapred-site.xml
在该文件里面增加如下配置。
<!-- 历史服务器端地址 -->
<property>
<name>mapreduce.jobhistory.address</name>
<value>linux201:10020</value>
</property>
<!-- 历史服务器web端地址 -->
<property>
<name>mapreduce.jobhistory.webapp.address</name>
<value>linux201:19888</value>
</property>
2）分发配置
[fuhong@linux201 hadoop]$ xsync $HADOOP_HOME/etc/hadoop/mapred-site.xml
3）在hadoop102启动历史服务器
[fuhong@linux201 hadoop]$ mapred --daemon start historyserver
4）查看历史服务器是否启动
[fuhong@linux201 hadoop]$ jps
5）查看JobHistory
http://linux201:19888/jobhistory
6）重新执行任务，查看历史服务器
7.集群崩溃解决方法(学习用)
实际上：
保证namespaceID一致
[fuhong@linux202 hadoop-3.1.3]$ cat data/dfs/data/current/BP-572461443-192.168.10.201-1641870291928/current/VERSION
保证datanode版本一致
[fuhong@linux202 hadoop-3.1.3]$ cat data/dfs/data/current/VERSION
1）关闭yarn
[fuhong@linux202 sbin]$ stop-yarn.sh
- 关闭dfs
[fuhong@linux201 sbin]$ stop-dfs.sh
- 删除每一个节点的data目录logs目录
[fuhong@linux201 hadoop-3.1.3]$ rm -rf data/ logs/
[fuhong@linux202 hadoop-3.1.3]$ rm -rf data/ logs/
[fuhong@linux203 hadoop-3.1.3]$ rm -rf data/ logs/
- 格式化hdfs
[fuhong@linux201 hadoop-3.1.3]$ hdfs namenode -format
5）启动dfs
[fuhong@linux201 hadoop-3.1.3]$ sbin/start-dfs.sh
- 启动yarn
[fuhong@linux202 hadoop-3.1.3]$ sbin/start-yarn.sh
8 配置日志的聚集
日志聚集概念：应用运行完成以后，将程序运行日志信息上传到HDFS系统上。
日志聚集功能好处：可以方便的查看到程序运行详情，方便开发调试。
注意：开启日志聚集功能，需要重新启动NodeManager 、ResourceManager和HistoryServer。
开启日志聚集功能具体步骤如下：
1）配置yarn-site.xml
[fuhong@linux201 hadoop]$ vim yarn-site.xml
在该文件里面增加如下配置。
<!-- 开启日志聚集功能 -->
<property>
<name>yarn.log-aggregation-enable</name>
<value>true</value>
</property>
<!-- 设置日志聚集服务器地址 -->
<property>
<name>yarn.log.server.url</name>
<value>http://hadoop102:19888/jobhistory/logs</value>
</property>
<!-- 设置日志保留时间为7天 -->
<property>
<name>yarn.log-aggregation.retain-seconds</name>
<value>604800</value>
</property>
2）分发配置
[fuhong@linux201 hadoop]$ xsync $HADOOP_HOME/etc/hadoop/yarn-site.xml
3）关闭NodeManager 、ResourceManager和HistoryServer
[fuhong@linux202 hadoop-3.1.3]$ sbin/stop-yarn.sh
[fuhong@linux201 hadoop]$ mapred --daemon stop historyserver
4）启动NodeManager 、ResourceManage和HistoryServer
[fuhong@linux202 hadoop-3.1.3]$ sbin/start-yarn.sh
[fuhong@linux201 hadoop]$ mapred --daemon start historyserver
5）删除HDFS上已经存在的输出文件
[fuhong@linux201 hadoop]$ hadoop fs -rm -r /output
6）执行WordCount程序
[fuhong@linux201 hadoop-3.1.3]$ hadoop jar share/hadoop/mapreduce/hadoop-mapreduce-examples-3.1.3.jar wordcount /input /output
7）查看日志
（1）历史服务器地址
http://hadoop102:19888/jobhistory
（2）历史任务列表
9.集群启动/停止方式总结
1）各个模块分开启动/停止（配置ssh是前提）常用
（1）整体启动/停止HDFS
start-dfs.sh/stop-dfs.sh
（2）整体启动/停止YARN
start-yarn.sh/stop-yarn.sh
2）各个服务组件逐一启动/停止
（1）分别启动/停止HDFS组件
hdfs --daemon start/stop namenode/datanode/secondarynamenode
（2）启动/停止YARN
yarn --daemon start/stop resourcemanager/nodemanager
10 编写Hadoop集群常用脚本
1）Hadoop集群启停脚本（包含HDFS，Yarn，Historyserver）：myhadoop.sh
[fuhong@linux201 hadoop-3.1.3]$ cd /home/fuhong/bin/
[fuhong@linux201 bin]$ vim myhadoop.sh
输入如下内容
#!/bin/bash
if [ $# -lt 1 ]
then
echo "No Args Input..."
exit ;
fi
case $1 in
"start")
echo " =================== 启动 hadoop集群 ==================="
echo " --------------- 启动 hdfs ---------------"
ssh linux201 "/opt/module/hadoop-3.1.3/sbin/start-dfs.sh"
echo " --------------- 启动 yarn ---------------"
ssh linux202 "/opt/module/hadoop-3.1.3/sbin/start-yarn.sh"
echo " --------------- 启动 historyserver ---------------"
ssh linux201 "/opt/module/hadoop-3.1.3/bin/mapred --daemon start historyserver"
;;
"stop")
echo " =================== 关闭 hadoop集群 ==================="
echo " --------------- 关闭 historyserver ---------------"
ssh linux201 "/opt/module/hadoop-3.1.3/bin/mapred --daemon stop historyserver"
echo " --------------- 关闭 yarn ---------------"
ssh linux202 "/opt/module/hadoop-3.1.3/sbin/stop-yarn.sh"
echo " --------------- 关闭 hdfs ---------------"
ssh linux201 "/opt/module/hadoop-3.1.3/sbin/stop-dfs.sh"
;;
*)
echo "Input Args Error..."
;;
esac
保存后退出，然后赋予脚本执行权限
[fuhong@linux201 bin]$ chmod +x myhadoop.sh
执行启动或者停止
[fuhong@linux201 bin]$ myhadoop.sh stop
[fuhong@linux201 bin]$ myhadoop.sh start
2）查看三台服务器Java进程脚本：jpsall
[fuhong@linux201 hadoop-3.1.3]$ cd /home/fuhong/bin/
[fuhong@linux201 bin]$ vim jpsall
输入如下内容
#!/bin/bash
for host in linux201 linux202 linux203
do
echo =============== $host ===============
ssh $host jps
done
保存后退出，然后赋予脚本执行权限
[fuhong@linux201 bin]$ chmod 777 myhadoop.sh
3）分发/home/fuhong/bin目录，保证自定义脚本在三台机器上都可以使用
[fuhong@linux201 bin]$ xsync /home/fuhong/bin/
11 常用端口号/常用配置文件说明
| 端口名称 | Hadoop2.x | Hadoop3.x |
|---|---|---|
| NameNode内部通信端口 | 8020 / 9000 | 8020 / 9000/9820 |
| NameNode HTTP UI对用户的查询端口 | 50070 | 9870 |
| MapReduce查看执行任务端口，3.0x yarn查看任务运行 | 8088 | 8088 |
| 历史服务器通信端口 | 19888 | 19888 |
配置文件：
hadoop3.0x:
core-site.xml、hdfs-site.xml、yarn-site.xml、mapred-site.xml、workers
hadoop2.0x:
core-site.xml、hdfs-site.xml、yarn-site.xml、mapred-site.xml、slaves
12 集群时间同步
如果服务器在公网环境（能连接外网），可以不采用集群时间同步，因为服务器会定期和公网时间进行校准；
如果服务器在内网环境，必须要配置集群时间同步，否则时间久了，会产生时间偏差，导致集群执行任务时间不同步。
1）需求
找一个机器，作为时间服务器，所有的机器与这台集群时间进行定时的同步，生产环境根据任务对时间的准确程度要求周期同步。测试环境为了尽快看到效果，采用1分钟同步一次。
2）时间服务器配置（必须root用户）
（1）查看所有节点ntpd服务状态和开机自启动状态
[root@linux201 bin]# systemctl status ntpd
[root@linux201 bin]# systemctl start ntpd
[root@linux201 bin]# systemctl is-enabled ntpd
（2）修改linux201的ntp.conf配置文件
[root@linux201 bin]# vim /etc/ntp.conf
修改内容如下
（a）修改1（授权192.168.10.0-192.168.10.255网段上的所有机器可以从这台机器上查询和同步时间）
#restrict 192.168.10.0 mask 255.255.255.0 nomodify notrap
改为
restrict 192.168.10.0 mask 255.255.255.0 nomodify notrap
（b）修改2（集群在局域网中，不使用其他互联网上的时间）
server 0.centos.pool.ntp.org iburst
server 1.centos.pool.ntp.org iburst
server 2.centos.pool.ntp.org iburst
server 3.centos.pool.ntp.org iburst
改为
#server 0.centos.pool.ntp.org iburst
#server 1.centos.pool.ntp.org iburst
#server 2.centos.pool.ntp.org iburst
#server 3.centos.pool.ntp.org iburst
（c）添加3（当该节点丢失网络连接，依然可以采用本地时间作为时间服务器为集群中的其他节点提供时间同步）
server 127.127.1.0
fudge 127.127.1.0 stratum 10
（3）修改linux201的/etc/sysconfig/ntpd 文件
[root@linux201 ~]$ vim /etc/sysconfig/ntpd
增加内容如下（让硬件时间与系统时间一起同步）
SYNC_HWCLOCK=yes
（4）重新启动ntpd服务
[root@linux201 ~]$ systemctl start ntpd
（5）设置ntpd服务开机启动
[root@linux201 ~]$ systemctl enable ntpd
3）其他机器配置（必须root用户）
（1）关闭所有节点上ntp服务和自启动
[root@linux202 ~]$ systemctl stop ntpd
[root@linux202 ~]$ systemctl disable ntpd
[root@linux203 ~]$ systemctl stop ntpd
[root@linux203 ~]$ systemctl disable ntpd
（2）在其他机器配置1分钟与时间服务器同步一次
[root@linux202 ~]$ crontab -e
编写定时任务如下：
*/1 * * * * /usr/sbin/ntpdate linux201
（3）修改任意机器时间
[root@linux202 ~]$ date -s "2021-9-11 11:11:11"
（4）1分钟后查看机器是否与时间服务器同步
[root@linux202 ~]$ date
4 常见错误及解决方案
1）防火墙没关闭、或者没有启动YARN
INFO client.RMProxy: Connecting to ResourceManager at hadoop108/192.168.10.108:8032
2）主机名称配置错误
3）IP地址配置错误
4）ssh没有配置好
5）root用户和fuhong两个用户启动集群不统一
6）配置文件修改不细心
7）不识别主机名称
java.net.UnknownHostException: linux201: linux201
at java.net.InetAddress.getLocalHost(InetAddress.java:1475)
at org.apache.hadoop.mapreduce.JobSubmitter.submitJobInternal(JobSubmitter.java:146)
at org.apache.hadoop.mapreduce.Job$10.run(Job.java:1290)
at org.apache.hadoop.mapreduce.Job$10.run(Job.java:1287)
at java.security.AccessController.doPrivileged(Native Method)
at javax.security.auth.Subject.doAs(Subject.java:415)
解决办法：
（1）在/etc/hosts文件中添加192.168.10.201 linux201
（2）主机名称不要起hadoop hadoop000等特殊名称
8）DataNode和NameNode进程同时只能工作一个。
9）执行命令不生效，粘贴Word中命令时，遇到-和长–没区分开。导致命令失效
解决办法：尽量不要粘贴Word中代码。
10）jps发现进程已经没有，但是重新启动集群，提示进程已经开启。
原因是在Linux的根目录下/tmp目录中存在启动的进程临时文件，将集群相关进程删除掉，再重新启动集群。
11）jps不生效
原因：全局变量hadoop java没有生效。解决办法：需要source /etc/profile文件。
12）8088端口连接不上
[fuhong@linux201 桌面]$ cat /etc/hosts
注释掉如下代码
#127.0.0.1 localhost localhost.localdomain localhost4 localhost4.localdomain4
#::1 linux201
二、HDFS
1.HDFS产出背景及定义
1 HDFS产生背景
随着数据量越来越大，在一个操作系统存不下所有的数据，那么就分配到更多的操作系统管理的磁盘中，但是不方便管理和维护，迫切需要一种系统来管理多台机器上的文件，这就是分布式文件管理系统。HDFS只是分布式文件管理系统中的一种。
2 HDFS定义
HDFS（Hadoop Distributed File System），它是一个文件系统，用于存储文件，通过目录树来定位文件；其次，它是分布式的，由很多服务器联合起来实现其功能，集群中的服务器有各自的角色。
HDFS的使用场景：适合一次写入，多次读出的场景。一个文件经过创建、写入和关闭之后就不需要改变。
2 HDFS优缺点
1.优点
2.缺点
3 HDFS组成架构
1 ) NameNode (nn) :就是Master，它是一个主管、管理者。
(1）管理HDFS的名称空间;
(2）配置副本策略;
(3）管理数据块（Block)映射信息;
(4）处理客户端读写请求。
2 ) DataNode:就是Slave。NameNode下达命令，DataNode执行实际的操作。
(1)存储实际的数据块;
(2）执行数据块的读写操作。
3 ) Client:就是客户端。
(1)文件切分。文件上传HDFS的时候，Client将文件切分成一个一个的Block，然后进行上传;
(2)与NameNode交互，获取文件的位置信息;
(3）与DataNode交互，读取或者写入数据;
(4) Client提供一些命令来管理HDFS，比如NameNode格式化;
(5) Client可以通过一些命令来访问HDFS，比如对HDFS增删查改操作;
- Secondary NameNode:并非NameNode的热备。当NameNode挂掉的时候，它并不能马上替换NameNode并提供服务。
(1）辅助NameNode，分担其工作量，比如定期合并Fsimage和Edits，并推送给NameNode;
(2）在紧急情况下，可辅助恢复NameNode。
4 HDFS文件块大小
（面试重点）
HDFS中的文件在物理上是分块存储（Block)，块的大小可以通过配置参数( dfs.blocksize)来规定，默认大小在Hadoop2.x/3.x版本中是128M，1.x版本中是64M。
思考:为什么块的大小不能设置太小，也不能设置太大?
(1 ) HDFS的块设置太小，会增加寻址时间，程序一直在找块的开始位置;
(2）如果块设置的太大，从磁盘传输数据的时间会明显大于定位这个块开始位置所需的时间。导致程序在处理这块数据时，会非常慢。
总结:HDFS块的大小设置主要取决于磁盘传输速率。
5 HDFS的Shell操作（开发重点）
1 基本语法
hadoop fs 具体命令 OR hdfs dfs 具体命令
两个是完全相同的。
2 命令大全
[fuhong@linux203 hadoop-3.1.3]$ bin/hadoop fs
Usage: hadoop fs [generic options]
[-appendToFile <localsrc> ... <dst>]
[-cat [-ignoreCrc] <src> ...]
[-checksum <src> ...]
[-chgrp [-R] GROUP PATH...]
[-chmod [-R] <MODE[,MODE]... | OCTALMODE> PATH...]
[-chown [-R] [OWNER][:[GROUP]] PATH...]
[-copyFromLocal [-f] [-p] [-l] [-d] [-t <thread count>] <localsrc> ... <dst>]
[-copyToLocal [-f] [-p] [-ignoreCrc] [-crc] <src> ... <localdst>]
[-count [-q] [-h] [-v] [-t [<storage type>]] [-u] [-x] [-e] <path> ...]
[-cp [-f] [-p | -p[topax]] [-d] <src> ... <dst>]
[-createSnapshot <snapshotDir> [<snapshotName>]]
[-deleteSnapshot <snapshotDir> <snapshotName>]
[-df [-h] [<path> ...]]
[-du [-s] [-h] [-v] [-x] <path> ...]
[-expunge]
[-find <path> ... <expression> ...]
[-get [-f] [-p] [-ignoreCrc] [-crc] <src> ... <localdst>]
[-getfacl [-R] <path>]
[-getfattr [-R] {-n name | -d} [-e en] <path>]
[-getmerge [-nl] [-skip-empty-file] <src> <localdst>]
[-head <file>]
[-help [cmd ...]]
[-ls [-C] [-d] [-h] [-q] [-R] [-t] [-S] [-r] [-u] [-e] [<path> ...]]
[-mkdir [-p] <path> ...]
[-moveFromLocal <localsrc> ... <dst>]
[-moveToLocal <src> <localdst>]
[-mv <src> ... <dst>]
[-put [-f] [-p] [-l] [-d] <localsrc> ... <dst>]
[-renameSnapshot <snapshotDir> <oldName> <newName>]
[-rm [-f] [-r|-R] [-skipTrash] [-safely] <src> ...]
[-rmdir [--ignore-fail-on-non-empty] <dir> ...]
[-setfacl [-R] [{-b|-k} {-m|-x <acl_spec>} <path>]|[--set <acl_spec> <path>]]
[-setfattr {-n name [-v value] | -x name} <path>]
[-setrep [-R] [-w] <rep> <path> ...]
[-stat [format] <path> ...]
[-tail [-f] [-s <sleep interval>] <file>]
[-test -[defsz] <path>]
[-text [-ignoreCrc] <src> ...]
[-touch [-a] [-m] [-t TIMESTAMP ] [-c] <path> ...]
[-touchz <path> ...]
[-truncate [-w] <length> <path> ...]
[-usage [cmd ...]]
3 常用命令实操
1 准备工作
1）启动Hadoop集群（方便后续的测试）
[fuhong@linux201 hadoop-3.1.3]$ sbin/start-dfs.sh
[fuhong@linux202 hadoop-3.1.3]$ sbin/start-yarn.sh
2）-help：输出这个命令参数
[fuhong@linux201 hadoop-3.1.3]$ hadoop fs -help rm
3）创建/sanguo文件夹
[fuhong@linux201 hadoop-3.1.3]$ hadoop fs -mkdir /sanguo
2 上传
1）-moveFromLocal：从本地剪切粘贴到HDFS
[root@linux201 hadoop-3.1.3]# vim shuguo.txt
输入：
shuguo
[fuhong@linux201 hadoop-3.1.3]$ hadoop fs -moveFromLocal shuguo.txt /sanguo
2）-copyFromLocal：从本地文件系统中拷贝文件到HDFS路径去
[fuhong@linux201 hadoop-3.1.3]$ vim weiguo.txt
输入：
weiguo
[fuhong@linux201 hadoop-3.1.3]$ hadoop fs -copyFromLocal weiguo.txt /sanguo
3）-put：等同于copyFromLocal，生产环境更习惯用put
[fuhong@linux201 hadoop-3.1.3]$ vim wuguo.txt
输入：
wuguo
[fuhong@linux201 hadoop-3.1.3]$ hadoop fs -put wuguo.txt /sanguo
4）-appendToFile：追加一个文件到已经存在的文件末尾
[fuhong@linux201 hadoop-3.1.3]$ vim liubei.txt
输入：
liubei
[fuhong@linux201 hadoop-3.1.3]$ hadoop fs -appendToFile liubei.txt /sanguo/shuguo.txt
3 下载
1）-copyToLocal：从HDFS拷贝到本地
[fuhong@linux201 hadoop-3.1.3]$ hadoop fs -copyToLocal /sanguo/shuguo.txt ./
2）-get：等同于copyToLocal，生产环境更习惯用get
[fuhong@linux201 hadoop-3.1.3]$ hadoop fs -get /sanguo/shuguo.txt ./shuguo2.txt
4 HDFS直接操作
1）-ls: 显示目录信息
[fuhong@linux201 hadoop-3.1.3]$ hadoop fs -ls /sanguo
2）-cat：显示文件内容
[fuhong@linux201 hadoop-3.1.3]$ hadoop fs -cat /sanguo/shuguo.txt
3）-chgrp、-chmod、-chown：Linux文件系统中的用法一样，修改文件所属权限
[fuhong@linux201 hadoop-3.1.3]$ hadoop fs -chmod 666 /sanguo/shuguo.txt
[fuhong@linux201 hadoop-3.1.3]$ hadoop fs -chown fuhong:fuhong /sanguo/shuguo.txt
4）-mkdir：创建路径
[fuhong@linux201 hadoop-3.1.3]$ hadoop fs -mkdir /jinguo
5）-cp：从HDFS的一个路径拷贝到HDFS的另一个路径
[fuhong@linux201 hadoop-3.1.3]$ hadoop fs -cp /sanguo/shuguo.txt /jinguo
6）-mv：在HDFS目录中移动文件
[fuhong@linux201 hadoop-3.1.3]$ hadoop fs -mv /sanguo/wuguo.txt /jinguo
[fuhong@linux201 hadoop-3.1.3]$ hadoop fs -mv /sanguo/weiguo.txt /jinguo
7）-tail：显示一个文件的末尾1kb的数据
[fuhong@linux201 hadoop-3.1.3]$ hadoop fs -tail /jinguo/shuguo.txt
8）-rm：删除文件或文件夹
[fuhong@linux201 hadoop-3.1.3]$ hadoop fs -rm /sanguo/shuguo.txt
9）-rm -r：递归删除目录及目录里面内容
[fuhong@linux201 hadoop-3.1.3]$ hadoop fs -rm -r /sanguo
10）-du统计文件夹的大小信息
[fuhong@linux201 hadoop-3.1.3]$ hadoop fs -du -s -h /jinguo
27 81 /jinguo
[fuhong@linux201 hadoop-3.1.3]$ hadoop fs -du -h /jinguo
14 42 /jinguo/shuguo.txt
7 21 /jinguo/weiguo.txt
6 18 /jinguo/wuguo.tx
说明：27表示文件大小；81表示27*3个副本；/jinguo表示查看的目录
11）-setrep：设置HDFS中文件的副本数量
[fuhong@linux201 hadoop-3.1.3]$ hadoop fs -setrep 10 /jinguo/shuguo.txt
6 HDFS的API操作
1 客户端环境准备
1）找到资料包路径下的Windows依赖文件夹，拷贝hadoop-3.1.0到非中文路径（比如d:\）。
2）配置HADOOP_HOME环境变量
3）配置Path环境变量。
注意：如果环境变量不起作用，可以重启电脑试试。
验证Hadoop环境变量是否正常。双击winutils.exe，如果报如下错误。说明缺少微软运行库（正版系统往往有这个问题）。再资料包里面有对应的微软运行库安装包双击安装即可。
4）在IDEA中创建一个Maven工程HdfsClientDemo，并导入相应的依赖坐标+日志添加
<dependency>
<groupId>org.apache.hadoop</groupId>
<artifactId>hadoop-client</artifactId>
<version>3.1.3</version>
</dependency>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.12</version>
</dependency>
<dependency>
<groupId>org.slf4j</groupId>
<artifactId>slf4j-log4j12</artifactId>
<version>1.7.30</version>
</dependency>
在项目的src/main/resources目录下，新建一个文件，命名为“log4j.properties”，在文件中填入
log4j.rootLogger=INFO, stdout
log4j.appender.stdout=org.apache.log4j.ConsoleAppender
log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
log4j.appender.stdout.layout.ConversionPattern=%d %p [%c] - %m%n
log4j.appender.logfile=org.apache.log4j.FileAppender
log4j.appender.logfile.File=target/spring.log
log4j.appender.logfile.layout=org.apache.log4j.PatternLayout
log4j.appender.logfile.layout.ConversionPattern=%d %p [%c] - %m%n
5）创建包名：com.fuhong.hdfs
6）创建HdfsClient类
1.创建目录
public class HdfsClient {
private FileSystem fs;
@Test
public void testMkdirs() throws IOException, URISyntaxException, InterruptedException {
// 2 创建目录
fs.mkdirs(new Path("/xiyou/huaguoshan/"));
// 3 关闭资源
close();
}
@After
private void close() throws IOException {
fs.close();
}
@Before
private FileSystem init() throws IOException, InterruptedException, URISyntaxException {
// 1 获取文件系统
Configuration configuration = new Configuration();
fs = FileSystem.get(new URI("hdfs://linux201:8020"), configuration, "fuhong");
return fs;
}
}
2.文件上传
@Test
public void testPut() throws IOException {
// 2 执行下载操作
// boolean delSrc 指是否将原文件删除
// boolean overwrite 覆盖
// Path src 本地文件
// Path dst hdfs文件
fs.copyFromLocalFile(false, false, new Path("D:\\projecs_doc\\test_doc\\sunwukong.txt"), new Path("/xiyou/huaguoshan/sunwukong.txt"));
}
参数优先级
参数优先级排序：（1）客户端代码中设置的值 >（2）ClassPath下的用户自定义配置文件 >（3）然后是服务器的自定义配置（xxx-site.xml） >（4）服务器的默认配置（xxx-default.xml）
xml文件配置副本数
<?xml version="1.0" encoding="UTF-8"?>
<?xml-stylesheet type="text/xsl" href="configuration.xsl"?>
<configuration>
<property>
<name>dfs.replication</name>
<value>1</value>
</property>
</configuration>
代码修改配置：
@Before
public void init() throws IOException, InterruptedException, URISyntaxException {
// 1 获取文件系统
Configuration configuration = new Configuration();
configuration.set("dfs.replication","2");
fs = FileSystem.get(new URI("hdfs://linux201:8020"), configuration, "fuhong");
}
3.下载文件到本地
@Test
public void testCopyToLocalFile() throws IOException {
// 2 执行下载操作
// boolean delSrc 指是否将原文件删除
// Path src 指要下载的文件路径
// Path dst 指将文件下载到的路径
// boolean useRawLocalFileSystem 是否开启文件校验
fs.copyToLocalFile(false, new Path("/xiyou/huaguoshan/sunwukong.txt")
, new Path("D:\\projecs_doc\\test_doc\\sunwukong2.txt"), true);
}
4.删除文件
@Test
public void testDel() throws IOException {
// 2 执行删除
fs.delete(new Path("/xiyou"), true);
}
5.文件移动和更名
@Test
public void testReName() throws IOException {
// 2 修改文件名称
fs.rename(new Path("/xiyou/huaguoshan/sunwukong2.txt"), new Path("/xiyou/huaguoshan/meihouwang.txt"));
}
6.获取文件详细信息
@Test
public void testListFiles() throws IOException {
// 2 修改文件名称
RemoteIterator<LocatedFileStatus> listFiles = fs.listFiles(new Path("/"), true);
while (listFiles.hasNext()) {
LocatedFileStatus fileStatus = listFiles.next();
System.out.println("========" + fileStatus.getPath() + "=========");
System.out.println(fileStatus.getPermission());
System.out.println(fileStatus.getOwner());
System.out.println(fileStatus.getGroup());
System.out.println(fileStatus.getLen());
System.out.println(fileStatus.getModificationTime());
System.out.println(fileStatus.getReplication());
System.out.println(fileStatus.getBlockSize());
System.out.println(fileStatus.getPath().getName());
// 获取块信息
BlockLocation[] blockLocations = fileStatus.getBlockLocations();
System.out.println(Arrays.toString(blockLocations));
}
}
7.HDFS文件文件夹判断
@Test
public void testListStatus() throws IOException {
// 2 判断是文件还是文件夹
FileStatus[] listStatus = fs.listStatus(new Path("/"));
for (FileStatus fileStatus : listStatus) {
// 如果是文件
if (fileStatus.isFile()) {
System.out.println("f:" + fileStatus.getPath().getName());
} else {
System.out.println("d:" + fileStatus.getPath().getName());
}
}
}
7.HDFS的读写流程
重点
1 HDFS写数据流程
1.1剖析文件写入
（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步）。
2 机架感知（副本存储节点选择）
1）机架感知说明
（1）官方说明
http://hadoop.apache.org/docs/r3.1.3/hadoop-project-dist/hadoop-hdfs/HdfsDesign.html#Data_Replication
For the common case, when the replication factor is three,
HDFS’s placement policy is to put one replica on the local machine if the writer is on a datanode, otherwise on a random datanode, another replica on a node in a different (remote) rack, and the last on a different node in the same remote rack.
This policy cuts the inter-rack write traffic which generally improves write performance. The chance of rack failure is far less than that of node failure; this policy does not impact data reliability and availability guarantees. However, it does reduce the aggregate network bandwidth used when reading data since a block is placed in only two unique racks rather than three. With this policy, the replicas of a file do not evenly distribute across the racks. One third of replicas are on one node, two thirds of replicas are on one rack, and the other third are evenly distributed across the remaining racks. This policy improves write performance without compromising data reliability or read performance.
（2）源码说明
Crtl + n 查找BlockPlacementPolicyDefault，在该类中查找chooseTargetInOrder方法。
2）Hadoop3.1.3副本节点选择
3.HDFS读数据流程
（1）客户端通过DistributedFileSystem向NameNode请求下载文件，NameNode通过查询元数据，找到文件块所在的DataNode地址。
（2）挑选一台DataNode（就近原则，然后随机）服务器，请求读取数据。
（3）DataNode开始传输数据给客户端（从磁盘里面读取数据输入流，以Packet为单位来做校验）。
（4）客户端以Packet为单位接收，先在本地缓存，然后写入目标文件。
8.NameNode和SecondaryNameNode
1 NN和2NN工作机制
（面试重点）
思考：NameNode中的元数据是存储在哪里的？
首先，我们做个假设，如果存储在NameNode节点的磁盘中，因为经常需要进行随机访问，还有响应客户请求，必然是效率过低。因此，元数据需要存放在内存中。但如果只存在内存中，一旦断电，元数据丢失，整个集群就无法工作了。因此产生在磁盘中备份元数据的FsImage。
这样又会带来新的问题，当在内存中的元数据更新时，如果同时更新FsImage，就会导致效率过低，但如果不更新，就会发生一致性问题，一旦NameNode节点断电，就会产生数据丢失。因此，引入Edits文件（只进行追加操作，效率很高）。每当元数据有更新或者添加元数据时，修改内存中的元数据并追加到Edits中。这样，一旦NameNode节点断电，可以通过FsImage和Edits的合并，合成元数据。
但是，如果长时间添加数据到Edits中，会导致该文件数据过大，效率降低，而且一旦断电，恢复元数据需要的时间过长。因此，需要定期进行FsImage和Edits的合并，如果这个操作由NameNode节点完成，又会效率过低。因此，引入一个新的节点SecondaryNamenode，专门用于FsImage和Edits的合并。
1）第一阶段：NameNode启动
（1）第一次启动NameNode格式化后，创建Fsimage和Edits文件。如果不是第一次启动，直接加载编辑日志和镜像文件到内存。
（2）客户端对元数据进行增删改的请求。
（3）NameNode记录操作日志，更新滚动日志。
（4）NameNode在内存中对元数据进行增删改。
2）第二阶段：Secondary NameNode工作
（1）Secondary NameNode询问NameNode是否需要CheckPoint。直接带回NameNode是否检查结果。
（2）Secondary NameNode请求执行CheckPoint。
（3）NameNode滚动正在写的Edits日志。
（4）将滚动前的编辑日志和镜像文件拷贝到Secondary NameNode。
（5）Secondary NameNode加载编辑日志和镜像文件到内存，并合并。
（6）生成新的镜像文件fsimage.chkpoint。
（7）拷贝fsimage.chkpoint到NameNode。
（8）NameNode将fsimage.chkpoint重新命名成fsimage。
nn路径：linux201
2nn：linux203同样包含
2 Fsimage和Edits解析
NameNode被格式化之后，将在/opt/module/hadoop-3.1.3/data/tmp/dfs/name/current目录中产生如下文件
fsimage_0o00000000000000000
fsimage_oo00000000000000000.md5
seen_txid
VERSTON
(1) Fsimage文件: HDFS文件系统元数据的一个永久性的检查点，其中包含HDFS文件系统的所有目录和文件inode的序列化信息。
(2)Edits文件:存放HDFS文件系统的所有更新操作的路径，文件系统客户端执行的所有写操作首先会被记录到Edits文件中。
(3) seen_txid文件保存的是一个数字，就是最后一个edits_的数字
(4)每次NameNode启动的时候都会将Fsimage文件读入内存，加载Edits里面的更新操作，保证内存中的元数据信息是最新的、同步的，可以看成NameNode启动的时候就将Fsimage和Edits文件进行了合并。
1）oiv查看Fsimage文件
（1）查看oiv和oev命令
[fuhong@linux201 current]$ hdfs
oiv apply the offline fsimage viewer to an fsimage
oev apply the offline edits viewer to an edits file
（2）基本语法
hdfs oiv -p 文件类型 -i镜像文件 -o 转换后文件输出路径
（3）案例实操
[fuhong@linux201 current]$ pwd
/opt/module/hadoop-3.1.3/data/dfs/name/current
[fuhong@linux201 current]$ hdfs oiv -p XML -i fsimage_0000000000000000309 -o /opt/module/hadoop-3.1.3/fsimage.xml
[fuhong@linux201 current]$ cat /opt/module/hadoop-3.1.3/fsimage.xml
#下载文件
[fuhong@linux201 hadoop-3.1.3]$ sz fsimage.xml
将显示的xml文件内容拷贝到Idea中创建的xml文件中，并格式化。部分显示结果如下。
<inode>
<id>16385</id>
<type>DIRECTORY</type>
<name/>
<mtime>1642394631741</mtime>
<permission>fuhong:supergroup:0755</permission>
<nsquota>9223372036854775807</nsquota>
<dsquota>-1</dsquota>
</inode>
<inode>
<id>16386</id>
<type>DIRECTORY</type>
<name>input</name>
<mtime>1641872343120</mtime>
<permission>fuhong:supergroup:0755</permission>
<nsquota>-1</nsquota>
<dsquota>-1</dsquota>
</inode>
<inode>
<id>16387</id>
<type>FILE</type>
<name>word.txt</name>
<replication>3</replication>
<mtime>1641872343107</mtime>
<atime>1641876021061</atime>
<preferredBlockSize>134217728</preferredBlockSize>
<permission>fuhong:supergroup:0644</permission>
<blocks>
<block>
<id>1073741825</id>
<genstamp>1001</genstamp>
<numBytes>35</numBytes>
</block>
</blocks>
<storagePolicyId>0</storagePolicyId>
</inode>
思考：可以看出，Fsimage中没有记录块所对应DataNode，为什么？
在集群启动后，要求DataNode上报数据块信息，并间隔一段时间后再次上报。
2）oev查看Edits文件
（1）基本语法
hdfs oev -p 文件类型 -i编辑日志 -o 转换后文件输出路径
（2）案例实操
[fuhong@linux201 current]$ hdfs oev -p XML -i edits_inprogress_0000000000000000314 -o /opt/module/hadoop-3.1.3/edits.xml
[fuhong@linux201 current]$ cat /opt/module/hadoop-3.1.3/edits.xml
将显示的xml文件内容拷贝到Idea中创建的xml文件中，并格式化。显示结果如下。
<?xml version="1.0" encoding="UTF-8"?>
<EDITS>
<EDITS_VERSION>-63</EDITS_VERSION>
<RECORD>
<OPCODE>OP_START_LOG_SEGMENT</OPCODE>
<DATA>
<TXID>129</TXID>
</DATA>
</RECORD>
<RECORD>
<OPCODE>OP_ADD</OPCODE>
<DATA>
<TXID>130</TXID>
<LENGTH>0</LENGTH>
<INODEID>16407</INODEID>
<PATH>/hello7.txt</PATH>
<REPLICATION>2</REPLICATION>
<MTIME>1512943607866</MTIME>
<ATIME>1512943607866</ATIME>
<BLOCKSIZE>134217728</BLOCKSIZE>
<CLIENT_NAME>DFSClient_NONMAPREDUCE_-1544295051_1</CLIENT_NAME>
<CLIENT_MACHINE>192.168.10.102</CLIENT_MACHINE>
<OVERWRITE>true</OVERWRITE>
<PERMISSION_STATUS>
<USERNAME>fuhong</USERNAME>
<GROUPNAME>supergroup</GROUPNAME>
<MODE>420</MODE>
</PERMISSION_STATUS>
<RPC_CLIENTID>908eafd4-9aec-4288-96f1-e8011d181561</RPC_CLIENTID>
<RPC_CALLID>0</RPC_CALLID>
</DATA>
</RECORD>
<RECORD>
<OPCODE>OP_ALLOCATE_BLOCK_ID</OPCODE>
<DATA>
<TXID>131</TXID>
<BLOCK_ID>1073741839</BLOCK_ID>
</DATA>
</RECORD>
<RECORD>
<OPCODE>OP_SET_GENSTAMP_V2</OPCODE>
<DATA>
<TXID>132</TXID>
<GENSTAMPV2>1016</GENSTAMPV2>
</DATA>
</RECORD>
<RECORD>
<OPCODE>OP_ADD_BLOCK</OPCODE>
<DATA>
<TXID>133</TXID>
<PATH>/hello7.txt</PATH>
<BLOCK>
<BLOCK_ID>1073741839</BLOCK_ID>
<NUM_BYTES>0</NUM_BYTES>
<GENSTAMP>1016</GENSTAMP>
</BLOCK>
<RPC_CLIENTID></RPC_CLIENTID>
<RPC_CALLID>-2</RPC_CALLID>
</DATA>
</RECORD>
<RECORD>
<OPCODE>OP_CLOSE</OPCODE>
<DATA>
<TXID>134</TXID>
<LENGTH>0</LENGTH>
<INODEID>0</INODEID>
<PATH>/hello7.txt</PATH>
<REPLICATION>2</REPLICATION>
<MTIME>1512943608761</MTIME>
<ATIME>1512943607866</ATIME>
<BLOCKSIZE>134217728</BLOCKSIZE>
<CLIENT_NAME></CLIENT_NAME>
<CLIENT_MACHINE></CLIENT_MACHINE>
<OVERWRITE>false</OVERWRITE>
<BLOCK>
<BLOCK_ID>1073741839</BLOCK_ID>
<NUM_BYTES>25</NUM_BYTES>
<GENSTAMP>1016</GENSTAMP>
</BLOCK>
<PERMISSION_STATUS>
<USERNAME>fuhong</USERNAME>
<GROUPNAME>supergroup</GROUPNAME>
<MODE>420</MODE>
</PERMISSION_STATUS>
</DATA>
</RECORD>
</EDITS >
思考：NameNode如何确定下次开机启动的时候合并哪些Edits？
3 CheckPoint时间设置
1）通常情况下，SecondaryNameNode每隔一小时执行一次。
[hdfs-default.xml]
<property>
<name>dfs.namenode.checkpoint.period</name>
<value>3600s</value>
</property>
2）一分钟检查一次操作次数，当操作次数达到1百万时，SecondaryNameNode执行一次。
<property>
<name>dfs.namenode.checkpoint.txns</name>
<value>1000000</value>
<description>操作动作次数</description>
</property>
<property>
<name>dfs.namenode.checkpoint.check.period</name>
<value>60s</value>
<description> 1分钟检查一次操作次数</description>
</property>
9 DataNode
1 DataNode工作机制
（1）一个数据块在DataNode上以文件形式存储在磁盘上，包括两个文件，一个是数据本身，一个是元数据包括数据块的长度，块数据的校验和，以及时间戳。
（2）DataNode启动后向NameNode注册，通过后，周期性（6小时）的向NameNode上报所有的块信息。
DN向NN汇报当前解读信息的时间间隔，默认6小时；
<property>
<name>dfs.blockreport.intervalMsec</name>
<value>21600000</value>
<description>Determines block reporting interval in milliseconds.</description>
</property>
DN扫描自己节点块信息列表的时间，默认6小时
<property>
<name>dfs.datanode.directoryscan.interval</name>
<value>21600s</value>
<description>Interval in seconds for Datanode to scan data directories and reconcile the difference between blocks in memory and on the disk.
Support multiple time unit suffix(case insensitive), as described
in dfs.heartbeat.interval.
</description>
</property>
（3）心跳是每3秒一次，心跳返回结果带有NameNode给该DataNode的命令如复制块数据到另一台机器，或删除某个数据块。如果超过10分钟没有收到某个DataNode的心跳，则认为该节点不可用。
（4）集群运行中可以安全加入和退出一些机器。
2 数据完整性（crc32校验）
思考：如果电脑磁盘里面存储的数据是控制高铁信号灯的红灯信号（1）和绿灯信号（0），但是存储该数据的磁盘坏了，一直显示是绿灯，是否很危险？同理DataNode节点上的数据损坏了，却没有发现，是否也很危险，那么如何解决呢？
如下是DataNode节点保证数据完整性的方法。
（1）当DataNode读取Block的时候，它会计算CheckSum。
（2）如果计算后的CheckSum，与Block创建时值不一样，说明Block已经损坏。
（3）Client读取其他DataNode上的Block。
（4）常见的校验算法crc（32），md5（128），sha1（160）
（5）DataNode在其文件创建后周期验证CheckSum。
3 掉线时限参数设置
需要注意的是hdfs-site.xml 配置文件中的heartbeat.recheck.interval的单位为毫秒，dfs.heartbeat.interval的单位为秒。
<property>
<name>dfs.namenode.heartbeat.recheck-interval</name>
<value>300000</value>
</property>
<property>
<name>dfs.heartbeat.interval</name>
<value>3</value>
</property>
三、MapReduce
1 MapReduce概述
1.1 MapReduce定义
MapReduce是一个分布式运算程序的编程框架，是用户开发“基于Hadoop的数据分析应用”的核心框架。
MapReduce核心功能是将用户编写的业务逻辑代码和自带默认组件整合成一个完整的分布式运算程序，并发运行在一个Hadoop集群上。
1.2 MapReduce优缺点
1.2.1 优点
1）MapReduce易于编程
它简单的实现一些接口，就可以完成一个分布式程序，这个分布式程序可以分布到大量廉价的PC机器上运行。也就是说你写一个分布式程序，跟写一个简单的串行程序是一模一样的。就是因为这个特点使得MapReduce编程变得非常流行。
2）良好的扩展性
当你的计算资源不能得到满足的时候，你可以通过简单的增加机器来扩展它的计算能力。
3）高容错性
MapReduce设计的初衷就是使程序能够部署在廉价的PC机器上，这就要求它具有很高的容错性。比如其中一台机器挂了，它可以把上面的计算任务转移到另外一个节点上运行，不至于这个任务运行失败，而且这个过程不需要人工参与，而完全是由Hadoop内部完成的。
4）适合PB级以上海量数据的离线处理
可以实现上千台服务器集群并发工作，提供数据处理能力。
1.2.2 缺点
1）不擅长实时计算
MapReduce无法像MySQL一样，在毫秒或者秒级内返回结果。
2）不擅长流式计算
流式计算的输入数据是动态的，而MapReduce的输入数据集是静态的，不能动态变化。这是因为MapReduce自身的设计特点决定了数据源必须是静态的。
3）不擅长DAG（有向无环图）计算（计算结果基于磁盘，spark计算结果基于内存）
多个应用程序存在依赖关系，后一个应用程序的输入为前一个的输出。在这种情况下，MapReduce并不是不能做，而是使用后，每个MapReduce作业的输出结果都会写入到磁盘，会造成大量的磁盘IO，导致性能非常的低下。
1.3 MapReduce核心思想
（1）分布式的运算程序往往需要分成至少2个阶段。
（2）第一个阶段的MapTask并发实例，完全并行运行，互不相干。
（3）第二个阶段的ReduceTask并发实例互不相干，但是他们的数据依赖于上一个阶段的所有MapTask并发实例的输出。
（4）MapReduce编程模型只能包含一个Map阶段和一个Reduce阶段，如果用户的业务逻辑非常复杂，那就只能多个MapReduce程序，串行运行。
总结：分析WordCount数据流走向深入理解MapReduce核心思想。
1.4 MapReduce进程
一个完整的MapReduce程序在分布式运行时有三类实例进程：
（1）MrAppMaster：负责整个程序的过程调度及状态协调。
（2）MapTask：负责Map阶段的整个数据处理流程。
（3）ReduceTask：负责Reduce阶段的整个数据处理流程。
1.5 官方WordCount源码
采用反编译工具反编译源码，发现WordCount案例有Map类、Reduce类和驱动类。且数据的类型是Hadoop自身封装的序列化类型。
package org.apache.hadoop.examples;
import java.io.IOException;
import java.io.PrintStream;
import java.util.StringTokenizer;
import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.fs.Path;
import org.apache.hadoop.io.IntWritable;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapreduce.Job;
import org.apache.hadoop.mapreduce.Mapper;
import org.apache.hadoop.mapreduce.Mapper.Context;
import org.apache.hadoop.mapreduce.Reducer;
import org.apache.hadoop.mapreduce.Reducer.Context;
import org.apache.hadoop.mapreduce.lib.input.FileInputFormat;
import org.apache.hadoop.mapreduce.lib.output.FileOutputFormat;
import org.apache.hadoop.util.GenericOptionsParser;
public class WordCount
{
public static void main(String[] args)
throws Exception
{
Configuration conf = new Configuration();
String[] otherArgs = new GenericOptionsParser(conf, args).getRemainingArgs();
if (otherArgs.length < 2) {
System.err.println("Usage: wordcount <in> [<in>...] <out>");
System.exit(2);
}
Job job = Job.getInstance(conf, "word count");
job.setJarByClass(WordCount.class);
job.setMapperClass(TokenizerMapper.class);
job.setCombinerClass(IntSumReducer.class);
job.setReducerClass(IntSumReducer.class);
job.setOutputKeyClass(Text.class);
job.setOutputValueClass(IntWritable.class);
for (int i = 0; i < otherArgs.length - 1; i++) {
FileInputFormat.addInputPath(job, new Path(otherArgs[i]));
}
FileOutputFormat.setOutputPath(job, new Path(otherArgs[(otherArgs.length - 1)]));
System.exit(job.waitForCompletion(true) ? 0 : 1);
}
public static class IntSumReducer extends Reducer<Text, IntWritable, Text, IntWritable>
{
private IntWritable result = new IntWritable();
public void reduce(Text key, Iterable<IntWritable> values, Reducer<Text, IntWritable, Text, IntWritable>.Context context)
throws IOException, InterruptedException
{
int sum = 0;
for (IntWritable val : values) {
sum += val.get();
}
this.result.set(sum);
context.write(key, this.result);
}
}
/**
object：偏移量（这一行首字母的偏移量）
Text: 内容（这一行的内容）
**/
public static class TokenizerMapper extends Mapper<Object, Text, Text, IntWritable>
{
private static final IntWritable one = new IntWritable(1);
private Text word = new Text();
public void map(Object key, Text value, Mapper<Object, Text, Text, IntWritable>.Context context) throws IOException, InterruptedException
{
StringTokenizer itr = new StringTokenizer(value.toString());
while (itr.hasMoreTokens()) {
this.word.set(itr.nextToken());
context.write(this.word, one);
}
}
}
}
1.6 常用数据序列化类型
| Java类型 | Hadoop Writable类型 |
|---|---|
| Boolean | BooleanWritable |
| Byte | ByteWritable |
| Int | IntWritable |
| Float | FloatWritable |
| Long | LongWritable |
| Double | DoubleWritable |
| String | Text |
| Map | MapWritable |
| Array | ArrayWritable |
| Null | NullWritable |
1.7 MapReduce编程规范
用户编写的程序分成三个部分：Mapper、Reducer和Driver。
-
Mapper阶段
(1）用户自定义的Mapper要继承自己的父类
(2)Mapper的输入数据是KV对的形式(KV的类型可自定义)
(3 ) Mapper中的业务逻辑写在map()方法中
(4) Mapper的输出数据是KV的形式(KV的类型可自定义)也是KV (a,1);(a,1);(b,1)形式
(5) map(方法(MapTask进程）对每一个<K,V>调用一次 -
Reducer阶段
(1）用户自定义的Reducer要继承自己的父类
(2) Reducer的输入数据类型对应Mapper的输出数据类型，
(3)Reducer的业务逻辑写在reduce(方法中
(4) ReduceTask进程对每一组相同k的k,v>组调用一次reduce()方法
- Driver阶段
相当于YARN集群的客户端，用于提交我们整个程序到YARN集群，提交的是封装了MapReduce程序相关运行参数的job对象
1.8 WordCount案例实操
1.8.1 本地测试
1）需求
在给定的文本文件中统计输出每一个单词出现的总次数
（1）输入数据（txt文件）
fuhong fuhong
ss ss
cls cls
jiao
banzhang
xue
hadoop
（2）期望输出数据
fuhong 2
banzhang 1
cls 2
hadoop 1
jiao 1
ss 2
xue 1
2）需求分析
按照MapReduce编程规范，分别编写Mapper，Reducer，Driver。
3）环境准备
（1）创建maven工程
（2）在pom.xml文件中添加如下依赖
<dependency>
<groupId>org.apache.hadoop</groupId>
<artifactId>hadoop-client</artifactId>
<version>3.1.3</version>
</dependency>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
</dependency>
<dependency>
<groupId>org.slf4j</groupId>
<artifactId>slf4j-log4j12</artifactId>
</dependency>
<build>
<plugins>
<plugin>
<artifactId>maven-compiler-plugin</artifactId>
<version>3.8.1</version>
<configuration>
<source>1.8</source>
<target>1.8</target>
</configuration>
</plugin>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-assembly-plugin</artifactId>
<version>3.3.0</version>
<configuration>
<descriptorRefs>
<descriptorRef>jar-with-dependencies</descriptorRef>
</descriptorRefs>
</configuration>
<executions>
<execution>
<id>make-assembly</id>
<phase>package</phase>
<goals>
<goal>single</goal>
</goals>
</execution>
</executions>
</plugin>
</plugins>
</build>
（3）在项目的src/main/resources目录下，新建一个文件，命名为“log4j.properties”，在文件中填入。
log4j.rootLogger=INFO, stdout
log4j.appender.stdout=org.apache.log4j.ConsoleAppender
log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
log4j.appender.stdout.layout.ConversionPattern=%d %p [%c] - %m%n
log4j.appender.logfile=org.apache.log4j.FileAppender
log4j.appender.logfile.File=target/spring.log
log4j.appender.logfile.layout=org.apache.log4j.PatternLayout
log4j.appender.logfile.layout.ConversionPattern=%d %p [%c] - %m%n
4）编写程序
（1）编写Mapper类
import org.apache.hadoop.io.IntWritable;
import org.apache.hadoop.io.LongWritable;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapreduce.Mapper;
import java.io.IOException;
/**
* @author fuhong
* KEYIN：map阶段输入的key类型 :LongWritable
* VALUEIN：map阶段输入的value类型 Text
* KEYOUT：map阶段输出的key类型 ：Text
* VALUEOUT：map阶段输出的value类型： IntWritable,LongWritable
* @description WordCountMapper
* @date 2022/1/18 16:16
*/
public class WordCountMapper extends Mapper<LongWritable, Text, Text, IntWritable> {
private final Text outKey = new Text();
private final IntWritable outValue = new IntWritable(1);
@Override
protected void map(LongWritable key, Text value, Mapper<LongWritable, Text, Text
, IntWritable>.Context context) throws IOException, InterruptedException {
// 1 获取一行
String line = value.toString();
// 2 切割
String[] words = line.split(" ");
// 3 输出
for (String word : words) {
outKey.set(word);
context.write(outKey, outValue);
}
}
}
（2）编写reducer类
import org.apache.hadoop.io.IntWritable;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapreduce.Reducer;
import java.io.IOException;
/**
* @author fuhong
* KEYIN：Reduce阶段输入的key类型 :Text
* VALUEIN：Reduce阶段输入的value类型 IntWritable
* KEYOUT：Reduce阶段输出的key类型 ：Text
* VALUEOUT：Reduce阶段输出的value类型： IntWritable
* @description WordCountReducer
* @date 2022/1/18 16:53
*/
public class WordCountReducer extends Reducer<Text, IntWritable, Text, IntWritable> {
private final IntWritable value = new IntWritable();
/**
* 每一个key 执行一次本方法 key, (1,1)
*
* @param key key
* @param values (1.1)
* @param context 写出
* @throws IOException 异常
* @throws InterruptedException 异常
*/
@Override
protected void reduce(Text key, Iterable<IntWritable> values, Reducer<Text, IntWritable, Text
, IntWritable>.Context context) throws IOException, InterruptedException {
int sum = 0;
//fuhong, (1,1)
//ss, (1,1)
for (IntWritable value : values) {
sum += value.get();
}
value.set(sum);
//写出
context.write(key, value);
}
}
(3) 编写Reducer类
import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.fs.Path;
import org.apache.hadoop.io.IntWritable;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapreduce.Job;
import org.apache.hadoop.mapreduce.lib.input.FileInputFormat;
import org.apache.hadoop.mapreduce.lib.output.FileOutputFormat;
import java.io.IOException;
/**
* @author fuhong
* @description WordCountDriver
* @date 2022/1/18 16:56
*/
public class WordCountDriver {
public static void main(String[] args) throws IOException, InterruptedException, ClassNotFoundException {
//1.获取job
Configuration conf = new Configuration();
Job job = Job.getInstance(conf);
//2.设置jar包路径
job.setJarByClass(WordCountDriver.class);
//3.管mapper和reducer
job.setMapperClass(WordCountMapper.class);
job.setReducerClass(WordCountReducer.class);
//4.设置map输出的kv类型
job.setMapOutputKeyClass(Text.class);
job.setMapOutputValueClass(IntWritable.class);
//5.输出最终的kv类型
job.setOutputKeyClass(Text.class);
job.setOutputValueClass(IntWritable.class);
//6.设置输入路径和输出路径
FileInputFormat.setInputPaths(job, new Path("D:\\learn\\input"));
FileOutputFormat.setOutputPath(job, new Path("D:\\learn\\output"));
//7.提交job
//获取job信息
boolean result = job.waitForCompletion(true);
System.exit(result ? 0 : 1);
}
}
1.8提交集群测试
1.程序打jar包(复制包，修改路径)
2.修改不带依赖的jar包名称为wc.jar，并拷贝该jar包到Hadoop集群的/opt/module/hadoop-3.1.3路径。
3.启动集群
[fuhong@linux201 hadoop-3.1.3]$ myhadoop.sh start
[fuhong@linux201 hadoop-3.1.3]$ jpsall
4.执行程序
[fuhong@linux201 hadoop-3.1.3]$ hadoop jar wc.jar com/fuhong/hdfsclientdemo/mapreduce/wordcount2/WordCountDriver /input /output
2.Hadoop序列化
2.1 序列化概述
1）什么是序列化
序列化就是把内存中的对象，转换成字节序列（或其他数据传输协议）以便于存储到磁盘（持久化）和网络传输。
反序列化就是将收到字节序列（或其他数据传输协议）或者是磁盘的持久化数据，转换成内存中的对象。
2）为什么要序列化
一般来说，“活的”对象只生存在内存里，关机断电就没有了。而且“活的”对象只能由本地的进程使用，不能被发送到网络上的另外一台计算机。 然而序列化可以存储“活的”对象，可以将“活的”对象发送到远程计算机。
3）为什么不用Java的序列化
Java的序列化是一个重量级序列化框架（Serializable），一个对象被序列化后，会附带很多额外的信息（各种校验信息，Header，继承体系等），不便于在网络中高效传输。所以，Hadoop自己开发了一套序列化机制（Writable）。
4）Hadoop序列化特点：
（1）紧凑 ：高效使用存储空间。
（2）快速：读写数据的额外开销小。
（3）互操作：支持多语言的交互
2.2 自定义bean对象实现序列化接口（Writable）
在企业开发中往往常用的基本序列化类型不能满足所有需求，比如在Hadoop框架内部传递一个bean对象，那么该对象就需要实现序列化接口。
具体实现bean对象序列化步骤如下7步。
（1）必须实现Writable接口
（2）反序列化时，需要反射调用空参构造函数，所以必须有空参构造
public FlowBean() {
super();
}
（3）重写序列化方法
@Override
public void write(DataOutput out) throws IOException {
out.writeLong(upFlow);
out.writeLong(downFlow);
out.writeLong(sumFlow);
}
（4）重写反序列化方法
@Override
public void readFields(DataInput in) throws IOException {
upFlow = in.readLong();
downFlow = in.readLong();
sumFlow = in.readLong();
}
（5）注意反序列化的顺序和序列化的顺序完全一致
（6）要想把结果显示在文件中，需要重写toString()，可用"\t"分开，方便后续用。
（7）如果需要将自定义的bean放在key中传输，则还需要实现Comparable接口，因为MapReduce框中的Shuffle过程要求对key必须能排序。详见后面排序案例。
@Override
public int compareTo(FlowBean o) {
// 倒序排列，从大到小
return this.sumFlow > o.getSumFlow() ? -1 : 1;
}
2.3 序列化案例实操
1）需求
统计每一个手机号耗费的总上行流量、总下行流量、总流量
（1）输入数据
phone_data.txt文件（使用\t分割信息）
1 13736230513 192.196.100.1 www.fuhong.com 2481 24681 200
2 13846544121 192.196.100.2 264 0 200
3 13956435636 192.196.100.3 132 1512 200
4 13966251146 192.168.100.1 240 0 404
5 18271575951 192.168.100.2 www.fuhong.com 1527 2106 200
6 84188413 192.168.100.3 www.fuhong.com 4116 1432 200
7 13590439668 192.168.100.4 1116 954 200
8 15910133277 192.168.100.5 www.hao123.com 3156 2936 200
9 13729199489 192.168.100.6 240 0 200
10 13630577991 192.168.100.7 www.shouhu.com 6960 690 200
11 15043685818 192.168.100.8 www.baidu.com 3659 3538 200
12 15959002129 192.168.100.9 www.fuhong.com 1938 180 500
13 13560439638 192.168.100.10 918 4938 200
14 13470253144 192.168.100.11 180 180 200
15 13682846555 192.168.100.12 www.qq.com 1938 2910 200
16 13992314666 192.168.100.13 www.gaga.com 3008 3720 200
17 13509468723 192.168.100.14 www.qinghua.com 7335 110349 404
18 18390173782 192.168.100.15 www.sogou.com 9531 2412 200
19 13975057813 192.168.100.16 www.baidu.com 11058 48243 200
20 13768778790 192.168.100.17 120 120 200
21 13568436656 192.168.100.18 www.alibaba.com 2481 24681 200
22 13568436656 192.168.100.19 1116 954 200
（2）输入数据格式
7 13560436666 120.196.100.99 1116 954 200
id 手机号码 网络ip 上行流量 下行流量 网络状态码
（3）期望输出数据格式
13560436666 1116 954 2070
手机号码 上行流量 下行流量 总流量
2）需求分析
3）编写MapReduce程序
（1）编写流量统计的Bean对象
import org.apache.hadoop.io.Writable;
import java.io.DataInput;
import java.io.DataOutput;
import java.io.IOException;
/**
* @author eccom
* 1.必须实现Writable接口
* 2.重新序列化反序列化方法
* 3.重写空参构造
* 4.toString方法
* @description 序列化
* @date 2022/5/24 15:47
*/
public class FlowBean implements Writable {
/**
* 上行流量
*/
private long upFlow;
/**
* 下行流量
*/
private long downFlow;
/**
* 总流量
*/
private long sumFlow;
/**
* 空参构造
*/
public FlowBean() {
}
@Override
public void write(DataOutput out) throws IOException {
out.writeLong(upFlow);
out.writeLong(downFlow);
out.writeLong(sumFlow);
}
@Override
public void readFields(DataInput in) throws IOException {
this.upFlow = in.readLong();
this.downFlow = in.readLong();
this.sumFlow = in.readLong();
}
@Override
public String toString() {
return upFlow + "\t" + downFlow + "\t" + sumFlow;
}
public long getUpFlow() {
return upFlow;
}
public void setUpFlow(long upFlow) {
this.upFlow = upFlow;
}
public long getDownFlow() {
return downFlow;
}
public void setDownFlow(long downFlow) {
this.downFlow = downFlow;
}
public long getSumFlow() {
return sumFlow;
}
public void setSumFlow(long sumFlow) {
this.sumFlow = sumFlow;
}
public void setSumFlow() {
this.sumFlow = this.downFlow + this.upFlow;
}
}
（2）编写Mapper类
import org.apache.hadoop.io.LongWritable;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapreduce.Mapper;
import java.io.IOException;
/**
* @author eccom
* @description map
* @date 2022/5/24 15:59
*/
public class FlowMapper extends Mapper<LongWritable, Text, Text, FlowBean> {
private final Text outK = new Text();
private final FlowBean outV = new FlowBean();
@Override
protected void map(LongWritable key, Text value, Mapper<LongWritable
, Text, Text, FlowBean>.Context context) throws IOException, InterruptedException {
//获取一行 1 13736230513 192.196.100.1 www.fuhong.com 2481 24681 200
String line = value.toString();
//切割 \t
String[] split = line.split("\t");
//抓取想要的数据 手机号 上行流量 下行流量
String phone = split[1];
String up = split[split.length - 3];
String down = split[split.length - 2];
//封装
outK.set(phone);
outV.setUpFlow(Long.parseLong(up));
outV.setDownFlow(Long.parseLong(down));
outV.setSumFlow();
//写出
context.write(outK, outV);
}
}
（3）编写Reducer类
import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapreduce.Reducer;
import java.io.IOException;
/**
* @author eccom
* @description Reducer
* @date 2022/5/24 16:14
*/
public class FlowReducer extends Reducer<Text, FlowBean, Text, FlowBean> {
private final FlowBean outV = new FlowBean();
@Override
protected void reduce(Text key, Iterable<FlowBean> values, Reducer<Text, FlowBean, Text, FlowBean>.Context context) throws IOException, InterruptedException {
//1.遍历集合累加值
long totalUp = 0;
long totalDown = 0;
for (FlowBean value : values) {
totalUp += value.getUpFlow();
totalDown += value.getDownFlow();
}
//2.封装对象
outV.setUpFlow(totalUp);
outV.setDownFlow(totalDown);
outV.setSumFlow();
//写出
context.write(key, outV);
}
}
（4）编写Driver驱动类
import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.fs.Path;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapreduce.Job;
import org.apache.hadoop.mapreduce.lib.input.FileInputFormat;
import org.apache.hadoop.mapreduce.lib.output.FileOutputFormat;
import java.io.IOException;
/**
* @author eccom
* @description driver
* @date 2022/5/24 16:24
*/
public class FlowDriver {
public static void main(String[] args) throws IOException, InterruptedException, ClassNotFoundException {
//1.获取job对象
Configuration conf = new Configuration();
Job job = Job.getInstance(conf);
//2.设置jar包
job.setJarByClass(FlowDriver.class);
//3.关联mapper reducer
job.setMapperClass(FlowMapper.class);
job.setReducerClass(FlowReducer.class);
//4.设置mapper 输出的key和value类型
job.setMapOutputKeyClass(Text.class);
job.setMapOutputValueClass(FlowBean.class);
//5.设置最终数据输出的key value类型
job.setOutputKeyClass(Text.class);
job.setOutputValueClass(FlowBean.class);
//6.设置数据的输入和输出路径
FileInputFormat.setInputPaths(job, new Path("D:\\learn\\input\\hadoop\\flow"));
FileOutputFormat.setOutputPath(job, new Path("D:\\learn\\output\\hadoop\\flow"));
//提交job
boolean result = job.waitForCompletion(true);
System.exit(result ? 0 : 1);
}
}
3 MapReduce框架原理
3.1 InputFormat数据输入
3.1.1 切片与MapTask并行度决定机制
1）问题引出
MapTask的并行度决定Map阶段的任务处理并发度，进而影响到整个Job的处理速度。
思考：1G的数据，启动8个MapTask，可以提高集群的并发处理能力。那么1K的数据，也启动8个MapTask，会提高集群性能吗？MapTask并行任务是否越多越好呢？哪些因素影响了MapTask并行度？
2）MapTask并行度决定机制
数据块：Block是HDFS物理上把数据分成一块一块。数据块是HDFS存储数据单位。
数据切片：数据切片只是在逻辑上对输入进行分片，并不会在磁盘上将其切分成片进行存储。数据切片是MapReduce程序计算输入数据的单位，一个切片会对应启动一个MapTask。
3.1.2Job提交流程源码和切片源码详解
1）Job提交流程源码详解
重点：提交三个东西：jar包、切片信息、job的XML配置文件
//1.提交job
boolean result = job.waitForCompletion(true);
//2.
submit();
//3.建立连接
connect();
//4.创建客户端
return new Cluster(getConfiguration());
//5.判断是本地运行环境还是yarn集群运行环境，遍历客户端进行判断
initialize(jobTrackAddr, conf);
//6.核心代码 提交job
return submitter.submitJobInternal(Job.this, cluster);
//7.首先校验输出路径是否设置 是否存在
checkSpecs(job);
//8.创建给集群提交数据的Stag路径
Path jobStagingArea = JobSubmissionFiles.getStagingDir(cluster, conf);
//9.获取jobid ，并创建Job路径
JobID jobId = submitClient.getNewJobID();
//10.拷贝jar包到集群
copyAndConfigureFiles(job, submitJobDir);
rUploader.uploadResources(job, jobSubmitDir);
//11.创建job路径
uploadResourcesInternal(job, submitJobDir);
mkdirs(jtFs, submitJobDir, mapredSysPerms);
//12.提交jar包 集群会提交 本地不需要提交
uploadJobJar(job, jobJar, submitJobDir, replication, statCache);
//13.计算切片，生成切片规划文件
int maps = writeSplits(job, submitJobDir);
//14.设置mapTask个数 多少个切片设置多少个
conf.setInt(MRJobConfig.NUM_MAPS, maps);
//15.运行参数生成xml文件，向Stag路径写XML配置文件 这个job按照这个配置执行
writeConf(conf, submitJobFile);
conf.writeXml(out);
//16.客户端提交job信息返回提交状态（运行状态）
status = submitClient.submitJob(
jobId, submitJobDir.toString(), job.getCredentials());
//17.监控并打印相关信息
monitorAndPrintJob();
2）FileInputFormat切片源码解析（input.getSplits(job)）
切片的个数决定了mapTask开启的个数
//1.直接从切片方法入口
int maps = writeSplits(job, submitJobDir);
//2.新api的处理方式
maps = writeNewSplits(job, jobSubmitDir);
//3. 逻辑上处理切片信息 但未实际切片,只是记录切片的元数据
List<InputSplit> splits = input.getSplits(job);
//4.获取最小的切片大小参数，可由mapreduce.input.fileinputformat.split.minsize配置
//mapred-default.xml查找，切片大小需要调大调整该参数值
long minSize = Math.max(getFormatMinSplitSize(), getMinSplitSize(job));
//5.获取最大切片大小参数mapreduce.input.fileinputformat.split.maxsize不配置则获取long最大值，切片大小需要调小调整
long maxSize = getMaxSplitSize(job);
//6.遍历每个文件 按照文件进行单独切片
//7.获取块儿大小 本地默认32M yarn默认 128M
long blockSize = file.getBlockSize();
//8.块儿大小等于切片大小
long splitSize = computeSplitSize(blockSize, minSize, maxSize);
//9.文件必须有切片大小的1.1倍 才多切一片，否则就一片<合理性设计>
//例如，本地切片大小为32M 文件为32.1M 只切一片
((double) bytesRemaining)/splitSize > SPLIT_SLOP
//10.实际切片，形成切片文件
JobSplitWriter.createSplitFiles(jobSubmitDir, conf,
jobSubmitDir.getFileSystem(conf), array);
3.1.3 FileInputFormat切片机制
3.1.4 TextInputFormat
1）FileInputFormat实现类
思考：在运行MapReduce程序时，输入的文件格式包括：基于行的日志文件、二进制格式文件、数据库表等。那么，针对不同的数据类型，MapReduce是如何读取这些数据的呢？
FileInputFormat常见的接口实现类包括：TextInputFormat（一次读取一行处理）、KeyValueTextInputFormat（用指定符号分割，kV）、NLineInputFormat(一次读取多行处理，提升效率)、CombineTextInputFormat（一次读取多个文件处理，提升效率小文件）和自定义InputFormat等。
2）TextInputFormat
TextInputFormat是默认的FileInputFormat实现类。按行读取每条记录。键是存储该行在整个文件中的起始字节偏移量， LongWritable类型。值是这行的内容，不包括任何行终止符（换行符和回车符），Text类型。
以下是一个示例，比如，一个分片包含了如下4条文本记录。
Rich learning form
Intelligent learning engine
Learning more convenient
From the real demand for more close to the enterprise
每条记录表示为以下键/值对：
(0,Rich learning form)
(20,Intelligent learning engine)
(49,Learning more convenient)
(74,From the real demand for more close to the enterprise)
3.1.5 CombineTextInputFormat切片机制
框架默认的TextInputFormat切片机制是对任务按文件规划切片，不管文件多小，都会是一个单独的切片，都会交给一个MapTask，这样如果有大量小文件，就会产生大量的MapTask，处理效率极其低下。
1）应用场景
CombineTextInputFormat用于小文件过多的场景，它可以将多个小文件从逻辑上规划到一个切片中，这样，多个小文件就可以交给一个MapTask处理。
2）虚拟存储切片最大值设置
CombineTextInputFormat.setMaxInputSplitSize(job, 4194304);// 4m
注意：虚拟存储切片最大值设置最好根据实际的小文件大小情况来设置具体的值。
3）切片机制
生成切片过程包括：虚拟存储过程和切片过程二部分。
（1）虚拟存储过程
将输入目录下所有文件大小，依次和设置的setMaxInputSplitSize值比较，如果不大于设置的最大值，逻辑上划分一个块。如果输入文件大于设置的最大值且大于两倍，那么以最大值切割一块；当剩余数据大小超过设置的最大值且不大于最大值2倍，此时将文件均分成2个虚拟存储块（防止出现太小切片）。
例如setMaxInputSplitSize值为4M，输入文件大小为8.02M，则先逻辑上分成一个4M。剩余的大小为4.02M，如果按照4M逻辑划分，就会出现0.02M的小的虚拟存储文件，所以将剩余的4.02M文件切分成（2.01M和2.01M）两个文件。
（2）切片过程
（a）判断虚拟存储的文件大小是否大于setMaxInputSplitSize值，大于等于则单独形成一个切片。
（b）如果不大于则跟下一个虚拟存储文件进行合并，共同形成一个切片。
（c）测试举例：有4个小文件大小分别为1.7M、5.1M、3.4M以及6.8M这四个小文件，则虚拟存储之后形成6个文件块，大小分别为：
1.7M，（2.55M、2.55M），3.4M以及（3.4M、3.4M）
最终会形成3个切片，大小分别为：
（1.7+2.55）M，（2.55+3.4）M，（3.4+3.4）M
3.1.6 CombineTextInputFormat案例实操
1）需求
将输入的大量小文件合并成一个切片统一处理。
（1）输入数据
准备4个小文件a.txt(1.7M) b.txt(5.1M) c.txt(3.4M）d.txt(6.8M)
（2）期望
期望一个切片处理4个文件
2）实现过程
（1）不做任何处理，运行1.8节的WordCount案例程序，观察切片个数为4。
number of splits:4
（2）在WordcountDriver中增加如下代码，运行程序，并观察运行的切片个数为3。
（a）驱动类中添加代码如下：
// 如果不设置InputFormat，它默认用的是TextInputFormat.class
job.setInputFormatClass(CombineTextInputFormat.class);
//虚拟存储切片最大值设置4m
CombineTextInputFormat.setMaxInputSplitSize(job, 4194304);
（b）运行结果为3个切片。
number of splits:3
（3）在WordcountDriver中增加如下代码，运行程序，并观察运行的切片个数为1。
（a）驱动中添加代码如下：
// 如果不设置InputFormat，它默认用的是TextInputFormat.class
job.setInputFormatClass(CombineTextInputFormat.class);
//虚拟存储切片最大值设置20m
CombineTextInputFormat.setMaxInputSplitSize(job, 20971520);
（b）运行结果为1个切片
number of splits:1
3.2.MapReduce工作流程
上面的流程是整个MapReduce最全工作流程，但是Shuffle过程只是从第7步开始到第16步结束，具体Shuffle过程详解，如下：
（1）MapTask收集我们的map()方法输出的kv对，放到内存缓冲区中
（2）从内存缓冲区不断溢出本地磁盘文件，可能会溢出多个文件
（3）多个溢出文件会被合并成大的溢出文件
（4）在溢出过程及合并的过程中，都要调用Partitioner进行分区和针对key进行排序
（5）ReduceTask根据自己的分区号，去各个MapTask机器上取相应的结果分区数据
（6）ReduceTask会抓取到同一个分区的来自不同MapTask的结果文件，ReduceTask会将这些文件再进行合并（归并排序）
（7）合并成大文件后，Shuffle的过程也就结束了，后面进入ReduceTask的逻辑运算过程（从文件中取出一个一个的键值对Group，调用用户自定义的reduce()方法）
注意：
（1）Shuffle中的缓冲区大小会影响到MapReduce程序的执行效率，原则上说，缓冲区越大，磁盘io的次数越少，执行速度就越快。
（2）缓冲区的大小可以通过参数调整，参数：mapreduce.task.io.sort.mb默认100M。
3.3 Shuffle机制
3.3.1 Shuffle机制
重点：Map方法之后，Reduce方法之前的数据处理过程称之为Shuffle。
3.3.2 Partition分区
job.setNumReduceTasks(2);
3.3.3 Partition分区案例实操
1）需求
将统计结果按照手机归属地不同省份输出到不同文件中（分区）
（1）输入数据
phone_data.txt文件
（2）期望输出数据
手机号136、137、138、139开头都分别放到一个独立的4个文件中，其他开头的放到一个文件中。
2）需求分析
3）在案例2.3的基础上，增加一个分区类
import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapreduce.Partitioner;
/**
* @author eccom
* @description 分区设置
* @date 2022/5/25 15:13
*/
public class ProvincePartitioner extends Partitioner<Text, FlowBean> {
@Override
public int getPartition(Text text, FlowBean flowBean, int numPartitions) {
int partition;
//text是手机号
String phone = text.toString();
if (phone.startsWith("136")) {
partition = 0;
} else if (phone.startsWith("137")) {
partition = 1;
} else if (phone.startsWith("138")) {
partition = 2;
} else if (phone.startsWith("139")) {
partition = 3;
} else {
partition = 4;
}
return partition;
}
}
4）在驱动函数中增加自定义数据分区设置和ReduceTask设置
import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.fs.Path;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapreduce.Job;
import org.apache.hadoop.mapreduce.lib.input.FileInputFormat;
import org.apache.hadoop.mapreduce.lib.output.FileOutputFormat;
import java.io.IOException;
/**
* @author eccom
* @description driver
* @date 2022/5/24 16:24
*/
public class FlowDriver {
public static void main(String[] args) throws IOException, InterruptedException, ClassNotFoundException {
//1.获取job对象
Configuration conf = new Configuration();
Job job = Job.getInstance(conf);
//2.设置jar包
job.setJarByClass(FlowDriver.class);
//3.关联mapper reducer
job.setMapperClass(FlowMapper.class);
job.setReducerClass(FlowReducer.class);
//4.设置mapper 输出的key和value类型
job.setMapOutputKeyClass(Text.class);
job.setMapOutputValueClass(FlowBean.class);
//5.设置最终数据输出的key value类型
job.setOutputKeyClass(Text.class);
job.setOutputValueClass(FlowBean.class);
//8 指定自定义分区器
job.setPartitionerClass(ProvincePartitioner.class);
//9 同时指定相应数量的ReduceTask
job.setNumReduceTasks(5);
//6.设置数据的输入和输出路径
FileInputFormat.setInputPaths(job, new Path("D:\\learn\\input\\hadoop\\flow"));
FileOutputFormat.setOutputPath(job, new Path("D:\\learn\\output\\hadoop\\flow"));
//提交job
boolean result = job.waitForCompletion(true);
System.exit(result ? 0 : 1);
}
}
3.3.4 WritableComparable排序
为什么要排序：因为reduce方法是将同一个key的数据传进去处理，如果不排序，则此步骤每次会去遍历全部数据，效率低下
排序是MapReduce框架中最重要的操作之一。
MapTask和ReduceTask均会对数据按照key进行排序。该操作属于Hadoop的默认行为。任何应用程序中的数据均会被排序，而不管逻辑上是否需要。
默认排序是按照字典顺序排序，且实现该排序的方法是排序是MapReduce框架中最重要的操作之一。
对于MapTask，它会将处理的结果暂时放到环形缓冲区中，当环形缓冲区使用率达到一定阈值后，再对缓冲区中的数据进行一次快速排序，并将这些有序数据溢写到磁盘上，而当数据处理完毕后，它会对磁盘上所有文件进行归并排序。
对于ReduceTask，它从每个MapTask上远程拷贝相应的数据文件，如果文件大小超过一定阈值，则溢写磁盘上，否则存储在内存中。如果磁盘上文件数目达到一定阈值，则进行一次归并排序以生成一个更大文件;如果内存中文件大小或者数目超过一定阈值，则进行一次合并后将数据溢写到磁盘上。当所有数据拷贝完毕后，ReduceTask统一对内存和磁盘上的所有数据进行一次归并排序。
排序分类
(1）部分排序
MapReduce根据输入记录的键对数据集排序。保证输出的每个文件内部有序。
(2)全排序
最终输出结果只有一个文件，且文件内部有序。实现方式是只设置一个ReduceTask。但该方法在处理大型文件时效率极低，因为一台机器处理所有文件，完全丧失了MapReduce所提供的并行架构。
(3）辅助排序:(GroupingComparator分组)
在Reduce端对key进行分组。应用于:在接收的key为bean对象时，想让一个或几个字段相同（全部字段比较不相同)的key进入到同一个reduce方法时，可以采用分组排序。
(4)二次排序
在自定义排序过程中，如果compareTo中的判断条件为两个即为二次排序。
自定义排序WritableComparable原理分析
bean对象做为key传输，需要实现WritableComparable接口重写compareTo方法，就可以实现排序。
@Override
public int compareTo(FlowBean bean) {
int result;
// 按照总流量大小，倒序排列
if (this.sumFlow > bean.getSumFlow()) {
result = -1;
}else if (this.sumFlow < bean.getSumFlow()) {
result = 1;
}else {
result = 0;
}
return result;
}
3.3.5 WritableComparable排序案例实操（全排序）
1）需求
根据案例2.3序列化案例产生的结果再次对总流量进行倒序排序。
（1）输入数据
原始数据 phone_data.txt 第一次处理后得到的数据 part-r-00000
（2）期望输出数据
13509468723 7335 110349 117684
13736230513 2481 24681 27162
13956435636 132 1512 1644
13846544121 264 0 264
。。。 。。。
2）需求分析
3）代码实现
（1）FlowBean对象在在需求1基础上增加了比较功能
import org.apache.hadoop.io.WritableComparable;
import java.io.DataInput;
import java.io.DataOutput;
import java.io.IOException;
/**
* @author eccom
* 1.必须实现Writable接口
* 2.重新序列化反序列化方法
* 3.重写空参构造
* 4.toString方法
* @description 序列化
* @date 2022/5/24 15:47
*/
public class FlowBean implements WritableComparable<FlowBean> {
/**
* 上行流量
*/
private long upFlow;
/**
* 下行流量
*/
private long downFlow;
/**
* 总流量
*/
private long sumFlow;
/**
* 空参构造
*/
public FlowBean() {
}
@Override
public void write(DataOutput out) throws IOException {
out.writeLong(upFlow);
out.writeLong(downFlow);
out.writeLong(sumFlow);
}
@Override
public void readFields(DataInput in) throws IOException {
this.upFlow = in.readLong();
this.downFlow = in.readLong();
this.sumFlow = in.readLong();
}
@Override
public int compareTo(FlowBean o) {
//按照总流量倒叙排序
if (this.sumFlow > o.sumFlow) {
return -1;
} else if (this.sumFlow < o.sumFlow) {
return 1;
}
return 0;
}
@Override
public String toString() {
return upFlow + "\t" + downFlow + "\t" + sumFlow;
}
public long getUpFlow() {
return upFlow;
}
public void setUpFlow(long upFlow) {
this.upFlow = upFlow;
}
public long getDownFlow() {
return downFlow;
}
public void setDownFlow(long downFlow) {
this.downFlow = downFlow;
}
public long getSumFlow() {
return sumFlow;
}
public void setSumFlow(long sumFlow) {
this.sumFlow = sumFlow;
}
public void setSumFlow() {
this.sumFlow = this.downFlow + this.upFlow;
}
}
（2）编写Mapper类
import org.apache.hadoop.io.LongWritable;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapreduce.Mapper;
import java.io.IOException;
/**
* @author eccom
* @description map
* @date 2022/5/24 15:59
*/
public class FlowMapper extends Mapper<LongWritable, Text, FlowBean, Text> {
private final Text outV = new Text();
private final FlowBean outK = new FlowBean();
@Override
protected void map(LongWritable key, Text value, Mapper<LongWritable, Text, FlowBean, Text>.Context context) throws IOException, InterruptedException {
//获取一行
String line = value.toString();
//切割
String[] split = line.split("\t");
//3 封装outK outV
outK.setUpFlow(Long.parseLong(split[1]));
outK.setDownFlow(Long.parseLong(split[2]));
outK.setSumFlow();
outV.set(split[0]);
//写出
context.write(outK, outV);
}
}
（3）编写Reducer类
import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapreduce.Reducer;
import java.io.IOException;
/**
* @author eccom
* @description Reducer
* @date 2022/5/24 16:14
*/
public class FlowReducer extends Reducer<FlowBean, Text, Text, FlowBean> {
@Override
protected void reduce(FlowBean key, Iterable<Text> values, Reducer<FlowBean
, Text, Text, FlowBean>.Context context) throws IOException, InterruptedException {
for (Text value : values) {
context.write(value, key);
}
}
}
（4）编写Driver类
import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.fs.Path;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapreduce.Job;
import org.apache.hadoop.mapreduce.lib.input.FileInputFormat;
import org.apache.hadoop.mapreduce.lib.output.FileOutputFormat;
import java.io.IOException;
/**
* @author eccom
* @description driver
* @date 2022/5/24 16:24
*/
public class FlowDriver {
public static void main(String[] args) throws IOException, InterruptedException, ClassNotFoundException {
//1.获取job对象
Configuration conf = new Configuration();
Job job = Job.getInstance(conf);
//2.设置jar包
job.setJarByClass(FlowDriver.class);
//3.关联mapper reducer
job.setMapperClass(FlowMapper.class);
job.setReducerClass(FlowReducer.class);
//4.设置mapper 输出的key和value类型
job.setMapOutputKeyClass(FlowBean.class);
job.setMapOutputValueClass(Text.class);
//5.设置最终数据输出的key value类型
job.setOutputKeyClass(Text.class);
job.setOutputValueClass(FlowBean.class);
//6.设置数据的输入和输出路径
FileInputFormat.setInputPaths(job, new Path("D:\\learn\\input\\writablecompable"));
FileOutputFormat.setOutputPath(job, new Path("D:\\learn\\output\\writablecompable"));
//提交job
boolean result = job.waitForCompletion(true);
System.exit(result ? 0 : 1);
}
}
二次排序：总流量相同按照上行流量升序排序FlowBean.class
@Override
public int compareTo(FlowBean o) {
//按照总流量倒叙排序
if (this.sumFlow > o.sumFlow) {
return -1;
} else if (this.sumFlow < o.sumFlow) {
return 1;
}
if (this.upFlow > o.upFlow) {
return 1;
} else if (this.upFlow < o.upFlow) {
return -1;
}
return 0;
}
3.3.6 WritableComparable排序案例实操（区内排序）
1）需求
要求每个省份手机号输出的文件中按照总流量内部排序。
2）需求分析
基于前一个需求，增加自定义分区类，分区按照省份手机号设置。
3）案例实操
（1）增加自定义分区类
import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapreduce.Partitioner;
/**
* @author eccom
* @description 分区器
* @date 2022/5/25 17:10
*/
public class ProvincePartitioner2 extends Partitioner<FlowBean, Text> {
@Override
public int getPartition(FlowBean flowBean, Text text, int numPartitions) {
int partition;
//text是手机号
String phone = text.toString();
if (phone.startsWith("136")) {
partition = 0;
} else if (phone.startsWith("137")) {
partition = 1;
} else if (phone.startsWith("138")) {
partition = 2;
} else if (phone.startsWith("139")) {
partition = 3;
} else {
partition = 4;
}
return partition;
}
}
（2）在驱动类中添加分区类
job.setPartitionerClass(ProvincePartitioner2.class);
job.setNumReduceTasks(5);
3.3.7 Combiner合并
（6）自定义Combiner实现步骤
（a）自定义一个Combiner继承Reducer，重写Reduce方法
public class WordCountCombiner extends Reducer<Text, IntWritable, Text, IntWritable> {
private IntWritable outV = new IntWritable();
@Override
protected void reduce(Text key, Iterable<IntWritable> values, Context context) throws IOException, InterruptedException {
int sum = 0;
for (IntWritable value : values) {
sum += value.get();
}
outV.set(sum);
context.write(key,outV);
}
}
（b）在Job驱动类中设置
job.setCombinerClass(WordCountCombiner.class);
3.3.8 Combiner合并案例实操
1）需求
统计过程中对每一个MapTask的输出进行局部汇总，以减小网络传输量即采用Combiner功能。
（1）数据输入
hello.txt
（2）期望输出数据
期望：Combine输入数据多，输出时经过合并，输出数据降低。
2）需求分析
3）案例实操-方案一
（1）增加一个WordCountCombiner类继承Reducer
import org.apache.hadoop.io.IntWritable;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapreduce.Reducer;
import java.io.IOException;
/**
* @author eccom
* @description Combiner
* @date 2022/5/26 11:16
*/
public class WordCountCombiner extends Reducer<Text, IntWritable, Text, IntWritable> {
private final IntWritable outK = new IntWritable();
@Override
protected void reduce(Text key, Iterable<IntWritable> values, Reducer<Text, IntWritable
, Text, IntWritable>.Context context) throws IOException, InterruptedException {
int sum = 0;
for (IntWritable value : values) {
sum += value.get();
}
outK.set(sum);
context.write(key, outK);
}
}
（2）在WordcountDriver驱动类中指定Combiner
// 指定需要使用combiner，以及用哪个类作为combiner的逻辑
job.setCombinerClass(WordCountCombiner.class);
4）案例实操-方案二
（1）将WordcountReducer作为Combiner在WordcountDriver驱动类中指定
// 指定需要使用Combiner，以及用哪个类作为Combiner的逻辑
job.setCombinerClass(WordCountReducer.class);
3.4 OutputFormat数据输出
经历reduce之后，由outputFormat进行输出格式化
3.4.1 OutputFormat接口实现类
3.4.2 自定义OutputFormat案例实操
1）需求
过滤输入的log日志，包含fuhong的网站输出到d:/fuhong.log，不包含fuhong的网站输出到d:/other.log。
（1）输入数据
见分析
（2）期望输出数据
见分析
2）需求分析
3）案例实操
（1）编写LogMapper类
import org.apache.hadoop.io.LongWritable;
import org.apache.hadoop.io.NullWritable;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapreduce.Mapper;
import java.io.IOException;
/**
* @author eccom
* @description logMapper
* @date 2022/5/26 13:37
*/
public class LogMapper extends Mapper<LongWritable, Text, Text, NullWritable> {
@Override
protected void map(LongWritable key, Text value, Mapper<LongWritable, Text, Text
, NullWritable>.Context context) throws IOException, InterruptedException {
//http://www.baidu.com
context.write(value, NullWritable.get());
}
}
（2）编写LogReducer类
import org.apache.hadoop.io.NullWritable;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapreduce.Reducer;
import java.io.IOException;
/**
* @author eccom
* @description LogReducer
* @date 2022/5/26 13:41
*/
public class LogReducer extends Reducer<Text, NullWritable, Text, NullWritable> {
@Override
protected void reduce(Text key, Iterable<NullWritable> values, Reducer<Text, NullWritable, Text, NullWritable>.Context context) throws IOException, InterruptedException {
//http://www.baidu.com
//防止相同数据丢数据
for (NullWritable value : values) {
context.write(key, NullWritable.get());
}
}
}
（3）自定义一个LogOutputFormat类
import org.apache.hadoop.io.NullWritable;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapreduce.RecordWriter;
import org.apache.hadoop.mapreduce.TaskAttemptContext;
import org.apache.hadoop.mapreduce.lib.output.FileOutputFormat;
import java.io.IOException;
/**
* @author eccom
* @description LogOutputFormat
* @date 2022/5/26 13:49
*/
public class LogOutputFormat extends FileOutputFormat<Text, NullWritable> {
@Override
public RecordWriter<Text, NullWritable> getRecordWriter(TaskAttemptContext job) throws IOException, InterruptedException {
return new LogRecordWriter(job);
}
}
（4）编写LogRecordWriter类
import org.apache.hadoop.fs.FSDataOutputStream;
import org.apache.hadoop.fs.FileSystem;
import org.apache.hadoop.fs.Path;
import org.apache.hadoop.io.IOUtils;
import org.apache.hadoop.io.NullWritable;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapreduce.RecordWriter;
import org.apache.hadoop.mapreduce.TaskAttemptContext;
import java.io.IOException;
/**
* @author eccom
* @description 写出规则
* @date 2022/5/26 13:51
*/
public class LogRecordWriter extends RecordWriter<Text, NullWritable> {
private FSDataOutputStream otherOut;
private FSDataOutputStream fuOut;
public LogRecordWriter(TaskAttemptContext job) {
//创建两条流
try {
FileSystem fileSystem = FileSystem.get(job.getConfiguration());
fuOut = fileSystem
.create(new Path("D:\\learn\\output\\hadoop\\inputoutputformat\\fuhong.log"));
otherOut = fileSystem
.create(new Path("D:\\learn\\output\\hadoop\\inputoutputformat\\other.log"));
} catch (IOException e) {
e.printStackTrace();
}
}
@Override
public void write(Text key, NullWritable value) throws IOException, InterruptedException {
//具体些
String log = key.toString();
if (log.contains("fuhong")) {
fuOut.writeBytes(log + "\n");
} else {
otherOut.writeBytes(log + "\n");
}
}
@Override
public void close(TaskAttemptContext context) throws IOException, InterruptedException {
//关闭流
IOUtils.closeStream(fuOut);
IOUtils.closeStream(otherOut);
}
}
（5）编写LogDriver类
import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.fs.Path;
import org.apache.hadoop.io.NullWritable;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapreduce.Job;
import org.apache.hadoop.mapreduce.lib.input.FileInputFormat;
import org.apache.hadoop.mapreduce.lib.output.FileOutputFormat;
import java.io.IOException;
/**
* @author eccom
* @description 驱动
* @date 2022/5/26 14:05
*/
public class LogDriver {
public static void main(String[] args) throws IOException, ClassNotFoundException, InterruptedException, IOException {
Configuration conf = new Configuration();
Job job = Job.getInstance(conf);
job.setJarByClass(LogDriver.class);
job.setMapperClass(LogMapper.class);
job.setReducerClass(LogReducer.class);
job.setMapOutputKeyClass(Text.class);
job.setMapOutputValueClass(NullWritable.class);
job.setOutputKeyClass(Text.class);
job.setOutputValueClass(NullWritable.class);
//设置自定义的outputformat
job.setOutputFormatClass(LogOutputFormat.class);
FileInputFormat.setInputPaths(job, new Path("D:\\learn\\input\\hadoop\\inputoutputformat"));
//虽然我们自定义了outputformat，但是因为我们的outputformat继承自fileoutputformat
//而fileoutputformat要输出一个_SUCCESS文件，所以在这还得指定一个输出目录
FileOutputFormat.setOutputPath(job, new Path("D:\\learn\\output\\hadoop\\inputoutputformat\\success"));
boolean b = job.waitForCompletion(true);
System.exit(b ? 0 : 1);
}
}
3.5 MapReduce内核源码解析
3.5.1 MapTask工作机制
（重点）
（1）Read阶段：MapTask通过InputFormat获得的RecordReader，从输入InputSplit中解析出一个个key/value。
（2）Map阶段：该节点主要是将解析出的key/value交给用户编写map()函数处理，并产生一系列新的key/value。
（3）Collect收集阶段：在用户编写map()函数中，当数据处理完成后，一般会调用OutputCollector.collect()输出结果。在该函数内部，它会将生成的key/value分区（调用Partitioner），并写入一个环形内存缓冲区中。
（4）Spill阶段：即“溢写”，当环形缓冲区满后，MapReduce会将数据写到本地磁盘上，生成一个临时文件。需要注意的是，将数据写入本地磁盘之前，先要对数据进行一次本地排序，并在必要时对数据进行合并、压缩等操作。
溢写阶段详情：
步骤1：利用快速排序算法对缓存区内的数据进行排序，排序方式是，先按照分区编号Partition进行排序，然后按照key进行排序。这样，经过排序后，数据以分区为单位聚集在一起，且同一分区内所有数据按照key有序。
步骤2：按照分区编号由小到大依次将每个分区中的数据写入任务工作目录下的临时文件output/spillN.out（N表示当前溢写次数）中。如果用户设置了Combiner，则写入文件之前，对每个分区中的数据进行一次聚集操作。
步骤3：将分区数据的元信息写到内存索引数据结构SpillRecord中，其中每个分区的元信息包括在临时文件中的偏移量、压缩前数据大小和压缩后数据大小。如果当前内存索引大小超过1MB，则将内存索引写到文件output/spillN.out.index中。
（5）Merge阶段：当所有数据处理完成后，MapTask对所有临时文件进行一次合并，以确保最终只会生成一个数据文件。
当所有数据处理完后，MapTask会将所有临时文件合并成一个大文件，并保存到文件output/file.out中，同时生成相应的索引文件output/file.out.index。
在进行文件合并过程中，MapTask以分区为单位进行合并。对于某个分区，它将采用多轮递归合并的方式。每轮合并mapreduce.task.io.sort.factor（默认10）个文件，并将产生的文件重新加入待合并列表中，对文件排序后，重复以上过程，直到最终得到一个大文件。
让每个MapTask最终只生成一个数据文件，可避免同时打开大量文件和同时读取大量小文件产生的随机读取带来的开销。
3.5.2 ReduceTask工作机制
(重点)
（1）Copy阶段：ReduceTask从各个MapTask上远程拷贝一片数据，并针对某一片数据，如果其大小超过一定阈值，则写到磁盘上，否则直接放到内存中。
（2）Sort阶段：在远程拷贝数据的同时，ReduceTask启动了两个后台线程对内存和磁盘上的文件进行合并，以防止内存使用过多或磁盘上文件过多。按照MapReduce语义，用户编写reduce()函数输入数据是按key进行聚集的一组数据。为了将key相同的数据聚在一起，Hadoop采用了基于排序的策略。由于各个MapTask已经实现对自己的处理结果进行了局部排序，因此，ReduceTask只需对所有数据进行一次归并排序即可。
（3）Reduce阶段：reduce()函数将计算结果写到HDFS上。
3.5.3 ReduceTask并行度决定机制
回顾：MapTask并行度由切片个数决定，切片个数由输入文件和切片规则决定。
思考：ReduceTask并行度由谁决定？
1）设置ReduceTask并行度（个数）
ReduceTask的并行度同样影响整个Job的执行并发度和执行效率，但与MapTask的并发数由切片数决定不同，ReduceTask数量的决定是可以直接手动设置：
// 默认值是1，手动设置为4
job.setNumReduceTasks(4);
2）实验：测试ReduceTask多少合适
（1）实验环境：1个Master节点，16个Slave节点：CPU:8GHZ，内存: 2G
（2）实验结论：
表 改变ReduceTask（数据量为1GB）
| MapTask =16 | ||||||||||
|---|---|---|---|---|---|---|---|---|---|---|
| ReduceTask | 1 | 5 | 10 | 15 | 16 | 20 | 25 | 30 | 45 | 60 |
| 总时间 | 892 | 146 | 110 | 92 | 88 | 100 | 128 | 101 | 145 | 104 |
3）注意事项
(1) ReduceTask=0，表示没有Reduce阶段，输出文件个数和Map个数一致。
(2) ReduccTask默认值就是1，所以输出文件个数为一个。
(3）如果数据分布不均匀，就有可能在Reduce阶段产生数据倾斜
(4) ReduceTask数量并不是任意设置，还要考虑业务逻辑需求，有些情况下，需要计算全局汇总结果，就只能有1个ReduceTask。
(5）具体多少个ReduccTask，需要根据集群性能而定。
(6）如果分区数不是1，但是ReduceTask为1，是否执行分区过程。答案是:不执行分区过程。因为在MapTask的源码中，执行分区的前提是先判断ReduccNum个数是否大于1。不大于1肯定不执行。
3.5.4 MapTask & ReduceTask源码解析
1）MapTask源码解析流程
//1.入口 map方法的write
context.write(outK, outV);
//MapTask.java 799行
mapper.run(mapperContext);
//2.MapTask.java收集方法 进入两次（这里传入 分区定义 数据分区）727行
collector.collect(key, value,partitioner.getPartition(key, value, partitions));
//3.MapTask 1082行 map端所有的kv全部写出后会走下面的close方法
//写一条元数据和实际数据到环形缓冲区，元数据：keyStart valStart index partition
//一条记录：key value 必须支持序列化，因为这个数据后期可能是跨服务器处理
collect()
//重复以上步骤，直到读取所有内容（内存足）或者环形缓冲区不足（内存不足，溢写）
//4.MapTask.java 803行调用MapTask.java 732行
input.close();
// 5. 溢出刷写方法，MapTask735行 调用本类1474行
collector.flush();
//6.溢写排序，MapTask1505行
sortAndSpill();
//7.QuickSort 溢写排序方法，MapTask1625行
//排序
sorter.sort(MapOutputBuffer.this, mstart, mend, reporter);
//8.溢写 虽然有五个分区，但是放入一个文件，用索引等元数据进行标记，溢写时按索引位往外写；到目前为止splill0.txt一些文件为空的，循环遍历每一个分区进行数据写入
//9.产生了溢写文件 进行归并MapTask.java1527行
//遍历所有的溢写文件，合并成一个最终的溢写文件 file.out file.out.index(reducer拉取分区时使用)
mergeParts();
//10.MapTask.java739行,收集器关闭,即将进入ReduceTask
collector.close();
2）ReduceTask源码解析流程
//1.reduceTask324行，提前打断点 开启一个mapTask的数据写出 重复开展此过程 可以进行全部mapTask数据写入
if (isMapOrReduce())
//2.初始化reduceTask333行
initialize(job, getJobID(), reporter, useNewApi);
//3.Task.java 604行
outputFormat =
ReflectionUtils.newInstance(taskContext.getOutputFormatClass(), job);
shuffleConsumerPlugin.init(shuffleContext);
//new 对象
scheduler = new ShuffleSchedulerImpl<K, V>(jobConf, taskStatus, reduceId,
this, copyPhase, context.getShuffledMapsCounter(),
context.getReduceShuffleBytes(), context.getFailedShuffleCounter());
//4.获取mapTask数量 知道从多少个mapTask中拉取数据
totalMaps = job.getNumMapTasks();
//入口 合并方法，Shuffle第80行
merger = createMergeManager(context);
//new 对象 初始化参数
return new MergeManagerImpl<K, V>(reduceId, jobConf, context.getLocalFS(),
context.getLocalDirAllocator(), reporter, context.getCodec(),
context.getCombinerClass(), context.getCombineCollector(),
context.getSpilledRecordsCounter(),
context.getReduceCombineInputCounter(),
context.getMergedMapOutputsCounter(), this, context.getMergePhase(),
context.getMapOutputFile());
//初始化内存和磁盘
this.inMemoryMerger = createInMemoryMerger();
this.inMemoryMerger.start();
this.onDiskMerger = new OnDiskMerger(this);
this.onDiskMerger.start();
this.mergePhase = mergePhase;
//5.初始化工作完成，开始拉取数据操作
rIter = shuffleConsumerPlugin.run();
//6.开始抓取数据，Shuffle第107行
eventFetcher.start();
//7.抓取结束，Shuffle第141行，提前打断点
eventFetcher.shutDown();
//copy阶段完成，Shuffle第151行
copyPhase.complete();
//开始排序阶段，状态切换 Shuffle第152行
taskStatus.setPhase(TaskStatus.Phase.SORT);
//8.排序阶段完成，即将进入reduce阶段 reduceTask382行
sortPhase.complete();
//9.进入reduce方法
runNewReducer(job, umbilical, reporter, rIter, comparator,
keyClass, valueClass);
//10.真正进入reduce方法入口 进入Reducer.java 171行的run方法 从这里经过前置方法进入自定义的reduce方法，在进入购置方法
reducer.run(reducerContext);
//11.遍历每一个key 进入写流程
reduce(context.getCurrentKey(), context.getValues(), context);
//12.自定义reducer方法 相同key开始往出写
context.write(key, outV);
//13.TextOutputFormat.java写数据 先写一个key 再写value value写出时是调用对象的toString方法
writeObject(key);
writeObject(value);
//到目前为止 只写了一个Key 重复 11 12 13 完成这个MapTask每一个Key的写入
//到这里完成了一个 mapTask 数据的写入 重复开展1-12 完成所有mapTask（切片，分区）的数据写入
3.6 Join应用
3.6.1 Reduce Join
Map端的主要工作：为来自不同表或文件的key/value对，打标签以区别不同来源的记录。然后用连接字段作为key，其余部分和新加的标志作为value，最后进行输出。
Reduce端的主要工作：在Reduce端以连接字段作为key的分组已经完成，我们只需要在每一个分组当中将那些来源于不同文件的记录（在Map阶段已经打标志）分开，最后进行合并就ok了。
3.6.2 Reduce Join案例实操
1）需求
表4-4 订单数据表t_order
| id | pid | amount |
|---|---|---|
| 1001 | 01 | 1 |
| 1002 | 02 | 2 |
| 1003 | 03 | 3 |
| 1004 | 01 | 4 |
| 1005 | 02 | 5 |
| 1006 | 03 | 6 |
表4-5 商品信息表t_product
| pid | pname |
|---|---|
| 01 | 小米 |
| 02 | 华为 |
| 03 | 格力 |
将商品信息表中数据根据商品pid合并到订单数据表中。
表4-6 最终数据形式
| id | pname | amount |
|---|---|---|
| 1001 | 小米 | 1 |
| 1004 | 小米 | 4 |
| 1002 | 华为 | 2 |
| 1005 | 华为 | 5 |
| 1003 | 格力 | 3 |
| 1006 | 格力 | 6 |
2）需求分析
通过将关联条件作为Map输出的key，将两表满足Join条件的数据并携带数据所来源的文件信息，发往同一个ReduceTask，在Reduce中进行数据的串联。
3）代码实现
（1）创建商品和订单合并后的TableBean类
import org.apache.hadoop.io.Writable;
import java.io.DataInput;
import java.io.DataOutput;
import java.io.IOException;
/**
* @author eccom
* @description 表实体类
* @date 2022/5/27 9:53
*/
public class TableBean implements Writable {
/**
* 订单id
*/
private String id;
/**
* 商品id
*/
private String pid;
/**
* 商品数量
*/
private int amount;
/**
* 商品名称
*/
private String pName;
/**
* 标记 order pd
*/
private String flag;
/**
* 空参构造
*/
public TableBean() {
}
@Override
public void write(DataOutput out) throws IOException {
out.writeUTF(id);
out.writeUTF(pid);
out.writeInt(amount);
out.writeUTF(pName);
out.writeUTF(flag);
}
@Override
public void readFields(DataInput in) throws IOException {
this.id = in.readUTF();
this.pid = in.readUTF();
this.amount = in.readInt();
this.pName = in.readUTF();
this.flag = in.readUTF();
}
@Override
public String toString() {
return id + '\t' + pName + '\t' + amount;
}
public String getId() {
return id;
}
public void setId(String id) {
this.id = id;
}
public String getPid() {
return pid;
}
public void setPid(String pid) {
this.pid = pid;
}
public int getAmount() {
return amount;
}
public void setAmount(int amount) {
this.amount = amount;
}
public String getpName() {
return pName;
}
public void setpName(String pName) {
this.pName = pName;
}
public String getFlag() {
return flag;
}
public void setFlag(String flag) {
this.flag = flag;
}
}
（2）编写TableMapper类
import org.apache.hadoop.io.LongWritable;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapreduce.Mapper;
import org.apache.hadoop.mapreduce.lib.input.FileSplit;
import java.io.IOException;
/**
* @author eccom
* @description mapper
* @date 2022/5/27 10:11
*/
public class TableMapper extends Mapper<LongWritable, Text, Text, TableBean> {
private String fileName;
private Text outK = new Text();
private TableBean outV = new TableBean();
@Override
protected void setup(Mapper<LongWritable, Text, Text, TableBean>.Context context)
throws IOException, InterruptedException {
//初始化 order pd
FileSplit split = (FileSplit) context.getInputSplit();
fileName = split.getPath().getName();
}
@Override
protected void map(LongWritable key, Text value, Mapper<LongWritable, Text
, Text, TableBean>.Context context) throws IOException, InterruptedException {
//1.获取1行
String line = value.toString();
//2.判断是哪个文件
//处理订单表
if (fileName.contains("order")) {
String[] split = line.split("\t");
//封装kv
outK.set(split[1]);
outV.setId(split[0]);
outV.setPid(split[1]);
outV.setAmount(Integer.parseInt(split[2]));
outV.setpName("");
outV.setFlag("order");
} else { //处理商品表
String[] split = line.split("\t");
//封装kv
outK.set(split[0]);
outV.setId("");
outV.setPid(split[0]);
outV.setAmount(0);
outV.setpName(split[1]);
outV.setFlag("pd");
}
//写出
context.write(outK, outV);
}
}
（3）编写TableReducer类
import org.apache.hadoop.io.NullWritable;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapreduce.Reducer;
import java.io.IOException;
import java.lang.reflect.InvocationTargetException;
import java.util.ArrayList;
import java.util.List;
import static org.apache.commons.beanutils.BeanUtils.copyProperties;
public class TableReducer extends Reducer<Text, TableBean, TableBean, NullWritable> {
@Override
protected void reduce(Text key, Iterable<TableBean> values, Reducer<Text, TableBean
, TableBean, NullWritable>.Context context) throws IOException, InterruptedException {
List<TableBean> tableBeans = new ArrayList<>();
TableBean tableBean = new TableBean();
//循环遍历
for (TableBean value : values) {
//订单表
if ("order".equals(value.getFlag())) {
TableBean temp = new TableBean();
try {
copyProperties(temp, value);
} catch (IllegalAccessException | InvocationTargetException e) {
e.printStackTrace();
}
tableBeans.add(value);
} else {
//商品表
try {
copyProperties(tableBean, value);
} catch (IllegalAccessException | InvocationTargetException e) {
e.printStackTrace();
}
}
}
//循环遍历
for (TableBean bean : tableBeans) {
bean.setpName(tableBean.getpName());
context.write(bean, NullWritable.get());
}
}
}
（4）编写TableDriver类
import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.fs.Path;
import org.apache.hadoop.io.NullWritable;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapreduce.Job;
import org.apache.hadoop.mapreduce.lib.input.FileInputFormat;
import org.apache.hadoop.mapreduce.lib.output.FileOutputFormat;
import java.io.IOException;
public class TableDriver {
public static void main(String[] args) throws IOException, ClassNotFoundException, InterruptedException {
Job job = Job.getInstance(new Configuration());
job.setJarByClass(TableDriver.class);
job.setMapperClass(TableMapper.class);
job.setReducerClass(TableReducer.class);
job.setMapOutputKeyClass(Text.class);
job.setMapOutputValueClass(TableBean.class);
job.setOutputKeyClass(TableBean.class);
job.setOutputValueClass(NullWritable.class);
FileInputFormat.setInputPaths(job, new Path("D:\\learn\\input\\hadoop\\inputtable"));
FileOutputFormat.setOutputPath(job, new Path("D:\\learn\\output\\hadoop\\outputtable"));
boolean b = job.waitForCompletion(true);
System.exit(b ? 0 : 1);
}
}
4）测试
运行程序查看结果
1004 小米 4
1001 小米 1
1005 华为 5
1002 华为 2
1006 格力 6
1003 格力 3
5）总结
缺点：这种方式中，合并的操作是在Reduce阶段完成，Reduce端的处理压力太大，Map节点的运算负载则很低，资源利用率不高，且在Reduce阶段极易产生数据倾斜。
解决方案：Map端实现数据合并。
3.6.3 Map Join
1）使用场景
Map Join适用于一张表十分小、一张表很大的场景。
2）优点
思考：在Reduce端处理过多的表，非常容易产生数据倾斜。怎么办？
在Map端缓存多张表，提前处理业务逻辑，这样增加Map端业务，减少Reduce端数据的压力，尽可能的减少数据倾斜。
3）具体办法：采用DistributedCache
（1）在Mapper的setup阶段，将文件读取到缓存集合中。
（2）在Driver驱动类中加载缓存。
//缓存普通文件到Task运行节点。
job.addCacheFile(new URI("file:///e:/cache/pd.txt"));
//如果是集群运行,需要设置HDFS路径
job.addCacheFile(new URI("hdfs://hadoop102:8020/cache/pd.txt"));
3.6.4 Map Join案例实操
1）需求
需求以及文件同上。
2）需求分析
MapJoin适用于关联表中有小表的情形。
3）实现代码
（1）先在MapJoinDriver驱动类中添加缓存文件
import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.fs.Path;
import org.apache.hadoop.io.NullWritable;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapreduce.Job;
import org.apache.hadoop.mapreduce.lib.input.FileInputFormat;
import org.apache.hadoop.mapreduce.lib.output.FileOutputFormat;
import java.io.IOException;
import java.net.URI;
import java.net.URISyntaxException;
public class MapJoinDriver {
public static void main(String[] args) throws IOException, URISyntaxException, ClassNotFoundException, InterruptedException {
// 1 获取job信息
Configuration conf = new Configuration();
Job job = Job.getInstance(conf);
// 2 设置加载jar包路径
job.setJarByClass(MapJoinDriver.class);
// 3 关联mapper
job.setMapperClass(MapJoinMapper.class);
// 4 设置Map输出KV类型
job.setMapOutputKeyClass(Text.class);
job.setMapOutputValueClass(NullWritable.class);
// 5 设置最终输出KV类型
job.setOutputKeyClass(Text.class);
job.setOutputValueClass(NullWritable.class);
// 加载缓存数据
job.addCacheFile(new URI("file:///D:/learn/input/hadoop/tablecache/pd.txt"));
// Map端Join的逻辑不需要Reduce阶段，设置reduceTask数量为0
job.setNumReduceTasks(0);
// 6 设置输入输出路径
FileInputFormat.setInputPaths(job, new Path("D:\\learn\\input\\hadoop\\inputtable2"));
FileOutputFormat.setOutputPath(job, new Path("D:\\learn\\output\\hadoop\\inputtable2"));
// 7 提交
boolean b = job.waitForCompletion(true);
System.exit(b ? 0 : 1);
}
}
（2）在MapJoinMapper类中的setup方法中读取缓存文件
import org.apache.commons.lang3.StringUtils;
import org.apache.hadoop.fs.FSDataInputStream;
import org.apache.hadoop.fs.FileSystem;
import org.apache.hadoop.fs.Path;
import org.apache.hadoop.io.IOUtils;
import org.apache.hadoop.io.LongWritable;
import org.apache.hadoop.io.NullWritable;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapreduce.Mapper;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.net.URI;
import java.nio.charset.StandardCharsets;
import java.util.HashMap;
public class MapJoinMapper extends Mapper<LongWritable, Text, Text, NullWritable> {
private final HashMap<String, String> map = new HashMap<>();
private Text outK = new Text();
@Override
protected void setup(Mapper<LongWritable, Text, Text, NullWritable>.Context context)
throws IOException, InterruptedException {
//获取换成的文件，并把文件内容封装到集合
URI[] cacheFiles = context.getCacheFiles();
FileSystem fileSystem = FileSystem.get(context.getConfiguration());
FSDataInputStream open = fileSystem.open(new Path(cacheFiles[0]));
//从流中读取数据
try (BufferedReader reader = new BufferedReader(new InputStreamReader(open, StandardCharsets.UTF_8))) {
String line;
while (StringUtils.isNotEmpty((line = reader.readLine()))) {
//切割
String[] fields = line.split("\t");
map.put(fields[0], fields[1]);
}
IOUtils.closeStream(reader);
}
}
@Override
protected void map(LongWritable key, Text value, Mapper<LongWritable, Text, Text, NullWritable>
.Context context) throws IOException, InterruptedException {
String line = value.toString();
String[] fields = line.split("\t");
String pName = map.get(fields[1]);
//获取订单id 和订单数量
outK.set(fields[0] + "\t" + pName + "\t" + fields[2]);
context.write(outK, NullWritable.get());
}
}
3.7 数据清洗（ETL）
ETL，是英文Extract-Transform-Load的缩写，用来描述将数据从来源端经过抽取（Extract）、转换（Transform）、加载（Load）至目的端的过程。ETL一词较常用在数据仓库，但其对象并不限于数据仓库
在运行核心业务MapReduce程序之前，往往要先对数据进行清洗，清理掉不符合用户要求的数据。清理的过程往往只需要运行Mapper程序，不需要运行Reduce程序。
1）需求
去除日志中字段个数小于等于11的日志。
（1）输入数据
web.txt
（2）期望输出数据
每行字段长度都大于11。
2）需求分析
需要在Map阶段对输入的数据根据规则进行过滤清洗。
3）实现代码
（1）编写WebLogMapper类
import org.apache.hadoop.io.LongWritable;
import org.apache.hadoop.io.NullWritable;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapreduce.Mapper;
import java.io.IOException;
public class WebLogMapper extends Mapper<LongWritable, Text, Text, NullWritable> {
@Override
protected void map(LongWritable key, Text value, Mapper<LongWritable, Text, Text, NullWritable>.Context context) throws IOException, InterruptedException {
//1.获取1行
String line = value.toString();
//2.etl
boolean result = parseLog(line, context);
if (!result) {
return;
}
//3.写出
context.write(value, NullWritable.get());
}
private boolean parseLog(String line, Mapper<LongWritable, Text, Text, NullWritable>.Context context) {
String[] fields = line.split(" ");
if (fields.length > 11) {
return true;
}
return false;
}
}
（2）编写WebLogDriver类
import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.fs.Path;
import org.apache.hadoop.io.NullWritable;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapreduce.Job;
import org.apache.hadoop.mapreduce.lib.input.FileInputFormat;
import org.apache.hadoop.mapreduce.lib.output.FileOutputFormat;
public class WebLogDriver {
public static void main(String[] args) throws Exception {
// 输入输出路径需要根据自己电脑上实际的输入输出路径设置
args = new String[]{"D:\\learn\\input\\hadoop\\inputlog", "D:\\learn\\output\\hadoop\\inputlog"};
// 1 获取job信息
Configuration conf = new Configuration();
Job job = Job.getInstance(conf);
// 2 加载jar包
job.setJarByClass(WebLogDriver.class);
// 3 关联map
job.setMapperClass(WebLogMapper.class);
// 4 设置最终输出类型
job.setOutputKeyClass(Text.class);
job.setOutputValueClass(NullWritable.class);
// 设置reducetask个数为0
job.setNumReduceTasks(0);
// 5 设置输入和输出路径
FileInputFormat.setInputPaths(job, new Path(args[0]));
FileOutputFormat.setOutputPath(job, new Path(args[1]));
// 6 提交
boolean b = job.waitForCompletion(true);
System.exit(b ? 0 : 1);
}
}
3.7 Map&Reduce总结
1、 InputFormat
1）默认的是TextInputformat kv key偏移量，v :一行内容
2）处理小文件combineTextInputFormat把多个文件合并到一起统一切片
2、Mapper
setup()；初始化; map()用户的业务逻辑; clearup()关闭资源;
3、分区
默认分区HashPartitioner ，默认按照key的hash值%numreducetask个数自定义分区
4、排子
1）部分排序 每个输出的文件内部有序。
2）全排序 一个reduce ,对所有数据大排序。
3）二次排序:自定义排序范畴，实现 writableCompare接口，重写comparero方法
5、Combiner
前提:不影响最终的业务逻辑（求平均值有影响）
提前聚合map =>解决数据倾斜的一个方法
6、Reducer
用户的业务逻辑;
setup ()初始化; reduce ()用户的业务逻辑; clearup()关闭资源;
4、Hadoop数据压缩
4.1 概述
1）压缩的好处和坏处
压缩的优点：以减少磁盘IO、减少磁盘存储空间。
压缩的缺点：增加CPU开销。
2）压缩原则
（1）运算密集型的Job，少用压缩
（2）IO密集型的Job，多用压缩
4.2 MR支持的压缩编码
1）压缩算法对比介绍
| 压缩格式 | Hadoop自带？ | 算法 | 文件扩展名 | 是否可切片 | 换成压缩格式后，原来的程序是否需要修改 |
|---|---|---|---|---|---|
| DEFLATE | 是，直接使用 | DEFLATE | .deflate | 否 | 和文本处理一样，不需要修改 |
| Gzip | 是，直接使用 | DEFLATE | .gz | 否 | 和文本处理一样，不需要修改 |
| bzip2 | 是，直接使用 | bzip2 | .bz2 | 是 | 和文本处理一样，不需要修改 |
| LZO | 否，需要安装 | LZO | .lzo | 是 | 需要建索引，还需要指定输入格式 |
| Snappy | 是，直接使用 | Snappy | .snappy | 否 | 和文本处理一样，不需要修改 |
2）压缩性能的比较
| 压缩算法 | 原始文件大小 | 压缩文件大小 | 压缩速度 | 解压速度 |
|---|---|---|---|---|
| gzip | 8.3GB | 1.8GB | 17.5MB/s | 58MB/s |
| bzip2 | 8.3GB | 1.1GB | 2.4MB/s | 9.5MB/s |
| LZO | 8.3GB | 2.9GB | 49.3MB/s | 74.6MB/s |
http://google.github.io/snappy/
Snappy is a compression/decompression library. It does not aim for maximum compression, or compatibility with any other compression library; instead, it aims for very high speeds and reasonable compression. For instance, compared to the fastest mode of zlib, Snappy is an order of magnitude faster for most inputs, but the resulting compressed files are anywhere from 20% to 100% bigger.On a single core of a Core i7 processor in 64-bit mode, Snappy compresses at about 250 MB/sec or more and decompresses at about 500 MB/sec or more.
4.3 压缩方式选择
压缩方式选择时重点考虑：压缩/解压缩速度、压缩率（压缩后存储大小）、压缩后是否可以支持切片。
4.3.1 Gzip压缩
优点：压缩率比较高；
缺点：不支持Split；压缩/解压速度一般；
4.3.2 Bzip2压缩
优点：压缩率高；支持Split；
缺点：压缩/解压速度慢。
4.3.3 Lzo压缩
优点：压缩/解压速度比较快；支持Split；
缺点：压缩率一般；想支持切片需要额外创建索引。
4.3.4 Snappy压缩
优点：压缩和解压缩速度快；
缺点：不支持Split；压缩率一般；
4.3.5 压缩位置选择
压缩可以在MapReduce作用的任意阶段启用。
4.4 压缩参数配置
1）为了支持多种压缩/解压缩算法，Hadoop引入了编码/解码器
| 压缩格式 | 对应的编码/解码器 |
|---|---|
| DEFLATE | org.apache.hadoop.io.compress.DefaultCodec |
| gzip | org.apache.hadoop.io.compress.GzipCodec |
| bzip2 | org.apache.hadoop.io.compress.BZip2Codec |
| LZO | com.hadoop.compression.lzo.LzopCodec |
| Snappy | org.apache.hadoop.io.compress.SnappyCodec |
2）要在Hadoop中启用压缩，可以配置如下参数
| 参数 | 默认值 | 阶段 | 建议 |
|---|---|---|---|
| io.compression.codecs （在core-site.xml中配置） | 无，这个需要在命令行输入hadoop checknative查看 | 输入压缩 | Hadoop使用文件扩展名判断是否支持某种编解码器 |
| mapreduce.map.output.compress（在mapred-site.xml中配置） | false | mapper输出 | 这个参数设为true启用压缩 |
| mapreduce.map.output.compress.codec（在mapred-site.xml中配置） | org.apache.hadoop.io.compress.DefaultCodec | mapper输出 | 企业多使用LZO或Snappy编解码器在此阶段压缩数据 |
| mapreduce.output.fileoutputformat.compress（在mapred-site.xml中配置） | false | reducer输出 | 这个参数设为true启用压缩 |
| mapreduce.output.fileoutputformat.compress.codec（在mapred-site.xml中配置） | org.apache.hadoop.io.compress.DefaultCodec | reducer输出 | 使用标准工具或者编解码器，如gzip和bzip2 |
#查看支持的压缩方式
[fuhong@linux201 ~]$ hadoop checknative
4.5 压缩实操案例
4.5.1 Map输出端采用压缩
即使你的MapReduce的输入输出文件都是未压缩的文件，你仍然可以对Map任务的中间结果输出做压缩，因为它要写在硬盘并且通过网络传输到Reduce节点，对其压缩可以提高很多性能，这些工作只要设置两个属性即可，我们来看下代码怎么设置。
1）给大家提供的Hadoop源码支持的压缩格式有：BZip2Codec、DefaultCodec
wordcount案例上修改driver
import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.fs.Path;
import org.apache.hadoop.io.IntWritable;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.io.compress.BZip2Codec;
import org.apache.hadoop.io.compress.CompressionCodec;
import org.apache.hadoop.mapreduce.Job;
import org.apache.hadoop.mapreduce.lib.input.FileInputFormat;
import org.apache.hadoop.mapreduce.lib.output.FileOutputFormat;
import java.io.IOException;
/**
* @author fuhong
* @description WordCountDriver
* @date 2022/1/18 16:56
*/
public class WordCountDriver {
public static void main(String[] args) throws IOException, InterruptedException, ClassNotFoundException {
//1.获取job
Configuration conf = new Configuration();
// 开启map端输出压缩
conf.setBoolean("mapreduce.map.output.compress", true);
// 设置map端输出压缩方式
conf.setClass("mapreduce.map.output.compress.codec", BZip2Codec.class, CompressionCodec.class);
Job job = Job.getInstance(conf);
//2.设置jar包路径
job.setJarByClass(WordCountDriver.class);
//3.管mapper和reducer
job.setMapperClass(WordCountMapper.class);
job.setReducerClass(WordCountReducer.class);
//4.设置map输出的kv类型
job.setMapOutputKeyClass(Text.class);
job.setMapOutputValueClass(IntWritable.class);
//5.输出最终的kv类型
job.setOutputKeyClass(Text.class);
job.setOutputValueClass(IntWritable.class);
//6.设置输入路径和输出路径
FileInputFormat.setInputPaths(job, new Path("D:\\learn\\input\\hadoop\\compress"));
FileOutputFormat.setOutputPath(job, new Path("D:\\learn\\output\\hadoop\\compress"));
//7.提交job
//获取job信息
boolean result = job.waitForCompletion(true);
System.exit(result ? 0 : 1);
}
}
2）Mapper保持不变 wordcount案例 代码略
3）Reducer保持不变 wordcount案例 代码略
4.5.2 Reduce输出端采用压缩
基于WordCount案例处理。
1）修改驱动
import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.fs.Path;
import org.apache.hadoop.io.IntWritable;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.io.compress.BZip2Codec;
import org.apache.hadoop.mapreduce.Job;
import org.apache.hadoop.mapreduce.lib.input.FileInputFormat;
import org.apache.hadoop.mapreduce.lib.output.FileOutputFormat;
import java.io.IOException;
/**
* @author fuhong
* @description WordCountDriver
* @date 2022/1/18 16:56
*/
public class WordCountDriver {
public static void main(String[] args) throws IOException, InterruptedException, ClassNotFoundException {
//1.获取job
Configuration conf = new Configuration();
// // 开启map端输出压缩
// conf.setBoolean("mapreduce.map.output.compress", true);
//
// // 设置map端输出压缩方式
// conf.setClass("mapreduce.map.output.compress.codec", BZip2Codec.class, CompressionCodec.class);
Job job = Job.getInstance(conf);
//2.设置jar包路径
job.setJarByClass(WordCountDriver.class);
//3.管mapper和reducer
job.setMapperClass(WordCountMapper.class);
job.setReducerClass(WordCountReducer.class);
//4.设置map输出的kv类型
job.setMapOutputKeyClass(Text.class);
job.setMapOutputValueClass(IntWritable.class);
//5.输出最终的kv类型
job.setOutputKeyClass(Text.class);
job.setOutputValueClass(IntWritable.class);
//6.设置输入路径和输出路径
FileInputFormat.setInputPaths(job, new Path("D:\\learn\\input\\hadoop\\compress"));
FileOutputFormat.setOutputPath(job, new Path("D:\\learn\\output\\hadoop\\compress"));
// 设置reduce端输出压缩开启
FileOutputFormat.setCompressOutput(job, true);
// 设置压缩的方式
FileOutputFormat.setOutputCompressorClass(job, BZip2Codec.class);
// FileOutputFormat.setOutputCompressorClass(job, GzipCodec.class);
// FileOutputFormat.setOutputCompressorClass(job, DefaultCodec.class);
//7.提交job
//获取job信息
boolean result = job.waitForCompletion(true);
System.exit(result ? 0 : 1);
}
}
2）Mapper保持不变 wordcount案例 代码略
3）Reducer保持不变 wordcount案例 代码略
5、常见错误及解决方案
1）导包容易出错。尤其Text和CombineTextInputFormat。
2）Mapper中第一个输入的参数必须是LongWritable或者NullWritable，不可以是IntWritable. 报的错误是类型转换异常。
3）java.lang.Exception: java.io.IOException: Illegal partition for 13926435656 (4)，说明Partition和ReduceTask个数没对上，调整ReduceTask个数。
4）如果分区数不是1，但是reducetask为1，是否执行分区过程。答案是：不执行分区过程。因为在MapTask的源码中，执行分区的前提是先判断ReduceNum个数是否大于1。不大于1肯定不执行。
5）在Windows环境编译的jar包导入到Linux环境中运行，
hadoop jar wc.jar com.fuhong.mapreduce.wordcount.WordCountDriver /user/fuhong/ /user/fuhong/output
报如下错误：
Exception in thread "main" java.lang.UnsupportedClassVersionError: com/fuhong/mapreduce/wordcount/WordCountDriver : Unsupported major.minor version 52.0
原因是Windows环境用的jdk1.7，Linux环境用的jdk1.8。
解决方案：统一jdk版本。
6）缓存pd.txt小文件案例中，报找不到pd.txt文件
原因：大部分为路径书写错误。还有就是要检查pd.txt.txt的问题。还有个别电脑写相对路径找不到pd.txt，可以修改为绝对路径。
7）报类型转换异常。
通常都是在驱动函数中设置Map输出和最终输出时编写错误。
Map输出的key如果没有排序，也会报类型转换异常。
8）集群中运行wc.jar时出现了无法获得输入文件。
原因：WordCount案例的输入文件不能放用HDFS集群的根目录。
9）出现了如下相关异常
Exception in thread "main" java.lang.UnsatisfiedLinkError: org.apache.hadoop.io.nativeio.NativeIO$Windows.access0(Ljava/lang/String;I)Z
at org.apache.hadoop.io.nativeio.NativeIO$Windows.access0(Native Method)
at org.apache.hadoop.io.nativeio.NativeIO$Windows.access(NativeIO.java:609)
at org.apache.hadoop.fs.FileUtil.canRead(FileUtil.java:977)
java.io.IOException: Could not locate executable null\bin\winutils.exe in the Hadoop binaries.
at org.apache.hadoop.util.Shell.getQualifiedBinPath(Shell.java:356)
at org.apache.hadoop.util.Shell.getWinUtilsPath(Shell.java:371)
at org.apache.hadoop.util.Shell.<clinit>(Shell.java:364)
解决方案：拷贝hadoop.dll文件到Windows目录C:\Windows\System32。个别同学电脑还需要修改Hadoop源码。
方案二：创建如下包名，并将NativeIO.java拷贝到该包名下
10）自定义Outputformat时，注意在RecordWirter中的close方法必须关闭流资源。否则输出的文件内容中数据为空。
@Override
public void close(TaskAttemptContext context) throws IOException, InterruptedException {
if (fuhongfos != null) {
fuhongfos.close();
}
if (otherfos != null) {
otherfos.close();
}
}
四、Yarn
1、Yarn资源调度器
思考：
1）如何管理集群资源？
2）如何给任务合理分配资源？
Yarn是一个资源调度平台，负责为运算程序提供服务器运算资源，相当于一个分布式的操作系统平台，而MapReduce等运算程序则相当于运行于操作系统之上的应用程序。
1.1 Yarn基础架构
YARN主要由ResourceManager、NodeManager、ApplicationMaster和Container等组件构成。
1.2 Yarn工作机制
（1）MR程序提交到客户端所在的节点。
（2）YarnRunner向ResourceManager申请一个Application。
（3）RM将该应用程序的资源路径返回给YarnRunner。
（4）该程序将运行所需资源提交到HDFS上。
（5）程序资源提交完毕后，申请运行mrAppMaster。
（6）RM将用户的请求初始化成一个Task。
（7）其中一个NodeManager领取到Task任务。
（8）该NodeManager创建容器Container，并产生MRAppmaster。
（9）Container从HDFS上拷贝资源到本地。
（10）MRAppmaster向RM 申请运行MapTask资源。
（11）RM将运行MapTask任务分配给另外两个NodeManager，另两个NodeManager分别领取任务并创建容器。
（12）MR向两个接收到任务的NodeManager发送程序启动脚本，这两个NodeManager分别启动MapTask，MapTask对数据分区排序。
（13）MrAppMaster等待所有MapTask运行完毕后，向RM申请容器，运行ReduceTask。
（14）ReduceTask向MapTask获取相应分区的数据。
（15）程序运行完毕后，MR会向RM申请注销自己。
1.3 作业提交全过程
HDFS、YARN、MapReduce三者关系
作业提交过程YARN
作业提交过程之HDFS&MapReduce
作业提交全过程详解
（1）作业提交
第1步：Client调用job.waitForCompletion方法，向整个集群提交MapReduce作业。
第2步：Client向RM申请一个作业id。
第3步：RM给Client返回该job资源的提交路径和作业id。
第4步：Client提交jar包、切片信息和配置文件到指定的资源提交路径。
第5步：Client提交完资源后，向RM申请运行MrAppMaster。
（2）作业初始化
第6步：当RM收到Client的请求后，将该job添加到容量调度器中。
第7步：某一个空闲的NM领取到该Job。
第8步：该NM创建Container，并产生MRAppmaster。
第9步：下载Client提交的资源到本地。
（3）任务分配
第10步：MrAppMaster向RM申请运行多个MapTask任务资源。
第11步：RM将运行MapTask任务分配给另外两个NodeManager，另两个NodeManager分别领取任务并创建容器。
（4）任务运行
第12步：MR向两个接收到任务的NodeManager发送程序启动脚本，这两个NodeManager分别启动MapTask，MapTask对数据分区排序。
第13步：MrAppMaster等待所有MapTask运行完毕后，向RM申请容器，运行ReduceTask。
第14步：ReduceTask向MapTask获取相应分区的数据。
第15步：程序运行完毕后，MR会向RM申请注销自己。
（5）进度和状态更新
YARN中的任务将其进度和状态(包括counter)返回给应用管理器, 客户端每秒(通过mapreduce.client.progressmonitor.pollinterval设置)向应用管理器请求进度更新, 展示给用户。
（6）作业完成
除了向应用管理器请求作业进度外, 客户端每5秒都会通过调用waitForCompletion()来检查作业是否完成。时间间隔可以通过mapreduce.client.completion.pollinterval来设置。作业完成之后, 应用管理器和Container会清理工作状态。作业的信息会被作业历史服务器存储以备之后用户核查。
1.4 Yarn调度器和调度算法
目前，Hadoop作业调度器主要有三种：FIFO、容量（Capacity Scheduler）和公平（Fair Scheduler）。Apache Hadoop3.1.3默认的资源调度器是Capacity Scheduler。
CDH框架默认调度器是Fair Scheduler。
具体设置详见：yarn-default.xml文件
<property>
<description>The class to use as the resource scheduler.</description>
<name>yarn.resourcemanager.scheduler.class</name>
<value>org.apache.hadoop.yarn.server.resourcemanager.scheduler.capacity.CapacityScheduler</value>
</property>
1.4.1 先进先出调度器（FIFO）(开发中一般不会用)
FIFO调度器（First In First Out）：单队列，根据提交作业的先后顺序，先来先服务。
优点：简单易懂；
缺点：不支持多队列，生产环境很少使用；
1.4.2 容量调度器（Capacity Scheduler）
Capacity Scheduler是Yahoo开发的多用户调度器。被较多使用
1、多队列:每个队列可配置一定的资源量，每个队列采用FIFO调度策略。
2、容量保证:管理员可为每个队列设置资源最低保证和资源使用上限
3、灵活性:如果一个队列中的资源有剩余，可以暂时共享给那些需要资源的队列，而一旦该队列有新的应用程序提交，则其他队列借调的资源会归还给该队列。
4、多租户:
支持多用户共享集群和多应用程序同时运行。
为了防止同一个用户的作业独占队列中的资源，该调度器会对同一用户提交的作业所占资源量进行限定。
容量调度器资源分配算法
1.4.3 公平调度器（Fair Scheduler）
Fair Schedulere是Facebook开发的多用户调度器。
公平调度器特点
1)与容量调度器相同点
(1)多队列:支持多队列多作业
(2)容量保证:管理员可为每个队列设置资源最低保证和资源使用上线
(3）灵活性:如果一个队列中的资源有剩余，可以暂时共享给那些需要资源的队列，而一旦该队列有新的应用程序提交，则其他队列借调的资源会归还给该队列。
(4)多租户:支持多用户共享集群和多应用程序同时运行;为了防止同一个用户的作业独占队列中的资源，该调度器会对同一用户提交的作业所占资源量进行限定。
2)与容量调度器不同点
(1）核心调度策略不同
容量调度器:优先选择资源利用率低的队列公平调度器:优先选择对资源的缺额比例大的
(2)每个队列可以单独设置资源分配方式
容量调度器:FIFO、DRF
公平调度器:FIFO、FAIR、DRF
公平调度器–缺额
（1）公平调度器设计目标是:在时间尺度上，所有作业获得公平的资源。某一时刻一个作业应获资源和实际获取资源的差距叫“缺额”
（2）调度器会优先为缺额大的作业分配资源
公平调度器队列资源分配方式
公平调度器资源分配算法（队列资源分配）
公平调度器队列资源分配方式
不加权 ：绝对公平
1.5 Yarn常用命令
Yarn状态的查询，除了可以在hadoop103:8088页面查看外，还可以通过命令操作。常见的命令操作如下所示：
需求：执行WordCount案例，并用Yarn命令查看任务运行情况。
[fuhong@linux201 ~]$ myhadoop.sh start
[fuhong@linux201 ~]$ cd /opt/module/hadoop-3.1.3/
[fuhong@linux201 hadoop-3.1.3]$ hadoop jar share/hadoop/mapreduce/hadoop-mapreduce-examples-3.1.3.jar wordcount /input /output1
1.5.1 yarn application查看任务
（1）列出所有Application：
[fuhong@linux201 hadoop-3.1.3]$ yarn application -list
#如果有任务在运行中
2022-05-30 15:07:57,240 INFO client.RMProxy: Connecting to ResourceManager at linux202/192.168.10.202:8032
Total number of applications (application-types: [], states: [SUBMITTED, ACCEPTED, RUNNING] and tags: []):0
Application-Id Application-Name Application-Type User Queue State Final-State Progress Tracking-URL
（2）根据Application状态过滤：yarn application -list -appStates （所有状态：ALL、NEW、NEW_SAVING、SUBMITTED、ACCEPTED、RUNNING、FINISHED、FAILED、KILLED）
[fuhong@linux201 hadoop-3.1.3]$ yarn application -list -appStates FINISHED
2022-05-30 15:16:29,180 INFO client.RMProxy: Connecting to ResourceManager at linux202/192.168.10.202:8032
Total number of applications (application-types: [], states: [FINISHED] and tags: []):1
Application-Id Application-Name Application-Type User Queue State Final-State Progress Tracking-URL
application_1653876692101_0001 word count MAPREDUCE fuhong default FINISHED SUCCEEDED 100% http://linux201:19888/jobhistory/job/job_1653876692101_0001
（3）Kill掉Application
[fuhong@linux201 hadoop-3.1.3]$ yarn application -kill application_1653876692101_0001
2022-05-30 15:19:39,390 INFO client.RMProxy: Connecting to ResourceManager at linux202/192.168.10.202:8032
Application application_1653876692101_0001 has already finished
1.5.2 yarn logs查看日志
（1）查询Application日志：yarn logs -applicationId
[fuhong@linux201 hadoop-3.1.3]$ yarn logs -applicationId application_1653876692101_0001
（2）查询Container日志：yarn logs -applicationId -containerId
[fuhong@linux201 hadoop-3.1.3]$ yarn logs -applicationId application_1653876692101_0001 -containerId container_1653876692101_0001_01_000001
1.5.3 yarn applicationattempt查看尝试运行的任务
（1）列出所有Application尝试的列表：yarn applicationattempt -list
[fuhong@linux201 hadoop-3.1.3]$ yarn applicationattempt -list application_1653876692101_0001
2022-05-30 15:42:06,431 INFO client.RMProxy: Connecting to ResourceManager at linux202/192.168.10.202:8032
Total number of application attempts :1
ApplicationAttempt-Id State AM-Container-Id Tracking-URL
appattempt_1653876692101_0001_000001 FINISHED container_1653876692101_0001_01_000001 http://linux202:8088/proxy/application_1653876692101_0001/
（2）打印ApplicationAttemp状态：yarn applicationattempt -status
[fuhong@linux201 hadoop-3.1.3]$ yarn applicationattempt -status appattempt_1653876692101_0001_000001
2022-05-30 15:46:01,715 INFO client.RMProxy: Connecting to ResourceManager at linux202/192.168.10.202:8032
Application Attempt Report :
ApplicationAttempt-Id : appattempt_1653876692101_0001_000001
State : FINISHED
AMContainer : container_1653876692101_0001_01_000001
Tracking-URL : http://linux202:8088/proxy/application_1653876692101_0001/
RPC Port : 35574
AM Host : linux203
Diagnostics :
1.5.4 yarn container查看容器
（1）列出所有Container：yarn container -list
[fuhong@linux201 hadoop-3.1.3]$ yarn container -list appattempt_1653876692101_0001_000001
2022-05-30 15:48:07,899 INFO client.RMProxy: Connecting to ResourceManager at linux202/192.168.10.202:8032
Total number of containers :0
Container-Id Start Time Finish Time State Host Node Http Address LOG-URL
（2）打印Container状态： yarn container -status
[fuhong@linux201 hadoop-3.1.3]$ yarn container -status container_1653876692101_0001_01_000001
2022-05-30 15:51:20,496 INFO client.RMProxy: Connecting to ResourceManager at linux202/192.168.10.202:8032
Container with id 'container_1653876692101_0001_01_000001' doesn't exist in RM or Timeline Server.
注：只有在任务跑的途中才能看到container的状态
1.5.5 yarn node查看节点状态
列出所有节点：yarn node -list -all
[fuhong@linux201 hadoop-3.1.3]$ yarn node -list -all
2022-05-30 15:52:53,031 INFO client.RMProxy: Connecting to ResourceManager at linux202/192.168.10.202:8032
Total Nodes:3
Node-Id Node-State Node-Http-Address Number-of-Running-Containers
linux201:45480 RUNNING linux201:8042 0
linux203:39657 RUNNING linux203:8042 0
linux202:40351 RUNNING linux202:8042 0
1.5.6 yarn rmadmin更新配置
加载队列配置：yarn rmadmin -refreshQueues
队列信息发生变化，直接执行此命令 不需重启
[fuhong@linux201 hadoop-3.1.3]$ yarn rmadmin -refreshQueues
2022-05-30 15:54:17,914 INFO client.RMProxy: Connecting to ResourceManager at linux202/192.168.10.202:8033
1.5.7 yarn queue查看队列
打印队列信息：yarn queue -status
[fuhong@linux201 hadoop-3.1.3]$ yarn queue -status default
2022-05-30 15:56:16,254 INFO client.RMProxy: Connecting to ResourceManager at linux202/192.168.10.202:8032
Queue Information :
Queue Name : default
State : RUNNING
Capacity : 100.0%
Current Capacity : .0%
Maximum Capacity : 100.0%
Default Node Label expression : <DEFAULT_PARTITION>
Accessible Node Labels : *
Preemption : disabled
Intra-queue Preemption : disabled
1.6 Yarn生产环境核心参数
2、Yarn案例实操
注：调整下列参数之前尽量拍摄Linux快照，否则后续的案例，还需要重写准备集群。
直接虚拟机拍摄快照
2.1 Yarn生产环境核心参数配置案例
1）需求：从1G数据中，统计每个单词出现次数。服务器3台，每台配置4G内存，4核CPU，4线程。
2）需求分析：
1G / 128m = 8个MapTask；1个ReduceTask；1个mrAppMaster
平均每个节点运行10个 / 3台 ≈ 3个任务（4 3 3）
3）修改yarn-site.xml配置参数如下：
[fuhong@linux201 hadoop-3.1.3]$ cd etc/hadoop/
#修改配置文件 加入以下信息
[fuhong@linux201 hadoop]$ vim yarn-site.xml
[fuhong@linux201 hadoop]$ xsync yarn-site.xml
<!-- 选择调度器，默认容量 -->
<property>
<description>The class to use as the resource scheduler.</description>
<name>yarn.resourcemanager.scheduler.class</name>
<value>org.apache.hadoop.yarn.server.resourcemanager.scheduler.capacity.CapacityScheduler</value>
</property>
<!-- ResourceManager处理调度器请求的线程数量,默认50；如果提交的任务数大于50，可以增加该值，但是不能超过3台 * 4线程 = 12线程（去除其他应用程序实际不能超过8） -->
<property>
<description>Number of threads to handle scheduler interface.</description>
<name>yarn.resourcemanager.scheduler.client.thread-count</name>
<value>8</value>
</property>
<!-- 是否让yarn自动检测硬件进行配置，默认是false，如果该节点有很多其他应用程序，建议手动配置。如果该节点没有其他应用程序，可以采用自动 -->
<property>
<description>Enable auto-detection of node capabilities such as
memory and CPU.
</description>
<name>yarn.nodemanager.resource.detect-hardware-capabilities</name>
<value>false</value>
</property>
<!-- 是否将虚拟核数当作CPU核数，默认是false，采用物理CPU核数 -->
<property>
<description>Flag to determine if logical processors(such as
hyperthreads) should be counted as cores. Only applicable on Linux
when yarn.nodemanager.resource.cpu-vcores is set to -1 and
yarn.nodemanager.resource.detect-hardware-capabilities is true.
</description>
<name>yarn.nodemanager.resource.count-logical-processors-as-cores</name>
<value>false</value>
</property>
<!-- 虚拟核数和物理核数乘数，默认是1.0 -->
<property>
<description>Multiplier to determine how to convert phyiscal cores to
vcores. This value is used if yarn.nodemanager.resource.cpu-vcores
is set to -1(which implies auto-calculate vcores) and
yarn.nodemanager.resource.detect-hardware-capabilities is set to true. The number of vcores will be calculated as number of CPUs * multiplier.
</description>
<name>yarn.nodemanager.resource.pcores-vcores-multiplier</name>
<value>1.0</value>
</property>
<!-- NodeManager使用内存数，默认8G，修改为4G内存 -->
<property>
<description>Amount of physical memory, in MB, that can be allocated
for containers. If set to -1 and
yarn.nodemanager.resource.detect-hardware-capabilities is true, it is
automatically calculated(in case of Windows and Linux).
In other cases, the default is 8192MB.
</description>
<name>yarn.nodemanager.resource.memory-mb</name>
<value>4096</value>
</property>
<!-- nodemanager的CPU核数，不按照硬件环境自动设定时默认是8个，修改为4个 -->
<property>
<description>Number of vcores that can be allocated
for containers. This is used by the RM scheduler when allocating
resources for containers. This is not used to limit the number of
CPUs used by YARN containers. If it is set to -1 and
yarn.nodemanager.resource.detect-hardware-capabilities is true, it is
automatically determined from the hardware in case of Windows and Linux.
In other cases, number of vcores is 8 by default.</description>
<name>yarn.nodemanager.resource.cpu-vcores</name>
<value>4</value>
</property>
<!-- 容器最小内存，默认1G -->
<property>
<description>The minimum allocation for every container request at the RM in MBs. Memory requests lower than this will be set to the value of this property. Additionally, a node manager that is configured to have less memory than this value will be shut down by the resource manager.
</description>
<name>yarn.scheduler.minimum-allocation-mb</name>
<value>1024</value>
</property>
<!-- 容器最大内存，默认8G，修改为2G -->
<property>
<description>The maximum allocation for every container request at the RM in MBs. Memory requests higher than this will throw an InvalidResourceRequestException.
</description>
<name>yarn.scheduler.maximum-allocation-mb</name>
<value>2048</value>
</property>
<!-- 容器最小CPU核数，默认1个 -->
<property>
<description>The minimum allocation for every container request at the RM in terms of virtual CPU cores. Requests lower than this will be set to the value of this property. Additionally, a node manager that is configured to have fewer virtual cores than this value will be shut down by the resource manager.
</description>
<name>yarn.scheduler.minimum-allocation-vcores</name>
<value>1</value>
</property>
<!-- 容器最大CPU核数，默认4个，修改为2个 -->
<property>
<description>The maximum allocation for every container request at the RM in terms of virtual CPU cores. Requests higher than this will throw an
InvalidResourceRequestException.</description>
<name>yarn.scheduler.maximum-allocation-vcores</name>
<value>2</value>
</property>
<!-- 虚拟内存检查，默认打开，修改为关闭 -->
<property>
<description>Whether virtual memory limits will be enforced for
containers.</description>
<name>yarn.nodemanager.vmem-check-enabled</name>
<value>false</value>
</property>
<!-- 虚拟内存和物理内存设置比例,默认2.1 -->
<property>
<description>Ratio between virtual memory to physical memory when setting memory limits for containers. Container allocations are expressed in terms of physical memory, and virtual memory usage is allowed to exceed this allocation by this ratio.
</description>
<name>yarn.nodemanager.vmem-pmem-ratio</name>
<value>2.1</value>
</property>
关闭虚拟内存检查原因 解决java8和centos7各自为政导致内存问题
4）分发配置。
注意：如果集群的硬件资源不一致，要每个NodeManager单独配置
5）重启集群
[fuhong@linux201 hadoop]$ myhadoop.sh stop
[fuhong@linux201 hadoop]$ myhadoop.sh start
6）执行WordCount程序
[fuhong@linux201 hadoop-3.1.3]$ hadoop jar share/hadoop/mapreduce/hadoop-mapreduce-examples-3.1.3.jar wordcount /input /output2
7）观察Yarn任务执行页面
http://linux202:8088/cluster
2.2 容量调度器多队列提交案例
1）在生产环境怎么创建队列？
（1）调度器默认就1个default队列，不能满足生产要求。
（2）按照框架：hive /spark/ flink 每个框架的任务放入指定的队列（企业用的不是特别多）
（3）按照业务模块：登录注册、购物车、下单、业务部门1、业务部门2
2）创建多队列的好处？
（1）因为担心员工不小心，写递归死循环代码，把所有资源全部耗尽。
（2）实现任务的降级使用，特殊时期保证重要的任务队列资源充足。11.11 6.18
业务部门1（重要）=》业务部门2（比较重要）=》下单（一般）=》购物车（一般）=》登录注册（次要）
2.2.1 需求
需求1：default队列占总内存的40%，最大资源容量占总资源60%，hive队列占总内存的60%，最大资源容量占总资源80%。
需求2：配置队列优先级
2.2.2 配置多队列的容量调度器
1）在capacity-scheduler.xml中配置如下：
default队列有的配置 hive都有
[fuhong@linux201 hadoop-3.1.3]$ cd etc/hadoop/
（1）修改如下配置
<!-- 指定多队列，增加hive队列 -->
<property>
<name>yarn.scheduler.capacity.root.queues</name>
<value>default,hive</value>
<description>
The queues at the this level (root is the root queue).
</description>
</property>
<!-- 降低default队列资源额定容量为40%，默认100% -->
<property>
<name>yarn.scheduler.capacity.root.default.capacity</name>
<value>40</value>
</property>
<!-- 降低default队列资源最大容量为60%，默认100% -->
<property>
<name>yarn.scheduler.capacity.root.default.maximum-capacity</name>
<value>60</value>
</property>
（2）为新加队列添加必要属性
<!-- 指定hive队列的资源额定容量 -->
<property>
<name>yarn.scheduler.capacity.root.hive.capacity</name>
<value>60</value>
</property>
<!-- 用户最多可以使用队列多少资源，1表示 -->
<property>
<name>yarn.scheduler.capacity.root.hive.user-limit-factor</name>
<value>1</value>
</property>
<!-- 指定hive队列的资源最大容量 -->
<property>
<name>yarn.scheduler.capacity.root.hive.maximum-capacity</name>
<value>80</value>
</property>
<!-- 启动hive队列 -->
<property>
<name>yarn.scheduler.capacity.root.hive.state</name>
<value>RUNNING</value>
</property>
<!-- 哪些用户有权向队列提交作业 -->
<property>
<name>yarn.scheduler.capacity.root.hive.acl_submit_applications</name>
<value>*</value>
</property>
<!-- 哪些用户有权操作队列，管理员权限（查看/杀死） -->
<property>
<name>yarn.scheduler.capacity.root.hive.acl_administer_queue</name>
<value>*</value>
</property>
<!-- 哪些用户有权配置提交任务优先级 -->
<property>
<name>yarn.scheduler.capacity.root.hive.acl_application_max_priority</name>
<value>*</value>
</property>
<!-- 任务的超时时间设置：yarn application -appId appId -updateLifetime Timeout
参考资料：https://blog.cloudera.com/enforcing-application-lifetime-slas-yarn/ -->
<!-- 如果application指定了超时时间，则提交到该队列的application能够指定的最大超时时间不能超过该值。
-->
<property>
<name>yarn.scheduler.capacity.root.hive.maximum-application-lifetime</name>
<value>-1</value>
</property>
<!-- 如果application没指定超时时间，则用default-application-lifetime作为默认值 -->
<property>
<name>yarn.scheduler.capacity.root.hive.default-application-lifetime</name>
<value>-1</value>
</property>
2）分发配置文件
[fuhong@linux201 hadoop]$ xsync capacity-scheduler.xml
3）重启Yarn或者执行yarn rmadmin -refreshQueues刷新队列，就可以看到两条队列：
http://linux202:8088/cluster/scheduler
[fuhong@linux201 hadoop]$ yarn rmadmin -refreshQueues
2.2.3 向Hive队列提交任务
1）hadoop jar的方式
[fuhong@linux201 hadoop-3.1.3]$ hadoop jar share/hadoop/mapreduce/hadoop-mapreduce-examples-3.1.3.jar wordcount -D mapreduce.job.queuename=hive /input /output
2）打jar包的方式
默认的任务提交都是提交到default队列的。如果希望向其他队列提交任务，需要在Driver中声明
public class WcDrvier {
public static void main(String[] args) throws IOException, ClassNotFoundException, InterruptedException {
Configuration conf = new Configuration();
conf.set("mapreduce.job.queuename","hive");
//1. 获取一个Job实例
Job job = Job.getInstance(conf);
。。。 。。。
//6. 提交Job
boolean b = job.waitForCompletion(true);
System.exit(b ? 0 : 1);
}
}
2.2.4 任务优先级
容量调度器，支持任务优先级的配置，在资源紧张时，优先级高的任务将优先获取资源。默认情况，Yarn将所有任务的优先级限制为0，若想使用任务的优先级功能，须开放该限制。
1）修改yarn-site.xml文件，增加以下参数
<property>
<name>yarn.cluster.max-application-priority</name>
<value>5</value>
</property>
2）分发配置，并重启Yarn
[fuhong@linux202 hadoop]$ cd /opt/module/hadoop-3.1.3/etc/hadoop/
[fuhong@linux202 hadoop]$ vim yarn-site.xml
[fuhong@linux202 hadoop]$ xsync yarn-site.xml
[fuhong@linux202 hadoop]$ sbin/stop-yarn.sh
[fuhong@linux202 sbin]$ cd /opt/module/hadoop-3.1.3/
[fuhong@linux202 hadoop-3.1.3]$ sbin/stop-yarn.sh
[fuhong@linux202 hadoop-3.1.3]$ sbin/start-yarn.sh
3）模拟资源紧张环境，可连续提交以下任务，直到新提交的任务申请不到资源为止。
[fuhong@linux202 hadoop-3.1.3]$ hadoop jar /opt/module/hadoop-3.1.3/share/hadoop/mapreduce/hadoop-mapreduce-examples-3.1.3.jar pi 5 2000000
4）再次重新提交优先级高的任务
[fuhong@linux203 ~]$ hadoop jar /opt/module/hadoop-3.1.3/share/hadoop/mapreduce/hadoop-mapreduce-examples-3.1.3.jar pi -D mapreduce.job.priority=5 5 2000000
5）也可以通过以下命令修改正在执行的任务的优先级。
yarn application -appID -updatePriority 优先级
[fuhong@linux202 hadoop-3.1.3]$ yarn application -appID application_1653963957298_0004 -updatePriority 5
2.3 公平调度器案例
2.3.1 需求
创建两个队列，分别是test和fuhong（以用户所属组命名）。期望实现以下效果：若用户提交任务时指定队列，则任务提交到指定队列运行；若未指定队列，test用户提交的任务到root.group.test队列运行，fuhong提交的任务到root.group.fuhong队列运行（注：group为用户所属组）。
公平调度器的配置涉及到两个文件，一个是yarn-site.xml，另一个是公平调度器队列分配文件fair-scheduler.xml（文件名可自定义）。
（1）配置文件参考资料：
https://hadoop.apache.org/docs/r3.1.3/hadoop-yarn/hadoop-yarn-site/FairScheduler.html
（2）任务队列放置规则参考资料：
https://blog.cloudera.com/untangling-apache-hadoop-yarn-part-4-fair-scheduler-queue-basics/
2.3.2 配置多队列的公平调度器
1）修改yarn-site.xml文件，加入以下参数
[fuhong@linux202 hadoop-3.1.3]$ cd /opt/module/hadoop-3.1.3/etc/hadoop/
[fuhong@linux202 hadoop]$ vim yarn-site.xml
<property>
<name>yarn.resourcemanager.scheduler.class</name>
<value>org.apache.hadoop.yarn.server.resourcemanager.scheduler.fair.FairScheduler</value>
<description>配置使用公平调度器</description>
</property>
<property>
<name>yarn.scheduler.fair.allocation.file</name>
<value>/opt/module/hadoop-3.1.3/etc/hadoop/fair-scheduler.xml</value>
<description>指明公平调度器队列分配配置文件</description>
</property>
<property>
<name>yarn.scheduler.fair.preemption</name>
<value>false</value>
<description>禁止队列间资源抢占</description>
</property>
2）配置fair-scheduler.xml
[fuhong@linux202 hadoop]$ vim fair-scheduler.xml
<?xml version="1.0"?>
<allocations>
<!-- 单个队列中Application Master占用资源的最大比例,取值0-1 ，企业一般配置0.1 -->
<queueMaxAMShareDefault>0.5</queueMaxAMShareDefault>
<!-- 单个队列最大资源的默认值 test fuhong default -->
<queueMaxResourcesDefault>4096mb,4vcores</queueMaxResourcesDefault>
<!-- 增加一个队列test -->
<queue name="test">
<!-- 队列最小资源 -->
<minResources>2048mb,2vcores</minResources>
<!-- 队列最大资源 -->
<maxResources>4096mb,4vcores</maxResources>
<!-- 队列中最多同时运行的应用数，默认50，根据线程数配置 -->
<maxRunningApps>4</maxRunningApps>
<!-- 队列中Application Master占用资源的最大比例 -->
<maxAMShare>0.5</maxAMShare>
<!-- 该队列资源权重,默认值为1.0 -->
<weight>1.0</weight>
<!-- 队列内部的资源分配策略 -->
<schedulingPolicy>fair</schedulingPolicy>
</queue>
<!-- 增加一个队列fuhong -->
<queue name="fuhong" type="parent">
<!-- 队列最小资源 -->
<minResources>2048mb,2vcores</minResources>
<!-- 队列最大资源 -->
<maxResources>4096mb,4vcores</maxResources>
<!-- 队列中最多同时运行的应用数，默认50，根据线程数配置 -->
<maxRunningApps>4</maxRunningApps>
<!-- 队列中Application Master占用资源的最大比例 -->
<maxAMShare>0.5</maxAMShare>
<!-- 该队列资源权重,默认值为1.0 -->
<weight>1.0</weight>
<!-- 队列内部的资源分配策略 -->
<schedulingPolicy>fair</schedulingPolicy>
</queue>
<!-- 任务队列分配策略,可配置多层规则,从第一个规则开始匹配,直到匹配成功 -->
<queuePlacementPolicy>
<!-- 提交任务时指定队列,如未指定提交队列,则继续匹配下一个规则; false表示：如果指定队列不存在,不允许自动创建-->
<rule name="specified" create="false"/>
<!-- 提交到root.group.username队列,若root.group不存在,不允许自动创建；若root.group.user不存在,允许自动创建 -->
<rule name="nestedUserQueue" create="true">
<rule name="primaryGroup" create="false"/>
</rule>
<!-- 最后一个规则必须为reject或者default。Reject表示拒绝创建提交失败，default表示把任务提交到default队列 -->
<rule name="reject" />
</queuePlacementPolicy>
</allocations>
3）分发配置并重启Yarn
#加入内容后脚本分发
[fuhong@linux202 hadoop]$ xsync yarn-site.xml fair-scheduler.xml
[fuhong@linux202 hadoop]$ cd /opt/module/hadoop-3.1.3/
[fuhong@linux202 hadoop-3.1.3]$ sbin/stop-yarn.sh
[fuhong@linux202 hadoop-3.1.3]$ sbin/start-yarn.sh
2.3.3 测试提交任务
1）提交任务时指定队列，按照配置规则，任务会到指定的root.test队列
[fuhong@linux202 hadoop]$ hadoop jar /opt/module/hadoop-3.1.3/share/hadoop/mapreduce/hadoop-mapreduce-examples-3.1.3.jar pi -Dmapreduce.job.queuename=root.test 1 1
2）提交任务时不指定队列，按照配置规则，任务会到root.fuhong.fuhong队列
[fuhong@linux202 hadoop]$ hadoop jar /opt/module/hadoop-3.1.3/share/hadoop/mapreduce/hadoop-mapreduce-examples-3.1.3.jar pi 1 1
2.4 Yarn的Tool接口案例
0）回顾：
[fuhong@linux202 hadoop-3.1.3]$ hadoop jar wc.jar com.atguigu.mapreduce.wordcount2.WordCountDriver /input /output1
期望可以动态传参，结果报错，误认为是第一个输入参数。
[fuhong@linux202 hadoop-3.1.3]$ hadoop jar wc.jar com.atguigu.mapreduce.wordcount2.WordCountDriver -Dmapreduce.job.queuename=root.test /input /output1
1）需求：自己写的程序也可以动态修改参数。编写Yarn的Tool接口。
2）具体步骤：
(1)创建类WordCount并实现Tool接口：
import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.fs.Path;
import org.apache.hadoop.io.IntWritable;
import org.apache.hadoop.io.LongWritable;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapreduce.Job;
import org.apache.hadoop.mapreduce.Mapper;
import org.apache.hadoop.mapreduce.Reducer;
import org.apache.hadoop.mapreduce.lib.input.FileInputFormat;
import org.apache.hadoop.mapreduce.lib.output.FileOutputFormat;
import org.apache.hadoop.util.Tool;
import java.io.IOException;
/**
* @author eccom
* @description tool接口
* @date 2022/5/31 13:36
*/
public class WordCount implements Tool {
private Configuration conf;
//核心驱动 conf需要传入
@Override
public int run(String[] args) throws Exception {
Job job = Job.getInstance(conf);
job.setJarByClass(WordCountDriver.class);
job.setMapperClass(WordCountMapper.class);
job.setReducerClass(WordCountReducer.class);
job.setMapOutputKeyClass(Text.class);
job.setMapOutputValueClass(IntWritable.class);
job.setOutputKeyClass(Text.class);
job.setOutputValueClass(IntWritable.class);
FileInputFormat.setInputPaths(job, new Path(args[0]));
FileOutputFormat.setOutputPath(job, new Path(args[1]));
return job.waitForCompletion(true) ? 0 : 1;
}
@Override
public void setConf(Configuration conf) {
this.conf = conf;
}
@Override
public Configuration getConf() {
return conf;
}
/**
* @author eccom
* @description mapper
* @date 2022/5/31 13:43
*/
public static class WordCountMapper extends Mapper<LongWritable, Text, Text, IntWritable> {
private final Text outK = new Text();
private final IntWritable outV = new IntWritable(1);
@Override
protected void map(LongWritable key, Text value, Mapper<LongWritable, Text
, Text, IntWritable>.Context context) throws IOException, InterruptedException {
//1.获取1行
String line = value.toString();
//2.切割
String[] words = line.split(" ");
//3.循环写出
for (String word : words) {
outK.set(word);
context.write(outK, outV);
}
}
}
//reducer
public static class WordCountReducer extends Reducer<Text, IntWritable, Text, IntWritable> {
private final IntWritable outV = new IntWritable();
@Override
protected void reduce(Text key, Iterable<IntWritable> values, Reducer<Text, IntWritable, Text, IntWritable>.Context context) throws IOException, InterruptedException {
int sum = 0;
for (IntWritable value : values) {
sum += value.get();
}
outV.set(sum);
context.write(key, outV);
}
}
}
（2）新建WordCountDriver
import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.util.ToolRunner;
import java.util.Arrays;
/**
* @author eccom
* @description driver
* @date 2022/5/31 14:23
*/
public class WordCountDriver {
public static void main(String[] args) throws Exception {
WordCount tool;
//创建配置
Configuration conf = new Configuration();
if ("wordcount".equals(args[0])) {
tool = new WordCount();
} else {
throw new RuntimeException("no such tool" + args[0]);
}
//执行程序
int run = ToolRunner.run(conf, tool, Arrays.copyOfRange(args, 1, args.length));
System.exit(run);
}
}
3）在HDFS上准备输入文件，假设为/input目录，向集群提交该Jar包
[fuhong@linux202 hadoop-3.1.3]$ yarn jar YarnDemo.jar com.fuhong.yarn.wordCount.WordCountDriver wordcount /input /output
注意此时提交的3个参数，第一个用于生成特定的Tool，第二个和第三个为输入输出目录。此时如果我们希望加入设置参数，可以在wordcount后面添加参数，例如：
[fuhong@linux202 hadoop-3.1.3]$ yarn jar YarnDemo.jar com.fuhong.yarn.wordCount.WordCountDriver wordcount -Dmapreduce.job.queuename=root.test /input /output1
4）注：以上操作全部做完过后，快照回去或者手动将配置文件修改成之前的状态，因为本身资源就不够，分成了这么多，不方便以后测试。
3、Yarn总结
-
yarn工作机制
-
yarn的调度器
1）FIFO/容量/公平
2）apache 默认调度器：容量 cdh默认调度器：公平
3）公平、容量 默认一个default队列，需要创建多队列
4）中小企业：hive、spark、flink、mr
5）中大型企业：业务模块儿：登录、注册、购物车、营销
6）好处：解耦 降低风险 11.11 6.18 降级使用
7）每个调度器特点
相同点：支持多队列，可以借资源，支持多用户
不同点：
容量调度器：有限满足先进来的任务
公平调度器：在队列里面的任务公平享有队列的资源
8）生产环境怎么选：
中小企业：对并发度要求不高，选择容量
中大企业：对并发度要求高选择公平
- 开发需要重点掌握
1）队列运行原理
2）yarn常用命令
3）核心参数的配置
4）配置容量调度器和公平调度器
5）tool接口的使用
五、生产调优
1、HDFS—核心参数
1.1 NameNode内存生产配置（重要）
1）NameNode内存计算
每个文件块大概占用150byte，一台服务器128G内存为例，能存储多少文件块呢？
128 * 1024 * 1024 * 1024 / 150Byte ≈ 9.1亿
G MB KB Byte
2）Hadoop2.x系列，配置NameNode内存
NameNode内存默认2000m，如果服务器内存4G，NameNode内存可以配置3g。在hadoop-env.sh文件中配置如下
HADOOP_NAMENODE_OPTS=-Xmx3072m
3）Hadoop3.x系列，配置NameNode内存
（1）hadoop-env.sh中描述Hadoop的内存是动态分配的
[fuhong@linux202 hadoop-3.1.3]$ cd /opt/module/hadoop-3.1.3/etc/
# The maximum amount of heap to use (Java -Xmx). If no unit
# is provided, it will be converted to MB. Daemons will
# prefer any Xmx setting in their respective _OPT variable.
# There is no default; the JVM will autoscale based upon machine
# memory size.
# export HADOOP_HEAPSIZE_MAX=
# The minimum amount of heap to use (Java -Xms). If no unit
# is provided, it will be converted to MB. Daemons will
# prefer any Xms setting in their respective _OPT variable.
# There is no default; the JVM will autoscale based upon machine
# memory size.
# export HADOOP_HEAPSIZE_MIN=
HADOOP_NAMENODE_OPTS=-Xmx102400m
（2）查看NameNode占用内存
[fuhong@linux201 hadoop-3.1.3]$ jps
55796 DataNode
12568 NodeManager
126089 Jps
56745 JobHistoryServer
55595 NameNode
[fuhong@linux201 hadoop-3.1.3]$ jmap -heap 55595
Heap Configuration:
MinHeapFreeRatio = 0
MaxHeapFreeRatio = 100
#内存
MaxHeapSize = 1031798784 (984.0MB)
NewSize = 21495808 (20.5MB)
MaxNewSize = 343932928 (328.0MB)
OldSize = 43515904 (41.5MB)
NewRatio = 2
SurvivorRatio = 8
MetaspaceSize = 21807104 (20.796875MB)
CompressedClassSpaceSize = 1073741824 (1024.0MB)
MaxMetaspaceSize = 17592186044415 MB
G1HeapRegionSize = 0 (0.0MB)
（3）查看DataNode占用内存
[fuhong@linux201 hadoop-3.1.3]$ jmap -heap 55796
Heap Configuration:
MinHeapFreeRatio = 0
MaxHeapFreeRatio = 100
#内存
MaxHeapSize = 1031798784 (984.0MB)
NewSize = 21495808 (20.5MB)
MaxNewSize = 343932928 (328.0MB)
OldSize = 43515904 (41.5MB)
NewRatio = 2
SurvivorRatio = 8
MetaspaceSize = 21807104 (20.796875MB)
CompressedClassSpaceSize = 1073741824 (1024.0MB)
MaxMetaspaceSize = 17592186044415 MB
G1HeapRegionSize = 0 (0.0MB)
查看发现hadoop102上的NameNode和DataNode占用内存都是自动分配的，且相等。不是很合理。
经验参考：
https://docs.cloudera.com/documentation/enterprise/6/release-notes/topics/rg_hardware_requirements.html#concept_fzz_dq4_gbb
具体修改：hadoop-env.sh
export HDFS_NAMENODE_OPTS="-Dhadoop.security.logger=INFO,RFAS -Xmx1024m"
export HDFS_DATANODE_OPTS="-Dhadoop.security.logger=ERROR,RFAS -Xmx1024m"
1.2 NameNode心跳并发配置
1）hdfs-site.xml
The number of Namenode RPC server threads that listen to requests from clients. If dfs.namenode.servicerpc-address is not configured then Namenode RPC server threads listen to requests from all nodes.
NameNode有一个工作线程池，用来处理不同DataNode的并发心跳以及客户端并发的元数据操作。
对于大集群或者有大量客户端的集群来说，通常需要增大该参数。默认值是10。
<property>
<name>dfs.namenode.handler.count</name>
<value>21</value>
</property>
配置完分发
1.3 开启回收站配置
开启回收站功能，可以将删除的文件在不超时的情况下，恢复原数据，起到防止误删除、备份等作用。
1）回收站工作机制
2）开启回收站功能参数说明
（1）默认值fs.trash.interval = 0，0表示禁用回收站；其他值表示设置文件的存活时间。
（2）默认值fs.trash.checkpoint.interval = 0，检查回收站的间隔时间。如果该值为0，则该值设置和fs.trash.interval的参数值相等。
（3）要求fs.trash.checkpoint.interval <= fs.trash.interval。
3）启用回收站
修改core-site.xml，配置垃圾回收时间为1分钟。
<property>
<name>fs.trash.interval</name>
<value>1</value>
</property>
配置完分发，重启服务
4）查看回收站
回收站目录在HDFS集群中的路径：/user/atguigu/.Trash/….
5）注意：通过网页上直接删除的文件也不会走回收站。
6）通过程序删除的文件不会经过回收站，需要调用moveToTrash()才进入回收站
Trash trash = new Trash(conf);
trash.moveToTrash(path);
7）只有在命令行利用hadoop fs -rm命令删除的文件才会走回收站。
[fuhong@linux202 etc]$ hadoop fs -rm /sanguo/shuguo.txt
#网页查看路径 一分钟后消失
2022-05-31 16:58:46,176 INFO fs.TrashPolicyDefault: Moved: 'hdfs://linux201:8020/sanguo/shuguo.txt' to trash at: hdfs://linux201:8020/user/fuhong/.Trash/Current/sanguo/shuguo.txt
2、 HDFS—集群压测
在企业中非常关心每天从Java后台拉取过来的数据，需要多久能上传到集群？消费者关心多久能从HDFS上拉取需要的数据？
为了搞清楚HDFS的读写性能，生产环境上非常需要对集群进行压测。
HDFS的读写性能主要受网络和磁盘影响比较大。为了方便测试，将hadoop102、hadoop103、hadoop104虚拟机网络都设置为100mbps。
100Mbps单位是bit；10M/s单位是byte ; 1byte=8bit，100Mbps/8=12.5M/s。
测试网速：来到linux202的/opt/module目录，创建一个
[fuhong@linux202 module]$ python -m SimpleHTTPServer
Serving HTTP on 0.0.0.0 port 8000 ...
#浏览器访问linux202:8000进行下载
2.1 测试HDFS写性能
0）写测试底层原理
[fuhong@linux203 hadoop-3.1.3]$ cd /opt/module/hadoop-3.1.3/etc/hadoop/
[fuhong@linux203 hadoop]$ vim yarn-site.xml
<!--是否启动一个线程检查每个任务正使用的虚拟内存量，如果任务超出分配值，则直接将其杀掉，默认是true -->
<property>
<name>yarn.nodemanager.vmem-check-enabled</name>
<value>false</value>
</property>
[fuhong@linux203 hadoop]$ xsync yarn-site.xml
[fuhong@linux203 hadoop-3.1.3]$ sbin/stop-yarn.sh
[fuhong@linux203 hadoop-3.1.3]$ sbin/start-yarn.sh
1）测试内容：向HDFS集群写10个128M的文件
[fuhong@linux203 hadoop-3.1.3]$ 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
2022-06-01 11:12:55,111 INFO fs.TestDFSIO: ----- TestDFSIO ----- : write
2022-06-01 11:12:55,111 INFO fs.TestDFSIO: Date & time: Wed Jun 01 11:12:55 CST 2022
2022-06-01 11:12:55,111 INFO fs.TestDFSIO: Number of files: 10
2022-06-01 11:12:55,111 INFO fs.TestDFSIO: Total MBytes processed: 1280
2022-06-01 11:12:55,111 INFO fs.TestDFSIO: Throughput mb/sec: 2.03
2022-06-01 11:12:55,111 INFO fs.TestDFSIO: Average IO rate mb/sec: 2.62
2022-06-01 11:12:55,111 INFO fs.TestDFSIO: IO rate std deviation: 1.39
2022-06-01 11:12:55,111 INFO fs.TestDFSIO: Test exec time sec: 153.58
注意：nrFiles n为生成mapTask的数量，生产环境一般可通过linux203:8088查看CPU核数，设置为（CPU核数 - 1）
Number of files：生成mapTask数量，一般是集群中（CPU核数-1），我们测试虚拟机就按照实际的物理内存-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处理的差值，越小越均衡
3）测试结果分析
（1）由于副本1就在本地，所以该副本不参与测试
一共参与测试的文件：10个文件 * 2个副本 = 20个
压测后的速度：2.03
实测速度：2.03M/s * 20个文件 ≈ 40M/s
三台服务器的带宽：12.5 + 12.5 + 12.5 ≈ 36m/s
所有网络资源都已经用满。
如果实测速度远远小于网络，并且实测速度不能满足工作需求，可以考虑采用固态硬盘或者增加磁盘个数。
（2）如果客户端不在集群节点，那就三个副本都参与计算
2.2 测试HDFS读性能
1）测试内容：读取HDFS集群10个128M的文件
[fuhong@linux203 hadoop-3.1.3]$ 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
2022-06-01 11:44:34,864 INFO fs.TestDFSIO: ----- TestDFSIO ----- : read
2022-06-01 11:44:34,865 INFO fs.TestDFSIO: Date & time: Wed Jun 01 11:44:34 CST 2022
2022-06-01 11:44:34,865 INFO fs.TestDFSIO: Number of files: 10
2022-06-01 11:44:34,865 INFO fs.TestDFSIO: Total MBytes processed: 1280
2022-06-01 11:44:34,865 INFO fs.TestDFSIO: Throughput mb/sec: 64.14
2022-06-01 11:44:34,865 INFO fs.TestDFSIO: Average IO rate mb/sec: 66.12
2022-06-01 11:44:34,865 INFO fs.TestDFSIO: IO rate std deviation: 11.81
2022-06-01 11:44:34,865 INFO fs.TestDFSIO: Test exec time sec: 36.34
2022-06-01 11:44:34,865 INFO fs.TestDFSIO:
2）删除测试生成数据
[fuhong@linux203 hadoop-3.1.3]$ hadoop jar /opt/module/hadoop-3.1.3/share/hadoop/mapreduce/hadoop-mapreduce-client-jobclient-3.1.3-tests.jar TestDFSIO -clean
3）测试结果分析：为什么读取文件速度大于网络带宽？由于目前只有三台服务器，且有三个副本，数据读取就近原则，相当于都是读取的本地磁盘数据，没有走网络。
3、HDFS—多目录–了解
3.1 NameNode多目录配置
1）NameNode的本地目录可以配置成多个，且每个目录存放内容相同，增加了可靠性
2）具体配置如下
（1）在hdfs-site.xml文件中添加如下内容
[fuhong@linux203 hadoop]$ cd /opt/module/hadoop-3.1.3/etc/hadoop/
[fuhong@linux203 hadoop]$ vim 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>
[fuhong@linux203 hadoop]$ xsync hdfs-site.xml
注意：因为每台服务器节点的磁盘情况不同，所以这个配置配完之后，可以选择不分发
（2）停止集群，删除三台节点的data和logs中所有数据。
[fuhong@linux203 hadoop]$ myhadoop.sh stop
[fuhong@linux201 ~]$ cd /opt/module/hadoop-3.1.3/
[fuhong@linux202 ~]$ cd /opt/module/hadoop-3.1.3/
[fuhong@linux203 hadoop]$ cd /opt/module/hadoop-3.1.3/
[fuhong@linux201 hadoop-3.1.3]$ rm -rf data/ logs/
[fuhong@linux202 hadoop-3.1.3]$ rm -rf data/ logs/
[fuhong@linux203 hadoop-3.1.3]$ rm -rf data/ logs/
（3）格式化集群并启动。
[fuhong@linux201 hadoop-3.1.3]$ hdfs namenode -format
[fuhong@linux201 hadoop-3.1.3]$ sbin/start-dfs.sh
3）查看结果
[fuhong@linux201 hadoop-3.1.3]$ cd data/dfs/
3.2 DataNode多目录配置
1）DataNode可以配置成多个目录，每个目录存储的数据不一样（数据不是副本）
2）具体配置如下
在hdfs-site.xml文件中添加如下内容
[fuhong@linux201 dfs]$ cd /opt/module/hadoop-3.1.3/etc/hadoop/
[fuhong@linux201 hadoop]$ vim 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>
#集群配置不一样则不分发 单独配置
[fuhong@linux201 hadoop]$ xsync hdfs-site.xml
[fuhong@linux201 hadoop-3.1.3]$ sbin/stop-dfs.sh
[fuhong@linux201 hadoop-3.1.3]$ sbin/start-dfs.sh
3）查看结果
[fuhong@linux201 hadoop-3.1.3]$ cd data/dfs/
[fuhong@linux201 dfs]$ ll
3.3 集群数据均衡之磁盘间数据均衡
生产环境，由于硬盘空间不足，往往需要增加一块硬盘。刚加载的硬盘没有数据时，可以执行磁盘数据均衡命令。（Hadoop3.x新特性）
（1）生成均衡计划（我们只有一块磁盘，不会生成计划）
hdfs diskbalancer -plan linux102
（2）执行均衡计划
hdfs diskbalancer -execute linux102.plan.json
（3）查看当前均衡任务的执行情况
hdfs diskbalancer -query linux102
（4）取消均衡任务
hdfs diskbalancer -cancel linux102.plan.json
4、HDFS—集群扩容及缩容
4.1 添加白名单
白名单：表示在白名单的主机IP地址可以，用来存储数据。
企业中：配置白名单，可以尽量防止黑客恶意访问攻击。
配置白名单步骤如下：
1）在NameNode节点的/opt/module/hadoop-3.1.3/etc/hadoop目录下分别创建whitelist 和blacklist文件
（1）创建白名单
[fuhong@linux201 dfs]$ cd /opt/module/hadoop-3.1.3/etc/hadoop/
[fuhong@linux201 hadoop]$ vim whitelist
linux201
linux202
（2）创建黑名单
[fuhong@linux201 hadoop]$ touch blacklist
2）在hdfs-site.xml配置文件中增加dfs.hosts配置参数
[fuhong@linux201 dfs]$ cd /opt/module/hadoop-3.1.3/etc/hadoop/
[fuhong@linux201 hadoop]$ vim hdfs-site.xml
<!-- 白名单 -->
<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>
3）分发配置文件whitelist，hdfs-site.xml
[fuhong@linux201 hadoop]$ xsync hdfs-site.xml whitelist
4）第一次添加白名单必须重启集群，不是第一次，只需要刷新NameNode节点即可
[fuhong@linux201 hadoop]$ myhadoop.sh stop
[fuhong@linux201 hadoop]$ myhadoop.sh start
5）在web浏览器上查看DN，http://linux201:9870/dfshealth.html#tab-datanode
6）在linux203上执行上传数据数据失败
[fuhong@linux203 hadoop-3.1.3]$ hadoop fs -put NOTICE.txt /
7）二次修改白名单，增加linux203
[fuhong@linux203 hadoop]$ cd /opt/module/hadoop-3.1.3/etc/hadoop/
[fuhong@linux203 hadoop]$ vim whitelist
linux203
8）刷新NameNode
[fuhong@linux203 hadoop]$ xsync whitelist
[fuhong@linux203 hadoop]$ hdfs dfsadmin -refreshNodes
Refresh nodes successful
9）在web浏览器上查看DN，http://linux201:9870/dfshealth.html#tab-datanode
4.2 服役新服务器
1）需求
随着公司业务的增长，数据量越来越大，原有的数据节点的容量已经不能满足存储数据的需求，需要在原有集群基础上动态添加新的数据节点。
2）环境准备
（1）在linux200主机上再克隆一台linux204主机
（2）修改IP地址和主机名称
[fuhong@linux204 ~]$ vim /etc/sysconfig/network-scripts/ifcfg-ens160
#IP地址
IPADDR=192.168.10.204
#网关
GATEWAY=192.168.10.2
#域名解析器
DNS1=192.168.10.2
[fuhong@linux204 ~]$ vim /etc/hostname
linux204
[fuhong@linux204 ~]$ reboot
（3）拷贝linux201的/opt/module目录和/etc/profile.d/my_env.sh到linux204
[fuhong@linux201 hadoop]$ cd /opt
[fuhong@linux201 opt]$ scp -r module/* fuhong@linux204:/opt/module/
[fuhong@linux201 opt]$ sudo scp /etc/profile.d/my_env.sh root@linux204:/etc/profile.d/my_env.sh
[fuhong@linux204 ~]$ source /etc/profile
（4）删除linux204上Hadoop的历史数据，data和log数据
[fuhong@linux204 hadoop-3.1.3]$ rm -rf data/ logs/
（5）配置linux201和linux202到linux204的ssh无密登录
[fuhong@linux201 opt]$ cd
[fuhong@linux201 ~]$ cd .ssh/
[fuhong@linux201 .ssh]$ ssh-copy-id linux204
[fuhong@linux202 hadoop-3.1.3]$ cd
[fuhong@linux202 ~]$ cd .ssh/
[fuhong@linux202 .ssh]$ ssh-copy-id linux204
3）服役新节点具体步骤
（1）直接启动DataNode，即可关联到集群
[fuhong@linux204 hadoop-3.1.3]$ hdfs --daemon start datanode
[fuhong@linux204 hadoop-3.1.3]$ yarn --daemon start nodemanager
4）在白名单中增加新服役的服务器
（1）在白名单whitelist中增加linux204，并重启集群
[fuhong@linux201 .ssh]$ cd /opt/module/hadoop-3.1.3/etc/hadoop/
[fuhong@linux201 hadoop]$ vim whitelist
linux204
（2）分发
[fuhong@linux201 hadoop]$ xsync whitelist
（3）刷新NameNode
[fuhong@linux201 hadoop]$ hdfs dfsadmin -refreshNodes
Refresh nodes successful
（4）查看http://linux201:9870/dfshealth.html#tab-datanode
5）在linux204上上传文件
[fuhong@linux204 hadoop-3.1.3]$ hadoop fs -put /opt/module/hadoop-3.1.3/LICENSE.txt /
4.3 服务器间数据均衡
1）企业经验：
在企业开发中，如果经常在linux201和linux203上提交任务，且副本数为2，由于数据本地性原则，就会导致linux201和linux203数据过多，hadoop103存储的数据量小。
另一种情况，就是新服役的服务器数据量比较少，需要执行集群均衡命令。
2）开启数据均衡命令：
[fuhong@linux204 hadoop-3.1.3]$ sbin/start-balancer.sh -threshold 10
对于参数10，代表的是集群中各个节点的磁盘空间利用率相差不超过10%，可根据实际情况进行调整。
3）停止数据均衡命令：
[fuhong@linux204 hadoop-3.1.3]$ sbin/stop-balancer.sh
注意：由于HDFS需要启动单独的Rebalance Server来执行Rebalance操作，所以尽量不要在NameNode上执行start-balancer.sh，而是找一台比较空闲的机器。
4.4 黑名单退役服务器
黑名单：表示在黑名单的主机IP地址不可以，用来存储数据。
企业中：配置黑名单，用来退役服务器。
黑名单配置步骤如下：
1）编辑/opt/module/hadoop-3.1.3/etc/hadoop目录下的blacklist文件
[fuhong@linux201 hadoop]$ vim blacklist
linux04
注意：如果白名单中没有配置，需要在hdfs-site.xml配置文件中增加dfs.hosts配置参数
<!-- 黑名单 -->
<property>
<name>dfs.hosts.exclude</name>
<value>/opt/module/hadoop-3.1.3/etc/hadoop/blacklist</value>
</property>
2）分发配置文件blacklist，hdfs-site.xml
[fuhong@linux201 hadoop]$ xsync hdfs-site.xml blacklist
3）第一次添加黑名单必须重启集群，不是第一次，只需要刷新NameNode节点即可
[fuhong@linux201 hadoop]$ hdfs dfsadmin -refreshNodes
Refresh nodes successful
4）检查Web浏览器，退役节点的状态为decommission in progress（退役中），说明数据节点正在复制块到其他节点http://linux201:9870/dfshealth.html#tab-datanode
5）等待退役节点状态为decommissioned（所有块已经复制完成），停止该节点及节点资源管理器。注意：如果副本数是3，服役的节点小于等于3，是不能退役成功的，需要修改副本数后才能退役
#手动关闭204
[fuhong@linux204 hadoop]$ hdfs --daemon stop datanode
[fuhong@linux204 hadoop]$ yarn --daemon stop nodemanager
6）如果数据不均衡，可以用命令实现集群的再平衡
[fuhong@linux201 hadoop-3.1.3]$ sbin/start-balancer.sh -threshold 10
5、HDFS—存储优化
注：演示纠删码和异构存储需要一共5台虚拟机。尽量拿另外一套集群。提前准备5台服务器的集群。
这里准备linux205,流程参考linux204
[fuhong@linux201 hadoop-3.1.3]$ cd
[fuhong@linux201 ~]$ cd bin/
[fuhong@linux201 bin]$ ll
总用量 12
-rwxrwxrwx. 1 fuhong fuhong 134 1月 11 14:24 jpsall
-rwxrwxrwx. 1 fuhong fuhong 1124 1月 11 14:19 myhadoop.sh
-rwxrwxr-x. 1 fuhong fuhong 737 1月 12 10:22 xsync
[fuhong@linux201 bin]$ vim jpsall
linux204 linux205
#不需要修改
[fuhong@linux201 bin]$ vim myhadoop.sh
[fuhong@linux201 bin]$ vim xsync
linux204 linux205
[fuhong@linux201 bin]$ cd /opt/module/hadoop-3.1.3/etc/hadoop/
[fuhong@linux201 hadoop]$ vim whitelist
linux205
[fuhong@linux201 hadoop]$ vim blacklist
去除linux204
#取消多目录
[fuhong@linux201 hadoop]$ vim hdfs-site.xml
<property>
<name>dfs.namenode.name.dir</name>
<value>file://${hadoop.tmp.dir}/dfs/name</value>
</property>
<property>
<name>dfs.datanode.data.dir</name>
<value>file://${hadoop.tmp.dir}/dfs/data</value>
</property>
[fuhong@linux201 etc]$ xsync hadoop/
[fuhong@linux201 hadoop-3.1.3]$ hdfs namenode -format
[fuhong@linux201 hadoop-3.1.3]$ cd etc/hadoop/
[fuhong@linux201 hadoop]$ vim workers
linux204
linux205
[fuhong@linux201 hadoop]$ xsync workers
[fuhong@linux201 hadoop-3.1.3]$ myhadoop.sh start
[fuhong@linux201 hadoop-3.1.3]$ jpsall
5.1 纠删码
5.1.1 纠删码原理
HDFS默认情况下，一个文件有3个副本，这样提高了数据的可靠性，但也带来了2倍的冗余开销。Hadoop3.x引入了纠删码，采用计算的方式，可以节省约50％左右的存储空间。
任意挂掉两个服务，可以通过计算的方式恢复数据，保证可靠性。但需要占用cpu的计算资源
1）纠删码操作相关的命令
[fuhong@linux201 hadoop-3.1.3]$ hdfs ec
Usage: bin/hdfs ec [COMMAND]
[-listPolicies] #列出纠删码策略
[-addPolicies -policyFile <file>] #添加纠删码策略
[-getPolicy -path <path>] #按照路径获取纠删码策略
[-removePolicy -policy <policy>] #删除策略
[-setPolicy -path <path> [-policy <policy>] [-replicate]] #按路径设置纠删策略
[-unsetPolicy -path <path>]
[-listCodecs]
[-enablePolicy -policy <policy>] #开启某一个纠删策略
[-disablePolicy -policy <policy>] #关闭某一个纠删策略
[-help <command-name>]
2）查看当前支持的纠删码策略
[fuhong@linux201 hadoop-3.1.3]$ hdfs ec -listPolicies
Erasure Coding Policies:
ErasureCodingPolicy=[Name=RS-10-4-1024k, Schema=[ECSchema=[Codec=rs, numDataUnits=10, numParityUnits=4]], CellSize=1048576, Id=5], State=DISABLED
ErasureCodingPolicy=[Name=RS-3-2-1024k, Schema=[ECSchema=[Codec=rs, numDataUnits=3, numParityUnits=2]], CellSize=1048576, Id=2], State=DISABLED
ErasureCodingPolicy=[Name=RS-6-3-1024k, Schema=[ECSchema=[Codec=rs, numDataUnits=6, numParityUnits=3]], CellSize=1048576, Id=1], State=ENABLED
ErasureCodingPolicy=[Name=RS-LEGACY-6-3-1024k, Schema=[ECSchema=[Codec=rs-legacy, numDataUnits=6, numParityUnits=3]], CellSize=1048576, Id=3], State=DISABLED
ErasureCodingPolicy=[Name=XOR-2-1-1024k, Schema=[ECSchema=[Codec=xor, numDataUnits=2, numParityUnits=1]], CellSize=1048576, Id=4], State=DISABLED
3）纠删码策略解释:
RS-3-2-1024k：使用RS编码，每3个数据单元，生成2个校验单元，共5个单元，也就是说：这5个单元中，只要有任意的3个单元存在（不管是数据单元还是校验单元，只要总数=3），就可以得到原始数据。每个单元的大小是1024k=1024*1024=1048576。
RS-10-4-1024k：使用RS编码，每10个数据单元（cell），生成4个校验单元，共14个单元，也就是说：这14个单元中，只要有任意的10个单元存在（不管是数据单元还是校验单元，只要总数=10），就可以得到原始数据。每个单元的大小是1024k=10241024=1048576。
RS-6-3-1024k：使用RS编码，每6个数据单元，生成3个校验单元，共9个单元，也就是说：这9个单元中，只要有任意的6个单元存在（不管是数据单元还是校验单元，只要总数=6），就可以得到原始数据。每个单元的大小是1024k=10241024=1048576。
RS-LEGACY-6-3-1024k：策略和上面的RS-6-3-1024k一样，只是编码的算法用的是rs-legacy。
XOR-2-1-1024k：使用XOR编码（速度比RS编码快），每2个数据单元，生成1个校验单元，共3个单元，也就是说：这3个单元中，只要有任意的2个单元存在（不管是数据单元还是校验单元，只要总数= 2），就可以得到原始数据。每个单元的大小是1024k=1024*1024=1048576。
5.1.2 纠删码案例实操
纠删码策略是给具体一个路径设置。所有往此路径下存储的文件，都会执行此策略。
默认只开启对RS-6-3-1024k策略的支持，如要使用别的策略需要提前启用。
1）需求：将/input目录设置为RS-3-2-1024k策略
2）具体步骤
（1）开启对RS-3-2-1024k策略的支持
[fuhong@linux201 bin]$ hdfs ec -enablePolicy -policy RS-3-2-1024k
Erasure coding policy RS-3-2-1024k is enabled
[fuhong@linux201 bin]$ hdfs ec -listPolicies
Erasure Coding Policies:
ErasureCodingPolicy=[Name=RS-10-4-1024k, Schema=[ECSchema=[Codec=rs, numDataUnits=10, numParityUnits=4]], CellSize=1048576, Id=5], State=DISABLED
ErasureCodingPolicy=[Name=RS-3-2-1024k, Schema=[ECSchema=[Codec=rs, numDataUnits=3, numParityUnits=2]], CellSize=1048576, Id=2], State=DISABLED
ErasureCodingPolicy=[Name=RS-6-3-1024k, Schema=[ECSchema=[Codec=rs, numDataUnits=6, numParityUnits=3]], CellSize=1048576, Id=1], State=ENABLED
ErasureCodingPolicy=[Name=RS-LEGACY-6-3-1024k, Schema=[ECSchema=[Codec=rs-legacy, numDataUnits=6, numParityUnits=3]], CellSize=1048576, Id=3], State=DISABLED
ErasureCodingPolicy=[Name=XOR-2-1-1024k, Schema=[ECSchema=[Codec=xor, numDataUnits=2, numParityUnits=1]], CellSize=1048576, Id=4], State=DISABLED
（2）在HDFS创建目录，并设置RS-3-2-1024k策略
[fuhong@linux201 bin]$ hadoop fs -mkdir /input
[fuhong@linux201 bin]$ hdfs ec -setPolicy -path /input -policy RS-3-2-1024k
Set RS-3-2-1024k erasure coding policy on /input
（3）上传文件，并查看文件编码后的存储情况
注：你所上传的文件需要大于2M才能看出效果。（低于2M，只有一个数据单元和两个校验单元）
（4）查看存储路径的数据单元和校验单元，并作破坏实验
[fuhong@linux201 hadoop-3.1.3]$ cd /opt/module/hadoop-3.1.3/data/dfs/data/current/BP-268815710-192.168.10.201-1654072351561/current/finalized/subdir0/subdir0/
[fuhong@linux201 subdir0]$ ll
总用量 1036
-rw-rw-r--. 1 fuhong fuhong 1048576 6月 2 10:53 blk_-9223372036854775791
-rw-rw-r--. 1 fuhong fuhong 8199 6月 2 10:53 blk_-9223372036854775791_1002.meta
#linux201为数据单元
[fuhong@linux201 subdir0]$ cat blk_-9223372036854775791
[fuhong@linux203 subdir0]$ cd /opt/module/hadoop-3.1.3/data/dfs/data/current/BP-268815710-192.168.10.201-1654072351561/current/finalized/subdir0/subdir0/
[fuhong@linux203 subdir0]$ ll
总用量 1036
-rw-rw-r--. 1 fuhong fuhong 1048576 6月 2 10:53 blk_-9223372036854775788
-rw-rw-r--. 1 fuhong fuhong 8199 6月 2 10:53 blk_-9223372036854775788_1002.meta
#linux203为校验单元
[fuhong@linux203 subdir0]$ cat blk_-9223372036854775788
#以此类推查看各数据单元与检验单元
#删除其中某个数据进行下载测试，能够下载（原则上任意删除两个都可以下载，损坏三个块儿下载失败）且能通过计算恢复
[fuhong@linux203 subdir0]$ rm -rf blk_-9223372036854775792 blk_-9223372036854775792_1002.meta
[fuhong@linux202 subdir0]$ ll
总用量 1036
-rw-rw-r--. 1 fuhong fuhong 1048576 6月 2 11:15 blk_-9223372036854775792
-rw-rw-r--. 1 fuhong fuhong 8199 6月 2 11:15 blk_-9223372036854775792_1002.meta
5.2 异构存储（冷热数据分离）
异构存储主要解决，不同的数据，存储在不同类型的硬盘中，达到最佳性能的问题。
存储类型和存储策略
5.2.1 异构存储Shell操作
（1）查看当前有哪些存储策略可以用
[fuhong@linux203 subdir0]$ hdfs storagepolicies -listPolicies
Block Storage Policies:
BlockStoragePolicy{PROVIDED:1, storageTypes=[PROVIDED, DISK], creationFallbacks=[PROVIDED, DISK], replicationFallbacks=[PROVIDED, DISK]}
BlockStoragePolicy{COLD:2, storageTypes=[ARCHIVE], creationFallbacks=[], replicationFallbacks=[]}
BlockStoragePolicy{WARM:5, storageTypes=[DISK, ARCHIVE], creationFallbacks=[DISK, ARCHIVE], replicationFallbacks=[DISK, ARCHIVE]}
BlockStoragePolicy{HOT:7, storageTypes=[DISK], creationFallbacks=[], replicationFallbacks=[ARCHIVE]}
BlockStoragePolicy{ONE_SSD:10, storageTypes=[SSD, DISK], creationFallbacks=[SSD, DISK], replicationFallbacks=[SSD, DISK]}
BlockStoragePolicy{ALL_SSD:12, storageTypes=[SSD], creationFallbacks=[DISK], replicationFallbacks=[DISK]}
BlockStoragePolicy{LAZY_PERSIST:15, storageTypes=[RAM_DISK, DISK], creationFallbacks=[DISK], replicationFallbacks=[DISK]}
（2）为指定路径（数据存储目录）设置指定的存储策略
hdfs storagepolicies -setStoragePolicy -path xxx -policy xxx
（3）获取指定路径（数据存储目录或文件）的存储策略
hdfs storagepolicies -getStoragePolicy -path xxx
（4）取消存储策略；执行改命令之后该目录或者文件，以其上级的目录为准，如果是根目录，那么就是HOT
hdfs storagepolicies -unsetStoragePolicy -path xxx
（5）查看文件块的分布
bin/hdfs fsck xxx -files -blocks -locations
（6）查看集群节点
hadoop dfsadmin -report
5.2.2 测试环境准备
1）测试环境描述
服务器规模：5台
集群配置：副本数为2，创建好带有存储类型的目录（提前创建）
集群规划：
| 节点 | 存储类型分配 |
|---|---|
| linux201 | RAM_DISK，SSD |
| linux202 | SSD，DISK |
| linux203 | DISK，RAM_DISK |
| linux204 | ARCHIVE |
| linux205 | ARCHIVE |
2）配置文件信息（指明该服务器各存储介质类型）
（1）为linux201节点的hdfs-site.xml添加如下信息
[fuhong@linux201 subdir0]$ cd /opt/module/hadoop-3.1.3/etc/hadoop/
[fuhong@linux201 hadoop]$ vim hdfs-site.xml
<property>
<name>dfs.replication</name>
<value>2</value>
</property>
<property>
<name>dfs.storage.policy.enabled</name>
<value>true</value>
</property>
<!--只能配置一个data.dir-->
<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>
</property>
（2）为linux202节点的hdfs-site.xml添加如下信息
[fuhong@linux202 subdir0]$ cd /opt/module/hadoop-3.1.3/etc/hadoop/
[fuhong@linux202 hadoop]$ vim hdfs-site.xml
<property>
<name>dfs.replication</name>
<value>2</value>
</property>
<property>
<name>dfs.storage.policy.enabled</name>
<value>true</value>
</property>
<!--只能配置一个data.dir-->
<property>
<name>dfs.datanode.data.dir</name>
<value>[SSD]file:///opt/module/hadoop-3.1.3/hdfsdata/ssd,[DISK]file:///opt/module/hadoop-3.1.3/hdfsdata/disk</value>
</property>
（3）为linux203节点的hdfs-site.xml添加如下信息
[fuhong@linux203 subdir0]$ cd /opt/module/hadoop-3.1.3/etc/hadoop/
[fuhong@linux203 hadoop]$ vim hdfs-site.xml
<property>
<name>dfs.replication</name>
<value>2</value>
</property>
<property>
<name>dfs.storage.policy.enabled</name>
<value>true</value>
</property>
<!--只能配置一个data.dir-->
<property>
<name>dfs.datanode.data.dir</name>
<value>[RAM_DISK]file:///opt/module/hdfsdata/ram_disk,[DISK]file:///opt/module/hadoop-3.1.3/hdfsdata/disk</value>
</property>
（4）为linux204节点的hdfs-site.xml添加如下信息
[fuhong@linux204 subdir0]$ cd /opt/module/hadoop-3.1.3/etc/hadoop/
[fuhong@linux204 hadoop]$ vim hdfs-site.xml
<property>
<name>dfs.replication</name>
<value>2</value>
</property>
<property>
<name>dfs.storage.policy.enabled</name>
<value>true</value>
</property>
<!--只能配置一个data.dir-->
<property>
<name>dfs.datanode.data.dir</name>
<value>[ARCHIVE]file:///opt/module/hadoop-3.1.3/hdfsdata/archive</value>
</property>
（5）为linux205节点的hdfs-site.xml添加如下信息
[fuhong@linux205 subdir0]$ cd /opt/module/hadoop-3.1.3/etc/hadoop/
[fuhong@linux205 hadoop]$ vim hdfs-site.xml
<property>
<name>dfs.replication</name>
<value>2</value>
</property>
<property>
<name>dfs.storage.policy.enabled</name>
<value>true</value>
</property>
<!--只能配置一个data.dir-->
<property>
<name>dfs.datanode.data.dir</name>
<value>[ARCHIVE]file:///opt/module/hadoop-3.1.3/hdfsdata/archive</value>
</property>
3）数据准备
（1）启动集群
[fuhong@linux202 hadoop]$ myhadoop.sh stop
#删除集群的数据日志
[fuhong@linux201 hadoop-3.1.3]$ rm -rf data/ logs/
#格式化集群
[fuhong@linux201 hadoop-3.1.3]$ hdfs namenode -format
[fuhong@linux201 hadoop-3.1.3]$ myhadoop.sh start
（2）并在HDFS上创建文件目录
[fuhong@linux201 hadoop-3.1.3]$ hadoop fs -mkdir /hdfsdata
（3）并将文件资料上传
[fuhong@linux201 hadoop-3.1.3]$ hadoop fs -put /opt/module/hadoop-3.1.3/NOTICE.txt /hdfsdata
5.2.3 HOT存储策略案例
（1）最开始我们未设置存储策略的情况下，我们获取该目录的存储策略
[fuhong@linux201 hadoop-3.1.3]$ hdfs storagepolicies -getStoragePolicy -path /hdfsdata
The storage policy of /hdfsdata is unspecified
（2）我们查看上传的文件块分布
[fuhong@linux201 hadoop-3.1.3]$ hdfs fsck /hdfsdata -files -blocks -locations
[DatanodeInfoWithStorage[192.168.10.202:9866,DS-287893c3-819c-4f4b-8ffd-ecbbfdb8bb86,DISK], DatanodeInfoWithStorage[192.168.10.203:9866,DS-ed7dde26-692f-4d07-8d96-7d07d8d4f29b,DISK]]
未设置存储策略，所有文件块都存储在DISK下。所以，默认存储策略为HOT。
5.2.4 WARM存储策略测试
（1）接下来我们为数据降温
[fuhong@linux201 hadoop-3.1.3]$ hdfs storagepolicies -setStoragePolicy -path /hdfsdata -policy WARM
Set storage policy WARM on /hdfsdata
（2）再次查看文件块分布，我们可以看到文件块依然放在原处。
[fuhong@linux201 hadoop-3.1.3]$ hdfs fsck /hdfsdata -files -blocks -locations
（3）我们需要让他HDFS按照存储策略自行移动文件块
[fuhong@linux201 hadoop-3.1.3]$ hdfs mover /hdfsdata
（4）再次查看文件块分布
[fuhong@linux201 hadoop-3.1.3]$ hdfs fsck /hdfsdata -files -blocks -locations
[DatanodeInfoWithStorage[192.168.10.202:9866,DS-287893c3-819c-4f4b-8ffd-ecbbfdb8bb86,DISK], DatanodeInfoWithStorage[192.168.10.204:9866,DS-066d07ff-bd1d-4c45-bb6d-994fcb5bbfb7,ARCHIVE]]
文件块一半在DISK，一半在ARCHIVE，符合我们设置的WARM策略
5.2.5 COLD策略测试
（1）我们继续将数据降温为cold
[fuhong@linux201 hadoop-3.1.3]$ hdfs storagepolicies -setStoragePolicy -path /hdfsdata -policy COLD
Set storage policy COLD on /hdfsdata
注意：当我们将目录设置为COLD并且我们未配置ARCHIVE存储目录的情况下，不可以向该目录直接上传文件，会报出异常。
（2）手动转移
[fuhong@linux201 hadoop-3.1.3]$ hdfs mover /hdfsdata
（3）检查文件块的分布
[fuhong@linux201 hadoop-3.1.3]$ hdfs fsck /hdfsdata -files -blocks -locations
[DatanodeInfoWithStorage[192.168.10.205:9866,DS-ea3759a0-b8e4-414e-8505-25ae8739da4e,ARCHIVE], DatanodeInfoWithStorage[192.168.10.204:9866,DS-066d07ff-bd1d-4c45-bb6d-994fcb5bbfb7,ARCHIVE]]
所有文件块都在ARCHIVE，符合COLD存储策略。
5.2.6 ONE_SSD策略测试
（1）接下来我们将存储策略从默认的HOT更改为One_SSD
[fuhong@linux201 hadoop-3.1.3]$ hdfs storagepolicies -setStoragePolicy -path /hdfsdata -policy One_SSD
Set storage policy One_SSD on /hdfsdata
（2）手动转移文件块
[fuhong@linux201 hadoop-3.1.3]$ hdfs mover /hdfsdata
（3）转移完成后，我们查看文件块分布
[fuhong@linux201 hadoop-3.1.3]$ bin/hdfs fsck /hdfsdata -files -blocks -locations
[DatanodeInfoWithStorage[192.168.10.202:9866,DS-c9850651-55c2-416c-8ac1-3b7bf6878954,SSD], DatanodeInfoWithStorage[192.168.10.203:9866,DS-ed7dde26-692f-4d07-8d96-7d07d8d4f29b,DISK]]
文件块分布为一半在SSD，一半在DISK，符合One_SSD存储策略。
5.2.7 ALL_SSD策略测试
（1）接下来，我们再将存储策略更改为All_SSD
[fuhong@linux201 hadoop-3.1.3]$ hdfs storagepolicies -setStoragePolicy -path /hdfsdata -policy All_SSD
Set storage policy All_SSD on /hdfsdata
（2）手动转移文件块
[fuhong@linux201 hadoop-3.1.3]$ hdfs mover /hdfsdata
（3）查看文件块分布，我们可以看到
[fuhong@linux201 hadoop-3.1.3]$ bin/hdfs fsck /hdfsdata -files -blocks -locations
[DatanodeInfoWithStorage[192.168.10.202:9866,DS-c9850651-55c2-416c-8ac1-3b7bf6878954,SSD], DatanodeInfoWithStorage[192.168.10.201:9866,DS-e7d6bc97-43ce-4189-9ffc-270fb220527f,SSD]]
所有的文件块都存储在SSD，符合All_SSD存储策略。
5.2.8 LAZY_PERSIST策略测试
（1）继续改变策略，将存储策略改为lazy_persist
[fuhong@linux201 hadoop-3.1.3]$ hdfs storagepolicies -setStoragePolicy -path /hdfsdata -policy lazy_persist
Set storage policy lazy_persist on /hdfsdata
（2）手动转移文件块
[fuhong@linux201 hadoop-3.1.3]$ hdfs mover /hdfsdata
（3）查看文件块分布
[fuhong@linux201 hadoop-3.1.3]$ bin/hdfs fsck /hdfsdata -files -blocks -locations
[DatanodeInfoWithStorage[192.168.10.203:9866,DS-ed7dde26-692f-4d07-8d96-7d07d8d4f29b,DISK], DatanodeInfoWithStorage[192.168.10.202:9866,DS-287893c3-819c-4f4b-8ffd-ecbbfdb8bb86,DISK]]
不管是hdfs 还是linux系统，都做了限制，都不希望在内存中存数据，因为容易数据丢失
这里我们发现所有的文件块都是存储在DISK，按照理论一个副本存储在RAM_DISK，其他副本存储在DISK中，这是因为，我们还需要配置“dfs.datanode.max.locked.memory”，“dfs.block.size”参数。
hdfs-default.xml配置文件默认配置的0
那么出现存储策略为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，所以，如果参数配置过大，还会报出错误：
ERROR org.apache.hadoop.hdfs.server.datanode.DataNode: Exception in secureMain
java.lang.RuntimeException: Cannot start datanode because the configured max locked memory size (dfs.datanode.max.locked.memory) of 209715200 bytes is more than the datanode's available RLIMIT_MEMLOCK ulimit of 65536 bytes.
我们可以通过该命令查询此参数的内存
[fuhong@linux201 hadoop-3.1.3]$ ulimit -a
max locked memory (kbytes, -l) 64
6、HDFS—故障排除
注意：采用三台服务器即可，恢复到Yarn开始的服务器快照。
6.1 NameNode故障处理
1）需求：
NameNode进程挂了并且存储的数据也丢失了，如何恢复NameNode
2）故障模拟
（1）kill -9 NameNode进程
[fuhong@linux201 ~]$ jpsall
=============== linux201 ===============
4818 DataNode
128994 Jps
5845 JobHistoryServer
4598 NameNode
5513 NodeManager
=============== linux202 ===============
5025 NodeManager
127474 Jps
4821 ResourceManager
4312 DataNode
=============== linux203 ===============
4801 NodeManager
128183 Jps
4427 SecondaryNameNode
4191 DataNode
[fuhong@linux201 ~]$ kill -9 4598
#重启
[fuhong@linux201 ~]$ hdfs --daemon start namenode
（2）删除NameNode存储的数据（/opt/module/hadoop-3.1.3/data/tmp/dfs/name）-- 另一种方式
[fuhong@linux201 ~]$ cd /opt/module/hadoop-3.1.3/data/dfs/name/
[fuhong@linux201 name]$ kill -9 2972
[fuhong@linux201 name]$ rm -rf *
#发现不能开启namenode了
[fuhong@linux201 name]$ hdfs --daemon start namenode
[fuhong@linux201 name]$ jps
4818 DataNode
5845 JobHistoryServer
11640 Jps
5513 NodeManager
#查看日志
[fuhong@linux201 name]$ cd /opt/module/hadoop-3.1.3/logs/
[fuhong@linux201 logs]$ tail -n 100 hadoop-fuhong-namenode-linux201.log
2022-06-02 14:52:28,004 ERROR org.apache.hadoop.hdfs.server.namenode.NameNode: Failed to start namenode.
java.io.IOException: NameNode is not formatted.
at org.apache.hadoop.hdfs.server.namenode.FSImage.recoverTransitionRead(FSImage.java:250)
at org.apache.hadoop.hdfs.server.namenode.FSNamesystem.loadFSImage(FSNamesystem.java:1103)
at org.apache.hadoop.hdfs.server.namenode.FSNamesystem.loadFromDisk(FSNamesystem.java:718)
at org.apache.hadoop.hdfs.server.namenode.NameNode.loadNamesystem(NameNode.java:644)
at org.apache.hadoop.hdfs.server.namenode.NameNode.initialize(NameNode.java:706)
at org.apache.hadoop.hdfs.server.namenode.NameNode.<init>(NameNode.java:949)
at org.apache.hadoop.hdfs.server.namenode.NameNode.<init>(NameNode.java:922)
at org.apache.hadoop.hdfs.server.namenode.NameNode.createNameNode(NameNode.java:1688)
at org.apache.hadoop.hdfs.server.namenode.NameNode.main(NameNode.java:1755)
3）问题解决
（1）拷贝SecondaryNameNode中数据到原NameNode存储数据目录
namesecondary和namenode唯一的区别没有动态的日志
[fuhong@linux203 ~]$ cd /opt/module/hadoop-3.1.3/data/dfs/namesecondary/
[fuhong@linux203 namesecondary]$ ll
总用量 8
drwxrwxr-x. 2 fuhong fuhong 4096 5月 30 16:09 current
-rw-rw-r--. 1 fuhong fuhong 15 5月 30 10:11 in_use.lock
[fuhong@linux201 dfs]$ scp -r fuhong@linux203:/opt/module/hadoop-3.1.3/data/dfs/namesecondary/* ./name/
（2）重新启动NameNode
[fuhong@linux201 name]$ hdfs --daemon start namenode
[fuhong@linux201 name]$ jps
4818 DataNode
5845 JobHistoryServer
54485 Jps
5513 NodeManager
54254 NameNode
（3）向集群上传一个文件
6.2 集群安全模式&磁盘修复
1）安全模式：文件系统只接受读数据请求，而不接受删除、修改等变更请求
2）进入安全模式场景
NameNode在加载镜像文件和编辑日志期间处于安全模式； 集群启动的时候
NameNode再接收DataNode注册时，处于安全模式
3）退出安全模式条件
dfs.namenode.safemode.min.datanodes:最小可用datanode数量，默认0
dfs.namenode.safemode.threshold-pct:副本数达到最小要求的block占系统总block数的百分比，默认0.999f。（只允许丢一个块）
dfs.namenode.safemode.extension:稳定时间，默认值30000毫秒，即30秒
4）基本语法
集群处于安全模式，不能执行重要操作（写操作）。集群启动完成后，自动退出安全模式。
（1）bin/hdfs dfsadmin -safemode get （功能描述：查看安全模式状态）
（2）bin/hdfs dfsadmin -safemode enter （功能描述：进入安全模式状态）
（3）bin/hdfs dfsadmin -safemode leave （功能描述：离开安全模式状态）
（4）bin/hdfs dfsadmin -safemode wait （功能描述：等待安全模式状态）
5）案例1：启动集群进入安全模式
（1）重新启动集群
（2）页面删除文件无法删除
6）案例2：磁盘修复
需求：数据块损坏，进入安全模式，如何处理
（1）分别进入linux201、linux202、linux203的/opt/module/hadoop-3.1.3/data/dfs/data/current/BP-1015489500-192.168.10.102-1611909480872/current/finalized/subdir0/subdir0目录，统一删除某2个块信息
[fuhong@linux201 name]$ cd /opt/module/hadoop-3.1.3/data/dfs/data/current/BP-572461443-192.168.10.201-1641870291928/current/finalized/subdir0/subdir0/
[fuhong@linux202 ~]$ cd /opt/module/hadoop-3.1.3/data/dfs/data/current/BP-572461443-192.168.10.201-1641870291928/current/finalized/subdir0/subdir0/
[fuhong@linux203 namesecondary]$ cd /opt/module/hadoop-3.1.3/data/dfs/data/current/BP-572461443-192.168.10.201-1641870291928/current/finalized/subdir0/subdir0/
[fuhong@linux201 subdir0]$ rm -rf blk_1073741825 blk_1073741825_1001.meta blk_1073741846 blk_1073741846_1022.meta
[fuhong@linux202 subdir0]$ rm -rf blk_1073741825 blk_1073741825_1001.meta blk_1073741846 blk_1073741846_1022.meta
[fuhong@linux203 subdir0]$ rm -rf blk_1073741825 blk_1073741825_1001.meta blk_1073741846 blk_1073741846_1022.meta
目前namenode还不知道磁盘已经损坏，datanode每六小时向namenode汇报一次，或者集群重启时汇报
（2）重新启动集群
[fuhong@linux203 subdir0]$ myhadoop.sh stop
[fuhong@linux203 subdir0]$ myhadoop.sh start
（3）观察http://linux201:9870/dfshealth.html#tab-overview
说明：安全模式已经打开，块的数量没有达到要求。
（4）离开安全模式
#查看安全模式
[fuhong@linux203 subdir0]$ hdfs dfsadmin -safemode get
Safe mode is ON
[fuhong@linux203 subdir0]$ hdfs dfsadmin -safemode leave
Safe mode is OFF
（6）将元数据删除
（7）观察http://linux201:9870/dfshealth.html#tab-overview，集群已经正常
7）案例3：
需求：模拟等待安全模式
（1）查看当前模式
#查看安全模式
[fuhong@linux203 subdir0]$ hdfs dfsadmin -safemode get
Safe mode is OFF
（2）先进入安全模式
[fuhong@linux203 hadoop-3.1.3]$ bin/hdfs dfsadmin -safemode enter
Safe mode is ON
（3）创建并执行下面的脚本
在/opt/module/hadoop-3.1.3路径上，编辑一个脚本safemode.sh
[fuhong@linux201 subdir0]$ cd /opt/module/hadoop-3.1.3/
[fuhong@linux201 hadoop-3.1.3]$ vim safemode.sh
#安全模式下 进行等待
#!/bin/bash
hdfs dfsadmin -safemode wait
hdfs dfs -put /opt/module/hadoop-3.1.3/README.txt /
[fuhong@linux201 hadoop-3.1.3]$ chmod 777 safemode.sh
# 执行脚本
[fuhong@linux201 hadoop-3.1.3]$ ./safemode.sh
（4）再打开一个窗口，执行
[fuhong@linux203 hadoop-3.1.3]$ bin/hdfs dfsadmin -safemode leave
Safe mode is OFF
（5）再观察上一个窗口
Safe mode is OFF
（6）HDFS集群上已经有上传的数据
6.3 慢磁盘监控
“慢磁盘”指的时写入数据非常慢的一类磁盘。其实慢性磁盘并不少见，当机器运行时间长了，上面跑的任务多了，磁盘的读写性能自然会退化，严重时就会出现写入数据延时的问题。
如何发现慢磁盘？
正常在HDFS上创建一个目录，只需要不到1s的时间。如果你发现创建目录超过1分钟及以上，而且这个现象并不是每次都有。只是偶尔慢了一下，就很有可能存在慢磁盘。
可以采用如下方法找出是哪块磁盘慢：
1）通过心跳未联系时间。
一般出现慢磁盘现象，会影响到DataNode与NameNode之间的心跳。正常情况心跳时间间隔是3s。超过3s说明有异常。
2）fio命令，测试磁盘的读写性能
（1）顺序读测试
[fuhong@linux201 hadoop-3.1.3]$ sudo yum install -y fio
[fuhong@linux201 hadoop-3.1.3]$ sudo fio -filename=/home/fuhong/test.log -direct=1 -iodepth 1 -thread -rw=read -ioengine=psync -bs=16k -size=2G -numjobs=10 -runtime=60 -group_reporting -name=test_r
Run status group 0 (all jobs):
READ: bw=516MiB/s (541MB/s), 516MiB/s-516MiB/s (541MB/s-541MB/s), io=20.0GiB (21.5GB), run=39686-39686msec
#结果显示，磁盘的总体顺序读速度为516MiB/s。
（2）顺序写测试
[fuhong@linux201 hadoop-3.1.3]$ sudo fio -filename=/home/fuhong/test.log -direct=1 -iodepth 1 -thread -rw=write -ioengine=psync -bs=16k -size=2G -numjobs=10 -runtime=60 -group_reporting -name=test_w
Run status group 0 (all jobs):
WRITE: bw=481MiB/s (504MB/s), 481MiB/s-481MiB/s (504MB/s-504MB/s), io=20.0GiB (21.5GB), run=42589-42589msec
#结果显示，磁盘的总体顺序写速度为481MiB/s。
（3）随机写测试
[fuhong@linux201 hadoop-3.1.3]$ sudo fio -filename=/home/fuhong/test.log -direct=1 -iodepth 1 -thread -rw=randwrite -ioengine=psync -bs=16k -size=2G -numjobs=10 -runtime=60 -group_reporting -name=test_randw
Run status group 0 (all jobs):
WRITE: bw=435MiB/s (457MB/s), 435MiB/s-435MiB/s (457MB/s-457MB/s), io=20.0GiB (21.5GB), run=47028-47028msec
#结果显示，磁盘的总体随机写速度为435MiB/s。
（4）混合随机读写
[fuhong@linux201 hadoop-3.1.3]$ sudo fio -filename=/home/fuhong/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
Run status group 0 (all jobs):
READ: bw=295MiB/s (310MB/s), 295MiB/s-295MiB/s (310MB/s-310MB/s), io=13.0GiB (15.0GB), run=48502-48502msec
WRITE: bw=127MiB/s (133MB/s), 127MiB/s-127MiB/s (133MB/s-133MB/s), io=6149MiB (6447MB), run=48502-48502msec
#结果显示，磁盘的总体混合随机读写，读速度为295MiB/s，写速度127MiB/s。
6.4 小文件归档
1）HDFS存储小文件弊端
每个文件均按块存储，每个块的元数据存储在NameNode的内存中，因此HDFS存储小文件会非常低效。因为大量的小文件会耗尽NameNode中的大部分内存。但注意，存储小文件所需要的磁盘容量和数据块的大小无关。例如，一个1MB的文件设置为128MB的块存储，实际使用的是1MB的磁盘空间，而不是128MB。
2）解决存储小文件办法之一
HDFS存档文件或HAR文件，是一个更高效的文件存档工具，它将文件存入HDFS块，在减少NameNode内存使用的同时，允许对文件进行透明的访问。具体说来，HDFS存档文件对内还是一个一个独立文件，对NameNode而言却是一个整体，减少了NameNode的内存。
3）案例实操
（1）需要启动YARN进程
[fuhong@linux201 hadoop-3.1.3]$ start-yarn.sh
（2）归档文件
把/input目录里面的所有文件归档成一个叫input.har的归档文件，并把归档后文件存储到/output路径下。
[fuhong@linux201 hadoop-3.1.3]$ hadoop archive -archiveName input.har -p /input /output
（3）查看归档
[fuhong@linux201 hadoop-3.1.3]$ hadoop fs -ls /output/input.har
Found 4 items
-rw-r--r-- 3 fuhong supergroup 0 2022-06-02 17:05 /output/input.har/_SUCCESS
-rw-r--r-- 3 fuhong supergroup 295 2022-06-02 17:05 /output/input.har/_index
-rw-r--r-- 3 fuhong supergroup 23 2022-06-02 17:05 /output/input.har/_masterindex
-rw-r--r-- 3 fuhong supergroup 1302 2022-06-02 17:05 /output/input.har/part-0
[fuhong@linux201 hadoop-3.1.3]$ hadoop fs -ls har:///output/input.har
2022-06-02 17:08:25,115 INFO sasl.SaslDataTransferClient: SASL encryption trust check: localHostTrusted = false, remoteHostTrusted = false
Found 3 items
-rw-r--r-- 3 fuhong supergroup 60 2022-06-02 17:03 har:///output/input.har/hello.txt
-rw-r--r-- 3 fuhong supergroup 64 2022-06-02 17:02 har:///output/input.har/order.txt
-rw-r--r-- 3 fuhong supergroup 1178 2022-06-02 17:02 har:///output/input.har/phone_data.txt
（4）解归档文件 到根目录下
[fuhong@linux201 hadoop-3.1.3]$ hadoop fs -cp har:///output/input.har/* /
7、HDFS-集群迁移
7.1 Apache和Apache集群间数据拷贝
1）scp实现两个远程主机之间的文件复制
scp -r hello.txt root@linux203:/user/fuhong/hello.txt // 推 push
scp -r root@linux203:/user/fuhong/hello.txt hello.txt // 拉 pull
scp -r root@linux203:/user/fuhong/hello.txt root@linux202:/user/fuhong //是通过本地主机中转实现两个远程主机的文件复制；如果在两个远程主机之间ssh没有配置的情况下可以使用该方式。
2）采用distcp命令实现两个Hadoop集群之间的递归数据复制
[fuhong@linux203 hadoop-3.1.3]$ bin/hadoop distcp hdfs://linux203:8020/user/fuhong/hello.txt hdfs://linux204:8020/user/fuhong/hello.txt
7.2 Apache和CDH集群间数据拷贝
(略)
8、MapReduce生产经验
8.1 MapReduce跑的慢的原因
MapReduce程序效率的瓶颈在于两点：
1）计算机性能
CPU、内存、磁盘、网络
2）I/O操作优化
（1）数据倾斜（同一个reduce的key太多）
（2）Map运行时间太长，导致Reduce等待过久
（3）小文件过多
8.2 MapReduce常用调优参数
8.3 MapReduce数据倾斜问题
1）数据倾斜现象
数据频率倾斜——某一个区域的数据量要远远大于其他区域。
数据大小倾斜——部分记录的大小远远大于平均值。
2）减少数据倾斜的方法
（1）首先检查是否空值过多造成的数据倾斜
生产环境，可以直接过滤掉空值；如果想保留空值，就自定义分区，将空值加随机数打散。最后再二次聚合。
（2）能在map阶段提前处理，最好先在Map阶段处理。如：Combiner、MapJoin
（3）设置多个reduce个数
9、 Hadoop-Yarn生产经验
9.1 常用的调优参数
1）调优参数列表
（1）Resourcemanager相关
yarn.resourcemanager.scheduler.client.thread-count ResourceManager处理调度器请求的线程数量
yarn.resourcemanager.scheduler.class 配置调度器
（2）Nodemanager相关
yarn.nodemanager.resource.memory-mb NodeManager使用内存数
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 虚拟内存物理内存比例
（3）Container容器相关
yarn.scheduler.minimum-allocation-mb 容器最小内存
yarn.scheduler.maximum-allocation-mb 容器最大内存
yarn.scheduler.minimum-allocation-vcores 容器最小核数
yarn.scheduler.maximum-allocation-vcores 容器最大核数
10、Hadoop综合调优
10.1 Hadoop小文件优化方法
10.1.1 Hadoop小文件弊端
HDFS上每个文件都要在NameNode上创建对应的元数据，这个元数据的大小约为150byte，这样当小文件比较多的时候，就会产生很多的元数据文件，一方面会大量占用NameNode的内存空间，另一方面就是元数据文件过多，使得寻址索引速度变慢。
小文件过多，在进行MR计算时，会生成过多切片，需要启动过多的MapTask。每个MapTask处理的数据量小，导致MapTask的处理时间比启动时间还小，白白消耗资源。
10.1.2 Hadoop小文件解决方案
1）在数据采集的时候，就将小文件或小批数据合成大文件再上传HDFS（数据源头）
2）Hadoop Archive（存储方向）
是一个高效的将小文件放入HDFS块中的文件存档工具，能够将多个小文件打包成一个HAR文件，从而达到减少NameNode的内存使用
3）CombineTextInputFormat（计算方向）
CombineTextInputFormat用于将多个小文件在切片过程中生成一个单独的切片或者少量的切片。
4）开启uber模式，实现JVM重用（计算方向）
默认情况下，每个Task任务都需要启动一个JVM来运行，如果Task任务计算的数据量很小，我们可以让同一个Job的多个Task运行在一个JVM中，不必为每个Task都开启一个JVM。
（1）未开启uber模式，在/input路径上上传多个小文件并执行wordcount程序
[fuhong@linux201 ~]$ cd /opt/module/hadoop-3.1.3/
[fuhong@linux201 hadoop-3.1.3]$ hadoop jar share/hadoop/mapreduce/hadoop-mapreduce-examples-3.1.3.jar wordcount /input /output2
（2）观察控制台
2022-07-30 17:00:21,131 INFO mapreduce.Job: Job job_1659068214282_0001 running in uber mode : false
（3）观察http://linux202:8088/cluster
（4）开启uber模式，在mapred-site.xml中添加如下配置
[fuhong@linux201 hadoop-3.1.3]$ cd etc/hadoop/
[fuhong@linux201 hadoop]$ vim 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>
（5）分发配置
[fuhong@linux201 hadoop]$ xsync mapred-site.xml
（6）再次执行wordcount程序
[fuhong@linux201 hadoop-3.1.3]$ hadoop jar share/hadoop/mapreduce/hadoop-mapreduce-examples-3.1.3.jar wordcount /input /output3
（7）观察控制台
2022-07-30 17:26:20,409 INFO mapreduce.Job: Job job_1659068214282_0002 running in uber mode : true
（8）观察http://linux202:8088/cluster
10.2 测试MapReduce计算性能
使用Sort程序评测MapReduce
注：一个虚拟机不超过150G磁盘尽量不要执行这段代码
（1）使用RandomWriter来产生随机数，每个节点运行10个Map任务，每个Map产生大约1G大小的二进制随机数
[fuhong@linux201 mapreduce]$ hadoop jar /opt/module/hadoop-3.1.3/share/hadoop/mapreduce/hadoop-mapreduce-examples-3.1.3.jar randomwriter random-data
（2）执行Sort程序
[fuhong@linux201 mapreduce]$ hadoop jar /opt/module/hadoop-3.1.3/share/hadoop/mapreduce/hadoop-mapreduce-examples-3.1.3.jar sort random-data sorted-data
（3）验证数据是否真正排好序了
[fuhong@linux201 mapreduce]$
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
10.3 企业开发场景案例
10.3.1 需求
（1）需求：从1G数据中，统计每个单词出现次数。服务器3台，每台配置4G内存，4核CPU，4线程。
（2）需求分析：
1G / 128m = 8个MapTask；1个ReduceTask；1个mrAppMaster
平均每个节点运行10个 / 3台 ≈ 3个任务（4 3 3）
10.3.2 HDFS参数调优
（1）修改：hadoop-env.sh
[fuhong@linux201 hadoop-3.1.3]$ cd /opt/module/hadoop-3.1.3/etc/hadoop/
[fuhong@linux201 hadoop]$ vim hadoop-env.sh
export HDFS_NAMENODE_OPTS="-Dhadoop.security.logger=INFO,RFAS -Xmx1024m"
export HDFS_DATANODE_OPTS="-Dhadoop.security.logger=ERROR,RFAS -Xmx1024m"
（2）修改hdfs-site.xml
[fuhong@linux201 hadoop]$ vim hdfs-site.xml
<!-- NameNode有一个工作线程池，默认值是10 -->
<property>
<name>dfs.namenode.handler.count</name>
<value>21</value>
</property>
（3）修改core-site.xml
[fuhong@linux201 hadoop]$ vim core-site.xml
<!-- 配置垃圾回收时间为60分钟 -->
<property>
<name>fs.trash.interval</name>
<value>60</value>
</property>
（4）分发配置
[fuhong@linux201 hadoop]$ xsync hdfs-site.xml core-site.xml hadoop-env.sh
10.3.3 MapReduce参数调优
（1）修改mapred-site.xml
[fuhong@linux201 hadoop]$ vim 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>
<description>The amount of memory to request from the scheduler for each map task. If this is not specified or is non-positive, it is inferred from mapreduce.map.java.opts and mapreduce.job.heap.memory-mb.ratio. If java-opts are also not specified, we set it to 1024.
</description>
</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>
<description>The amount of memory to request from the scheduler for each reduce task. If this is not specified or is non-positive, it is inferred
from mapreduce.reduce.java.opts and mapreduce.job.heap.memory-mb.ratio.
If java-opts are also not specified, we set it to 1024.
</description>
</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>
（2）分发配置
[fuhong@linux201 hadoop]$ xsync mapred-site.xml
10.3.4 Yarn参数调优
（1）修改yarn-site.xml配置参数如下：
[fuhong@linux201 hadoop]$ vim yarn-site.xml
<!-- 选择调度器，默认容量 -->
<property>
<description>The class to use as the resource scheduler.</description>
<name>yarn.resourcemanager.scheduler.class</name>
<value>org.apache.hadoop.yarn.server.resourcemanager.scheduler.capacity.CapacityScheduler</value>
</property>
<!-- ResourceManager处理调度器请求的线程数量,默认50；如果提交的任务数大于50，可以增加该值，但是不能超过3台 * 4线程 = 12线程（去除其他应用程序实际不能超过8） -->
<property>
<description>Number of threads to handle scheduler interface.</description>
<name>yarn.resourcemanager.scheduler.client.thread-count</name>
<value>8</value>
</property>
<!-- 是否让yarn自动检测硬件进行配置，默认是false，如果该节点有很多其他应用程序，建议手动配置。如果该节点没有其他应用程序，可以采用自动 -->
<property>
<description>Enable auto-detection of node capabilities such as
memory and CPU.
</description>
<name>yarn.nodemanager.resource.detect-hardware-capabilities</name>
<value>false</value>
</property>
<!-- 是否将虚拟核数当作CPU核数，默认是false，采用物理CPU核数 -->
<property>
<description>Flag to determine if logical processors(such as
hyperthreads) should be counted as cores. Only applicable on Linux
when yarn.nodemanager.resource.cpu-vcores is set to -1 and
yarn.nodemanager.resource.detect-hardware-capabilities is true.
</description>
<name>yarn.nodemanager.resource.count-logical-processors-as-cores</name>
<value>false</value>
</property>
<!-- 虚拟核数和物理核数乘数，默认是1.0 -->
<property>
<description>Multiplier to determine how to convert phyiscal cores to
vcores. This value is used if yarn.nodemanager.resource.cpu-vcores
is set to -1(which implies auto-calculate vcores) and
yarn.nodemanager.resource.detect-hardware-capabilities is set to true. The number of vcores will be calculated as number of CPUs * multiplier.
</description>
<name>yarn.nodemanager.resource.pcores-vcores-multiplier</name>
<value>1.0</value>
</property>
<!-- NodeManager使用内存数，默认8G，修改为4G内存 -->
<property>
<description>Amount of physical memory, in MB, that can be allocated
for containers. If set to -1 and
yarn.nodemanager.resource.detect-hardware-capabilities is true, it is
automatically calculated(in case of Windows and Linux).
In other cases, the default is 8192MB.
</description>
<name>yarn.nodemanager.resource.memory-mb</name>
<value>4096</value>
</property>
<!-- nodemanager的CPU核数，不按照硬件环境自动设定时默认是8个，修改为4个 -->
<property>
<description>Number of vcores that can be allocated
for containers. This is used by the RM scheduler when allocating
resources for containers. This is not used to limit the number of
CPUs used by YARN containers. If it is set to -1 and
yarn.nodemanager.resource.detect-hardware-capabilities is true, it is
automatically determined from the hardware in case of Windows and Linux.
In other cases, number of vcores is 8 by default.</description>
<name>yarn.nodemanager.resource.cpu-vcores</name>
<value>4</value>
</property>
<!-- 容器最小内存，默认1G -->
<property>
<description>The minimum allocation for every container request at the RM in MBs. Memory requests lower than this will be set to the value of this property. Additionally, a node manager that is configured to have less memory than this value will be shut down by the resource manager.
</description>
<name>yarn.scheduler.minimum-allocation-mb</name>
<value>1024</value>
</property>
<!-- 容器最大内存，默认8G，修改为2G -->
<property>
<description>The maximum allocation for every container request at the RM in MBs. Memory requests higher than this will throw an InvalidResourceRequestException.
</description>
<name>yarn.scheduler.maximum-allocation-mb</name>
<value>2048</value>
</property>
<!-- 容器最小CPU核数，默认1个 -->
<property>
<description>The minimum allocation for every container request at the RM in terms of virtual CPU cores. Requests lower than this will be set to the value of this property. Additionally, a node manager that is configured to have fewer virtual cores than this value will be shut down by the resource manager.
</description>
<name>yarn.scheduler.minimum-allocation-vcores</name>
<value>1</value>
</property>
<!-- 容器最大CPU核数，默认4个，修改为2个 -->
<property>
<description>The maximum allocation for every container request at the RM in terms of virtual CPU cores. Requests higher than this will throw an
InvalidResourceRequestException.</description>
<name>yarn.scheduler.maximum-allocation-vcores</name>
<value>2</value>
</property>
<!-- 虚拟内存检查，默认打开，修改为关闭 -->
<property>
<description>Whether virtual memory limits will be enforced for
containers.</description>
<name>yarn.nodemanager.vmem-check-enabled</name>
<value>false</value>
</property>
<!-- 虚拟内存和物理内存设置比例,默认2.1 -->
<property>
<description>Ratio between virtual memory to physical memory when setting memory limits for containers. Container allocations are expressed in terms of physical memory, and virtual memory usage is allowed to exceed this allocation by this ratio.
</description>
<name>yarn.nodemanager.vmem-pmem-ratio</name>
<value>2.1</value>
</property>
（2）分发配置
[fuhong@linux201 hadoop]$ xsync yarn-site.xml
10.3.5 执行程序
（1）重启集群
[fuhong@linux201 hadoop-3.1.3]$ myhadoop.sh stop
[fuhong@linux201 hadoop-3.1.3]$ myhadoop.sh start
（2）执行WordCount程序
[fuhong@linux201 hadoop-3.1.3]$ hadoop jar share/hadoop/mapreduce/hadoop-mapreduce-examples-3.1.3.jar wordcount /input /output
（3）观察Yarn任务执行页面
http://linux202:8088/cluster/apps
六、源码解析
1、RPC通信原理解析
1）回顾
2）需求：
模拟RPC的客户端、服务端、通信协议三者如何工作的
3）代码编写：
（1）在HadoopDemo项目基础上创建包名com.fuhong.rpc
/**
* @author lfh
* @description 协议
* @date 2022/7/30 22:23
*/
public interface RPCProtocol {
/**
* 规定版本号
*/
long versionID = 1433L;
/**
* 创建文件夹方法
* @param path 文件路径
*/
void mkdirs(String path);
}
（2）创建RPC协议
import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.ipc.RPC;
import java.io.IOException;
/**
* @author lfh
* @description 服务端 实现通信接口
* @date 2022/7/30 22:26
*/
public class NNService implements RPCProtocol {
public static void main(String[] args) throws IOException {
//启动服务
RPC.Server server = new RPC.Builder(new Configuration())
.setBindAddress("localhost")
.setPort(8888)
.setProtocol(RPCProtocol.class)
.setInstance(new NNService())
.build();
System.out.println("服务器开始工作");
server.start();
}
@Override
public void mkdirs(String path) {
System.out.println("服务器接收到客户端请求：" + path);
}
}
（3）创建RPC服务端
import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.ipc.RPC;
import java.io.IOException;
import java.net.InetSocketAddress;
/**
* @author lfh
* @description 客户端
* @date 2022/7/30 22:37
*/
public class HDFSClient {
public static void main(String[] args) throws IOException {
//获取客户端对象
RPCProtocol client = RPC.getProxy(RPCProtocol.class
, RPCProtocol.versionID, new InetSocketAddress("localhost", 8888)
, new Configuration());
System.out.println("客户端开始工作");
client.mkdirs("/input");
}
}
3）测试
（1）启动服务端
观察控制台打印：服务器开始工作
在控制台Terminal窗口输入，jps，查看到NNServer服务
（2）启动客户端
观察客户端控制台打印：我是客户端
观察服务端控制台打印：服务端，创建路径/input
4）总结
RPC的客户端调用通信协议方法，方法的执行在服务端；
通信协议就是接口规范。
2、NameNode启动源码解析
1）在pom.xml中增加如下依赖
<dependency>
<groupId>org.apache.hadoop</groupId>
<artifactId>hadoop-client</artifactId>
<version>3.1.3</version>
</dependency>
<dependency>
<groupId>org.apache.hadoop</groupId>
<artifactId>hadoop-hdfs</artifactId>
<version>3.1.3</version>
</dependency>
<dependency>
<groupId>org.apache.hadoop</groupId>
<artifactId>hadoop-hdfs-client</artifactId>
<version>3.1.3</version>
<scope>provided</scope>
</dependency>
ctrl + n 全局查找namenode，进入NameNode.java
NameNode启动流程方法树状图
1.初始化http服务端
2.加载镜像文件
3.创建rpc通信服务
4.启动对NN资源检测
5.NN心跳管理超时判断
6.NN安全模式管理
//main方法
public static void main(String argv[]) throws Exception
//1.1.createNameNode方法
NameNode namenode = createNameNode(argv, null);
//1.2.创建nameNode对象
return new NameNode(conf);
//1.3.初始化
initialize(getConf());
//1.4.启动http服务
startHttpServer(conf);
//1.5.查看启动服务端口号getHttpServerBindAddress(conf)方法
httpServer = new NameNodeHttpServer(conf, this, getHttpServerBindAddress(conf));
getHttpServerAddress(conf);
getHttpAddress(conf);
//1.6.DFS_NAMENODE_HTTP_ADDRESS_DEFAULT 9870
return NetUtils.createSocketAddr(
conf.getTrimmed(DFS_NAMENODE_HTTP_ADDRESS_KEY, DFS_NAMENODE_HTTP_ADDRESS_DEFAULT));
//1.7.启动http服务端
httpServer.start();
//2.1.加载镜像文件
loadNamesystem(conf);
//2.2从磁盘上加载镜像文件
this.namesystem = FSNamesystem.loadFromDisk(conf);
//2.3 从编辑日志存储路径和镜像文件存储路径加载
FSImage fsImage = new FSImage(conf,
FSNamesystem.getNamespaceDirs(conf),
FSNamesystem.getNamespaceEditsDirs(conf));
//2.4加载操作
namesystem.loadFSImage(startOpt);
//3.1创建rpc通信服务
rpcServer = createRpcServer(conf);
//3.2创建对象
return new NameNodeRpcServer(conf, this);
//3.3bulider
serviceRpcServer = new RPC.Builder(conf)
.setProtocol(
org.apache.hadoop.hdfs.protocolPB.ClientNamenodeProtocolPB.class)
.setInstance(clientNNPbService)
.setBindAddress(bindHost)
.setPort(serviceRpcAddr.getPort())
.setNumHandlers(serviceHandlerCount)
.setVerbose(false)
.setSecretManager(namesystem.getDelegationTokenSecretManager())
.build();
//4.1启动NN资源检测
startCommonServices(conf);
namesystem.startCommonServices(conf, haContext);
nnResourceChecker = new NameNodeResourceChecker(conf);
//4.2默认元数据存储空间100mDFSConfigKeys.DFS_NAMENODE_DU_RESERVED_DEFAULT
duReserved = conf.getLong(DFSConfigKeys.DFS_NAMENODE_DU_RESERVED_KEY,
DFSConfigKeys.DFS_NAMENODE_DU_RESERVED_DEFAULT);
//4.3真正的资源检测
checkAvailableResources();
//4.4是否有存储空间
hasResourcesAvailable = nnResourceChecker.hasAvailableDiskSpace();
//4.5判断方法
return NameNodeResourcePolicy.areResourcesAvailable(volumes.values(),
minimumRedundantVolumes);
//4.6资源是否够用
resource.isResourceAvailable()
//4.7ctrl+alt+b找实现类，并对磁盘空间信息进行检测判断
//5.1心跳 -nameNode dataNode
blockManager.activate(conf, completeBlocksTotal);
//5.2管理
datanodeManager.activate(conf);
//5.3心跳管理
heartbeatManager.activate();
//5.4心跳线程启动
heartbeatThread.start();
//5.5查看线程run方法 心跳检查
heartbeatCheck();
//5.6遍历每一个dataNode 判断是否死掉
//heartbeatExpireInterval
dm.isDatanodeDead(d)
//5.7时间 10分钟+30S
this.heartbeatExpireInterval = 2 * heartbeatRecheckInterval
+ 10 * 1000 * heartbeatIntervalSeconds;
//6.1安全模式管理
bmSafeMode.activate(blockTotal);
//6.2 允许启动的块儿的正常的比列
setBlockTotal(total);
//6.3 threshold = 0.999
this.blockThreshold = (long) (total * threshold);
//6.4判断进入安全模式或离开安全模式
areThresholdsMet()
//6.5已经启动的数量是否大于等于阈值数量
return blockSafe >= blockThreshold && datanodeNum >= datanodeThreshold;
3、DataNode启动源码解析
工作机制
DataNode启动源码解析
pom文件同上
DataNode启动流程方法树状图
ctrl + n 全局查找datanode，进入DataNode.java
1.初始化DataXceiverServer
2.初始化HTTP服务
3.初始化DN的RPC服务端
4.DN向NN注册
5.向NN发送心跳
//main方法
public static void main(String args[])
secureMain(args, null);
//1.1创建dataNode
DataNode datanode = createDataNode(args, null, resources);
//1.2初始化detanode
DataNode dn = instantiateDataNode(args, conf, resources);
//1.3创建实例
return makeInstance(dataLocations, conf, resources);
//1.4真正的初始化代码
return new DataNode(conf, locations, storageLocationChecker, resources);
//1.5
startDataNode(dataDirs, resources);
//1.6对DN全局的一个初始化
initDataXceiver();
//1.7开启一个线程
this.dataXceiverServer = new Daemon(threadGroup, xserver);
//2.1初始化http服务
startInfoServer();
//2.2获取httpservice
httpServer = new DatanodeHttpServer(getConf(), this, httpServerChannel);
//2.3对httpservice进行封装
HttpServer2.Builder builder = new HttpServer2.Builder()
.setName("datanode")
.setConf(confForInfoServer)
.setACL(new AccessControlList(conf.get(DFS_ADMIN, " ")))
.hostName(getHostnameForSpnegoPrincipal(confForInfoServer))
.addEndpoint(URI.create("http://localhost:" + proxyPort))
.setFindPort(true);
//3.1初始化rpc服务
initIpcServer();
//3.2创建rpc服务端
ipcServer = new RPC.Builder(getConf())
.setProtocol(ClientDatanodeProtocolPB.class)
.setInstance(service)
.setBindAddress(ipcAddr.getHostName())
.setPort(ipcAddr.getPort())
.setNumHandlers(
getConf().getInt(DFS_DATANODE_HANDLER_COUNT_KEY,
DFS_DATANODE_HANDLER_COUNT_DEFAULT)).setVerbose(false)
.setSecretManager(blockPoolTokenSecretManager).build();
//4.1刷写NameNode
blockPoolManager.refreshNamenodes(getConf());
doRefreshNamenodes(newAddressMap, newLifelineAddressMap);
//4.2创建服务对象 遍历所有的NNrpc服务端，每一个NNrpc服务端创建一个bpos对象
BPOfferService bpos = createBPOS(nsToAdd, addrs, lifelineAddrs);
return new BPOfferService(nameserviceId, nnAddrs, lifelineNnAddrs, dn);
//4.3遍历NN 每一个NN创建BPservice
this.bpServices.add(new BPServiceActor(nnAddrs.get(i),
lifelineNnAddrs.get(i), this));
//4.4开启所有服务
startAll();
bpos.start();
actor.start();
//4.5开启一个线程 对每一个namenode进行注册
bpThread.start();
//4.6 线程run方法，链接NN
connectToNNAndHandshake();
//4.7获取NN代理
bpNamenode = dn.connectToNN(nnAddr);
return new DatanodeProtocolClientSideTranslatorPB(nnAddr, getConf());
//4.8创建代理
rpcProxy = createNamenode(nameNodeAddr, conf, ugi);
//4.9获取代理对象
return RPC.getProxy(DatanodeProtocolPB.class,
RPC.getProtocolVersion(DatanodeProtocolPB.class), nameNodeAddr, ugi,
conf, NetUtils.getSocketFactory(conf, DatanodeProtocolPB.class));
//4.10进行注册
register(nsInfo);
//4.11向代理对象RPC发消息注册DN，转4.12
newBpRegistration = bpNamenode.registerDatanode(newBpRegistration);
resp = rpcProxy.registerDatanode(NULL_CONTROLLER, builder.build());
//5.1心跳信息发送
offerService();
//5.2给NN发送心跳
resp = sendHeartBeat(requestBlockReportLease);
//5.3向代理对象RPC发送心跳，转5.4
HeartbeatResponse response = bpNamenode.sendHeartbeat(bpRegistration,
reports,
dn.getFSDataset().getCacheCapacity(),
dn.getFSDataset().getCacheUsed(),
dn.getXmitsInProgress(),
dn.getXceiverCount(),
numFailedVolumes,
volumeFailureSummary,
requestBlockReportLease,
slowPeers,
slowDisks);
由上面4.11步骤转到NameNodeRpcServer.java
最开始由NameNode开启了RPC访问服务，DataNode发送消息应该是在NameNodeRpcServer接收
//registerDatanode方法接收DataNode的注册消息
//4.12接收的注册信息
namesystem.registerDatanode(nodeReg);
blockManager.registerDatanode(nodeReg);
//4.13注册dataNode
datanodeManager.registerDatanode(nodeReg);
//4.14注册信息添加
addDatanode(nodeDescr);
//4.15添加心跳管理
heartbeatManager.addDatanode(nodeDescr);
//sendHeartbeat方法接收DataNode的注册消息
//5.4处理心跳
return namesystem.handleHeartbeat(nodeReg, report,
dnCacheCapacity, dnCacheUsed, xceiverCount, xmitsInProgress,
failedVolumes, volumeFailureSummary, requestFullBlockReportLease,
slowPeers, slowDisks);
//5.5处理心跳
DatanodeCommand[] cmds = blockManager.getDatanodeManager().handleHeartbeat(
nodeReg, reports, getBlockPoolId(), cacheCapacity, cacheUsed,
xceiverCount, maxTransfer, failedVolumes, volumeFailureSummary,
slowPeers, slowDisks);
//5.6更新心跳相关信息
heartbeatManager.updateHeartbeat(nodeinfo, reports, cacheCapacity,
cacheUsed, xceiverCount, failedVolumes, volumeFailureSummary);
//5.7更新
blockManager.updateHeartbeat(node, reports, cacheCapacity, cacheUsed,
xceiverCount, failedVolumes, volumeFailureSummary);
//5.8更新方法
node.updateHeartbeat(reports, cacheCapacity, cacheUsed, xceiverCount,
failedVolumes, volumeFailureSummary);
//5.9更新
updateHeartbeatState(reports, cacheCapacity, cacheUsed, xceiverCount, volFailures, volumeFailureSummary);
//5.10更新存储状态信息
updateStorageStats(reports, cacheCapacity, cacheUsed, xceiverCount, volFailures, volumeFailureSummary);
//5.11更新心跳发送时间
setLastUpdate(Time.now());
setLastUpdateMonotonic(Time.monotonicNow());
//5.12返回给DataNode信息响应心跳
return new HeartbeatResponse(cmds, haState, rollingUpgradeInfo,
blockReportLeaseId);
4、HDFS上传源码解析
HDFS写数据流程
HDFS上传源码解析
pom文件同上
4.1 create创建过程
自己的代码
private FileSystem fs;
@Before
public void init() throws IOException, InterruptedException, URISyntaxException {
// 1 获取文件系统
Configuration configuration = new Configuration();
//configuration.set("dfs.replication", "2");
fs = FileSystem.get(new URI("hdfs://linux201:8020"), configuration, "fuhong");
}
@Test
public void testPut2() throws IOException {
//创建路径
FSDataOutputStream fos = fs.create(new Path("/input"));
//写数据
fos.write("hello world".getBytes());
}
创建过程
1.DN向NN发起创建请求
2.NN处理DN的创建请求
3.DataStreamer创建输出流
//1.1create方法
FSDataOutputStream fos = fs.create(new Path("/input"));
//其中子方法只包含一个方法就跳过直接进入方法
//1.2.分布式文件系统 实现类找DistributedFileSystem.java的create方法
return this.create(f, permission,
overwrite ? EnumSet.of(CreateFlag.CREATE, CreateFlag.OVERWRITE)
: EnumSet.of(CreateFlag.CREATE), bufferSize, replication,
blockSize, progress, null);
//1.3
final DFSOutputStream dfsos = dfs.create(getPathName(p), permission,
cflags, replication, blockSize, progress, bufferSize,
checksumOpt);
//跳过一系列的create方法
//1.4输出流创建
final DFSOutputStream result = DFSOutputStream.newStreamForCreate(this,
src, masked, flag, createParent, replication, blockSize, progress,
dfsClientConf.createChecksum(checksumOpt),
getFavoredNodesStr(favoredNodes), ecPolicyName);
//1.5客户端代码 向NameNode RPC服务端发送请求 获取nameNode 同意应答
stat = dfsClient.namenode.create(src, masked, dfsClient.clientName,
new EnumSetWritable<>(flag), createParent, replication,
blockSize, SUPPORTED_CRYPTO_VERSIONS, ecPolicyName);
//2.1NameNodeRpcService.java create方法 接收RPC请求
status = namesystem.startFile(src, perm, clientName, clientMachine,
flag.get(), createParent, replication, blockSize, supportedVersions,
ecPolicyName, cacheEntry != null);
//2.2
status = startFileInt(src, permissions, holder, clientMachine, flag, createParent, replication, blockSize, supportedVersions, ecPolicyName, logRetryCache);
//2.3 这个方法 如果文件存在抛异常
stat = FSDirWriteFileOp.startFile(this, iip, permissions, holder, clientMachine, flag, createParent, replication, blockSize, feInfo,
toRemoveBlocks, shouldReplicate, ecPolicyName, logRetryCache);
//2.4添加文件
iip = addFile(fsd, parent, iip.getLastLocalName(), permissions, replication, blockSize, holder, clientMachine, shouldReplicate, ecPolicyName);
//2.5
INodeFile newNode = newINodeFile(fsd.allocateNewInodeId(), permissions, modTime, modTime, replicationFactor, ecPolicyID, preferredBlockSize, blockType);
//2.6添加文件节点
newiip = fsd.addINode(existing, newNode, permissions.getPermission());
//3.1获取namenode同意之后，创建输出流
out = new DFSOutputStream(dfsClient, src, stat, flag, progress, checksum, favoredNodes, true);
//3.2 packetSize bodySize chunkSize
computePacketChunkSize(dfsClient.getConf().getWritePacketSize(), bytesPerChecksum);
//3.3
out.start();
//3.4这里又启动一个线程 查看DataStreamer.java 的run方法
getStreamer().start();
//3.5队列为空 阻塞等待
dataQueue.wait(timeout);
//3.6队列不为空，从队列中取出packet
one = dataQueue.getFirst(); // regular data packet
4.2 write上传过程
1.向DataStreamer的队列里面写数据
2.建立管道之机架感知（块存储位置）
3.建立管道之Socket发送
4.建立管道之Socket接收
5.客户端接收DN写数据应答Response
1.向DataStreamer的队列里面写数据
//1.1 点击自己写的write方法
fos.write("hello world".getBytes());
//此处跳过一系列write方法进入FSOutputSummer.java的write方法
//1.2 往出写
flushBuffer();
//1.3
writeChecksumChunks(buf, 0, lenToFlush);
//1.4
writeChunk(b, off + i, chunkLen, checksum, ckOffset, getChecksumSize());
//1.5来到DFSOutputStream.java的writeChunk方法 chunk checkSum
currentPacket.writeChecksum(checksum, ckoff, cklen);
currentPacket.writeData(b, offset, len);
//1.6check 判断是否满了
enqueueCurrentPacketFull()
//1.7
enqueueCurrentPacket();
//1.8 如果dataQueue满了 等待
getStreamer().waitAndQueuePacket(currentPacket);
//1.9队列没满
queuePacket(packet);
//1.10添加队列 通知
dataQueue.addLast(packet);
dataQueue.notifyAll();
队列有数据，唤醒队列之后，进入DataStreamer.java的run方法
2.建立管道之机架感知（块存储位置）
3.建立管道之Socket发送
//2.1没数据的时候是等待，有数据则获取数据
one = dataQueue.getFirst(); // regular data packet
//2.2发送数据之前 建立管道 nextBlockOutputStream()获取块儿信息
setPipeline(nextBlockOutputStream());
//2.3 和nameNode RPC通信
lb = locateFollowingBlock(excluded.length > 0 ? excluded : null, oldBlock);
return DFSOutputStream.addBlock(excluded, dfsClient, src, oldBlock,
stat.getFileId(), favoredNodes, addBlockFlags);
//2.4和nameNode通信添加块信息 RPC通信 NameNodeRpcServer.java的addBlock接收消息
return dfsClient.namenode.addBlock(src, dfsClient.clientName, prevBlock, excludedNodes, fileId, favoredNodes, allocFlags);
//2.5 获取机架
LocatedBlock locatedBlock = namesystem.getAdditionalBlock(src, fileId, clientName, previous, excludedNodes, favoredNodes, addBlockFlags);
//2.6获取新块儿
DatanodeStorageInfo[] targets = FSDirWriteFileOp.chooseTargetForNewBlock(blockManager, src, excludedNodes, favoredNodes, flags, r);
//2.7 选择新块儿
// choose targets for the new block to be allocated.
return bm.chooseTarget4NewBlock(src, r.numTargets, clientNode, excludedNodesSet, r.blockSize, favoredNodesList, r.storagePolicyID, r.blockType, r.ecPolicy, flags);
//2.8
final DatanodeStorageInfo[] targets = blockplacement.chooseTarget(src, numOfReplicas, client, excludedNodes, blocksize, favoredDatanodeDescriptors, storagePolicy, flags);
//2.9抽象方法 找BlockPlacementPolicyDefault.java类
return chooseTarget(src, numOfReplicas, writer, new ArrayList<DatanodeStorageInfo>(numOfReplicas), false, excludedNodes, blocksize, storagePolicy, flags);
//2.10
return chooseTarget(numOfReplicas, writer, chosenNodes, returnChosenNodes, excludedNodes, blocksize, storagePolicy, flags, null);
//2.11任然是选择节点
localNode = chooseTarget(numOfReplicas, writer, excludedNodeCopy, blocksize, maxNodesPerRack, results, avoidStaleNodes, storagePolicy, EnumSet.noneOf(StorageType.class), results.isEmpty(), sTypes);
//2.12
writer = chooseTargetInOrder(numOfReplicas, writer, excludedNodes, blocksize, maxNodesPerRack, results, avoidStaleNodes, newBlock, storageTypes);
//2.13第一个选择本地节点
DatanodeStorageInfo storageInfo = chooseLocalStorage(writer, excludedNodes, blocksize, maxNodesPerRack, results, avoidStaleNodes, storageTypes, true);
//2.14第二块儿选择和本地节点不同的远程机架节点
chooseRemoteRack(1, dn0, excludedNodes, blocksize, maxNodesPerRack, results, avoidStaleNodes, storageTypes);
//2.15 先判断1,2块儿是否在同一机架 如果在，则第三块儿选择不同的远程机架 如果是一个新块儿，选择和第二个机架相同的机架，其余选择本地机架
if (clusterMap.isOnSameRack(dn0, dn1)) {
chooseRemoteRack(1, dn0, excludedNodes, blocksize, maxNodesPerRack,
results, avoidStaleNodes, storageTypes);
} else if (newBlock){
chooseLocalRack(dn1, excludedNodes, blocksize, maxNodesPerRack,
results, avoidStaleNodes, storageTypes);
} else {
chooseLocalRack(writer, excludedNodes, blocksize, maxNodesPerRack,
results, avoidStaleNodes, storageTypes);
}
//3.1开始写数据
// Connect to first DataNode in the list.
success = createBlockOutputStream(nodes, nextStorageTypes, nextStorageIDs,
0L, false);
//3.2获取输出流（写数据） 输入流（应答）
OutputStream unbufOut = NetUtils.getOutputStream(s, writeTimeout);
InputStream unbufIn = NetUtils.getInputStream(s, readTimeout);
//3.3写块儿信息
// send the request
new Sender(out).writeBlock(blockCopy, nodeStorageTypes[0], accessToken,
dfsClient.clientName, nodes, nodeStorageTypes, null, bcs,
nodes.length, block.getNumBytes(), bytesSent, newGS,
checksum4WriteBlock, cachingStrategy.get(), isLazyPersistFile,
(targetPinnings != null && targetPinnings[0]), targetPinnings,
nodeStorageIDs[0], nodeStorageIDs);
//3.4socket通信
send(out, Op.WRITE_BLOCK, proto.build());
socket通信发送之后，DataNode会进行信息接收DataXceiverServer.java
4.建立管道之Socket接收
//DataXceiverServer.java run方法进行接收
//4.1 run方法里面开了一个线程
new Daemon(datanode.threadGroup, DataXceiver.create(peer, datanode, this)) .start();
//4.2找到DataXceiver.java的run方法
//4.3获取 前面send的OP类型
op = readOp();
//4.4操作op
processOp(op);
//4.5是写操作进来的
case WRITE_BLOCK:
opWriteBlock(in);
break;
//4.6往出写
writeBlock(PBHelperClient .convert(proto.getHeader().getBaseHeader().getBlock()),
PBHelperClient.convertStorageType(proto.getStorageType()),
PBHelperClient.convert(proto.getHeader().getBaseHeader().getToken()),
proto.getHeader().getClientName(),
targets,
PBHelperClient.convertStorageTypes(proto.getTargetStorageTypesList(), targets.length),
PBHelperClient.convert(proto.getSource()),
fromProto(proto.getStage()),
proto.getPipelineSize(),
proto.getMinBytesRcvd(), proto.getMaxBytesRcvd(),
proto.getLatestGenerationStamp(),
fromProto(proto.getRequestedChecksum()),
(proto.hasCachingStrategy() ?
getCachingStrategy(proto.getCachingStrategy()) :
CachingStrategy.newDefaultStrategy()),
(proto.hasAllowLazyPersist() ? proto.getAllowLazyPersist() : false),
(proto.hasPinning() ? proto.getPinning(): false),
(PBHelperClient.convertBooleanList(proto.getTargetPinningsList())),
proto.getStorageId(),
proto.getTargetStorageIdsList().toArray(new String[0]));
//4.7找到实现类DataXceiver.java writeBlock方法 getBlockReceiver方法写文件
setCurrentBlockReceiver(getBlockReceiver(block, storageType, in,
peer.getRemoteAddressString(),
peer.getLocalAddressString(),
stage, latestGenerationStamp, minBytesRcvd, maxBytesRcvd,
clientname, srcDataNode, datanode, requestedChecksum,
cachingStrategy, allowLazyPersist, pinning, storageId));
//4.8
return new BlockReceiver(block, storageType, in,
inAddr, myAddr, stage, newGs, minBytesRcvd, maxBytesRcvd,
clientname, srcDataNode, dn, requestedChecksum,
cachingStrategy, allowLazyPersist, pinning, storageId);
//4.9管道建立阶段 走这个case createRbw写文件 最后再改名字
case PIPELINE_SETUP_CREATE:
replicaHandler = datanode.data.createRbw(storageType, storageId,
block, allowLazyPersist);
datanode.notifyNamenodeReceivingBlock(
block, replicaHandler.getReplica().getStorageUuid());
break;
//4.10写文件找到实现类FsDatasetImpl.java createRbw方法
// First try to place the block on a transient volume.
ref = volumes.getNextTransientVolume(b.getNumBytes());
//4.11在写完文件之后，会往下个target发送 如果链接的节点>0
if (targets.length > 0) {
//4.12任然往下个节点继续发送 从DN1发送给DN2
new Sender(mirrorOut).writeBlock(originalBlock, targetStorageTypes[0],
blockToken, clientname, targets, targetStorageTypes,
srcDataNode, stage, pipelineSize, minBytesRcvd, maxBytesRcvd,
latestGenerationStamp, requestedChecksum, cachingStrategy,
allowLazyPersist, targetPinnings[0], targetPinnings,
targetStorageId, targetStorageIds);
5.客户端接收DN写数据应答Response
当DN1写完发送给DN2，DN2写完发送给DN3，DN3写完进行应答给DN2,DN2应答给DN1，DN1应答客户端,决定是否删除ackQueue;
//5.1DataStreamer.java run方法类进行应答 建立管道 应答反馈
setPipeline(nextBlockOutputStream());
initDataStreaming()
//5.2 启动一个线程进行应答，找ResponseProcessor.java的run方法，收集信息 一切正常的话移除ackQueue的元素
ackQueue.removeFirst();
//5.3往出写数据 移除dataQueue的元素 添加进ackQueue
dataQueue.removeFirst();
ackQueue.addLast(one);
//5.4真正写数据是这个方法
one.writeTo(blockStream);
5、Yarn源码解析
yarn工作机制
yarn源码解析
pom文件
<dependency>
<groupId>org.apache.hadoop</groupId>
<artifactId>hadoop-yarn-server-resourcemanager</artifactId>
<version>3.1.3</version>
</dependency>
<dependency>
<groupId>org.apache.hadoop</groupId>
<artifactId>hadoop-mapreduce-client-app</artifactId>
<version>3.1.3</version>
</dependency>
1.Yarn客户端向RM提交作业（切片信息 配置文件 jar包）
2.RM启动MRAppMaster
3.调度器任务执行（YarnChild）
1.Yarn客户端向RM提交作业（切片信息 配置文件 jar包）
//1.1自己代码提交job
boolean result = job.waitForCompletion(true);
//1.2
submit();
//1.3 yarn客户端 local客户端
connect();
//1.4 真正的提交任务
return submitter.submitJobInternal(Job.this, cluster);
//1.5以往的路径检查
//validate the jobs output specs
checkSpecs(job);
//1.6设置任务id
JobID jobId = submitClient.getNewJobID();
job.setJobID(jobId);
//1.7创建资源的提交路径
copyAndConfigureFiles(job, submitJobDir);
//1.8走切片规则
int maps = writeSplits(job, submitJobDir);
//1.9在提交路径上写xml配置文件
// Write job file to submit dir
writeConf(conf, submitJobFile);
//1.10任务提交
status = submitClient.submitJob(
jobId, submitJobDir.toString(), job.getCredentials());
//1.11 接口 找YARNRunner.java的submitJob方法 创建提交的上下文环境 其实是封装了一个运行org.apache.hadoop.mapreduce.v2.app.MRAppMaster命令
ApplicationSubmissionContext appContext =
createApplicationSubmissionContext(conf, jobSubmitDir, ts);
//1.12设置命令 其实提交的是一个命令 让ResouceManage执行命令得到一个MrAppMaster
// Setup ContainerLaunchContext for AM container
//拼接的各种参数
List<String> vargs = setupAMCommand(jobConf);
//1.13需要运行的程序org.apache.hadoop.mapreduce.v2.app.MRAppMaster
vargs.add(MRJobConfig.APPLICATION_MASTER_CLASS);
//1.14 提交上下文相关内容（提交命令）
ApplicationId applicationId =
resMgrDelegate.submitApplication(appContext);
//1.15接口 找到YarnClientImpl.java实现类 submitApplication方法
rmClient.submitApplication(request);
//1.16接口找到ClientRMService.java的submitApplication方法 get上下文环境，执行
ApplicationSubmissionContext submissionContext = request
.getApplicationSubmissionContext();
2.RM启动MRAppMaster
//2.1MRAppMaster.java main方法 初始化
initAndStartAppMaster(appMaster, conf, jobUserName);
//2.2初始化
appMaster.init(conf);
//2.3服务的启动
serviceInit(config);
//2.4抽象方法 找到MRAppMaster.java的 serviceInit方法 创建任务调度器
dispatcher = createDispatcher();
//2.5启动 MRAppMaster
appMaster.start();
//2.6
serviceStart();
//2.7抽象方法 找到MRAppMaster.java的 serviceStart方法
startJobs();
//2.8
dispatcher.getEventHandler().handle(startJobEvent);
//2.9抽象方法 GenericEventHandler.java的handle方法 将任务/Mr提交yarn的调度器队列,准备执行
eventQueue.put(event);
3.调度器任务执行（YarnChild）
//3.1将任务和MRAppMaster提交进yarn队列，由YarnChild.java的main方法执行
final Task taskFinal = task;
taskFinal.run(job, umbilical); // run the task
//3.2接口 找实现类MapTask.java 判断是否为mapTask
isMapTask()
//如果ReduceTaskNum等于0 不会走环形缓冲区 资源比列都给map阶段
if (conf.getNumReduceTasks() == 0) {
mapPhase = getProgress().addPhase("map", 1.0f);
} else {
//方便定位问题 如果进度未到百分之67 则map出的问题 超过67 sort出的问题（资源问题）
// If there are reducers then the entire attempt's progress will be
// split between the map phase (67%) and the sort phase (33%).
//map阶段处理的事情 资源给到map阶段的数量
mapPhase = getProgress().addPhase("map", 0.667f);
//map阶段出来环形缓冲区处理的事情 资源给到环形缓冲区的数量
sortPhase = getProgress().addPhase("sort", 0.333f);
}
//3.3执行新api
runNewMapper(job, splitMetaInfo, umbilical, reporter);
//3.4 mapper运行
mapper.run(mapperContext);
//3.5抽象方法 执行自己的map方法
//3.6接口 找实现类ReduceTask.java run方法 新api
runNewReducer(job, umbilical, reporter, rIter, comparator,
keyClass, valueClass);
//3.7运行reduceTask
reducer.run(reducerContext);
//3.8抽象方法 执行自己的reducer方法
6、MapReduce源码解析
unbufOut = NetUtils.getOutputStream(s, writeTimeout);
InputStream unbufIn = NetUtils.getInputStream(s, readTimeout);
//3.3写块儿信息
// send the request
new Sender(out).writeBlock(blockCopy, nodeStorageTypes[0], accessToken,
dfsClient.clientName, nodes, nodeStorageTypes, null, bcs,
nodes.length, block.getNumBytes(), bytesSent, newGS,
checksum4WriteBlock, cachingStrategy.get(), isLazyPersistFile,
(targetPinnings != null && targetPinnings[0]), targetPinnings,
nodeStorageIDs[0], nodeStorageIDs);
//3.4socket通信
send(out, Op.WRITE_BLOCK, proto.build());
socket通信发送之后，DataNode会进行信息接收DataXceiverServer.java
###### 4.建立管道之Socket接收
```java
//DataXceiverServer.java run方法进行接收
//4.1 run方法里面开了一个线程
new Daemon(datanode.threadGroup, DataXceiver.create(peer, datanode, this)) .start();
//4.2找到DataXceiver.java的run方法
//4.3获取 前面send的OP类型
op = readOp();
//4.4操作op
processOp(op);
//4.5是写操作进来的
case WRITE_BLOCK:
opWriteBlock(in);
break;
//4.6往出写
writeBlock(PBHelperClient .convert(proto.getHeader().getBaseHeader().getBlock()),
PBHelperClient.convertStorageType(proto.getStorageType()),
PBHelperClient.convert(proto.getHeader().getBaseHeader().getToken()),
proto.getHeader().getClientName(),
targets,
PBHelperClient.convertStorageTypes(proto.getTargetStorageTypesList(), targets.length),
PBHelperClient.convert(proto.getSource()),
fromProto(proto.getStage()),
proto.getPipelineSize(),
proto.getMinBytesRcvd(), proto.getMaxBytesRcvd(),
proto.getLatestGenerationStamp(),
fromProto(proto.getRequestedChecksum()),
(proto.hasCachingStrategy() ?
getCachingStrategy(proto.getCachingStrategy()) :
CachingStrategy.newDefaultStrategy()),
(proto.hasAllowLazyPersist() ? proto.getAllowLazyPersist() : false),
(proto.hasPinning() ? proto.getPinning(): false),
(PBHelperClient.convertBooleanList(proto.getTargetPinningsList())),
proto.getStorageId(),
proto.getTargetStorageIdsList().toArray(new String[0]));
//4.7找到实现类DataXceiver.java writeBlock方法 getBlockReceiver方法写文件
setCurrentBlockReceiver(getBlockReceiver(block, storageType, in,
peer.getRemoteAddressString(),
peer.getLocalAddressString(),
stage, latestGenerationStamp, minBytesRcvd, maxBytesRcvd,
clientname, srcDataNode, datanode, requestedChecksum,
cachingStrategy, allowLazyPersist, pinning, storageId));
//4.8
return new BlockReceiver(block, storageType, in,
inAddr, myAddr, stage, newGs, minBytesRcvd, maxBytesRcvd,
clientname, srcDataNode, dn, requestedChecksum,
cachingStrategy, allowLazyPersist, pinning, storageId);
//4.9管道建立阶段 走这个case createRbw写文件 最后再改名字
case PIPELINE_SETUP_CREATE:
replicaHandler = datanode.data.createRbw(storageType, storageId,
block, allowLazyPersist);
datanode.notifyNamenodeReceivingBlock(
block, replicaHandler.getReplica().getStorageUuid());
break;
//4.10写文件找到实现类FsDatasetImpl.java createRbw方法
// First try to place the block on a transient volume.
ref = volumes.getNextTransientVolume(b.getNumBytes());
//4.11在写完文件之后，会往下个target发送 如果链接的节点>0
if (targets.length > 0) {
//4.12任然往下个节点继续发送 从DN1发送给DN2
new Sender(mirrorOut).writeBlock(originalBlock, targetStorageTypes[0],
blockToken, clientname, targets, targetStorageTypes,
srcDataNode, stage, pipelineSize, minBytesRcvd, maxBytesRcvd,
latestGenerationStamp, requestedChecksum, cachingStrategy,
allowLazyPersist, targetPinnings[0], targetPinnings,
targetStorageId, targetStorageIds);
5.客户端接收DN写数据应答Response
当DN1写完发送给DN2，DN2写完发送给DN3，DN3写完进行应答给DN2,DN2应答给DN1，DN1应答客户端,决定是否删除ackQueue;
//5.1DataStreamer.java run方法类进行应答 建立管道 应答反馈
setPipeline(nextBlockOutputStream());
initDataStreaming()
//5.2 启动一个线程进行应答，找ResponseProcessor.java的run方法，收集信息 一切正常的话移除ackQueue的元素
ackQueue.removeFirst();
//5.3往出写数据 移除dataQueue的元素 添加进ackQueue
dataQueue.removeFirst();
ackQueue.addLast(one);
//5.4真正写数据是这个方法
one.writeTo(blockStream);
5、Yarn源码解析
yarn工作机制
[外链图片转存中…(img-hNhJZrRY-1659265420007)]
yarn源码解析
[外链图片转存中…(img-vxiOCItz-1659265420007)]
pom文件
<dependency>
<groupId>org.apache.hadoop</groupId>
<artifactId>hadoop-yarn-server-resourcemanager</artifactId>
<version>3.1.3</version>
</dependency>
<dependency>
<groupId>org.apache.hadoop</groupId>
<artifactId>hadoop-mapreduce-client-app</artifactId>
<version>3.1.3</version>
</dependency>
1.Yarn客户端向RM提交作业（切片信息 配置文件 jar包）
2.RM启动MRAppMaster
3.调度器任务执行（YarnChild）
1.Yarn客户端向RM提交作业（切片信息 配置文件 jar包）
//1.1自己代码提交job
boolean result = job.waitForCompletion(true);
//1.2
submit();
//1.3 yarn客户端 local客户端
connect();
//1.4 真正的提交任务
return submitter.submitJobInternal(Job.this, cluster);
//1.5以往的路径检查
//validate the jobs output specs
checkSpecs(job);
//1.6设置任务id
JobID jobId = submitClient.getNewJobID();
job.setJobID(jobId);
//1.7创建资源的提交路径
copyAndConfigureFiles(job, submitJobDir);
//1.8走切片规则
int maps = writeSplits(job, submitJobDir);
//1.9在提交路径上写xml配置文件
// Write job file to submit dir
writeConf(conf, submitJobFile);
//1.10任务提交
status = submitClient.submitJob(
jobId, submitJobDir.toString(), job.getCredentials());
//1.11 接口 找YARNRunner.java的submitJob方法 创建提交的上下文环境 其实是封装了一个运行org.apache.hadoop.mapreduce.v2.app.MRAppMaster命令
ApplicationSubmissionContext appContext =
createApplicationSubmissionContext(conf, jobSubmitDir, ts);
//1.12设置命令 其实提交的是一个命令 让ResouceManage执行命令得到一个MrAppMaster
// Setup ContainerLaunchContext for AM container
//拼接的各种参数
List<String> vargs = setupAMCommand(jobConf);
//1.13需要运行的程序org.apache.hadoop.mapreduce.v2.app.MRAppMaster
vargs.add(MRJobConfig.APPLICATION_MASTER_CLASS);
//1.14 提交上下文相关内容（提交命令）
ApplicationId applicationId =
resMgrDelegate.submitApplication(appContext);
//1.15接口 找到YarnClientImpl.java实现类 submitApplication方法
rmClient.submitApplication(request);
//1.16接口找到ClientRMService.java的submitApplication方法 get上下文环境，执行
ApplicationSubmissionContext submissionContext = request
.getApplicationSubmissionContext();
2.RM启动MRAppMaster
//2.1MRAppMaster.java main方法 初始化
initAndStartAppMaster(appMaster, conf, jobUserName);
//2.2初始化
appMaster.init(conf);
//2.3服务的启动
serviceInit(config);
//2.4抽象方法 找到MRAppMaster.java的 serviceInit方法 创建任务调度器
dispatcher = createDispatcher();
//2.5启动 MRAppMaster
appMaster.start();
//2.6
serviceStart();
//2.7抽象方法 找到MRAppMaster.java的 serviceStart方法
startJobs();
//2.8
dispatcher.getEventHandler().handle(startJobEvent);
//2.9抽象方法 GenericEventHandler.java的handle方法 将任务/Mr提交yarn的调度器队列,准备执行
eventQueue.put(event);
3.调度器任务执行（YarnChild）
//3.1将任务和MRAppMaster提交进yarn队列，由YarnChild.java的main方法执行
final Task taskFinal = task;
taskFinal.run(job, umbilical); // run the task
//3.2接口 找实现类MapTask.java 判断是否为mapTask
isMapTask()
//如果ReduceTaskNum等于0 不会走环形缓冲区 资源比列都给map阶段
if (conf.getNumReduceTasks() == 0) {
mapPhase = getProgress().addPhase("map", 1.0f);
} else {
//方便定位问题 如果进度未到百分之67 则map出的问题 超过67 sort出的问题（资源问题）
// If there are reducers then the entire attempt's progress will be
// split between the map phase (67%) and the sort phase (33%).
//map阶段处理的事情 资源给到map阶段的数量
mapPhase = getProgress().addPhase("map", 0.667f);
//map阶段出来环形缓冲区处理的事情 资源给到环形缓冲区的数量
sortPhase = getProgress().addPhase("sort", 0.333f);
}
//3.3执行新api
runNewMapper(job, splitMetaInfo, umbilical, reporter);
//3.4 mapper运行
mapper.run(mapperContext);
//3.5抽象方法 执行自己的map方法
//3.6接口 找实现类ReduceTask.java run方法 新api
runNewReducer(job, umbilical, reporter, rIter, comparator,
keyClass, valueClass);
//3.7运行reduceTask
reducer.run(reducerContext);
//3.8抽象方法 执行自己的reducer方法
6、MapReduce源码解析
参照MapReduce阶段介绍
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
