hadoop

hadoop2.0核心
    HDFS        分布式文件系统
    YARN        资源管理调度系统



hadoop特点
    扩容能力
        能可靠的存储和处理千兆字节(PB)数据
    成本低
        可以通过普通机器组成的服务器群来分发处理数据.这些服务器群总计可达数千个节点
    高效率
        通过分发数据,hadoop可以在数据所在的节点上并行的处理他们,这使得处理非常的快速
    可靠性
        hadoop能自动的维护数据的多份副本,并且在任务失败后能自动的重新部署计算任务



hadoop部署方式
    本地模式
    伪分布模式
    集群模式



hadoop目录结构
    sbin        启动服务的命令
    bin         操作hadoop的命令
    etc         配置文件
    share       jar包
    lib
    include
    libexec



hadoop伪分布式搭建
    修改配置文件
        hadoop-env.sh
            修改: export JAVA-HOME=具体地址
        core-site.xml
            在<configuration>标签中添加
                <!-- 指定namenode的地址-->
                <property>
                    <name>fs.defaultFS</name>
                    <value>hdfs://localhost:9000</value>
                </property>
                <!-- 指定hadoop运行时产生文件的存放目录(不是临时文件)-->
                <property>
                    <name>hadoop.tmp.dir</name>
                    <value>/usr/hadoop/tmp</value>
                </property>
        hdfs-site.xml
            在<configuration>标签中添加
                <!-- 指定hdfs副本的数量(文件总共保存1份)-->
                <property>
                    <name>dfs.replication</name>
                    <value>1</value>
                </property>
        mapred-site.xml(从mapred-site.xml.template重命名得来)
            在<configuration>标签中添加
                <!-- 指定mapreduce运行在yarn上-->
                <property>
                    <name>mapreduce.framework.name</name>
                    <value>yarn</value>
                </property>
        yarn-site.xml
            在<configuration>标签中添加
                <!-- 指定yarn的ResourceManager的地址-->
                <property>
                    <name>yarn.resourcemanager.hostname</name>
                    <value>localhost</value>
                </property>
                <!-- reducer获取数据的方式-->
                <property>
                    <name>yarn.nodemanager.aux-services</name>
                    <value>mapreduce_shuffle</value>
                </property>
    将hadoop添加到环境变量
        在/etc/profile文件中添加
            export HADOOP_HOME=...
            export PATH=$PATH:$HADOOP_HOME/bin:$HADOOP_HOME/sbin
        保存并source /etc/profile
    初始化namenode
        hdfs namenode -format
    启动
        运行安装目录下sbin下面的start-all.sh
        查看jps是否启动成功
        可使用浏览器访问hdfs管理界面查看是否启动成功(localhost:50070)
        可使用浏览器访问yarn管理界面查看是否启动成功(localhost:8088)
        或单独启动一个进程: hadoop-daemon.sh start namenode


hdfs命令
    上传文件
        hadoop fs -put /root/words.txt hdfs;//localhost:9000/words.txt
    下载文件
        hadoop fs -get hdfs://localhost:9000/words.txt /home/123.txt
    查看文件
        hadoop fs -ls hdfs://localhost:9000/
    查看文件内容
        hadoop fs -cat hdfs://localhost:9000/words.txt
    删除文件
        hadoop fs -rm -r hdfs://localhost:9000/tmp
    统计(总文件夹数,总文件数,总大小)
        hadoop fs -count hdfs://localhost:9000/
    复制
        hadoop fs -cp hdfs://localhost:9000/123 hdfs://localhost:9000/home/123
    移动
        hadoop fs -mv hdfs://localhost:9000/123 hdfs://localhost:9000/home/123
    显示文件系统使用情况
        hadoop fs -df hdfs://localhost:9000/
    显示指定目录下各个文件的大小
        hadoop fs -du hdfs://localhost:9000/
    注意: 
        如果是本机,则hdfs://localhost:9000/可以省略为/
        可使用通配符,如 hdfs://localhost:9000/12* ,当使用通配符时,需要写全路径,不能简写



HDFS的架构
    主节点(namenode)
        说明
            只有一个
            接收用户操作请求
            维护文件系统的目录结构
            管理文件与block之间关系,block与datanode之间关系
            相关文件存在 tmp/dfs/name 中
        维护的文件
            fsimage     元数据镜像文件,存储某一时段namenode内存中的元数据信息
            edits       操作日志文件
            fstime      保存最近一次checkpoint的时间
        工作特点
            始终在内存中保存metadata,用于处理读请求
            写请求时,首先向edits文件中写日志,再修改内存,并向客户端返回
            会维护一个fsimage文件,是内存中metadata的镜像.fsimage不会随时更新,而是每隔一段时间会通过合并edits文件来更新内容.
            secondary namenode就是用来合并fsimage和edits文件来更新fsimage的
    secondarynamenode
        说明
            在伪分布式中存在,在集群中不存在
            辅助namenode,用来合并fsimage和edits文件来更新fsimage的
            ha的一个解决方案,但不支持热备,配置即可
            默认安装在namenode节点上(不安全)
            相关文件存在 tmp/dfs/namesecondary 中
        工作流程
            通知namenode切换新的edits文件
            获得并合并fsimage和edits文件
            发送给namenode新的fsimage文件
            namenode用新的fsimage文件替换旧的fsimage
        触发条件(checkpoint)
            fs.checkpoint.period,指定两次运行最大时间间隔,默认3600秒
            fs.checkpoint.size,规定edits文件的最大值,默认64mb
    从节点(datanode)
        说明
            有很多个
            存储文件
            文件被分成block存储在磁盘上
            为保证数据安全,文件会有多个副本
            相关文件存在 tmp/dfs/node 中
        特点
            文件块为最基本的存储单位,hdfs默认block大小是128MB
            不同于普通文件系统的是,hdfs中,如果一个文件小于数据块的大小,并不占用整个数据块存储空间
            Replication,多副本,默认是三个
    


java操作hdfs
    上传,下载



rpc
    两个进程之间的方法调用
    和webservice基本相同,不过需要得到接口对象(webservice是需要wsdl文件,然后生成类似于接口的文件)
    底层还是套接字



hdfs底层
    使用rpc调用namenode的方法获得资源的元数据信息(分几块,每块的位置,大小)
    访问datanode获取数据



远程调试hadoop
    jpda
        sun公司提供的远程调试方式
    需要在$HADOOP_HOME/etc/hadoop/hadoop-env.sh文件的最后添加你想debug的进程
        #远程调试namenode
        export HADOOP_NAMENODE_OPTS="-agentlib:jdwp=transport=dt_socket,address=8888,server=y,suspend=y"
        #远程调试datanode
        export HADOOP_DATANODE_OPTS="-agentlib:jdwp=transport=dt_socket,address=9888,server=y,suspend=y"

        #远程调试RM
        export YARN_RESOURCEMANAGER_OPTS="-agentlib:jdwp=transport=dt_socket,address=10888,server=y,suspend=y"

        #远程调试NM
        export YARN_NODEMANAGER_OPTS="-agentlib:jdwp=transport=dt_socket,address=10888,server=y,suspend=y"
    说明
        dt_socket表示使用套接字传输。
        address=8000
        JVM在8000端口上监听请求，这个设定为一个不冲突的端口即可。
        server=y
        y表示启动的JVM是被调试者。如果为n，则表示启动的JVM是调试器。
        suspend=y
        y表示启动的JVM会暂停等待，直到调试器连接上才继续执行。suspend=n，则JVM不会暂停等待。
    然后使用eclipse的远程调试即可



MapReduce
    说明
        是一种分布式计算模型,主要用于搜索领域,解决海量数据的计算问题
        由两个阶段完成,Map和Reduce,用户只需要实现map()和reduce()两个函数即可实现分布式计算
        这两个函数的形参是key,value对,表示函数的输入信息
    MapReduce执行步骤
        总体流程
            rm-resourceManager nm-nodeManager
            1.客户端启动(配置map和reduce的信息)
            2.客户端跟rm进行rpc通信,返回hdfs地址
            3.客户端将jar包存放到hdfs对应地址上
            4.客户端将作业的描述信息提交给rm
            nm从rm获取作业的描述信息(心跳机制)
            nm到hdfs上获取jar包
            nm启动新进程(yarnChild)执行作业(MapReduce),并将结果写回到hdfs中
        map任务处理
            读取输入文件内容，解析成key、value对。对输入文件的每一行，解析成key、value对。每一个键值对调用一次map函数。
            在map函数中写自己的逻辑，对输入的key、value处理，转换成新的key、value输出。
            对输出的key、value进行分区。
            对不同分区的数据，按照key进行排序、分组。相同key的value放到一个集合中。
            (可选)分组后的数据进行归约。
        reduce任务处理
            对多个map任务的输出，按照不同的分区，通过网络copy到不同的reduce节点。
            对多个map任务的输出进行合并、排序。写reduce函数自己的逻辑，对输入的key、value处理，转换成新的key、value输出。
            把reduce的输出保存到文件中。
        例子：实现WordCountApp
    实现过程
        导入jar包
        定义一个类继承Mapper类重写map方法
        定义一个类继承Reduce类重写reduce方法
        定义一个类,存在main方法,构建job对象,设置mapper和reduce,并设置属性,提交
        使用本地模式运行main方法,或使用伪分布式运行(打jar包,用hadoop jar命令)
    例子:单词统计
        map
            public class WCMapper extends Mapper<LongWritable, Text, Text, LongWritable>{
                @Override
                protected void map(LongWritable key, Text value, Context context)
                        throws IOException, InterruptedException {
                    //accept
                    String line = value.toString();
                    //split
                    String[] words = line.split(" ");
                    //loop
                    for(String w : words){
                        //send,发送的数据需要实现序列化接口
                        context.write(new Text(w), new LongWritable(1));
                    }
                }
            }
        reduce
            public class WCReducer extends Reducer<Text, LongWritable, Text, LongWritable>{
                @Override
                protected void reduce(Text key, Iterable<LongWritable> values, Context context)
                        throws IOException, InterruptedException {
                    //define a counter
                    long counter = 0;
                    //loop
                    for(LongWritable l : values){
                        counter += l.get();
                    }
                    //write,发送的数据需要实现序列化接口
                    context.write(key, new LongWritable(counter));
                }
            }
        main方法
            public static void main(String[] args) throws Exception {
                Configuration conf = new Configuration();
                Job job = Job.getInstance(conf);
                
                //notice,main方法所在类
                job.setJarByClass(WordCount.class);
                
                //set mapper`s property
                job.setMapperClass(WCMapper.class);
                job.setMapOutputKeyClass(Text.class);
                job.setMapOutputValueClass(LongWritable.class);
                FileInputFormat.setInputPaths(job, new Path("hdfs://localhost:9000/words.txt"));
                
                //set reducer`s property
                job.setReducerClass(WCReducer.class);
                job.setOutputKeyClass(Text.class);
                job.setOutputValueClass(LongWritable.class);
                FileOutputFormat.setOutputPath(job, new Path("hdfs://localhost:9000//wcout"));
                
                //submit
                job.waitForCompletion(true);
            }



hadoop序列化
    hadoop的序列化没有使用jdk默认的序列化(可自定义需要序列化的属性,jdk是全部序列化)
    hadoop序列化的特点
        紧凑：高效使用存储空间。
        快速：读写数据的额外开销小
        可扩展：可透明地读取老格式的数据
        互操作：支持多语言的交互
    hadoop的序列化类型
        Text --> String
        LongWritable --> Long
    需要序列化的类实现Writable接口,并实现两个方法(类型和顺序需要自己控制)
    示例:
        public void write(DataOutput out) throws IOException {
            out.writeUTF(tel);
            out.writeLong(upPayLoad);
            out.writeLong(downPayLoad);
            out.writeLong(totalPayLoad);
        }
        public void readFields(DataInput in) throws IOException {
            this.tel = in.readUTF();
            this.upPayLoad = in.readLong();
            this.downPayLoad = in.readLong();
            this.totalPayLoad = in.readLong();
        }



分区和排序
    说明
        是在map后,reduce前对mapper结果进行操作
        分区就是为了对mapper结果进行分组,确认将某个结果分配给哪个reduce,每个reduce会产生一个结果文件
        分区的数量一般和reduce的数量相同,reduce的数量可手动设置(如果reduce的数量大于分区的数量,会产生空的结果文件)
        reduce的数量默认为1个,分区的规则默认为平均分配给reduce(应尽量使不同分区的数据量均匀分布,否则造成某个reduce压力过大)
        如统计手机号使用的流量,按移动,联通,电信分区,应有三个分区,三个reduce,产生3个输出文件
    实现分区的步骤
        1.1先分析一下具体的业务逻辑，确定大概有多少个分区
        1.2首先书写一个类，它要继承org.apache.hadoop.mapreduce.Partitioner这个类
        1.3重写public int getPartition这个方法，根据具体逻辑，返回数字(相同数字代表同一个分区)
        1.4在main方法中设置Partioner的类，job.setPartitionerClass(DataPartitioner.class);
        1.5设置Reducer的数量，job.setNumReduceTasks(6);
    实现排序
        需要写两个mapReduce,第二个实现排序,将需要排序的对象作为map输出的key,会自动排序
        需要序列化的类实现WritableComparable接口,重写compareTo方法
        例子:统计盈利最大的商户信息(收入,支出,盈利,需要排序)



Combiners
    说明
        combiners相当于本地reducer
        会先对于map输出的key进行一次合并,减少网络传输
        可适用于累加,求最大值,过滤等情况
        如单词统计中,发送3次{hello=1}合并为1次{hello=3}
    局限性
        combiners使用的还是reducer的代码,且combiners的输出是reducer的输入
        所以combiners只适用于reducer的输入key/value和输出key/value类型一致的时候,且要注意不能影响最终结果
    使用
        job.setCombinerClass(reducer实现类.class);



shuffle
    说明
        reduce获取map指定分区的位置的过程
        粗略理解:map的输出到达reduce的输入的中间过程
    MapReduce流程
        数据切片
        map
            map处理
            map处理后的数据放入内存缓存区,到达80m后分区,并写入硬盘形成一个小文件
            将多个小文件进行归并排序,形成一个大文件(分区并排序好的,一个map形成一个大文件)
        shuffle
            reduce获取map指定分区的位置的过程
            分配任务前rm会先启动一个MrAppMaster进程
            nm向rm领取任务后启动yarnchild执行任务(yarnchild中可能运行map,也可能运行reduce)
            map执行完成后向MrAppMaster进行汇报
            reduce定时向MrAppMaster询问map的执行信息和分区结果
        reduce
            获取各个map对应分区的文件
            合并,排序
            reduce处理并写入hdfs



map的数量
    一个切片对应一个map,调整map的数量即调整切片的大小
    默认实现类: TextInputFormat, 一个块一个切片
    可修改配置修改切片大小
        mapreduce.input.fileinputformat.split.minsize
        mapreduce.input.fileinputformat.split.maxsize
        
    

nameservice
    一个nameservice中有两个namenode,可以有多个nameservice,可实现namenode的水平扩展
    namenode的active和standby状态由zookerper进行切换



zookerper
    说明
        提供通用的分布式锁服务,用以协调分布式应用
        集群由奇数台组成(由策略决定)
        一台Leader(主人),多台Follower(随从)
        可实现数据同步
    在hadoop中的用处
        hadoop2.0,使用Zookeeper的事件处理确保整个集群只有一个活跃的NameNode,存储配置信息等
        HBase,使用Zookeeper的事件处理确保整个集群只有一个HMaster,察觉HRegionServer联机和宕机,存储访问控制列表等
    特性
        简单
        富有表现力
        高可用性
        松耦合交互方式
        是一个资源库
    安装
        下载压缩包解压
    配置文件
        位置:
            conf/zoo_sample.xml
        说明:
            tickTime：CS通信心跳时间
                Zookeeper 服务器之间或客户端与服务器之间维持心跳的时间间隔，也就是每个 tickTime 时间就会发送一个心跳。tickTime以毫秒为单位。
                tickTime=2000  
            initLimit：LF初始通信时限
                集群中的follower服务器(F)与leader服务器(L)之间初始连接时能容忍的最多心跳数（tickTime的数量）。
                initLimit=5  
            syncLimit：LF同步通信时限
                集群中的follower服务器与leader服务器之间请求和应答之间能容忍的最多心跳数（tickTime的数量）。
                syncLimit=2  
            dataDir：数据文件目录
                Zookeeper保存数据的目录，默认情况下，Zookeeper将写数据的日志文件也保存在这个目录里。
                dataDir=/home/michael/opt/zookeeper/data  
            clientPort：客户端连接端口
                客户端连接 Zookeeper 服务器的端口，Zookeeper 会监听这个端口，接受客户端的访问请求。
                clientPort=2181 
            服务器名称与地址：集群信息（服务器编号，服务器地址，LF通信端口，选举端口）
                这个配置项的书写格式比较特殊，规则如下：
                server.N=YYY:A:B 
                server.1=itcast05:2888:3888
                server.2=itcast06:2888:3888
                server.3=itcast07:2888:3888
    单机环境搭建
        将conf/zoo_sample.xml重命名为zoo.xml
        启动服务端: bin/zkServer.sh start
        启动客户端: bin/zKCli.sh
        在客户端sell状态下可输入命令 help,ls,create,rmr
    集群环境搭建
        配置第一台机器
            安装zookerper
            将conf/zoo_sample.xml重命名为zoo.xml
            在配置文件中添加集群信息
                    server.1=itcast05:2888:3888
                    server.2=itcast06:2888:3888
                    server.3=itcast07:2888:3888
            在配置文件中将dataDir配置一个目录,并在配置的目录下创建一个文件:myid,内容为当前机器的id(配置文件的server.N的N)
        将zookerper文件夹复制到另外两台机器,并分别修改对应的myid文件内容
        启动三台机器上的zkServer.sh
        启动的三台机器第二个启动的机器为leader(刚超过半数的那一台)
        宕机的机器不能超过总数的一半,否则无法正常工作(无法选举leader)
        可启动客户端演示多服务端的数据同步功能



hadoop分布式搭建(2.4.1)
    集群规划：
        主机名      IP              安装的软件                  运行的进程
        itcast01    192.168.1.201   jdk、hadoop                 NameNode、DFSZKFailoverController
        itcast02    192.168.1.202   jdk、hadoop                 NameNode、DFSZKFailoverController
        itcast03    192.168.1.203   jdk、hadoop                 ResourceManager
        itcast04    192.168.1.204   jdk、hadoop                 ResourceManager
        itcast05    192.168.1.205   jdk、hadoop、zookeeper      DataNode、NodeManager、JournalNode、QuorumPeerMain
        itcast06    192.168.1.206   jdk、hadoop、zookeeper      DataNode、NodeManager、JournalNode、QuorumPeerMain
        itcast07    192.168.1.207   jdk、hadoop、zookeeper      DataNode、NodeManager、JournalNode、QuorumPeerMain
        
    说明：
        1.在hadoop2.0中通常由两个NameNode组成，一个处于active状态，另一个处于standby状态。Active NameNode对外提供服务，而Standby NameNode则不对外提供服务，仅同步active namenode的状态，以便能够在它失败时快速进行切换。
        hadoop2.0官方提供了两种HDFS HA的解决方案，一种是NFS，另一种是QJM。这里我们使用简单的QJM。在该方案中，主备NameNode之间通过一组JournalNode同步元数据信息，一条数据只要成功写入多数JournalNode即认为写入成功。通常配置奇数个JournalNode
        这里还配置了一个zookeeper集群，用于ZKFC（DFSZKFailoverController）故障转移，当Active NameNode挂掉了，会自动切换Standby NameNode为standby状态
        2.hadoop-2.2.0中依然存在一个问题，就是ResourceManager只有一个，存在单点故障，hadoop-2.4.1解决了这个问题，有两个ResourceManager，一个是Active，一个是Standby，状态由zookeeper进行协调
    1.安装配置zooekeeper集群（在itcast05上）
        1.1解压
            tar -zxvf zookeeper-3.4.5.tar.gz -C /itcast/
        1.2修改配置
            cd /itcast/zookeeper-3.4.5/conf/
            cp zoo_sample.cfg zoo.cfg
            vim zoo.cfg
            修改：dataDir=/itcast/zookeeper-3.4.5/tmp
            在最后添加：
            server.1=itcast05:2888:3888
            server.2=itcast06:2888:3888
            server.3=itcast07:2888:3888
            保存退出
            然后创建一个tmp文件夹
            mkdir /itcast/zookeeper-3.4.5/tmp
            再创建一个空文件
            touch /itcast/zookeeper-3.4.5/tmp/myid
            最后向该文件写入ID
            echo 1 > /itcast/zookeeper-3.4.5/tmp/myid
        1.3将配置好的zookeeper拷贝到其他节点(首先分别在itcast06、itcast07根目录下创建一个itcast目录：mkdir /itcast)
            scp -r /itcast/zookeeper-3.4.5/ itcast06:/itcast/
            scp -r /itcast/zookeeper-3.4.5/ itcast07:/itcast/
            
            注意：修改itcast06、itcast07对应/itcast/zookeeper-3.4.5/tmp/myid内容
            itcast06：
                echo 2 > /itcast/zookeeper-3.4.5/tmp/myid
            itcast07：
                echo 3 > /itcast/zookeeper-3.4.5/tmp/myid
    2.安装配置hadoop集群（在itcast01上操作）
        2.1解压
            tar -zxvf hadoop-2.4.1.tar.gz -C /itcast/
        2.2配置HDFS（hadoop2.0所有的配置文件都在$HADOOP_HOME/etc/hadoop目录下）
            #将hadoop添加到环境变量中
            vim /etc/profile
            export JAVA_HOME=/usr/java/jdk1.7.0_55
            export HADOOP_HOME=/itcast/hadoop-2.4.1
            export PATH=$PATH:$JAVA_HOME/bin:$HADOOP_HOME/bin
            
            #hadoop2.0的配置文件全部在$HADOOP_HOME/etc/hadoop下
            cd /itcast/hadoop-2.4.1/etc/hadoop
            2.2.1修改hadoo-env.sh
                export JAVA_HOME=/usr/java/jdk1.7.0_55
            2.2.2修改core-site.xml
                <configuration>
                    <!-- 指定hdfs的nameservice为ns1 -->
                    <property>
                        <name>fs.defaultFS</name>
                        <value>hdfs://ns1</value>
                    </property>
                    <!-- 指定hadoop临时目录 -->
                    <property>
                        <name>hadoop.tmp.dir</name>
                        <value>/itcast/hadoop-2.4.1/tmp</value>
                    </property>
                    <!-- 指定zookeeper地址 -->
                    <property>
                        <name>ha.zookeeper.quorum</name>
                        <value>itcast05:2181,itcast06:2181,itcast07:2181</value>
                    </property>
                </configuration>
            2.2.3修改hdfs-site.xml
                <configuration>
                    <!--指定hdfs的nameservice为ns1，需要和core-site.xml中的保持一致 -->
                    <property>
                        <name>dfs.nameservices</name>
                        <value>ns1</value>
                    </property>
                    <!-- ns1下面有两个NameNode，分别是nn1，nn2 -->
                    <property>
                        <name>dfs.ha.namenodes.ns1</name>
                        <value>nn1,nn2</value>
                    </property>
                    <!-- nn1的RPC通信地址 -->
                    <property>
                        <name>dfs.namenode.rpc-address.ns1.nn1</name>
                        <value>itcast01:9000</value>
                    </property>
                    <!-- nn1的http通信地址 -->
                    <property>
                        <name>dfs.namenode.http-address.ns1.nn1</name>
                        <value>itcast01:50070</value>
                    </property>
                    <!-- nn2的RPC通信地址 -->
                    <property>
                        <name>dfs.namenode.rpc-address.ns1.nn2</name>
                        <value>itcast02:9000</value>
                    </property>
                    <!-- nn2的http通信地址 -->
                    <property>
                        <name>dfs.namenode.http-address.ns1.nn2</name>
                        <value>itcast02:50070</value>
                    </property>
                    <!-- 指定NameNode的元数据在JournalNode上的存放位置 -->
                    <property>
                        <name>dfs.namenode.shared.edits.dir</name>
                        <value>qjournal://itcast05:8485;itcast06:8485;itcast07:8485/ns1</value>
                    </property>
                    <!-- 指定JournalNode在本地磁盘存放数据的位置 -->
                    <property>
                        <name>dfs.journalnode.edits.dir</name>
                        <value>/itcast/hadoop-2.4.1/journal</value>
                    </property>
                    <!-- 开启NameNode失败自动切换 -->
                    <property>
                        <name>dfs.ha.automatic-failover.enabled</name>
                        <value>true</value>
                    </property>
                    <!-- 配置失败自动切换实现方式 -->
                    <property>
                        <name>dfs.client.failover.proxy.provider.ns1</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>
            2.2.4修改mapred-site.xml
                <configuration>
                    <!-- 指定mr框架为yarn方式 -->
                    <property>
                        <name>mapreduce.framework.name</name>
                        <value>yarn</value>
                    </property>
                </configuration>    
            2.2.5修改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>itcast03</value>
                        </property>
                        <property>
                           <name>yarn.resourcemanager.hostname.rm2</name>
                           <value>itcast04</value>
                        </property>
                        <!-- 指定zk集群地址 -->
                        <property>
                           <name>yarn.resourcemanager.zk-address</name>
                           <value>itcast05:2181,itcast06:2181,itcast07:2181</value>
                        </property>
                </configuration>
            2.2.6修改slaves(slaves是指定子节点的位置，因为要在itcast01上启动HDFS、在itcast03启动yarn，所以itcast01上的slaves文件指定的是datanode的位置，itcast03上的slaves文件指定的是nodemanager的位置)
                itcast05
                itcast06
                itcast07
            2.2.7配置免密码登陆
                #首先要配置itcast01到itcast02、itcast03、itcast04、itcast05、itcast06、itcast07的免密码登陆
                #在itcast01上生产一对钥匙
                ssh-keygen -t rsa
                #将公钥拷贝到其他节点，包括自己
                ssh-coyp-id itcast01
                ssh-coyp-id itcast02
                ssh-coyp-id itcast03
                ssh-coyp-id itcast04
                ssh-coyp-id itcast05
                ssh-coyp-id itcast06
                ssh-coyp-id itcast07
                #配置itcast03到itcast04、itcast05、itcast06、itcast07的免密码登陆
                #在itcast03上生产一对钥匙
                ssh-keygen -t rsa
                #将公钥拷贝到其他节点
                ssh-coyp-id itcast04
                ssh-coyp-id itcast05
                ssh-coyp-id itcast06
                ssh-coyp-id itcast07
                #注意：两个namenode之间要配置ssh免密码登陆，别忘了配置itcast02到itcast01的免登陆
                在itcast02上生产一对钥匙
                ssh-keygen -t rsa
                ssh-coyp-id -i itcast01             
        2.4将配置好的hadoop拷贝到其他节点
            scp -r /itcast/ itcast02:/
            scp -r /itcast/ itcast03:/
            scp -r /itcast/hadoop-2.4.1/ root@itcast04:/itcast/
            scp -r /itcast/hadoop-2.4.1/ root@itcast05:/itcast/
            scp -r /itcast/hadoop-2.4.1/ root@itcast06:/itcast/
            scp -r /itcast/hadoop-2.4.1/ root@itcast07:/itcast/
        ###注意：严格按照下面的步骤
        2.5启动zookeeper集群（分别在itcast05、itcast06、tcast07上启动zk）
            cd /itcast/zookeeper-3.4.5/bin/
            ./zkServer.sh start
            #查看状态：一个leader，两个follower
            ./zkServer.sh status
        2.6启动journalnode（分别在在itcast05、itcast06、tcast07上执行）
            cd /itcast/hadoop-2.4.1
            sbin/hadoop-daemon.sh start journalnode
            #运行jps命令检验，itcast05、itcast06、itcast07上多了JournalNode进程
        2.7格式化HDFS
            #在itcast01上执行命令:
            hdfs namenode -format
            #格式化后会在根据core-site.xml中的hadoop.tmp.dir配置生成个文件，这里我配置的是/itcast/hadoop-2.4.1/tmp，然后将/itcast/hadoop-2.4.1/tmp拷贝到itcast02的/itcast/hadoop-2.4.1/下。
            scp -r tmp/ itcast02:/itcast/hadoop-2.4.1/
        2.8格式化ZK(在itcast01上执行即可)
            hdfs zkfc -formatZK
        2.9启动HDFS(在itcast01上执行)
            sbin/start-dfs.sh
        2.10启动YARN(#####注意#####：是在itcast03上执行start-yarn.sh，把namenode和resourcemanager分开是因为性能问题，因为他们都要占用大量资源，所以把他们分开了，他们分开了就要分别在不同的机器上启动)
            sbin/start-yarn.sh
    到此，hadoop-2.4.1配置完毕，可以统计浏览器访问:
        http://192.168.1.201:50070
        NameNode 'itcast01:9000' (active)
        http://192.168.1.202:50070
        NameNode 'itcast02:9000' (standby)
    验证HDFS HA
        首先向hdfs上传一个文件
        hadoop fs -put /etc/profile /profile
        hadoop fs -ls /
        然后再kill掉active的NameNode
        kill -9 <pid of NN>
        通过浏览器访问：http://192.168.1.202:50070
        NameNode 'itcast02:9000' (active)
        这个时候itcast02上的NameNode变成了active
        在执行命令：
        hadoop fs -ls /
        -rw-r--r--   3 root supergroup       1926 2014-02-06 15:36 /profile
        刚才上传的文件依然存在！！！
        手动启动那个挂掉的NameNode
        sbin/hadoop-daemon.sh start namenode
        通过浏览器访问：http://192.168.1.201:50070
        NameNode 'itcast01:9000' (standby)
    验证YARN：
        运行一下hadoop提供的demo中的WordCount程序：
        hadoop jar share/hadoop/mapreduce/hadoop-mapreduce-examples-2.4.1.jar wordcount /profile /out
    OK，大功告成！！！