Apache Spark 是一个快速、通用的分布式计算系统，适用于大规模数据处理。为了让我们开发的应用程序能够在 Spark 集群上运行，我们需要将任务代码打包成一个可执行的 JAR 文件，并提交到 Spark 集群执行。下面我将详细演示如何完成这一过程。

1，编写代码

import org.apache.spark.{SparkConf, SparkContext}

object WordCount {
  def main(args: Array[String]): Unit = {
    //第一步：创建SparkContext
    val conf = new SparkConf()
    conf.setAppName("WordCount")//设置任务名称
    //  .setMaster("local")//local表示在本地执行
    val sc = new SparkContext(conf)

    //第二步：加载数据
    var path = "D:\\hello.txt"
    if (args.length == 1) {
      path = args(0)
    }
    val linesRDD = sc.textFile(path)

    //第三步：对数据进行切割，把一行数据切分成一个一个的单词
    val wordsRDD = linesRDD.flatMap(_.split(" "))

    //第四步：迭代words,将每个word转化为(word,1)这种形式
    val pairRDD = wordsRDD.map((_,1))

    //第五步：根据key(其实就是word)进行分组聚合统计
    val wordCountRDD = pairRDD.reduceByKey(_ + _)

    //第六步：将结果打印到控制台
    wordCountRDD.foreach(wordCount=>println(wordCount._1+"--"+wordCount._2))

    //第七步：停止SparkContext
    sc.stop()
  }
}

2，将项目打成 Jar 包

<build>
    <plugins>
        <!-- java编译插件 -->
        <plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-compiler-plugin</artifactId>
            <version>3.6.0</version>
            <configuration>
                <source>1.8</source>
                <target>1.8</target>
                <encoding>UTF-8</encoding>
            </configuration>
        </plugin>
        <!-- scala编译插件 -->
        <plugin>
            <groupId>net.alchim31.maven</groupId>
            <artifactId>scala-maven-plugin</artifactId>
            <version>3.1.6</version>
            <configuration>
                <scalaCompatVersion>2.13</scalaCompatVersion>
                <scalaVersion>2.13.1</scalaVersion>
            </configuration>
            <executions>
                <execution>
                    <id>compile-scala</id>
                    <phase>compile</phase>
                    <goals>
                        <goal>add-source</goal>
                        <goal>compile</goal>
                    </goals>
                </execution>
                <execution>
                    <id>test-compile-scala</id>
                    <phase>test-compile</phase>
                    <goals>
                        <goal>add-source</goal>
                        <goal>testCompile</goal>
                    </goals>
                </execution>
            </executions>
        </plugin>
        <!-- 打包插件 -->
        <plugin>
            <artifactId>maven-assembly-plugin</artifactId>
            <configuration>
                <descriptorRefs>
                    <descriptorRef>jar-with-dependencies</descriptorRef>
                </descriptorRefs>
                <archive>
                    <manifest>
                        <mainClass></mainClass>
                    </manifest>
                </archive>
            </configuration>
            <executions>
                <execution>
                    <id>make-assembly</id>
                    <phase>package</phase>
                    <goals>
                        <goal>single</goal>
                    </goals>
                </execution>
            </executions>
        </plugin>
    </plugins>
</build>

（2）然后把 spark-core 依赖的作用域设置为 provided，表示只在编译时使用该依赖，在执行及打包时都不使用。

<dependencies>
    <dependency>
        <groupId>org.apache.spark</groupId>
        <artifactId>spark-core_2.13</artifactId>
        <version>3.4.0</version>
        <scope>provided</scope>
    </dependency>
</dependencies>

3，准备测试数据

vi hello.txt

（2）文件内容如下：

hello hangge.com
welcome to hangge.com
hello world
bye world

（3）接着执行如下命令把测试数据上传至 HDFS：

hdfs dfs -put hello.txt /

4，提交任务

./bin/spark-submit \
--master yarn \
--class WordCount  \
spark-1.0-SNAPSHOT-jar-with-dependencies.jar \
hdfs://192.168.121.128:9000/hello.txt

（2）此时任务会被提交到 YARN 集群中，可以看到任务执行成功了：

附一：Spark Job 的三种提交模式

1，standalone 模式

--master spark://node1:7077

2，基于 YARN 的 client 模式

（2）要使用该模式提交时指定如下参数即可：

–master yarn --deploy-mode client

3，是基于 YARN 的 cluster 模式（推荐）

–master yarn --deploy-mode cluster

4，三种模式对比

（2）中间的值 yarn client 模式，由于是 on yarn 模式，所以里面是 yarn 集群的进程，此时 driver 进程就在提交 spark 任务的客户端机器上了。