大数据Spark03_集群环境搭建及任务提交的方式

来源：互联网发布：linux cal windows 编辑：程序博客网时间：2024/05/29 05:53

Spark四种部署方式
Spark应用程序在集群上部署运行时，可以由不同的组件为其提供资源管理调度服务（资源包括CPU、内存等）。比如，可以使用自带的独立集群管理器（standalone），或者使用YARN，也可以使用Mesos。因此，Spark包括三种不同类型的集群部署方式，包括standalone、Spark on Mesos和Spark on YARN。
1.Local模式：此模式适合在开发工具中进行测试。
2.standalone模式
与MapReduce1.0框架类似，Spark框架本身也自带了完整的资源调度管理服务，可以独立部署到一个集群中，而不需要依赖其他系统来为其提供资源管理调度服务。在架构的设计上，Spark与MapReduce1.0完全一致，都是由一个Master和若干个Slave构成，并且以槽（slot）作为资源分配单位。不同的是，Spark中的槽不再像MapReduce1.0那样分为Map 槽和Reduce槽，而是只设计了统一的一种槽提供给各种任务来使用。
3.Spark on Mesos模式
Mesos是一种资源调度管理框架，可以为运行在它上面的Spark提供服务。Spark on Mesos模式中，Spark程序所需要的各种资源，都由Mesos负责调度。由于Mesos和Spark存在一定的血缘关系，因此，Spark这个框架在进行设计开发的时候，就充分考虑到了对Mesos的充分支持，因此，相对而言，Spark运行在Mesos上，要比运行在YARN上更加灵活、自然。目前，Spark官方推荐采用这种模式，所以，许多公司在实际应用中也采用该模式。
4. Spark on YARN模式
Spark可运行于YARN之上，与Hadoop进行统一部署，即“Spark on YARN”，其架构如图9-13所示，资源管理和调度依赖YARN，分布式存储则依赖HDFS。

一、Local 模式搭建
Local模式也就是说不是分布式模式，我们只需要在一台机器上就可以搭建。其实它可以运行在其他不同的多种模式比如下面的Standalone、Yarn、Mesos等模式。
将下载好的tgz包移动weekend13节点的/usr/local目录下重命名conf目录下的log4j.properties.template为log4j.properties然后修改其日志级别为WARN这样启动spark shell的时候输出的日志信息就会少些。
log4j.rootCategory=INFO, console
log4j.rootCategory=WARN, console
在Sparks hell中SparkContext对象自动的创建并命名了为sc ,一旦有了sc我们就通过sc创建RDD。
后续的所有基于RDD的操作都可以执行。
启动成功后可通过 ipaddress:4040 访问SparkUI界面查看任务和集群的信息。
最后，可以使用命令“:quit”退出Spark Shell，如下所示：
二、Standalone集群搭建

在节点weekend10、weekend11、weekend12、weekend13上搭建Spark standalone集群

将下载好的tgz包移动到各节点的/usr/local目录下

进入conf目录下重命名slaves.template 为slaves 、spark-env.sh.template 为 spark-env.sh

vi slaves ：添加从节点（worker节点）weekend11、weekend12

vi spark-env.sh ：

Note:主节点是weekend10 ，从节点weekend11、weekend12

将weekend10节点上配置好的spark-1.6.0复制到weekend11、weekend12节点上

在节点weekend10的sbin目录下执行命令：

./start-all.sh

查看节点进程

查看Web界面：weekend10:8080

修改端口的方式

vi start-master.sh

提交任务测试

进入spark的bin目录下执行lib包中的例子

执行命令：

./spark-submit --master spark://weekend10:7077 --class org.apache.spark.examples.SparkPi ../lib/spark-examples-1.6.0-hadoop2.6.0.jar 100

在节点weekend13上搭建Driver客户端

将weekend10节点上的spark复制到weekend13节点上然后删除 conf下的slaves 再将spark-env.sh配置中的修改内容注释掉。

进入spark bin目录下再次执行命令：

./spark-submit --master spark://weekend10:7077 --class org.apache.spark.examples.SparkPi ../lib/spark-examples-1.6.0-hadoop2.6.0.jar 100

三、使用开发工具书写spark程序进行测试

开发工具有ScalaIDE、eclipse、IDEA等，包的管理工具可以使用Maven。

1、初始化SparkContext

val conf=new SparkConf()

conf.setMaster("local").setAppName("My App")

val sc=new SparkContext(conf)

初始化SparkContext的时候需要传入两个参数：

A Cluster URL:设置为Local 表示运行spark是在本地机器的一个线程中不需要连接到集群中。

An Application name:在集群的管理界面中可以显示程序的名称。

2、基于SparkCOntext创建RDD

3、基于RDD执行一系列的转换和行动算子

4、程序结束使用 sc.stop()关闭spark

四、Spark独立应用程序编程、打包、提交运行

使用 Scala 编写的程序需要使用 sbt 进行编译打包，相应的，Java 程序使用 Maven 编译打包，而 Python 程序通过 spark-submit 直接提交。

编写Scala独立应用程序

1、安装sbt

sbt是一款Spark用来对scala编写程序进行打包的工具。Spark 中没有自带 sbt，需要单独下载sbt-launch.jar

（https://repo.typesafe.com/typesafe/ivy-releases/org.scala-sbt/sbt-launch/0.13.11/sbt-launch.jar）

将下载好的 sbt-launch.jar 包拷贝到/usr/local/sbt目录下

接着在 /usr/local/sbt 中创建 sbt 脚本（vim ./sbt），添加如下内容：

#!/bin/bashSBT_OPTS="-Xms512M -Xmx1536M -Xss1M -XX:+CMSClassUnloadingEnabled -XX:MaxPermSize=256M"java $SBT_OPTS -jar `dirname $0`/sbt-launch.jar "$@"

保存后，为 ./sbt 脚本增加可执行权限：chmod u+x ./sbt

最后运行如下命令，检验 sbt 是否可用（请确保电脑处于联网状态，首次运行会处于 “Getting org.scala-sbt sbt 0.13.11 ...” 的下载状态，请耐心等待。笔者等待了 7 分钟才出现第一条下载提示）：

./sbt sbt-version

只要能得到如下图的版本信息就没问题：

2.编写Scala应用程序
在终端中执行如下命令创建一个文件夹 sparkapp 作为应用程序根目录：

cd ~           # 进入用户主文件夹
mkdir ./sparkapp        # 创建应用程序根目录
mkdir -p ./sparkapp/src/main/scala     # 创建所需的文件夹结构

在 ./sparkapp/src/main/scala 下建立一个名为 SimpleApp.scala 的文件（vi ./sparkapp/src/main/scala/SimpleApp.scala），添加代码如下（目前不需要理解代码的具体含义，只需要理解如何编译运行代码就可以）：

/* SimpleApp.scala */
import org.apache.spark.SparkContext
import org.apache.spark.SparkContext._
import org.apache.spark.SparkConf
 
object SimpleApp {
    def main(args: Array[String]) {
        val logFile = "file:///usr/local/spark-1.6.0/README.md" // Should be some file on your system
        val conf = new SparkConf().setAppName("Simple Application")
        val sc = new SparkContext(conf)
        val logData = sc.textFile(logFile, 2).cache()
        val numAs = logData.filter(line => line.contains("a")).count()
        val numBs = logData.filter(line => line.contains("b")).count()
        println("Lines with a: %s, Lines with b: %s".format(numAs, numBs))
    }
}

该程序计算 /usr/local/spark/README 文件中包含 "a" 的行数和包含 "b" 的行数。代码第8行的 /usr/local/spark-1.6.0 为 Spark 的安装目录，如果不是该目录请自行修改。不同于 Spark shell，独立应用程序需要通过 val sc = new SparkContext(conf) 初始化 SparkContext，SparkContext 的参数 SparkConf 包含了应用程序的信息。

3.使用sbt打包Scala程序

该程序依赖 Spark API，因此我们需要通过 sbt 进行编译打包。请在./sparkapp 中新建文件 simple.sbt（vi ./sparkapp/simple.sbt），添加内容如下，声明该独立应用程序的信息以及与 Spark 的依赖关系：

name := "Simple Project"version := "1.0"scalaVersion := "2.10.5"libraryDependencies += "org.apache.spark" %% "spark-core" % "1.6.0"

文件 simple.sbt 需要指明 Spark 和 Scala 的版本。在上面的配置信息中，scalaVersion用来指定scala的版本，sparkcore用来指定spark的版本，这两个版本信息都可以在之前的启动 Spark shell 的过程中，从屏幕的显示信息中找到。

为保证 sbt 能正常运行，先执行如下命令检查整个应用程序的文件结构：

    cd ~/sparkapp
    find .

文件结构应如下图所示：

SimpleApp的文件结构

接着，我们就可以通过如下代码将整个应用程序打包成 JAR（首次运行同样需要下载依赖包）：

    /usr/local/sbt/sbt package

对于刚安装好的Spark和sbt而言，第一次运行上面的打包命令时，会需要几分钟的运行时间，因为系统会自动从网络上下载各种文件。后面再次运行上面命令，就会很快，因为不再需要下载相关文件。
打包成功的话，会输出如下内容：

hadoop@dblab:~/sparkapp$ /usr/local/sbt/sbt package
OpenJDK 64-Bit Server VM warning: ignoring option MaxPermSize=256M; support was removed in 8.0
[info] Set current project to Simple Project (in build file:/home/hadoop/sparkapp/)
[success] Total time: 2 s, completed 2017-2-19 15:45:29

生成的 jar 包的位置为 usr/local/target/scala-2.10/simple-project_2.11-1.0.jar。

4.通过 spark-submit 运行程序

最后，我们就可以将生成的 jar 包通过 spark-submit 提交到 Spark 中运行了，命令如下：

/usr/local/spark/bin/spark-submit --class "SimpleApp" ~/sparkapp/target/scala-2.11/simple-project_2.11-1.0.jar
#上面命令执行后会输出太多信息，可以不使用上面命令，而使用下面命令查看想要的结果
/usr/local/spark/bin/spark-submit --class "SimpleApp" ~/sparkapp/target/scala-2.11/simple-project_2.11-1.0.jar 2>&1 | grep "Lines with a:"

最终得到的结果如下：

Lines with a: 62, Lines with b: 30

自此，你就完成了你的第一个 Spark 应用程序了。

Java独立应用编程

1、安装Maven

手动安装maven。可以访问maven官方下载自己下载。（http://apache.fayea.com/maven/maven-3/3.3.9/binaries/apache-maven-3.3.9-bin.zip）
选择安装在/usr/local/maven中：

unzip apache-maven-3.3.9-bin.zip

然后移动到/usr/local/maven 目录下

2.Java应用程序代码
在终端执行如下命令创建一个文件夹sparkapp2作为应用程序根目录

cd ~ #进入用户主文件夹
mkdir -p ./sparkapp2/src/main/java

在 ./sparkapp2/src/main/java 下建立一个名为 SimpleApp.java 的文件（vim ./sparkapp2/src/main/java/SimpleApp.java），添加代码如下：

/*** SimpleApp.java ***/
    import org.apache.spark.api.java.*;
    import org.apache.spark.api.java.function.Function;
 
    public class SimpleApp {
        public static void main(String[] args) {
            String logFile = "file:///usr/local/spark/README.md"; // Should be some file on your system
            JavaSparkContext sc = new JavaSparkContext("local", "Simple App",
                "file:///usr/local/spark/", new String[]{"target/simple-project-1.0.jar"});
            JavaRDD<String> logData = sc.textFile(logFile).cache();
 
            long numAs = logData.filter(new Function<String, Boolean>() {
                public Boolean call(String s) { return s.contains("a"); }
            }).count();
 
            long numBs = logData.filter(new Function<String, Boolean>() {
                public Boolean call(String s) { return s.contains("b"); }
            }).count();
 
            System.out.println("Lines with a: " + numAs + ", lines with b: " + numBs);
        }
    }

该程序依赖Spark Java API,因此我们需要通过Maven进行编译打包。在./sparkapp2中新建文件pom.xml(vim ./sparkapp2/pom.xml),添加内容如下，声明该独立应用程序的信息以及与Spark的依赖关系：

    <project>        <groupId>edu.berkeley</groupId>        <artifactId>simple-project</artifactId>        <modelVersion>4.0.0</modelVersion>        <name>Simple Project</name>        <packaging>jar</packaging>        <version>1.0</version>        <repositories>            <repository>                <id>Akka repository</id>                <url>http://repo.akka.io/releases</url>            </repository>        </repositories>        <dependencies>            <dependency> <!-- Spark dependency -->                <groupId>org.apache.spark</groupId>                <artifactId>spark-core_2.11</artifactId>                <version>2.1.0</version>            </dependency>        </dependencies>    </project>

关于Spark dependency的依赖关系，可以访问The Central Repository。搜索spark-core可以找到相关依赖关系信息。

3.使用maven打包java程序
为了保证maven能够正常运行，先执行如下命令检查整个应用程序的文件结构:

cd ~/sparkapp2
find

文件结构如下图：

接着，我们可以通过如下代码将这整个应用程序打包成Jar(注意：电脑需要保持连接网络的状态，而且首次运行mvn package命令时，系统会自动从网络下载相关的依赖包，同样消耗几分钟的时间，后面再次运行mvn package命令，速度就会快很多):

/usr/local/maven/bin/mvn package

如果运行上面命令后出现类似下面的信息，说明生成Jar包成功：

[INFO] ------------------------------------------------------------------------[INFO] BUILD SUCCESS[INFO] ------------------------------------------------------------------------[INFO] Total time: 6.583 s[INFO] Finished at: 2017-02-19T15:52:08+08:00[INFO] Final Memory: 15M/121M[INFO] ------------------------------------------------------------------------

4.通过spark-submit 运行程序

可以通过spark-submit提交应用程序，该命令的格式如下：

./bin/spark-submit   --class <main-class>  //需要运行的程序的主类，应用程序的入口点  --master <master-url>  //Master URL，下面会有具体解释  --deploy-mode <deploy-mode>   //部署模式  ... # other options  //其他参数  <application-jar>  //应用程序JAR包  [application-arguments] //传递给主类的主方法的参数

deploy-mode这个参数用来指定应用程序的部署模式，部署模式有两种：client和cluster，默认是client。当采用client部署模式时，就是直接在本地运行Driver Program，当采用cluster模式时，会在Worker节点上运行Driver Program。比较常用的部署策略是从网关机器提交你的应用程序，这个网关机器和你的Worker集群进行协作。在这种设置下，比较适合采用client模式，在client模式下，Driver直接在spark-submit进程中启动，这个进程直接作为集群的客户端，应用程序的输入和输出都和控制台相连接。因此，这种模式特别适合涉及REPL的应用程序。另一种选择是，如果你的应用程序从一个和Worker机器相距很远的机器上提交，那么采用cluster模式会更加合适，它可以减少Driver和Executor之间的网络迟延。

Spark的运行模式取决于传递给SparkContext的Master URL的值。Master URL可以是以下任一种形式：
* local 使用一个Worker线程本地化运行SPARK(完全不并行)
* local[*] 使用逻辑CPU个数数量的线程来本地化运行Spark
* local[K] 使用K个Worker线程本地化运行Spark（理想情况下，K应该根据运行机器的CPU核数设定）
* spark://HOST:PORT 连接到指定的Spark standalone master。默认端口是7077.
* yarn-client 以客户端模式连接YARN集群。集群的位置可以在HADOOP_CONF_DIR 环境变量中找到。
* yarn-cluster 以集群模式连接YARN集群。集群的位置可以在HADOOP_CONF_DIR 环境变量中找到。
* mesos://HOST:PORT 连接到指定的Mesos集群。默认接口是5050。

最后，针对上面编译打包得到的应用程序，可以通过将生成的jar包通过spark-submit提交到Spark中运行，如下命令：

/usr/local/spark/bin/spark-submit --class "SimpleApp" ~/sparkapp2/target/simple-project-1.0.jar
#上面命令执行后会输出太多信息，可以不使用上面命令，而使用下面命令查看想要的结果
/usr/local/spark/bin/spark-submit --class "SimpleApp" ~/sparkapp2/target/simple-project-1.0.jar 2>&1 | grep "Lines with a"

最后得到的结果如下:

Lines with a: 62, Lines with b: 30

二、Spark任务提交的方式

Standalone Client 提交任务
Standalone Cluster 提交任务
Yarn Cluster 提交任务
Yarn Client 提交任务

上述在weekend13节点上提交任务的方式是Standalone Client的方式。

Yarn模式两种提交任务方式

1. yarn-client提交任务方式

启动HDFS集群、在weeeknd10节点中的Spark目下下的spark-env.sh添加

export HADOOP_CONF_DIR=$HADOOP_HOME/etc/hadoop

最后再提交如下命令

提交命令

./spark-submit

--master yarn

--class org.apache.spark.examples.SparkPi ../lib/spark-examples-1.6.0-hadoop2.6.0.jar

100

或者

./spark-submit

--master yarn–client

--class org.apache.spark.examples.SparkPi ../lib/spark-examples-1.6.0-hadoop2.6.0.jar

100

或者

./spark-submit

--master yarn

--deploy-mode client

--class org.apache.spark.examples.SparkPi ../lib/spark-examples-1.6.0-hadoop2.6.0.jar

100

执行原理图解

执行流程

1. 客户端提交一个Application，在客户端启动一个Driver进程。

2. 应用程序启动后会向RS(ResourceManager)发送请求，启动AM(ApplicationMaster)的资源。

3. RS收到请求，随机选择一台NM(NodeManager)启动AM。这里的NM相当于Standalone中的Worker节点。

4. AM启动后，会向RS请求一批container资源，用于启动Executor.

5. RS会找到一批NM返回给AM,用于启动Executor。

6. AM会向NM发送命令启动Executor。

7. Executor启动后，会反向注册给Driver，Driver发送task到Executor,执行情况和结果返回给Driver端。

总结

Yarn-client模式同样是适用于测试，因为Driver运行在本地，Driver会与yarn集群中的Executor进行大量的通信，会造成客户机网卡流量的大量增加.

ApplicationMaster的作用：

1. 为当前的Application申请资源

2. 给NameNode发送消息启动Executor。

注意：ApplicationMaster有launchExecutor和申请资源的功能，并没有作业调度的功能。

2、yarn-cluster提交任务方式

提交命令

./spark-submit

--master yarn

--deploy-mode cluster

--class org.apache.spark.examples.SparkPi ../lib/spark-examples-1.6.0-hadoop2.6.0.jar

100

或者

./spark-submit

--master yarn-cluster

--class org.apache.spark.examples.SparkPi ../lib/spark-examples-1.6.0-hadoop2.6.0.jar

100

执行原理图解

执行流程

1. 客户机提交Application应用程序，发送请求到RS(ResourceManager),请求启动AM(ApplicationMaster)。

2. RS收到请求后随机在一台NM(NodeManager)上启动AM（相当于Driver端）。

3. AM启动，AM发送请求到RS，请求一批container用于启动Excutor。

4. RS返回一批NM节点给AM。

5. AM连接到NM,发送请求到NM启动Excutor。

6. Excutor反向注册到AM所在的节点的Driver。Driver发送task到Excutor。

总结

Yarn-Cluster主要用于生产环境中，因为Driver运行在Yarn集群中某一台nodeManager中，每次提交任务的Driver所在的机器都是随机的，不会产生某一台机器网卡流量激增的现象，缺点是任务提交后不能看到日志。只能通过yarn查看日志。

ApplicationMaster的作用：

1. 为当前的Application申请资源

2. 给NameNode发送消息启动Excutor。

3. 任务调度。

停止集群任务命令：yarn application -kill applicationID

阅读全文

0 0