Hadoop总结
谁说大象不能跳舞，大象能跳舞啊！！！！不过跳起来是笨重的、、、、、、
概述
Hadoop 是一个性能、可靠性、可扩展性、可管理性的软件，为以后的分布式打下了基础，接下来咱们好好的深刨一下这个有意思的框架。
因为MR是进程集运算，写代码的时候不注意线程安全的问题。
Hadoop 使用的是socket长连接，原理是一直保持着心跳，传送数据，再心跳的一个过程，短连接则是请求一次之后就关闭了，步骤是：连接→数据传输→关闭连接，例如银行就是使用的短连接。
CDH
CDH (Cloudera's Distribution, including Apache Hadoop)，是Hadoop众多分支中的一种，由Cloudera维护，基于稳定版本的Apache Hadoop构建，并集成了很多补丁，可直接用于生产环境。
Cloudera Manager则是为了便于在集群中进行Hadoop等大数据处理相关的服务安装和监控管理的组件，对集群中主机、Hadoop、Hive、Spark等服务的安装配置管理做了极大简化。
详细的使用请查看：http://blog.csdn.net/xfg0218/article/details/52490971
和http://blog.csdn.net/xfg0218/article/details/54880533
安装Hadoop2.6.4 非Zookeeper集群版
此安装的是hadoop2.x版本，所以有YAEN的概念
1-1）、安装
[root@hadoop1 hadoop]# tar -zxvf hadoop-2.6.4.tar.gz
[root@hadoop1 hadoop-2.6.4]# cd etc/hadoop/
1-2）、修改配置文件
[root@hadoop1 hadoop]# vi core-site.xml
加入以下配置：
<configuration>
<property>
<name>fs.defaultFS</name>
<value>hdfs://hadoop1:9000</value>
</property>
<property>
<name>hadoop.tmp.dir</name>
<value>/home/tmpe</value>
</property>
</configuration>
[root@hadoop1 hadoop]# vi hadoop-env.sh
加入以下配置：
export JAVA_HOME=/home/jdk/jdk1.7.0_76
[root@hadoop1 hadoop]#vi hdfs-site.xml
加入以下配置：
<configuration>
<property>
<name>dfs.namenode.name.dir</name>
<value>/home/hadoop/data/name</value>
</property>
# 数据保存路径
<property>
<name>dfs.datanode.data.dir</name>
<value>/home/hadoop/data/data</value>
</property>
# 设置副本数
<property>
<name>dfs.replication</name>
<value>3</value>
</property>
# http的请求地址
<property>
<name>dfs.secondary.http.address</name>
<value>hadoop1:50090</value>
</property>
# 管理权限的，如果这只为false可在win端直接把数据保存到HDFS上
<property>
<name>dfs.permissions</name>
<value>false</value>
</property>
</configuration>
[root@hadoop1 hadoo]# cat slaves
加入以下配置：
hadoop1
hadoop2
hadoop3
[root@hadoop1 hadoop]# cat mapred-env.sh
加入以下配置：
export JAVA_HOME=/home/jdk/jdk1.7.0_76
[root@hadoop1 hadoop]# vi yarn-site.xml
加入以下配置：
<configuration>
# 设置namenode的节点的机器
<property>
<name>yarn.resourcemanager.hostname</name>
<value>hadoop1</value>
</property>
<property>
<name>yarn.nodemanager.aux-services</name>
<value>mapreduce_shuffle</value>
</property>
</configuration>
[root@hadoop1 hadoop]# vi yarn-env.sh
添加JAVA路径
export JAVA_HOME=/home/jdk1.7
[root@hadoop1 hadoop]# mkdir - p /home/tmpe
[root@hadoop1 hadoop]# mkdir -p /home/hadoop/data/name
[root@hadoop1 hadoop]# mkdir -p /home/hadoop/data/data
1-3）、传送到其他的机器上
[root@hadoop1 local]# scp -r hadoop-2.6.4/ hadoop2:$PWD
[root@hadoop1 local]# scp -r hadoop-2.6.4/ hadoop3:/usr/local/
1-4）、Hadoop启动命令
在hadoop1集群的机器上格式化数据
[root@hadoop1 bin]# hadoop namenode -fromat
启动全部的进程：
[root@hadoop1 sbin]# ./start-all.sh
或者单独的启动程序：
[root@hadoop1 sbin]# ./start-dfs.sh
[root@hadoop1 sbin]# ./start-yarn.sh
1-5）、集群启动
[root@hadoop1 sbin]# ./start-all.sh
This script is Deprecated. Instead use start-dfs.sh and start-yarn.sh
Starting namenodes on [hadoop1]
hadoop1: starting namenode, logging to
hadoop1: starting datanode, logging to
hadoop3: starting datanode, logging to
hadoop2: starting datanode, logging to
Starting secondary namenodes [hadoop1]
hadoop1: starting secondarynamenode, logging
starting yarn daemons
starting resourcemanager, logging to
hadoop3: starting nodemanager, logging to
hadoop2: starting nodemanager, logging to
hadoop1: starting nodemanager, logging to
从上面的启动过程可以看出如果机器上有namenode先回启动namenode没有namenode则会启动datanode最后再启动secondarynamenode
1-6）、查看进程
查看进程：
[root@hadoop1 ~]# jps
7996 DataNode
8366 NodeManager
8733 Jps
8251 ResourceManager
[root@hadoop2 ~]# jps
5575 NodeManager
5783 Jps
5466 SecondaryNameNode
5369 DataNode
[root@hadoop3 ~]# jps
4615 Jps
4298 DataNode
4441 NodeManager
1-7）、启动脚本
[root@hadoop1 start_sh]# cat hadoop.sh
cd /usr/local/hadoop-2.6.4/sbin
./start-all.sh
安装Hadoop2.6.4 Zookeeper集群版
准备3台机器，名字分别为skycloud1 / skycloud2 / skycloud3
Zookeeper与JDK提前安装好。
1-1）、安装
[root@skycloud1 hadoop]# tar -zxvf hadoop-2.6.4.tar.gz
[root@skycloud1 hadoop-2.6.4]# cd etc/hadoop/
1-2）、修改配置文件
[root@skycloud1 hadoop]# vi core-site.xml
加入以下配置：
<configuration>
<!-- 指定hdfs的nameservice为ns1 -->
<property>
<name>fs.defaultFS</name>
<value>hdfs://mycluster</value>
</property>
<!-- 指定hadoop临时目录 -->
<property>
<name>hadoop.tmp.dir</name>
<value>/usr/lib/hadoop/tmp/</value>
</property>
<!-- 指定zookeeper地址 -->
<property>
<name>ha.zookeeper.quorum</name>
<value>skycloud1:2181,skycloud2:2181,skycloud3:2181</value>
</property>
</configuration>
[root@skycloud1 hadoop]# vi hadoop-env.sh
加入以下配置：
export JAVA_HOME=/home/jdk/jdk1.7.0_76
[root@skycloud1 hadoop]#vi hdfs-site.xml
加入以下配置：
<configuration>
<!--指定hdfs的nameservice为mycluster，需要和core-site.xml中的保持一致 -->
<property>
<name>dfs.nameservices</name>
<value>mycluster</value>
</property>
<!-- mycluster下面有两个NameNode，分别是nn1，nn2 -->
<property>
<name>dfs.ha.namenodes.mycluster</name>
<value>nn1,nn2</value>
</property>
<!-- nn1的RPC通信地址 -->
<property>
<name>dfs.namenode.rpc-address.mycluster.nn1</name>
<value>skycloud1:9000</value>
</property>
<!-- nn1的http通信地址 -->
<property>
<name>dfs.namenode.http-address.mycluster.nn1</name>
<value>skycloud1:50070</value>
</property>
<!-- nn2的RPC通信地址 -->
<property>
<name>dfs.namenode.rpc-address.mycluster.nn2</name>
<value>skycloud2:9000</value>
</property>
<!-- nn2的http通信地址 -->
<property>
<name>dfs.namenode.http-address.mycluster.nn2</name>
<value>skycloud2:50070</value>
</property>
<!-- 指定NameNode的元数据在JournalNode上的存放位置 -->
<property>
<name>dfs.namenode.shared.edits.dir</name>
<value>qjournal://skycloud1:8485;skycloud2:8485;skycloud3:8485/mycluster</value>
</property>
<!-- 指定JournalNode在本地磁盘存放数据的位置 -->
<property>
<name>dfs.journalnode.edits.dir</name>
<value>/opt/hadoop-2.6.4/journal</value>
</property>
<!-- 开启NameNode失败自动切换 -->
<property>
<name>dfs.ha.automatic-failover.enabled</name>
<value>true</value>
</property>
<!-- 配置失败自动切换实现方式 -->
<property>
<name>dfs.client.failover.proxy.provider.mycluster</name>
<value>org.apache.hadoop.hdfs.server.namenode.ha.ConfiguredFailoverProxyProvider</value>
</property>
<!-- 配置隔离机制方法，多个机制用换行分割，即每个机制暂用一行-->
<property>
<name>dfs.ha.fencing.methods</name>
<value>
sshfence
shell(/bin/true)
</value>
</property>
<!-- 使用sshfence隔离机制时需要ssh免登陆 -->
<property>
<name>dfs.ha.fencing.ssh.private-key-files</name>
<value>/root/.ssh/id_rsa</value>
</property>
<!-- 配置sshfence隔离机制超时时间 -->
<property>
<name>dfs.ha.fencing.ssh.connect-timeout</name>
<value>30000</value>
</property>
</configuration>
[root@skycloud1 hadoo]# cat slaves
加入以下配置：
skycloud1
skycloud2
skycloud3
[root@skycloud1 hadoop]# cat mapred-env.sh
加入以下配置：
export JAVA_HOME=/home/jdk/jdk1.7.0_76
[root@skycloud1 hadoop]# vi yarn-site.xml
加入以下配置：
<configuration>
<!-- 开启RM高可用 -->
<property>
<name>yarn.resourcemanager.ha.enabled</name>
<value>true</value>
</property>
<!-- 指定RM的cluster id -->
<property>
<name>yarn.resourcemanager.cluster-id</name>
<value>yrc</value>
</property>
<!-- 指定RM的名字 -->
<property>
<name>yarn.resourcemanager.ha.rm-ids</name>
<value>rm1,rm2</value>
</property>
<!-- 分别指定RM的地址 -->
<property>
<name>yarn.resourcemanager.hostname.rm1</name>
<value>skycloud1</value>
</property>
<property>
<name>yarn.resourcemanager.hostname.rm2</name>
<value>skycloud2</value>
</property>
<!-- 指定zk集群地址 -->
<property>
<name>yarn.resourcemanager.zk-address</name>
<value>skycloud1:2181,skycloud2:2181,skycloud3:2181</value>
</property>
<property>
<name>yarn.nodemanager.aux-services</name>
<value>mapreduce_shuffle</value>
</property>
</configuration>
[root@skycloud1 hadoop]# vi yarn-env.sh
添加JAVA路径
export JAVA_HOME=/home/jdk1.7
[root@skycloud1 hadoop]# mkdir - p /opt/hadoop-2.6.4/journal
[root@skycloud1 hadoop]# mkdir -p /usr/lib/hadoop/tmp/
[root@skycloud2 hadoop]# mkdir -p /usr/lib/hadoop/
1-3）、传送到其他的机器上
[root@skycloud1 opt]# scp -r hadoop-2.6.4/ skycloud2:$PWD
[root@skycloud1 opt]# scp -r hadoop-2.6.4/ skycloud3:/opt/
1-4）、Hadoop启动命令
先启动zookeeper
[root@skycloud1 start_sh]# ./start-zookeeper.sh
在yarn.resourcemanager.zk-address节点上启动journalnode
[root@skycloud1 sbin]# ./hadoop-daemon.sh start journalnode
*************
在skycloud1 集群的机器上格式化数据
[root@skycloud1 bin]# hadoop namenode -fromat
复制文件到skycloud2
[root@skycloud2 ~]# mkdir -p /usr/lib/hadoop/
[root@skycloud1 hadoop]# scp -r tmp/ skycloud2:/usr/lib/hadoop/
格式化ZK
[root@skycloud1 bin]# ./hdfs zkfc -formatZK
启动全部的进程：
[root@skycloud1 sbin]# ./start-all.sh
或者单独的启动程序：
[root@skycloud1 sbin]# ./start-dfs.sh
[root@skycloud2 sbin]# ./start-yarn.sh
查看zookeeper上的信息
[zk: localhost:2181(CONNECTED) 6] ls /hadoop-ha/mycluster
[ActiveBreadCrumb, ActiveStandbyElectorLock]
[zk: localhost:2181(CONNECTED) 7] get /hadoop-ha/mycluster/ActiveStandbyElectorLock
mycluster_x0012_nn1 skycloud1 �F(�>
cZxid = 0x800000017
ctime = Fri Feb 03 10:10:52 CST 2017
mZxid = 0x800000017
mtime = Fri Feb 03 10:10:52 CST 2017
pZxid = 0x800000017
cversion = 0
dataVersion = 0
aclVersion = 0
ephemeralOwner = 0x25a01b27f0d0001
dataLength = 33
numChildren = 0
可以看出来ActiveStandbyElectorLock是一个活跃的锁，主要是选出活跃的leader，工作在zookeeper的控制器(如ZKFailoverController)之间，具体的详解请看：
http://blog.csdn.net/xfg0218/article/details/60320782
1-5）、集群启动
[root@skycloud1sbin]# ./start-all.sh
This script is Deprecated. Instead use start-dfs.sh and start-yarn.sh
Starting namenodes on [skycloud1 skycloud2]
skycloud1: starting namenode, logging to /opt/hadoop-2.6.4/logs/hadoop-root-namenode-skycloud1.out
skycloud2: starting namenode, logging to /opt/hadoop-2.6.4/logs/hadoop-root-namenode-skycloud2.out
skycloud2: starting datanode, logging to /opt/hadoop-2.6.4/logs/hadoop-root-datanode-skycloud2.out
skycloud1: starting datanode, logging to /opt/hadoop-2.6.4/logs/hadoop-root-datanode-skycloud1.out
skycloud3: starting datanode, logging to /opt/hadoop-2.6.4/logs/hadoop-root-datanode-skycloud3.out
Starting journal nodes [skycloud1 skycloud2 skycloud3]
skycloud1: starting journalnode, logging to /opt/hadoop-2.6.4/logs/hadoop-root-journalnode-skycloud1.out
skycloud3: starting journalnode, logging to /opt/hadoop-2.6.4/logs/hadoop-root-journalnode-skycloud3.out
skycloud2: starting journalnode, logging to /opt/hadoop-2.6.4/logs/hadoop-root-journalnode-skycloud2.out
Starting ZK Failover Controllers on NN hosts [skycloud1 skycloud2]
skycloud2: starting zkfc, logging to /opt/hadoop-2.6.4/logs/hadoop-root-zkfc-skycloud2.out
skycloud1: starting zkfc, logging to /opt/hadoop-2.6.4/logs/hadoop-root-zkfc-skycloud1.out
starting yarn daemons
starting resourcemanager, logging to /opt/hadoop-2.6.4/logs/yarn-root-resourcemanager-skycloud1.out
skycloud2: starting nodemanager, logging to /opt/hadoop-2.6.4/logs/yarn-root-nodemanager-skycloud2.out
skycloud3: starting nodemanager, logging to /opt/hadoop-2.6.4/logs/yarn-root-nodemanager-skycloud3.out
skycloud1: starting nodemanager, logging to /opt/hadoop-2.6.4/logs/yarn-root-nodemanager-skycloud1.out
在上的启动顺序中可以看到先启动namenode--> journal nodes --> ZK Failover --> yarn daemons
1-6）、查看进程
查看进程：
[root@skycloud1~]# jps
7996 DataNode
8366 NodeManager
8733 Jps
8251 ResourceManager
[root@skycloud1 hadoop]# jps
2973 ResourceManager
2462 NameNode
2730 JournalNode
2901 DFSZKFailoverController
2308 QuorumPeerMain
2548 DataNode
3073 NodeManager
4278 Jps
[root@skycloud2 ~]# jps
2337 NameNode
2389 DataNode
2594 DFSZKFailoverController
3225 Jps
2278 QuorumPeerMain
2482 JournalNode
2680 NodeManager
1-7）、启动脚本
[root@hadoop1 start_sh]# cat hadoop.sh
cd /usr/local/hadoop-2.6.4/sbin
./start-all.sh
1-8）、查看journal下的文件
[root@skycloud1 journal]# ls
mycluster
[root@skycloud1 journal]# cd mycluster/
[root@skycloud1 mycluster]# ls
current in_use.lock
[root@skycloud1 current]# ls
committed-txid edits_0000000000000000019-0000000000000000020 edits_0000000000000000035-0000000000000000036 edits_inprogress_0000000000000000051
edits_0000000000000000021-0000000000000000022 edits_0000000000000000037-0000000000000000038 last-promised-epoch
edits_0000000000000000023-0000000000000000024 edits_0000000000000000039-0000000000000000040 last-writer-epoch
edits_0000000000000000025-0000000000000000026 edits_0000000000000000041-0000000000000000042 paxos
edits_0000000000000000027-0000000000000000028 edits_0000000000000000043-0000000000000000044 VERSION
edits_0000000000000000029-0000000000000000030 edits_0000000000000000045-0000000000000000046
[root@skycloud1 current]# cat VERSION
#Mon Jan 02 14:55:41 CST 2017
namespaceID=4326435
clusterID=CID-1c109689-972b-41c3-aebe-cbfbea3eeb9c
cTime=0
storageType=JOURNAL_NODE
layoutVersion=-60
可以看到正在写入的数据
MapReduce整体的流程详解
- MapTask会去执行InputFormat的getRecordRead的方法
- getRecordRead去执行LineRecordReader组件中的RecordRead方法中的nextKey与nextValue去获取数据
- nextKey与nextValue去split重拿数据
- 在回到MapTask去执行key与value
- 在wordCountMapper中map去获取数据，最后再把数据通过上下文context写出去
- MapOuputConllecter中的conllecter(key,value)，也就是reduce阶段
- 拿到上一步的数据后会落入到唤醒缓冲区中做排序与溢出，在溢出时会用到compareTo组件进行排序
- 拿到上一步的溢出数据后通过组件splier溢出到磁盘
- 内部的merge组件会把小文件合并成大文件
Hadoop HDFS 系统详解
概述
1、HDFS分为两大角色：Namenode , datanode , Secondary Name
2、nameNode 保存数据的元数据
3、DataNode 负责管理用户的文件的数据块，文件会按照块的大小保存到不同的DataNode ,每一个数据都有很多块的副本，保存在不同的机器上。
4、DataNode 会定期的向namenode汇报保存到数据的情况
5、HDFS的内部工作机制对客户端保持透明，客户端请求访问HDFS都是通过向namenode申请来进行
用户上传文件思路
- 客户端向nameNode发送要上传文件的请求,并把文件分为128M的块
- nameNode 返回给用户是否能上传数据的状态
- 加入用户端需要上传一个120M的文件，客户端会通过Rpc请求NameNode，并返回需要上传给那些DataNode(分配机器的距离以及空间的大小等),会选择离namenode比较近的机器分配,同机架的有限.
- 客户端请求建立block传输管道chnnel上传数据
- 在上传是datanode会与其他的机器建立连接并把数据块传送到其他的机器上
- dataNode向namenode汇报自己的储存情况以及自己的信息
- 档第一个快上传完后再去执行其他的快的上传
补充：
它分为两个部分：NameNode和DateNode，NameNode相当于一个领导，它管理集群内的DataNode，当客户发送请求过来后，NameNode会根据情况指定存储到哪些DataNode上，而其本身自己并不存储真实的数据。那NameNode怎么知道集群内DataNode的信息呢？DataNode发送心跳信息给NameNode。
Namenode具备机架感知的能力，可以配置.
用户读取数据的流程
客户端将需要读取的文件的信息发送给namenode,namenode会把文件的元数据返回给用户，用户根据返回的储存block的机器上去请求datanode的信息，最后客户端再把数据库合并成整个数据。
元数据的Checkpoint 过程
每隔一段时间secondary namenode 将namenode 上积累的所有的edits和一个最新的fsimage下载到本地，并加载到内存进行merge的过程叫做checkpoit
下面是保存edits与fsimage的路径， /usr/local/hadoop-2.6.4/data/name/current/下：
[root@hadoop1 current]# ll
total 2088
-rw-r--r--. 1 root root 270 Sep 2 05:45 edits_0000000000000000001-0000000000000000005
-rw-r--r--. 1 root root 42 Sep 2 08:05 edits_0000000000000000006-0000000000000000007
-rw-r--r--. 1 root root 1048576 Sep 2 08:05 edits_0000000000000000008-0000000000000000008
-rw-r--r--. 1 root root 42 Sep 12 21:14 edits_0000000000000000009-0000000000000000010
-rw-r--r--. 1 root root 42 Sep 12 22:14 edits_0000000000000000011-0000000000000000012
-rw-r--r--. 1 root root 1048576 Sep 12 22:14 edits_inprogress_0000000000000000013
-rw-r--r--. 1 root root 554 Sep 12 21:14 fsimage_0000000000000000010
-rw-r--r--. 1 root root 62 Sep 12 21:14 fsimage_0000000000000000010.md5
-rw-r--r--. 1 root root 554 Sep 12 22:14 fsimage_0000000000000000012
-rw-r--r--. 1 root root 62 Sep 12 22:14 fsimage_0000000000000000012.md5
-rw-r--r--. 1 root root 3 Sep 12 22:14 seen_txid
-rw-r--r--. 1 root root 207 Sep 12 20:45 VERSION
http://hadoop1:50070/dfshealth.html#tab-startup-progress
1-4）、checkPoint的附带作用
namenode和secondary namenode的工作目录存储结构完全相同，所以，当namenode故障退出需要重新恢复时，可以从secondary namenode的工作目录中将fsimage拷贝到namenode的工作目录，以恢复namenode的元数据
DataNode 工作机制
Data会定期的向namenode 汇报自己的block储存的信息，被称为心跳，因为储存的信息特别重要，配置选项如下：
<property>
<name>dfs.blockreport.intervalMsec</name>
<value>3600000</value>
<description>Determines block reporting interval in milliseconds.</description>
</property>
Datanode 进程死亡或者网络的原因导致无法与namenode进行通信，namenome并不会马上任务datanome是死亡的，需要经过一点时间，那么这段时间被称为超时时长，HDFS默认的时间为10分钟+30秒，定义超时的时间为timeout，可以通过hdfs.site.xml进行配置，时间的单位为毫秒，如下：
<property>
<name>heartbeat.recheck.interval</name>
<value>2000</value>
</property>
<property>
<name>dfs.heartbeat.interval</name>
<value>1</value>
</property>
Hadoop & hadoop fs 常用命令
[root@hadoop1 hadoop]# hadoop -help
Usage: hadoop [--config confdir] COMMAND
where COMMAND is one of:
fs run a generic filesystem user client
version print the version
jar <jar> run a jar file
checknative [-a|-h] check native hadoop and compression libraries availability
distcp <srcurl> <desturl> copy file or directories recursively
archive -archiveName NAME -p <parent path> <src>* <dest> create a hadoop archive
classpath prints the class path needed to get the
credential interact with credential providers
Hadoop jar and the required libraries
daemonlog get/set the log level for each daemon
trace view and modify Hadoop tracing settings
or
CLASSNAME run the class named CLASSNAME
Most commands print help when invoked w/o parameters.
[root@hadoop1 hadoop]# hadoop fs -help
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] <localsrc> ... <dst>]
[-copyToLocal [-p] [-ignoreCrc] [-crc] <src> ... <localdst>]
[-count [-q] [-h] <path> ...]
[-cp [-f] [-p | -p[topax]] <src> ... <dst>]
[-createSnapshot <snapshotDir> [<snapshotName>]]
[-deleteSnapshot <snapshotDir> <snapshotName>]
[-df [-h] [<path> ...]]
[-du [-s] [-h] <path> ...]
[-expunge]
[-get [-p] [-ignoreCrc] [-crc] <src> ... <localdst>]
[-getfacl [-R] <path>]
[-getfattr [-R] {-n name | -d} [-e en] <path>]
[-getmerge [-nl] <src> <localdst>]
[-help [cmd ...]]
[-ls [-d] [-h] [-R] [<path> ...]]
[-mkdir [-p] <path> ...]
[-moveFromLocal <localsrc> ... <dst>]
[-moveToLocal <src> <localdst>]
[-mv <src> ... <dst>]
[-put [-f] [-p] [-l] <localsrc> ... <dst>]
[-renameSnapshot <snapshotDir> <oldName> <newName>]
[-rm [-f] [-r|-R] [-skipTrash] <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] <file>]
[-test -[defsz] <path>]
[-text [-ignoreCrc] <src> ...]
[-touchz <path> ...]
[-usage [cmd ...]]
多看一下帮助详情，对今后的操作有帮助
[root@hadoop1 ~]# hadoop fs -mkdir /mkdirComm
[root@hadoop1 ~]# hadoop fs -ls /
drwxr-xr-x - root supergroup 0 2016-10-05 01:55 /mkdirComm
把本地/usr/local/hadoop-2.6.4/etc/hadoop/目录下的所有文件上传到/mkdirComm目录下
[root@hadoop1 ~]# hadoop fs -put /usr/local/hadoop-2.6.4/etc/hadoop/* /mkdirComm
[root@hadoop1 ~]# hadoop fs -ls /mkdirComm
Found 29 items
-rw-r--r-- 3 root supergroup 4436 2016-10-05 01:57 /mkdirComm/capacity-scheduler.xml
-rw-r--r-- 3 root supergroup 1335 2016-10-05 01:57 /mkdirComm/configuration.xsl
-rw-r--r-- 3 root supergroup 318 2016-10-05 01:57 /mkdirComm/container-executor.cfg
-rw-r--r-- 3 root supergroup 952 2016-10-05 01:57 /mkdirComm/core-site.xml
****************
查看全部的数据
[root@hadoop1 ~]# hadoop fs -cat /mkdirComm/capacity-scheduler.xml
<!--
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
***************************
或者用head查看前几行数据
[root@hadoop1 ~]# hadoop fs -cat /mkdirComm/capacity-scheduler.xml | head
<!--
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
把HDFS上的文件下载到本地的/user文件夹下
[root@hadoop1 ~]# hadoop fs -get /mkdirComm/capacity-scheduler.xml /usr/
[root@hadoop1 usr]# ls
bin capacity-scheduler.xml etc games include lib lib64 libexec local sbin share src tmp
把HDFS上的capacity-scheduler.xml重命名为capacity.xml
[root@hadoop1 usr]# hadoop fs -mv /mkdirComm/capacity-scheduler.xml /mkdirComm/capacity.xml
删除HDFS上mkdirComm目录下的capacity-scheduler.xml文件
[root@hadoop1 usr]# hadoop fs -rm /mkdirComm/capacity-scheduler.xml
16/10/05 02:02:43 INFO fs.TrashPolicyDefault: Namenode trash configuration: Deletion interval = 0 minutes, Emptier interval = 0 minutes.
Deleted /mkdirComm/capacity-scheduler.xml
删除HDFS上的mkdirComm夹下的所有的数据
[root@hadoop1 usr]# hadoop fs -rmr /mkdirComm
rmr: DEPRECATED: Please use 'rm -r' instead.
16/10/05 02:04:04 INFO fs.TrashPolicyDefault: Namenode trash configuration: Deletion interval = 0 minutes, Emptier interval = 0 minutes.
Deleted /mkdirComm
详解请查看：
http://archive.cloudera.com/cdh5/cdh/5/hadoop/hadoop-project-dist/hadoop-common/FileSystemShell.html
A）、Hadoop fs –fs [local | <file system URI>]
Hadoop fs –fs [local | <file system URI>]：声明hadoop使用的文件系统，如果不声明的话，使用当前配置文件配置的，按如下顺序查找：hadoop jar里的hadoop-default.xml->$HADOOP_CONF_DIR下的hadoop-default.xml->$HADOOP_CONF_DIR下的hadoop-site.xml。使用local代表将本地文件系统作为hadoop的DFS。如果传递uri做参数，那么就是特定的文件系统作为DFS。
B）、hadoop fs –ls <path>
hadoop fs –ls <path>：等同于本地系统的ls，列出在指定目录下的文件内容，支持pattern匹配。输出格式如filename(full path) <r n> size.其中n代表replica的个数，size代表大小（单位bytes）。
实例：
# hadoop fs -ls /test-20171106/test2.txt
C）、hadoop fs –lsr <path>
hadoop fs –lsr <path>：递归列出匹配pattern的文件信息，类似ls，只不过递归列出所有子目录信息。
实例：
# hadoop fs -lsr /test-20171106/test2.txt
D）、hadoop fs –du <path>
hadoop fs –du <path>：列出匹配pattern的指定的文件系统空间总量（单位bytes），等价于unix下的针对目录的du –sb <path>/*和针对文件的du –b <path> ，输出格式如name(full path) size(in bytes)。
实例：
# hadoop fs -du /test-20171106/test2.txt
E）、hadoop fs –dus <path>
hadoop fs –dus <path>：等价于-du，输出格式也相同，只不过等价于unix的du -sb。
实例：
# hadoop fs -dus /test-20171106/test2.txt
F）、hadoop fs –mv <src> <dst>
hadoop fs –mv <src> <dst>：将制定格式的文件 move到指定的目标位置。当src为多个文件时，dst必须是个目录。
实例：
# hadoop fs -mv /test-20171106/test1.txt /tmp/
G）、hadoop fs –cp <src> <dst>
hadoop fs –cp <src> <dst>：拷贝文件到目标位置，当src为多个文件时，dst必须是个目录。
实例：
# hadoop fs -cp /test-20171106/test1.txt /tmp/
H）、hadoop fs –rm [-skipTrash] <src>
hadoop fs –rm [-skipTrash] <src>：删除匹配pattern的指定文件，等价于unix下的rm <src>。
实例：
# hadoop fs -rm /test-20171106/
I）、hadoop fs –rmr [skipTrash] <src>
hadoop fs –rmr [skipTrash] <src>：递归删掉所有的文件和目录，等价于unix下的rm –rf <src>。
实例：
# hadoop fs -rmr /test-20171106
K）、hadoop fs –rmi [skipTrash] <src>
hadoop fs –rmi [skipTrash] <src>：等价于unix的rm –rfi <src>。
L）、hadoop fs –put <localsrc> … <dst>
hadoop fs –put <localsrc> … <dst>：从本地系统拷贝文件到DFS。
实例：
# hadoop fs -put aaa.txt /test-20171106/
M）、hadoop fs –copyFromLocal <localsrc> … <dst>
hadoop fs –copyFromLocal <localsrc> … <dst>：等价于-put。
N）、hadoop fs –moveFromLocal <localsrc> … <dst>
hadoop fs –moveFromLocal <localsrc> … <dst>：等同于-put，只不过源文件在拷贝后被删除。
实例：
# hadoop fs -moveFromLocal /home/xiaoxu/test2.txt /test-20171106/
O）、hadoop fs –get [-ignoreCrc] [-crc] <src> <localdst>
hadoop fs –get [-ignoreCrc] [-crc] <src> <localdst>：从DFS拷贝文件到本地文件系统，文件匹配pattern，若是多个文件，则dst必须是目录。
实例：
# hadoop fs -get /test-20171106/test1.txt /home
P）、hadoop fs –getmerge <src> <localdst>
hadoop fs –getmerge <src> <localdst>：顾名思义，从DFS拷贝多个文件、合并排序为一个文件到本地文件系统。
实例：
# hadoop fs -getmerge /test-20171106/test1.txt /test-20171106/test2.txt /home/xiao3/aaa.txt
Q）、hadoop fs –cat <src>
hadoop fs –cat <src>：展示文件内容。
实例：
hadoop fs -cat /test-20171106/hive.service.keytab
R）、hadoop fs –copyToLocal [-ignoreCrc] [-crc] <src> <localdst>
hadoop fs –copyToLocal [-ignoreCrc] [-crc] <src> <localdst>：等价于-get。
实例：
# hadoop fs -copyToLocal /test-20171106/hive.service.keytab /home/
S）、hadoop fs –mkdir <path>
hadoop fs –mkdir <path> <path>：在指定位置创建目录，可以制定多个路径。
实例：
# hadoop fs -mkdir /test-20171108 /test-20171107
T）、hadoop fs –setrep [-R] [-w] <rep> <path/file>
hadoop fs -setrep -setrep [-R] [-w] <副本数> <路径> 修改副本数量
实例：
# hadoop fs -setrep -R 2 /test-20171106/hive.service.keytab
Replication 2 set: /test-20171106/hive.service.keytab
可以看到已经修改了2个副本
U）、hadoop fs –chmod [-R] <MODE[,MODE]…|OCTALMODE> PATH…
hadoop fs –chmod [-R] <MODE[,MODE]…|OCTALMODE> PATH…：修改文件的权限，-R标记递归修改。MODE为a+r,g-w,+rwx等，OCTALMODE为755这样。
实例：
# hadoop fs -chmod 777 /test-20171106
V）、hadoop fs -chown [-R] [OWNER][:[GROUP]] PATH…
hadoop fs -chown [-R] [OWNER][:[GROUP]] PATH…：修改文件的所有者和组。-R表示递归。
实例：
# hadoop fs -chown -R root:root /test-20171106
W)、hadoop fs -chgrp [-R] GROUP PATH…
hadoop fs -chgrp [-R] GROUP PATH…：等价于-chown … :GROUP …。
实例：
# hadoop fs -chgrp 777 /tmp
X）、hadoop fs –count[-q] <path>
hadoop fs –count[-q] <path>：计数文件个数及所占空间的详情，输出表格的列的含义依次为：DIR_COUNT,FILE_COUNT,CONTENT_SIZE,FILE_NAME或者如果加了-q的话，还会列出QUOTA,REMAINING_QUOTA,SPACE_QUOTA,REMAINING_SPACE_QUOTA。
实例：
# hadoop fs -count /tmp
1068 26788 328166357 /tmp
L）、设置reduce.tasks启动
hadoop jar /root/hadoop-mapreduce-examples-2.7.3.2.6.0.3-8.jar terasort -Dmapred.reduce.tasks=50 /embrace/1T-input /embrace/1T-ouput
[root@hadoop1 testData]# tail -n 2 addressess.txt
3673,03,820201,凼仔区,820200
3674,03,820301,路环区,820300
查看testtbl-data.csv文件夹的总大小
[root@hadoop1 testData]# hadoop fs -du -h -s testtbl-data.csv
10.8 G testtbl-data.csv
[root@hadoop1 start-single]# hadoop fs -cat /tmpbulkdata/sp_addr_data/sp_address/51cef7aca49a4532b0f5a7099ccea21e|head
DATABLK*_x001D_ ÿÿÿÿÿÿÿÿ@*_x0019_1
sp_addressID[8H>110000! 1
sp_addressPLACE_CODE[8H>北京市10
sp_addressID[8H>320000" 10
distcp（distribution copy）用来在两个HDFS 之间拷贝数据
实例：
hadoop distcp hdfs://hadoop1:8020/tmpbulkdata/sp_addr_data/sp_address/ hdfs://master1:8020/tmpbulkdata/sp_addr_data/sp_address/
# yarn logs -applicationId application_1508901525098_0005
# yarn application -kill application_1508901525098_0005
或
hadoop job -kill job_1469693904965_0011
常用命令
# hdfs dfsadmin -safemode get ## 返回安全模式是否开启的信息，返回 Safe mode is OFF/OPEN
# hdfs dfsadmin -safemode enter ## 进入安全模工
# hdfs dfsadmin -safemode leave ## 强制 NameNode 离开安全模式
# hdfs dfsadmin -safemode wait ## 等待，一直到安全模式结束
实例：
#hadoop dfsadmin -report
**********************
详细的信息请查看：http://blog.csdn.net/xfg0218/article/details/78465722
安全模式实例：
进入安全模式，需要超级管理员
退出安全模式
hadoop dfsadmin -safemode leave
进入安全模式
hadoop dfsadmin -safemode enter
1-18）、查看blocks的信息
hadoop fsck
Usage: DFSck <path> [-move | -delete | -openforwrite] [-files [-blocks [-locations | -racks]]]
<path> 检查这个目录中的文件是否完整
-move 破损的文件移至/lost+found目录
-delete 删除破损的文件
-openforwrite 打印正在打开写操作的文件
-files 打印正在check的文件名
-blocks 打印block报告 （需要和-files参数一起使用）
-locations 打印每个block的位置信息（需要和-files参数一起使用）
-racks 打印位置信息的网络拓扑图 （需要和-files参数一起使用）
A）、查看当前文件的储存路径信息
# hadoop fsck /apps/hive/warehouse/*****.db/station -files -blocks -locations
***********
/apps/hive/warehouse/*****.db/station/station.txt 35 bytes, 1 block(s): OK
0. BP-631917053-172.17.109.151-1505107242047:blk_1074082946_344142 len=35 repl=3 [DatanodeInfoWithStorage[172.17.109.169:1019,DS-93273dbd-5beb-4878-84ba-dda2674690b9,DISK], DatanodeInfoWithStorage[172.17.109.161:1019,DS-88882ffe-de8c-4312-8a4e-f0c20d7d8933,DISK], DatanodeInfoWithStorage[172.17.109.172:1019,DS-1b78dcb6-4a07-4909-9612-35059946aec4,DISK]]
# ssh 172.17.109.169
# find / -name blk_1074082946
B）、查看集群的运行状态
# hadoop fsck /
FSCK started by admin (auth:KERBEROS_SSL) from /172.17.109.153 for path / at Tue Nov 07 17:20:04 CST 2017
**************************
Total size: 11458019104593 B (Total open files size: 209859749 B)
Total dirs: 6684
Total files: 97631
Total symlinks: 0 (Files currently being written: 79)
Total blocks (validated): 166422 (avg. block size 68849185 B) (Total open file blocks (not validated): 54)
Minimally replicated blocks: 166422 (100.0 %)
Over-replicated blocks: 0 (0.0 %)
Under-replicated blocks: 0 (0.0 %)
Mis-replicated blocks: 0 (0.0 %)
Default replication factor: 3
Average block replication: 2.2904844
Corrupt blocks: 0
Missing replicas: 0 (0.0 %)
Number of data-nodes: 20
Number of racks: 1
FSCK ended at Tue Nov 07 17:20:06 CST 2017 in 1453 milliseconds
The filesystem under path '/' is HEALTHY
在以上信息可以看出Default replication factor:3 ： 缺省的备份参数3
Corrupt blocks:0 ： 破损的block数0
Number of data-nodes:20 ： 节点的个数为20个
# hadoop fs -tail /test-20171106/test2.txt
1-20）、显示文件系统，文件系统大小，已用空间，可用空间和已使用百分比
# hadoop fs -df -h
Filesystem Size Used Available Use%
hdfs://rdspProCluster 714.1 T 17.7 T 696.3 T 2%
1-21）、archive压缩文件
A）、对文件进行压缩
# hadoop archive -archiveName zoo.har -p /test-20171106/test1.txt /test-20171106
17/11/06 15:30:28 INFO client.AHSProxy: Connecting to Application History server at rdsp-nn-02.test.com/172.17.109.152:10200
******************************
B）、查看数据
# hadoop dfs -ls har:///test-20171106/zoo.har
# hadoop dfs -ls -R har:/test-20171106/zoo.har
并行解压数据
hdfs dfs -cp har:/test-20171106/zoo.har hdfs:/tmp/
新加机器后会产生数据节点行数据不平衡的现象，在执行任务时会较低效率，平衡术后便会解决这个现象
详细请查看：
http://blog.csdn.net/xfg0218/article/details/78465274
下载文件：链接: https://pan.baidu.com/s/1nvxHkBv 密码: 71tk 如果无法下载请联系作者
#BigDataBench_V3.2.1_Hadoop_Hive/SearchEngine/Index/nutch-1.2-hadoop1/bin/start-balancer.sh -t 10%
注意：在执行此脚本时最好在一个空闲的机器上执行，避免占用执行任务的资源。如果数据量大建议一天执行一次，数据量小建议一周执行一次，按照自己的集群规模以及数据量的大小来执行数据平衡任务
或者
sh $HADOOP_HOME/bin/start-balancer.sh -t 15%
# hadoop version
Hadoop 2.7.3.2.6.0.3-8
Subversion [email protected]:hortonworks/hadoop.git -r c6befa0f1e911140cc815e0bab744a6517abddae
Compiled by jenkins on 2017-04-01T21:32Z
Compiled with protoc 2.5.0
From source with checksum a28afaaa6b3713cb3163c88551b1c48
This command was run using /usr/hdp/2.6.0.3-8/hadoop/hadoop-common-2.7.3.2.6.0.3-8.jar
图实例
1-2）、Nodes信息
http://hadoop1:8088/
http://hadoop1:50090/
HDFS误删除恢复方法
我们每天面对hdfs命令，有时会误删除文件，怎样才能把误删除的文件恢复呢，接下来详细的讲解一下过程
# vi test.txt
# hadoop fs -put test.txt /user/root
# hadoop fs -ls /user/root
Found 1 items
-rw-r--r-- 3 root hdfs 12 2018-01-31 08:25 /user/root/test.txt
# hadoop fs -rmr /user/root/test.txt
rmr: DEPRECATED: Please use 'rm -r' instead.
18/01/31 08:26:16 INFO fs.TrashPolicyDefault: Moved: 'hdfs://rdsp-cn-01.cars.com:8020/user/root/test.txt' to trash at: hdfs://rdsp-cn-01.cars.com:8020/user/root/.Trash/Current/user/root/test.txt
可以看出已经把文件放到垃圾箱了
# hadoop fs -ls /user/root/.Trash/Current/user/root/
Found 1 items
-rw-r--r-- 3 root hdfs 12 2018-01-31 08:25 /user/root/.Trash/Current/user/root/test.txt
# hadoop fs -mv /user/root/.Trash/Current/user/root/test.txt /user/root/
# hadoop fs -ls /user/root/root
Found 1 items
-rw-r--r-- 3 root hdfs 12 2018-01-31 08:25 /user/root/test.txt
次选项在conf下的core-site.xml中，单位是分钟，如果一天便是:60*24=1440
1-2）、通过快照恢复
# hadoop fs -put test.txt /user/root
# hadoop fs -cat /user/root/root/test.txt
123
456
789
# hadoop dfsadmin -allowSnapshot /user/root/root
DEPRECATED: Use of this script to execute hdfs command is deprecated.
Instead use the hdfs command for it.
Allowing snaphot on /user/root/root succeeded
# hadoop fs -createSnapshot /user/root/root/ test-snapshot
Created snapshot /user/root/root/.snapshot/test-snapshot
可以看出来创建的快照是test-snapshot
# hadoop fs -rmr /user/root/root/test.txt
rmr: DEPRECATED: Please use 'rm -r' instead.
18/01/31 09:02:55 INFO fs.TrashPolicyDefault: Moved: 'hdfs://rdsp-cn-01.cars.com:8020/user/root/root/test.txt' to trash at: hdfs://rdsp-cn-01.cars.com:8020/user/root/.Trash/Current/user/root/root/test.txt
# hadoop fs -ls /user/root/root/.snapshot/test-snapshot
Found 1 items
-rw-r--r-- 3 root hdfs 12 2018-01-31 08:25 /user/root/root/.snapshot/test-snapshot/test.txt
# hadoop fs -cp /user/root/root/.snapshot/test-snapshot/test.txt /user/root/root/
# hadoop fs -ls /user/root/root/
Found 1 items
-rw-r--r-- 3 root hdfs 12 2018-01-31 09:06 /user/root/root/test.txt
JAVA操作HDFS
链接：http://pan.baidu.com/s/1qX9krmO 密码：4w2p 请配置windows开发插件，如果无法下载请联系作者。
1-1） 、环境的准备
在项目中把hadoop安装包中的share包导入到项目中。
1-2） 、代码实现
或者在JAVA项目中导入hadoop安装包中的share下的包
A）、文件的增删改查
package hdfs;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.net.URI;
import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.fs.BlockLocation;
import org.apache.hadoop.fs.FileStatus;
import org.apache.hadoop.fs.FileSystem;
import org.apache.hadoop.fs.LocatedFileStatus;
import org.apache.hadoop.fs.Path;
import org.apache.hadoop.fs.RemoteIterator;
import org.junit.Before;
import org.junit.Test;
/**
* HDFS属性的操作
*/
public class HdfsClient {
FileSystem fs = null;
@Before
public void init() throws Exception {
// 加入winutils.exe工具
System.setProperty("hadoop.home.dir",
"E:\\winutils-hadoop-2.6.4\\hadoop-2.6.4");
// 构造一个配置参数对象，设置一个参数：我们要访问的hdfs的URI
// 从而FileSystem.get()方法就知道应该是去构造一个访问hdfs文件系统的客户端，以及hdfs的访问地址
// new Configuration();的时候，它就会去加载jar包中的hdfs-default.xml
// 然后再加载classpath下的hdfs-site.xml
Configuration conf = new Configuration();
conf.set("fs.defaultFS", "hdfs://hadoop1:9000");
/**
* 参数优先级： 1、客户端代码中设置的值 2、classpath下的用户自定义配置文件 3、然后是服务器的默认配置
*/
conf.set("dfs.replication", "3");
// 获取一个hdfs的访问客户端，根据参数，这个实例应该是DistributedFileSystem的实例
// fs = FileSystem.get(conf);
// 如果这样去获取，那conf里面就可以不要配"fs.defaultFS"参数，而且，这个客户端的身份标识已经是hadoop用户
fs = FileSystem.get(new URI("hdfs://hadoop1:9000"), conf, "root");
}
/**
* 往hdfs上传文件
*
* @throws Exception
*/
@Test
public void testAddFileToHdfs() throws Exception {
// 要上传的文件所在的本地路径
Path src = new Path("D:\\hadoop\\AverageScoreInput\\china.txt");
// 要上传到hdfs的目标路径
Path dst = new Path("/updateFile/a.text");
fs.copyFromLocalFile(src, dst);
fs.close();
}
/**
* 从hdfs中复制文件到本地文件系统
*
* @throws IOException
* @throws IllegalArgumentException
*/
@Test
public void testDownloadFileToLocal() throws IllegalArgumentException,
IOException {
fs.copyToLocalFile(new Path("/updateFile/a.text"), new Path("d:/"));
fs.close();
}
/**
* 删除与修改文件夹的名字
*
* @throws IllegalArgumentException
* @throws IOException
*/
@Test
public void testMkdirAndDeleteAndRename() throws IllegalArgumentException,
IOException {
// 创建目录
fs.mkdirs(new Path("/mkdirDirs"));
// 删除文件夹 ，如果是非空文件夹，参数2必须给值true
fs.delete(new Path("/updateFile"), true);
// 重命名文件或文件夹
fs.rename(new Path("/mkdirDirs"), new Path("/mkdirDirs1"));
fs.close();
}
/**
* 查看目录信息，只显示文件
*
* @throws IOException
* @throws IllegalArgumentException
* @throws FileNotFoundException
*/
@Test
public void testListFiles() throws FileNotFoundException,
IllegalArgumentException, IOException {
// 思考：为什么返回迭代器，而不是List之类的容器
RemoteIterator<LocatedFileStatus> listFiles = fs.listFiles(
new Path("/"), true);
while (listFiles.hasNext()) {
LocatedFileStatus fileStatus = listFiles.next();
System.out.println(fileStatus.getPath().getName());
System.out.println(fileStatus.getBlockSize());
System.out.println(fileStatus.getPermission());
System.out.println(fileStatus.getLen());
BlockLocation[] blockLocations = fileStatus.getBlockLocations();
for (BlockLocation bl : blockLocations) {
System.out.println("block-length:" + bl.getLength() + "--"
+ "block-offset:" + bl.getOffset());
String[] hosts = bl.getHosts();
for (String host : hosts) {
System.out.println(host);
}
}
}
}
/**
* 查看文件及文件夹信息
*
* @throws IOException
* @throws IllegalArgumentException
* @throws FileNotFoundException
*/
@Test
public void testListAll() throws FileNotFoundException,
IllegalArgumentException, IOException {
FileStatus[] listStatus = fs.listStatus(new Path("/"));
String flag = "d-- ";
for (FileStatus fstatus : listStatus) {
if (fstatus.isFile())
flag = "f-- ";
System.out.println(flag + fstatus.getPath().getName());
}
}
}
B）、通过流的方式访问Hdfs
package hdfs;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.net.URI;
import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.fs.FSDataInputStream;
import org.apache.hadoop.fs.FSDataOutputStream;
import org.apache.hadoop.fs.FileSystem;
import org.apache.hadoop.fs.Path;
//import org.apache.commons.io.IOUtils;
import org.apache.hadoop.io.IOUtils;
import org.junit.Before;
import org.junit.Test;
public class StreamHdfs {
FileSystem fs = null;
@Before
public void init() throws Exception {
// 加入winutils.exe工具
System.setProperty("hadoop.home.dir",
"E:\\winutils-hadoop-2.6.4\\hadoop-2.6.4");
Configuration conf = new Configuration();
fs = FileSystem.get(new URI("hdfs://hadoop1:9000"), conf, "root");
}
/**
* 通过流的方式上传文件到hdfs
*
* @throws Exception
*/
@Test
public void testUpload() throws Exception {
FSDataOutputStream outputStream = fs.create(
new Path("/angelababy.love"), true);
FileInputStream inputStream = new FileInputStream("c:/angelababy.love");
// IOUtils.copy(inputStream, outputStream);
}
/**
* 把HDFS上的文件的信息下载到本地的文件中
*
* @throws IllegalArgumentException
* @throws IOException
*/
@Test
public void testDownLoadFileToLocal() throws IllegalArgumentException,
IOException {
// 先获取一个文件的输入流----针对hdfs上的
FSDataInputStream in = fs.open(new Path(
"/wordcount/capacity-scheduler.xml"));
// 再构造一个文件的输出流----针对本地的
FileOutputStream out = new FileOutputStream(new File("d:/china.txt"));
// 再将输入流中数据传输到输出流
IOUtils.copyBytes(in, out, 4096);
}
/**
* hdfs支持随机定位进行文件读取，而且可以方便地读取指定长度 用于上层分布式运算框架并发处理数据
*
* @throws IllegalArgumentException
* @throws IOException
*/
@Test
public void testRandomAccess() throws IllegalArgumentException, IOException {
// 先获取一个文件的输入流----针对hdfs上的
FSDataInputStream in = fs.open(new Path(
"/wordcount/capacity-scheduler.xml"));
// 可以将流的起始偏移量进行自定义
in.seek(22);
// 再构造一个文件的输出流----针对本地的
FileOutputStream out = new FileOutputStream(new File("d:/china.txt"));
IOUtils.copyBytes(in, out, 19L, true);
}
/**
* 显示hdfs上文件的内容
*
* @throws IOException
* @throws IllegalArgumentException
*/
@Test
public void testCat() throws IllegalArgumentException, IOException {
FSDataInputStream in = fs.open(new Path(
"/wordcount/capacity-scheduler.xml"));
IOUtils.copyBytes(in, System.out, 1024);
}
}
Hadoop MapReduce 实例
1-1）、Linux 实例
在项目中把hadoop安装包中的share包导入到项目中。
package bigDate;
import java.io.IOException;
import org.apache.hadoop.io.IntWritable;
import org.apache.hadoop.io.LongWritable;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapreduce.Mapper;
/**
* Mapper<KEYIN, VALUEIN, KEYOUT, VALUEOUT> KEYIN 是指框架读取到的数据的key的类型，
* 在默认的InputFormat下，读到的key是一行文本的起始偏移量，所以key的类型是Long VALUEIN 是指框架读取到的数据的value的类型
* ， 在默认的InputFormat下，读到的value是一行文本的内容，所以value的类型是String
*
*
* KEYOUT 是指用户自定义逻辑方法返回的数据中key的类型，由用户业务逻辑决定，
* 在此wordcount程序中，我们输出的key是单词，所以是String
*
* VALUEOUT 是指用户自定义逻辑方法返回的数据中value的类型，由用户业务逻辑决定
* 在此wordcount程序中，我们输出的value是单词的数量，所以是Integer
*
* 但是，String ，Long等jdk中自带的数据类型，在序列化时，效率比较低，hadoop为了提高序列化效率，自定义了一套序列化框架
* 所以，在hadoop的程序中，如果该数据需要进行序列化（写磁盘，或者网络传输），就一定要用实现了hadoop序列化框架的数据类型
*
* Long ----> LongWritable String ----> Text Integer ----> IntWritable Null
* ----> NullWritable
*/
public class WordCountMapper extends
Mapper<LongWritable, Text, Text, IntWritable> {
// 这就是mapreduce框架中一个主体运行程序MapTask所要调用的用户业务逻辑方法
// MapTask会驱动InputFormat去读取数据（keyIN,VALUEIN），每读到一个KV对，就传入这个用户写的map方法中调用一次
// 在默认的inputformat实现中，此处的一个key就是一行的起始偏移量，value就是一行的内容
@Override
protected void map(LongWritable key, Text value, Context context)
throws IOException, InterruptedException {
String line = value.toString();
String[] words = line.split(" ");
for (String word : words) {
context.write(new Text(word), new IntWritable(1));
}
}
}
package bigDate;
import java.io.IOException;
import org.apache.hadoop.io.IntWritable;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapreduce.Reducer;
public class WordCountReducer extends
Reducer<Text, IntWritable, Text, IntWritable> {
// reducetask在调我们写的reduce方法
// reducetask应该收到了前一阶段（map阶段）中所有maptask输出的数据中的一部分
// （数据的key.hashcode%reducetask数==本reductask号）
// reducetask将这些收到kv数据拿来处理时，是这样调用我们的reduce方法的：
// 先将自己收到的所有的kv对按照k分组（根据k是否相同）
// 将某一组kv中的第一个kv中的k传给reduce方法的key变量，把这一组kv中所有的v用一个迭代器传给reduce方法的变量values
@Override
protected void reduce(Text key, Iterable<IntWritable> values,
Context context) throws IOException, InterruptedException {
int count = 0;
for (IntWritable v : values) {
count += v.get();
}
context.write(key, new IntWritable(count));
}
}
package bigDate;
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.input.TextInputFormat;
import org.apache.hadoop.mapreduce.lib.output.FileOutputFormat;
import org.apache.hadoop.mapreduce.lib.output.TextOutputFormat;
public class LinuxWordCount {
public static void main(String[] args) throws Exception {
Configuration conf = new Configuration();
Job job = Job.getInstance(conf);
// 告诉框架，我们的程序所在jar包的路径
job.setJar("/root/wordcount.jar");
// 告诉框架，我们的程序所用的mapper类和reducer类
job.setMapperClass(WordCountMapper.class);
job.setReducerClass(WordCountReducer.class);
// 告诉框架，我们的mapperreducer输出的数据类型
job.setMapOutputKeyClass(Text.class);
job.setMapOutputValueClass(IntWritable.class);
job.setOutputKeyClass(Text.class);
job.setOutputValueClass(IntWritable.class);
// 告诉框架，我们的数据读取、结果输出所用的format组件
// TextInputFormat是mapreduce框架中内置的一种读取文本文件的输入组件
job.setInputFormatClass(TextInputFormat.class);
job.setOutputFormatClass(TextOutputFormat.class);
// 告诉框架，我们要处理的文件在哪个路径下
FileInputFormat.setInputPaths(job, new Path("/wordcount/"));
// 告诉框架，我们的处理结果要输出到哪里去
FileOutputFormat.setOutputPath(job, new Path("/wordcountOutput/"));
boolean res = job.waitForCompletion(true);
System.exit(res ? 0 : 1);
}
}
在开发项目中把项目制作成JAR上传到linux
[root@hadoop1 ~]# hadoop jar wordcount.jar bigDate.LinuxWordCount
***************
File System Counters
FILE: Number of bytes read=241235
FILE: Number of bytes written=2923209
FILE: Number of read operations=0
FILE: Number of large read operations=0
FILE: Number of write operations=0
HDFS: Number of bytes read=196687
HDFS: Number of bytes written=10550
HDFS: Number of read operations=127
HDFS: Number of large read operations=0
HDFS: Number of write operations=11
Map-Reduce Framework
Map input records=773
Map output records=5008
Map output bytes=46713
Map output materialized bytes=56777
Input split bytes=877
Combine input records=0
Combine output records=0
Reduce input groups=603
Reduce shuffle bytes=56777
Reduce input records=5008
Reduce output records=603
Spilled Records=10016
Shuffled Maps =8
Failed Shuffles=0
Merged Map outputs=8
GC time elapsed (ms)=793
CPU time spent (ms)=0
Physical memory (bytes) snapshot=0
Virtual memory (bytes) snapshot=0
Total committed heap usage (bytes)=1370177536
Shuffle Errors
BAD_ID=0
CONNECTION=0
IO_ERROR=0
WRONG_LENGTH=0
WRONG_MAP=0
WRONG_REDUCE=0
File Input Format Counters
Bytes Read=26697
File Output Format Counters
Bytes Written=10550
包含所有运算的信息，请仔细阅读。
详细的请查看：http://blog.csdn.net/xfg0218/article/details/52740327
[root@hadoop1 ~]# hadoop fs -cat /wordcountOutput/part-r-00000
2229
"*" 18
"AS 8
"License"); 8
"alice,bob 18
"kerberos". 1
"simple" 1
*****************
输出的数据是有序的，原因在于mapreduce中的框架已经把顺序排好了。
1-2）、windows 上开发(是单机版程序)
在项目中把hadoop安装包中的share包导入到项目中。下载win执行插件
链接：http://pan.baidu.com/s/1slAKyK1 密码：mc2d 如果无法下载请联系作者。
package bigDate;
import java.io.IOException;
import org.apache.hadoop.io.IntWritable;
import org.apache.hadoop.io.LongWritable;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapreduce.Mapper;
/**
* Mapper<KEYIN, VALUEIN, KEYOUT, VALUEOUT> KEYIN 是指框架读取到的数据的key的类型，
* 在默认的InputFormat下，读到的key是一行文本的起始偏移量，所以key的类型是Long VALUEIN 是指框架读取到的数据的value的类型
* ， 在默认的InputFormat下，读到的value是一行文本的内容，所以value的类型是String
*
*
* KEYOUT 是指用户自定义逻辑方法返回的数据中key的类型，由用户业务逻辑决定，
* 在此wordcount程序中，我们输出的key是单词，所以是String
*
* VALUEOUT 是指用户自定义逻辑方法返回的数据中value的类型，由用户业务逻辑决定
* 在此wordcount程序中，我们输出的value是单词的数量，所以是Integer
*
* 但是，String ，Long等jdk中自带的数据类型，在序列化时，效率比较低，hadoop为了提高序列化效率，自定义了一套序列化框架
* 所以，在hadoop的程序中，如果该数据需要进行序列化（写磁盘，或者网络传输），就一定要用实现了hadoop序列化框架的数据类型
*
* Long ----> LongWritable String ----> Text Integer ----> IntWritable Null
* ----> NullWritable
*/
public class WordCountMapper extends
Mapper<LongWritable, Text, Text, IntWritable> {
// 这就是mapreduce框架中一个主体运行程序MapTask所要调用的用户业务逻辑方法
// MapTask会驱动InputFormat去读取数据（keyIN,VALUEIN），每读到一个KV对，就传入这个用户写的map方法中调用一次
// 在默认的inputformat实现中，此处的一个key就是一行的起始偏移量，value就是一行的内容
@Override
protected void map(LongWritable key, Text value, Context context)
throws IOException, InterruptedException {
String line = value.toString();
String[] words = line.split(" ");
for (String word : words) {
context.write(new Text(word), new IntWritable(1));
}
}
}
package bigDate;
import java.io.IOException;
import org.apache.hadoop.io.IntWritable;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapreduce.Reducer;
public class WordCountReducer extends
Reducer<Text, IntWritable, Text, IntWritable> {
// reducetask在调我们写的reduce方法
// reducetask应该收到了前一阶段（map阶段）中所有maptask输出的数据中的一部分
// （数据的key.hashcode%reducetask数==本reductask号）
// reducetask将这些收到kv数据拿来处理时，是这样调用我们的reduce方法的：
// 先将自己收到的所有的kv对按照k分组（根据k是否相同）
// 将某一组kv中的第一个kv中的k传给reduce方法的key变量，把这一组kv中所有的v用一个迭代器传给reduce方法的变量values
@Override
protected void reduce(Text key, Iterable<IntWritable> values,
Context context) throws IOException, InterruptedException {
int count = 0;
for (IntWritable v : values) {
count += v.get();
}
context.write(key, new IntWritable(count));
}
}
package bigDate;
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.input.TextInputFormat;
import org.apache.hadoop.mapreduce.lib.output.FileOutputFormat;
import org.apache.hadoop.mapreduce.lib.output.TextOutputFormat;
public class LinuxWordCount {
public static void main(String[] args) throws Exception {
Configuration conf = new Configuration();
// 加入winutils.exe工具
System.setProperty("hadoop.home.dir",
"E:\\cenos-6.5-hadoop-2.6.4\\hadoop-2.6.4");
Job job = Job.getInstance(conf);
// 告诉框架，我们的程序所在jar包
job.setJarByClass(WordCountDriver.class);
// 告诉框架，我们的程序所用的mapper类和reducer类
job.setMapperClass(WordCountMapper.class);
job.setReducerClass(WordCountReducer.class);
// 告诉框架，我们的mapperreducer输出的数据类型
job.setMapOutputKeyClass(Text.class);
job.setMapOutputValueClass(IntWritable.class);
job.setOutputKeyClass(Text.class);
job.setOutputValueClass(IntWritable.class);
// 告诉框架，我们的数据读取、结果输出所用的format组件
// TextInputFormat是mapreduce框架中内置的一种读取文本文件的输入组件
job.setInputFormatClass(TextInputFormat.class);
job.setOutputFormatClass(TextOutputFormat.class);
// 告诉框架，我们要处理的文件在哪个路径下
FileInputFormat.setInputPaths(job, new Path(
"D:\\hadoop\\wordCountInput"));
// 告诉框架，我们的处理结果要输出到哪里去
FileOutputFormat.setOutputPath(job, new Path(
"D:\\hadoop\\wordCountOuput"));
boolean res = job.waitForCompletion(true);
System.exit(res ? 0 : 1);
}
}
****************
Shuffle Errors
BAD_ID=0
CONNECTION=0
IO_ERROR=0
WRONG_LENGTH=0
WRONG_MAP=0
WRONG_REDUCE=0
File Input Format Counters
Bytes Read=270651
File Output Format Counters
Bytes Written=107107
详细过程请参考：http://blog.csdn.net/xfg0218/article/details/52741046
1-3）、windows下向Linux集群提交代码
Map端与reduce端的数据不变，只需要修改一下客户端的代码即可，修改如下：
package bigDate;
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.input.TextInputFormat;
import org.apache.hadoop.mapreduce.lib.output.FileOutputFormat;
import org.apache.hadoop.mapreduce.lib.output.TextOutputFormat;
public class LinuxWordCount {
public static void main(String[] args) throws Exception {
System.setProperty("hadoop.home.dir",
"E:\\winutils-hadoop-2.6.4\\hadoop-2.6.4");
Configuration conf = new Configuration();
conf.set("fs.defaultFS", "hdfs://hadoop1:9000");
conf.set("mapreduce,framework,name", "yarn");
conf.set("arn.resourcemanager.hostname", "hadoop1");
// conf.set("-DHADOOP_USER_NAME", "root");
Job job = Job.getInstance(conf);
// 告诉框架，我们的程序所在jar包的路径
job.setJarByClass(LinuxWordCount.class);
// 告诉框架，我们的程序所用的mapper类和reducer类
job.setMapperClass(WordCountMapper.class);
job.setReducerClass(WordCountReducer.class);
// 告诉框架，我们的mapperreducer输出的数据类型
job.setMapOutputKeyClass(Text.class);
job.setMapOutputValueClass(IntWritable.class);
job.setOutputKeyClass(Text.class);
job.setOutputValueClass(IntWritable.class);
// 告诉框架，我们的数据读取、结果输出所用的format组件
// TextInputFormat是mapreduce框架中内置的一种读取文本文件的输入组件
job.setInputFormatClass(TextInputFormat.class);
job.setOutputFormatClass(TextOutputFormat.class);
// 告诉框架，我们要处理的文件在哪个路径下
FileInputFormat.setInputPaths(job, new Path("/wordcount/"));
// 告诉框架，我们的处理结果要输出到哪里去
FileOutputFormat.setOutputPath(job, new Path("/wordcountOutput/"));
boolean res = job.waitForCompletion(true);
System.exit(res ? 0 : 1);
}
}
-DHADOOP_USER_NAME=root
********************
Shuffle Errors
BAD_ID=0
CONNECTION=0
IO_ERROR=0
WRONG_LENGTH=0
WRONG_MAP=0
WRONG_REDUCE=0
File Input Format Counters
Bytes Read=26697
File Output Format Counters
Bytes Written=10550
详细过程：http://blog.csdn.net/xfg0218/article/details/52742648
Hadoop 其他总结
1-1）、Shuffer 概念
Shuffer 是一个数据分发的过程，是在map端到缓冲区溢出开始到reduce端拿到数据的工程叫做shuffer。主要的包含缓存，分区与排序还有数据的分发(实际的是reduce是拉数据的)和传输。过程分为3个操作：
1、分区partition
2、Sort根据key排序
3、Combiner进行局部value的合
1-2）、文件的切片
文件的额切片是有客户端完成的，有jobSubmilit方法来完成的，之后就交给jobTask去执行，这样可以减少集群的运算性能。
Hadoop 优化总结
1-1）、hadoop 优化思路
所有能减少网络的尽量减少网络，所有能减少IO的尽量减少IO
在挂在磁盘时要注意各个目录的划分大小，例如：boot目录的大小，swap目录的大小以及其他挂在的磁盘的大小
1-1）、修改Linux上文件打开的大小
[root@hadoop1 /]# vi /etc/security/limits.conf 添加一下配置
加上：* 代表所有的用户都生效
* soft nofile 10240
* hard nofile 20480
[root@hadoop1 /]# vi /etc/pam.d/login
session required pam_limits.so
与nginx 有相同的优化配置
1-2）、修改网卡的MTU
[root@hadoop1 /]# cat /sys/class/net/eth0/mtu
[root@hadoop1 eth0]# echo "10000" > /sys/class/net/eth0/mtu
要根据网卡的配置来设置，适当的调节参数的大小
1-2）、集群典型的节点分配
角色 描述 节点数目
HDFS Namenode 分布式文件系统用以储存文件 1个独立节点
系统以及数据块的元数据
HDFS Seccondary NameNode的影子点 小规模集群可以和namenode
NameNode 共享节点，大规模集群用独立节点
HDFS DataNode HDFS数据储存 多个独立节点
MapReduce MapReduce调度程序 一个独立节点，小规模集群可以
JobTracker 与NameNode共享，大规模集群
使用独立节点
Hive Hive 元数据的驱动程序 独立配置的话可以与namenode
共享节点，或者将元数据存放在
客户端
Zookeeper 可以提供集群高可用性的所服务 3个或3个以上的奇数的独立
节点(小规模可以和其他的角色
共享节点)
Hbase HMaster HBase用以调度RegionServr的主服务 与其他角色共享节点的多个节点
Management Node CRH特有的管理节点 一般为一个独立的节点如果小
集群的话可以与其他角色共享
Hadopo 集群测试工具
1-1）、软件下载
http://prof.ict.ac.cn/bdb_uploads/bdb_3_1/packages/BigDataBench_V3.2.1_Hadoop.tar.gz
1-2）、使用方法
# cd /opt/BigDataBench_V3.2.1_Hadoop_Hive/SearchEngine/PageRank
# ./run_PageRank.sh 10
10 代表循环10次
基于HDP2.6.0.3-8的Hadoop TestDFSIO、mrbench和nnbench是三个广泛被使用的测试
详细测试过程请查看：http://blog.csdn.net/xfg0218/article/details/78592512
1-1）、Hadoop Test 的测试
# cd /usr/hdp/2.6.0.3-8/hadoop-mapreduce
B）、查看参数
# hadoop jar hadoop-mapreduce-client-jobclient-2.7.3.2.6.0.3-8.jar
*****
1-2）、TestDFSIO write的性能测试
主要目的是测试hadoop写的速度
A）、查看参数
# hadoop jar hadoop-mapreduce-client-jobclient-2.7.3.2.6.0.3-8.jar TestDFSIO
17/11/21 14:46:38 INFO fs.TestDFSIO: TestDFSIO.1.8
Missing arguments.
Usage: TestDFSIO [genericOptions] -read [-random | -backward | -skip [-skipSize Size]] | -write | -append | -truncate | -clean [-compression codecClassName] [-nrFiles N] [-size Size[B|KB|MB|GB|TB]] [-resFile resultFileName] [-bufferSize Bytes] [-rootDir]
B）、运行实例
# hadoop jar hadoop-mapreduce-client-jobclient-2.7.3.2.6.0.3-8.jar TestDFSIO -write -nrFiles 10 -size 10MB
*********
C）、查看数据
# hadoop fs -ls -h /benchmarks/TestDFSIO/io_data
Found 10 items
-rw-r--r-- 3 admin hdfs 10 M 2017-11-21 14:53 /benchmarks/TestDFSIO/io_data/test_io_0
-rw-r--r-- 3 admin hdfs 10 M 2017-11-21 14:53 /benchmarks/TestDFSIO/io_data/test_io_1
***********
D）、查看执行的结果
# cat TestDFSIO_results.log
----- TestDFSIO ----- : write
Date & time: Tue Nov 21 14:53:44 CST 2017
Number of files: 10
Total MBytes processed: 100.0
Throughput mb/sec: 19.485580670303975
Average IO rate mb/sec: 24.091276168823242
IO rate std deviation: 9.242316274402379
Test exec time sec: 63.103
1-3）、TestDFSIO Read的性能测试
主要目的测试hadoop读文件的速度
TestDFSIO的用法如下：
Usage: TestDFSIO [genericOptions] -read [-random | -backward | -skip [-skipSize Size]] | -write | -append | -clean [-compression codecClassName] [-nrFiles N] [-size Size[B|KB|MB|GB|TB]] [-resFile resultFileName] [-bufferSize Bytes] [-rootDir]
# hadoop jar hadoop-mapreduce-client-jobclient-2.7.3.2.6.0.3-8.jar TestDFSIO -read -nrFiles 10 -size 10
***************
B）、查看运行的情况
# cat TestDFSIO_results.log
----- TestDFSIO ----- : write
Date & time: Tue Nov 21 14:53:44 CST 2017
Number of files: 10
Total MBytes processed: 100.0
Throughput mb/sec: 19.485580670303975
Average IO rate mb/sec: 24.091276168823242
IO rate std deviation: 9.242316274402379
Test exec time sec: 63.103
----- TestDFSIO ----- : read
Date & time: Tue Nov 21 15:04:33 CST 2017
Number of files: 10
Total MBytes processed: 100.0
Throughput mb/sec: 617.283950617284
Average IO rate mb/sec: 688.1331176757812
IO rate std deviation: 182.42935237458195
Test exec time sec: 36.148
1-4）、清空测试数据
# hadoop jar hadoop-mapreduce-client-jobclient-2.7.3.2.6.0.3-8.jar TestDFSIO -clean
17/11/21 15:15:35 INFO fs.TestDFSIO: TestDFSIO.1.8
17/11/21 15:15:35 INFO fs.TestDFSIO: nrFiles = 1
17/11/21 15:15:35 INFO fs.TestDFSIO: nrBytes (MB) = 1.0
17/11/21 15:15:35 INFO fs.TestDFSIO: bufferSize = 1000000
17/11/21 15:15:35 INFO fs.TestDFSIO: baseDir = /benchmarks/TestDFSIO
17/11/21 15:15:35 INFO fs.TestDFSIO: Cleaning up test files
1-5）、查看hadoop文件系统
# hadoop fs -ls /benchmarks/
1-6）、nnbench 测试 [NameNode benchmark (nnbench)]
nnbench用于测试NameNode的负载，它会生成很多与HDFS相关的请求，给NameNode施加较大的压力。
这个测试能在HDFS上创建、读取、重命名和删除文件操作
A）、查看nnbench选项
# hadoop jar hadoop-mapreduce-client-jobclient-2.7.3.2.6.0.3-8.jar nnbench
*********
以下例子使用10个mapper和5个reducer来创建1000个文件
# hadoop jar hadoop-mapreduce-client-jobclient-2.7.3.2.6.0.3-8.jar nnbench -operation create_write -maps 10 -reduces 5 -numberOfFiles 1000 -replicationFactorPerFile 3 -readFileAfterOpen true
***************
C）、查看结果
# cat NNBench_results.log
-------------- NNBench -------------- :
Version: NameNode Benchmark 0.4
Date & time: 2017-11-21 15:21:35,703
Test Operation: create_write
Start time: 2017-11-21 15:21:08,692
Maps to run: 10
Reduces to run: 5
Block Size (bytes): 1
Bytes to write: 0
Bytes per checksum: 1
Number of files: 1000
Replication factor: 3
Successful file operations: 0
# maps that missed the barrier: 5
# exceptions: 5000
TPS: Create/Write/Close: 0
Avg exec time (ms): Create/Write/Close: Infinity
Avg Lat (ms): Create/Write: NaN
Avg Lat (ms): Close: NaN
RAW DATA: AL Total #1: 0
RAW DATA: AL Total #2: 0
RAW DATA: TPS Total (ms): 21176
RAW DATA: Longest Map Time (ms): 4535.0
RAW DATA: Late maps: 5
RAW DATA: # of exceptions: 5000
1-7）、mrbench测试[MapReduce benchmark (mrbench)]
mrbench会多次重复执行一个小作业，用于检查在机群上小作业的运行是否可重复以及运行是否高效。
A）、查看帮助
# hadoop jar hadoop-mapreduce-client-jobclient-2.7.3.2.6.0.3-8.jar mrbench --help
MRBenchmark.0.0.2
Usage: mrbench [-baseDir <base DFS path for output/input, default is /benchmarks/MRBench>] [-jar <local path to job jar file containing Mapper and Reducer implementations, default is current jar file>] [-numRuns <number of times to run the job, default is 1>] [-maps <number of maps for each run, default is 2>] [-reduces <number of reduces for each run, default is 1>] [-inputLines <number of input lines to generate, default is 1>] [-inputType <type of input to generate, one of ascending (default), descending, random>] [-verbose]
B）、下面的例子会运行一个小作业2次
# hadoop jar hadoop-mapreduce-client-jobclient-2.7.3.2.6.0.3-8.jar mrbench -numRuns 2
MRBenchmark.0.0.2
*************
DataLines Maps Reduces AvgTime (milliseconds)
1 2 1 39012