282110318蒋立豪分布并行计算机技术.docx

282110318蒋立豪分布并行计算机技术.docx

《282110318蒋立豪分布并行计算机技术.docx》由会员分享，可在线阅读，更多相关《282110318蒋立豪分布并行计算机技术.docx（20页珍藏版）》请在冰豆网上搜索。

282110318蒋立豪分布并行计算机技术

2018级“分布并行计算机技术”试卷

学号：

姓名：

蒋立豪专业：

计算机技术

利用不少于3台计算机组成集群系统，利用相关软件平台进行大数据并行处理。

设计与实现内容：

1.自己下载或利用各自实验室已有的数据集（不小于100MB），编程实现大数据并行处理功能，撰写完整的设计、实验文档。

编程语言自定。

2.对数据集进行详细说明，具体定义并行处理需求。

3.撰写Spark环境安装及该平台下的程序设计文档。

4.实验结果分析与优化建议。

要求：

1．不需要单独的封面（本页为第1页及封面）

2．A4纸张纵向打印（最好双面打印）

3．左侧装订

4．正文小四号宋体，1.25倍行距

5．提交截止日期：

2018年12月31日（过期无效）

6．提交方式：

纸质版+电子版

7．提交地址：

B603，希望班长收齐后统一提交

8．电子版提交内容：

文档及源程序、执行程序和数据集

9．文件名：

文档名：

-蒋立豪-分布并行计算机技术.docx

数据集：

-蒋立豪-count_及WordCount

上述红色斜体部分用具体内容代替，-为半角符号。

不符合上述要求者将以0分计

1Hadoop集群的搭建

1.1基础环境

在Linux上安装Hadoop之前，需要先安装Jdk1.7.0_181。

（1）查看当前Java版本

（2）连接到APTServer，更新软件包信息

sudoapt-getupdate

（3）使用apt-get安装JDK

sudoapt-getinstalldefault-jdk

（4）配置环境变量。

修改配置文件vi/etc/profile，在最后下添加:

exportJAVA_HOME=/usr/lib/jvm/java-7-openjdk-amd64

exportPATH=${JAVA_HOME}/bin:

${PATH}

exportHADOOP_CLASSPATH=${JAVA_HOME}/lib/tools.jar

然后刷新配置文件：

source~/.bashrc

（3）查询JAVA安装路径

update-alternatives--displayjava

1.2集群规划如下表所示：

主机名

内部IP

HDFS

master

192.168.56.100

NameNode

data1

192.168.56.101

DataNode

data2

192.168.56.102

Datanode

data3

192.168.56.103

DataNode

1.3免登陆（直接用root用户）

（1）关闭防火墙

sudosystemctlstopfirewalld.service

（2）关闭开机启动

sudosystemctldisablefirewalld.service

（3）免密码登录：

cd/root/.ssh/

ssh-keygen-trsa

（4）将公钥拷贝到其它机器上，实现免密码登录

ssh-copy-iddata1

ssh-copy-iddata2

ssh-copy-iddata3

这样会在data1的/root/.ssh/目录下生成一个authorized_keys就可以实现master免登录到data1,如下：

sshdata1

1.4安装Hadoop

（1）解压缩:

sudotar-zxvfHadoop-2.6.4.tar.gz

（2）移动hadoop-2.6.4目录到/usr/local/hadoop

sudomvHadoop-2.6.4/usr/local/hadoop

（3）修改环境变量。

修改配置文件：

~/.bashrc，并在在最后下添加：

exportHADOOP_HOME=/usr/local/hadoop

exportPATH=$PATH:

$HADOOP_HOME/bin

exportPATH=$PATH:

$HADOOP_HOME/sbin

exportHADOOP_MAPRED_HOME=$HADOOP_HOME

exportHADOOP_COMMON_HOME=$HADOOP_HOME

exportHADOOP_HDFS_HOME=$HADOOP_HOME

exportYARN_HOME=$HADOOP_HOME

exportHADOOP_COMMON_LIB_NATIVE_DIR=$HADOOP_HOME/lib/native

exportHADOOP_OPTS="-DJava.library.path=$HADOOP_HOME/lib"

exportJAVA_LIBRARY_PATH=$HADOOP_HOME/lib/native:

$JAVA_LIBRARY_PATH

刷新配置文件令环境变量立马生效：

source~/.bashrc

（4）修改配置文件。

进入hadoop-2.7.2的配置目录：

/hadoop-2.7.2/etc/hadoop，依次修改core-site.xml、hdfs-site.xml、mapred-site.xml、yarn-site.xml以及slaves文件。

（5）master连接到data1,data2,data3，并创建HDFS目录

连接到data1虚拟机

sshdata1

删除HDFS所有目录

sudorm-rf/usr/local/hadoop/hadoop_data/hdfs

创建DataNode存储目录

mkdir-p/usr/local/hadoop/hadoop_data/hdfs/datanode

将目录的所有者更改为hduser

dudochown-Rhduser:

hduser/usr/local/Hadoop

data2,data3依照以上步骤执行。

（6）启动。

格式化：

./bin/hdfsnamenode-format；

启动dfs：

./sbin/start-dfs.sh

（7）查看。

通过执行jps命令查看搭建结果如下：

2Spark集群搭建

2.1基础环境

在Linux上安装Spark之前，先安装了两个程序：

JDK1.7或更高版本和scala。

JDK已经在安装Hadoop的时候安装了，因此只需要安装scala。

（1）下载scala-2.11.8.tar，tar-zxvf解压以后，生成scala-2.11.8目录

（2）在/etc/profile里配置scala的环境变量，添加：

exportSCALA_HOME=/data/wanglei/soft/scala-2.11.8

exportPATH=$SCALA_HOME/bin:

$PATH

（3）使配置变量立即生效:

source/etc/profile

2.2集群规划如下表所示：

主机名

内部IP

Spark

master

192.168.242.134

ResourceManager

data1

192.168.242.135

NodeManager

data2

192.168.242.136

NodeManager

data3

192.168.242.137

NodeManager

2.3安装Spark

（1）下载二进制包spark-2.1.0-bin-hadoop2.7.tgz并进行解压。

tar-zxvfspark-2.1.0-bin-hadoop2.7.tgz

移动到对应的目录中

mvhadoop-2.7.3/opt

（2）修改配置文件

修改/etc/profie，增加如下内容：

exportSPARK_HOME=/opt/spark-2.1.0-bin-hadoop2.7/

exportPATH=$PATH:

$SPARK_HOME/bin

复制spark-env.sh.template成spark-env.sh

cpspark-env.sh.templatespark-env.sh

修改$SPARK_HOME/conf/spark-env.sh，添加如下内容：

exportJAVA_HOME=/usr/local/jdk1.8.0_121

exportSCALA_HOME=/usr/share/scala

exportHADOOP_HOME=/opt/hadoop-2.7.3

exportHADOOP_CONF_DIR=/opt/hadoop-2.7.3/etc/hadoop

exportSPARK_MASTER_IP=192.168.242.134

exportSPARK_MASTER_HOST=192.168.242.134

exportSPARK_WORKER_MEMORY=1g

exportSPARK_WORKER_CORES=2

exportSPARK_HOME=/opt/spark-2.1.0-bin-hadoop2.7

exportSPARK_DIST_CLASSPATH=$（/opt/hadoop-2.7.3/bin/hadoopclasspath）

复制slaves.template成slaves

cpslaves.templateslaves

修改$SPARK_HOME/conf/slaves，添加如下内容：

data1

data2

data3

（3）将配置好的spark文件复制到data1、data2、data3节点。

scp/opt/spark-2.1.0-bin-hadoop2.7root@data1:

/opt

scp/opt/spark-2.1.0-bin-hadoop2.7root@data2:

/opt

scp/opt/spark-2.1.0-bin-hadoop2.7root@data3:

/opt

（4）修改data1、data2、data3配置。

修改/etc/profie，增加如下内容：

exportSPARK_HOME=/opt/spark-2.1.0-bin-hadoop2.7/

exportPATH=$PATH:

$SPARK_HOME/bin

修改$SPARK_HOME/conf/spark-env.sh，添加如下内容：

exportSPARK_LOCAL_IP=192.168.242.134改成data1、data2、data3对应节点的IP。

（5）在slave7节点启动集群。

/opt/spark-2.1.0-bin-hadoop2.7/sbin/start-all.sh

（6）查看。

通过执行jps命令查看搭建结果如下：

3试验

3.1试验内容

“数据计数”是许多实际任务执行时要完成的第一项工作，比如学生成绩统计、大数据挖掘与处理、商店选址等。

随着社会发展，数据量呈指数增加，分布并行技术的具有强大的数值计算能力和数据处理能力，因此，使用分布并行处理技术可以有效提高数据计数的效率，促进工作的有效完成。

本次试验中，我使用Shell内置的$RANDOM生成0到25的随机正整数，通过循环生成107M的数据，分别在hadoop集群和Spark集群中对这些数据计数。

生成数据集的代码如下所示：

foriin{1..10000000};do

        echo$（（$RANDOM%26））

done;

执行四次，即可生成104.6M的数据到count.txt文件。

计数的代码采用java编写，代码如下：

importjava.io.IOException;

importjava.util.StringTokenizer;

importorg.apache.hadoop.conf.Configuration;

importorg.apache.hadoop.fs.Path;

importorg.apache.hadoop.io.IntWritable;

importorg.apache.hadoop.io.Text;

importorg.apache.hadoop.mapreduce.Job;

importorg.apache.hadoop.mapreduce.Mapper;

importorg.apache.hadoop.mapreduce.Reducer;

importorg.apache.hadoop.mapreduce.lib.input.FileInputFormat;

importorg.apache.hadoop.mapreduce.lib.output.FileOutputFormat;

publicclassWordCount{

publicstaticclassTokenizerMapper

extendsMapper{

privatefinalstaticIntWritableone=newIntWritable

（1）;

privateTextword=newText（）;

publicvoidmap（Objectkey,Textvalue,Contextcontext

）throwsIOException,InterruptedException{

StringTokenizeritr=newStringTokenizer（value.toString（））;

while（itr.hasMoreTokens（））{

word.set（itr.nextToken（））;

context.write（word,one）;

}

}

}

publicstaticclassIntSumReducer

extendsReducer{

privateIntWritableresult=newIntWritable（）;

publicvoidreduce（Textkey,Iterablevalues,

Contextcontext

）throwsIOException,InterruptedException{

intsum=0;

for（IntWritableval:

values）{

sum+=val.get（）;

}

result.set（sum）;

context.write（key,result）;

}

}

publicstaticvoidmain（String[]args）throwsException{

Configurationconf=newConfiguration（）;

Jobjob=Job.getInstance（conf,"wordcount"）;

job.setJarByClass（WordCount.class）;

job.setMapperClass（TokenizerMapper.class）;

job.setCombinerClass（IntSumReducer.class）;

job.setReducerClass（IntSumReducer.class）;

job.setOutputKeyClass（Text.class）;

job.setOutputValueClass（IntWritable.class）;

FileInputFormat.addInputPath（job,newPath（args[0]））;

FileOutputFormat.setOutputPath（job,newPath（args[1]））;

System.exit（job.waitForCompletion（true）?

0:

1）;

}

}

3.2使用Hadoop进行计数

（1）上传数据，并列出文件

（2）执行程序，命令如下：

（3）程序运行结果

程序的运行时间为11：

44：

24到15：

45：

56，一共用了1分钟27秒。

（4）运行结果如下图所示：

（5）查看计数输出目录

如图所示，生成了两个文件。

（6）查看计数输出文件

如图所示，会列出每个数字出现的次数

3.3使用Spark进行排序

（1）创建WordCount的数据目录，切换至目录

（2）运行程序

（3）实验结果

3.4实验结果对比分析

在数据集大小固定，为107.2M的前提下，主要对比hadoop和spark进行计数的时间。

Hadoop中无法输出运行时间，因此我通过记录程序运行开始和截至的时间进行计算程序运行的总时间，为1m32s，Spark中，可以得到程序的运行时间为41.23s。

因此，对比结果如下所示：

集群

运行时间

Hadoop

1m32s

Spark

41.23

由对比结果可知：

在进行全排序的分布式计算中，Spark的计算能力远远优于Hadoop。

3.5Hadoop和Spark的比较

Hadoop就是解决了大数据的可靠存储和处理。

其中，HDFS在由普通PC组成的集群上提供高可靠的文件存储，通过将块保存多个副本的办法解决服务器或硬盘坏掉的问题；MapReduce，通过简单的Mapper和Reducer的抽象提供一个编程模型，在一个由几十台上百台的PC组成的不可靠集群上并发地，分布式地处理大量的数据集，而把并发、分布式（如机器间通信）和故障恢复等计算细节隐藏起来。

但是，MapRecue存在以下局限，使用起来比较困难。

抽象层次低，需要手工编写代码来完成，使用上难以上手；只提供两个操作，Map和Reduce，表达力欠缺；一个Job只有Map和Reduce两个阶段（Phase），复杂的计算需要大量的Job完成，Job之间的依赖关系是由开发者自己管理的；处理逻辑隐藏在代码细节中，没有整体逻辑；中间结果也放在HDFS文件系统；ReduceTask需要等待所有MapTask都完成后才可以开始；时延高，只适用Batch数据处理，对于交互式数据处理，实时数据处理的支持不够对于迭代式数据处理性能比较差。

Spark是一个新兴的大数据处理的引擎，主要特点是提供了一个集群的分布式内存抽象，以支持需要工作集的应用，这个抽象就是RDD。

RDD就是一个不可变的带分区的记录集合，RRD也是Spark中的编程模型。

Spark提供了RDD上的两类操作，转换和动作。

转换是用来定义一个新的RDD，包括map,flatMap,filter,union,sample,join,groupByKey,cogroup,ReduceByKey,cros,sortByKey,mapValues等，动作是返回一个结果，包括collect,reduce,count,save,lookupKey。

在Spark中，所有RDD的转换都是是惰性求值的。

RDD的转换操作会生成新的RDD，新的RDD的数据依赖于原来的RDD的数据，每个RDD又包含多个分区。

那么一段程序实际上就构造了一个由相互依赖的多个RDD组成的有向无环图。

并通过在RDD上执行动作将这个有向无环图作为一个Job提交给Spark执行。

Spark对于有向无环图Job进行调度，确定阶段，分区，流水线，任务和缓存，进行优化，并在Spark集群上运行Job。

RDD之间的依赖分为宽依赖（依赖多个分区）和窄依赖（只依赖一个分区），在确定阶段时，需要根据宽依赖划分阶段,根据分区划分任务。

Spark支持故障恢复的方式也不同，提供两种方式，Linage，通过数据的血缘关系，再执行一遍前面的处理，Checkpoint，将数据集存储到持久存储中。

Spark为迭代式数据处理提供更好的支持。

每次迭代的数据可以保存在内存中，而不是写入文件。

因此，Spark的性能相比Hadoop有很大提升。

4优化

Hadoop和Spark都可以根据各方面的调优实现性能的优化。

4.1Hadoop的优化

（1）参数调优。

通过修改hadoop三个配置文件的参数来提高性能。

主要有三个文件core-site.xml、hdfs-site.xml、mapred-site.xml。

对于常用的参数设置，需要整体把握的一些主体思想：

如果reduce个数设置太小，单个reducetask执行速度很慢，这样出错重新调试的时间花销就比较多；如果怕Reduce个数设置太大，Shuffle开销及调度开销很大，job输出大量文件，影响后续Job的执行；单个reducetask处理数据量介于1至10G之间，reduce的个数要少于map的个数。

压缩中间数据，用CPU换磁盘和网络，设press.map.output设为true，减少磁盘操作和网络传输数据量。

（2）作业调度调优。

虽然参数的配置可以很好的提高性能，但是，这些方法只是静态的对集群性能做优化，在job运行的时候无法动态的修改配置文件并使加载生效，因此我们需要考虑动态的性能调优。

作业调度调优算法有默认调度算法FIFO、公平调度算法默认调度算法和计算能力调度算法。

默认调度算法按照作业的优先级高低，再按照到达时间的先后选择被执行的作业，这种方法简单、易于实现，同时也减轻了jobtracker的负担。

但是它对所有的作业都一视同仁，没有考虑到作业的紧迫程度。

公平调度算法中，公平调度器按资源池来组织作业，并把资源公平的分到这些资源池里面，用户提交的作业将会放进一个能够公平共享资源的池中。

每个作业池设定了一个最低资源保障，当一个池中包含job时，它至少可以获得minimumshare的资源。

池中的作业获得一定份额的资源。

可以通过配置文件限制每个池中的作业数量。

缺省情况下，每个作业池中选择将要执行的作业的策略是FIFO策略，先按照优先级高低排序，然后再按照提交时间排序。

计算能力调度算法支持多个队列，某个作业可被提交到某一个队列中。

每个队列会配置一定比例的计算资源，且所有提交到队列中的作业共享该队列中的资源。

该算法具有较高的灵活性，空闲资源会被分配给那些未达到资源使用上限的队列，当某个未达到资源的队列需要资源时，一旦出现空闲资源，便会分配给他们；支持优先级和多重租赁。

除此之外，该算法基于资源的调度，支持资源密集型作业，允许作业使用的资源量高于默认值，进而可容纳不同资源需求的作业。

不过，当前仅支持内存资源的调度。

作业调度算法虽然可以提高Hadoop的性能，但对于只有一个jobtracker的Hadoop框架来说，经常会出现大规模的作业提交和运行，在其上运行的调度算法一定不能过于复杂，否则将会给jobtracker带来繁重的工作压力，一旦jobtracker宕机，后果将不堪设想，究竟该如何调度作业必须视具体情况而定。

（3）程序编写调优正确的配置集群。

如果是一大批MR程序，如果可以设置一个Combiner，Combiner可减少MapTask中间输出结果，从而减少各个ReduceTask的远程拷贝数据量，最终表现为MapTask和ReduceTask执行