Hadoop实践笔记

#########ubuntu18.04 lts############
#########hadoop3.2.0################
#########jdk1.8.0_11################
客户机桌面模式和文本模式切换

1.ctrl+alt+f6   //文本模式
2.ctrl+alt+f7   //桌面模式

开机进入文本模式

1.修改/etc/default/grub文件
    [/etc/default/grub]
    ...
    #图形模式
    GRUB_CMDLINE_LINUX_DEFAULT="quiet"
    #文本模式
    GRUB_CMDLINE_LINUX_DEFAULT="text"
    ...
    #修改文本模式的分辨率（一般不推荐修改）
    GRUB_GFXMODE=640x480
    ...
2.运行update-grub更新启动项
    $>sudo update-grub文件
3.手动启动
    $>startx

客户机环境处理

1.ip        :100-104
2.主机名       s100 s101 s102 s103 s104
3.用户 fgq 密码 123456

修改主机名

步骤：1.终端中hostnamectl查看主机名
	  2.修改主机名为s100 sudo hostnamectl set-hostname s100
	  3.vim或者nano编辑/etc/hosts文件将旧主机名改为新的主机名  
*使用nano编辑文件后 保存ctrl+o 退出ctrl+x

修改dns解析

[/etc/hosts]
120.0.0.1   localhost
192.168.146.100 s100  
192.168.146.101 s101
192.168.146.102 s102
192.168.146.103 s103
192.168.146.104 s104

Hadoop

1.Apache、google等技术标准公司
2.可靠、可伸缩、分布式计算的开源框架
3.去IOE（去昂贵存储设备）
    IBM+Oracle+EMC(网络存储设备)
4.MapReduce
    MR       映射 编程模型
    Reduce   化简

Hadoop的安装

1.安装jdk
    a.复制jdk-xx.tar.gz 到 ~/Downloads
    b.tar开
        tar -xzvf file.tar.gz //解压tar.gz
            -c：C reate存档。
            -z：压缩zip存档。
            -v：在终端显示进度的同时创建归档，也被称为“V erbose”模式。 在V总是在这些命令可选的，但它是有帮助的。
            -f：允许你指定存档的Filename。
    c.移动到/soft(自己创建一个soft文件夹 权限给到普通用户，尽量避开root用户下安装软件) cp -r hadoop-3.2.0 ~/soft
        [创建符号链接] 在安装目录下创建符号链接 目的是为了在配置系统环境变量时 好写
        $>ln -s /soft/jdk-xx jdk  （删除符号rm -rf symbolic_name）
    d.配置环境变量
        第一种方式[/etc/environment]
                    JAVA_HOME=/soft/jdk
                    PATH="...:/soft/jdk/bin"
        第二种方式[~/.bashrc]
            (1)sudo gedit ~/.bashrc
            （2）在文件末尾添加以下几行代码
                # added by java jdk1.8.0
                export JAVA_HOME=/home/fgq/jdk
                export JRE_HOME=${JAVA_HOME}/jre
                export CLASSPATH=.:${JAVA_HOME}/lib:${JRE_HOME}/lib
                # added by hadoop hadoop-3.2.0
                export HADOOP_HOME=/home/fgq/hadoop
                export PATH=${JAVA_HOME}/bin:${HADOOP_HOME}/bin:${HADOOP_HOME}/sbin:$PATH
            然后保存文件
            （3）使配置文件生效
                source ~/.bashrc    //当前shell生效 要想全部shell有效得重启机器
            （4）验证jdk hadoop是否安装成功
                java -version
                javac -version
                hadoop version
    e.检查安装是否成功
        $>cd ~
        $>java -version
    *如果不成功 则重新启动
2.安装Hadoop  参看jdk的安装配置
    a.复制并tar开hadoop.tar.gz
    b.
    c.
    d.
    e.
    r.验证是否安装成功
        $>Hadoop version

大数据 4V 解决大数据的存储和计算 最广泛的应用就是做到了精准营销 推荐系统

1.volumn    量大
2.variaty   样式多
3.velocity  速度快
4.valueless 价值密度低

学习推荐

[o REILLY]出版社出版的一系列书籍
    Hadoop....
    Learning.Spark....
    看英文版的内容
    1.O'REILLY 出版社的大数据书籍
    2.看技术书籍最好还是看英文版 结合 百度翻译(google翻译)
    《hadoop 权威指南3》 《hadoop架构分析》
官方api apache官网

hadoop 包含四个模块=>hadoop架构分析 hdfs架构分析 yarn架构分析 mapreduce计算分析

1.Hadoop Common
    支持其他模块的工具模块
2.Hadoop Distributed File System（HDFS）
    分布式文件系统，提供了对应程序数据的高吞吐量访问
    [包含三个进程]
    NameNode            //名称节点  --NN
    DataNode            //数据节点  --DN
    SecondaryNameNode   //辅助名称节点 --2NN
3.Hadoop YARN
    作业调度与集群资源管理的框架
    [包含两个进程]
    ResourceMananger        //资源管理器--RM
    NodeManager             //节点管理器--NM
4.Hadoop MapReduce
    基于YARN系统的对大数据集进行并行处理技术

配置Hadoop（集群配置模式有三种） =>独立模式 伪分布式 完全分布式 ssh原理

1.Standalone/local
    独立/本地模式，使用的本地文件系统
    nothing!!!什么都不需要干，不需要启动单独的hadoop进程，使用的就是本地系统，无守护进程在运行
    查看文件系统的方式：
        $hadoop fs -ls
    没有启动任何java进程
    用于测试和开发环境
2.Pseudodistributed mode
    伪分布式
    [配置过程]
    a.进入${HADOOP_HOME}/etc/hadoop目录
    b.编辑core-site.xml
        <?xml version="1.0"?>
        <configuration>
            <property>
                <name>fs.defaultFS</name>
                <value>hdfs://localhost/</value>
            </property>
        </configuration>
    c.编辑hdfs-site.xml
        <?xml version="1.0"?>
        <configuration>
            <property>
                <name>dfs.replication</name>
                <value>1</value>
            </property>
        </configuration>
    d.编辑mapred-site.xml
        注意:cp mapred-site.xml.template mapred-site.xml(如果没有mapred-site.xml的话才有此步骤)
        <?xml version="1.0"?>
        <configuration>
            <property>
                <name>mapreduce.framework.name</name>
                <value>yarn</value>
            </property>
        </configuration>
    e.编辑yarn-site.xml
        <?xml version="1.0"?>
        <configuration>
            <property>
                <name>yarn.resourcemanager.hostname</name>
                <value>localhost</value>
            </property>
            <property>
                <name>yarn.nodemanager.aux-services</name>
                <value>mapreduce_shuffle</value>
            </property>
        </configuration>
    f.配置SSH(Secure Shell)
        安全登录
        1.安装ssh
            $>sudo apt install ssh  
            （查看是否启动了sshd服务 $>ps -Af|grep ssh）
        2.生成秘钥对
            $>ssh-keygen -t rsa -P '' -f ~/.ssh/id_rsa
            $>cd ~/.ssh         //查看生成的公钥私钥
        3.导入公钥数据到授权文件(库)中
            $>cat ~/.ssh/id_rsa.pub >> ~/.ssh/authorized_keys
        4.登录到localhost
            $>ssh localhost
            $>...yes    //第一次需要询问
            $>exit
            $>ssh localhost //第二次不需要密码
        5.格式化hdfs文件系统
            $>hadoop namenode -format   //只一次需要格式化，不需要每次都格式化
        6.启动所有进程（在hadoop/sbin目录中有这个start-all.sh文件）
            $>start-all.sh
            *也许会报错 Hadoop初次启动时 进程启动失败 提示JAVA_HOME is not set and could not be found
                解决办法: 
                    在Hadoop 安装目录修改配置文件 "/usr/local/hadoop/etc/hadoop" 
                    修改里面的hadoop-env.sh
                    sudo vim hadoop-env.sh
                    找到 "export JAVA_HOME=${JAVA_HOME}" 
                    修改为Java安装路径的具体地址 
                    如我的 "export JAVA_HOME=/usr/lib/jvm/default-java" （如果你的java路径不是这里  则修改为你的Java安装目录 ）
                    再次启动Hadoop 即可成功

        7.查看有关java的进程（查看有关xxx的所有进程 ps -Af|grep xxx） 成功的话会有五个进程 RM NM NN DN 2NN
            $>jps
        8.查看文件系统
            $>hadoop fs -ls
        9.创建文件系统
            $>hadoop fs -mkdir -p /user/fgq/data
            $>hadoop fs -ls -R /        //递归查看文件系统目录
            $>hadoop fs -put  <local file>  <hdfs file>  //hadoop放入文件命令
3.Fully distributed mode
    完全分布式
    1.准备五台机器
        a.分别实现ssh安装
        b.mkdir .ssh  (查看当前目录下文件列表 $>ls -al  //查看跟目录下文件列表$>ls -al /)
        a.以及实现s100 免密码登录其他四台机器(建议普通用户和root用户都做ssh免密码登录)
          s100作为NN节点 s101:DN-1 s102:DN-2 s103:DN-3 s104:2NN
          只需s100上生成公钥私钥即可，其他接收公钥切授权即可
            1.s100上 生成秘钥对 $>ssh-keygen -t rsa -P '' -f ~/.ssh/id_rsa
            2.s100上 拷贝公钥给其他四台机器并授权
                2.1 fgq@s100:~/.ssh$>scp -r authorized_keys fgq@s101:~/.ssh/  //普通用户
                2.2 fgq@s100:~$>su root                             //切换用户root
                    root@s100:~$>scp authorized_keys root@s101:/root/.ssh
                （或在其他机器上 复制s100的公钥到本机器的.ssh目录中
                    fgq@s101:~$>scp fgq@s100:~/.ssh/authorized_keys ~/.ssh/   普通用户
                    root@s101:~$>scp root@s100:/root/.ssh/authorized_keys /root/.ssh/
                ）
				**ubuntu18.04 root 用户做ssh配置时候要注意
				    1. 查看ssh服务器是否安装并启动
					  #sudo ps -e | grep ssh
					1. 安装ssh服务器
					#sudo apt-get install openssh-server
					2. 配置sshd文件
					#sudo vi /etc/ssh/sshd_config
					 	PermitRootLogin yes （默认为#PermitRootLogin prohibit-password）
					 或
					 	UsePrivilegeSeparation no
						PermitRootLogin yes
						PasswordAuthentication yes
					3. 重启服务器 service ssh restart
    2.搭建好s100这一台机器的jdk hadoop以及环境变量配置
    3.在s100上ssh免密码登录s101创建同样的软件安装文件夹目录 
        $>sudo mkdir soft   //查看文件路径 whereis 文件(夹)名
        $>sudo chown -R fgq:fgq soft    //由root拥有者改变文件夹的拥有者为fgq  （递归删除文件夹 sudo rm -rf soft）
    4.fgq@s100:~$>rsync -rvl soft/* fgq@s101:soft  //复制jdk hadoop等软件 (-rvl r递归拷贝 v可以看到复制过程 l 就是支持符号连接拷贝)
    5.fgq@s100:~$>rsync .bashrc fgq@s101:~  //复制.bashrc等环境配置文件  如果拷贝root权限的文件(/etc/environment)则是rsync /etc/environment root@s101:/etc/
    6.fgq@s101:~$>source ~/.bashrc  //配置立即生效
    7.其他几台机器重复2-6步
        (以上步骤在机器少时可以使用 但是机器多时显得不够自动化 所以 有了自定义脚本 参看 #自定义脚本xsync 设置)
    #开始借助 xcall xsync 脚本文件进行hadoop集群搭建
    9.配置文件  NN和RM 2NN节点在同一个节点s100上 s101:DN NM  s102:DN NM s103:DN NM 
        在伪分布式基础上进行修改
            a.[/soft/hadoop/etc/hadoop/core-site.xml]  
                fs.defaultFS=hdfs://s100/   //也可以写端口默认8020  NM节点机器配置
            b.[/soft/hadoop/etc/hadoop/hdfs-site.xml]  //数据副本数量配置
                replication=3
            c.[/soft/hadoop/etc/hadoop/yarn-site.xml]  //资源管理RM节点机器配置
                yarn.resourcemanager.hostname=s100
            d.[/soft/hadoop/etc/hadoop/workers] //hadoop3.x 版本之前是  /soft/hadoop/etc/hadoop/slaves 数据节点(数据副本 3台副本DN节点机器)
                s101
                s102
                s103
    10.在集群上分发以上三个文件
        fgq@s100:~$> cd soft/hadoop/etc/hadoop
        fgq@s100:~soft/hadoop/etc/hadoop$> xsync core-site.xml
        fgq@s100:~soft/hadoop/etc/hadoop$> xsync hdfs-site.xml
        fgq@s100:~soft/hadoop/etc/hadoop$> xsync yarn-site.xml
        fgq@s100:~soft/hadoop/etc/hadoop$> xsync workers
    11.停止一切hadoop服务
        fgq@s100:~$>stop-all.sh
    12.重新格式化系统
        fgq@s100:~$>hadoop namenode -format
    13.启动所有进程
        fgq@s100:~$>start-all.sh
    14.借助自定义的脚本xcall再次查对进程
        fgq@s100:~$>xcall jps
    15.webui 查看hadoop集群服务  localhost:9870（s100:9870）
    16.可以创建文件系统 放置文件
        fgq@s100:~$>hadoop fs -mkdir -p /user/fgq/data //创建文件库
        fgq@s100:~$>echo helloWord > hello.txt        //创建一个文件
        fgq@s100:~$>hadoop fs -put hello.txt /user/fgq/data    //放置文件到hadoop文件库中
    17.webui 查看hadoop集群服务的文件库(Utilites)

自定义脚本xsync 在集群上实现自动化分发内容(文件)到其他机器

用到的相关命令
    fgq@s100:~$> cd /usr/local/bin/     //制造商的命令执行(文件存放)目录 放置自己自定义的脚本命令文件
    fgq@s100:~/usr/local/bin$> touch xsync   //新建文件xsync
    fgq@s100:~/usr/local/bin$> sudo nano xsync       //编辑文件xsync
    fgq@s100:~/usr/local/bin$> chmod a+x xsync  //修改权限 使得所以人都可以执行
    fgq@s100:~/usr/local/bin$> echo hello world > hello.txt  //写入或输出hello world 到hello.txt(如果没有hello.txt 会自动创建)
    fgq@s100:~/usr/local/bin$> cat hello.txt  //查看文件
    dirname hello.txt  //取得文件或文件夹上级目录
    basename /soft/jdk  //取得文件名jdk
    echo  xxx           //输出后面带的命令执行结果
#实例 编写xsync文件内容如下 实现在s100上循环复制文件到所有节点的相同目录下：
    [/usr/local/bin/xsync]
    #!/bin/bash 
    pcount=$#;                  //参数个数
    if (( pcount<1 )) ; then
        echo no args;
        exit ;
    fi 

    #
    p1=$1       //获取第一个参数
    fname=`basename $p1`

    #获得上级目录的绝对路径
    pdir=`cd -P $(dirname $p1) ; pwd`
    echo $pdir

    cuser=`whoami`      //获取当前用户

    #循环
    for (( host=101 ; host<105 ; host=host+1 )) ; do 
        echo ------------s$host--------------
        rsync -rvl $pdir/$fname $cuser@s$host:$pdir
    done 
#执行实例
    xsync hello.txt   //xsync是上文中自定义的可执行文件 hello.txt待分发文件

自定义脚本xcall(在/usr/local/bin/下创建xcall文件 参看 #自定义脚本xsync) 实现在所有主机上执行相同的命令 基于ssh

实例
    #!/bin/bash 
    pcount=$#;
    if (( pcount<1 )) ; then
        echo no args;
        exit ;
    fi

    #循环
    for (( host=101 ; host<105 ; host=host+1 )) ; do 
        echo ------------s$host--------------
        ssh s$host $@       //$@ 表示在本机登录进行操作(例如 fgq@s100:~$>ssh @s101 ls -al)
    done 
执行
    xcall rm file  // xcall为/usr/local/bin/下创建的xcall可执行脚本文件 

scp

安全远程文件复制程序，基于ssh
符号连接编程会转变成文件(比如上面的jdk、hadoop符号连接)

rsync 解决scp符号连接复制后编程文件的问题

远程同步工具，主要用于备份和镜像
支持连接、设备等等
速度快、避免复制相同文件的数据内容

nc在两台client之间传递文件

s100机器ssh免密码登录s101机器的做法
    1.s100机器上生成公钥私钥，s101机器生成公钥私钥 （ssh-keygen -t rsa -P '' -f ~/.ssh/id_rsa）
    2.将s100的公钥发给s101，然后s101上加上授权key就可以
        采用nc的方式（nc 俗称瑞士军刀）
            a.在s101机器上进到~/.ssh目录
                $>nc -l 8888 > id_rsa.pub.s100
            b.在s100机器上进到~/.ssh目录
                $>nc s101 8888 < id_rsa.pub
            c.在s101机器上进到~/.ssh目录
                $>ls    //可以看到s100的公钥id_rsa.pub.s100已经传递给了s101
            d.在s101机器上进到~/.ssh目录
                进行授权key操作
                    $>cat id_rsa.pub.s100 >> authorized_keys
                    $>cat authorized_keys       //可以看到s100的授权信息放到了里面

hadoop进程处理

1.查看hadoop进程个数（5）
    $>jps
        NN
        DN
        2NN
        RM
        NM
2.如果进程数不对，杀死所有进程
    $>stop-all.sh
3.重新格式化系统
    $>hadoop namenode -format
4.启动所有进程
    $>start-all.sh
5.jps 再次查对进程

使用webui访问hadoop3.2.0 hdfs

查看网络端口
    $>netstat -ano | more

1.name node
    http://localhost:9870
2.data node
    http://localhost:9866
3.2nn
    http://localhost:9868

4.All Applications
    mapreduce job 
    http://s100:8088

使用webui访问hadoop2.7.0 hdfs

1.name node
    http://localhost:50070
2....
3....

hadoop类库和配置文件抽取-2nn的配置

1.解压缩hadoop-3.2.0.tar.gz到一个目录下(在windows系统下)
2.整理jar包
    2.1 解压后的hadoop-3.2.0文件夹下创建_lib、_source、_test、_config文件夹
    2.2 hadoop-3.2.0中share文件夹下进行整体搜索jar（然后进行ctrl+a ctrl+c）复制到_lib目录下
    2.3 在_lib下进行source.jar搜索（然后进行ctrl+a ctrl+x）将hadoop源码和测试源码的jar包放到_source
    2.4 在_lib下进行test.jar搜索（然后进行ctrl+a ctrl+x）将测试jar包放到_test
3.抽取所有配置文件（在_lib目录下找）放到_config目录中
    [core-default.xml]
    hadoop-common-3.2.0.jar/core-default.xml
    [hdfs-default.xml]
    hadoop-hdfs-3.2.0.jar/hdfs-default.xml
    [yarn-default.xml]
    hadoop-yarn-3.2.0.jar/yarn-default.xml
    [mapred-default.xml]
    hadoop-mapreduce-client-core-3.2.0.jar/mapred-default.xml

4.配置2nn
    4.1 在_config目录中使用Editplus搜索功能找寻<name>dfs.namemode.secondary.http-address</name>
    4.2 hdfs-default.xml文件中好到2nn的配置相关内容 
        <property>
            <name>dfs.namemode.secondary.http-address</name>
            <value>0.0.0.0:9868</value>
        </property>
        进行2nn的配置修改
        <property>
            <name>dfs.namemode.secondary.http-address</name>
            <value>s104:9868</value>
        </property>
        将修改的property配置内容在s100上的hadoop的hdfs-site.xml进行粘贴
    4.3 xsync 分发hdfs-site.xml
        fgq@s100:~soft/hadoop/etc/hadoop$> xsync hdfs-site.xml
    4.5 停止hadoop集群 
        $>stop-all.sh
    4.6 重新格式化hadoop集群配置 
        $>hadoop namenode -format
    4.7 启动所有进程
        $>start-all.sh    
5.namenode的本地目录配置成多个，则每个目录存放内容相同
    在hdfs-default.xml中找dfs.namemode.name.dir节点
    复制到hdfs-site.xml文件中
    [hdfs-site.xml]    
    dfs.namemode.name.dir=file:///${hadoop.tmp.dir}/dfs/name1,file:///${hadoop.tmp.dir}/dfs/name2
6. datanode的本地目录配置成多个，不是副本，数据只会放到一个文件夹中，因为本身数据节点已经配置三台机器s101,s102,s103有备份意义了
    在hdfs-default.xml中找dfs.datanode.data.dir节点
    复制到hdfs-site.xml文件中
    [hdfs-site.xml]    
    dfs.datanode.data.dir=file:///${hadoop.tmp.dir}/dfs/data1,file:///${hadoop.tmp.dir}/dfs/data2
7. 然后建立逻辑文件系统的文件库(区别与hadoop临时目录存放的是namenode信息，以及区别与datanode目录配置存放的是实际的上传的文件) put上去一个文件
    fgq@s100:~$ hdfs dfs -ls -R /
    fgq@s100:~$ hadoop fs -mkdir -p /home/fgq/logicdata
    fgq@s100:~$ hdfs dfs -put hello.txt /home/fgq/logicdata
    fgq@s100:~$ hdfs dfs -ls -R /
    drwxr-xr-x   - fgq supergroup          0 2019-09-16 20:33 /home
    drwxr-xr-x   - fgq supergroup          0 2019-09-16 20:33 /home/fgq
    drwxr-xr-x   - fgq supergroup          0 2019-09-16 20:34 /home/fgq/logicdata
    -rw-r--r--   2 fgq supergroup         10 2019-09-16 20:34 /home/fgq/logicdata/hello.txt
    fgq@s100:~$ 
8. 进行webui查看测试

问题 如果启动后 xcall 查看有失败情况 则进行一下排除
    hadoop文件在本地有一个默认存放目录 
        $>cd /temp/ 
        $>ls
    将里面的hadoop-ubuntu、hadoop-ubuntu-datanode.pid(伪分布式时生成的文件)删除
        /temp$>xcall rm -rf /temp/hadoop-ubuntu
        /temp$>xcall rm -rf /temp/hadoop-ubuntu-datanode.pid
    然后再次重启hadoop集群

查看本地文件的内容 以备修改本地hadoop本地临时目录

1.s100:/tmp/hadoop-fgq/dfs/name/current/VERSION
    #Sun Sep 15 22:29:33 PDT 2019
    namespaceID=1574219430
    clusterID=CID-3f4ec779-7811-4251-a65f-bb3d520f0b86
    cTime=1568611773802
    storageType=NAME_NODE
    blockpoolID=BP-1040694739-192.168.146.100-1568611773802
    layoutVersion=-65

2.s101:/tmp/hadoop-fgq/dfs/data/current/VERSION
    #Sun Sep 15 22:30:56 PDT 2019
    storageID=DS-bf752c74-13cd-4243-a392-8bee0b0e5ac4
    clusterID=CID-3f4ec779-7811-4251-a65f-bb3d520f0b86
    cTime=0
    datanodeUuid=93f0655a-c5de-4a71-8179-a7238ef8969a
    storageType=DATA_NODE
    layoutVersion=-57

3.s102:/tmp/hadoop-fgq/dfs/data/current/VERSION
    略
4.s103:/tmp/hadoop-fgq/dfs/data/current/VERSION
    略
5.s104:/tmp/hadoop-fgq/dfs/namesecondary/current/VERSION
    #Sun Sep 15 22:32:04 PDT 2019
    namespaceID=1574219430
    clusterID=CID-3f4ec779-7811-4251-a65f-bb3d520f0b86
    cTime=1568611773802
    storageType=NAME_NODE
    blockpoolID=BP-1040694739-192.168.146.100-1568611773802
    layoutVersion=-65

修改本hadoop地临时目录： find . 递归查看文件夹下内容

1.在_config目录中使用Editplus搜索功能找寻hadoop.temp.dir
2.在core-default.xml中找到节点
    <property>
        <name>hadoop.tmp.dir</name>
        <value>/tmp/hadoop-${user.name}</value>
    </property>
    [core-site.xml]修改为
    <property>
        <name>hadoop.tmp.dir</name>
        <value>/home/fgq/hadoop</value>
    </property>
    复制修改后的内容到s100的hadoop的配置文件core-site.xml中
        <configuration>
            <property>
                <name>fs.defaultFS</name>
                <value>hdfs://s100/</value>
            </property>
            <property>
                <name>hadoop.tmp.dir</name>
                <value>/home/fgq/hadoop</value>
            </property>
        </configuration>
3.分发此配置文件
    $>xsync core-site.xml    
4.停止hadoop集群
    $>stop-all.sh
5.创建配置的hadoop文件目录/home/fgq/hadoop
    $>xcall mkdir /home/fgq/hadoop
6.查看是否创建成功
    $>xcall ls -l
7.删除以前的临时目录/tmp下的内容
    $>cd /tmp
    tmp$> xcall rm -rf /tmp/hadoop-fgq
8.以前的日志也删掉
    tmp$> xcall rm -rf /soft/hadoop/logs
9.格式化
    $>hadoop namenode -format
10.重启
    $>start-all.sh
11.put一个文件 使用webui查看完全分布式集群内容
    $>hadoop fs -put hello.txt /hadoop
    浏览器中 http://localhost:9870

hadoop脚本分析 百度"hadoop3.2.0启动脚本分析"进行深入学习

1.start-all.sh
    libexec/hadoop-config.sh                        --设置变量
    sbin/start-dfs.sh  --config $HADOOP_CONF_DIR    --启动hdfs
    sbin/start-yarn.sh --config $HADOOP_CONF_DIR    --启动yarn
2.libexec/hadoop-config.sh 包含的变量有
    COMMON_DIR
    ...
    HADOOP_CONF_DIR=...
    HEAP_SIZE=1000m
    CLASSPATH=...
3.sbin/start-dfs.sh     --config $HADOOP_CONF_DIR   --启动hdfs
    1.libexec/hdfs-config.sh
    2.获得名称节点主机名
        NAMENODES=hdfs getconf -namenodes 
    3.启动名称节点
        hadoop_uservar_su hdfs namenode "${HADOOP_HDFS_HOME}/bin/hdfs" \
        --workers \
        --config "${HADOOP_CONF_DIR}" \
        --hostnames "${NAMENODES}" \
        --daemon start \
        namenode ${nameStartOpt}
    4.启动datanode节点
        hadoop_uservar_su hdfs datanode "${HADOOP_HDFS_HOME}/bin/hdfs" \
        --workers \
        --config "${HADOOP_CONF_DIR}" \
        --daemon start \
        datanode ${dataStartOpt}
    5.启动2nn
        hadoop_uservar_su hdfs secondarynamenode "${HADOOP_HDFS_HOME}/bin/hdfs" \
        --workers \
        --config "${HADOOP_CONF_DIR}" \
        --hostnames "${SECONDARY_NAMENODES}" \
        --daemon start \
        secondarynamenode

4.libexec/hdfs-config.sh
    libexec/hadoop-config.sh
5.sbin/hadoop-daemons.sh        --启动守护进程脚本
    1.libexec/hdfs-config.sh    --执行配置脚本
    2.workers.sh
        循环workers文件，通过ssh方式登录远程主机，执行相应命令
        [sbin/hadoop-daemon.sh]
        [或出现个别进程无法启动后 自己手动启动的方法如下]
            a.$>hadoop-daemon.sh start datanode/namemode/secondarynamenode     --启动单一节点
            b.$>hadoop-daemons.sh start datanode    --启动所有节点
6.bin/hadoop
    hadoop-config.sh
    java ...
7.bin/hdfs
    hadoop-config.sh
    java...

hdfs常用操作

1.查看hdfs的文件列表
    $>hdfs dfs -ls -R /  --类比 hadoop fs -ls -R /
2.上传文件到hdfs
    $>hdfs dfs -put hello.txt /hadoop               --复制
    $>hdfs dfs -moveFromLocal hello.txt /hadoop     --剪切
3.重命名
    $>hdfs dfs -mv ./hello.txt ./how.txt
4.下载
    $>hdfs dfs -get ./hello.txt ./kk.txt
5.剪切下载
    未实现
6.删除文件(也可以删除目录)
    hdfs dfs -rm -r ...
7.删除目录(空目录)
    hdfs dfs -rmdir ...
8.在hdfs上进行文件复制
9.查看文件内容
    hadoop fs -cat  /user/hadoop/output 

hadoop数据切块 hdfs文件块大小(128M)

磁盘寻道时间
磁盘的寻道时间==10ms
磁盘的IO速率==100M/s
寻道时间暂用磁盘读取速率的1%
10*100=1000ms=1s *100M/s =100M 换成二进制计算方法 2的n次幂的话 就是128M

hadoop集群 datanode启动不成功

1、问题描述：
    多次格式化文件系统时，会出现datanode无法启动
2、问题产生原因：
    执行文件系统格式化时（即执行命令$ bin/hadoop namenode -format 后），
    会在namenode数据文件夹（即配置文件中dfs.name.dir在本地系统的路径）
    中保存一个hadoopData/name（我的路径配置在core-cite.xml中）文件，记录namespaceID，
    标识了所格式化的namenode的版本。如果我们频繁的格式化namenode，
    那么datanode中保存（即配置文件中dfs.data.dir在本地系统的路径）
    的hadoopData/name文件（路径为usr/local/hadoop/tmp/dfs/data/hadoopData/name）
    只是你第一次格式化时保存的namenode的ID，因此就会造成namdenode 的 namespaceID 与 
    datanode的namespaceID 不一致，从而导致namenode和 datanode的断连。
3、解决方案：
    把/tmp下的Hadoop开关的临时文件删除，或者把/hadoop.tmp.dir目录清空
    （我是直接删除了:# rm -r /tmp,因为仅仅删除dir发现并没有效果，要根据具体情况解决问题，
    此处只是提供一个正确的思路）
    【注：在每次执行hadoop namenode -format时，都会为NameNode生成namespaceID,，
    但是在hadoop.tmp.dir目录下的DataNode还是保留上次的namespaceID，因为namespaceID的不一致，
    而导致DataNode无法启动，所以只要在每次执行hadoop namenode -format之前，
    先删除hadoop.tmp.dir（路径为 /usr/local/hadoop/下的）tmp目录就可以启动成功，
    或者删除/usr/local/hadoop/tmp/dfs下的data目录，
    然后重新启动dfs（在hadoop安装路径 /usr/local/hadoop/ 下，运行命令./sbin/start-dfs.sh）即可。
    请注意是删除hadoop.tmp.dir对应的本地目录，即/usr/local/hadoop/下的tmp文件夹，而不是HDFS目录。】
    [注意*删除hadoop临时目录要删除整个集群所有机器上的这个目录]

hdfs FileSystem API(java通过API访问hadoop文件)

错误集合
1.org.apache.hadoop.security.AccessControlException: Permission denied: user=Administrator, access=WRITE, inode="/home":fgq:supergroup:drwxr-xr-x
    由于/home这个hadoop的逻辑文件库目录权限的限制无法写
    fgq@s100:~$ hdfs dfs -ls -R /
    drwxr-xr-x   - fgq supergroup          0 2019-09-16 20:33 /home
    drwxr-xr-x   - fgq supergroup          0 2019-09-16 20:33 /home/fgq
    drwxr-xr-x   - fgq supergroup          0 2019-09-16 20:34 /home/fgq/logicdata
    -rw-r--r--   2 fgq supergroup         10 2019-09-16 20:34 /home/fgq/logicdata/he
    所以进行一下改动即可
    fgq@s100:~$ hdfs dfs -chmod 777 /home 
    改后的权限如下
    fgq@s100:~$ hdfs dfs -ls -R /
    drwxrwxrwx   - fgq supergroup          0 2019-09-16 20:33 /home
    drwxr-xr-x   - fgq supergroup          0 2019-09-16 20:33 /home/fgq
    drwxr-xr-x   - fgq supergroup          0 2019-09-16 20:34 /home/fgq/logicdata
    -rw-r--r--   2 fgq supergroup         10 2019-09-16 20:34 /home/fgq/logicdata/hello.txt
    使用程序上传一个文件
    fgq@s100:~$ hdfs dfs -ls -R /
    drwxrwxrwx   - fgq supergroup          0 2019-09-16 22:41 /home
    drwxr-xr-x   - fgq           supergroup          0 2019-09-16 20:33 /home/fgq
    drwxr-xr-x   - fgq           supergroup          0 2019-09-16 20:34 /home/fgq/logicdata
    -rw-r--r--   2 fgq           supergroup         10 2019-09-16 20:34 /home/fgq/logicdata/hello.txt
    -rw-r--r--   3 Administrator supergroup         22 2019-09-16 22:42 /home/hello.txt     --windows上使用eclipse代码上传的文件


2.由一个HADOOP_HOME and hadoop.home.dir are unset报错引起的window环境连接调试远程hadoop的一系列问题
    这个问题一般是因为当前服务器没有安装Hadoop，因此首先需要下载并解压Hadoop安装包，其次需要配置系统环境变量：
    控制面板 > 系统和安全 > 系统 > 高级系统变量 > 环境变量，添加一个环境变量，名字是：HADOOP_HOME，值是：D:\hadoop-3.0.3
    下载WINUTILS.EXE，并放到Hadoop的bin目录
3.注意了*在(旗舰版)windows上使用eclipse(java api)访问hadoop集群,如果不是在administrator的身份下登录的Windows那么会出现很多问题
代码示例
    示例一(不推荐)
    package com.it18zhang.hdfs;
    import java.io.FileOutputStream;
    import java.io.InputStream;
    import java.net.URL;
    import java.net.URLConnection;

    import org.apache.hadoop.fs.FsUrlStreamHandlerFactory;

    public class TestHDFS {
        static {
            //注册协议处理器工厂，让java程序能够识别hdfs协议
                    URL.setURLStreamHandlerFactory(new FsUrlStreamHandlerFactory());
        }
        public static void main(String[] args) throws Exception {
            
            //定义url地址
            String url="hdfs://s100:8020/home/fgq/logicdata/hello.txt";
            //URL链接对象
            URL u=new URL(url);
            //URL连接
            URLConnection conn=u.openConnection();
            //打开输入流
            InputStream is=conn.getInputStream();
            
            //输出流
            FileOutputStream fos=new java.io.FileOutputStream("e:/fgq/hello.txt");
            //对拷贝
            byte[] buf=new byte[1024];
            int len=1;
            while((len=is.read(buf))!=-1) {
                fos.write(buf,0,len);
            }
            is.close();
            fos.close();
            
        }
    }
    示例二(推荐)
    package com.it18zhang.hdfs.test;
    import java.io.FileNotFoundException;
    import java.io.FileOutputStream;
    import java.io.IOException;
    import java.lang.reflect.Method;

    import org.apache.hadoop.conf.Configuration;
    import org.apache.hadoop.fs.FSDataInputStream;
    import org.apache.hadoop.fs.FSDataOutputStream;
    import org.apache.hadoop.fs.FileStatus;
    import org.apache.hadoop.fs.FileSystem;
    import org.apache.hadoop.fs.Path;
    import org.apache.hadoop.fs.permission.FsAction;
    import org.apache.hadoop.fs.permission.FsPermission;
    import org.apache.hadoop.io.IOUtils;
    import org.junit.Before;
    import org.junit.Test;

    public class TestFileSystem {
        Configuration conf=null;
        FileSystem fs=null;
        @Before
        public void before() throws Exception {
            conf=new Configuration();
            fs=FileSystem.get(conf);
        }
        /***
        * 读操作，从hdfs上下载文件
        * @throws Exception 
        */
        @Test
        public void readFile() throws Exception {
            Path path=new Path("/home/hello.txt");
            FSDataInputStream fis=fs.open(path);
            FileOutputStream fos=new FileOutputStream("e:/fgq/hello.txt");
            IOUtils.copyBytes(fis, fos, 1024);
            IOUtils.closeStream(fis);
            IOUtils.closeStream(fos);
            System.out.println("读完了");
        }
        /***
        * 写操作
        * @throws Exception 
        */
        @Test
        public void writeFile() throws Exception {
            Path path=new Path("hdfs://s100:8020/home/hello.txt");
            //输出流
            FSDataOutputStream dos=fs.create(path);
            dos.write("helloworld hadoop hdfs".getBytes());
            dos.close();
            System.out.println("over");
            
        }
        
        /***
        * 写操作，指定副本数
        * @throws Exception 
        */
        @Test
        public void writeFileInReplication() throws Exception {
            Path path=new Path("hdfs://s100:8020/home/how.txt");
            //数据输出流
            FSDataOutputStream dos=fs.create(path,(short)2);
            dos.write("how are you?".getBytes());
            dos.close();
            System.out.println("over");
        }
        
        /***
        * 读文件，定义文件偏移量(分块来读)
        *  定位文件读取第一块 注意hello.txt大小有分块才可以，是否有分块可以在hadoop集群上查看，所以得找个大于128M的文件来测试
        * @throws Exception 
        */
        @Test
        public void readFileSeekBlock0() throws Exception {
            Path path=new Path("/home/hello.txt");
            FSDataInputStream fis=fs.open(path);
            FileOutputStream fos=new FileOutputStream("e:/fgq/hello.txt.part-0");
            int count=1024*1024*128;
            byte[] buf=new byte[1024];
            for (int i = 0; i < 1024*128; i++) {
                fis.read(buf);
                fos.write(buf);
            }
            IOUtils.closeStream(fis);
            IOUtils.closeStream(fos);
            System.out.println("读完了");
        }
        
        /***
        * 读文件，定义文件偏移量(分块来读)
        * 定位文件读取第二块 注意hello.txt大小有分块才可以，是否有分块可以在hadoop集群上查看，所以得找个大于128M的文件来测试
        * 当两块都读完后 可以在cmd使用 "cat 第二块文件  >>  第一块文件"命令合并
        * @throws Exception 
        */
        @Test
        public void readFileSeekBlock1() throws Exception {
            Path path=new Path("/home/hello.txt");
            FSDataInputStream fis=fs.open(path);
            FileOutputStream fos=new FileOutputStream("e:/fgq/hello.txt.part-1");
            //定义文件偏移量
            fis.seek(1024*1024*128); //从第二块开始读取(因为第一块的大小是128M)
            IOUtils.copyBytes(fis, fos, 1024);
            IOUtils.closeStream(fis);
            IOUtils.closeStream(fos);
            System.out.println("读完了");
        }
        /***
        * 创建目录并指定权限
        * @throws Exception
        */
        @Test
        public void mkdir() throws Exception {
            Path path=new Path("/home/myfolder");
            //创建权限对象
            FsPermission perm=new FsPermission(FsAction.ALL,FsAction.ALL,FsAction.ALL);
            //创建目录指定权限
            boolean b=fs.mkdirs(path,perm);
            System.out.println(b);
        }
        
        
        /***
        * 遍历目录（遍历所以参数为空的方法 getSymlink()这个方法不支持调用要排除掉）
        * @throws Exception
        */
        @Test
        public void fileStatus() throws Exception {
            FileStatus fs0=fs.getFileStatus(new Path("/"));
            Class clazz=FileStatus.class;
            Method[] ms=clazz.getDeclaredMethods();
            for (Method m : ms) {
                String mname=m.getName();
                Class[] ptype=m.getParameterTypes();
                if(mname.startsWith("get")&&(ptype==null||ptype.length==0)) {
                    if(!mname.equals("getSymlink")) {
                        Object ret=m.invoke(fs0, null);
                        System.out.println(mname+"() = "+ret);
                    }
                }
            }
            
        }
    }

查询集群副本数

$>hdfs getconf -confkey dfs.replication

查看文件块信息

/***
 * 获取文件块位置数组
 * @throws Exception
 */
public void getBlockLocation() throws Exception {
	//创建路径
	Path path=new Path("/home/fgq/logicdata/hello.txt");
	//得到文件状态
	FileStatus fss=fs.getFileStatus(path);
	//得到文件长度
	long length=fss.getLen();
	//得到文件块列表
	BlockLocation[] locs=fs.getFileBlockLocations(fss, 0, length);
	//
	for (BlockLocation loc : locs) {
		System.out.println(loc.getHosts());
	}
	
}

日志滚动(滚动编辑日志-融合镜像) 随着时间和编辑日志大小进行自动滚动

访问读写速度快
避免直接操作镜像文件导致的镜像文件锁定
手动滚动命令
    $>hdfs dfsadmin -rollEdits
保存名字空间/融合镜像和编辑日志
    $>hdfs dfsadmin -safemode enter
    $>hdfs dfsadmin -saveNamespace
    $>hdfs dfsadmin -safemode leave

数据的完整性 校验和

/***
    * 测试本地文件系统的校验和  LocalFileSystem
    * @throws Exception
    */
    @Test
    public void testLocalFileSystem() throws Exception {
        //创建配置对象，加载core-default.xml + core-site.xml
        Configuration conf=new Configuration();
        //自定义设定 覆盖默认加载core-default.xml + core-site.xml的内容
        conf.set("fs.defaultFS", "file:///");
        FileSystem fs=FileSystem.get(conf);
        Path path=new Path("d:/hello.txt");
        FSDataOutputStream fos=fs.create(path);
        fos.write("helloworld".getBytes());
        fos.close();
        fs.close();
        System.out.println("over");
    }

Ubuntu上安装eclipse 注意eclipse和jdk版本对应问题 不可乱下载

1.去eclipse官网下载 Eclipse IDE for Enterprise Java Developers (jdk1.8.0_xx)
2.gq@s100:~/Downloads$ tar -xzvf eclipse-jee-mars-2-linux-gtk-x86_64.tar.gz
    可以看到解压后的文件夹就叫eclipse
3.gq@s100:~/Downloads$ mv eclipse /home/fgq/soft/
4.建立jre软连接
    mkdir /home/fgq/soft/eclipse/jre
    ln -s /home/fgq/soft/jdk/bin /home/fgq/soft/eclipse/jre/
5.添加eclipse的桌面图标
    sudo gedit /usr/share/applications/eclipse.desktop
    在打开的文件中键入（注意Exec和Icon路径是否正确）
    [Desktop Entry]
    Encoding=UTF-8
    Name=eclipse
    Comment=eclipse
    Exec=/home/fgq/soft/eclipse/eclipse 
    Icon=/home/fgq/soft/eclipse/icon.xpm
    Terminal=false
    StartupNotify=true
    Type=Application
    Categories=Application;Development;

    sudo chmod u+x /usr/share/applications/eclipse.desktop
    
    然后点击图标进行开发

6.问题 如何是的eclipse正确的加载hadoop的本地类库 native-hadoop
1.Unable to load native-hadoop library for your platform... using builtin-java classes where applicable
    解决方式
        fgq@s100:~/soft/hadoop/lib/native$ sudo su root
        root@s100:/home/fgq/soft/hadoop-3.2.0/lib/native# rsync -l * /usr/local/lib

压缩和解压缩 deflate

管道模糊或精确查询

$>ls -al | grep xxx
或
$>find / | grep xxx

安装loz-2.06报错

fgq@s100:~/Downloads/lzo-2.06$ ./configure --enable-shared
configure: Configuring LZO 2.06
checking build system type... x86_64-unknown-linux-gnu
checking host system type... x86_64-unknown-linux-gnu
checking target system type... x86_64-unknown-linux-gnu
checking whether to enable maintainer-specific portions of Makefiles... no
checking for gcc... no              --缺少gcc
checking for cc... no               --缺少cc
checking for cl.exe... no           --缺少cl.exe
configure: error: in `/home/fgq/Downloads/lzo-2.06':
configure: error: no acceptable C compiler found in $PATH
See `config.log' for more details
解决方式 安装基础工具库
fgq@s100:~$>sudo apt-get install build-essential

压缩解压缩 代码

package com.it18zhang.hdfs.test;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;

import org.apache.avro.file.BZip2Codec;
import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.io.IOUtils;
import org.apache.hadoop.io.compress.CompressionCodec;
import org.apache.hadoop.io.compress.CompressionInputStream;
import org.apache.hadoop.io.compress.CompressionOutputStream;
import org.apache.hadoop.io.compress.DeflateCodec;
import org.apache.hadoop.io.compress.GzipCodec;
import org.apache.hadoop.io.compress.Lz4Codec;
import org.apache.hadoop.io.compress.SnappyCodec;
import org.apache.hadoop.util.ReflectionUtils;
import org.junit.Test;

import com.hadoop.compression.lzo.LzoCodec;

public class FileCompressionTest {
    /***
    * compression
    * @throws Exception
    */
    @Test
    public void begincompression() throws Exception{
        Class[] codecs={
                DeflateCodec.class,
                GzipCodec.class,
                BZip2Codec.class,
                LzoCodec.class,
                Lz4Codec.class,
                SnappyCodec.class,
        };
        for (Class clazz : codecs) {
            compress("hadoop.pdf",clazz);
            decompress("hadoop.pdf",clazz);
            System.out.println();
        }
    }
    
    @Test
    public void compress(String filename,Class clazz) throws Exception {
        // fgq@s100:~/soft/hadoop/lib/native$ sudo su root
        // root@s100:/home/fgq/soft/hadoop-3.2.0/lib/native# rsync -l *
        // /usr/local/lib
//		String codecClassname = "org.apache.hadoop.io.compress.DefaultCodec";
//		Class<?> codecClass = Class.forName(clazz.getName());
        long start=System.currentTimeMillis();
        Configuration conf = new Configuration();
        CompressionCodec codec = (CompressionCodec) ReflectionUtils.newInstance(clazz, conf);
        
        FileInputStream fis = new FileInputStream("/home/fgq/codec/"+filename);
        FileOutputStream fos = new FileOutputStream("/home/fgq/codec/"+(filename.substring(0,filename.indexOf(".")))+codec.getDefaultExtension());
        CompressionOutputStream out = codec.createOutputStream(fos);
        IOUtils.copyBytes(fis, out, 4096, false);
        out.finish();

        out.close();
        fos.close();
        fis.close();
        File file =new File("/home/fgq/codec/"+(filename.substring(0,filename.indexOf(".")))+codec.getDefaultExtension());
        long length=file.length();
        System.out.println(clazz.getSimpleName()+" :length="+length);
        
        System.out.print(",compressionTime="+(System.currentTimeMillis()-start));
    }
    
    /***
    * decompression
    * @throws Exception
    * @throws IOException
    */
    @Test
    public void decompress(String filename,Class clazz) throws Exception {
        long start=System.currentTimeMillis();
        Configuration conf =new Configuration();
//		Class<DeflateCodec> codecClass=DeflateCodec.class;
        DeflateCodec codec=ReflectionUtils.newInstance(clazz,conf);
        CompressionInputStream cis=codec.createInputStream(new FileInputStream("/home/fgq/codec/"+(filename.substring(0,filename.indexOf(".")))+codec.getDefaultExtension()));	
        FileOutputStream fos=new FileOutputStream("/home/fgq/codec/new_"+filename);
        IOUtils.copyBytes(cis, fos, 1024);
        fos.close();
        cis.close();
        System.out.print(",decompressionTime="+(System.currentTimeMillis()-start));
    }
}

使用codePool池优化压缩过程

package com.it18zhang.hdfs;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;

import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.io.IOUtils;
import org.apache.hadoop.io.compress.CodecPool;
import org.apache.hadoop.io.compress.CompressionCodec;
import org.apache.hadoop.io.compress.CompressionInputStream;
import org.apache.hadoop.io.compress.CompressionOutputStream;
import org.apache.hadoop.io.compress.Compressor;
import org.apache.hadoop.io.compress.Decompressor;
import org.apache.hadoop.io.compress.DeflateCodec;
import org.apache.hadoop.util.ReflectionUtils;

public class CodecPoolTest {
    /***
    * compression,CodecPool
    * @param args
    * @throws Exception
    * @throws IOException
    */
    public static void main0(String[] args) throws Exception, IOException {
        Configuration  configuration=new Configuration();
        Class codecClass=DeflateCodec.class;
        CompressionCodec codec=(CompressionCodec)ReflectionUtils.newInstance(codecClass, configuration);
        Compressor compressor=CodecPool.getCompressor(codec);
        CompressionOutputStream coStream=codec.createOutputStream(new FileOutputStream("/home/fgq/codec/hadoop.defalte"),compressor);
        IOUtils.copyBytes(new FileInputStream("/home/fgq/codec/hadoop.pdf"), coStream, 1024);
        coStream.close();
        CodecPool.returnCompressor(compressor);
        System.out.println("over!!!");
    }
    
    /***
    * decompression,CodecPool
    * @param args
    * @throws Exception
    * @throws IOException
    */
    public static void main(String[] args) throws Exception, IOException {
        Configuration  configuration=new Configuration();
        Class codecClass=DeflateCodec.class;
        CompressionCodec codec=(CompressionCodec)ReflectionUtils.newInstance(codecClass, configuration);
        Decompressor decompressor=CodecPool.getDecompressor(codec);
        CompressionInputStream cis=codec.createInputStream(new FileInputStream("/home/fgq/codec/hadoop.defalte"),decompressor);
        IOUtils.copyBytes(cis,new FileOutputStream("/home/fgq/codec/hadoop.pdf"), 1024);
        cis.close();
        CodecPool.returnDecompressor(decompressor);
        System.out.println("over!!!");
    }
}

hadoop-day07-03-04-05 sequncefile->mapfile->arrayfile->setfile

源码提取 执行

mapreduce job 气温数据计算分析 day9-03

源码提取 执行

考察hadoop的底层IPC通信 day10-01

源码提取 执行

考察hadoop mapduce的计数器 day10-05

源码提取 执行

hadoop 利用mapreduce读写mysql数据 day11-07

源码提取

查看网络端口命令

&>netstat -ano | grep 8000

在做mapreduce编程时 避免切片文件太小

一个文件
    切片文件太小 导致切片很多 map很多 运行计算效率很低

---