精华内容
下载资源
问答
  • 文章目录前言Hadoop大数据平台搭建一.Hadoop原理和功能介绍二.Hadoop安装部署三.Hadoop常用操作总结 此文章摘自充电了么创始人,CEO兼CTO陈敬雷先生的新书《分布式机器学习实战》(人工智能科学与技术丛书)。更...

    前言

    分布式机器学习为什么需求大数据呢?随着海量用户数据的积累,单机运算已经不能满足需求。基于海量数据,机器学习训练之前需要做数据预处理、特征工程等,需要在大数据平台上来进行。另一个就是机器学习训练过程的中间结果集可能会数据膨胀,依然需要大数据平台来承载。也就是说为了高性能的数据处理、分布式计算等,分布式机器学习是以大数据平台为基础的。所以下面我们来讲一下热门常用的大数据技术。

    Hadoop大数据平台搭建

    Hadoop是一种分析和处理大数据的软件平台,是一个用 Java 语言实现的 Apache 的开源软件框架,在大量计算机组成的集群中实现了对海量数据的分布式计算。Hadoop是大数据平台的标配,不管哪个公司的大数据部门,基本都是以Hadoop为核心。下面我们详细讲解下Hadoop原理和常用的一些操作命令。

    一.Hadoop原理和功能介绍

    Hadoop是一个由Apache基金会所开发的分布式系统基础架构。用户可以在不了解分布式底层细节的情况下,开发分布式程序。充分利用集群的威力进行高速运算和存储。
    Hadoop实现了一个分布式文件系统(Hadoop Distributed File System),简称HDFS。HDFS有高容错性的特点,并且设计用来部署在低廉的(low-cost)硬件上;而且它提供高吞吐量(high throughput)来访问应用程序的数据,适合那些有着超大数据集(large data set)的应用程序。HDFS放宽了(relax)POSIX的要求,可以以流的形式访问(streaming access)文件系统中的数据。
    Hadoop的框架最核心的设计有三大块:HDFS分布式存储、MapReduce计算引擎、YARN资源调度和管理,针对Hadoop这三大块核心,我们详细来讲一下。
    1.HDFS架构原理
    HDFS 全称 Hadoop 分布式文件系统,其最主要的作用是作为 Hadoop 生态中各系统的存储服务。HDFS为海量的数据提供了存储,可以认为它是个分布式数据库,用来存储。HDFS 主要包含了6个服务:
    1)NameNode
    负责管理文件系统的Namespace以及客户端对文件的访问,NameNode在Hadoop2可以有多个,Hadoop1只能有一个,存在单点故障。HDFS中的NameNode被称为元数据节点,DataNode称为数据节点。NameNode维护了文件与数据块的映射表以及数据块与数据节点的映射表,而真正的数据是存储在DataNode上。 NameNode的功能如下:
    (1)它是维护和管理 DataNode 的主守护进程;
    (2)它记录存储在集群中的所有文件的元数据,例如Block 的位置、文件大小、权限、层次结构等。有两个文件与元数据关联;
    (3)FsImage:它包含自 NameNode 开始以来文件的 namespace 的完整状态;
    (4)EditLogs:它包含最近对文件系统进行的与最新 FsImage 相关的所有修改。它记录了发生在文件系统元数据上的每个更改。例如,如果一个文件在 HDFS 中被删除,NameNode会立即在EditLog中记录这个操作;
    (5)它定期从集群中的所有 DataNode 接收心跳信息和Block 报告,以确保 DataNode 处于活动状态;
    (6)它保留了HDFS中所有Block的记录以及这些Block所在的节点;
    (7)它负责管理所有Block的复制;
    (8)在 DataNode 失败的情况下,NameNode会为副本选择新的 DataNode,平衡磁盘使用并管理到DataNode的通信流量;
    (9)DataNode 则是 HDFS 中的从节点,与 NameNode 不同的是,DataNode 是一种商品硬件,它并不具有高质量或高可用性。DataNode 是一个将数据存储在本地文件 ext3 或 ext4 中的Block服务器。
    2)DataNode
    用于管理它所在节点上的数据存储:
    (1)这些是丛属守护进行或在每台从属机器上运行的进程;
    (2)实际的数据存储在DataNode上;
    (3)执行文件系统客户端底层的读写请求;
    (4)定期向NameNode发送心跳报告HDFS的整体健康状况,默认频率为3秒;
    (5)数据块(Block):通常,在任何文件系统中,都将数据存储为Block 的集合。Block 是硬盘上存储数据的最不连续的位置。在Hadoop 集群中,每个Block 的默认大小为 128M(此处指 Hadoop 2.x 版本,Hadoop 1.x 版本为 64M),您也可以通过如下配置配置Block的大小:dfs.block.size或 dfs.blocksize =64M
    (6)数据复制:HDFS 提供了一种将大数据作为数据块存储在分布式环境中的可靠方法,即将这些Block复制以容错。默认的复制因子是3,您也可以通过如下配置配置复制因子:
    fs.replication = 3每个Block 被复制3次存储在不同的 DataNode 中。
    3)FailoverController
    故障切换控制器,负责监控与切换 NameNode 服务。
    4)JournalNode
    用于存储 EditLog;记录文件和数映射关系,操作记录,恢复操作。
    5)Balancer
    用于平衡集群之间各节点的磁盘利用率。
    6)HttpFS
    提供 HTTP 方式访问 HDFS 的功能。总的看来NameNode 和 DataNode 是 HDFS 的核心,也是客户端操作数据需要依赖的两个服务。
    2.MapReduce计算引擎
    MapReduce计算引擎经历了两个版本,Hadoop1的时候叫MRv1,Hadoop2的时候叫MRv2。MapReduce则为海量的数据提供了计算引擎,拿里面的数据做运算,跑的快。一声令下,多台机器团结合作,每台机器分自己一部分任务,同时并行跑。等所有机器小任务跑完,汇总报道,总任务全部完成。
    1)MapReduce1架构原理
    在Hadoop1.X的时代,其核心是JobTracker。
    JobTracker:
    主要负责资源监控管理和作业调度
    (1)监控所有TaskTracker与Job的健康状况,一旦发现失败,就将相应的任务转移到其他节点;
    (2)同时JobTracker会跟踪任务的执行进度、资源使用量等信息,并将这些信息告诉任务调度器,而调度器会在资源出现空闲时,选择合适的任务使用这些资源。
    TaskTracker:
    TaskTracker是JobTracker与Task之前的桥梁。
    (1)从JobTracker接收并执行各种命令:运行任务、提交任务、Kill任务、重新初始化任务;
    (2)周期性地通过心跳机制,将节点健康情况和资源使用情况、各个任务的进度和状态等汇报给JobTracker。
    MapReduce1框架的主要局限:
    (1)JobTracker 是 MapReduce 的集中处理点,存在单点故障,可靠性差;
    (2)JobTracker 完成了太多的任务,造成了过多的资源消耗,当MapReduce Job非常多的时候,会造成很大的内存开销,潜在来说,也增加了JobTracker 失效的风险,这也是业界普遍总结出老Hadoop的MapReduce只能支持4000节点主机的上限,扩展性能差;
    (3)可预测的延迟:这是用户非常关心的。小作业应该尽可能快得被调度,而当前基于TaskTracker->JobTracker ping(heartbeat)的通信方式代价和延迟过大,比较好的方式是JobTracker->TaskTracker ping,这样JobTracker可以主动扫描有作业运行的TaskTracker。
    2)MapReduce2架构原理
    Hadoop2之后有Yarn,Hadoop1的时候还没有。MapReduce2(又名MRv2),用Yarn来管理,下面我们来讲一下Yarn资源调度。
    3.Yarn资源调度和管理
    1)ResourceManager(RM)
    ResourceManager就是资源调度器,包含两个主要的组件:定时调用器(Scheduler)以及应用管理器(ApplicationManager)。
    (1)调度器(Scheduler):根据容量,队列等限制条件,将系统中的资源分配给各个正在运行的应用。这里的调度器是一个“纯调度器”,因为它不再负责监控或者跟踪应用的执行状态等,此外,他也不负责重新启动因应用执行失败或者硬件故障而产生的失败任务。调度器仅根据各个应用的资源需求进行调度,这是通过抽象概念“资源容器”完成的,资源容器(Resource Container)将内存,CPU,磁盘,网络等资源封装在一起,从而限定每个任务使用的资源量。总而言之,定时调度器负责向应用程序分配资源,它不做监控以及应用程序的状态跟踪,并且它不保证会重启由于应用程序本身或硬件出错而执行失败的应用程序。
    (2)应用管理器(ApplicationsManager,ASM):ASM主要负责接收作业,协商获取第一个容器用于执行AM和提供重启失败AM container的服务。
    2)NodeManager
    NodeManager简称NM,是每个节点上的框架代理,主要负责启动应用所需的容器,监控资源(内存,CPU,磁盘,网络等)的使用情况并将之汇报给调度器(Scheduler)。
    3)ApplicationMaster
    每个应用程序的ApplicationMaster负责从Scheduler申请资源,以及跟踪这些资源的使用情况以及任务进度的监控。
    4)Container
    是Yarn中资源的抽象,它将内存、CPU、磁盘、网络等资源封装在一起。当AM向RM申请资源时,RM为AM返回的资源便是用Container表示的。
    了解了Hadoop的原理和核心组件,我们看下如何安装部署搭建分布式集群。

    二.Hadoop安装部署

    Hadoop有Apache社区版和第三方发行版CDH,Apache社区版优点是完全开源免费 社区活跃 文档、资料详实。缺点是版本管理比较混乱,各种版本层出不穷,很难选择,选择生态组件时需要大量考虑兼容性问题、版本匹配问题、组件冲突问题、编译问题等。集群的部署安装配置复杂,需要编写大量配置文件,分发到每台节点,容易出错,效率低。集群运维复杂,需要安装第三方软件辅助。CDH是第三方公司Cloudera公司基于社区版本的基础上做了一些优化和改进,稳定性更强一些。CDH分免费版和商业版。CDH安装可以使用CM通过管理界面的方式来安装,非常简单。Cloudera Manager(简称CM)是Cloudera公司开发的一款大数据集群安装部署利器,这款利器具有集群自动化安装、中心化管理、集群监控、报警等功能,使得安装集群从几天的时间缩短在几小时以内,运维人员从数十人降低到几人以内,极大的提高集群管理的效率。
    不管是CDH还是Apache社区版,我们都是使用tar包手动来部署,所有的环境需要我们一步步来操作,Hadoop的每个配置文件也需要我们手工配置,这种方式安装的优势比较灵活,集群服务器也不需要连外网,但这种方式对开发人员的要求比较高,对各种开发环境和配置文件都需要了解清楚。不过这种方式更方便我们了解Hadoop的各个模块和工作原理。下面我们使用这种方式来手动的安装分布式集群,我们的例子是部署5台服务器,两个NameNode节点做HA,5个DataNode节点,两个NameNode节点也同时作为DataNode。一般当服务器不多的时候,为了尽量的充分利用服务器的资源,NameNode节点可以同时是DataNode。
    安装步骤如下:
    1.创建Hadoop用户
    1)useradd hadoop
    设密码passwd hadoop
    命令usermod -g hadoop hadoop
    2)vi /root/sudo
    添加一行
    hadoop ALL=(ALL) NOPASSWD:ALL
    chmod u+w /etc/sudoers
    3)编辑/etc/sudoers文件
    #也就是输入命令:
    vi /etc/sudoers
    #进入编辑模式,找到这一行:
    root ALL=(ALL) ALL
    #在它的下面添加:
    hadoop ALL=(ALL) NOPASSWD:ALL
    #这里的hadoop是你的用户名,然后保存退出。
    4)撤销文件的写权限
    #也就是输入命令:
    chmod u-w /etc/sudoers
    2.设置环境变量
    编辑/etc/profile文件
    vim /etc/profile
    输入以下配置,如代码3.1所示:
    【代码3.1】 环境变量
    export JAVA_HOME=/home/hadoop/software/jdk1.8.0_121
    export SPARK_HOME=/home/hadoop/software/spark21
    export SCALA_HOME=/home/hadoop/software/scala-2.11.8
    export SQOOP_HOME=/home/hadoop/software/sqoop
    export HADOOP_HOME=/home/hadoop/software/hadoop2
    export PATH= P A T H : PATH: PATH:HADOOP_HOME/bin
    export PATH= P A T H : PATH: PATH:HADOOP_HOME/sbin
    export HADOOP_MAPARED_HOME= H A D O O P H O M E e x p o r t H A D O O P C O M M O N H O M E = {HADOOP_HOME} export HADOOP_COMMON_HOME= HADOOPHOMEexportHADOOPCOMMONHOME={HADOOP_HOME}
    export HADOOP_HDFS_HOME= H A D O O P H O M E e x p o r t Y A R N H O M E = {HADOOP_HOME} export YARN_HOME= HADOOPHOMEexportYARNHOME={HADOOP_HOME}
    export HADOOP_CONF_DIR= H A D O O P H O M E / e t c / h a d o o p e x p o r t H I V E H O M E = / h o m e / h a d o o p / s o f t w a r e / h a d o o p 2 / h i v e e x p o r t P A T H = {HADOOP_HOME}/etc/hadoop export HIVE_HOME=/home/hadoop/software/hadoop2/hive export PATH= HADOOPHOME/etc/hadoopexportHIVEHOME=/home/hadoop/software/hadoop2/hiveexportPATH=JAVA_HOME/bin: H I V E H O M E / b i n : HIVE_HOME/bin: HIVEHOME/bin:SQOOP_HOME/bin: P A T H e x p o r t C L A S S P A T H = . : PATH export CLASSPATH=.: PATHexportCLASSPATH=.:JAVA_HOME/lib/dt.jar: J A V A H O M E / l i b / t o o l s . j a r e x p o r t P A T H U S E R L O G N A M E M A I L H O S T N A M E H I S T S I Z E H I S T C O N T R O L e x p o r t F L U M E H O M E = / h o m e / h a d o o p / s o f t w a r e / f l u m e e x p o r t P A T H = JAVA_HOME/lib/tools.jar export PATH USER LOGNAME MAIL HOSTNAME HISTSIZE HISTCONTROL export FLUME_HOME=/home/hadoop/software/flume export PATH= JAVAHOME/lib/tools.jarexportPATHUSERLOGNAMEMAILHOSTNAMEHISTSIZEHISTCONTROLexportFLUMEHOME=/home/hadoop/software/flumeexportPATH=PATH: F L U M E H O M E / b i n e x p o r t H B A S E H O M E = / h o m e / h a d o o p / s o f t w a r e / h b a s e − 0.98.8 − h a d o o p 2 e x p o r t P A T H = FLUME_HOME/bin export HBASE_HOME=/home/hadoop/software/hbase-0.98.8-hadoop2 export PATH= FLUMEHOME/binexportHBASEHOME=/home/hadoop/software/hbase0.98.8hadoop2exportPATH=PATH: H B A S E H O M E / b i n e x p o r t S O L R H O M E = / h o m e / h a d o o p / s o f t w a r e / s o l r c l o u d / s o l r − 6.4.2 e x p o r t P A T H = HBASE_HOME/bin export SOLR_HOME=/home/hadoop/software/solrcloud/solr-6.4.2 export PATH= HBASEHOME/binexportSOLRHOME=/home/hadoop/software/solrcloud/solr6.4.2exportPATH=PATH: S O L R H O M E / b i n e x p o r t M 2 H O M E = / h o m e / h a d o o p / s o f t w a r e / a p a c h e − m a v e n − 3.3.9 e x p o r t P A T H = SOLR_HOME/bin export M2_HOME=/home/hadoop/software/apache-maven-3.3.9 export PATH= SOLRHOME/binexportM2HOME=/home/hadoop/software/apachemaven3.3.9exportPATH=PATH: M 2 H O M E / b i n e x p o r t P A T H = M2_HOME/bin export PATH= M2HOME/binexportPATH=PATH:/home/hadoop/software/apache-storm-1.1.0/bin
    export OOZIE_HOME=/home/hadoop/software/oozie-4.3.0
    export SQOOP_HOME=/home/hadoop/software/sqoop-1.4.6-cdh5.5.2
    export PATH= P A T H : PATH: PATH:SQOOP_HOME/bin
    #按:wq保存,保存后环境变量还没有生效,执行以下命令才会生效。
    source /etc/profile
    #然后修改下Hadoop的安装目录为Hadoop用户所有。
    chown -R hadoop:hadoop /data1/software/hadoop
    3.设置local无密码登陆
    su - hadoop
    cd ~/.ssh 如果没有.shh 则mkdir ~/.ssh
    ssh-keygen -t rsa
    cd ~/.ssh
    cat id_rsa.pub >> authorized_keys
    sudo chmod 644 ~/.ssh/authorized_keys
    sudo chmod 700 ~/.ssh
    然后重启sshd服务:
    sudo /etc/rc.d/init.d/sshd restart
    有些情况下会遇到这个报错,可以这么来解决。
    常见错误:
    ssh-keygen -t rsa
    Generating public/private rsa key pair.
    Enter file in which to save the key (/home/hadoop/.ssh/id_rsa):
    Could not create directory ‘/home/hadoop/.ssh’.
    Enter passphrase (empty for no passphrase):
    Enter same passphrase again:
    open /home/hadoop/.ssh/id_rsa failed: Permission denied.
    Saving the key failed: /home/hadoop/.ssh/id_rsa.
    解决办法:
    在root用户下操作yum remove selinux*
    4.修改/etc/hosts主机名和IP地址的映射文件
    sudo vim /etc/hosts
    增加:
    172.172.0.11 data1
    172.172.0.12 data2
    172.172.0.13 data3
    172.172.0.14 data4
    172.172.0.15 data5
    5.设置远程无密码登陆
    使用Hadoop用户:
    每台机器先本地无秘钥部署一遍。然后因为我们搭建的是双NameNode节点,需要从这两个服务器上把authorized_keys文件复制到其它机器上,主要目的是NameNode节点需要直接访问DataNode节点。
    把双namenode HA的authorized_keys复制到slave上。
    从namenode1节点上复制:
    scp authorized_keys hadoop@data2:~/.ssh/authorized_keys_from_data1
    scp authorized_keys hadoop@data3:~/.ssh/authorized_keys_from_data1
    scp authorized_keys hadoop@data4:~/.ssh/authorized_keys_from_data1
    scp authorized_keys hadoop@data5:~/.ssh/authorized_keys_from_data1
    然后从namenode2节点上复制:
    scp authorized_keys hadoop@data1:~/.ssh/authorized_keys_from_data2
    scp authorized_keys hadoop@data3:~/.ssh/authorized_keys_from_data2
    scp authorized_keys hadoop@data4:~/.ssh/authorized_keys_from_data2
    scp authorized_keys hadoop@data5:~/.ssh/authorized_keys_from_data2
    6.每台都关闭机器的防火墙
    #关闭防火墙
    sudo /etc/init.d/iptables stop
    #关闭开机启动
    sudo chkconfig iptables off
    7.jdk安装
    因为Hadoop是基于Java开发,所以我们需要安装jdk环境:
    cd /home/hadoop/software/
    上传rz jdk1.8.0_121.gz
    tar xvzf jdk1.8.0_121.gz
    然后修改下环境变量指定到这个jdk目录就算安装好了:
    vim /etc/profile
    export JAVA_HOME=/home/hadoop/software/jdk1.8.0_121
    source /etc/profile
    8.Hadoop安装
    Hadoop就是一个tar包放上去解压缩后再进行各个文件的配置。
    上传hadoop-2.6.0-cdh5.tar.gz到/home/hadoop/software/
    tar xvzf hadoop-2.6.0-cdh5.tar.gz
    mv hadoop-2.6.0-cdh5 hadoop2
    cd /home/hadoop/software/hadoop2/etc/hadoop

    vi hadoop-env.sh
    修改JAVA_HOME值(export JAVA_HOME=/home/hadoop/software/jdk1.8.0_121)
    vi yarn-env.sh
    修改JAVA_HOME值(export JAVA_HOME=/home/hadoop/software/jdk1.8.0_121)
    然后修改Hadoop的主从节点文件,slaves是从节点,masters是主节点。需要说明的是一个主节点也可以同时从节点。也就是说这个节点可以同时是NameNode节点和DataNode节点。
    vim slaves
    添加这5台机器的节点:
    data1
    data2
    data3
    data4
    data5
    vim masters
    添加两个NameNode节点:
    data1
    data2
    下面来修改Hadoop的配置文件:
    1)编辑core-site.xml文件
    core-site.xml文件用于定义系统级别的参数,如HDFS URL 、Hadoop的临时目录等。这个文件主要是修改fs.defaultFS节点,改成hdfs://ai,ai是双NameNodeHA的虚拟域名,再就是hadoop.tmp.dir这个节点也非常重要,如果不配置,Hadoop重启后可能会有问题。
    然后就是配置zookeeper的地址ha.zookeeper.quorum。


    fs.defaultFS
    hdfs://ai


    ha.zookeeper.quorum
    data1:2181,data2:2181,data3:2181,data4:2181,data5:2181


    dfs.cluster.administrators
    hadoop


    io.file.buffer.size
    131072


    hadoop.tmp.dir
    /home/hadoop/software/hadoop/tmp
    Abase for other temporary directories.


    hadoop.proxyuser.hduser.hosts



    hadoop.proxyuser.hduser.groups



    2)编辑hdfs-site.xml文件
    hdfs-site.xml文件用来配置名称节点和数据节点的存放位置、文件副本的个数、文件的读取权限等。
    dfs.nameservices设置双NameNodeHA的虚拟域名。
    dfs.ha.namenodes.ai指定两个节点名称。
    dfs.namenode.rpc-address.ai.nn1指定HDFS访问节点1。
    dfs.namenode.rpc-address.ai.nn2指定HDFS访问节点2。
    dfs.namenode.http-address.ai.nn1指定HDFS的Web访问节点1。
    dfs.namenode.http-address.ai.nn2指定HDFS的Web访问节点2。
    dfs.namenode.name.dir定义DFS的名称节点在本地文件系统的位置。
    dfs.datanode.data.dir定义DFS数据节点存储数据块时存储在本地文件系统的位置。
    dfs.replication缺省的块复制数量。
    dfs.webhdfs.enabled是否通过http协议读取hdfs文件,如果选是,则集群安全性较差。
    vim hdfs-site.xml


    dfs.nameservices
    ai


    dfs.ha.namenodes.ai
    nn1,nn2


    dfs.namenode.rpc-address.ai.nn1
    data1:9000


    dfs.namenode.rpc-address.ai.nn2
    data2:9000


    dfs.namenode.http-address.ai.nn1
    data1:50070


    dfs.namenode.http-address.ai.nn2
    data2:50070


    dfs.namenode.shared.edits.dir
    qjournal://data1:8485;data2:8485;data3:8485;data4:8485;data5:8485/aicluster


    dfs.client.failover.proxy.provider.ai
    org.apache.hadoop.hdfs.server.namenode.ha.ConfiguredFailoverProxyProvider


    dfs.ha.fencing.methods
    sshfence


    dfs.ha.fencing.ssh.private-key-files
    /home/hadoop/.ssh/id_rsa


    dfs.journalnode.edits.dir
    /home/hadoop/software/hadoop/journal/data


    dfs.ha.automatic-failover.enabled
    true


    dfs.namenode.name.dir
    file:/home/hadoop/software/hadoop/dfs/name


    dfs.datanode.data.dir
    file:/home/hadoop/software/hadoop/dfs/data


    dfs.replication
    3


    dfs.webhdfs.enabled
    true


    dfs.permissions
    true


    dfs.client.block.write.replace-datanode-on-failure.enable
    true


    dfs.client.block.write.replace-datanode-on-failure.policy
    NEVER


    dfs.datanode.max.xcievers
    4096


    dfs.datanode.balance.bandwidthPerSec
    104857600


    dfs.qjournal.write-txns.timeout.ms
    120000


    3)编辑mapred-site.xml文件
    主要是修改mapreduce.jobhistory.address和mapreduce.jobhistory.webapp.address两个节点,主要是配置历史服务器地址,通过历史服务器查看已经运行完的Mapreduce作业记录,比如用了多少个Map、用了多少个Reduce、作业提交时间、作业启动时间、作业完成时间等信息。默认情况下,Hadoop历史服务器是没有启动的,我们可以通过下面的命令来启动Hadoop历史服务器:
    $ sbin/mr-jobhistory-daemon.sh start historyserver
    这样我们就可以在相应机器的19888端口上打开历史服务器的WEB UI界面。可以查看已经运行完的作业情况。历史服务器可以单独在一台机器上启动,参数配置如下:
    vim mapred-site.xml


    mapreduce.framework.name
    yarn


    mapreduce.jobhistory.address
    data1:10020


    mapred.child.env
    LD_LIBRARY_PATH=/usr/lib64


    mapreduce.jobhistory.webapp.address
    data1:19888


    mapred.child.java.opts
    -Xmx3072m


    mapreduce.task.io.sort.mb
    1000


    mapreduce.jobtracker.expire.trackers.interval
    1600000


    mapreduce.tasktracker.healthchecker.script.timeout
    1500000


    mapreduce.task.timeout
    88800000


    mapreduce.map.memory.mb
    8192


    mapreduce.reduce.memory.mb
    8192


    mapreduce.reduce.java.opts
    -Xmx6144m


    4)编辑yarn-site.xml文件
    主要是对Yarn资源调度的配置,核心配置参数如下:
    yarn.resourcemanager.address
    参数解释:ResourceManager 对客户端暴露的地址。客户端通过该地址向RM提交应用程序,杀死应用程序等。
    默认值: y a r n . r e s o u r c e m a n a g e r . h o s t n a m e : 8032 y a r n . r e s o u r c e m a n a g e r . s c h e d u l e r . a d d r e s s 参 数 解 释 : R e s o u r c e M a n a g e r 对 A p p l i c a t i o n M a s t e r 暴 露 的 访 问 地 址 。 A p p l i c a t i o n M a s t e r 通 过 该 地 址 向 R M 申 请 资 源 、 释 放 资 源 等 。 默 认 值 : {yarn.resourcemanager.hostname}:8032 yarn.resourcemanager.scheduler.address 参数解释:ResourceManager 对ApplicationMaster暴露的访问地址。ApplicationMaster通过该地址向RM申请资源、释放资源等。 默认值: yarn.resourcemanager.hostname:8032yarn.resourcemanager.scheduler.addressResourceManagerApplicationMaster访ApplicationMasterRM{yarn.resourcemanager.hostname}:8030
    yarn.resourcemanager.resource-tracker.address
    参数解释:ResourceManager 对NodeManager暴露的地址.。NodeManager通过该地址向RM汇报心跳,领取任务等。
    默认值: y a r n . r e s o u r c e m a n a g e r . h o s t n a m e : 8031 y a r n . r e s o u r c e m a n a g e r . a d m i n . a d d r e s s 参 数 解 释 : R e s o u r c e M a n a g e r 对 管 理 员 暴 露 的 访 问 地 址 。 管 理 员 通 过 该 地 址 向 R M 发 送 管 理 命 令 等 。 默 认 值 : {yarn.resourcemanager.hostname}:8031 yarn.resourcemanager.admin.address 参数解释:ResourceManager 对管理员暴露的访问地址。管理员通过该地址向RM发送管理命令等。 默认值: yarn.resourcemanager.hostname:8031yarn.resourcemanager.admin.addressResourceManager访RM{yarn.resourcemanager.hostname}:8033
    yarn.resourcemanager.webapp.address
    参数解释:ResourceManager对外web ui地址。用户可通过该地址在浏览器中查看集群各类信息。
    默认值: y a r n . r e s o u r c e m a n a g e r . h o s t n a m e : 8088 y a r n . r e s o u r c e m a n a g e r . s c h e d u l e r . c l a s s 参 数 解 释 : 启 用 的 资 源 调 度 器 主 类 。 目 前 可 用 的 有 F I F O 、 C a p a c i t y S c h e d u l e r 和 F a i r S c h e d u l e r 。 默 认 值 : o r g . a p a c h e . h a d o o p . y a r n . s e r v e r . r e s o u r c e m a n a g e r . s c h e d u l e r . c a p a c i t y . C a p a c i t y S c h e d u l e r y a r n . r e s o u r c e m a n a g e r . r e s o u r c e − t r a c k e r . c l i e n t . t h r e a d − c o u n t 参 数 解 释 : 处 理 来 自 N o d e M a n a g e r 的 R P C 请 求 的 H a n d l e r 数 目 。 默 认 值 : 50 y a r n . r e s o u r c e m a n a g e r . s c h e d u l e r . c l i e n t . t h r e a d − c o u n t 参 数 解 释 : 处 理 来 自 A p p l i c a t i o n M a s t e r 的 R P C 请 求 的 H a n d l e r 数 目 。 默 认 值 : 50 y a r n . s c h e d u l e r . m i n i m u m − a l l o c a t i o n − m b / y a r n . s c h e d u l e r . m a x i m u m − a l l o c a t i o n − m b 参 数 解 释 : 单 个 可 申 请 的 最 小 / 最 大 内 存 资 源 量 。 比 如 设 置 为 1024 和 3072 , 则 运 行 M a p R e d c e 作 业 时 , 每 个 T a s k 最 少 可 申 请 1024 M B 内 存 , 最 多 可 申 请 3072 M B 内 存 。 默 认 值 : 1024 / 8192 y a r n . s c h e d u l e r . m i n i m u m − a l l o c a t i o n − v c o r e s / y a r n . s c h e d u l e r . m a x i m u m − a l l o c a t i o n − v c o r e s 参 数 解 释 : 单 个 可 申 请 的 最 小 / 最 大 虚 拟 C P U 个 数 。 比 如 设 置 为 1 和 4 , 则 运 行 M a p R e d u c e 作 业 时 , 每 个 T a s k 最 少 可 申 请 1 个 虚 拟 C P U , 最 多 可 申 请 4 个 虚 拟 C P U 。 什 么 是 虚 拟 C P U , 可 阅 读 我 的 这 篇 文 章 : “ Y A R N 资 源 调 度 器 剖 析 ” 。 默 认 值 : 1 / 32 y a r n . r e s o u r c e m a n a g e r . n o d e s . i n c l u d e − p a t h / y a r n . r e s o u r c e m a n a g e r . n o d e s . e x c l u d e − p a t h 参 数 解 释 : N o d e M a n a g e r 黑 白 名 单 。 如 果 发 现 若 干 个 N o d e M a n a g e r 存 在 问 题 , 比 如 故 障 率 很 高 , 任 务 运 行 失 败 率 高 , 则 可 以 将 之 加 入 黑 名 单 中 。 注 意 , 这 两 个 配 置 参 数 可 以 动 态 生 效 。 ( 调 用 一 个 r e f r e s h 命 令 即 可 ) 默 认 值 : “ ” y a r n . r e s o u r c e m a n a g e r . n o d e m a n a g e r s . h e a r t b e a t − i n t e r v a l − m s 参 数 解 释 : N o d e M a n a g e r 心 跳 间 隔 默 认 值 : 1000 ( 毫 秒 ) 一 般 需 要 修 改 的 地 方 在 下 面 的 配 置 中 加 粗 了 。 这 个 配 置 文 件 是 Y a r n 资 源 调 度 最 核 心 的 配 置 , 下 面 的 是 一 个 实 例 配 置 。 有 一 个 需 要 注 意 的 配 置 技 巧 , 分 配 的 内 存 和 C P U 一 定 要 配 套 , 需 要 根 据 你 的 服 务 器 的 情 况 , 计 算 最 小 分 配 内 存 , 分 配 C P U 等 。 这 个 如 果 计 算 不 好 的 话 , 可 能 会 造 成 H a d o o p 跑 任 务 资 源 分 配 的 时 候 , C P U 资 源 用 尽 了 , 但 内 存 还 剩 很 多 。 但 对 于 H a d o o p 来 讲 , 只 要 C P U 或 内 存 有 一 个 占 满 了 , 后 面 的 任 务 就 不 能 分 配 了 , 所 以 设 置 不 好 会 造 成 C P U 和 内 存 资 源 的 浪 费 。 另 外 一 个 需 要 注 意 的 地 方 y a r n . n o d e m a n a g e r . w e b a p p . a d d r e s s 节 点 复 制 到 每 台 H a d o o p 服 务 器 上 记 得 把 节 点 值 的 I P 地 址 改 成 本 机 。 这 个 地 方 忘 了 改 , 可 能 会 出 现 N o d e M a n a g e r 启 动 不 了 的 问 题 。 v i m y a r n − s i t e . x m l < c o n f i g u r a t i o n > < p r o p e r t y > < n a m e > y a r n . n o d e m a n a g e r . w e b a p p . a d d r e s s < / n a m e > < v a l u e > 172.172.0.11 : 8042 < / v a l u e > < / p r o p e r t y > < p r o p e r t y > < n a m e > y a r n . r e s o u r c e m a n a g e r . r e s o u r c e − t r a c k e r . a d d r e s s < / n a m e > < v a l u e > d a t a 1 : 8031 < / v a l u e > < / p r o p e r t y > < p r o p e r t y > < n a m e > y a r n . r e s o u r c e m a n a g e r . s c h e d u l e r . a d d r e s s < / n a m e > < v a l u e > d a t a 1 : 8030 < / v a l u e > < / p r o p e r t y > < p r o p e r t y > < n a m e > y a r n . r e s o u r c e m a n a g e r . s c h e d u l e r . c l a s s < / n a m e > < v a l u e > o r g . a p a c h e . h a d o o p . y a r n . s e r v e r . r e s o u r c e m a n a g e r . s c h e d u l e r . c a p a c i t y . C a p a c i t y S c h e d u l e r < / v a l u e > < / p r o p e r t y > < p r o p e r t y > < n a m e > y a r n . r e s o u r c e m a n a g e r . a d d r e s s < / n a m e > < v a l u e > d a t a 1 : 8032 < / v a l u e > < / p r o p e r t y > < p r o p e r t y > < n a m e > y a r n . n o d e m a n a g e r . l o c a l − d i r s < / n a m e > < v a l u e > {yarn.resourcemanager.hostname}:8088 yarn.resourcemanager.scheduler.class 参数解释:启用的资源调度器主类。目前可用的有FIFO、Capacity Scheduler和Fair Scheduler。 默认值: org.apache.hadoop.yarn.server.resourcemanager.scheduler.capacity.CapacityScheduler yarn.resourcemanager.resource-tracker.client.thread-count 参数解释:处理来自NodeManager的RPC请求的Handler数目。 默认值:50 yarn.resourcemanager.scheduler.client.thread-count 参数解释:处理来自ApplicationMaster的RPC请求的Handler数目。 默认值:50 yarn.scheduler.minimum-allocation-mb/ yarn.scheduler.maximum-allocation-mb 参数解释:单个可申请的最小/最大内存资源量。比如设置为1024和3072,则运行MapRedce作业时,每个Task最少可申请1024MB内存,最多可申请3072MB内存。 默认值:1024/8192 yarn.scheduler.minimum-allocation-vcores/yarn.scheduler.maximum-allocation-vcores 参数解释:单个可申请的最小/最大虚拟CPU个数。比如设置为1和4,则运行MapReduce作业时,每个Task最少可申请1个虚拟CPU,最多可申请4个虚拟CPU。什么是虚拟CPU,可阅读我的这篇文章:“YARN 资源调度器剖析”。 默认值:1/32 yarn.resourcemanager.nodes.include-path/yarn.resourcemanager.nodes.exclude-path 参数解释:NodeManager黑白名单。如果发现若干个NodeManager存在问题,比如故障率很高,任务运行失败率高,则可以将之加入黑名单中。注意,这两个配置参数可以动态生效。(调用一个refresh命令即可) 默认值:“” yarn.resourcemanager.nodemanagers.heartbeat-interval-ms 参数解释:NodeManager心跳间隔 默认值:1000(毫秒) 一般需要修改的地方在下面的配置中加粗了。这个配置文件是Yarn资源调度最核心的配置,下面的是一个实例配置。有一个需要注意的配置技巧,分配的内存和CPU一定要配套,需要根据你的服务器的情况,计算最小分配内存,分配CPU等。这个如果计算不好的话,可能会造成Hadoop跑任务资源分配的时候,CPU资源用尽了,但内存还剩很多。但对于Hadoop来讲,只要CPU或内存有一个占满了,后面的任务就不能分配了,所以设置不好会造成CPU和内存资源的浪费。 另外一个需要注意的地方yarn.nodemanager.webapp.address节点复制到每台Hadoop服务器上记得把节点值的IP地址改成本机。这个地方忘了改,可能会出现NodeManager启动不了的问题。 vim yarn-site.xml <configuration> <property> <name>yarn.nodemanager.webapp.address</name> <value>172.172.0.11:8042</value> </property> <property> <name>yarn.resourcemanager.resource-tracker.address</name> <value>data1:8031</value> </property> <property> <name>yarn.resourcemanager.scheduler.address</name> <value>data1:8030</value> </property> <property> <name>yarn.resourcemanager.scheduler.class</name> <value>org.apache.hadoop.yarn.server.resourcemanager.scheduler.capacity.CapacityScheduler</value> </property> <property> <name>yarn.resourcemanager.address</name> <value>data1:8032</value> </property> <property> <name>yarn.nodemanager.local-dirs</name> <value> yarn.resourcemanager.hostname:8088yarn.resourcemanager.scheduler.classFIFOCapacitySchedulerFairSchedulerorg.apache.hadoop.yarn.server.resourcemanager.scheduler.capacity.CapacityScheduleryarn.resourcemanager.resourcetracker.client.threadcountNodeManagerRPCHandler50yarn.resourcemanager.scheduler.client.threadcountApplicationMasterRPCHandler50yarn.scheduler.minimumallocationmb/yarn.scheduler.maximumallocationmb/10243072MapRedceTask1024MB3072MB1024/8192yarn.scheduler.minimumallocationvcores/yarn.scheduler.maximumallocationvcores/CPU14MapReduceTask1CPU4CPUCPUYARN1/32yarn.resourcemanager.nodes.includepath/yarn.resourcemanager.nodes.excludepathNodeManagerNodeManagerrefreshyarn.resourcemanager.nodemanagers.heartbeatintervalmsNodeManager1000YarnCPUCPUHadoopCPUHadoopCPUCPUyarn.nodemanager.webapp.addressHadoopIPNodeManagervimyarnsite.xml<configuration><property><name>yarn.nodemanager.webapp.address</name><value>172.172.0.11:8042</value></property><property><name>yarn.resourcemanager.resourcetracker.address</name><value>data1:8031</value></property><property><name>yarn.resourcemanager.scheduler.address</name><value>data1:8030</value></property><property><name>yarn.resourcemanager.scheduler.class</name><value>org.apache.hadoop.yarn.server.resourcemanager.scheduler.capacity.CapacityScheduler</value></property><property><name>yarn.resourcemanager.address</name><value>data1:8032</value></property><property><name>yarn.nodemanager.localdirs</name><value>{hadoop.tmp.dir}/nodemanager/local


    yarn.nodemanager.address
    0.0.0.0:8034


    yarn.nodemanager.remote-app-log-dir
    h a d o o p . t m p . d i r / n o d e m a n a g e r / r e m o t e < / v a l u e > < / p r o p e r t y > < p r o p e r t y > < n a m e > y a r n . n o d e m a n a g e r . l o g − d i r s < / n a m e > < v a l u e > {hadoop.tmp.dir}/nodemanager/remote</value> </property> <property> <name>yarn.nodemanager.log-dirs</name> <value> hadoop.tmp.dir/nodemanager/remote</value></property><property><name>yarn.nodemanager.logdirs</name><value>{hadoop.tmp.dir}/nodemanager/logs


    yarn.nodemanager.aux-services
    mapreduce_shuffle


    yarn.nodemanager.aux-services.mapreduce.shuffle.class
    org.apache.hadoop.mapred.ShuffleHandler


    mapred.job.queue.name
    ${user.name}


    yarn.nodemanager.resource.memory-mb
    116888


    yarn.scheduler.minimum-allocation-mb
    5120


    yarn.scheduler.maximum-allocation-mb
    36688


    yarn.scheduler.maximum-allocation-vcores
    8


    yarn.nodemanager.resource.cpu-vcores
    50


    yarn.scheduler.minimum-allocation-vcores
    2


    yarn.nm.liveness-monitor.expiry-interval-ms
    700000


    yarn.nodemanager.health-checker.interval-ms
    800000


    yarn.nm.liveness-monitor.expiry-interval-ms
    900000


    yarn.resourcemanager.container.liveness-monitor.interval-ms
    666000


    yarn.nodemanager.localizer.cache.cleanup.interval-ms
    688000


    5)编辑capacity-scheduler.xml文件
    在上面讲的yarn-site.xml 配置文件中,我们配置的调度器用的是容量调度器,就是这个节点指定的配置yarn.resourcemanager.scheduler.class,容量调度器是Hadoop默认的,另外还有公平调度器,我们可以分别讲一下,看看它们有什么区别。
    公平调度
    公平共享调度器的核心概念是,随着时间推移平均分配工作,这样每个作业都能平均地共享到资源。结果是只需较少时间执行的作业能够访问 CPU,那些需要更长时间执行的作业中结束得迟。这样的方式可以在 Hadoop 作业之间形成交互,而且可以让 Hadoop 集群对提交的多种类型作业作出更大的响应。公平调度器是由Facebook开发出来的。
    Hadoop的实现会创建一组池,将作业放在其中供调度器选择。每个池会分配一组共享以平衡池中作业的资源(更多的共享意味着作业执行所需的资源更多)。默认情况下,所有池的共享相等,但可以进行配置,根据作业类型提供更多或更少的共享。如果需要的话,还可以限制同时活动的作业数,以尽量减少拥堵,让工作及时完成。
    为了保证公平,每个用户被分配一个池。在这样的方式下,如果一个用户提交很多作业,那么他分配的集群资源与其他用户一样多(与他提交的工作数无关)。无论分配到池的共享有多少,如果系统未加载,那么作业收到的共享不会被使用(在可用作业之间分配)。
    调度器实现会追踪系统中每个作业的计算时间。调度器还会定期检查作业接收到的计算时间和在理想的调度器中应该收到的计算时间的差距。会使用该结果来确定任务的亏空。调度器作业接着会保证亏空最多的任务最先执行。
    在 mapred-site.xml 文件中配置公平共享。该文件会定义对公平共享调度器行为的管理。一个 XML 文件(即 mapred.fairscheduler.allocation.file 属性)定义了每个池的共享的分配。为了优化作业大小,您可以设置 mapread.fairscheduler.sizebasedweight 将共享分配给作业作为其大小的函数。还有一个类似的属性可以通过调整作业的权重让更小的作业在 5 分钟之后运行得更快 (mapred.fairscheduler.weightadjuster)。您还可以用很多其他的属性来调优节点上的工作负载(例如某个 TaskTracker 能管理的 maps 和 reduces 数目)并确定是否执行抢占。
    容量调度器
    容量调度器的原理与公平调度器有些相似,但也有一些区别。首先,容量调度是用于大型集群,它们有多个独立用户和目标应用程序。由于这个原因,容量调度能提供更大的控制和能力,提供用户之间最小容量保证并在用户之间共享多余的容量。容量调度是由 Yahoo! 开发出来的。
    在容量调度中,创建的是队列而不是池,每个队列的 map 和 reduce 插槽数都可以配置。每个队列都会分配一个保证容量(集群的总容量是每个队列容量之和)。
    队列处于监控之下;如果某个队列未使用分配的容量,那么这些多余的容量会被临时分配到其他队列中。由于队列可以表示一个人或大型组织,那么所有的可用容量都可以由其他用户重新分配使用。
    与公平调度另一个区别是可以调整队列中作业的优先级。一般来说,具有高优先级的作业访问资源比低优先级作业更快。Hadoop 路线图包含了对抢占的支持(临时替换出低优先级作业,让高优先级作业先执行),但该功能尚未实现。
    另一个区别是对队列进行严格的访问控制(假设队列绑定到一个人或组织)。这些访问控制是按照每个队列进行定义的。对于将作业提交到队列的能力和查看修改队列中作业的能力都有严格限制。
    可在多个 Hadoop 配置文件中配置容量调度器。队列是在 hadoop-site.xml 中定义,在 capacity-scheduler.xml 中配置。可以在 mapred-queue-acls.xml 中配置 ACL。单个的队列属性包括容量百分比(集群中所有的队列容量少于或等于 100)、最大容量(队列多余容量使用的限制)以及队列是否支持优先级。更重要的是,可以在运行时调整队列优先级,从而可以在集群使用过程中改变或避免中断的情况。
    我们的实例用的容量调度器,我们看下配置参数:
    mapred.capacity-scheduler.queue..capacity:
    设置调度器中各个queue的容量,这里指的是占用的集群的slots的百分比,需要注意的是,所有queue的该配置项加起来必须小于等于100,否则会导致JobTracker启动失败。
    mapred.capacity-scheduler.queue..maximum-capacity:
    设置调度器中各个queue最大可以占有的容量,默认为-1表示最大可以占有集群100%的资源,和设置为100的效果是一样的。
    mapred.capacity-scheduler.queue..minimum-user-limit-percent:
    当queue中多个用户出现slots竞争的时候,限制每个用户的slots资源的百分比。举个例子,当minimum-user-limit-percent设置为25%时候,如果queue中有多余4个用户同时提交job,那么调度器保证每个用户占有的slots不超过queue中slots数的25%,默认为100表示不对用户作限制。
    mapred.capacity-scheduler.queue..user-limit-factor:
    设置queue中用户可占用queue容量的系数,默认为1表示,queue中每个用户最多只能占有queue的容量(即mapred.capacity-scheduler.queue..capacity),因此,需要注意的是,如果queue中只有一个用户提交job,且希望用户在集群不繁忙时候可扩展到mapred.capacity-scheduler.queue..maximum-capacity指定的slots数,则必须相应调大user-limit-factor这个系数。
    mapred.capacity-scheduler.queue..supports-priority:
    设置调度器中各个queue是否支持job优先级,不用过多解释。
    mapred.capacity-scheduler.maximum-system-jobs:
    设置调度器中各个queue中合起来共计可初始化后并发执行的job数,需要注意的是,各个queue会按照自己占有集群slots资源的比例(即mapred.capacity-scheduler.queue..capacity)决定每个queue最多同时并发执行的job数!举个例子,假设maximum-system-jobs为20个,而queue1占集群10%资源,那么意味着queue1最多可同时并发运行2个job,如果碰巧是运行时间比较长的job的话,将直接导致其他新提交的job被JobTracker阻塞不能进行初始化!
    mapred.capacity-scheduler.queue..maximum-initialized-active-tasks:
    设置queue中所有并发运行job包含的task数的上限值,如果超过此限制,则新提交到该queue中的job会被排队缓存到磁盘上。
    mapred.capacity-scheduler.queue..maximum-initialized-active-tasks-per-user:
    设置queue中每个特定用户并发运行job包含的task数的上限值,如果超过此限制,则该用户新提交到该queue中的job会被排队缓存到磁盘上。
    mapred.capacity-scheduler.queue..init-accept-jobs-factor:
    设置每个queue中可容纳接收的job总数(maximum-system-jobs * queue-capacity)的系数,举个例子,如果maximum-system-jobs为20,queue-capacity为10%,init-accept-jobs-factor为10,则当queue中job总数达到10*(20*10%)=20时,新的job将被JobTracker拒绝提交。
    我们下面的配置实例是配置了hadoop和spark两个队列,hadoop队列分配了92%的资源,参见yarn.scheduler.capacity.root.hadoop.capacity配置,spark队列分配了8%的资源,参见yarn.scheduler.capacity.root.spark.capacity配置:
    vim capacity-scheduler.xml


    yarn.scheduler.capacity.maximum-applications
    10000


    yarn.scheduler.capacity.maximum-am-resource-percent
    0.1


    yarn.scheduler.capacity.resource-calculator
    org.apache.hadoop.yarn.util.resource.DominantResourceCalculator


    yarn.scheduler.capacity.node-locality-delay
    -1


    yarn.scheduler.capacity.root.queues
    hadoop,spark


    yarn.scheduler.capacity.root.hadoop.capacity
    92


    yarn.scheduler.capacity.root.hadoop.user-limit-factor
    1

    yarn.scheduler.capacity.root.hadoop.maximum-capacity
    -1

    yarn.scheduler.capacity.root.hadoop.state
    RUNNING

    yarn.scheduler.capacity.root.hadoop.acl_submit_applications
    hadoop


    yarn.scheduler.capacity.root.hadoop.acl_administer_queue
    hadoop hadoop



    yarn.scheduler.capacity.root.spark.capacity
    8


    yarn.scheduler.capacity.root.spark.user-limit-factor
    1


    yarn.scheduler.capacity.root.spark.maximum-capacity
    -1


    yarn.scheduler.capacity.root.spark.state
    RUNNING


    yarn.scheduler.capacity.root.spark.acl_submit_applications
    hadoop


    yarn.scheduler.capacity.root.spark.acl_administer_queue
    hadoop hadoop



    以上对Hadoop的配置文件都配好了,然把这台服务器Hadoop整个目录复制到其它机器上就可以了。记得有个地方需要修改下yarn-site.xml里yarn.nodemanager.webapp.address每台Hadoop服务器上把IP地址改成本机。这个地方忘了改,可能会出现NodeManager启动不了的问题。
    scp -r /home/hadoop/software/hadoop2 hadoop@data2:/home/hadoop/software/
    scp -r /home/hadoop/software/hadoop2 hadoop@data3:/home/hadoop/software/
    scp -r /home/hadoop/software/hadoop2 hadoop@data4:/home/hadoop/software/
    scp -r /home/hadoop/software/hadoop2 hadoop@data5:/home/hadoop/software/
    另外还有个地方需要优化下,默认情况下Hadoop跑多个reduce可能报错:
    Failed on local exception: java.io.IOException: Couldn’t set up IO streams; Host Details : local hos
    解决办法:集群所有节点增加如下配置
    #在文件中增加
    sudo vi /etc/security/limits.conf
    hadoop soft nproc 100000
    hadoop hard nproc 100000
    重启整个集群每个节点,重启Hadoop集群即可。
    到现在环境安装一些准备就绪,下面就开始对Hadoop的HDFS分布式文件系统格式化,就像我们买了新电脑磁盘需要格式化之后才能用一样。由于我们的实例采用的NameNodeHA双节点模式,它是依靠zookeeper来实现的,所有我们实现需要先安装好zookeeper才行。每台服务器上启动zookeeper服务:
    /home/hadoop/software/zookeeper-3.4.6/bin/zkServer.sh restart
    在NameNode1上data1服务器上初始化zookeeper:
    hdfs zkfc –formatZK
    分别在5台Hadoop集群上启动journalnode服务,执行命令
    hadoop-daemon.sh start journalnode
    在NameNode1上data1服务器上格式化HDFS:
    hdfs namenode -format
    然后启动这台机器上的NameNode节点服务:
    hadoop-daemon.sh start namenode
    在第二个NameNode上data2执行:
    hdfs namenode -bootstrapStandby
    hadoop-daemon.sh start namenode
    最后我们启动Hadoop集群:
    start-all.sh
    启动集群过程如下:
    This script is Deprecated. Instead use start-dfs.sh and start-yarn.sh
    Starting namenodes on [datanode1 datanode2]
    datanode2: starting namenode, logging to /home/hadoop/software/hadoop2/logs/hadoop-hadoop-namenode-datanode2.out
    datanode1: starting namenode, logging to /home/hadoop/software/hadoop2/logs/hadoop-hadoop-namenode-datanode1.out
    datanode2: Java HotSpot™ 64-Bit Server VM warning: UseCMSCompactAtFullCollection is deprecated and will likely be removed in a future release.
    datanode2: Java HotSpot™ 64-Bit Server VM warning: CMSFullGCsBeforeCompaction is deprecated and will likely be removed in a future release.
    datanode1: Java HotSpot™ 64-Bit Server VM warning: UseCMSCompactAtFullCollection is deprecated and will likely be removed in a future release.
    datanode1: Java HotSpot™ 64-Bit Server VM warning: CMSFullGCsBeforeCompaction is deprecated and will likely be removed in a future release.
    172.172.0.12: starting datanode, logging to /home/hadoop/software/hadoop2/logs/hadoop-hadoop-datanode-datanode2.out
    172.172.0.11: starting datanode, logging to /home/hadoop/software/hadoop2/logs/hadoop-hadoop-datanode-datanode1.out
    172.172.0.14: starting datanode, logging to /home/hadoop/software/hadoop2/logs/hadoop-hadoop-datanode-datanode4.out
    172.172.0.13: starting datanode, logging to /home/hadoop/software/hadoop2/logs/hadoop-hadoop-datanode-datanode3.out
    172.172.0.15: starting datanode, logging to /home/hadoop/software/hadoop2/logs/hadoop-hadoop-datanode-datanode5.out
    Starting journal nodes [172.172.0.11 172.172.0.12 172.172.0.13 172.172.0.14 172.172.0.15]
    172.172.0.14: starting journalnode, logging to /home/hadoop/software/hadoop2/logs/hadoop-hadoop-journalnode-datanode4.out
    172.172.0.11: starting journalnode, logging to /home/hadoop/software/hadoop2/logs/hadoop-hadoop-journalnode-datanode1.out
    172.172.0.13: starting journalnode, logging to /home/hadoop/software/hadoop2/logs/hadoop-hadoop-journalnode-datanode3.out
    172.172.0.15: starting journalnode, logging to /home/hadoop/software/hadoop2/logs/hadoop-hadoop-journalnode-datanode5.out
    172.172.0.12: starting journalnode, logging to /home/hadoop/software/hadoop2/logs/hadoop-hadoop-journalnode-datanode2.out
    Starting ZK Failover Controllers on NN hosts [datanode1 datanode2]
    datanode1: starting zkfc, logging to /home/hadoop/software/hadoop2/logs/hadoop-hadoop-zkfc-datanode1.out
    datanode2: starting zkfc, logging to /home/hadoop/software/hadoop2/logs/hadoop-hadoop-zkfc-datanode2.out
    starting yarn daemons
    starting resourcemanager, logging to /home/hadoop/software/hadoop2/logs/yarn-hadoop-resourcemanager-datanode1.out
    172.172.0.15: starting nodemanager, logging to /home/hadoop/software/hadoop2/logs/yarn-hadoop-nodemanager-datanode5.out
    172.172.0.14: starting nodemanager, logging to /home/hadoop/software/hadoop2/logs/yarn-hadoop-nodemanager-datanode4.out
    172.172.0.12: starting nodemanager, logging to /home/hadoop/software/hadoop2/logs/yarn-hadoop-nodemanager-datanode2.out
    172.172.0.13: starting nodemanager, logging to /home/hadoop/software/hadoop2/logs/yarn-hadoop-nodemanager-datanode3.out
    172.172.0.11: starting nodemanager, logging to /home/hadoop/software/hadoop2/logs/yarn-hadoop-nodemanager-datanode1.out
    如果是停止集群的话用这个命令stop-all.sh
    停止集群过程如下:
    This script is Deprecated. Instead use stop-dfs.sh and stop-yarn.sh
    Stopping namenodes on [datanode1 datanode2]
    datanode1: stopping namenode
    datanode2: stopping namenode
    172.172.0.12: stopping datanode
    172.172.0.11: stopping datanode
    172.172.0.15: stopping datanode
    172.172.0.13: stopping datanode
    172.172.0.14: stopping datanode
    Stopping journal nodes [172.172.0.11 172.172.0.12 172.172.0.13 172.172.0.14 172.172.0.15]
    172.172.0.11: stopping journalnode
    172.172.0.13: stopping journalnode
    172.172.0.12: stopping journalnode
    172.172.0.15: stopping journalnode
    172.172.0.14: stopping journalnode
    Stopping ZK Failover Controllers on NN hosts [datanode1 datanode2]
    datanode2: stopping zkfc
    datanode1: stopping zkfc
    stopping yarn daemons
    stopping resourcemanager
    172.172.0.13: stopping nodemanager
    172.172.0.12: stopping nodemanager
    172.172.0.15: stopping nodemanager
    172.172.0.14: stopping nodemanager
    172.172.0.11: stopping nodemanager
    no proxyserver to stop
    启动成功后每个节点上会看到对应Hadoop进程,NameNode1主节点上看到的进程如下:
    5504 ResourceManager
    4912 NameNode
    5235 JournalNode
    5028 DataNode
    5415 DFSZKFailoverController
    90 QuorumPeerMain
    5628 NodeManager
    ResourceManager就是Yarn资源调度的进程。NameNode是HDFS的NameNode主节点。
    JournalNode是JournalNode节点。DataNode是HDFS的DataNode从节点和数据节点。DFSZKFailoverController是Hadoop中HDFS NameNode HA实现的中心组件,它负责整体的故障转移控制等。它是一个守护进程,通main()方法启动,继承自ZKFailoverController。QuorumPeerMain是zookeeper的进程。NodeManager是Yarn在每台服务器上的节点管理器,是运行在单个节点上的代理,它管理Hadoop集群中单个计算节点,功能包括与ResourceManager保持通信,管理Container的生命周期、监控每个Container的资源使用(内存、CPU等)情况、追踪节点健康状况、管理日志和不同应用程序用到的附属服务等。
    NameNode2主节点2上的进程如下:
    27232 NameNode
    165 QuorumPeerMain
    27526 DFSZKFailoverController
    27408 JournalNode
    27313 DataNode
    27638 NodeManager
    会少很多进程,因为做主节点的HA,也会有一个NameNode进程,如果没有,说明这个节点的NameNode挂了,我们需要重启它。并需要查看挂掉的原因。
    下面是其中一台DataNode上的进程,没有NameNode进程了:
    114 QuorumPeerMain
    17415 JournalNode
    17320 DataNode
    17517 NodeManager
    除了我们能看到集群每个节点的进程,并且根据进程就能判断哪个集群节点是不是有问题。但不是很方便,需要每台服务器逐个来看。Hadoop提供了Web界面,非常方便查看集群的状况。一个是Yarn的Web界面,在ResourceManager进程在的哪台机器上访问,也就是Yarn的主进程,访问地址是http://namenodeip:8088/,端口是8088,当然这个是默认端,可以通过配置文件来改,不过一般不和其它端口冲突的话,是不需要的改的。看另一个是两个NameNode的Web界面,端口是50070,能非常方便查看HDFS集群状态,总空间、使用空间、剩余空间,每台服务器节点情况一目了然。访问地址是:http://namenodeip:50070/
    我们来看下这两个界面:
    Yarn的Web界面如图3.1所示:
    图3.1 Yarn的Web界面截图

    图3.1 Yarn的Web界面截图

    NameNode的Web界面如图3.2所示:
    图3.2 NameNode的Web界面截图

    图3.2 NameNode的Web界面截图

    三.Hadoop常用操作

    Hadoop操作命令主要分Hadoop集群启动维护、HDFS文件操作命令、Yarn资源调度相关命令,我们分别来讲一下。
    1.Hadoop集群启动维护
    #整体启动Hadoop集群:
    start-all.sh
    #整体停止Hadoop集群:
    stop-all.sh
    #单独启动namenode服务:
    hadoop-daemon.sh start namenode
    #单独启动datanode服务:
    hadoop-daemon.sh start datanode
    #在某台机器上单独启动nodemanager服务:
    yarn-daemon.sh start nodemanager
    #单独启动historyserver
    mr-jobhistory-daemon.sh start historyserver
    2.HDFS文件操作命令
    操作使用hadoop dfs或者 hadoop fs都可以,建了简化操作时间,建议使用hadoop fs。
    1)列出HDFS下的文件
    hadoop fs -ls /
    hadoop fs -ls /ods/kc/dim/ods_kc_dim_product_tab/
    2) 查看文件的尾部的记录
    hadoop fs -tail /ods/kc/dim/ods_kc_dim_product_tab/product.txt
    3)上传本地文件到hadoop的hdfs上
    hadoop fs -put product.txt /ods/kc/dim/ods_kc_dim_product_tab/
    4)把hadoop上的文件下载到本地系统中
    hadoop fs -get /ods/kc/dim/ods_kc_dim_product_tab/product.txt product.txt
    5)删除文件和删除目录
    hadoop fs -rm /ods/kc/dim/ods_kc_dim_product_tab/product.txt
    hadoop fs -rmr /ods/kc/dim/ods_kc_dim_product_tab/
    6)查看文件
    #谨慎使用,尤其当文件内容太长的话。
    hadoop fs -cat /ods/kc/dim/ods_kc_dim_product_tab/product.txt
    7)建立目录
    hadoop fs -mkdir /ods/kc/dim/ods_kc_dim_product_tab/(目录/目录名)
    只能一级一级的建目录,建完一级才能建下一级。如果-mkdir –p价格-p参数会自动把没有文件夹都创建上。
    8)本集群内复制文件
    hadoop fs -cp 源路径 路径
    9)跨集群对拷,适合做集群数据迁移使用
    hadoop distcp hdfs://master1/ods/ hdfs://master2/ods/
    10)通过Hadoop命令把多个文件的内容合并起来
    #hadoop fs -getmerge 位于hdfs中的原文件(里面有多个文件) 合并后的文件名(本地)
    例如:
    hadoop fs -getmerge /ods/kc/dim/ods_kc_dim_product_tab/* all.txt
    3.Yarn资源调度相关命令
    1)application
    使用语法:yarn application [options] #打印报告,申请和杀死任务
    -appStates #与-list一起使用,可根据输入的逗号分隔的应用程序状态列表来过滤应用程序。有效的应用程序状态可以是以下之一:ALL,NEW,NEW_SAVING,SUBMITTED,ACCEPTED,RUNNING,FINISHED,FAILED,KILLED
    -appTypes #与-list一起使用,可以根据输入的逗号分隔的应用程序类型列表来过滤应用程序。
    -list #列出RM中的应用程序。支持使用-appTypes来根据应用程序类型过滤应用程序,并支持使用-appStates来根据应用程序状态过滤应用程序。
    -kill #终止应用程序。
    -status #打印应用程序的状态。
    2)applicationattempt
    使用语法:yarn applicationattempt [options] #打印应用程序尝试的报告
    -help #帮助
    -list #获取到应用程序尝试的列表,其返回值ApplicationAttempt-Id 等于
    -status #打印应用程序尝试的状态。
    3)classpath
    使用语法:yarn classpath #打印需要得到Hadoop的jar和所需要的lib包路径
    4)container
    使用语法:yarn container [options] #打印container(s)的报告
    -help #帮助
    -list #应用程序尝试的Containers列表
    -status #打印Container的状态
    5)jar
    使用语法:yarn jar [mainClass] args… #运行jar文件,用户可以将写好的YARN代码打包成jar文件,用这个命令去运行它。
    6)logs
    使用语法:yarn logs -applicationId [options] #转存container的日志。
    -applicationId #指定应用程序ID,应用程序的ID可以在yarn.resourcemanager.webapp.address配置的路径查看(即:ID)
    -appOwner #应用的所有者(如果没有指定就是当前用户)应用程序的ID可以在yarn.resourcemanager.webapp.address配置的路径查看(即:User)
    -containerId #Container Id
    -help #帮助
    -nodeAddress #节点地址的格式:nodename:port (端口是配置文件中:yarn.nodemanager.webapp.address参数指定)
    7)node
    使用语法:yarn node [options] #打印节点报告
    -all #所有的节点,不管是什么状态的。
    -list #列出所有RUNNING状态的节点。支持-states选项过滤指定的状态,节点的状态包含:NEW,RUNNING,UNHEALTHY,DECOMMISSIONED,LOST,REBOOTED。支持–all显示所有的节点。
    -states #和-list配合使用,用逗号分隔节点状态,只显示这些状态的节点信息。
    -status #打印指定节点的状态。
    8)queue
    使用语法:yarn queue [options] #打印队列信息
    -help #帮助
    -status # 打印队列的状态
    9)daemonlog
    使用语法:
    yarn daemonlog -getlevel host:httpport
    yarn daemonlog -setlevel host:httpport
    -getlevel host:httpport #打印运行在host:port的守护进程的日志级别。这个命令内部会连接http://host:port/logLevel?log=
    -setlevel host:httpport #设置运行在host:port的守护进程的日志级别。这个命令内部会连接http://host:port/logLevel?log=
    10)nodemanager
    使用语法:yarn nodemanager #启动nodemanager
    11)proxyserver
    使用语法:yarn proxyserver #启动web proxy server
    12)resourcemanager
    使用语法:yarn resourcemanager [-format-state-store] #启动ResourceManager
    -format-state-store # RMStateStore的格式. 如果过去的应用程序不再需要,则清理RMStateStore, RMStateStore仅仅在ResourceManager没有运行的时候,才运行RMStateStore
    13)rmadmin
    使用语法: #运行Resourcemanager管理客户端
    yarn rmadmin [-refreshQueues]
    [-refreshNodes]
    [-refreshUserToGroupsMapping]
    [-refreshSuperUserGroupsConfiguration]
    [-refreshAdminAcls]
    [-refreshServiceAcl]
    [-getGroups [username]]
    [-transitionToActive [–forceactive] [–forcemanual] ]
    [-transitionToStandby [–forcemanual] ]
    [-failover [–forcefence] [–forceactive] ]
    [-getServiceState ]
    [-checkHealth ]
    [-help [cmd]]
    -refreshQueues #重载队列的ACL,状态和调度器特定的属性,ResourceManager将重载mapred-queues配置文件
    -refreshNodes #动态刷新dfs.hosts和dfs.hosts.exclude配置,无需重启NameNode。
    #dfs.hosts:列出了允许连入NameNode的datanode清单(IP或者机器名)
    #dfs.hosts.exclude:列出了禁止连入NameNode的datanode清单(IP或者机器名)
    #重新读取hosts和exclude文件,更新允许连到Namenode的或那些需要退出或入编的Datanode的集合。
    -refreshUserToGroupsMappings #刷新用户到组的映射。
    -refreshSuperUserGroupsConfiguration #刷新用户组的配置
    -refreshAdminAcls #刷新ResourceManager的ACL管理
    -refreshServiceAcl #ResourceManager重载服务级别的授权文件。
    -getGroups [username] #获取指定用户所属的组。
    -transitionToActive [–forceactive] [–forcemanual] #尝试将目标服务转为 Active 状态。如果使用了–forceactive选项,不需要核对非Active节点。如果采用了自动故障转移,这个命令不能使用。虽然你可以重写–forcemanual选项,你需要谨慎。
    -transitionToStandby [–forcemanual] #将服务转为 Standby 状态. 如果采用了自动故障转移,这个命令不能使用。虽然你可以重写–forcemanual选项,你需要谨慎。
    -failover [–forceactive] #启动从serviceId1 到 serviceId2的故障转移。如果使用了-forceactive选项,即使服务没有准备,也会尝试故障转移到目标服务。如果采用了自动故障转移,这个命令不能使用。
    -getServiceState #返回服务的状态。(注:ResourceManager不是HA的时候,时不能运行该命令的)
    -checkHealth #请求服务器执行健康检查,如果检查失败,RMAdmin将用一个非零标示退出。(注:ResourceManager不是HA的时候,时不能运行该命令的)
    -help [cmd] #显示指定命令的帮助,如果没有指定,则显示命令的帮助。
    14)scmadmin
    使用语法:yarn scmadmin [options] #运行共享缓存管理客户端
    -help #查看帮助
    -runCleanerTask #运行清理任务
    15)sharedcachemanager
    使用语法:yarn sharedcachemanager #启动共享缓存管理器
    16)timelineserver
    使用语法:yarn timelineserver #启动timelineserver。

    总结

    Hadoop平台搭建好了,里面本身是没有数据的,所以下一步的工作就是建设数据仓库,而数据库是以Hive为主流的。有关Hive的更多内容请点击下方链接阅读
    Hive数据仓库实战
    此文章有对应的配套视频,其它更多精彩文章请大家下载充电了么app,可获取千万免费好课和文章,配套新书教材请看陈敬雷新书:《分布式机器学习实战》(人工智能科学与技术丛书)

    【新书介绍】
    《分布式机器学习实战》(人工智能科学与技术丛书)【陈敬雷编著】【清华大学出版社】
    新书特色:深入浅出,逐步讲解分布式机器学习的框架及应用配套个性化推荐算法系统、人脸识别、对话机器人等实战项目

    【新书介绍视频】
    分布式机器学习实战(人工智能科学与技术丛书)新书【陈敬雷】
    视频特色:重点对新书进行介绍,最新前沿技术热点剖析,技术职业规划建议!听完此课你对人工智能领域将有一个崭新的技术视野!职业发展也将有更加清晰的认识!

    【精品课程】
    《分布式机器学习实战》大数据人工智能AI专家级精品课程

    【免费体验视频】:
    人工智能百万年薪成长路线/从Python到最新热点技术

    从Python编程零基础小白入门到人工智能高级实战系列课

    视频特色: 本系列专家级精品课有对应的配套书籍《分布式机器学习实战》,精品课和书籍可以互补式学习,彼此相互补充,大大提高了学习效率。本系列课和书籍是以分布式机器学习为主线,并对其依赖的大数据技术做了详细介绍,之后对目前主流的分布式机器学习框架和算法进行重点讲解,本系列课和书籍侧重实战,最后讲几个工业级的系统实战项目给大家。 课程核心内容有互联网公司大数据和人工智能那些事、大数据算法系统架构、大数据基础、Python编程、Java编程、Scala编程、Docker容器、Mahout分布式机器学习平台、Spark分布式机器学习平台、分布式深度学习框架和神经网络算法、自然语言处理算法、工业级完整系统实战(推荐算法系统实战、人脸识别实战、对话机器人实战)、就业/面试技巧/职业生涯规划/职业晋升指导等内容。

    【充电了么公司介绍】

    充电了么App是专注上班族职业培训充电学习的在线教育平台。

    专注工作职业技能提升和学习,提高工作效率,带来经济效益!今天你充电了么?

    充电了么官网
    http://www.chongdianleme.com/

    充电了么App官网下载地址
    https://a.app.qq.com/o/simple.jsp?pkgname=com.charged.app

    功能特色如下:

    【全行业职位】 - 专注职场上班族职业技能提升

    覆盖所有行业和职位,不管你是上班族,高管,还是创业都有你要学习的视频和文章。其中大数据智能AI、区块链、深度学习是互联网一线工业级的实战经验。

    除了专业技能学习,还有通用职场技能,比如企业管理、股权激励和设计、职业生涯规划、社交礼仪、沟通技巧、演讲技巧、开会技巧、发邮件技巧、工作压力如何放松、人脉关系等等,全方位提高你的专业水平和整体素质。

    【牛人课堂】 - 学习牛人的工作经验

    1.智能个性化引擎:

    海量视频课程,覆盖所有行业、所有职位,通过不同行业职位的技能词偏好挖掘分析,智能匹配你目前职位最感兴趣的技能学习课程。

    2.听课全网搜索

    输入关键词搜索海量视频课程,应有尽有,总有适合你的课程。

    3.听课播放详情

    视频播放详情,除了播放当前视频,更有相关视频课程和文章阅读,对某个技能知识点强化,让你轻松成为某个领域的资深专家。

    【精品阅读】 - 技能文章兴趣阅读

    1.个性化阅读引擎:

    千万级文章阅读,覆盖所有行业、所有职位,通过不同行业职位的技能词偏好挖掘分析,智能匹配你目前职位最感兴趣的技能学习文章。

    2.阅读全网搜索

    输入关键词搜索海量文章阅读,应有尽有,总有你感兴趣的技能学习文章。

    【机器人老师】 - 个人提升趣味学习

    基于搜索引擎和智能深度学习训练,为您打造更懂你的机器人老师,用自然语言和机器人老师聊天学习,寓教于乐,高效学习,快乐人生。

    【精短课程】 - 高效学习知识

    海量精短牛人课程,满足你的时间碎片化学习,快速提高某个技能知识点。

    展开全文
  • Hadoop大数据平台安装

    千次阅读 2019-05-09 23:21:31
    实验一:Hadoop大数据平台安装 16281002 杜永坤 1、实验目的 在大数据时代,存在很多开源的分布式数据采集、计算、存储技术,本实验将熟悉并搭建几种常用的大数据采集、处理分析技术环境。 《大数据技术》实验一...

    实验一:Hadoop大数据平台安装

    16281002 杜永坤

    1、实验目的

    在大数据时代,存在很多开源的分布式数据采集、计算、存储技术,本实验将熟悉并搭建几种常用的大数据采集、处理分析技术环境。
    《大数据技术》实验一需要在笔记本上搭建 Hadoop
    集群,实验报告根据教程对笔记本上创建虚拟机搭建 Hadoop
    集群的步骤进行了说明。包含所有需要安装的软件与服务的版本,安装路径,安装方法等。主要流程为:安装虚拟机管理程序,创建三台虚拟服务器,在三台虚拟服务器上搭建以
    Hadoop 集群为核心的大数据平台。

    在这里插入图片描述
    2、实验要求

    实验要求搭建的大数据平台以 Hadoop 为核心,HDFS、MySQL、HBase
    组成了存储系统,通过Kafka 实时接入数据,使用 Storm
    对数据进行实时分析,Map/Reduce 和 Spark 负责离线数据分析。Zookeeper
    负责为分布式应用程序协调服务。
    3、实验环境说明

    个人笔记本电脑,虚拟机Oracle VM VirtualBox
    5.1.26,CentOS-7-x86_64-Minimal-1810.ios,win10系统

    Oracle VM VirtualBox 5.1.26
    下载链接https://download.virtualbox.org/virtualbox/5.1.26/
    CentOS-7-x86_64-Minimal-1810.ios下载链接
    https://mirrors.aliyun.com/centos/7/isos/x86_64/
    个人笔记本电脑内存要求大于等于8GB,要同时开启三个虚拟机,对内存的性能要求比较高。本人使用win10系统,但是Oracle
    VM VirtualBox
    5.1.26有不同系统版本的,可以在其他系统上搭建,建议win10系统,更稳定。
    实验步骤还是根据教程进行,但是对教程上的有些步骤是比价笼统的,对于我们新手,还是有理解难度的,实验报告将教程笼统的部分进行细节化,这样更便于理解。每一安装步骤之后,进行测试后,均有测试结果的截图。

    4、准备实验环境

    4.1、安装Oracle VM VirtualBox 5.1.26

    根据操作提示进行默认安装即可,如果不想装在C盘,在安装时候进行修改安装路径即可。
    设置Oracle VM VirtualBox
    点击管理→全局设定→网络→ NAT网络 点击 添加图标 按钮 ,默认出现NatNetwork
    在这里插入图片描述
    然后双击NatNetwork,进行如下的设置,设置完点击OK即可
    在这里插入图片描述
    选择 仅主机 (Host-Only)网络 然后点击 添加图标 按钮
    ,如果弹出窗口,点击确定即可

    在这里插入图片描述
    *** 双击新建的网卡,进行如下设置:IPv4地址: 192.168.56.1->IPv4网络掩码:
    255.255.255.0->DHCP服务器 ->取消勾选“启用服务器” ->OK->点 OK保存 ***
    在这里插入图片描述
    在这里插入图片描述

    4.2、配置虚拟机硬件环境

    打开Oracle VM VirtualBox 5.1.26,点击 新建 进行新建虚拟机
    在这里插入图片描述
    要注意的就是 类型 选择 linux 版本选择red hat (64.bit)
    点击下一步,设置内存大小,建议设置2048Mb,也就是2Gb,这样下载安装包,或者安装软件的时候速度回大大加快。但是这就需要笔记本电脑的内存至少需要8Gb,最好是16Gb。
    在这里插入图片描述
    在这里插入图片描述
    下一步选择VHD(虚拟硬盘)然后选择动态分配
    在这里插入图片描述
    在这里插入图片描述
    然后设置虚拟机的位置,建议不要放到C盘,虚拟硬盘大小设置为8GB即可,点击文件夹图标即可选择虚拟机的路径:
    在这里插入图片描述
    在这里插入图片描述
    然后点击按钮 创建 即可
    创建成功后大概显示如下信息:
    在这里插入图片描述
    上面仅仅是搭建了虚拟机的硬件环境,下面要安装虚拟机

    4.3、安装虚拟机

    选中刚刚创建的cluster,点击 设置
    在这里插入图片描述
    图标→存储 ->没有盘片 ->右侧的
    光盘图标,选择下载好的CentOS-7-x86_64-Minimal-1810.iso

    在这里插入图片描述
    选择好镜像之后,点击OK即可,会显示如下信息:
    在这里插入图片描述
    再次点击 设置 图标 →网络 ->网卡 1->启用网络连接 ->连接方式
    ->NAT->界面名称 ->选择刚才 先建立的那块虚拟网卡 即可 ->网卡 2->启用网络连接
    ->连接方式 连接方式 ->仅主机 (Host-Only)网络 ->界面名称
    ->选择刚才后建立的那块虚拟网卡 -> OK。

    在这里插入图片描述
    在这里插入图片描述
    下面双击cluster 进入虚拟机装载程序 选择 Install CentOS 7
    在这里插入图片描述
    等待加载完毕之后进行如下设置:

    • English->continue。
      在这里插入图片描述
      在这里插入图片描述
    • DATE&TIME,Region选择 Asia,City选择 Shanghai,左上角 ,左上角 Done。
      在这里插入图片描述
    • INSTALLATION DESTINATION,点进去后直接左上角的 Done。
    • NETWORK & HOST NAME,两张网卡 右侧 都选择 ON,下面的 Host name改为
      cluster1
      ,然后进行左上角 Done。
      在这里插入图片描述
    • 选择右下角 选择右下角 选择右下角 Begin installation。
    • 进入安装界面后选择 root password 随意 。
    • 右侧 user creation,Full name 设置为 cluster1,密码随意,不要选择 make
      this user administrator。
    • 待下方进度条结束后,会有 reboot这个选项,点击重启 后,即可登陆。
    • 后续从 *** 2、配置虚拟机硬件环境*** 开始再做两台这样的虚拟机分别是
      cluster2和 cluster3即可。

    4.4、下载所需的安装包

    我将所有的安装包都放到了百度网盘里:

    链接:https://pan.baidu.com/s/1tak5_8D3JfreBZYwFCLPyA 提取码:lr3u
    所有的版本号都为教程的版本对应。
    在这里插入图片描述

    4.5、centos系统指令预习

    至此所有需要的环境都准备成功,下面就是CentOS系统上的操作,在下面的操作中,首先要有linux命令的基础,如果对linux命令不熟悉,建议遇到陌生的命令时,先去查看命令的功能,再执行命令。
    linux指令

    1、明确用户的概念
    在实验中使用了root用户,和hadoop,在cluster2上进行了mysql的用户创建。root用户是具有特权一类用户,在root用户下可以操作只有特权才能操作的指令,比如vi
    /etc/profile
    指令,这指令是进行编辑(如果不熟悉vi操作指令,建议先去熟悉vi操作,比如怎么输入,怎么查找,怎么保存退出)
    profile这个文件,这个文件是进行环境变量的设置,只有root特权才能对这个文件进行编辑保存操作,而其他用户只能有读取的权利,不能修改编辑。
    所以具有root权限的文件普通用户hadoop是操作不了的,所以在进行创建文件夹或则文件的时候,要看清是通过什么用户进行创建的。如果是root用户创建的文件,只有root特权才能进行写操作,如果没有操作好用户权限,在后面的操作会出现权限错误。
    切换用户:su 指令
    su root
    切换到root用户,但是要输入root用户的密码,也就是在进行root password
    操作时输入密码入安装界面后选择 root password 随意
    。输入成功后会出现如下的符号(这个 #符号就代表root用户,有root权限):
    在这里插入图片描述
    su hadoop
    切换到hadoop用户,切换成功后会出现如下的符号在这里插入图片描述
    $表示是普通用户
    所以在进行操作指令的时候看清指令前的符号,是否一致,如果不一致,建议直接通过
    su hadoop 或者su root 手动切换,不建议使用exit 命令
    2、熟悉基本的操作指令
    例如 tar 解压操作;
    cd 切换目录操作
    操作指令时,要看清指令操作的目录,比如操作流程中经常有 切换到/usr/local
    这个操作提示,就是要执行 cd /usr/local 切换成功后会出现下面的提示:
    在这里插入图片描述
    同理其他提示也要按照上面的指令进行切换目录。
    ls 查看当前目录文件
    yum install **** 安装软件包操作
    vi 编辑指令
    vi /etc/profile 会进入编辑文件界面,这个时候要输入 i 才能进行编辑
    在这里插入图片描述
    会出现INSERT提示,才能进行编辑
    编辑完成后,先按ESC键,然后键入英文字符 :
    ,会出现光标闪烁,在输入wq,回车,回到终端,wq的vi命令表示的是先保存再退出。
    cp 复制命令
    cp mysql-5.6.37-linux-glibc2.12-x86_64.tar.gz /usr/local/
    这个命令的意思是将mysql-5.6.37-linux-glibc2.12-x86_64.tar.gz压缩包复制到文件夹/usr/local/下,指令cp前,要确保当前目录存在mysql-5.6.37-linux-glibc2.12-x86_64.tar.gz这个压缩包,才回执行成功,否则会出现找不到文件或者路径的错误
    source /etc/profile
    这个指令要在执行vi /etc/profile 退出编辑之后,每执行一次vi
    /etc/profile,就要执行一次这个指令一次,而且要切换到hadoop用户中执行
    在这里插入图片描述
    上面最重要的指令就是cd
    指令,在教程中,如果出现这个指令,一定要执行,然后再进行后面的指令,不能先执行后面的指令,再回来执行cd指令,而且如果没有直接给出cd
    指令,而是要求切换到某目录,也要执行cd指令,比如:
    在这里插入图片描述
    提示:解压到/usr/local ,所以一定要先执行cd /usr/local/
    ,然后再进行后面的tar解压指令。否则后面就会出现错误。
    **** 最主要的还是要明白各个指令意义,然后再进行操作。****

    5、CentOS系统安装hadoop大数据环境

    上面的准备工作完成之后,下面就是进入CentOS系统开始hadoop大数据环境的平台搭建

    5.1关闭防火墙和selinux

    本实验采用的阿里镜像网站的CentOS镜像,不是最小版,所以要将防火墙和selinux进行关闭,防止防火墙阻止某些操作。下面的操作cluster1cluster2cluster3都要进行执行:

    // 关闭防火墙和 关闭防火墙和 关闭防火墙和 selinux
              # systemctl stop firewalld.service
    // 禁止 firewall 开机启动 开机启动
              # systemctl disable firewalld.service
    // 开机关闭 开机关闭 Selinux,编辑 ,编辑 Selinux配置文件 配置文件 配置文件
              # vi /etc/selinux/config
    //将 SELINUX设置为 设置为 disabled
    //如下 :
    //SELINUX=disabled
    // 重启
              # reboot
    // 重启机器后 重启机器后 root用户查看 用户查看 用户查看 Selinux状态
              # getenforce
    //执行getenforce结束之后会出现 Disabled 表示Selinux关闭成功。
    

    5.2安装软件

    以下软件是安装 时需要的依赖环境,MySQL时需要使用 perl和
    libaio,ntpdate负责集群内服务器时间, screen用于新建后台任务。 每台都要执行

              # yum install perl*
              # yum install ntpdate
              # yum install libaio
              # yum install screen
    

    5.3检查网卡是否开机自启

    每台都要执行
    // 查看网卡名,看里面一个 enp0s
    开头的是多少,由于我们开启了两块网卡,注意这两张都是什么名字
    // 我的网卡名分别是 enp0s3 和 enp0s8,还有一个 lo,这个可以忽略不计。
    # ip addr
    在这里插入图片描述
    使用这条命令可以查看所有网卡的信息,注意记录每张网卡的网卡名:前面序号后面的即为网卡名。还需记录每张网卡的
    ip 地址,inet 后面的就是。
    注意:此处有两张网卡,分别是 2:enp0s3 和
    3:enp0s8,如果没有,可能是因为在安装系统的过程中,没有打开网络服务,或是网卡没有设定为开机自启。
    接下来编辑网卡配置文件
    编辑的第一个网卡的配置文件,应该是 ip 为 10.0.2 开头的那张网卡,网卡名为 enp0s3
    // 编辑网卡配置文件
    # vi /etc/sysconfig/network-scripts/ifcfg-enp0s3
    // 确认 ONBOOT 为 yes,这个设置为 yes 后,该网卡会开机自启,不会开机连不上网
    ONBOOT=yes
    接下来编辑第二张网卡的配置文件,是 enp0s8
    # vi /etc/sysconfig/network-scripts/ifcfg-enp0s8
    将 BOOTPROTO 设置为 none ONBOOT=yes
    新增 IPADDR=192.168.56.121(cluster2 设置为 192.168.56.122,cluster3 为
    192.168.56.123)
    NETMASK=255.255.255.0 NETWORK=192.168.56.0
    保存后关闭文件。
    // 重启网络服务
    # service network restart
    重启成功后会出现一个绿色的 OK,失败则显示红色的 failed,若失败,则使用 reboot
    重启服务器即可。重启后,就可以使用 putty 或其他 SSH 工具连接虚拟机了。
    以下以 putty 为例:
    在 windows 中,下载 putty,打开后,输入
    192.168.56.121,对应cluster1,想要连接cluster2,3进行ip地址的变换即可。
    在这里插入图片描述
    然后点击右下角的 Open,即可连接到 cluster1 上。连接上后:
    输入root:
    在这里插入图片描述
    然后再输入密码,即可进入CentOS系统的终端:
    在这里插入图片描述
    由于CentOS是终端操作,没有用户界面,所以我们要传输文件时可以使用
    winSCP文件传输软件,将安装包上传到系统中。
    在这里插入图片描述
    主机名为:192.168.56.121,用户名为 root,端口号为22,快速连接即可。
    连接上,可以看到本地文件,和虚拟机的文件,可以选中本地文件将需要的文件拖曳到虚拟机部分,即可上传。
    在这里插入图片描述

    5.4修改 hosts

    每台都要执行
    // 记录当前 ip 地址,要记录第一张网卡的 ip 地址
    # ip addr
    // 修改 hosts
    # vi /etc/hosts
    // 在最下面添加以下几行内容,下面的红色的 ip 地址写你用 ip addr
    里面显示的第一张网卡(enp0s3)的 ip

    10.0.2.5 cluster1
    10.0.2.6 cluster2
    10.0.2.7 cluster3
    在这里插入图片描述在这里插入图片描述

    5.6检查网络是否正常

    // 在 cluster1 上
    // 检查能否连接到 cluster2,3
    # ping cluster2
    # ping cluster3
    如果出现如下界面:
    在这里插入图片描述
    可以看到 time=多少秒,说明可以从 cluster1 连接到 cluster2,同理,检查能否连接到
    cluster3,使用 Ctrl+C
    同理可以在cluster2上ping另外两台虚拟机的ip地址
    在这里插入图片描述

    5.6新建 hadoop 用户

    每台都要执行
    新建 hadoop 用户,这个用户专门用来维护集群,因为实际中使用 root
    用户的机会很少,而且不安全。
    // 新建 hadoop 组
    # groupadd hadoop
    // 新建 hadoop 用户
    # useradd -s /bin/bash -g hadoop -d /home/hadoop -m hadoop
    // 修改 hadoop 这个用户的密码
    # passwd hadoop

    5.7生成 ssh 密钥并分发

    只在 cluster1 上执行
    // 生成 ssh 密钥(cluster1 上),切换到 hadoop 用户
    $ ssh-keygen -t rsa
    然后一路回车
    // 接下来分发密钥,请仔细观察显示的内容,会让你输入 yes
    $ ssh-copy-id cluster1
    $ ssh-copy-id cluster2
    $ ssh-copy-id cluster3

    5.8安装 NTP 服务

    // 三台都要安装
    # yum install ntpdate
    // cluster1 上装 ntp
    # yum install ntp
    // cluster1 上执行以下操作
    # vi /etc/ntp.conf
    注释掉以下 4 行,也就是在这 4 行前面加
    # server 0.centos.pool.ntp.org iburst
    #server 1.centos.pool.ntp.org iburst
    #server 2.centos.pool.ntp.org iburst
    #server 3.centos.pool.ntp.org iburst
    最下面加入以下内容,红色部分分别为网关和掩码
    restrict default ignore
    restrict 10.0.2.0 mask 255.255.255.0 nomodify notrap
    server 127.127.1.0
    // 重启 ntp 服务
    # service ntpd restart
    // 设置 ntp 服务器开机自动启动
    # chkconfig ntpd on
    // crontab是自启动服务, 以下为客户端的配置(除 cluster1 外其他所有的机器,即
    cluster2 和 cluster3):下面内容表示:设定每天 00:00
    向服务器同步时间,并写入日志
    如果没有安装crontab

    # yum install crontabs //安装
    # systemctl enable crond //设置开机启动crond服务
    # systemctl start crond //启动crond服务
    # crontab -e //编写
    # crontab -e
    输入以下内容后保存并退出:
    0 0 * * * /usr/sbin/ntpdate cluster1>> /root/ntpd.log
    在这里插入图片描述
    //重启
    # systemctl restart crond
    // 如果不是使用上面的服务,就要手动同步时间,需要在每台机器上(除 cluster1
    外其他所有的机器,即 cluster2 和 cluster3),使用 ntpdate cluster1 同步时间
    # ntpdate cluster1

    5.8安装 MySQL

    MySQL 是最流行的关系型数据库管理系统,在 WEB 应用方面 MySQL 是最好的
    RDBMS(Relational Database Management System:关系数据库管理系统)应用软件之一。
    MySQL 为关系型数据库(Relational Database Management System),
    这种所谓的"关系型"可以理解为"表格"的概念, 一个关系型数据库由一个或数个表格组成,
    如图所示的一个表格:
    在这里插入图片描述

    • 表头(header): 每一列的名称;
    • 列(col): 具有相同数据类型的数据的集合;
    • 行(row): 每一行用来描述某条记录的具体信息;
    • 值(value): 行的具体信息, 每个值必须与该列的数据类型相同;
    • 键(key): 键的值在当前列中具有唯一性。
      MySQL
      是一种关联数据库管理系统,关联数据库将数据保存在不同的表中,而不是将所有数据放在一个大仓库内,这样就增加了速度并提高了灵活性。
    • MySQL 支持大型的数据库。可以处理拥有上千万条记录的大型数据库。
    • MySQL 使用标准的 SQL 数据语言形式。
    • MySQL 可以运行于多个系统上,并且支持多种语言。这些编程语言包括
      C、C++、Python、Java、Perl、PHP、Eiffel、Ruby 和 Tcl 等。
    • MySQL 对PHP有很好的支持,PHP 是目前最流行的 Web 开发语言。
    • MySQL 支持大型数据库,支持 5000 万条记录的数据仓库,32
      位系统表文件最大可支持 4GB,64 位系统支持最大的表文件为8TB。
    • MySQL 是可以定制的,采用了 GPL 协议,你可以修改源码来开发自己的 MySQL 系统。

    5.8.1安装

    只在 cluster2 上做以下内容,因为我们的集群中,只有 cluster2 上需要安装一个 MySQL
    # yum remove mysql mysql-server mysql-libs compat-mysql51
    # rm -rf /var/lib/mysql
    # rm -rf /etc/my.cnf
    下载 mysql-5.6.37-linux-glibc2.12-x86_64
    # cp mysql-5.6.37-linux-glibc2.12-x86_64.tar.gz /usr/local/
    // 解压到/usr/local/
    # tar -zxvf mysql-5.6.37-linux-glibc2.12-x86_64.tar.gz
    // 改名为 mysql
    # mv mysql-5.6.37-linux-glibc2.12-x86_64 mysql
    // 删除安装包
    # rm mysql-5.6.37-linux-glibc2.12-x86_64.tar.gz
    // 修改环境变量
    # vi /etc/profile
    在最下面添加
    export MYSQL_HOME=/usr/local/mysql
    export PATH=$MYSQL_HOME/bin:$PATH
    // 刷新环境变量
    # source /etc/profile
    // 新建 mysql 用户
    # groupadd mysql 在/etc/group 中可以看到
    # useradd -r -g mysql -s /bin/false mysql 在/etc/passwd 中可以看到
    # cd /usr/local/mysql
    # chown -R mysql:mysql .
    # scripts/mysql_install_db --user=mysql
    // 修改当前目录拥有者为 root 用户
    # chown -R root .
    // 修改当前 data 目录拥有者为 mysql 用户
    # chown -R mysql data
    # bin/mysqld_safe --user=mysql &
    # cd /usr/local/mysql
    // 登陆 mysql
    # bin/mysql
    // 登陆成功后退出即可
    mysql> exit;
    // 进行 root 账户密码的修改等操作
    # bin/mysql_secure_installation
    首先要求输入 root 密码,由于我们没有设置过 root 密码,括号里面说了,如果没有
    root 密码就直接按回车。是否设定 root 密码,选 y,设定密码为
    cluster,是否移除匿名用户:y。然后有个是否关闭 root 账户的远程登录,选 n,删除
    test 这个数据库?y,更新权限?y,然后 ok。
    # cp support-files/mysql.server /etc/init.d/mysql.server
    // 查看 mysql 的进程号
    # ps -ef | grep mysql
    // 如果有的话就 kill 掉,保证 mysql 已经中断运行了,一般 kill
    掉/usr/local/mysql/bin/mysqld 开头的即可
    # kill 进程号
    // 启动 mysql
    # /etc/init.d/mysql.server start -user=mysql
    # exit
    还需要配置一下访问权限:
    $ mysql -u root -p
    mysql> GRANT ALL PRIVILEGES ON *.* TO ‘root’@’%’ IDENTIFIED BY ‘cluster’
    WITH GRANT OPTION; mysql> FLUSH PRIVILEGES;
    // 关闭 mysql 的指令(不需要执行)
    # mysqladmin -u root -p shutdown

    5.8.1测试

    mysql> create database test_table; mysql> use test_table;
    mysql> create table userinfo(id int not null); mysql> insert into userinfo
    values(1); mysql> select * from userinfo;
    mysql> drop database test_table; mysql> show databases;
    如果mysql关闭后想要在此启动,需要进行如下操作:
    在这里插入图片描述
    \# /etc/init.d/mysql.server start -user=mysql
    # su root
    $ mysql -u root -p
    这样才能正常启动mysql。

    5.8安装 JDK

    5.8.1安装

    每台都要安装
    $ su root
    # cp jdk-7u80-linux-x64.tar.gz /usr/local/
    # tar -zxvf jdk-7u80-linux-x64.tar.gz
    // 修改环境变量
    # vi /etc/profile
    // 添加以下内容
    export JAVA_HOME=/usr/local/jdk1.7.0_80/
    export JRE_HOME=/usr/local/jdk1.7.0_80/jre
    export CLASSPATH=.:$JAVA_HOME/lib:$JRE_HOME/lib:$CLASSPATH
    export PATH=$JAVA_HOME/bin:$JRE_HOME/bin:$JAVA_HOME:$PATH
    // 复制 jdk 到其他的服务器上
    # scp -r /usr/local/jdk1.7.0_80/ cluster2:/usr/local/
    # scp -r /usr/local/jdk1.7.0_80/ cluster3:/usr/local/
    // cluster2 上
    # vi /etc/profile
    // 添加以下内容
    export JAVA_HOME=/usr/local/jdk1.7.0_80/
    export JRE_HOME=/usr/local/jdk1.7.0_80/jre
    export CLASSPATH=.:$JAVA_HOME/lib:$JRE_HOME/lib:$CLASSPATH
    export PATH=$JAVA_HOME/bin:$JRE_HOME/bin:$JAVA_HOME:$PATH
    // cluster3 上
    # vi /etc/profile
    // 添加以下内容
    export JAVA_HOME=/usr/local/jdk1.7.0_80/
    export JRE_HOME=/usr/local//jdk1.7.0_80/jre
    export CLASSPATH=.:$JAVA_HOME/lib:$JRE_HOME/lib:$CLASSPATH
    export PATH=$JAVA_HOME/bin:$JRE_HOME/bin:$JAVA_HOME:$PATH
    //然后再每台机器上更新配置文件
    $ source /etc/profile

    5.8.2测试

    $ java -version
    可以看到 java 版本为 1.7.0_80 即为安装成功
    在这里插入图片描述

    5.9安装 ZooKeeper

    ZooKeeper是一种分布式协调服务,用于管理大型主机。在分布式环境中协调和管理服务是一个复杂的过程。ZooKeeper通过其简单的架构和API解决了这个问题。ZooKeeper允许开发人员专注于核心应用程序逻辑,而不必担心应用程序的分布式特性。
    ZooKeeper框架最初是在“Yahoo!"上构建的,用于以简单而稳健的方式访问他们的应用程序。
    后来,Apache ZooKeeper成为Hadoop,HBase和其他分布式框架使用的有组织服务的标准。
    例如,Apache HBase使用ZooKeeper跟踪分布式数据的状态。
    在进一步深入之前,我们了解关于分布式应用的一两件事情是很重要的。因此,让我们开始分布式应用的概述的快速讨论。
    分布式应用
    分布式应用可以在给定时间(同时)在网络中的多个系统上运行,通过协调它们以快速有效的方式完成特定任务。通常来说,对于复杂而耗时的任务,非分布式应用(运行在单个系统中)需要几个小时才能完成,而分布式应用通过使用所有系统涉及的计算能力可以在几分钟内完成。
    通过将分布式应用配置为在更多系统上运行,可以进一步减少完成任务的时间。分布式应用正在运行的一组系统称为集群,而在集群中运行的每台机器被称为节点
    分布式应用有两部分, Server(服务器) 和 Client(客户端)
    应用程序。服务器应用程序实际上是分布式的,并具有通用接口,以便客户端可以连接到集群中的任何服务器并获得相同的结果。
    客户端应用程序是与分布式应用进行交互的工具。
    分布式应用的优点
    可靠性 - 单个或几个系统的故障不会使整个系统出现故障。
    可扩展性 -
    可以在需要时增加性能,通过添加更多机器,在应用程序配置中进行微小的更改,而不会有停机时间。
    透明性 - 隐藏系统的复杂性,并将其显示为单个实体/应用程序。
    什么是Apache ZooKeeper?
    Apache
    ZooKeeper是由集群(节点组)使用的一种服务,用于在自身之间协调,并通过稳健的同步技术维护共享数据。ZooKeeper本身是一个分布式应用程序,为写入分布式应用程序提供服务。
    ZooKeeper提供的常见服务如下 :

    • 命名服务 - 按名称标识集群中的节点。它类似于DNS,但仅对于节点。
    • 配置管理 - 加入节点的最近的和最新的系统配置信息。
    • 集群管理 - 实时地在集群和节点状态中加入/离开节点。
    • 选举算法 - 选举一个节点作为协调目的的leader。
    • 锁定和同步服务 -
      在修改数据的同时锁定数据。此机制可帮助你在连接其他分布式应用程序(如Apache
      HBase)时进行自动故障恢复。
    • 高度可靠的数据注册表 - 即使在一个或几个节点关闭时也可以获得数据。
      分布式应用程序提供了很多好处,但它们也抛出了一些复杂和难以解决的挑战。ZooKeeper框架提供了一个完整的机制来克服所有的挑战。竞争条件和死锁使用故障安全同步方法进行处理。另一个主要缺点是数据的不一致性,ZooKeeper使用原子性解析。
      以下是使用ZooKeeper的好处:
    • 简单的分布式协调过程
    • 同步 - 服务器进程之间的相互排斥和协作。此过程有助于Apache
      HBase进行配置管理。
    • 有序的消息
    • 序列化 -
      根据特定规则对数据进行编码。确保应用程序运行一致。这种方法可以在MapReduce中用来协调队列以执行运行的线程。
    • 可靠性
    • 原子性 - 数据转移完全成功或完全失败,但没有事务是部分的。
      每台都要安装

    5.9.1 cluster1

    // cluster1 上
    将 zookeeper 解压到/usr/local 目录下,配置环境变量
    # vi /etc/profile
    // 添加以下内容
    export ZOOKEEPER_HOME=/usr/local/zookeeper-3.4.6
    export PATH=$ZOOKEEPER_HOME/bin:$PATH
    # cd /usr/local/zookeeper-3.4.6
    // 在 conf 中新建 zoo.cfg 文件
    # vi conf/zoo.cfg
    // 输入以下内容
    # 客户端心跳时间(毫秒)
    tickTime=2000
    # 允许心跳间隔的最大时间
    initLimit=10
    # 同步时限
    syncLimit=5
    # 数据存储目录
    dataDir=/home/hadoop_files/hadoop_data/zookeeper
    # 数据日志存储目录
    dataLogDir=/home/hadoop_files/hadoop_logs/zookeeper/dataLog
    # 端口号
    clientPort=2181
    # 集群节点和服务端口配置
    server.1=cluster1:2888:3888 server.2=cluster2:2888:3888
    server.3=cluster3:2888:3888
    // 创建 zookeeper 的数据存储目录和日志存储目录
    # mkdir -p /home/hadoop_files/hadoop_data/zookeeper
    # mkdir -p /home/hadoop_files/hadoop_logs/zookeeper/dataLog
    # mkdir -p /home/hadoop_files/hadoop_logs/zookeeper/logs
    // 修改文件夹的权限
    # chown -R hadoop:hadoop /home/hadoop_files
    # chown -R hadoop:hadoop /usr/local/zookeeper-3.4.6
    // 在 cluster1 号服务器的 data 目录中创建一个文件 myid,输入内容为 1
    // myid 应与 zoo.cfg 中的集群节点相匹配
    # echo “1” >> /home/hadoop_files/hadoop_data/zookeeper/myid
    // 修改 zookeeper 的日志输出路径(注意 CDH 版与原生版配置文件不同)
    # vi bin/zkEnv.sh
    // 将配置文件里面的以下项替换为红字的内容

    if [ “x${ZOO_LOG_DIR}” = “x” ]
    then
    ZOO_LOG_DIR="/home/hadoop_files/hadoop_logs/zookeeper/logs"
    fi
    if [ “x${ZOO_LOG4J_PROP}” = “x” ]
    then
    ZOO_LOG4J_PROP=“INFO,ROLLINGFILE”
    fi
    // 修改 zookeeper 的日志配置文件
    # vi conf/log4j.properties
    // 修改为以下内容:
    zookeeper.root.logger=INFO,ROLLINGFILE
    log4j.appender.ROLLINGFILE=org.apache.log4j.DailyRollingFileAppender
    将这个 zookeeper-3.4.6 的目录复制到其他的两个节点上
    # scp -r /usr/local/zookeeper-3.4.6 cluster2:/usr/local/
    # scp -r /usr/local/zookeeper-3.4.6 cluster3:/usr/local/
    // 退回 hadoop 用户
    # exit
    // 刷新环境变量
    $ source /etc/profile
    // 启动 zookeeper
    $ zkServer.sh start

    5.9.2 cluster2

    // cluster2 上面 改环境变量,加入以下内容
    export ZOOKEEPER_HOME=/usr/local/zookeeper-3.4.6
    export PATH=$ZOOKEEPER_HOME/bin:$PATH
    // 创建 zookeeper 的数据存储目录和日志存储目录
    $ su root
    # mkdir -p /home/hadoop_files/hadoop_data/zookeeper
    # mkdir -p /home/hadoop_files/hadoop_logs/zookeeper/dataLog
    # mkdir -p /home/hadoop_files/hadoop_logs/zookeeper/logs
    // 添加 myid
    # echo “2” >> /home/hadoop_files/hadoop_data/zookeeper/myid
    // 修改文件夹的权限
    # chown -R hadoop:hadoop /home/hadoop_files
    # chown -R hadoop:hadoop /usr/local/zookeeper-3.4.6
    // 退回 hadoop 用户
    # exit
    // 刷新环境变量
    $ source /etc/profile
    // 启动 zookeeper
    $ zkServer.sh start

    5.9.3cluster3

    // cluster3 上面 加环境变量
    # vi /etc/profile
    export ZOOKEEPER_HOME=/usr/local/zookeeper-3.4.6
    export PATH=$ZOOKEEPER_HOME/bin:$PATH
    // 创建 zookeeper 的数据存储目录和日志存储目录
    # mkdir -p /home/hadoop_files/hadoop_data/zookeeper
    # mkdir -p /home/hadoop_files/hadoop_logs/zookeeper/dataLog
    # mkdir -p /home/hadoop_files/hadoop_logs/zookeeper/logs
    // 添加 myid
    # echo “3” >> /home/hadoop_files/hadoop_data/zookeeper/myid
    // 修改文件夹的权限
    # chown -R hadoop:hadoop /home/hadoop_files
    # chown -R hadoop:hadoop /usr/local/zookeeper-3.4.6
    // 退回 hadoop 用户
    # exit
    // 刷新环境变量
    $ source /etc/profile
    // 启动 zookeeper(每台都要执行,而且三台要接连执行,都启动后再做下面的)
    $ zkServer.sh start

    5.9.4测试

    // 三台 zookeeper 都启动后,使用 jps 命令查看进程是否启动
    在这里插入图片描述
    # jps
    可以看到一个叫 QuorumPeerMain 的进程,说明 zookeeper 启动成功
    在这里插入图片描述
    // 退出 root 用户
    # exit
    // 查看 zookeeper 状态
    $ zkServer.sh status
    可以看到三台中有一个是 leader,两个是 follower
    在这里插入图片描述
    // 关闭 zookeeper 的命令 (关机前在每台上都要执行,这里不需要执行)
    $ zkServer.sh stop

    5.10安装 Kafka

    Apache Kafka® 是 一个分布式流处理平台. 这到底意味着什么呢?
    我们知道流处理平台有以下三种特性:
    可以让发布和订阅流式的记录。这一方面与消息队列或者企业消息系统类似。
    可以储存流式的记录,并且有较好的容错性。
    可以在流式记录产生时就进行处理。
    Kafka可以用于两大类别的应用:
    构造实时流数据管道,它可以在系统或应用之间可靠地获取数据。 (相当于message queue)
    构建实时流式应用程序,对这些流数据进行转换或者影响。 (就是流处理,通过kafka
    stream topic和topic之间内部进行变化)
    为了理解Kafka是如何做到以上所说的功能,从下面开始,我们将深入探索Kafka的特性。.
    概念:
    Kafka作为一个集群,运行在一台或者多台服务器上.
    Kafka 通过 topic 对存储的流数据进行分类。
    每条记录中包含一个key,一个value和一个timestamp(时间戳)。
    Kafka有四个核心的API:
    The Producer API 允许一个应用程序发布一串流式的数据到一个或者多个Kafka topic。
    The Consumer API 允许一个应用程序订阅一个或多个 topic
    ,并且对发布给他们的流式数据进行处理。
    The Streams API
    允许一个应用程序作为一个流处理器,消费一个或者多个topic产生的输入流,然后生产一个输出流到一个或多个topic中去,在输入输出流中进行有效的转换。
    The Connector API 允许构建并运行可重用的生产者或者消费者,将Kafka
    topics连接到已存在的应用程序或者数据系统。比如,连接到一个关系型数据库,捕捉表(table)的所有变更内容。

    5.10.1 cluster1 上

    kafka_2.10-0.8.2.1 解压到/usr/local
    //添加环境变量
    # vi /etc/profile
    export KAFKA_HOME=/usr/local/kafka_2.10-0.8.2.1
    export PATH=$KAFKA_HOME/bin:$PATH
    // 修改配置文件
    # vi /usr/local/kafka_2.10-0.8.2.1/config/server.properties
    // 修改下面 3 项
    // 第一项:这个值要唯一,不同的机器不能相同,cluster1 就写 1,cluster2 就写
    2,cluster3 就写 3 broker.id=1
    // 第二项:修改日志路径
    log.dirs=/home/hadoop_files/hadoop_logs/kafka
    // 第三项:此处要写 zookeeper 集群的
    ip+端口号,逗号隔开zookeeper.connect=cluster1:2181,cluster2:2181,cluster3:2181
    // 第四项:此处要写对应机器的 ip 地址!
    advertised.host.name=192.168.56.121
    //修改完环境变量,更新配置文件
    $ source /etc/profile
    // 保存退出后创建 logs 文件夹
    # mkdir -p /home/hadoop_files/hadoop_logs/kafka
    // 修改权限
    # chown -R hadoop:hadoop /home/hadoop_files
    # chown -R hadoop:hadoop /usr/local/kafka_2.10-0.8.2.1
    // 复制文件夹
    # scp -r /usr/local/kafka_2.10-0.8.2.1 cluster2:/usr/local/
    # scp -r /usr/local/kafka_2.10-0.8.2.1 cluster3:/usr/local/

    5.10.2cluster2 上

    # vi /etc/profile
    export KAFKA_HOME=/usr/local/kafka_2.10-0.8.2.1
    export PATH=$KAFKA_HOME/bin:$PATH
    //修改完环境变量,更新配置文件
    $ source /etc/profile
    # vi /usr/local/kafka_2.10-0.8.2.1/config/server.properties
    修改
    broker.id=2
    advertised.host.name=192.168.56.122
    // 保存退出后创建 logs 文件夹
    # mkdir -p /home/hadoop_files/hadoop_logs/kafka
    // 修改权限
    # chown -R hadoop:hadoop /home/hadoop_files
    # chown -R hadoop:hadoop /usr/local/kafka_2.10-0.8.2.1

    5.10.3 cluster3 上

    # vi /etc/profile
    export KAFKA_HOME=/usr/local/kafka_2.10-0.8.2.1
    export PATH=$KAFKA_HOME/bin:$PATH
    //修改完环境变量,更新配置文件
    $ source /etc/profile
    # vi /usr/local/kafka_2.10-0.8.2.1/config/server.properties
    修改
    broker.id=3
    advertised.host.name=192.168.56.123
    // 保存退出后创建 logs 文件夹
    # mkdir -p /home/hadoop_files/hadoop_logs/kafka
    // 修改权限
    # chown -R hadoop:hadoop /home/hadoop_files
    # chown -R hadoop:hadoop /usr/local/kafka_2.10-0.8.2.1

    5.10.4使用 hadoop 用户启动 kafka 集群

    先启动 zookeeper 集群,然后在 kafka 集群中的每个节点使用
    $ kafka-server-start.sh /usr/local/kafka_2.10-0.8.2.1/config/server.properties
    &
    启动完成后按回车即可
    在这里插入图片描述

    5.10.5测试

    在cluster1上创建topic
    Kafka的核心概念:提供一串流式的记录— topic 。
    Topic
    就是数据主题,是数据记录发布的地方,可以用来区分业务系统。Kafka中的Topics总是多订阅者模式,一个topic可以拥有一个或者多个消费者来订阅它的数据。
    对于每一个topic, Kafka集群都会维持一个分区日志,如下所示:
    在这里插入图片描述
    每个分区都是有序且顺序不可变的记录集,并且不断地追加到结构化的commit
    log文件。分区中的每一个记录都会分配一个id号来表示顺序,我们称之为offset,offset用来唯一的标识分区中每一条记录。
    Kafka
    集群保留所有发布的记录—无论他们是否已被消费—并通过一个可配置的参数——保留期限来控制.
    举个例子,
    如果保留策略设置为2天,一条记录发布后两天内,可以随时被消费,两天过后这条记录会被抛弃并释放磁盘空间。Kafka的性能和数据大小无关,所以长时间存储数据没有什么问题.
    在这里插入图片描述
    事实上,在每一个消费者中唯一保存的元数据是offset(偏移量)即消费在log中的位置.偏移量由消费者所控制:通常在读取记录后,消费者会以线性的方式增加偏移量,但是实际上,由于这个位置由消费者控制,所以消费者可以采用任何顺序来消费记录。例如,一个消费者可以重置到一个旧的偏移量,从而重新处理过去的数据;也可以跳过最近的记录,从"现在"开始消费。
    这些细节说明Kafka
    消费者是非常廉价的—消费者的增加和减少,对集群或者其他消费者没有多大的影响。比如,你可以使用命令行工具,对一些topic内容执行
    tail操作,并不会影响已存在的消费者消费数据。
    日志中的
    partition(分区)有以下几个用途。第一,当日志大小超过了单台服务器的限制,允许日志进行扩展。每个单独的分区都必须受限于主机的文件限制,不过一个主题可能有多个分区,因此可以处理无限量的数据。第二,可以作为并行的单元集—关于这一点,更多细节如下
    分布式
    日志的分区partition
    (分布)在Kafka集群的服务器上。每个服务器在处理数据和请求时,共享这些分区。每一个分区都会在已配置的服务器上进行备份,确保容错性.
    每个分区都有一台 server 作为 “leader”,零台或者多台server作为 follwers 。leader
    server 处理一切对 partition
    (分区)的读写请求,而follwers只需被动的同步leader上的数据。当leader宕机了,followers
    中的一台服务器会自动成为新的 leader。每台 server 都会成为某些分区的 leader
    和某些分区的 follower,因此集群的负载是平衡的。
    生产者
    生产者可以将数据发布到所选择的topic(主题)中。生产者负责将记录分配到topic的哪一个
    partition(分区)中。可以使用循环的方式来简单地实现负载均衡,也可以根据某些语义分区函数(例如:记录中的key)来完成。下面会介绍更多关于分区的使用。
    消费者
    消费者使用一个 消费组
    名称来进行标识,发布到topic中的每条记录被分配给订阅消费组中的一个消费者实例.消费者实例可以分布在多个进程中或者多个机器上。
    如果所有的消费者实例在同一消费组中,消息记录会负载平衡到每一个消费者实例.
    如果所有的消费者实例在不同的消费组中,每条消息记录会广播到所有的消费者进程.
    在这里插入图片描述
    如图,这个 Kafka 集群有两台 server
    的,四个分区(p0-p3)和两个消费者组。消费组A有两个消费者,消费组B有四个消费者。
    通常情况下,每个 topic
    都会有一些消费组,一个消费组对应一个"逻辑订阅者"。一个消费组由许多消费者实例组成,便于扩展和容错。这就是发布和订阅的概念,只不过订阅者是一组消费者而不是单个的进程。
    在Kafka中实现消费的方式是将日志中的分区划分到每一个消费者实例上,以便在任何时间,每个实例都是分区唯一的消费者。维护消费组中的消费关系由Kafka协议动态处理。如果新的实例加入组,他们将从组中其他成员处接管一些
    partition 分区;如果一个实例消失,拥有的分区将被分发到剩余的实例。
    Kafka 只保证分区内的记录是有序的,而不保证主题中不同分区的顺序。每个 partition
    分区按照key值排序足以满足大多数应用程序的需求。但如果你需要总记录在所有记录的上面,可使用仅有一个分区的主题来实现,这意味着每个消费者组只有一个消费者进程。
    // 创建 topic
    $ kafka-topics.sh --create --zookeeper
    cluster1:2181,cluster2:2181,cluster3:2181 --replication-factor 3 --partitions 1
    –topic mykafka
    在这里插入图片描述
    // 查看 Topic:
    $ kafka-topics.sh --list --zookeeper cluster1:2181,cluster2:2181,cluster3:2181
    此时会显示 Topic:mykafka
    // 查看详细信息
    $ kafka-topics.sh --describe --zookeeper
    cluster1:2181,cluster2:2181,cluster3:2181 Topic:mykafka PartitionCount:1
    ReplicationFactor:3Configs:
    Topic: mykafka Partition: 0 Leader: 133 Replicas: 133,134,132 Isr: 134
    // 发送消息(cluster1 上执行)
    $ kafka-console-producer.sh --broker-list localhost:9092 --topic mykafka
    // 接收消息(cluster2 上执行)
    $ kafka-console-consumer.sh -zookeeper
    cluster1:2181,cluster2:2181,cluster3:2181 --topic mykafka --from- beginning
    // 在 cluster1 输入以下内容
    test mycluster test
    可以在 cluster2 上看到相应的信息按 Ctrl+C 退出
    在这里插入图片描述
    // 关闭 kafka,在每台上执行
    $ kafka-server-stop.sh
    //新建虚拟窗口 kafka,在每台上执行
    $ screen -S kafka
    // 启动 kafka 集群,在每台上执行
    $ kafka-server-start.sh /usr/local/kafka_2.10-0.8.2.1/config/server.properties
    // 退出虚拟窗口 kafka,在每台上执行
    $ Ctrl+A+D
    在每台服务器上面执行 jps 可以看到 Kafka 进程在运行
    在这里插入图片描述
    // 关闭 kafka 的命令为,在每台服务器上进入虚拟窗口 kafka,然后使用
    kafka-server-stop.sh 即可。

    5.11安装 Hadoop

    Hadoop 是一个由 Apache
    基金会所开发的分布式系统基础架构,它可以使用户在不了解分布式底层细节的情況下开发分布式程序,充分利用集群的威力进行高速运算和存储。从其定义就可以发现,它解決了两大问题:大数据存储、大数据分析。
    Hadoop 2.X 项目包含以下模块
    Hadoop Common:为 Hadoop 其他模块提供支持的基础模块。
    HDFS:Hadoop:分布式文件系统。
    YARN:任务分配和集群资源管理框架。
    MapReduce:并行和可扩展的用于处理大数据的模式。
    Hadoop 是一个能够让用户轻松架构和使用的分布式计算的平台。用户可以轻松地在 Hadoop
    发和运行处理海量数据的应用程序。其优点主要有以下几个:

    (1) 高可靠性 : Hadoop 按位存储和处理数据的能力值得人们信赖。
    (2) 高扩展性 : Hadoop
    是在可用的计算机集簇间分配数据并完成计算任务的,这些集簇可以方便地扩展到数以干计的节点中。
    (3) 高效性 :
    Hadoop能够在节点之间动态地移动数据,并保证各个节点的动态平衡,因此处理速度非常快。
    (4) 高容错性 :
    Hadoop能够自动保存数据的多个副本,并且能够自动将失败的任务重新分。
    (5) 低成本 : 与一体机、商用数据仓库以及 QlikView、 Yonghong Z- Suites
    等数据集市相比,Hadoop 是开源的,项目的软件成本因此会大大降低。
    Hadoop 带有用 Java 语言编写的框架,因此运行在 linux 生产平台上是非常理想的,
    Hadoop 上的应用程序也可以使用其他语言编写,比如 C++。

    5.11.1cluster1

    Hadoop 启动的先决条件是 zookeeper 已经成功启动
    // 在 cluster1 节点/usr/local/解压 hadoop 安装包
    $ su root
    # tar -zxvf hadoop-2.6.5.tar.gz
    // 删除安装包
    # rm hadoop-2.6.5.tar.gz
    // 切换到存有 hadoop 配置文件的目录
    # cd /usr/local/hadoop-2.6.5/etc/hadoop
    // 修改 hadoop-env.sh 文件
    # vi hadoop-env.sh
    修改如下内容:
    export JAVA_HOME=/usr/local/jdk1.7.0_80
    export HADOOP_PID_DIR=/home/hadoop_files
    // 配置 mapred-env.sh
    # vi mapred-env.sh
    export HADOOP_MAPRED_PID_DIR=/home/hadoop_files
    // 配置 core-site.xml 文件
    # vi core-site.xml

    <configuration>
    <!-- 指定 hdfs 的 nameservices 名称为 mycluster,与 hdfs-site.xml 的 HA
    配置相同 -->
    <property>
    <name>fs.defaultFS</name>
    <value>hdfs://cluster1:9000</value>
    </property>
    <!-- 指定缓存文件存储的路径 -->
    <property>
    <name>hadoop.tmp.dir</name>
    <value>/home/hadoop_files/hadoop_tmp/hadoop/data/tmp</value>
    </property>
    <!-- 配置 hdfs 文件被永久删除前保留的时间(单位:分钟),默认值为 0
    表明垃圾回收站功能关闭 -->
    <property>
    <name>fs.trash.interval</name>
    <value>1440</value>
    </property>
    <!-- 指定 zookeeper 地址,配置 HA 时需要 -->
    <property>
    <name>ha.zookeeper.quorum</name>
    <value>cluster1:2181,cluster2:2181,cluster3:2181</value>
    </property>
    </configuration>
    // 配置 hdfs-site.xml 文件
    # vi hdfs-site.xml
    <configuration>
    <!-- 指定 hdfs 元数据存储的路径 -->
    <property>
    <name>dfs.namenode.name.dir</name>
    <value>/home/hadoop_files/hadoop_data/hadoop/namenode</value>
    </property>
    <!-- 指定 hdfs 数据存储的路径 -->
    <property>
    <name>dfs.datanode.data.dir</name>
    <value>/home/hadoop_files/hadoop_data/hadoop/datanode</value>
    </property>
    <property>
    <name>dfs.secondary.http.address</name>
    <value>cluster1:50090</value>
    </property>
    <!-- 数据备份的个数 -->
    <property>
    <name>dfs.replication</name>
    <value>3</value>
    </property>
    <!-- 关闭权限验证 -->
    <property>
    <name>dfs.permissions.enabled</name>
    <value>false</value>
    </property>
    <!-- 开启 WebHDFS 功能(基于 REST 的接口服务) -->
    <property>
    <name>dfs.webhdfs.enabled</name>
    <value>true</value>
    </property>
    </configuration>
    // 配置 mapred-site.xml 文件
    # vi mapred-site.xml
    <configuration>
    <!-- 指定 MapReduce 计算框架使用 YARN -->
    <property>
    <name>mapreduce.framework.name</name>
    <value>yarn</value>
    </property>
    <!-- 指定 jobhistory server 的 rpc 地址 -->
    <property>
    <name>mapreduce.jobhistory.address</name>
    <value>cluster1:10020</value>
    </property>
    <!-- 指定 jobhistory server 的 http 地址 -->
    <property>
    <name>mapreduce.jobhistory.webapp.address</name>
    <value>cluster1:19888</value>
    </property>
    </configuration>
    // 配置 yarn-site.xml 文件
    # vi yarn-site.xml
    <configuration>
    <!-- NodeManager 上运行的附属服务,需配置成 mapreduce_shuffle 才可运行
    MapReduce 程序 -->
    <property>
    <name>yarn.nodemanager.aux-services</name>
    <value>mapreduce_shuffle</value>
    </property>
    <!-- 配置 Web Application Proxy 安全代理(防止 yarn 被攻击) -->
    <property>
    <name>yarn.web-proxy.address</name>
    <value>cluster2:8888</value>
    </property>
    <!-- 开启日志 -->
    <property>
    <name>yarn.log-aggregation-enable</name>
    <value>true</value>
    </property>
    <!-- 配置日志删除时间为 7 天,-1 为禁用,单位为秒 -->
    <property>
    <name>yarn.log-aggregation.retain-seconds</name>
    <value>604800</value>
    </property>
    <!-- 修改日志目录 -->
    <property>
    <name>yarn.nodemanager.remote-app-log-dir</name>
    <value>/home/hadoop_files/hadoop_logs/yarn</value>
    </property>
    <property>
    <name>yarn.resourcemanager.address</name>
    <value>cluster1:8032</value>
    </property>
    <property>
    <name>yarn.resourcemanager.scheduler.address</name>
    <value>cluster1:8030</value>
    </property>
    <property>
    <name>yarn.resourcemanager.resource-tracker.address</name>
    <value>cluster1:8031</value>
    </property>
    </configuration>
    // 配置 slaves 文件
    # vi slaves
    删 除 localhost 添加以下内容:
    cluster1
    cluster2
    cluster3
    // 创建配置文件中涉及的目录(在所有结点上)
    # mkdir -p /home/hadoop_files/hadoop_data/hadoop/namenode
    # mkdir -p /home/hadoop_files/hadoop_data/hadoop/datanode
    # mkdir -p /home/hadoop_files/hadoop_tmp/hadoop/data/tmp
    # mkdir -p /home/hadoop_files/hadoop_logs/yarn
    // 修改文件夹权限(在所有结点上)
    # chown -R hadoop:hadoop /home/hadoop_files/
    # chown -R hadoop:hadoop /usr/local/hadoop-2.6.5/
    // 将 cluster1 的 hadoop 工作目录同步到集群其它节点
    $ scp -r /usr/local/hadoop-2.6.5 cluster2:/usr/local/
    $ scp -r /usr/local/hadoop-2.6.5 cluster3:/usr/local/

    5.11.2所有节点上

    // 修改文件夹权限(在所有结点上)
    # chown -R hadoop:hadoop /usr/local/hadoop-2.6.5/
    // 在集群各节点上修改环境变量
    # vi /etc/profile
    export HADOOP_HOME=/usr/local/hadoop-2.6.5
    export LD_LIBRARY_PATH=$HADOOP_HOME/lib/native
    export PATH=$HADOOP_HOME/bin:$HADOOP_HOME/sbin:$PATH
    // 使修改的环境变量生效
    $ source /etc/profile
    // 启动 zookeeper 集群(分别在 cluster1, cluster2 和 cluster3 上执行)
    $ zkServer.sh start
    接下来开始格式化:
    // 启动 journalnode(在所有 datanode 上执行,也就是 cluster1, cluster2,
    cluster3)
    $ hadoop-daemon.sh start journalnode
    启动后使用 jps 命令可以看到 JournalNode 进程

    5.11.3测试

    // 格式化 HDFS(在 cluster1 上执行)
    $ hdfs namenode -format
    // 格式化完毕后可关闭 journalnode(在cluster1,2,3上执行)
    $ hadoop-daemon.sh stop journalnode
    // 启动 HDFS(cluster1 上)
    $ start-dfs.sh
    // 启动后 cluster1 上使用 jps 可以看到 NameNode, DataNode, SecondaryNameNode
    cluster2 和 cluster3 上可以看到 DataNode
    $ jps
    // 启动 YARN(cluster1 上)
    $ start-yarn.sh
    // 启动后 cluster1 上使用 jps 可以看到 NodeManager, ResourceManager
    cluster2 和 cluster3 上可以看到 NodeManager
    $ jps
    // 以下两条命令是关闭 YARN 和 HDFS
    的命令,重启服务器或关机前一定要执行,否则有可能导致数据或服务损坏
    // 关闭 YARN 的命令(cluster1 上)
    $ stop-yarn.sh
    // 关闭 HDFS 的命令(cluster1 上)
    $ stop-dfs.sh
    测试结果:
    在这里插入图片描述
    启动 HDFS 后,可以在本地的浏览器中,打开 192.168.56.121:50070,可以看到 HDFS 的
    web 界面
    在这里插入图片描述
    第一页 Overview 是当前 HDFS 的概况,里面显示了 HDFS
    的启动时间,版本等信息。点击上面标签栏的第二项 Datanodes,可以看到如下界面
    这个页面显示了当前 HDFS 中的可用节点。
    在这里插入图片描述
    启动 YARN 后,可以通过浏览器访问 192.168.56.121:8088,查看 YARN 的 web 界面
    在这里插入图片描述
    该页面展示了所有提交到 YARN 上的程序,点击左侧的 Nodes 可以看到 YARN 的节点
    在这里插入图片描述
    注意,此处可以看到每个节点的可用内存 Mem Avail 为 8G,我们的虚拟机每台内存只有
    1.5G,之所以出现这个问题是因为我们没有在 yarn-site.xml
    这个文件中对节点的可用内存进行配置,可以增加一下内容进行配置:
    <!-- 配置 nodemanager 可用的资源内存 -->

    <property>
    <name>yarn.nodemanager.resource.memory-mb</name>
    <value>20480</value>
    </property>
    <!-- 配置 nodemanager 可用的资源 CPU -->
    <property>
    <name>yarn.nodemanager.resource.cpu-vcores</name>
    <value>24</value>
    </property>
    由于我们的虚拟机没有那么大的内存空间以及 CPU
    资源,所以我们暂时不设置这两个参数,在后续实验中,
    需要同学们设置这个参数以达到集群性能的最大化。
    命令行测试:
    // cluster1
    // 切换至 hadoop 用户的主目录
    $ cd ~/
    // 新建一个测试文件
    $ vi testfile
    输入
    1
    2
    3
    // 保存退出
    // 查看 HDFS 根目录的文件
    $ hdfs dfs -ls /
    // 在 HDFS 的根目录创建 test 目录
    $ hdfs dfs -mkdir /test
    // 如果出现了 mkdir: Cannot create directory /test. Name node is in safe
    mode.说明 HDFS
    刚启动不久,还在安全检查中。由于我们的笔记本性能不够强,安全检查的时间会很长,可以使用命令退出安全模式,看到
    Safe mode is OFF,再执行上面的创建目录的命令
    在这里插入图片描述
    $ hdfs dfsadmin -safemode leave
    // 创建完文件夹后再次查看根目录,查看目录是否新建成功
    $ hdfs dfs -ls /
    在这里插入图片描述
    // 将测试文件 testfile 上传至 HDFS 根目录下的 test 目录中
    $ hdfs dfs -put testfile /test
    // 在 cluster2 上
    // 切换至 hadoop 用户的主目录
    $ cd ~/
    // 查看 HDFS 根目录
    $ hdfs dfs -ls /
    在这里插入图片描述
    // 查看 HDFS 根目录下的 test 目录,可以看到我们刚才在 cluster1 上上传的文件
    testfile
    $ hdfs dfs -ls /test
    // 查看 HDFS 上的/test/testfile 文件的内容
    $ hdfs dfs -cat /test/testfile
    在这里插入图片描述
    // 将 HDFS 上的/test/testfile 下载到本地
    $ hdfs dfs -get /test/testfile
    // 查看本地当前目录内的内容,可以看到刚才下载的 testfile
    $ ls
    在这里插入图片描述

    5.12安装 HBase

    HBase(Hadoop
    Database)是一个高可靠性、高性能、面向列、可伸缩的分布式存储系统,利用 HBase
    技术可在廉价 PC Server 上搭建起大规模结构化存储集群。

    5.12.1cluster1

    HBase 启动的先决条件是 zookeeper 和 Hadoop 已经启动
    // 切换至 root 用户
    $ su root
    // 在 cluster1 节点/usr/local/解压 hbase 安装包
    # tar -zxvf hbase-1.2.6-bin.tar.gz
    // 进入 hbase 的 conf 目录
    #cd /usr/local/hbase-1.2.6/conf/
    // 修改 hbase-env.sh
    # vi hbase-env.sh
    将 JAVA_HOME, HADOOP_HOME, HBASE_LOG_DIR, HBASE_MANAGES_ZK 修改为以下内容:
    记得去掉前面的 #
    # 配置 JDK 安装路径
    export JAVA_HOME=/usr/local/jdk1.7.0_80
    # 配置 Hadoop 安装路径
    export HADOOP_HOME=/usr/local/hadoop-2.6.5
    # 设置 HBase 的日志目录
    export HBASE_LOG_DIR=/home/hadoop_files/hadoop_logs/hbase/logs
    # 使用独立的 ZooKeeper 集群
    export HBASE_MANAGES_ZK=false
    # 设置 pid 的路径
    export HBASE_PID_DIR=/home/hadoop_files
    // 配置 hbase-site.xml
    # vi hbase-site.xml

    <configuration>
    <property>
    <name>hbase.rootdir</name>
    <value>hdfs://cluster1:9000/hbase</value>
    </property>
    <property>
    <name>hbase.cluster.distributed</name>
    <value>true</value>
    </property>
    <property>
    <name>hbase.master</name>
    <value>60000</value>
    </property>
    <property>
    <name>hbase.tmp.dir</name>
    <value>/home/hadoop_files/hadoop_tmp/hbase/tmp</value>
    </property>
    <property>
    <name>hbase.zookeeper.quorum</name>
    <value>cluster1,cluster2,cluster3</value>
    </property>
    <property>
    <name>hbase.zookeeper.property.dataDir</name>
    <value>/home/hadoop_files/hadoop_data/zookeeper</value>
    </property>
    <property>
    <name>hbase.zookeeper.property.clientPort</name>
    <value>2181</value>
    </property>
    <property>
    <name>zookeeper.session.timeout</name>
    <value>120000</value>
    </property>
    <property>
    <name>hbase.regionserver.restart.on.zk.expire</name>
    <value>true</value>
    </property>
    <property>
    <name>hbase.master.info.port</name>
    <value>60010</value>
    </property>
    </configuration>
    // 配置 regionservers
    # vi regionservers
    删除 localhost
    添加: cluster1 cluster2 cluster3
    // 删除 hbase 的 slf4j-log4j12-1.7.5.jar,解决 hbase 和 hadoop 的 LSF4J 包冲突
    # cd /usr/local/hbase-1.2.6/lib
    # mv slf4j-log4j12-1.7.5.jar slf4j-log4j12-1.7.5.jar.bk
    // 将 hbase 工作目录同步到集群其它节点
    # scp -r /usr/local/hbase-1.2.6/ cluster2:/usr/local/
    # scp -r /usr/local/hbase-1.2.6/ cluster3:/usr/local/

    5.12.2所有节点上

    // 创建 hbase 的缓存文件目录(所有节点)
    # mkdir -p /home/hadoop_files/hadoop_tmp/hbase/tmp
    // 创建 hbase 的日志文件目录(所有节点)
    $ mkdir -p /home/hadoop_files/hadoop_logs/hbase/logs
    // 改权限(所有节点)
    # chown -R hadoop:hadoop /usr/local/hbase-1.2.6
    # chown -R hadoop:hadoop /home/hadoop_files
    // 在集群各节点上修改环境变量
    # vi /etc/profile
    export HBASE_HOME=/usr/local/hbase-1.2.6 export PATH=$HBASE_HOME/bin:$PATH
    $ source /etc/profile

    5.12.3测试

    // 启动 HBase(cluster1 上)
    先启动 zookeeper,Hadoop 的 HDFS 和 YARN,然后才能启动 HBase
    // 启动 HDFS(cluster1 上)
    $ start-dfs.sh
    // 启动 YARN(cluster1 上)
    $ start-yarn.sh
    // 启动 HBase(cluster1 上)
    $ start-hbase.sh
    启动后 cluster1 上使用 jps 可以看到 HMaster 和 HRegionServer
    cluster2 和 cluster3 上可以看到 HRegionServer
    // 关机前执行关闭 HBase 的命令(cluster1 上)
    $ stop-hbase.sh
    用浏览器打开 192.168.56.121:60010,可以看到 HBase 的 web 界面
    在这里插入图片描述
    测试 HBase:
    // cluster1 上
    $ hbase shell
    hbase> create
    ‘userinfotable’,{NAME=>‘username’},{NAME=>‘fullname’},{NAME=>‘homedir’}
    hbase> put ‘userinfotable’,‘r1’,‘username’,‘vcsa’
    hbase> put ‘userinfotable’,‘r2’,‘username’,‘sasuser’ hbase> scan
    ‘userinfotable’
    可以看到刚才插入的信息,在 web 界面也可以看到刚才建立的表。
    在这里插入图片描述
    在这里插入图片描述
    删除刚才建立的表: hbase> disable ‘userinfotable’ hbase> drop ‘userinfotable’
    hbase> exit

    5.13安装 Hive

    Hive 是建立在 Hadoop
    上的数据仓库基础构架。它提供了一系列的工具,可以用来进行数据提取转化加载(ETL),这是一种可以存储、查询和分析存储在
    Hadoop 中的大规模数据的机制。

    5.13.1 cluster2上

    以下内容除在 MySQL(cluster2 中)创建 hive 用户和创建 hive
    数据库只用操作一次,其他操作需要在每个 Hadoop 结点上都执行一次。
    注:hive 能启动的先决条件是 MySQL 已经安装并配置完成,而且 HDFS
    也要启动之后才能运行 hive
    $ su root
    # cp apache-hive-1.1.0-bin.tar.gz /usr/local
    # cd /usr/local
    # tar -zxvf ./apache-hive-1.1.0-bin.tar.gz
    # vi /etc/profile
    // 在下面加上两行:
    export HIVE_HOME=/usr/local/apache-hive-1.1.0-bin
    export PATH=$HIVE_HOME/bin:$HIVE_HOME/conf:$PATH
    $ source /etc/profile
    // root 用户登陆 MySQL
    # mysql -u root -p
    // 创建用户 hive,密码 hive
    mysql> GRANT USAGE ON *.* TO ‘hive’@’%’ IDENTIFIED BY ‘hive’ WITH GRANT
    OPTION;
    // 创建数据库 hive
    mysql> create database hive;
    // 允许任意 ip 以 hive 登陆数据库
    mysql> grant all on hive.* to hive@’%’ identified by ‘hive’; mysql> grant
    all on hive.* to hive@‘localhost’ identified by ‘hive’; mysql> grant all on
    hive.* to hive@‘cluster2’ identified by ‘hive’;
    // 刷新权限
    mysql> flush privileges;
    // 退出
    mysql> exit;
    // 验证 hive 用户,密码 hive
    # mysql -u hive -p
    // 查看当前的数据库
    mysql> show databases;
    若看到下面有 hive 这个库,则说明创建成功
    ±------------------------------+
    | Database |
    ±------------------------------+
    | information_schema |
    | hive |
    ±------------------------------+
    2 rows in set (0.00 sec)
    // 退出 mysql mysql> exit;
    // 修改 hive-site.xml
    # cp apache-hive-1.1.0-bin/conf/hive-default.xml.template
    apache-hive-1.1.0-bin/conf/hive-site.xml
    # vi apache-hive-1.1.0-bin/conf/hive-site.xml
    找到以下 property 项,value 值修改成如下,其他的在 hive-site.xml
    中出现,但是下文没出现的就不需要更改了:

    <property>
    <name>javax.jdo.option.ConnectionURL </name>
    <value>jdbc:mysql://cluster2:3306/hive</value>
    </property>
    <property>
    <name>javax.jdo.option.ConnectionDriverName </name>
    <value>com.mysql.jdbc.Driver </value>
    </property>
    <property>
    <name>javax.jdo.option.ConnectionPassword </name>
    <value>hive</value>
    </property>
    <property>
    <name>hive.hwi.listen.port</name>
    <value>9999 </value>
    <description>This is the port the Hive Web Interface will listen
    on</descript ion>
    </property>
    <property>
    <name>datanucleus.autoCreateSchema</name>
    <value>true</value>
    </property>
    <property>
    <name>datanucleus.fixedDatastore</name>
    <value>false</value>
    </property>
    <property>
    <name>javax.jdo.option.ConnectionUserName</name>
    <value>hive</value>
    <description>Username to use against metastore database</description>
    </property>
    <property>
    <name>hive.exec.local.scratchdir</name>
    <value>/home/hadoop_files/hadoop_tmp/hive/iotmp</value>
    <description>Local scratch space for Hive jobs</description>
    </property>
    <property>
    <name>hive.downloaded.resources.dir</name>
    <value>/home/hadoop_files/hadoop_tmp/hive/iotmp</value>
    <description>Temporary local directory for added resources in the remote
    file system.</description>
    </property>
    <property>
    <name>hive.querylog.location</name>
    <value>/home/hadoop_files/hadoop_logs/hive/querylog</value>
    <description>Location of Hive run time structured log file</description>
    </property>
    // 拷贝 mysql-connector-java-5.1.43-bin.jar 到 hive 的 lib 下面
    //要将文件mysql-connector-java-5.1.43-bin.jar上传到/usr/local/目录下
    # cp mysql-connector-java-5.1.43-bin.jar /usr/local/apache-hive-1.1.0-bin/lib/
    // 把 jline-2.12.jar 拷贝到 hadoop 相应的目录下,替代
    jline-0.9.94.jar,否则启动会报错
    // 将 hbase 工作目录同步到集群其它节点cluster1 cluster3
    # scp -r /usr/local/hbase-1.2.6/ cluster1:/usr/local/
    # scp -r /usr/local/hbase-1.2.6/ cluster3:/usr/local/

    5.13.2 所有节点上

    # cp /usr/local/apache-hive-1.1.0-bin/lib/jline-2.12.jar
    /usr/local/hadoop-2.6.5/share/hadoop/yarn/lib/
    // 切换到 hadoop 目录中 share/hadoop/yarn/lib
    # cd /usr/local/hadoop-2.6.5/share/hadoop/yarn/lib/
    // 将 hadoop-2.6.5/share/hadoop/yarn/lib/里面的 jline-0.9.94 重命名
    # mv jline-0.9.94.jar jline-0.9.94.jar.bak
    // 创建 hive 临时文件夹和日志目录
    # mkdir -p /home/hadoop_files/hadoop_tmp/hive/iotmp
    # mkdir -p /home/hadoop_files/hadoop_logs/hive/querylog
    // 改一下权限
    # chown -R hadoop:hadoop /home/hadoop_files/
    # chown -R hadoop:hadoop /usr/local/apache-hive-1.1.0-bin

    5.13.4 cluster1和cluster3上

    # vi /etc/profile
    // 在下面加上两行:
    export HIVE_HOME=/usr/local/apache-hive-1.1.0-bin
    export PATH=$HIVE_HOME/bin:$HIVE_HOME/conf:$PATH
    $ source /etc/profile

    5.13.2测试

    // 打开 hive 客户端cluster2
    $ hive
    hive> create table test_table(id int, name string);
    hive> insert into test_table values(1,”test”);
    在这里插入图片描述
    // 换台服务器cluster1或者cluster3
    hive> show tables;
    应该可以看到刚才创建的 test_table
    hive> select * from test_table;
    hive> drop table test_table;
    hive> show tables;
    hive> exit;
    在这里插入图片描述

    5.14安装 Scala

    5.14.1 cluster1 上

    $ su root
    # mv scala-2.10.6.tgz /usr/local
    # tar -zxvf scala-2.10.6.tgz
    # vi /etc/profile
    最下面加两行:
    export SCALA_HOME=/usr/local/scala-2.10.6 export PATH=$SCALA_HOME/bin:$PATH
    // 刷新环境变量
    # source /etc/profile
    // 查看版本,验证安装是否成功
    # scala -version
    // 修改文件夹权限
    # chown -R hadoop:hadoop /usr/local/scala-2.10.6
    // 复制到所有的服务器上
    # scp -r /usr/local/scala-2.10.6 cluster2:/usr/local/
    # scp -r /usr/local/scala-2.10.6 cluster3:/usr/local/

    5.14.2 cluster2,3上

    #vi /etc/profile
    export SCALA_HOME=/usr/local/scala-2.10.6
    export PATH=$SCALA_HOME/bin:$PATH
    // 刷新环境变量
    # source /etc/profile
    // 查看版本,验证安装是否成功
    # scala -version
    // 修改文件夹权限(每一个节点都要操作)
    # chown -R hadoop:hadoop /usr/local/scala-2.10.6

    5.15安装 Spark

    Apache Spark 是专为大规模数据处理而设计的快速通用的计算引擎。Spark是UC Berkeley
    AMP lab (加州大学伯克利分校的AMP实验室)所开源的类Hadoop
    MapReduce的通用并行框架,Spark,拥有Hadoop
    MapReduce所具有的优点;但不同于MapReduce的是——Job中间输出结果可以保存在内存中,从而不再需要读写HDFS,因此Spark能更好地适用于数据挖掘与机器学习等需要迭代的MapReduce的算法。
    Spark 是一种与 Hadoop
    相似的开源集群计算环境,但是两者之间还存在一些不同之处,这些有用的不同之处使
    Spark 在某些工作负载方面表现得更加优越,换句话说,Spark
    启用了内存分布数据集,除了能够提供交互式查询外,它还可以优化迭代工作负载。
    Spark 是在 Scala 语言中实现的,它将 Scala 用作其应用程序框架。与 Hadoop
    不同,Spark 和 Scala 能够紧密集成,其中的 Scala
    可以像操作本地集合对象一样轻松地操作分布式数据集。
    尽管创建 Spark 是为了支持分布式数据集上的迭代作业,但是实际上它是对 Hadoop
    的补充,可以在 Hadoop 文件系统中并行运行。通过名为 Mesos
    的第三方集群框架可以支持此行为。Spark 由加州大学伯克利分校 AMP 实验室
    (Algorithms, Machines, and People Lab)
    开发,可用来构建大型的、低延迟的数据分析应用程序。
    Spark 主要有三个特点:
    首先,高级 API 剥离了对集群本身的关注,Spark
    应用开发者可以专注于应用所要做的计算本身。
    其次,Spark 很快,支持交互式计算和复杂算法。
    最后,Spark 是一个通用引擎,可用它来完成各种各样的运算,包括 SQL
    查询、文本处理、机器学习等,而在 Spark
    出现之前,我们一般需要学习各种各样的引擎来分别处理这些需求。
    更快的速度
    内存计算下,Spark 比 Hadoop 快100倍。
    计算时间比较
    计算时间比较
    易用性
    Spark 提供了80多个高级运算符。
    通用性
    Spark 提供了大量的库,包括Spark Core、Spark SQL、Spark
    Streaming、MLlib、GraphX。 开发者可以在同一个应用程序中无缝组合使用这些库。
    支持多种资源管理器
    Spark 支持 Hadoop YARN,Apache Mesos,及其自带的独立集群管理器
    Spark生态系统
    Shark:Shark基本上就是在Spark的框架基础上提供和Hive一样的HiveQL命令接口,为了最大程度的保持和Hive的兼容性,Spark使用了Hive的API来实现query
    Parsing和 Logic Plan generation,最后的PhysicalPlan
    execution阶段用Spark代替HadoopMapReduce。通过配置Shark参数,Shark可以自动在内存中缓存特定的RDD,实现数据重用,进而加快特定数据集的检索。同时,Shark通过UDF用户自定义函数实现特定的数据分析学习算法,使得SQL数据查询和运算分析能结合在一起,最大化RDD的重复使用。
    SparkR:SparkR是一个为R提供了轻量级的Spark前端的R包。
    SparkR提供了一个分布式的data frame数据结构,解决了 R中的data
    frame只能在单机中使用的瓶颈,它和R中的data frame
    一样支持许多操作,比如select,filter,aggregate等等。(类似dplyr包中的功能)这很好的解决了R的大数据级瓶颈问题。
    SparkR也支持分布式的机器学习算法,比如使用MLib机器学习库。
    SparkR为Spark引入了R语言社区的活力,吸引了大量的数据科学家开始在Spark平台上直接开始数据分析之旅。
    基本原理
    Spark
    Streaming:构建在Spark上处理Stream数据的框架,基本的原理是将Stream数据分成小的时间片段(几秒),以类似batch批量处理的方式来处理这小部分数据。Spark
    Streaming构建在Spark上,一方面是因为Spark的低延迟执行引擎(100ms+),虽然比不上专门的流式数据处理软件,也可以用于实时计算,另一方面相比基于Record的其它处理框架(如Storm),一部分窄依赖的RDD数据集可以从源数据重新计算达到容错处理目的。此外小批量处理的方式使得它可以同时兼容批量和实时数据处理的逻辑和算法。方便了一些需要历史数据和实时数据联合分析的特定应用场合。
    计算方法
    Bagel: Pregel on
    Spark,可以用Spark进行图计算,这是个非常有用的小项目。Bagel自带了一个例子,实现了Google的PageRank算法。
    当下Spark已不止步于实时计算,目标直指通用大数据处理平台,而终止Shark,开启SparkSQL或许已经初见端倪。
    近几年来,大数据机器学习和数据挖掘的并行化算法研究成为大数据领域一个较为重要的研究热点。早几年国内外研究者和业界比较关注的是在
    Hadoop 平台上的并行化算法设计。然而, HadoopMapReduce
    平台由于网络和磁盘读写开销大,难以高效地实现需要大量迭代计算的机器学习并行化算法。随着
    UC Berkeley AMPLab 推出的新一代大数据平台 Spark
    系统的出现和逐步发展成熟,近年来国内外开始关注在 Spark
    平台上如何实现各种机器学习和数据挖掘并行化算法设计。为了方便一般应用领域的数据分析人员使用所熟悉的
    R 语言在 Spark 平台上完成数据分析,Spark 提供了一个称为 SparkR
    的编程接口,使得一般应用领域的数据分析人员可以在 R 语言的环境里方便地使用 Spark
    的并行化编程接口和强大计算能力。

    5.15.1cluster1上

    上传 spark-1.6.3-bin-hadoop2.6.tgz
    // 解压
    # cp spark-1.6.3-bin-hadoop2.6.tgz /usr/local
    # cd /usr/local/
    # tar -zxvf spark-1.6.3-bin-hadoop2.6.tgz
    # cd spark-1.6.3-bin-hadoop2.6
    // 环境变量
    # vi /etc/profile
    添加以下内容:
    export SPARK_HOME=/usr/local/spark-1.6.3-bin-hadoop2.6
    export PATH=$SPARK_HOME/bin:$PATH
    主节点要再加一行(cluster1):
    export PATH=$SPARK_HOME/sbin:$PATH
    // 复制 conf 文件夹里面 template 一份,改名为 spark-env.sh
    # cp conf/spark-env.sh.template conf/spark-env.sh
    // 在 conf/spark-env.sh 最下面加入以下 7 行:
    #vi conf/spark-env.sh
    export JAVA_HOME=/usr/local/jdk1.7.0_80
    export SCALA_HOME=/usr/local/scala-2.10.6
    export SPARK_MASTER_IP=cluster1
    export HADOOP_CONF_DIR=/usr/local/hadoop-2.6.5/etc/hadoop
    export SPARK_DIST_CLASSPATH=$(/usr/local/hadoop-2.6.5/bin/hadoop classpath)
    export SPARK_CLASSPATH=$HIVE_HOME/lib/mysql-connector-java-5.1.43-bin.jar
    export SPARK_PID_DIR=/home/hadoop_files
    // 在 conf 下面新建一个叫 slaves 的文件
    # vi conf/slaves
    添加以下几行
    cluster1
    cluster2
    cluster3
    // 将 hive 目录下 conf 文件夹中的 hive-site.xml 复制到 spark 的 conf 目录下
    # cd /usr/local/
    # cp apache-hive-1.1.0-bin/conf/hive-site.xml spark-1.6.3-bin-hadoop2.6/conf/
    // 将 hadoop/etc/hadoop 文件中的 hdfs-site.xml 和 core-site.xml 文件复制到 spark
    的 conf 目录下
    # cp hadoop-2.6.5/etc/hadoop/hdfs-site.xml
    hadoop-2.6.5/etc/hadoop/core-site.xml spark-1.6.3-bin-hadoop2.6/conf/
    // 将 conf 目录下的 spark-defaults.conf.template 复制一份,改名为
    spark-default.conf
    # cd spark-1.6.3-bin-hadoop2.6/conf/
    # cp spark-defaults.conf.template spark-defaults.conf
    # vi spark-defaults.conf
    // 在最下面加上下面这一行
    spark.files
    file:///usr/local/spark-1.6.3-bin-hadoop2.6/conf/hdfs-site.xml,file:///usr/local/spark-1.6.3-bin-
    hadoop2.6/conf/core-site.xml
    保存后退出即可。
    // 复制到所有的服务器上
    # scp -r /usr/local/spark-1.6.3-bin-hadoop2.6 cluster2:/usr/local/
    # scp -r /usr/local/spark-1.6.3-bin-hadoop2.6 cluster3:/usr/local/
    // 修改 spark 文件夹的权限(每个 spark 结点)
    # chown -R hadoop:hadoop /usr/local/spark-1.6.3-bin-hadoop2.6

    5.15.2 cluster2,3

    # vi /etc/profile
    添加以下内容:
    export SPARK_HOME=/usr/local/spark-1.6.3-bin-hadoop2.6
    export PATH=$SPARK_HOME/bin:$PATH
    $ source /etc/profile
    // 修改 spark 文件夹的权限(每个 spark 结点)
    # chown -R hadoop:hadoop /usr/local/spark-1.6.3-bin-hadoop2.6

    5.15.2测试

    // 运行 Spark(cluster1 上)
    运行 spark 前需启动 hadoop 的 HDFS 和 YARN
    $ start-master.sh
    $ start-slaves.sh
    // 关闭 Spark 的命令(cluster1 上)
    $ stop-slaves.sh
    $ stop-master.sh
    在 cluster1 上使用 jps 命令可以看到 Master 和 Worker,cluster2 和 3 上可以看到
    Worder
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    用浏览器访问 192.168.56.121:8080 可以看到 Spark 的 web 界面,可以看到 3 个
    worker
    在这里插入图片描述

    5.16安 装 Storm

    Apache
    Storm是一个分布式实时大数据处理系统。Storm设计用于在容错和水平可扩展方法中处理大量数据。它是一个流数据框架,具有最高的摄取率。虽然Storm是无状态的,它通过Apache
    ZooKeeper管理分布式环境和集群状态。它很简单,您可以并行地对实时数据执行各种操作。
    Apache
    Storm继续成为实时数据分析的领导者。Storm易于设置和操作,并且它保证每个消息将通过拓扑至少处理一次。
    Apache Storm vs Hadoop
    基本上Hadoop和Storm框架用于分析大数据。两者互补,在某些方面有所不同。Apache
    Storm执行除持久性之外的所有操作,而Hadoop在所有方面都很好,但滞后于实时计算。下表比较了Storm和Hadoop的属性。

    StormHadoop
    实时流处理批量处理
    无状态有状态
    主/从架构与基于ZooKeeper的协调。主节点称为nimbus,从属节点是主管具有/不具有基于ZooKeeper的协调的主 - 从结构。主节点是作业跟踪器,从节点是任务跟踪器
    Storm流过程在集群上每秒可以访问数万条消息。Hadoop分布式文件系统(HDFS)使用MapReduce框架来处理大量的数据,需要几分钟或几小时。
    Storm拓扑运行直到用户关闭或意外的不可恢复故障。MapReduce作业按顺序执行并最终完成。
    两者都是分布式和容错的
    如果nimbus / supervisor死机,重新启动使它从它停止的地方继续,因此没有什么受到影响。如果JobTracker死机,所有正在运行的作业都会丢失。

    Apache Storm的组件 -
    Tuple
    Tuple是Storm中的主要数据结构。它是有序元素的列表。默认情况下,Tuple支持所有数据类型。通常,它被建模为一组逗号分隔的值,并传递到Storm集群。
    Stream 流是元组的无序序列。
    Spouts 流的源。通常,Storm从原始数据源(如Twitter Streaming API,Apache
    Kafka队列,Kestrel队列等)接受输入数据。否则,您可以编写spouts以从数据源读取数据。“ISpout”是实现spouts的核心接口,一些特定的接口是IRichSpout,BaseRichSpout,KafkaSpout等。
    Bolts
    Bolts是逻辑处理单元。Spouts将数据传递到Bolts和Bolts过程,并产生新的输出流。Bolts可以执行过滤,聚合,加入,与数据源和数据库交互的操作。Bolts接收数据并发射到一个或多个Bolts。
    “IBolt”是实现Bolts的核心接口。一些常见的接口是IRichBolt,IBasicBolt等。
    storm 需要 python2.6 以上的版本
    // 查看 python 版本
    # python
    可以在最上面一行看到 python 的版本
    // 退出 python 交互式界面
    >>> exit()
    如果版本低于 2.6,使用 yum install python,安装 Python2.7

    5.16.1 cluster1

    (以下都要在所有节点上操作) 将上传的的 storm 到/usr/local 下,并解压
    # tar -zxvf apache-storm-1.1.1.tar.gz
    // 更改配置文件
    # vi apache-storm-1.1.1/conf/storm.yaml
    里面有两个要改的地方第一个是
    storm.zookeeper.servers :
    - “cluster1”
    - “cluster2”
    - “cluster3”
    第二个是加入一行
    storm.local.dir : “/home/hadoop_files/hadoop_tmp/storm/tmp”
    所有的双引号都是英文字符双引号
    切记:冒号左右要有空格,否则会报错 could not found expected ‘ : ’
    storm.local.dir 的最左边也要有一个空格
    // 复制到所有的服务器上
    # scp -r /usr/local/apache-storm-1.1.1 cluster2:/usr/local/
    # scp -r /usr/local/apache-storm-1.1.1 cluster3:/usr/local/

    5.16.2 所有节点上

    // 添加环境变量
    # vi /etc/profile
    export STORM_HOME=/usr/local/apache-storm-1.1.1
    export PATH=$STORM_HOME/bin:$PATH
    $ source /etc/profile
    // 改一下权限
    # chown -R hadoop:hadoop apache-storm-1.1.1
    // 然后新建 tmp 文件夹,改权限
    # mkdir -p /home/hadoop_files/hadoop_tmp/storm/tmp
    # chown -R hadoop:hadoop /home/hadoop_files
    # chown -R hadoop:hadoop /usr/local/apache-storm-1.1.1

    5.16.3测试

    // 新建 storm-master 的虚拟窗口(cluster1)
    $ screen -S storm-master
    $ storm nimbus
    $ Ctrl+A+D
    // 新建 storm-supervisor 的虚拟窗口(cluster2,cluster3)
    $ screen -S storm-supervisor
    $ storm supervisor
    $ Ctrl+A+D
    // 新建 storm-ui 的虚拟窗口(cluster1)
    $ screen -S storm-ui
    $ storm ui
    $ Ctrl+A+D
    // 新建 storm-logviewer 的虚拟窗口(cluster1,cluster2,cluster3)
    $ screen -S storm-logviewer
    $ storm logviewer
    $ Ctrl+A+D
    使用 jps 可以看到以下进程
    cluster1:nimbus, core, logviewer
    cluster2:Supervisor, logviewer
    cluster3:Supervisor, logviewer
    关闭的过程就是按逆向的顺序进入虚拟窗口后,使用 Ctrl+C 退出即可。
    测试结果:
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述

    展开全文
  • Hadoop大数据平台组件搭建系列(三)——Hive组件配置 简介 本篇介绍Hadoop大数据平台组件中的Hive组件的搭建(搭建Hive前需搭建完成MySQL) 使用软件版本 apache-hive-1.1.0-bin.tar mysql-connector-java-5.1.47....

    简介

    本篇介绍Hadoop大数据平台组件中的Hive组件的搭建(搭建Hive前需搭建完成MySQL)

    安装Hive

    • 解压hive安装包,设置hive的环境变量

    解压软件

    tar -zxvf /opt/software/apache-hive-1.1.0-bin.tar.gz -C /usr/local/scr/
    

    软件重命名(便于操作)

    mv apache-hive-1.1.0-bin/ hive
    

    设置hive环境变量

    vi /etc/profile
    

    添加环境变量

    #.....hive.....
    export HIVE_HOME=/usr/local/scr/hive
    export PATH=$PATH:$HIVE_HOME/bin
    

    使环境变量生效

    source /etc/profile
    
    • 拷贝驱动文件到 ‘{HIVE_HOME}/lib’ 路径下
    cp /opt/software/mysql-connector-java-5.1.47.jar /usr/local/scr/hive/lib/
    
    • 创建HDFS文件夹(如有需要可以更改路径,在hive-site.xml中修改)

    因为在hive-site.xml中有如下HDFS相关设置,因此我们需要先在HDFS中创建对应目录并赋予权限

      <property>
        <name>hive.metastore.warehouse.dir</name>
        <value>/user/hive/warehouse</value>
      </property>
      <property>
        <name>hive.exec.scratchdir</name>
        <value>/tmp/hive</value>
      </property>
    
    [root@master1 ~]# hadoop fs -mkdir -p /user/hive/warehouse
    [root@master1 ~]# hadoop fs -mkdir -p /tmp/hive
    [root@master1 ~]# hadoop fs -chmod -R 777 /user/hive/warehouse
    [root@master1 ~]# hadoop fs -chmod -R 777 /tmp/hive
    
    • 修改配置文件

    复制 hive-default.xml.template 改名为 hive-site.xml文件并修改

     cp hive-default.xml.template hive-site.xml
    

    修改相关配置

    1. 将 hive-site.xml中的{system:java.io.tmpdir}改为hive的本地临时目录,将{system:user.name}改为用户名。(共有4处需要修改)

    没有hive的本地临时目录,先到hive目录下创建本地临时目录 tmp

      <property>
        <name>hive.exec.local.scratchdir</name>
        <value>/usr/local/scr/hive/tmp/root</value>
      </property>
      
      <property>
        <name>hive.downloaded.resources.dir</name>
        <value>/usr/local/scr/hive/tmp/${hive.session.id}_resources</value>
      </property>
    
      <property>
        <name>hive.server2.logging.operation.log.location</name>
        <value>/usr/local/scr/hive/tmp/root/operation_logs</value>
      </property>
    
      <property>
        <name>hive.querylog.location</name>
        <value>/usr/local/scr/hive/tmp/root</value>
      </property>
    
    1. 数据库相关配置
    # 数据库jdbc地址
      <property>
        <name>javax.jdo.option.ConnectionURL</name>
        <value>jdbc:mysql://master2:3306/hive?createDatabaseIfNotExist=true&amp;characterEncoding=UTF-8&amp;useSSL=false</value>
      </property>
      
    # 数据库的驱动类名称
    # 新版本8.0版本的驱动为com.mysql.cj.jdbc.Driver
    # 旧版本5.x版本的驱动为com.mysql.jdbc.Driver
      <property>
        <name>javax.jdo.option.ConnectionDriverName</name>
        <value>com.mysql.cj.jdbc.Driver</value>
      </property>
      
    # 数据库用户名
      <property>
        <name>javax.jdo.option.ConnectionUserName</name>
        <value>root</value>
      </property>
     
    # 数据库密码
       <property>
        <name>javax.jdo.option.ConnectionPassword</name>
        <value>passwd</value> 
      </property>
    
    
    1. 配置hive-log4j2.properties

    复制并更名hive-log4j2.properties.template为 hive-log4j2.properties文件

     cp hive-log4j.properties.template hive-log4j.properties
    

    修改配置

    hive.log.dir=/usr/local/scr/hive/tmp/root
    
    1. 配置hive-env.sh文件

    复制并更名hive-env.sh.template为 hive-env.sh文件

    [root@master1 conf]# cp hive-env.sh.template hive-env.sh
    [root@master1 conf]# vi hive-env.sh
    

    修改配置

    # Set HADOOP_HOME to point to a specific hadoop install directory
    export HADOOP_HOME=/usr/local/scr/hadoop
    
    # Hive Configuration Directory can be controlled by:
    export HIVE_CONF_DIR=/usr/local/scr/hive/conf
    
    # Folder containing extra ibraries required for hive compilation/execution can be controlled by:
    export HIVE_AUX_JARS_PATH=/usr/local/scr/hive/lib
    
    • 启动hive

    进入mysql,创建Hive数据库

    在这里插入图片描述

    注意:将{HADOOP_HOME}/share/hadoop/yarn/lib目录下的jline-0.9.94.jar替换成hive/lib下的jline-2.12.jar

    cp /usr/local/scr/hive/lib/jline-2.12.jar /usr/local/scr/hadoop/share/hadoop/yarn/lib/
    mv jline-0.9.94.jar /media/
    

    进入hive的bin目录,进行初始化操作

    schematool -dbType mysql -initSchema
    

    启动hive

    [root@master1 ~]# hive
    

    最后,记得点赞哦!!!ღ( ´・ᴗ・` )比心!!!

    系列文章:

    Hadoop HA高可用+Zookeeper搭建 一站式解決方案!!!
    【Hadoop大数据平台组件搭建系列】——Hadoop完全分布式搭建(基于CentOS7.4) 一站式解决!!!
    【Hadoop大数据平台组件搭建系列(一)】——Zookeeper组件配置
    【Hadoop大数据平台组件搭建系列(二)】——Sqoop组件配置
    【Hadoop大数据平台组件搭建系列(三)】——Hive组件配置
    【Hadoop大数据平台组件搭建系列(四)】——Kafka组件配置
    【Hadoop大数据平台组件搭建系列(五)】——MySQL组件配置(tar源码安装)
    【Hadoop大数据平台组件搭建系列(六)】——Spark完全分布式组件配置
    【Hadoop大数据平台组件搭建系列(七)】——HBase完全分布式组件配置
    在这里插入图片描述

    展开全文
  • 1. 将hadoop2.9.2的软件,解压到window中,路径不能有中文,...替换客户端工具。 3. 配置环境变量 HADOOP_HOME=hadoop安装路径 PATH=hadoop安装路径/bin 4. 重启IDEA
  • Hadoop是一款开源的大数据通用处理平台,其提供了分布式存储和分布式离线计算,适合大规模数据、流式数据(写一次,读多次),不适合低延时的访问、大量的小文件以及频繁修改的文件。 *Hadoop由HDFS、YARN、MapReduce...

    Hadoop是一款开源的大数据通用处理平台,其提供了分布式存储和分布式离线计算,适合大规模数据、流式数据(写一次,读多次),不适合低延时的访问、大量的小文件以及频繁修改的文件。

    *Hadoop由HDFS、YARN、MapReduce组成。

    如果想学习Java工程化、高性能及分布式、深入浅出。微服务、Spring,MyBatis,Netty源码分析的朋友可以加我的Java高级交流:854630135,群里有阿里大牛直播讲解技术,以及Java大型互联网技术的视频免费分享给大家。

    Hadoop的特点:

    1. 高扩展(动态扩容):能够存储和处理千兆字节数据(PB),能够动态的增加和卸载节点,提升存储能力(能够达到上千个节点)
    2. 低成本:只需要普通的PC机就能实现,不依赖高端存储设备和服务器。
    3. 高效率:通过在Hadoop集群中分化数据并行处理,使得处理速度非常快。
    4. 可靠性:数据有多份副本,并且在任务失败后能自动重新部署。

    Hadoop的使用场景:

    • 日志分析,将数据分片并行计算处理。
    • 基于海量数据的在线应用。
    • 推荐系统,精准营销。
    • 搜索引擎。

    Hadoop生态圈:

     

    2.内部结构

    2.1 HDFS

     

    HDFS是分布式文件系统,存储海量的文件,其中HDFS中包含NameNode、DataNode、SecondaryNameNode组件等。

    Block数据块

    1. HDFS中基本的存储单元,1.X版本中每个Block默认是64M,2.X版本中每个Block默认是128M。
    2. 一个大文件会被拆分成多个Block进行存储,如果一个文件少于Block的大小,那么其实际占用的空间为文件自身大小。
    3. 每个Block都会在不同的DataNode节点中存在备份(默认备份数是3)

    DataNode

    1. 保存具体的Blocks数据。
    2. 负责数据的读写操作和复制操作。
    3. DataNode启动时会向NameNode汇报当前存储的数据块信息。

    NameNode

    1. 存储文件的元信息和文件与Block、DataNode的关系,NameNode运行时所有数据都保存在内存中,因此整个HDFS可存储的文件数受限于NameNode的内存大小。
    2. 每个Block在NameNode中都对应一条记录,如果是大量的小文件将会消耗大量内存,因此HDFS适合存储大文件。
    3. NameNode中的数据会定时保存到本地磁盘中(只有元数据),但不保存文件与Block、DataNode的位置信息,这部分数据由DataNode启动时上报和运行时维护。

    *NameNode不允许DataNode具有同一个Block的多个副本,所以创建的最大副本数量是当时DataNode的总数。

    *DataNode会定期向NameNode发送心跳信息,一旦在一定时间内NameNode没有接收到DataNode发送的心跳则认为其已经宕机,因此不会再给它任何IO请求。

    *如果DataNode失效造成副本数量下降并且低于预先设置的阈值或者动态增加副本数量,则NameNode会在合适的时机重新调度DataNode进行复制。

    SecondaryNameNode

    1. 定时与NameNode进行同步,合并HDFS中系统镜像,定时替换NameNode中的镜像。

    HDFS写入文件的流程

     

    1. HDFS Client向NameNode申请写入文件。
    2. NameNode根据文件大小,返回文件要写入的DataNode列表以及Block id (此时NameNode已存储文件的元信息、文件与DataNode、Block之间的关系)
    3. HDFS Client收到响应后,将文件写入第一个DataNode中,第一个DataNode接收到数据后将其写入本地磁盘,同时把数据传递给第二个DataNode,直到写入备份数个DataNode。
    4. 每个DataNode接收完数据后都会向前一个DataNode返回写入成功的响应,最终第一个DataNode将返回HDFS Client客户端写入成功的响应。
    5. 当HDFS Client接收到整个DataNodes的确认请求后会向NameNode发送最终确认请求,此时NameNode才会提交文件。

    *当写入某个DataNode失败时,数据会继续写入其他的DataNode,NameNode会重新寻找DataNode继续复制,以保证数据的可靠性。

    *每个Block都会有一个校验码并存放在独立的文件中,以便读的时候来验证数据的完整性。

    *文件写入完毕后,向NameNode发送确认请求,此时文件才可见,如果发送确认请求之前NameNode宕机,那么文件将会丢失,HDFS客户端无法进行读取。

    HDFS读取文件的流程

     

    如果想学习Java工程化、高性能及分布式、深入浅出。微服务、Spring,MyBatis,Netty源码分析的朋友可以加我的Java高级交流:854630135,群里有阿里大牛直播讲解技术,以及Java大型互联网技术的视频免费分享给大家。

    1. HDFS Client向NameNode申请读取指定文件。
    2. NameNode返回文件所有的Block以及这些Block所在的DataNodes中(包括复制节点)
    3. HDFS Client根据NameNode的返回,优先从与HDFS Client同节点的DataNode中直接读取(若HDFS Client不在集群范围内则随机选择),如果从DataNode中读取失败则通过网络从复制节点中进行读取。

    机架感知

     

    分布式集群中通常包含非常多的机器,由于受到机架槽位和交换机网口的限制,通常大型的分布式集群都会跨好几个机架,由多个机架上的机器共同组成一个分布式集群。

    机架内的机器之间的网络速度通常都会高于跨机架机器之间的网络速度,并且机架之间机器的网络通信通常受到上层交换机间网络带宽的限制。

    Hadoop默认没有开启机架感知功能,默认情况下每个Block都是随机分配DataNode,需要进行相关的配置,那么在NameNode启动时,会将机器与机架的对应信息保存在内存中,用于在HDFS Client申请写文件时,能够根据预先定义的机架关系合理的分配DataNode。

    Hadoop机架感知默认对3个副本的存放策略为:

    • 第1个Block副本存放在和HDFS Client所在的节点中(若HDFS Client不在集群范围内则随机选取)
    • 第2个Block副本存放在与第一个节点不同机架下的节点中(随机选择)
    • 第3个Block副本存放在与第2个副本所在节点的机架下的另一个节点中,如果还有更多的副本则随机存放在集群的节点中。

    *使用此策略可以保证对文件的访问能够优先在本机架下找到,并且如果整个机架上发生了异常也可以在另外的机架上找到该Block的副本。

    2.2 YARN

    YARN是分布式资源调度框架(任务计算框架的资源调度框架),主要负责集群中的资源管理以及任务调度并且监控各个节点。

    ResourceManager

    1. 是整个集群的资源管理者,管理并监控各个NodeManager。
    2. 处理客户端的任务请求。
    3. 启动和监控ApplicationMaster。
    4. 负责资源的分配以及调度。

    NodeManager

    1. 是每个节点的管理者,负责任务的执行。
    2. 处理来自ResourceManager的命令。
    3. 处理来自ApplicationMaster的命令。

    ApplicationMaster

    1. 数据切分,用于并行计算处理。
    2. 计算任务所需要的资源。
    3. 负责任务的监控与容错。

    任务运行在YARN的流程

     

    客户端提交任务请求到ResourceManager。

    1. ResourceManager生成一个ApplicationManager进程,用于任务的管理。
    2. ApplicationManager创建一个Container容器用于存放任务所需要的资源。
    3. ApplicationManager寻找其中一个NodeManager,在此NodeManager中启动一个ApplicationMaster,用于任务的管理以及监控。
    4. ApplicationMaster向ResourceManager进行注册,并计算任务所需的资源汇报给ResourceManager(CPU与内存)
    5. ResourceManager为此任务分配资源,资源封装在Container容器中。
    6. ApplicationMaster通知集群中相关的NodeManager进行任务的执行。
    7. 各个NodeManager从Container容器中获取资源并执行Map、Reduce任务。

    2.3 MapReduce

    已经为大家精心准备了大数据的系统学习资料,从Linux-Hadoop-spark-......,需要的小伙伴可以点击

    MapReduce是分布式离线并行计算框架,高吞吐量,高延时,原理是将分析的数据拆分成多份,通过多台节点并行处理,相对于Storm、Spark任务计算框架而言,MapReduce是最早出现的计算框架。

    MapReduce、Storm、Spark任务计算框架对比:

     

    MapReduce执行流程

    MapReduce将程序划分为Map任务以及Reduce任务两部分。

    Map任务处理流程

    1. 读取文件中的内容,解析成Key-Value的形式 (Key为偏移量,Value为每行的数据)
    2. 重写map方法,编写业务逻辑,生成新的Key和Value。
    3. 对输出的Key、Value进行分区(Partitioner类)
    4. 对数据按照Key进行排序、分组,相同key的value放到一个集合中(数据汇总)

    *处理的文件必须要在HDFS中。

    Reduce任务处理流程

    1. 对多个Map任务的输出,按照不同的分区,通过网络复制到不同的reduce节点。
    2. 对多个Map任务的输出进行合并、排序。
    3. 将reduce的输出保存到文件,存放在HDFS中。

    3.Hadoop的使用

    3.1 安装

    由于Hadoop使用Java语言进行编写,因此需要安装JDK。

     

    从CDH中下载Hadoop 2.X并进行解压,CDH是Cloudrea公司对各种开源框架的整合与优化(较稳定)

     

    • etc目录:Hadoop配置文件存放目录。
    • logs目录:Hadoop日志存放目录。
    • bin目录、sbin目录:Hadoop可执行命令存放目录。

    etc目录

     

    bin目录

     

    sbin目录

     

    3.2 Hadoop配置

    1.配置环境

    编辑etc/hadoop/hadoop-env.sh文件,修改JAVA_HOME配置项为本地JAVA的HOME目录,此文件是Hadoop启动时加载的环境变量。

     

    编辑/etc/hosts文件,添加主机名与IP的映射关系。

     

    2.配置Hadoop公共属性(core-site.xml)

    <configuration> 
     <!-- Hadoop工作目录,用于存放Hadoop运行时产生的临时数据 --> 
     <property> 
     <name>hadoop.tmp.dir</name> 
     <value>/usr/hadoop/hadoop-2.9.0/data</value> 
     </property> 
     <!-- NameNode的通信地址,1.x默认9000,2.x可以使用8020 --> 
     <property> 
     <name>fs.default.name</name> 
     <value>hdfs://192.168.1.80:8020</value> 
     </property> 
    </configuration> 
    

    3.配置HDFS(hdfs-site.xml)

    <configuration> 
     <!--指定block的副本数量(将block复制到集群中备份数-1个节点的DataNode中)--> 
     <property> 
     <name>dfs.replication</name> 
     <value>1</value> 
     </property> 
     <!-- 关闭HDFS的访问权限 --> 
     <property> 
     <name>dfs.permissions.enabled</name> 
     <value>false</value> 
     </property> 
    </configuration> 
    

    4.配置YARN(yarn-site.xml)

    <configuration> 
     <!-- 配置Reduce取数据的方式是shuffle(随机) --> 
     <property> 
     <name>yarn.nodemanager.aux-services</name> 
     <value>mapreduce_shuffle</value> 
     </property> 
    </configuration> 
    

    5.配置MapReduce(mapred-site.xml)

    <configuration> 
     <!-- 让MapReduce任务使用YARN进行调度 --> 
     <property> 
     <name>mapreduce.framework.name</name> 
     <value>yarn</value> 
     </property> 
    </configuration> 
    

    6.配置SSH

    由于在启动hdfs、yarn时都需要对用户的身份进行验证,因此可以配置SSH设置免密码登录。

    //生成秘钥 
    ssh-keygen -t rsa 
    //复制秘钥到本机 
    ssh-copy-id 192.168.1.80 
    

    3.3 启动HDFS

    1.格式化NameNode

     

    2.启动HDFS,将会启动NameNode、DataNode、SecondaryNameNode三个进程,可以通过jps命令进行查看。

     

     

     

     

    *若启动时出现错误,则可以进入logs目录查看相应的日志文件。

    当HDFS启动完毕后,可以访问http://localhost:50070进入HDFS的可视化管理界面,可以在此页面中监控整个HDFS集群的状况并且进行文件的上传以及下载。

     

    *进入HDFS监控页面下载文件时,会将请求重定向,重定向后的地址的主机名为NameNode的主机名,因此客户端本地的host文件中需要配置NameNode主机名与IP的映射关系。

    3.4 启动YARN

     

    启动YARN后,将会启动ResourceManager以及NodeManager进程,可以通过jps命令进行查看。

     

    当YARN启动完毕后,可以访问http://localhost:8088进入YARN的可视化管理界面,可以在此页面中查看任务的执行情况以及资源的分配。

    已经为大家精心准备了大数据的系统学习资料,从Linux-Hadoop-spark-......,需要的小伙伴可以点击

    3.5 使用Shell命令操作HDFS

    HDFS中的文件系统与Linux类似,由/代表根目录。

    如果想学习Java工程化、高性能及分布式、深入浅出。微服务、Spring,MyBatis,Netty源码分析的朋友可以加我的Java高级交流:854630135,群里有阿里大牛直播讲解技术,以及Java大型互联网技术的视频免费分享给大家。

    hadoop fs -cat <src>:显示文件中的内容。 
    hadoop fs -copyFromLocal <localsrc> <dst>:将本地中的文件上传到HDFS。 
    hadoop fs -copyToLocal <src> <localdst>:将HDFS中的文件下载到本地。 
    hadoop fs -count <path>:查询指定路径下文件的个数。 
    hadoop fs -cp <src> <dst>:在HDFS内对文件进行复制。 
    hadoop fs -get <src> <localdst>:将HDFS中的文件下载到本地。 
    hadoop fs -ls <path>:显示指定目录下的内容。 
    hadoop fs -mkdir <path>:创建目录。 
    hadoop fs -moveFromLocal <localsrc> <dst>:将本地中的文件剪切到HDFS中。 
    hadoop fs -moveToLocal <src> <localdst> :将HDFS中的文件剪切到本地中。 
    hadoop fs -mv <src> <dst> :在HDFS内对文件进行移动。 
    hadoop fs -put <localsrc> <dst>:将本地中的文件上传到HDFS。 
    hadoop fs -rm <src>:删除HDFS中的文件。 
    

    3.6 JAVA中操作HDFS

    /** 
     * @Auther: ZHUANGHAOTANG 
     * @Date: 2018/11/6 11:49 
     * @Description: 
     */ 
    public class HDFSUtils { 
     private static Logger logger = LoggerFactory.getLogger(HDFSUtils.class); 
     /** 
     * NameNode URL 
     */ 
     private static final String NAMENODE_URL = "192.168.1.80:8020"; 
     /** 
     * HDFS文件系统连接对象 
     */ 
     private static FileSystem fs = null; 
     static { 
     Configuration conf = new Configuration(); 
     try { 
     fs = FileSystem.get(URI.create(NAMENODE_URL), conf); 
     } catch (IOException e) { 
     logger.info("初始化HDFS连接失败:{}", e); 
     } 
     } 
     /** 
     * 创建目录 
     */ 
     public static void mkdir(String dir) throws Exception { 
     dir = NAMENODE_URL + dir; 
     if (!fs.exists(new Path(dir))) { 
     fs.mkdirs(new Path(dir)); 
     } 
     } 
     /** 
     * 删除目录或文件 
     */ 
     public static void delete(String dir) throws Exception { 
     dir = NAMENODE_URL + dir; 
     fs.delete(new Path(dir), true); 
     } 
     /** 
     * 遍历指定路径下的目录和文件 
     */ 
     public static List<String> listAll(String dir) throws Exception { 
     List<String> names = new ArrayList<>(); 
     dir = NAMENODE_URL + dir; 
     FileStatus[] files = fs.listStatus(new Path(dir)); 
     for (FileStatus file : files) { 
     if (file.isFile()) { //文件 
     names.add(file.getPath().toString()); 
     } else if (file.isDirectory()) { //目录 
     names.add(file.getPath().toString()); 
     } else if (file.isSymlink()) { //软或硬链接 
     names.add(file.getPath().toString()); 
     } 
     } 
     return names; 
     } 
     /** 
     * 上传当前服务器的文件到HDFS中 
     */ 
     public static void uploadLocalFileToHDFS(String localFile, String hdfsFile) throws Exception { 
     hdfsFile = NAMENODE_URL + hdfsFile; 
     Path src = new Path(localFile); 
     Path dst = new Path(hdfsFile); 
     fs.copyFromLocalFile(src, dst); 
     } 
     /** 
     * 通过流上传文件 
     */ 
     public static void uploadFile(String hdfsPath, InputStream inputStream) throws Exception { 
     hdfsPath = NAMENODE_URL + hdfsPath; 
     FSDataOutputStream os = fs.create(new Path(hdfsPath)); 
     BufferedInputStream bufferedInputStream = new BufferedInputStream(inputStream); 
     byte[] data = new byte[1024]; 
     int len; 
     while ((len = bufferedInputStream.read(data)) != -1) { 
     if (len == data.length) { 
     os.write(data); 
     } else { //最后一次读取 
     byte[] lastData = new byte[len]; 
     System.arraycopy(data, 0, lastData, 0, len); 
     os.write(lastData); 
     } 
     } 
     inputStream.close(); 
     bufferedInputStream.close(); 
     os.close(); 
     } 
     /** 
     * 从HDFS中下载文件 
     */ 
     public static byte[] readFile(String hdfsFile) throws Exception { 
     hdfsFile = NAMENODE_URL + hdfsFile; 
     Path path = new Path(hdfsFile); 
     if (fs.exists(path)) { 
     FSDataInputStream is = fs.open(path); 
     FileStatus stat = fs.getFileStatus(path); 
     byte[] data = new byte[(int) stat.getLen()]; 
     is.readFully(0, data); 
     is.close(); 
     return data; 
     } else { 
     throw new Exception("File Not Found In HDFS"); 
     } 
     } 
    } 
    

    3.7 执行一个MapReduce任务

    Hadoop中提供了hadoop-mapreduce-examples-2.9.0.jar,其封装了一些任务计算方法,可以直接进行调用。

     

    *使用hadoop jar命令执行JAR包。

    1.创建一个文件,将此文件上传到HDFS中。

     

    2.使用Hadoop提供的hadoop-mapreduce-examples-2.9.0.jar执行wordcount词频统计功能,然后在YARN管理页面中进行查看。

     

    YARN管理页面中可以查看任务的执行进度:

     

    3.当任务执行完毕后,可以查看任务的执行结果。

      

     

    *任务的执行结果将会放到HDFS的文件中。

    展开全文
  • hadoop大数据入门篇-shell常用命令(一)      linux是大数据开发入门必备掌握知识,今天给大家介绍下linux centos7一些常用的命令          &...
  • Apache Hadoop软件库是一个框架,允许使用简单的编程模型,在计算机集群分布式地处理大型数据集。 一、什么是Apache Hadoop? 1.1 定义和特性 可靠的、可扩展的、分布式计算开源软件。 Apache Hadoop软件...
  • BIGDAF(Big Data Application Firewall)是国内第一个网关级Hadoop大数据安全防火墙,也是目前唯一通过公安部认证的Hadoop安全防护产品,具备“软件-硬件-云”多样化产品形态。 BIGDAF由网管代理Gateway、管理...
  • 1.下载列表:winow和linux之间文件上传下载FileZilla jdk-7u79-linux-x64.tar.gz apache-maven-3.3.9-... hadoop-2.6.0-cdh5.8.0.tar.gz hadoop-native-64-2.6.0.tar hbase-1.2.0-cdh5.8.0.tar.gz hive-1...
  • 我们此处使用的是VM虚拟机,centOS6.5的系统,初学者建议装中文版的系统,方便查看,我这边也是先装中文版的系统,本文章主要讲解如何在搭建大数据平台之前要对虚拟机进行环境配置工作,我会在重要的步骤截图上传,...
  • [Hadoop大数据]——Hive部署入门教程 Hive是为了解决hadoop中mapreduce编写困难,提供给熟悉sql的人使用的。只要你对SQL有一定的了解,就能通过Hive写出mapreduce的程序,而不需要去学习hadoop中的...
  • 为解决上述问题和实现合理化、规范化数据管理,提供稳定、可靠和适配的数据服务能力,大数据平台的建设迫在眉睫。 另一方面,在对市场调研之后,由于我司业务处于政务环境网(与公有网进行了全方位隔离),只能通过...
  • 各种大数据框架近几年发展得如火如荼,比如Hadoop, MapReduce,Hive, Hbase, Storm, Spark, Flink, Kylin 等。 一、Hadoop核心组件 首先要介绍一下Hadoop,现在Hadoop分为3部分,分别是HDFS,Yarn和Mrv2 Hadoop ...
  • Hadoop大数据招聘网数据分析综合案例 Hadoop大数据综合案例1-Hadoop2.7.3伪分布式环境搭建 Hadoop大数据综合案例2-HttpClient与Python招聘网数据采集 Hadoop大数据综合案例3-MapReduce数据预处理 Hadoop大数据综合...
  • BIGDAF是国内第一个网关级Hadoop大数据安全防火墙,也是目前唯一通过公安部认证的Hadoop安全防护产品,具备“软件-硬件-云”多样化产品形态 官网 | www.datayuan.cn 微信公众号ID | datayuancn ...
  • 大数据是现如今的热门名词,而在大数据领域,Hadoop又是大数据的热门名词。尤其是对于大数据开发人员,基于Hadoop开发大数据平台,是主要的工作内容之一。学习大数据,其实重点也就是Hadoop开发技术学习,下面我们...
  • 搭建开发环境(eclipse,hdfs的jar包----hadoop的安装目录的share下) <dependency> <groupId>org.apache.hadoop</groupId> <artifactId>hadoop-client</artifactId> <...
  • Hadoop安装--大数据组件安装--史上最完整教程--手把手教会你安装 ——彻底揭开大数据技术的面纱,让小白彻底进入大数据技术领域 安装的Hadoop的生态圈组件有如下几个(以后会不断补充完善起来了)。 (1)Hadoop...
  • Hadoop基础组件学习-Yzg-2019-03-06 Hadoop基础组件学习文档.. 1 简介.. 4 HDFS. 5 HDFS读文件.. 6 HDFS写文件.. 7 Mapreduce 8 单词计数.. 9 数据去重.. 9 单表关联.. 10 多表关联.. 11 Hadoop流.. 12 ...
  • hadoop大数据平台手动搭建(二)-hadoop

    千次阅读 2017-03-31 14:09:07
    1.下载列表:winow和linux之间文件上传下载FileZilla  jdk-7u79-linux-x64.tar.gz ... hadoop-2.6.0-cdh5.8.0.tar.gz  hadoop-native-64-2.6.0.tar  hbase-1.2.0-cdh5.8.0.tar.gz  hive-1.1.0-c
  • Hadoop、Yarn、Spark是企业构建生产环境下大数据中心的关键技术,也是大数据处理的核心技术,是每个云计算大数据工程师必修课。   大数据时代的精髓技术在于Hadoop、Yarn、Spark,是大数据时代公司和个人必须掌握...
  • 在此之前我们已经创建...下面我们开始在虚拟机上安装hadoop,首先把hadoop的安装包上传到虚拟机的/opt目录下,然后运用命令 tar -zxf hadoop-2.6.5.tsr.gz -C /ysr/local,将Hadoop安装包解压到虚拟机master的/usr/l...
  • Hbase的引言: 一、什么是Hbase: hbase是Apache 组织... hbase是基于Hadoop的一个NoSQL产品 Column类型的NoSQL。 hbase是Google BigTable的开源实现, 数据存储于Hdfs上。 hbase运行亿级别数据查询时,效率可...
  • 近期对hadoop生态的大数据框架进行了实际的部署测试,并结合ArcGIS平台的矢量大数据分析产品进行空间数据挖掘分析。本系列博客将进行详细的梳理、归纳和总结,以便相互交流学习。A. 部署规划及节点功能:192.168.10....

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 14,130
精华内容 5,652
关键字:

hadoop大数据替换