虚拟机Ubuntu上Spark安装和编程实践

最新推荐文章于 2025-05-21 00:12:13 发布

原创最新推荐文章于 2025-05-21 00:12:13 发布 · 3k 阅读

44 ·

CC 4.0 BY-SA版权

文章标签：

#spark #大数据 #分布式 #ubuntu #linux

1.安装 Spark3.5.3

1.1 下载并安装Hadoop（伪分布式）

（1）首先下载Spark-3.5.3

wget https://dlcdn.apache.org/spark/spark-3.5.3/spark-3.5.3-bin-hadoop3.tgz

（2）安装基础

安装Hadoop3.3.4（伪分布式），如果没有安装，请先安装并配置hadoop伪分布式模式。

（3）安装Spark（Local模式）

sudo tar -zxf ~/下载/spark-3.5.3-bin-hadoop3.tgz -C /usr/local/spark  #此处spark为目录名
cd /usr/local/

sudo chown -R yourname ./spark         #此处yourname为用户名

1.2 配置环境

cd /usr/local/spark/spark-3.5.3-bin-hadoop3/
cp ./conf/spark-env.sh.template ./conf/spark-env.sh
通过运行Spark自带的示例，验证Spark是否安装成功: bin/run-example SparkPi

执行时会输出非常多的运行信息，输出结果不容易找到，可以通过 grep 命令进行过滤（命令中的 2>&1 可以将所有的信息都输出到 stdout 中，否则由于输出日志的性质，还是会输出到屏幕中）: bin/run-example SparkPi 2>&1 | grep "Pi is"

运行成功会看到：

2. 使用 Spark Shell 编写代码

Spark shell 提供了简单的方式来学习 API，也提供了交互的方式来分析数据。

2.1 启动Spark Shell

cd /usr/local/spark/spark-3.5.3-bin-hadoop3/

bin/spark-shell

启动spark-shell后，会自动创建名为sc的SparkContext对象和名为spark的SparkSession对象,如图。

2.2 加载text文件

spark创建sc，可以加载本地文件和HDFS文件创建RDD。这里用本地文件a.txt文件测试。

家目录home下文件a.txt:

Haoop is good

Spark is fast

Spark is better

val example=sc.textFile("file:///home/yourname/a.txt")

加载HDFS文件和本地文件都是使用textFile，区别是添加前缀(hdfs://和file:///)进行标识。

2.3 简单RDD操作

//获取RDD文件textFile的第一行内容
example.first()

//获取RDD文件textFile所有项的计数
example.count()

//抽取含有“Spark”的行，返回一个新的RDD
val a1 = example.filter(line => line.contains("Spark"))

//统计新的RDD的行数
a1.count()

//显示文件全部内容
a1.collect()

其他操作：

1.加载文件
val b=sc.textFile("/home/yourname/a.txt")            #后面为你要加载的文件的路径

2.筛选特定单词行
val spark=b.filter(a=>a.contains("Spark"))

3.以空格分出单词
val b1=b.flatMap(line=>line.split(" "))

4.统计每个单词的个数
val b2=b1.map(a=>(a,1))
val b3=b2.reduceByKey((a,b)=>a+b)

5.统计单词长度
b1.distinct().map(a=>(a,a.length())).collect

6.统计单词长度并按长度排序
b1.distinct().map(a=>(a,a.length())).sortBy(a=>a._2).collect


或者
val b4=b3.map(a=>(a._1,a._1.length()))               #统计单词长度
val b5=b4.sortBy(a=>a._2)                            #按单词长度排序

2.4 退出Spark Shell

   :quit

3. 独立应用程序编程

3.1 使用sbt对Scala独立应用程序进行编译打包

3.1.1 安装sbt

使用Scala语言编写的Spark程序，需要使用sbt进行编译打包。Spark中没有自带sbt，需要单独安装。可以到“http://www.scala-sbt.org”下载sbt安装文件sbt-1.3.8.tgz。

然后在下载路径下运行如下命令安装sbt :

curl -fL https://github.com/coursier/coursier/releases/latest/download/cs-x86_64-pc-linux.gz | gzip -d > cs && chmod +x cs && ./cs setup

安装成功之后的页面：

默认情况下，sbt安装在：~/.local/share/coursier/bin

~/.local/share/coursier/bin$ ll

执行以下指令查看sbt版本，如果能看到版本信息，表示安装成功。

sbt --script-version

3.1.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 包含了应用程序的信息。

该程序依赖 Spark API，因此我们需要通过 sbt 进行编译打包。在~/sparkapp这个目录中新建文件simple.sbt，命令如下：

cd ~/sparkapp

vim simple.sbt

在simple.sbt中添加如下内容，声明该独立应用程序的信息以及与 Spark 的依赖关系：

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

文件 simple.sbt 需要指明 Spark 和 Scala 的版本。在上面的配置信息中，scalaVersion用来指定scala的版本，sparkcore用来指定spark的版本，这两个版本信息都可以在之前的启动 Spark shell 的过程中，从屏幕的显示信息中找到。下面就是笔者在启动过程当中，看到的相关版本信息（备注：屏幕显示信息会很长，需要往回滚动屏幕仔细寻找信息）。

3.1.3 使用sbt打包Scala程序

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

cd ~/sparkapp

find .

文件结构应如下图所示：

接着，我们就可以通过如下代码将整个应用程序打包成JAR（首次运行同样需要下载依赖包，可能需要很长时间，请耐心等待）：

sbt package

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

生成的 jar 包的位置为 ~/sparkapp/target/scala-2.12/ simple-project_2.12-1.0.jar。

3.1.4 通过spark-submit运行程序

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

/usr/local/spark/spark-3.5.3-bin-hadoop3/bin/spark-submit --class "SimpleApp" ~/sparkapp/target/scala-2.12/simple-project_2.12-1.0.jar

# 上面命令执行后会输出太多信息，可以不使用上面命令，而使用下面命令查看想要的结果

/usr/local/spark/spark-3.3.0-bin-hadoop3/bin/spark-submit --class "SimpleApp" ~/sparkapp/target/scala-2.12/simple-project_2.12-1.0.jar 2>&1  | grep "Lines with a:"

最终得到的结果如下：

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

3.2 使用Maven对Java独立应用程序进行编译打包（omit）

3.2.1 安装Maven

Ubuntu中没有自带安装maven，需要手动安装maven。下载地址如下：

https://dlcdn.apache.org/maven/maven-3/3.9.6/binaries/apache-maven-3.9.6-bin.tar.gz

这里选择安装在/usr/local/spark/apache-maven-3.9.6/目录中：

tar -zxvf apache-maven-3.8.6-bin.tar.gz -C /usr/local/spark/

3.2.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;
import org.apache.spark.SparkConf;

public class SimpleApp {
    public static void main(String[] args) {
        String logFile = "file:///usr/local/spark/README.md"; // Should be some file on your system
        SparkConf conf=new SparkConf().setMaster("local").setAppName("SimpleApp");
        JavaSparkContext sc=new JavaSparkContext(conf);
        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，命令如下：

cd ~/sparkapp2

vim pom.xml

在pom.xml文件中添加内容如下，声明该独立应用程序的信息以及与Spark的依赖关系：

<project>
    <groupId>cn.edu.byau</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> https://repository.jboss.org/maven2/</url>
        </repository>
    </repositories>
    <dependencies>
        <dependency> <!-- Spark dependency -->
            <groupId>org.apache.spark</groupId>
            <artifactId>spark-core_2.12</artifactId>
            <version>3.5.3</version>
        </dependency>
    </dependencies>
</project>

关于Spark dependency的依赖关系，可以访问The Central Repository（https://search.maven.org/）。搜索spark-core可以找到相关依赖关系信息。

3.2.3 使用Maven打包Java程序

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

cd ~/sparkapp2

find .

文件结构如下图：

接着，我们可以通过如下代码将这整个应用程序打包成Jar(注意：电脑需要保持连接网络的状态，而且首次运行同样下载依赖包，同样消耗几分钟的时间):

cd ~/sparkapp2

/usr/local/maven/bin/mvn package            
/usr/share/maven/bin/mvn package        //有的是，具体看系统给的提示

如出现下图，说明生成Jar包成功：

如果运行Maven编译打包过程很慢，是因为需要到国外网站下载很多的依赖包，国外网站速度很慢，因此，要花费很长时间。

3.2.4 通过spark-submit 运行程序

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

/usr/local/spark/spark-3.5.3-bin-hadoop3/bin/spark-submit --class "SimpleApp" target/simple-project-1.0.jar

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

最后得到的结果如下:

3.3 使用Maven对Scala独立应用程序进行编译打包

3.3.1 安装Maven

参考前面maven安装。

3.3.2 Scala应用程序代码

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

cd ~                                  # 进入用户主文件夹

mkdir ./sparkapp3                     # 创建应用程序根目录

mkdir -p ./sparkapp3/src/main/scala   # 创建所需的文件夹结构

在./sparkapp3/src/main/scala下建立一个名为SimpleApp.scala的文件（vim ./sparkapp3/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.3.3 使用Maven进行编译打包

该程序依赖Spark Java API,因此我们需要通过Maven进行编译打包。在./sparkapp3目录中新建文件pom.xml，命令如下：

cd ~/sparkapp3

vim pom.xml

然后，在pom.xml文件中添加如下内容，用来声明该独立应用程序的信息以及与Spark的依赖关系：

<project>
    <groupId>cn.edu.byau</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.org/maven2/</url>
        </repository>
    </repositories>

    <dependencies>
        <dependency> <!-- Spark dependency -->
            <groupId>org.apache.spark</groupId>
            <artifactId>spark-core_2.12</artifactId>
            <version>3.5.3</version>
        </dependency>
    </dependencies>



  <build>
    <sourceDirectory>src/main/scala</sourceDirectory>
    <plugins>
      <plugin>
        <groupId>org.scala-tools</groupId>
        <artifactId>maven-scala-plugin</artifactId>
        <executions>
          <execution>
            <goals>
              <goal>compile</goal>
            </goals>
          </execution>
        </executions>
        <configuration>
          <scalaVersion>2.12.18</scalaVersion>
          <args>
            <arg>-target:jvm-1.8</arg>
          </args>
        </configuration>
    </plugin>
    </plugins>
</build>

</project>

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

cd  ~/sparkapp3

find  .

文件结构应该是类似如下的内容：

./pom.xml

./src

./src/main

./src/main/scala

./src/main/scala/SimpleApp.scala

接下来，通过如下代码将整个应用程序打包成JAR包（注意：计算机需要保持连接网络的状态，而且首次运行打包命令时，Maven会自动下载依赖包，需要消耗几分钟的时间）：

cd  ~/sparkapp3    #一定把这个目录设置为当前目录

/usr/local/spark/apache-maven-3.8.6/bin/mvn  package

如果屏幕返回如下信息，则说明生成JAR包成功：

生成的应用程序JAR包的位置为“~/sparkapp3/target/simple-project-1.0.jar”。

如果运行Maven编译打包过程很慢，是因为需要到国外网站下载很多的依赖包，国外网站速度很慢，因此，要花费很长时间。

3.3.4 通过 spark-submit 运行程序

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

/usr/local/spark/spark-3.5.3-bin-hadoop3/bin/spark-submit --class "SimpleApp" target/simple-project-1.0.jar

最终得到的结果如下：

到此，就顺利完成 Spark 应用程序的Maven编译打包运行了。