大数据概述🎾
😕什么是大数据？
维基百科:数据规模巨大到无法通过人工在合理的时间内达到截取，管理，处理并整理成为人类所解读的信息。
麦肯锡全球研究所:一种规模大到在获取、存储、管理、分析方面都大大超出了传统数据库软件工具能力范围的数据集合。
高德纳:需要新的处理模式才能具有更强的决策力、洞察发现力和流程优化能力来适应海量、高增长率和多样化的信息资产。
根据不同机构给出概念解释总结概念：海量数据，具有高增长率、数据类型多样化、一定时间内无法使用常规软件工具进行捕捉、管理和处理的数据集合。
😕大数据的特征？
第三次信息化浪潮-->大数据 （来自1980年托夫勒在其所著的《第三次浪潮》中就热情地将“大数据”称颂为“第三次浪潮的华彩乐章”。）
大数据四大特性，简称4V：[数据量庞大] [数据类型多] [增长速度快] [数据价值密度低]
⚽大数据的应用场景：
时至今日，大数据已经在生活的各行各业中都有应用了，在各个领域中影响着我们的生活。
- 共享单车故障维修报警系统
当你在街上扫一个共享单车会跳出一个提示，此单车编号，近1周有X人上报，XXXX故障我们正在抓紧维修，建议你换一辆以免影响正常骑行。 - 某团大数据杀熟
当你充了会员在一些配送费，推荐菜品价格和服务费等方面会比较高，在知到你离不开的时候疯狂嘎你韭菜还一直给你推荐你感兴趣喜欢吃的。 - 电商用户推送
例如拼多多刚打开首页全是家用品卫生纸，用的久了他就知道你会被什么价格的哪类东西感兴趣就会根据你的行为和搜索记录推送，这就是大数据的体现。 - 视频网站和音乐网站猜你喜欢
视频和音乐网站会根据你最近的浏览和记录来确定你感兴趣的话题和操作习惯，会尽可能给你符合口味的东西，增加用户存留。
大数据发展前景和处理流程🎾
😕大数据发展前景
本身的数据价值化就会开辟出很大的市场空间。大数据推动了科技领域的发展不仅体现在互联网领域，还体现在金融、教育、医疗等诸多领域，尤其是现在的人工智能。相关产业规模会进一步扩大。国家大力扶持大数据行业发展，高校专业发展
大数据的开发流程
00.数据源(企业中数据的来源)：
- 关系型数据库
* 各种关系表（订单表，账号表等）
- 日志文件
* 用户行为数据
* 浏览页面等行为
- 三方数据
* 第三方提供数据爬虫或者接口
01.数据采集或同步
常用数据采集导入框架：
- sqoop：用于RDBMS和HDFS之间数据导入和导出
- flume：采集日志文件数据，动态采集日志文件数据流，一部分给HDFS离线分析，一部分给kafka做实时
- kafka：用于实时数据流处理。
02.数据存储
常用的数据存储框架
03.数据清洗
对数据进行过滤，得到具有一定格式的数据源
常用工具： MapReduc、Hive、SparkCore、sparksql等
04.数据分析
经过数据清洗后的数据进行分析，得到某个指标
常用工具：MapReduce、Hive、SparkSQL、impala(impa:le)、kylin
05.数据展示
数据分析后的结果展示出来，也可以理解为数据的可视化一图标或者具体的形式展示出来
常用工具：metastore、Javaweb、hcharts、echarts简单的为上面的东西进行总结就是：采集-->存储-->清洗-->分析-->展示
Hadoop的概述
🐘Hadoop背景？
在2020年全球数据总量达到44ZB（440亿TB+）在爆炸的数据量下，硬盘瓶颈越来越明显了，在短短的20年硬盘容量提高了大概1000倍，存储速度只提高了20倍。也就是存储量和速度不成正比，读写数据有很明显的数据滞后性。
如何高效读取？目前主流的方法是把一个数据集存在多个硬盘上然后并行存入和读取，1G数据平分存10个硬盘相当于提高了900%速度。
存在的问题？理论可以但是难以避免的硬件故障问题，读写数据正确性问题越来越明显，多一个硬盘多一个风险，所以一般使用RAID进行多副本存储避免硬盘损坏数据丢失。当你把文件存在多个硬盘上读写文件的时候要验证数据是否正确通过副本分析这是很大的挑战。
针对以上问题。Hadoop为我们提供了一个可靠且可扩展的存储和分析平台，开源，使用成本低解决了上面的痛点
🐘Hadoop概念：
Hadoop是Apache基金会旗下一个开源的分布式存储和分析计算平台，使用java语言开发，具有很好的跨平台性，可以运行在商用(廉价)硬件上，用户无需了解分布式底层细节，就可以开发分布式程序，充分使用集群的高速计算和存储。创始人为：Doug·Cutting(道格·卡丁)
例如：当你多个服务器同时提供工作一台服务器维护或者挂掉了，怎么把工作转移给其他机器，怎么调度底层实现分布计算等都不需要你管只需要你在他之上开发给他任务他自己就会调度。
🐘Hadoop起源：
🌸Hadoop版本介绍：
Hadoop是Apache的一个开源项目，所以很多公司在这个基础上都进行了商业化，加入了自己的特色。如cloudera, 华为等主要是大型公司提供更为专业的技术支持，多数都收费。
- Apache Hadoop(社区版): 原生的Hadoop、开源、免费、社区活跃，更新速度快，适合学习阶段
- CLoudera Hadoop(CDH版):最成型的商业发行版本。有免费版和收费版本。版本划分清晰，版本更新速度快，对生态圈的其他软件做了很好的兼容性，安全性、稳定性都有增强。
- Hortonworks Hadoop(HDP):完全开源，安装方便,提供了直观的用户安装界面和配置工具
Hadoop的生态系统
使用VMware搭建虚拟机并实现集群搭建
- 请下载以下资源以确保你可以正确的实现下面的步骤：
- [虚拟机] VMware por 16+ [https://zhuanlan.zhihu.com/p/617093823?utm_id=0]
- [Linux] Centos7 2009+ [https://mirrors.aliyun.com/centos/7/isos/x86_64] 下载mini版本
- [SSH连接] finalshell [http://dl.hostbuf.com/finalshell2/finalshell_install.exe?tdVRE]虚拟机安装和配置! 教程默认已安装VMware por和finalshell
- 安装CentOS虚拟机系统
- 配置虚拟机网络连接并分配内网IP
-> 获取网卡信息：ip addr
-> 修改网卡文件：vi /etc/sysconfig/network-scripts/ifcfg-<网卡名>，进入文件后按i编辑，把最后一行改为ONBOOT=yes。ESC后输入:wq回车
-> 在虚拟机设置中，网络调整为桥接后重启虚拟
-> 获取拿到的分配的内网ip，打开finalshell连接
Hadoop的安装和部署[本地模式]
本地模式：即运行在单台机器上。没有分布式的思想，使用的是本地文件系统。使用本地模式主要是用于对MapReduce的程序的逻辑进行调试，确保程序的正确性。由于在本地模式下测试和调试MapReduce程序较为方便，因此，这种模式适合用在开发阶段。
在开始之前请确保你下载了如下安装程序包：[根据CPU类型确定，台式机x86，苹果ARM aarch64] JDK(8) [x86 tar] [aarch64 tar] Hadoop [X86 tar] [arrch64 tar] 并且完成了上一步的操作,确认你不是Linux小白
！Hadoop不支持JDK11以上的版本
· 上传JDK包到服务器【/root/softwares】上并解压到指定目录/usr/local下
· 解压JDK到指定目录下： cd /root/softwares& tar -zxvf jdk1.8.0_341[解压文件名] -C /usr/local
· 配置环境变量： vim /etc/profile 在文件最末尾插入：
！vim 未找到需要先执行： sudo yum install vim
# Java Environment
export JAVA_HOME=/usr/local/jdk1.8.0_341 # 看好你的路径是否存在不要盲抄
export PATH=$PATH:$JAVA_HOME/bin· source /etc/profile引导重新生效，验证是否可以运行java -version弹出版本号即为成功配置安装
· 安装Hadoop，需要先上传文件到【/root/softwares】上并解压到指定目录/usr/local下
· 解压Hadoop到指定目录下： cd /root/softwares 8& tar -zxvf hadoop-3.3.1.tar.gz[解压文件名] -C /usr/local
· 配置环境变量： vim /etc/profile 在文件最末尾插入：
# Hadoop Environment
export HADOOP_HOME=/usr/local/hadoop-3.3.1 # 看好你的路径是否存在不要盲抄
export PATH=$PATH:$HADOOP_HOME/bin:$HADOOP_HOME/sbin· source /etc/profile引导重新生效，验证是否可以运行hadoop version弹出版本号即为成功配置安装
解读Hadoop根目录文件夹
Hadoop本地模式案例：wordcount(词频统计)
- 新建一个文件夹并在里面创建一个文件
$ mkdir ~/wordcount
$ vim word1
[iterm2 shell edit view session scripts profiles toolbelt window help
hadoop spark hadoop hdfs hdfs hive hive spark core sgl mysql java idk
java jdk spark hadoop hdfs hdfs hive spark hdfs spark hive sql java] :wq
- 循环此文件达到可观的文件大小
$ for i in {1..1000}; do cat word1 >> word2; done # 重复1000次word1资料到word2
$ for i in {1..1000}; do cat word2 >> word3; done # 重复1000次word2资料到word3
$ for i in {1..1000}; do cat word3 >> word4; done # 重复1000次word3资料到word4
# 过程比较慢，要稍微等等
- 打开Hadoop的词频统计案例
$ cd $HADOOP_HOME/share/hadoop/mapreduce
$ hadoop jar hadoop-mapreduce-examples-3.3.1.jar wordcount /wordcount/ /wordcount/output
# 运行hadoop-mapreduce-examples-3.3.1.jar中的wordcount，根目录下的wordcount/全部处理，结果输出到/wordcount/output 注意，输出目录是不能存在的，他会自己创建
- 查看结果
# 结果存放在了/wordcount/output 两个文件 [part-r-00000] [_SUCCESS]
$ cat part-r-00000Hadoop本地模式案例：计算pi
$ hadoop jar $HADOOP_HOME/share/hadoop/mapreduce/hadoop-mapreduce-examples-3.3.1.jar pi 10 1000
# 计算π 1000次Hadoop的安装和部署[伪分布式]
伪分布式模式:只需要一台机器，但是与本地模式的不同，伪分布式使用的是分布式的思想，具有完整的分布式文件存储和分布式计算的思想。只不过在进行存储和计算的时候涉及到的相关的守护进程都运行在同一台机器上，都是独立的Java进程。因而称为伪分布式集群。比本地模式多了代码调试功能，允许检查内存使用情况、HDFS输入输出、以及其他的守护进程交互。 总结来说:伪分布式集群就是只有一个节点的分布式集群。
前期准备需要提前装好本地模式的JAVA和Hadoop这里不再赘述
- 防火墙关闭
systemctl status firewalld #检查防火墙状态，systemctl stop firewalld #关闭防火墙,systemctl disable firewalld #禁止防火墙开机自启动；通常后两个命令一起用防止防火墙开启
- 保证NAT模式和静态IP的确定性，保证/etc/hosts文件中，ip和hostname的映射关系
vim /etc/hosts在最后面添加内网IP 主机名保存 - 确保免密登录对localhost有效；
ssh-keygen -t rsa #生成密钥点回车直到结束，随后在cd ~/.ssh/文件中会有对应的公钥和私钥 id_rsa私钥；id_rsa.pub公钥
你需要做的就是把公钥写到要免密的主机的authorized_keys中;而现在我们要做的是免密操作，这里只有一个节点我们只需要自己对自己免密。ssh-copy-id <用户名>@<ip>，现在当你再打开~/.ssh/他就有一个名字为konw-host日志。
配置Hadoop
- 打开Hadoop的配置文件夹
$ cd $HADOOP_HOME/etc/hadoop # 这里就是Hadoop的配置文件
- 修改core-site.xml 包含了一些全局的配置信息，涉及到Hadoop的基本设置和访问控制。
$ vim core-site.xml
[ ----------------------------------------------------
<configuration>
<!-- 设置namenode节点 -->
<!-- hadoop3.x时代默认端口 9820 -->
<property>
<name>fs.defaultFS</name>
<value>hdfs://CentOS01:9820</value>
</property>
<!-- hdfs的基础路径，被其他属性所依赖的一个基础路径 -->
<property>
<name>hadoop.tmp.dir</name>
<value>/usr/local/hadoop-3.3.1/tmp</value>
</property>
</configuration>
----------------------------------------------------- ]
- 修改hdfs-site.xml 用于配置Hadoop分布式文件系统（HDFS）的属性，控制HDFS的行为和性能。
$ vim hdfs-site.xml
[ -----------------------------------------------------
<configuration>
<!-- HDFS副本数，用于指定文件的副本数，伪分布式通常设置为1 -->
<property>
<name>dfs.replication</name>
<value>1</value>
</property>
<!-- secondarynamenode守护进程的http地址: 主机名和端口号。参考守护进程布局 -->
<property>
<name>dfs.namenode.secondary.http-address</name>
#CentOS01 是之前配置的免密连接的名字，你可以填IP
<value>CentOS01:9868</value>
</property>
<!-- namenode守护进程的http地址: 主机名和端口号。参考守护进程布局 -->
<property>
<name>dfs.namenode.http-address</name>
<value>CentOS01:9870</value>
</property>
</configuration>
----------------------------------------------------- ]
- 修改hadoop-env.sh
$ vim hadoop-env.sh
[ -----------------------------------------------------
export JAVA_HOME=[/usr/local/jdk1.8.0_341] # 填你自己的java路径不要瞎填
# Hadoop3中，需要添加如下配置，设置启动集群角色的用户是谁
export HDFS_NAMENODEUSER=root
export HDFS_DATANODE USER=root
export HDFS_SECONDARYNAMENODE USER=root
------------------------------------------------------ ]
- 配置workers (伪分布做开发)
$ vim workers
[ -----------------------------------------------------
localhost
------------------------------------------------------ ]
- 格式化集群并启动
我们在core-site.xml中配置过hadoop.tmp.dir的路径，在集群格式化的时候需要保证在这个路径不存在! 如果之前存在数据，先将其删除，再进行格式化! 即不能有tmp文件在Hadoop根目录下。
$ hdfs namenode -format
初始化完成后会在根目录下创建一个log和tmp文件夹
$ start-dfs.sh
[ -----------------------------------------------------
>>>>>>>>解决无法使用root进行启动的Hadoop情况
$ cd $HADOOP_HOME/sbin
将start-dfs.sh，stop-dfs.sh两个文件顶部添加以下参数
{--------------------------
#!/usr/bin/env bash
HDFS_DATANODE_USER=root
HADOOP_SECURE_DN_USER=hdfs
HDFS_NAMENODE_USER=root
HDFS_SECONDARYNAMENODE_USER=root
--------------------------}
start-yarn.sh，stop-yarn.sh顶部也需添加以下：
{--------------------------
#!/usr/bin/env bash
YARN_RESOURCEMANAGER_USER=root
HADOOP_SECURE_DN_USER=yarn
YARN_NODEMANAGER_USER=root
--------------------------}
------------------------------------------------------- ]
在webui上查看自己的hadoop状态
你可以在浏览器上输入==:<守护进程端口>==进入web查看服务状态，例如上面hdfs-site.xml的配置中端口为9870，http://192.168.3.158:9870就是我的。
Hadoop伪分布式案例：wordcount(词频分析)
- 新建一个文件夹并在里面创建一个文件
$ mkdir ~/wordcount
$ vim word1
[iterm2 shell edit view session scripts profiles toolbelt window help
hadoop spark hadoop hdfs hdfs hive hive spark core sgl mysql java idk
java jdk spark hadoop hdfs hdfs hive spark hdfs spark hive sql java] :wq
- 循环此文件达到可观的文件大小
$ for i in {1..1000}; do cat word1 >> word2; done # 重复1000次word1资料到word2
$ for i in {1..1000}; do cat word2 >> word3; done # 重复1000次word2资料到word3
$ for i in {1..1000}; do cat word3 >> word4; done # 重复1000次word3资料到word4
# 过程比较慢，要稍微等等
- 现在有数据了，我们要按照分布式的思想给他实现出来，我们的任务是要上传到HDFS上的，而不是在本地Linux上计算
$ hdfs dfs -put /wordcount / # 上传/wordcount到Hadoop根目录上
# hdfs dfs -put <本地文件位置> <集群保存的位置>
- 现在回到Hadoop WEB控制台的Browse Directory就可以看到上传的文件，详情见下图
$ hadoop jar $HADOOP_HOME/share/hadoop/mapreduce/hadoop-mapreduce-examples-3.3.1.jar wordcount /wordcount /output
# 执行Hadoop的jar包<词频分析器> <数据位置> <导出位置>
- 完成计算后你发现现在计算完的文件不会存在本地了，而是在HDFS上，刷新Browse Directory找到Output
$ hdfs dfs -cat /output/part-r-00000 # 调用hdfs下的/output/part-r-00000文件显示
！访问不了网站，在确保服务都是正确启动的时候查看你的防火墙
多虚拟机搭建和完全分布式模式
在未来的学习中我们要尝试使用3台Linux虚拟机同时运行进行Hadoop集群处理，现在先进行虚拟机克隆多台虚拟机出来吧。
然后你需要做的是：给克隆出来的虚拟机重新分配网络ip，如果你使用的是桥接那么就不需要再配置了。现在去FinalShell中都连接起来。
修改主机名字：
hostname CentOS02，hostnamectl set-hostname CentOS02...三号机以此类推修改主机记录：每一台机器上
vim /etc/hosts插入创建的每一个机器的ip，如果有生成忽略
有关远程登录的补充
==ssh: 是一个远程登录的命令，可以远程登录到指定的虚拟机。==其实，我们使用的远程连接工具，就是使用ssh实现的。注意，密钥是单向的，不是说A发给B，B就可以操作A了，需要B给A免密
ssh在进行远程登录的时候，需要进行身份验证，输入远程登录用户的密码。 例如:
ssh root@CentOS01# 需要输入CentOS01节点的密码ssh qianfeng02# 当远程登录的用户名，与当前的用户名相同的时候，远程用户名可以省略 在我们后续的使用中，集群的节点之间盟要频繁的进行通信，因此免密登录是必须要配置的。如果不配置免密登录，则在很多时候集群通信的时候，需要输入密码。这就需要人工维护，成本很高，而且很麻烦。
- 假设我们有三台机，已经配置了正确的网络映射，CentOS01\CentOS02\CentOS03
在01中：
$ ssh-keygen -t rsa # 先生成自己的密钥
$ ssh-copy-id CentOS01/CentOS02/CentOS03 # 给带自己的机器都部署上免密
在02和03中重复这个操作
SCP远程拷贝命令
cp命令，是拷贝的作用，可以实现将文件或者目录拷贝到另外一个位置。 scp命令，也是拷贝的作用，但是是远程拷贝，可以实现将文件或者目录拷贝到另外的一台机器上
$ scp file <远程用户名@远程服务器:目标路径> #基本格式
示例:
#将本机的-/root/sofwares/文件夹，拷贝到CentOS02机器上的/root/sofwares/文件下
$ scp -r[如果不是文件夹省略-r] /root/sofwares/ root@CentOS02:/root/sofwares/ #第一种写法
$ cd /root # 先进入文件夹根目录
$ scp -r sofwares/ root@CentOS02:/$PWD #第二种写法，$PWD表示复制到和当前机子同目录下
同样，当你远程的机子用户名和本机相同时可以省略用户名 例如：$ scp -r sofwares/ CentOS02:/$PWD ；如果你没有设置免密登录你还是要输入密码的。
当然你也可以对配置文件和环境变量的文件进行远程拷贝。时间同步
很多项目多台机器的时间差要求比较严格最低容忍可能都低于10秒以内，现在我们对多台机器的时间和时区进行统一校准。
# 同步网络时间
- 首先安装ntpdate命令，$ yum install -y ntpdate
- 与阿里云服务器同步时间，$ ntpdate -u ntp.aliyun.com
- 定时任务：每隔30分钟同步一次时间
$ crontab -e
$ */30 * * * * /usr/sbin/ntpdate -u ntp.aliyun.com > /dev/null 2>&1 # 每隔30分钟同步一次阿里云时间，不要日志
$ :wq保存即可，你需要给每个机器都部署这个任务如果创建成功crontab -l可见
# 自定义时间服务器(无网络状态)
适用于没有网络的情况，通过局域网的一台服务器的时间为准进行调整
- 首先安装ntp，$ yum install -y ntp
- 检查服务进程是否开启：$ systemctl status ntpd
- 编辑校准机的ntp.conf : $ vim /etc/ntp.conf
- 运行 $ systemctl start ntpd
文件需要修改的地方有：【看下图】
（假设你操作的机器是CentOS01）现在你的分机可以直接同步CentOS01的时间了,在分机都运行 $ ntpdate -u CentOS01
- 后续你可以把之前配置的自动同步时间给改为本地的
搭建完全分布式集群
在真实的企业环境中，服务器集群会使用到多台机器，共同配合，来构建一个完整的分布式文件系统。而在这样的分布式文件系统中，HDFS相关的守护进程也会分布在不同的机器上，例如:
- NameNode官护进程，尽可能的单独部署在一台硬件性能较好的机器中。【主节点】
- 其他的每台机器上都会部署一个Datanode守护进程，一般的硬件环境即可。 【维护节点数据】
- SecondaryNameNode守护进程最好不要和NameNode在同一台机器上。【NameNode的备份理解为】
平台和软件 | 说明 |
宿主机操作系统与虚拟机平台 | Windows(11)、Vmware pro17 |
虚拟主机操作系统与SSH工具 | CentOS7 mini、FinalShell |
软件包部署位置 | /user/local |
操作用户 | root |
虚拟机网络配置 | CentOS01 ：192.168.3.158 CentOS02： 192.168.3.162 CentOS03： 192.168.3.163 |
NameNode | Datanode | SecondaryNameNode | |
CentOS01 | √ | √ | |
CentOS02 | √ | √ | |
CentOS03 | √ |
环境准备：防火墙关闭，网络流畅主机映射正确，免密登录配置正确，时间同步，JDK，HAdoop环境变量部署完成(有问题看前面的笔记)
优先查看前面伪分布式的安装教程，基本重复，而需要注意的是hdfs-site.xml文件和workers节点
- 修改hdfs-site.xml
$ vim $HADOOP_HOME/etc/hadoop/hdfs-site.xml
[---------------------------------------------
<configuration>
<!-- HDFS副本数，用于指定文件的副本数，伪分布式通常设置为1 ，现在为3台机器设3-->
<property>
<name>dfs.replication</name>
<value>3</value>
</property>
<!-- secondarynamenode守护进程的http地址: 主机名和端口号。参考守护进程布局 -->
<property>
<name>dfs.namenode.secondary.http-address</name>
#根据文档这里配置为CentOS02上
<value>CentOS02:9868</value>
</property>
<!-- namenode守护进程的http地址: 主机名和端口号。参考守护进程布局 -->
<property>
<name>dfs.namenode.http-address</name>
#根据文档这里配置为CentOS01上
<value>CentOS01:9870</value>
</property>
</configuration>
---------------------------------------------]
- 修改每台机子上的workers节点 [这是在部署Datanode]
$ vim $HADOOP_HOME/etc/hadoop/workers
[--------------------------------------------
# 删除之前伪服务器的localhost
CentOS01
CentOS02
CentOS03
---------------------------------------------]
同时还需要配置解决无法使用root进行启动的Hadoop情况，接上面伪服务器教程删除之前的tmp文件夹然后重新初始化进入Haoopweb。启动和关闭集群问题
开启的关闭集群的问题
关闭、开启所有进程：
start-dfs.sh # 启动所有的HDFS进程（NameNode、SecondaryNameNode、DataNode）
stop-dfs.sh # 停止所有的HDFS进程（NameNode、SecondaryNameNode、DataNode）关闭、开启单独一个进程（只能开启节点上规划的进程）
hdfs --daemon start/stop namenode# 只开启/关闭namenode
hdfs --daemon start/stop SecondaryNameNode# 只开启/关闭namenode
hdfs --daemon start/stop DataNode# 只开启/关闭namenode一键开启、关闭多个节点的datanode
hafs --workers --daemon start datanode
集群快捷查看方式
快捷查看每一个节点的运行状态脚本，用于避免多接点来回jps
cd /jiaoben/bin# 在根目录下创建一个文件夹专门存放脚本
vim jpsroobts.sh# 写一个名为jpsroobts.sh的脚本文件,文件在下面，编辑完保存即可
chorm 711 jpsroobts.sh#给与可操作性权限
ln -s /jiaoben/bin/jpsroobts.sh /usr/bin# 把文件软连接到环境变量文件夹方便直接使用
jpsroobts.sh# 调用文件，成功即可输出日志
#!/bin/bash
# 数组存放每一个节点
HOSTS=( CentOS01 CentOS02 CentOS03 )
for HOST in ${HOSTS[*]}
do
echo ">>>>连接 $HOST 中>>>>"
ssh -T $HOST << DELIMITER
jps | grep -iv jps
exit
DELIMITER
done启动日志查看
如果出现问题可以到$HADOOP_HOME/logs中查看你的日志；日志的命名规则hadoop-<操作用户>-<日志来源>-<来源节点>.log针对于那个节点那个位置的错误出现问题我们可以查看他的日志来寻找对应的警告和错误进行修改
hadoop jar $SHADOOP-HOME/share/hadoop/mapreduce/hadoop-mapreduce-examples-3.3.1.jar wordcount /input /output 词频分析，注意输出文件夹必须不存在
HDFS的Shell操作
HDFS是一个分布式文件系统，我们可以使用一些命令来操作HDFS集上的文件，例如上传下载移动删除拷贝等
创建新目录：!注意，操作路径都是绝对路径
》hdfs dfs -mkdir (-p) /目录《
$ hdfs dfs -mkdir /test # 在根目录下传建一个test文件夹
$ hdfs dfs -mkdir -p /test/a/b/c # 多级创建，在一个文件夹下在创建子级文件夹多加-p
上传命令：
》hdfs dfs -put /本地文件 /dfs路径《
$ hdfs dfs -put /sowfwares / # 上传/sowfwares到dfs的根目录上
$ hdfs dfs -put *.txt / $ # 上传当前目录下的txt文件到根目录上
移动文件：
》hdfs dfs -moveFromLocal /本地文件 /dfs路径《
$ hdfs dfs -moveFromLocal hello.jpg / # 上传当前目录下的txt文件到根目录上
查看hdfs文件：
》 hdsd dfs -ls (-hR) /dfs路径 《
$ hdsd dfs -ls / # 查看hdfs根目录文件
$ hdsd dfs -ls -h / # 带大小转换的目录展示
$ hdsd dfs -ls -R / # 递归查看hdfs根目录文件下所有文件
查看hdfs文件的内容：
》 hdsd dfs -cat /dfs路径 《
$ hdsd dfs -cat /file/txt01.txt # 查看hdfs下的/file/txt01.txt文件
$ hdsd dfs -cat /file/*.txt # 查看hdfs下的/file/*.txt,所有txt文件夹
查看文件的头几行：
》 hdsd dfs -head /dfs路径 《
查看文件的后几行：
》 hdsd dfs -tail /dfs路径 《
下载hdfs的文件到本地： []下的东西为非必写
》 hdfs dfs -copyToLocal /dfs路径 [本地路径] 《 # 不写本地路径会下载到当前位置
$ hdfs dfs -copyToLocal /file/txt01.txt # 下载hdfs下的/file/txt01.txt文件
》 hdfs dfs -get /dfs路径 《
$ hdfs dfs -get /file/txt01.txt # 下载hdfs下的/file/txt01.txt文件
合并下载hdfs的文件到本地：
》 hdfs dfs -getmerge /dfs路径* 文件名(位置) 《
$ hdfs dfs -getmerge /input/file* file # 合并下载/input/file*的所有文件存在file文件中
删除hdfs的文件：
》 hdfs dfs -rm (-r) /dfs路径 《 # 删除文件没提示信息，注意
$ hdfs dfs -rm /file/*.txt # 删除/file下的所有txt文件夹
$ hdfs dfs -rm -r /file # 删除整个/file文件夹
拷贝文件
》 hdfs dfs -cp /dfs路径 /移动到的dfs路径 《
$ hdfs dfs -cp /file/file1.txt /file2_cp.txt # 拷贝hdfs的文件到其根目录下/file2_cp.txt的文件
文件重命名和移动文件
》 hdfs dfs -mv /dfs路径文件 /dfs(同级目录下)新路径文件 《
$ hdfs dfs -mv /file/file1.txt /file/txt01.txt # 把/file/file1.txt文件重命名为/file/txt01.txt
》 hdfs dfs -mv /dfs路径文件 /dfs新路径文件 《
$ hdfs dfs -mv /file/file1.txt / # 把/file/file1.txt文件移动到根目录
创建空文件
》 hdfs dfs -touchz /dfs文件夹名 《
$ hdfs dfs -touchz /file2 # 在dfs上创建了/file2文件夹
向文件中追加内容
！HDFS中不支持你编辑文件，只能向后追加内容
》 hdfs dfs -appendToFile /本地文件 /dfs文件《
$ hdfs dfs -appendToFile /file1 /file # 向dfs文件/file上追加本地的文件/file1到文件末尾
修改文件权限
》 hdfs dfs -chomd (-R) 权限符 /dfs位置 《
$ hdfs dfs -chomd 755 /file # 赋予dfs下/file文件权限为 755
$ hdfs dfs -chomd 755 /sofwares # 递归赋予dfs下/sofwares文件夹及其内部文件权限为 755
修改文件所属用户、组
》 hdfs dfs -chown [所属用户][:所属用户组] /dfs位置 《
$ hdfs dfs -chown hadoop /file # dfs下的/file文件所属用户变为hadoop
$ hdfs dfs -chown root:superroot /file # dfs下的/file文件所属用户变为root,用户组为superroot
修改文本副本数量
》 hdfs dfs -setrep 整数 /dfs位置 《
$ hdfs dfs setrep 3 /file # dfs下的/file文件副本数量为3
# 作用于文件夹下的时候下面所有文件都会被修改
文件的测试
参考使用：hdfs dfs -test -d /sowfares && echo "0K" || echo "no"
# /sowfares 是不是一个文件夹(-d) 如果是输出OK，不是no
# -d 是否为文件夹 -e 是否存在 -z 是否为空
查看文件夹和子文件夹数量
》 hdfs dfs -count /dfs位置 《
$ hdfs dfs -count / # 根目录下的子文件数量
磁盘利用率统计：
》 hdfs dfs -df (-h) / 《
统计文件文件夹大小：
》 hdfs dfs -du (-hs) /dfs位置 《 # -s求总和
文件状态查看：
》 hdfs dfs -stat [占位符] /dfs位置 《
# 占位符：%b 文件大小，%n 打印文件名，%o 打印block的size，%r 打印副本数量，%y 修改时间
$ hdfs dfs -stat %n-%b-%r-%o-%y /softwares/hadoop-3.3.1.tar.gz
# 查看dfs/softwares/hadoop-3.3.1.tar.gz 文件的名字，大小，副本数，修改时间和块大小回收站
开启回收站（默认不开启）：
配置Centos01的配置文件 core-site.xml
!插入到原来的</configuration>标签里面，之前东西不要删除 更改文件后立即生效
[----------------------------------------------
<!-- 设置检查点删除的时间间隔，单位是分钟。如果设置为0表示不启用回收站。 -->
<property>
<name>fs.trash.interval</name>
<value>10080</value> # 7天清理一次
</property>
<!-- 这是检查点创建的时间间隔，单位是分钟。-->
<!-- 这个值应该小于或等于fs,trash,interval，如果设置为0，则会将这个值设置为fs.trash.interval的值。-->
<property>
<name>fs.trash.checkpoint.interval</name>
<value>0</value>
</property>
----------------------------------------------]
# 解决在图形化页面没权限查看回收站文件夹
$ hdfs dfs -chmod 755 /user/root/.Trash # 或者你直接在代码行操作
回收站的东西怎么恢复？从回收站中移动到回收站外路径 清空回收站：hdfs dfs -expunge
跳过回收站删除：hdfs dfs -rm (-r文件夹) -skipTrash /路径
HDFS详解
传统的的分布式文件系统的缺点
有四个文件，有大有小，大的甚至超过了单个服务器的内存大小，现在有多台服务器，传统来说就会把文件拆分放进去直到塞满在存到第二个，相当于服务器固态组成了一个radid0 【数据分布不均匀】
- 缺点：负载不均衡
- 缺点：网络瓶颈问题
在HDFS上使用块进行存储，把文件拆解成一块一块的分别存放，默认块大小为128MB，不足128MB块大小取决于文件大小，并且块大小可调节。根据情况他会自动对文件进行备份和尽可能保证负载均衡。
- Master-Slave 架构： HDFS采用主从架构，包括一个主节点（NameNode）和多个从节点（DataNode）。NameNode负责管理文件系统的命名空间和访问控制，而DataNode存储实际的数据块。
- 块存储： 文件在HDFS中被分割成固定大小的数据块（默认128MB），并在不同的DataNode上进行分布存储。
- 副本机制： HDFS通过创建多个数据副本来提供高可用性和数据容错性。默认情况下，每个数据块会被分为三个副本，并分别存储在不同的DataNode上，以防止数据丢失。
- 数据本地性： HDFS强调将计算移动到数据而不是将数据移动到计算。这意味着计算任务会被调度到存储着数据的节点上，以最大程度地减少数据传输开销。
- 命名空间和元数据： NameNode维护了文件系统的命名空间和元数据（文件和目录的信息）。这允许用户查找和管理文件，同时避免了将元数据保存在内存中的问题。
- 容错和恢复： HDFS具有自动检测和修复数据损坏的能力。当某个副本损坏或不可用时，HDFS会自动使用其他可用的副本进行修复。
- 适用于批处理： HDFS适用于处理大量数据，适合用于批处理、数据分析和离线计算等场景。
- 不适合小文件： HDFS设计用于存储大型文件，不适合存储大量小文件，因为每个文件都会占用一个元数据条目，可能会导致NameNode的负载过重。
HDFS优点 | HDFS缺点 |
高容错性(防硬件故障)、适合超大数据数据集、数据访问、构建成本低、多硬件软件可移植性、高效性、可靠性 | 不适合低延迟数据处理，不适合小文件存储，不适合并发写入文件修改、文件随机修改 |
自定义HDFS块大小
为什么HDFS块大小要设置为128MB
相对于文件来说128MB以上的文件是比较少的，这个大小是为了 1. 最小化寻址开销时间 2.为了节省内存使用率。
缺点：不适合小文件存储需求，当创建一个块的时候就会在多创建一个150字节的源数据信息文件，小文件多了源数据信息目录也就多了，存储率就低了。
自定义块大小
$ vim $HADOOP_HOME/etc/hadoop/hdfs-site.xml
!插入下面代码在</configuration>标签里面
[------------------------------------------------
<property>
<name>dfs.blocksize</name>
<value>128</value> <!-- 设置为你希望的块大小，例如 256 表示 256MB -->
</property>
-------------------------------------------------]HDFS的读写数据操作
Namenode负责文件系统的元数据管理，Datanode存储实际的数据块，而Secondary Namenode协助Namenode进行元数据的维护工作。这三者共同协作，实现了HDFS中数据的可靠存储和高效读写操作。
- Namenode： Namenode是HDFS的主要元数据管理者。它负责管理文件系统的命名空间、文件和目录结构，以及文件与数据块之间的映射关系。客户端首先与Namenode进行交互以获取文件的元数据，如文件的位置、副本信息等。
- Datanode： Datanode是存储实际数据块的节点。当客户端需要读取文件时，它会向Namenode请求文件的元数据，并获取文件的数据块位置。然后，客户端直接从对应的Datanode获取数据块，以实现高效的数据读取。
- 写入数据流程：
- 客户端向Namenode请求创建一个新的文件，Namenode返回文件元数据。
- 客户端将数据分割成数据块，并选择一个Datanode作为主要写入位置，将数据块写入该Datanode。
- 该Datanode将数据块存储在本地磁盘上，并向其他副本所在的Datanodes复制数据块，以创建副本。
- 客户端告知Namenode写入完成，Namenode更新文件的元数据，包括副本的位置等信息。
- 读取数据流程：
- 客户端向Namenode请求文件的元数据。
- Namenode返回文件的元数据，包括数据块的位置。
- 客户端根据数据块位置直接与相应的Datanode进行通信，获取所需的数据块。
- 如果所需数据块的副本存在问题，客户端可以选择从其他副本获取数据。
- **Secondary Namenode：**Secondary Namenode主要负责协助Namenode处理元数据的持久化工作，以避免Namenode的负载过重。它定期从Namenode复制元数据，合并编辑日志，生成新的镜像文件，从而保持元数据的一致性和可靠性。
HDFS机制
HDFS会记录你的所有操作和操作对文件的更改等信息的元数据来判断存储的是否正确等，但是他会越来越大，所以他定时会创建一个映像文件，记录在编辑日志中，当HDFS启动时先加载最近的映像文件随后读取编辑日志推演恢复和更新到之前的状态。
映像文件（fsimage）： 映像文件是一个快照，它包含了HDFS文件系统的整体结构、文件、目录以及文件与数据块之间的映射关系等元数据信息。映像文件在HDFS启动时被加载到内存中，以便快速提供文件系统元数据。由于映像文件比较大，它不适合频繁更新。因此，HDFS采用了编辑日志来记录元数据的变更。
编辑日志（edit log）： 编辑日志是一系列的记录，用于记录HDFS文件系统的元数据变更操作，如文件创建、删除、重命名等。每当发生文件系统元数据的变更时，HDFS都会将对应的操作记录到编辑日志中。编辑日志的记录是追加写入的，因此它适合频繁的元数据变更。编辑日志的格式使得HDFS能够在恢复时将这些操作应用到映像文件，从而更新文件系统的元数据。
将fsimage、edit log以xml文件格式输出以方便查看
$ cd $HADOOP_HOME/tmp/dfs/name/current # 日志和映像文件根目录
》 hdfs oiv -i [fsimage/edit_xxxxxxx] -o [导出目标文件路径] -p XML 《
$ hdfs oiv -i fsimage_00000000052 -o -/fs52.xml -p XML
$ hdfs oiv -i edit_00000000052 -o -/fs52.xml -p XML启动集群的步骤
- 当HDFS启动时，它首先加载映像文件，从而可以快速提供文件和目录的元数据信息。
- 之后，HDFS将编辑日志中的操作应用到映像文件，以更新文件系统的元数据，从而保持文件系统的一致性。
- 然后，进行检查点设置，创建一个空的edit文件，把所有未合并的edit日志和fsimage合并成一个新的fsimage
- 最后，当收到datenode节点的心跳反馈收到节点心跳保证数据正确之后退出安全模式，安全模式下不可以正常提供服务和进行操作
- 定期，HDFS会将已应用的编辑日志截断，从而防止编辑日志过大影响性能。
安全模式操作：
- 判断是否在安全模式当前：hdfs dfsadmin -safemode get
- 进入安全模式： hdfs dfsadmin -safemode enter
- 离开安全模式： hdfs dfsadmin -safemode leave心跳机制操作：
slave启动后，会主动连接IPC服务，并且每隔3秒链接一次，这个时间是可以调整的，设置heartbeat，这个每隔一段时间连接一次的机制，称为心跳机制。slave通过心跳给Namenode汇报自己信息，Namenode通过心跳下达命令。当Namenode没有收到来自节点的心跳达到2 x recheck + 10 x heartbeat(10:30秒)就认为slave节点挂了。就会找回原来的东西备份
属性: dfs.namenode.heartbeat.recheck-interval 的默认值为5分钟 #Recheck的时间单位为毫秒
属性: dfs.heartbeat.interval 的默认值时3秒 #eartbeat的时间单位为秒
Secondary Namenode机制：
SecondaryNamenode,是HDES集群中的重要组成部分，它可以辅助Namenode进行fsimage和editlog的合并工作，减小editlog文件大小，以便缩短下次Namenode的重启时间，能尽快退出安全模式。
有关Secondary Namenode可以在hdfs-default.xml中修改 txid(事务操作次数)
属性 | 默认值 | 解读 |
dfs.namenode .checkpoint .period | 3600(秒) | 两次检查点间隔的秒数，默认一小时 |
dfs.namenode.checkpoint.txns | 1000000(次) | txid执行100w次也执行checkpoint |
dfs.namenode.checkpoint .check.period | 60(秒) | 60秒检查一次txid执行次数 |
工作机制：当日志达到打包时间或者次数达到限制后Secondary Namenode会让Namenode暂停工作，把edit 和fsimage映像文件打包(http)发给Secondary Namenode，把他们加载到内存演算后再把它打包成最新的fsimage发送回去(发送回去的是ckpt文件)整理好名字再删除老的fsimage文件。
图解Hadoop的读和写操作
使用IDE对Hadoop集群的操作
- 在本地安装hadoop-windows或者mac，依然使用之前部署在服务器上的包就可以了，在一个合适的位置解压并配置环境变量即可 (电脑要提前有java8环境)
- 此电脑右键管理，高级系统设置，环境变量中新建系统变量
HADOOP_HOME D:\Code environment\Hadoop-3.1.1 <填自己的hadoop解压路径不要照抄>
hadoop.home.dir D:\CodeEnvironment\hadoop-3.3.1 <这个需要填写>
PATH中添加
%HADOOP_HOME%\bin
%HADOOP_HOME%\sbin
下载windows专用二进制文件和工具类依赖库: hadoop在windows上运行需要winutils支持和hadoop.dll等文件
[https://github.com/cdarlint/winutils] 你可以来这里下载你对应版本的这两个文件，对于3.1.1我们会给你提供：[链接：https://wwyy.lanzouc.com/icE6615w8ppc]
将它放到hadoop下的bin目录中即可。
！注意配置的hadoop，java环境不可以存放在有空格的文件夹内，否则会出现错误，例如D:\Code environmer\……上面的图片就是错误的，修改后即可- 给hadoop更改配置文件信息：
- 进入Hadoop/etc/hadoop文件夹，使用记事本打开更改 hadoop-env.cmd 文件中找到下面代码优化一下
@rem The java implementation to use. Required.
set JAVA_HOME=【删掉原来的这里填写你的JAVA_HOME路径】
-保存
-现在win+R打开cmd输入 hadoop version 输出版本号则为成功IDE操作Hadoop——HDFSapi
打开IntelliJ IDEA工具创建一个新项目，项目为Maven
!这里需要你有一定的Maven搭建基础，看不懂或者不会导包maven请学会再回来
- 修改pom.xml配置文件给maven导包，在中间插入以下代码
[-----------------------------------------
<dependencies>
<!-- Hadoop Common -->
<dependency>
<groupId>org.apache.hadoop</groupId>
<artifactId>hadoop-common</artifactId>
<version>3.3.1</version>
</dependency>
<!-- Hadoop HDFS -->
<dependency>
<groupId>org.apache.hadoop</groupId>
<artifactId>hadoop-hdfs</artifactId>
<version>3.3.1</version>
</dependency>
<!-- Hadoop Client -->
<dependency>
<groupId>org.apache.hadoop</groupId>
<artifactId>hadoop-client</artifactId>
<version>3.3.1</version>
</dependency>
</dependencies>
-----------------------------------------]
在java文件夹下创建软件包，例如我这边叫com.testhadoopide.hdfs,根据情况编写
创建一个java类：HDFSApi写如下东西：package com.testhadoopide.hdfs;
import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.fs.FileSystem;
import org.junit.Test;
import java.io.IOException;
public class HDFSapi {
/**
* 测试文件系统对象的获取
*/
@Test // 这里的@Test是junit的注解，需要导入junit的包,作为模拟测试环境
public void getFileSystemTest() throws IOException {
// 1. 创建配置对象
Configuration conf = new Configuration();
// 2. 获取文件系统对象
conf.set("fs.defaultFS", "hdfs://192.168.3.158:9820");
// 3. 获取文件系统对象，org.apache.hadoop.fs包不要导错了;异常直接抛出
FileSystem fs = FileSystem.get(conf);
// 4. 输出文件系统对象
System.out.println(fs.getClass().getName()); // 打印文件系统对象的类名
}
}对上文件的解读：
这段代码是一个简单的Java类，用于测试在Hadoop集群中连接和操作HDFS（Hadoop分布式文件系统）
1. 导入必要的类和包，包括 Configuration 类用于配置，FileSystem 类用于操作文件系统。
2. 使用 @Test 注解标记的方法是可执行的，这里是为了测试代码连接性。
3. 创建一个 Configuration 对象，这个对象会加载Hadoop的配置文件，比如 core-site.xml，用来配置HDFS连接信息。
4. 设置HDFS的默认文件系统地址，这里是 hdfs://192.168.3.158:9820。
5. 获取文件系统对象，这里使用 FileSystem.get(conf) 方法来获取Hadoop文件系统的实例。
6. 打印获取到的文件系统对象的类名。
当涉及正式使用的情况下时我们会把@Test改为@Before，在操作代码之前，这样就可以提前获取到文件系统对象FileSystem会被提取成变量以方便调用，不用每次使用都初始化一次。最终效果如下：package com.testhadoopide.hdfs;
import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.fs.FileSystem;
import org.junit.Before;
import java.io.IOException;
public class HDFSapi {
private FileSystem fs;
/**
* 测试文件系统对象的获取
*/
@Before // 让此方法在任务开始前自动执行
public void getFileSystemTest() throws IOException {
/* // 0. 设置HDFS操作用户是谁
System.setProperty("HADOOP_USER_NAME","root"); */
// 1. 创建配置对象
Configuration conf = new Configuration();
// 2. 获取文件系统对象
conf.set("fs.defaultFS", "hdfs://192.168.3.158:9820");
// 3. 获取文件系统对象
fs = FileSystem.get(conf);
// 4. 输出文件系统对象
System.out.println(fs.getClass().getName()); // 打印文件系统对象的类名
}
}
// 最后成功执行应该打印：org.apache.hadoop.hdfs.DistributedFileSystemIDE操作Hadoop——文件流关闭操作
/**
* 关闭文件系统对象
*/
@After // 让此方法在任务结束后自动执行
public void closeFileSystemTest() throws IOException {
fs.close();
}IDE操作Hadoop——文件上传和下载
这里上传会出现一个问题就是用户权限不足，我们对HDFS进行的操作使用的都是系统登录的用户，因此使用不正确的用户进行写操作的时候就出现权限不足的问题，解决：
修改需要操作的文件路径权限为777 修改需要操作的路径所属用户组(不推荐) 设置造作集群的用户(推荐)
请在文件api代码中添加环境变量：
System.setProperty("HADOOP_USER_NAME","root");方法一：使用hadoop.fs.FileSystem
/**
* 文件上传
*/
@Test
public void uploadFileTest() throws IOException {
// fs.copyFromLocalFile(本地路径,dfs路径)
// 1. 创建配置对象,src是本地文件路径，dst是hdfs文件路径
Path src = new Path("D:/Desktop/testfile01.txt");
Path dst = new Path("/上传文件/testfile01.txt");
// 2. 上传文件,抛出异常
fs.copyFromLocalFile(src,dst);
}
/**
* 文件下载
*/
@Test
public void downloadFileTest() throws IOException {
// fs.copyToLocalFile(dfs路径,本地路径) 与上传位置相反
// 1. 创建配置对象,src是hdfs文件路径，dst是本地文件路径
Path src = new Path("/上传文件/testfile01.txt");
Path dst = new Path("D:/Desktop/testfile01_copyto.txt");
// 2. 下载文件,抛出异常
fs.copyToLocalFile(dst,src);
}
/* 导包参考:
import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.fs.FileSystem;
import org.apache.hadoop.fs.Path;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import java.io.IOException;
*/返回SSH工具测试文件是否上传成功，或者打开webui查看变化
方法二：使用ioUtils
/**
* 使用ioUtils上传、下载文件
*/
@Test
public void ioUtilsTest() throws IOException {
// 0. 设置HDFS操作用户是谁
System.setProperty("HADOOP_USER_NAME","root");
Configuration configuration = new Configuration();
configuration.set("fs.defaultFS", "hdfs://192.168.3.158:9820");
FileSystem fileSystem = FileSystem.get(configuration);
// 1. 创建输入流(这是上传)
FileInputStream input = new FileInputStream("D:/Desktop/testfile01.txt");
// 2. 创建输出流
FSDataOutputStream output = fileSystem.create(new Path("/上传文件/testfile01.txt"));
// FSDataInputStream input = fileSystem.open(new Path("/上传文件/testfile01.txt"));
// FileOutputStream output = new FileOutputStream("D:/Desktop/testfile01_cpto.txt");
// 3. 流的对拷
IOUtils.copyBytes(input,output,configuration);
// 4. 关闭资源
IOUtils.closeStream(output);
IOUtils.closeStream(input);
}IDE操作Hadoop——文件夹创建和删除
/**
* 创建文件夹
*/
@Test
public void createDirTest() throws IOException {
// fs.mkdirs(dfs路径)
fs.mkdirs(new Path("/mkdirDirTest"));
}
/**
* 删除文件夹,也可以删除文件
*/
@Test
public void deleteDirTest() throws IOException {
// fs.delete(dfs路径,是否递归删除)
fs.delete(new Path("/mkdirDirTest"),true);
}IDE操作Hadoop——重命名和文件是否存在
/**
* 重命名文件，文件夹
*/
@Test
public void renameDirTest() throws IOException {
// fs.rename(原文件路径,新文件路径)
Path src = new Path("/上传文件/testfile01.txt");
Path newsrc = new Path("/上传文件/testfile01_new.txt");
if (fs.exists(src)==true){
fs.rename(src,newsrc);
} else {
System.out.println("文件不存在,无法执行");
}
}
/**
* 查看是否有文件，文件夹
*/
public boolean existDirTest(Path src) throws IOException {
// fs.exists(dfs路径)
boolean flag = fs.exists(src);
return flag;
}有了查看文件是否存在的方法我们就可以进行一些完善，比如当文件不存在的时候无法操作提前感知提醒操作者，例如上面的文件重命名，按照此方法试试给文件删除和下载进行修改和完善吧
IDE操作Hadoop——查看文件信息
/**
* 文件状态信息查看
*/
@Test
public void fileStatusTest() throws IOException {
// 获取每一个文件的状态信息列表，返回迭代器对象
// 可以写一个文件，可以写一个非空文件夹
RemoteIterator<LocatedFileStatus> iterator = fs.listLocatedStatus(new Path("/上传文件/testfile01.txt"));
while (iterator.hasNext()) {
LocatedFileStatus fileStatus = iterator.next();
// 文件名
System.out.println("基本信息："+ fileStatus);
// 获取所有的块信息
BlockLocation[] blockLocations = fileStatus.getBlockLocations();
for (BlockLocation blockLocation : blockLocations) {
System.out.println("块信息："+ Arrays.toString(blockLocation.getHosts()));
System.out.println("块大小："+ blockLocation.getLength());
System.out.println("块副本IP地址："+ Arrays.toString(blockLocation.getNames()));
}
System.out.println("系统块大小："+ fileStatus.getBlockSize());
System.out.println("文件总大小："+ fileStatus.getLen());
}
}1. 获取文件状态信息列表：`RemoteIterator<LocatedFileStatus> iterator = fs.listLocatedStatus(new Path("/上传文件/testfile01.txt"))` 使用 `fs.listLocatedStatus` 方法获取指定路径下文件状态信息的迭代器。在这个例子中，路径为 "/上传文件/testfile01.txt"。
2. 迭代文件状态信息：通过 `while (iterator.hasNext())` 循环迭代每一个文件的状态信息。
3. 获取文件的基本信息：`LocatedFileStatus fileStatus = iterator.next()` 获取当前迭代的文件状态信息对象。`System.out.println("基本信息："+ fileStatus)` 打印文件的基本信息。
4. 获取块信息：`BlockLocation[] blockLocations = fileStatus.getBlockLocations()` 获取文件的块信息，即文件在 HDFS 中划分的存储块。通过循环遍历块信息数组，分别打印块的主机信息、大小和副本 IP 地址。
5. 打印系统块大小和文件总大小：`System.out.println("系统块大小："+ fileStatus.getBlockSize())` 打印文件在 HDFS 中的系统块大小，`System.out.println("文件总大小："+ fileStatus.getLen())` 打印文件的总大小。
这段代码主要用于了解指定文件在 HDFS 中的存储状态，包括文件的块分布情况、块大小以及文件总大小等信息。它通过 Hadoop 提供的 API 来获取这些信息，并通过打印输出来展示给用户。
输出参考：
org.apache.hadoop.hdfs.DistributedFileSystem
基本信息：HdfsLocatedFileStatus{path=hdfs://192.168.3.158:9820/上传文件/testfile01.txt; isDirectory=false; length=151164; replication=3; blocksize=134217728; modification_time=1692239126008; access_time=1692239125358; owner=root; group=supergroup; permission=rw-r--r--; isSymlink=false; hasAcl=false; isEncrypted=false; isErasureCoded=false}
块信息：[CentOS01]
块大小：151164
块副本IP地址：[192.168.3.158:9866]
系统块大小：134217728
文件总大小：151164
进程已结束,退出代码0有关上面说的文件的总代码(参考)：https://wwyy.lanzouc.com/ioDTR15w818b【蓝奏云】
YARN的初识
YARN 是Apache Hadoop生态系统中的一个资源管理器和作业调度器，用于管理和分配集群中的计算资源。它的主要作用是协调和管理大规模数据处理作业的资源需求和分配，以实现高效的集群资源利用和作业执行。
YARN 的工作是将集群资源进行有效管理和分配，以便多个应用程序可以在同一集群上并行运行，提高集群资源的利用率，同时保证作业能够按照预期的方式执行。它在大规模数据处理中起着至关重要的作用，使得 Hadoop 生态系统能够高效地处理海量数据。
YARN在Hadoop2.0之后从MapReduce中提取出来的
资源调度负责：
ResourceManager:是在系统中的所有应用程序之间仲裁资源的最终权威，即管理整个集群上的所有资源分配,内部含有一个Scheduler(资源调度器)
NodeManager:是每台机器的资源管理器，也就是单个节点的管理者，负责启动和监视容器(container)资源使用情况，并向ResourceManager及其Scheduler报告使用情况、
container:即集群上的可使用资源，包含cpu、内存、磁盘、网络等
作业的管理调度：
ApplicationMaster:实际上是框架的特定的库，每启动一个应用程序，都会启动一个AM，它的任务是与ResourceManager协商资源，并与NodeManager一起执行和监视任务
1.客户端提交应用程序： 应用程序的开发者通过客户端工具（如命令行或API）将应用程序提交到YARN。应用程序可以是一个MapReduce作业、Spark作业、Hive查询等。提交的信息包括应用程序的资源需求、优先级、启动命令等。
2.ResourceManager接收应用程序： ResourceManager是YARN的核心组件之一，负责全局的资源管理和作业调度。当ResourceManager接收到新的应用程序提交请求时，它会为该应用程序分配一个唯一的Application Master。
3.资源分配： ResourceManager根据应用程序的资源需求，从集群中的可用资源中分配合适的资源给该应用程序。资源可以包括CPU、内存、磁盘等。
4.启动Application Master： ResourceManager会为每个应用程序分配一个Application Master（AM）。AM是应用程序的管理组件，负责与ResourceManager交互，协调作业执行过程，监控任务的状态等。
5.任务分配和执行： Application Master根据应用程序的类型（如MapReduce、Spark等）将作业拆分成不同的任务，并将这些任务分配给集群中的NodeManager。NodeManager是每个节点上的代理，负责管理和监控本地资源，执行任务等。
6.任务执行： NodeManager接收到任务后，会启动对应的任务执行器（如Map任务执行器、Reduce任务执行器等），执行任务的计算逻辑。任务执行器会从HDFS等存储系统中读取数据，处理数据，然后将结果写回存储系统。
7.状态监控和报告： Application Master会定期从NodeManager和ResourceManager收集任务的状态和进度信息。它会维护整个作业的状态，并将状态信息报告给客户端和ResourceManager。
8.任务完成和失败处理： 一旦任务完成，Application Master会通知ResourceManager，ResourceManager会更新作业的状态。如果任务失败，Application Master会尝试重新分配任务或请求更多资源，以确保作业的完成。
9.应用程序完成： 当所有任务都成功完成或者应用程序失败后，Application Master会通知ResourceManager，标记应用程序的状态为完成。此时，开发者可以从客户端获取应用程序的执行结果和日志。修改YARN的配置文件启动
mapred-site.xml修改：
$ vim $HADOOP_HOME/etc/hadoop/mapred-site.xml
[---------------------------------
<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=/usr/local/hadoop-3.3.1</value>
</property>
<property>
<name>mapreduce.map.env</name>
<value>HADOOP MAPRED HOME=/usr/local/hadoop-3.3.1</value>
</property>
<property>
<name>mapreduce.reduce.env</name>
<value>HADOOP_MAPRED_HOME=/usr/local/hadoop-3.3.1</value>
</property>
</configuration>
---------------------------------]
yarn-site.xml修改：
$ vim $HADOOP_HOME/etc/hadoop/yarn-site.xml
[---------------------------------
<configuration>
<!-- 设置ResourceManager的位置 -->
<property>
<name>yarn.resourcemanager.hostname</name>
<value>CentOS01</value>
</property>
<!-- 配置yarn的shuffle服务 -->
<property>
<name>yarn.nodemanager.aux-services</name>
<value>mapreduce_shuffle</value>
</property>
</configuration>
----------------------------------]
hadoop-env.sh 修改:
$ vim $HADOOP_HOME/etc/hadoop/hadoop-env.sh # 追加如下代码
[----------------------------------
export YARN_RESOURCEMANAGER_USER=root
export YARN_NODEMANAGER_USER=root
-----------------------------------]
将修改好的配置文件分发到其他机器上：
$ scp mapred-site.xml yarn-site.xml hadoop-env.sh CentOS02:$PWD
$ scp mapred-site.xml yarn-site.xml hadoop-env.sh CentOS03:$PWD
开启yarn服务： 关闭yarn服务：
$ start-yarn.sh $ stop-yarn.sh
参考运行结果：
$ jpsroobts.sh
>>>>连接 CentOS01 中>>>>
85649 DataNode
868 ResourceManager
85398 NameNode
1182 NodeManager
>>>>连接 CentOS02 中>>>>
3380 NodeManager
90519 DataNode
90702 SecondaryNameNode
>>>>连接 CentOS03 中>>>>
84901 DataNode
123396 NodeManager接下来我们就可以登录hadoop的web后台了，使用的是ResourceManager的8088端口默认 192.168.3.158:8088,现在你可以做一个任务来看看YARN的运行，(词频分析等)
当你做任务的时候发现提示yarn执行MapReduce任务时，找不到主类错误时，在配置文件yarn-site.sh中插入以下内容：
[-----------------------------------
1. 运行 hadoop classpath 复制输出结果
2. 把上述输出的值添加到yarn-site.xml文件对应的属性 yarn.application.classpath下面
[--------------------------
<property>
<name>yarn.application.classpath</name>
<value>【你的值】</value>
</property>
--------------------------]
3. 重新运行yarn并且重新上传任务即可。
------------------------------------]YARN的历史记录管理和聚合
YARN在运行MapReduce任务的时候我们可以在控制台上看到输出的日志，同时在结束之后YARN也会把日志写在本地的
$HADOOP_HOME/logs/userlogs中，随着YARN被重启而删除。如果不想让他重启删除日志可以开启YARN的历史日志服务，在进行任务结束后还会在HDFS中备份一份通过hadoop的历史任务服务来查看到之前的历史日志。有时候一个程序会被分配在一个一个指定的节点，日志不会在一台机器上，所以这也提供了日志聚合服务
1. 修改配置文件：mapred-site.xml
[-------------------------------------
<!-- 历史任务的内部通讯地址 -->
<property>
<name>MapReduce.jobhistory.address</name>
<value>CentOS01:10020</value>
</property>
<!--历史任务的外部监听页面-->
<property>
<name>MapReduce.jobhistory.webapp.address</name>
<value>CentOS01:19888</value>
</property>
--------------------------------------]
2. 修改配置文件：yarn-site.xml
[--------------------------------------
<!-- 是否需要开启日志聚合 -->
<!-- 开启日志聚合后，将会将各个Container的日志保存在yarn,nodemanager,remote-app-log-dir的位置 -->
<!-- 默认保存在/tmp/logs -->
<property>
<name>yarn.log-aggregation-enable</name>
<value>true</value>
</property>
<!-- 历史日志在HDFS保存的时间，单位是秒 -->
<!-- 默认的是-1，表示永久保存 259200即为3天-->
<property>
<name>yarn.log-aggregation.retain-seconds</name>
<value>259200</value>
</property>
<property>
<name>yarn.log.server.url</name>
<value>http://CentOS01:19888/jobhistory/logs</value>
</property>
--------------------------------------]
3. 分发配置文件：
$ cd $HADOOP_HOME/etc/hadoop
$ scp mapred-site.xml yarn-site.xml CentOS02:$PWD
$ scp mapred-site.xml yarn-site.xml CentOS03:$PWD
4. 重启YARN开启历史记录功能：
$ stop-yarn.sh
$ start-yarn.sh
$ mapred --daemon start historyserver
# 查看进程是否在CentOS01中出现历史记录进程，现在可以跑一个项目试试!扩展，在3.0以上版本可以不修改mapred-site.xml开启此项服务
只要修改yarn-site.xml即可：
[--------------------------------------
<!-- 启用YARN时间轴服务 -->
<property>
<name>yarn.timeline-service.enabled</name>
<value>true</value>
<!-- 设置为true以启用YARN时间轴服务 -->
</property>
<property>
<name>yarn.timeline-service.webapp.address</name>
<value>CentOS01:19888</value>
</property>
<!-- 设置日志保留时间为3天（259200秒） -->
<property>
<name>yarn.log-aggregation.retain-seconds</name>
<value>259200</value>
</property>
---------------------------------------]
$ mapred --daemon start historyserver #开启历史日志服服务YARN的命令
# 查看在yarn中使用资源最多的程序
$ yarn top
# 查看yarn中的所有任务程序
》 yarn application -list [任务运行状态] 《
$ yarn application -list -appStates RUNNING # 查看所有正在运行的状态的程序
$ yarn applocation -list -appStates FAILED # 查看所有失败状态的程序
！扩展任务运行状态：NEW（新建）、SCHEDULED（已调度）、ALLOCATED（已分配）、RUNNING（运行中）、FINISHED（已完成） 任务已经成功完成。、FAILED（失败）、KILLED（被杀死）、ERROR（错误）、KILL_WAIT（等待终止）、SUCCEEDED（成功）、ALL（所有程序）。
# 删除，杀掉任务
》 yarn application -kill [任务ID] 《
$ yarn application -kill job_1692334802201_0001 # 杀掉正在运行的job_1692334802201_0001任务
# 获取任务分配的分片(container)
$ yarn container -list [任务AttemptID] # 注意，不是任务ID，需要你登录19888端口点开任务查看
# 获取指定分片的信息
$ yarn contation -list [AM Contalner节点ID] # 在19888端口点击AttemptID可获取
# 查看节点运行的分片数量
$ yarn node -all -listYARN的调度器
YARN有三种调度器：这三种调度器各有特点，可以根据集群的需求和应用程序的特性选择合适的调度器。容量调度器适用于固定资源分配，公平调度器适用于动态资源共享，DRF 调度器适用于多资源环境的高效调度。
- FIFO 调度器（First-In-First-Out）：按照任务提交的顺序进行调度，不考虑任务的资源需求和优先级，适用于简单场景。先进先出！，最大的问题就是他不考虑现有的任务是否需要很长时间才能做完导致后面任务堵塞排队，非常不适合任务多而复杂的场景。
- Capacity Scheduler：容量调度器，允许在集群中预先分配资源给不同的队列，每个队列可以设置固定的资源容量，适用于多用户和多应用场景。简单来说就是留有余力，保证有小任务进来大任务不断小任务快速算完，可能大型任务就没有FIFO快，如果不是长时间多任务的场景效果提升不大。
- Fair Scheduler：公平调度器，根据任务的权重分配资源，适用于多用户和多应用场景，可以根据队列的权重动态分配资源。任务A运行来任务B，任务A关掉一半资源给B一起算。
在不配置的情况默认使用容量调度器，但是他却只有一个通道，也就是类FIFO 调度器。接下来我们就来探讨如何实现真正的容量调度器
配置队列任务——容量调度器
修改配置文件 ：$HADOOP_HOME/etc/hadoop/capacity-scheduler.xml 添加一个 small 的任务队列
！在修改前可以先复制一份进行备份，以免配置错误无法恢复
<configuration>
<!--同时运行的程序数量,不用修改-->
<property>
<name>yarn.scheduler.capacity.maximum-applications</name>
<value>10000</value>
<description>
Maximum number of applications that can be pending and running.
</description>
</property>
<!--MRAppMaster进程所占的资源队列百分比，不用修改-->
<property>
<name>yarn.scheduler.capacity.maximum-am-resource-percent</name>
<value>0.1</value>
<description>
Maximum percent of resources in the cluster which can be used to run
application masters i.e. controls number of concurrent running
applications.
</description>
</property>
<!--为Job分配工作的时候，使用什么策略，不用修改-->
<property>
<name>yarn.scheduler.capacity.resource-calculator</name>
<value>org.apache.hadoop.yarn.util.resource.DefaultResourceCalculator</value>
<description>
The ResourceCalculator implementation to be used to compare
Resources in the scheduler.
The default i.e. DefaultResourceCalculator only uses Memory while
DominantResourceCalculator uses dominant-resource to compare
multi-dimensional resources such as Memory, CPU etc.
</description>
</property>
<!--调度器中有什么队列，我们添加一个small队列，需要修改-->
<property>
<name>yarn.scheduler.capacity.root.queues</name>
<value>default,small</value>
<description>
The queues at the this level (root is the root queue).
</description>
</property>
<!--配置default的队列容量百分比，需要修改，现在大任务占用75%，小任务25%-->
<property>
<name>yarn.scheduler.capacity.root.default.capacity</name>
<value>75</value>
<description>Default queue target capacity.</description>
</property>
<property>
<name>yarn.scheduler.capacity.root.small.capacity</name>
<value>25</value>
<description>Default queue target capacity.</description>
</property>
<!--default队列用户能使用的最大百分比，不用修改，添加small值也为1-->
<property>
<name>yarn.scheduler.capacity.root.default.user-limit-factor</name>
<value>1</value>
<description>
Default queue user limit a percentage from 0.0 to 1.0.
</description>
</property>
</property>
<property>
<name>yarn.scheduler.capacity.root.small.user-limit-factor</name>
<value>1</value>
<description>
Default queue user limit a percentage from 0.0 to 1.0.
</description>
</property>
<!--不用修改，default队列任务能使用的最大百分比，同属性添加small-->
<property>
<name>yarn.scheduler.capacity.root.default.maximum-capacity</name>
<value>100</value>
<description>
The maximum capacity of the default queue.
</description>
</property>
<property>
<name>yarn.scheduler.capacity.root.small.maximum-capacity</name>
<value>100</value>
<description>
The maximum capacity of the default queue.
</description>
</property>
<!--标记default队列状态，不要修改同时添加small配置-->
<property>
<name>yarn.scheduler.capacity.root.default.state</name>
<value>RUNNING</value>
<description>
The state of the default queue. State can be one of RUNNING or STOPPED.
</description>
</property>
<property>
<name>yarn.scheduler.capacity.root.small.state</name>
<value>RUNNING</value>
<description>
The state of the default queue. State can be one of RUNNING or STOPPED.
</description>
</property>
<!--default配置队列的提交用户权限，不用修改添加small配置-->
<property>
<name>yarn.scheduler.capacity.root.default.acl_submit_applications</name>
<value>*</value>
<description>
The ACL of who can submit jobs to the default queue.
</description>
</property>
<property>
<name>yarn.scheduler.capacity.root.small.acl_submit_applications</name>
<value>*</value>
<description>
The ACL of who can submit jobs to the default queue.
</description>
</property>
<!--acl权限控制，不用动添加一个small配置-->
<property>
<name>yarn.scheduler.capacity.root.default.acl_administer_queue</name>
<value>*</value>
<description>
The ACL of who can administer jobs on the default queue.
</description>
</property>
<property>
<name>yarn.scheduler.capacity.root.small.acl_administer_queue</name>
<value>*</value>
<description>
The ACL of who can administer jobs on the default queue.
</description>
</property>
<!--下面的不用动他-->
<property>
<name>yarn.scheduler.capacity.root.default.acl_application_max_priority</name>
<value>*</value>
<description>
The ACL of who can submit applications with configured priority.
For e.g, [user={name} group={name} max_priority={priority} default_priority={priority}]
</description>
</property>
<property>
<name>yarn.scheduler.capacity.root.default.maximum-application-lifetime
</name>
<value>-1</value>
<description>
Maximum lifetime of an application which is submitted to a queue
in seconds. Any value less than or equal to zero will be considered as
disabled.
This will be a hard time limit for all applications in this
queue. If positive value is configured then any application submitted
to this queue will be killed after exceeds the configured lifetime.
User can also specify lifetime per application basis in
application submission context. But user lifetime will be
overridden if it exceeds queue maximum lifetime. It is point-in-time
configuration.
Note : Configuring too low value will result in killing application
sooner. This feature is applicable only for leaf queue.
</description>
</property>
…………省略源码和修改码源文件 链接：https://wwyy.lanzouc.com/i4MTr15w8k2j
你需要发给多个节点同时重启yarn服务，你现在可以写两个任务试试了。
指定任务使用的节点：yarn jar $HADOOP_HOME/share/hadoop/mapreduce/hadoop-mapreduce-examples-3.3.1.jar pi -Dmapreduce.job.queuename=small 10 1000000
【-Dmapreduce.job.queuename=small】
现在到8088端口侧栏在 Scheduler 可以查看通道压力
设置任务默认提交队列：正常情况下我们优先使用default，如果想要修改你只需要修改mapred-site.xml
添加下面语句：
<!--配置默认的提交队列-->
<property>
<name>mapreduce.job.queuename</name>
<!--设置队列为small默认提交-->
<value>small</value>
</property>
