【Spark独立应用程序编程】

Spark独立应用程序编程

继上次期刊，本期将完善两部分内容，主要是通过一个简单的应用程序 SimpleApp 来演示如何通过 Spark API 编写一个独立应用程序。使用 Scala 编写的程序需要使用 sbt 进行编译打包，相应的，Java 程序使用 Maven 编译打包，而 Python 程序通过 spark-submit 直接提交（这一步往期已经演示过，本期不再赘述）。

编写Scala独立应用程序

1、安装sbt

安装sbt，下载地址：http://www.scala-sbt.org

然后往下滑，找到.tgz文件下载

下载速度和网速有关，可能要等一会儿，然后上传到Downloads目录下，输入下面代码：

sudo mkdir /usr/local/sbt             　　　# 创建安装目录
cd ~/Downloads 
sudo tar -zxvf ./sbt-1.9.9.tgz -C /usr/local 
cd /usr/local/sbt
sudo chown -R hadoop /usr/local/sbt  　　 # 此处的hadoop为系统当前用户名
cp ./bin/sbt-launch.jar ./  #把bin目录下的sbt-launch.jar复制到sbt安装目录下

接着在安装目录中创建一个Shell脚本文件，用于启动sbt：

vim /usr/local/sbt/sbt

该脚本文件中的代码如下（注意不要手动换行）/usr/local/sbt是路径，注意你自己安装的位置，不一样的需要替换：

#!/bin/bash
java -Xmx3g -Xms1g -XX:+TieredCompilation -XX:ReservedCodeCacheSize=256m -XX:+UseNUMA -XX:+UseParallelGC -jar /usr/local/sbt/sbt-launch.jar "$@"

上面代码是适用于jdk1.8以上的版本，如果你的Java是低版本的，可换成下面的代码：

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

保存后，为该Shell脚本文件增加可执行权限：

chmod u+x /usr/local/sbt/sbt

查看sbt版本信息：

cd /usr/local/sbt
./sbt sbtVersion

上述查看版本信息的命令，可能需要执行很长一段时间，我本来以为some time是很短的时间，结果我等了好久，才出来版本信息，呜呜呜呜呜~

2、编写Scala应用程序

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

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

在./sparkapp/src/main/scala 下建立一个名为 SimpleApp.scala 的文件（vim ./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/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 为 Spark 的安装目录，如果不是该目录请自行修改。不同于 Spark shell，独立应用程序需要通过 val sc = new SparkContext(conf) 初始化 SparkContext，SparkContext 的参数 SparkConf 包含了应用程序的信息。

3、使用sbt打包Scala程序

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

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

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

cd /usr/local/spark
bin/spark-shell    #启动Spark shell

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

cd ~/sparkapp
find .

文件结构应如下图所示：

将整个应用程序打包成 JAR（首次运行需要下载依赖包）

/usr/local/sbt/sbt package

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

但是在下载的时候非常慢，我下了得有两天，所以我在网上找解决办法，具体步骤如下：

默认情况下，sbt使用的是国外的仓库地址，打包编译的时候非常慢。为了加快打包编译速度，可以更换仓库地址。

首先，执行如下命令：

cd ~
mkdir .sbt   #如果该目录已经存在，就不用创建了
cd .sbt
vim repositories #使用vim编辑器创建repositories文件

在文件repositories中输入如下内容并保存退出：

[repositories]
local
huaweicloud-maven: https://repo.huaweicloud.com/repository/maven/
maven-central: https://repo1.maven.org/maven2/
sbt-plugin-repo: https://repo.scala-sbt.org/scalasbt/sbt-plugin-releases, [organization]/[module]/(scala_[scalaVersion]/)(sbt_[sbtVersion]/)[revision]/[type]s/[artifact](-[classifier]).[ext]

然后，修改SBT配置文件。打开/usr/local/sbt/conf/sbtopts 文件，在末尾新增一行，内容如下：

-Dsbt.override.build.repos=true

通过上述设置以后，再去运行sbt编译打包，就可以成功了。

打包成功的话，会输出如下内容：

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

得到的结果如下：

Java独立应用编程

1.安装maven

安装maven：https://maven.apache.org/download.cgi#Files

同样，把压缩包从远程上传到Downloads目录下，然后执行如下命令：

sudo unzip ~/Downloads/apache-maven-3.9.6-bin.zip -d /usr/local
cd /usr/local
sudo mv apache-maven-3.9.6/ ./maven
sudo chown -R hadoop ./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>cn.edu.xmu</groupId>
    <artifactId>simple-project</artifactId>
    <modelVersion>4.0.0</modelVersion>
    <name>Simple Project</name>
    <packaging>jar</packaging>
    <version>1.0</version>
    <repositories>
        <repository>
            <id>jboss</id>
            <name>JBoss Repository</name>
            <url>http://repository.jboss.com/maven2/</url>
        </repository>
    </repositories>
    <dependencies>
        <dependency> <!-- Spark dependency -->
            <groupId>org.apache.spark</groupId>
            <artifactId>spark-core_2.12</artifactId>
            <version>3.5.1</version>
        </dependency>
    </dependencies>
</project>  

正常官方一点的配置和上面一样，但是执行起来超级慢，以至于我写这篇博文用了四天时间，所以，在附录一中给大家提供了快速打包方法，可供大家参考。

3、使用maven打包java程序

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

cd ~/sparkapp2
find

文件结构如下图：

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

/usr/local/maven/bin/mvn package

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

4、通过spark-submit 运行程序

对于上面编译打包得到的应用程序，可以通过将生成的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"

最后得到的结果如下：

附录一：解决Maven编译打包过程很慢的问题

将Maven源改为国内阿里云仓库

通过修改Maven的配置文件，让Maven到国内的阿里云仓库下载相关依赖，命令如下：

cd /usr/local/maven/conf
vim settings.xml

将settings.xml中的文本改为以下内容：

<settings xmlns="http://maven.apache.org/SETTINGS/1.0.0"
          xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
          xsi:schemaLocation="http://maven.apache.org/SETTINGS/1.0.0
                      http://maven.apache.org/xsd/settings-1.0.0.xsd">
<mirrors>
    <mirror>
        <id>aliyunmaven</id>
        <mirrorOf>*</mirrorOf>
        <name>阿里云公共仓库</name>
        <url>https://maven.aliyun.com/repository/public</url>
    </mirror>
    <mirror>
        <id>aliyunmaven</id>
        <mirrorOf>*</mirrorOf>
        <name>阿里云谷歌仓库</name>
        <url>https://maven.aliyun.com/repository/google</url>
    </mirror>
    <mirror>
        <id>aliyunmaven</id>
        <mirrorOf>*</mirrorOf>
        <name>阿里云阿帕奇仓库</name>
        <url>https://maven.aliyun.com/repository/apache-snapshots</url>
    </mirror>
    <mirror>
        <id>aliyunmaven</id>
        <mirrorOf>*</mirrorOf>
        <name>阿里云spring仓库</name>
        <url>https://maven.aliyun.com/repository/spring</url>
    </mirror>
    <mirror>
        <id>aliyunmaven</id>
        <mirrorOf>*</mirrorOf>
        <name>阿里云spring插件仓库</name>
        <url>https://maven.aliyun.com/repository/spring-plugin</url>
    </mirror>
</mirrors>
</settings>

我的建议是不要删除原来的配置，找到下图所在位置，按提示操作即可。

附录二：通过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。