Spark安装和编程实践(Spark2.4.0)
Spark安装和编程实践(Spark2.4.0)
链接:https://pan.baidu.com/s/1HP4Z0MVc2lLQ6lWpYCtwxA
提取码:hpyb
--来自百度网盘超级会员V6的分享
1、安装 Spark2.4.0
首先需要下载Spark安装文件。访问Spark官方下载地址,按照如下图下载。
需要注意的是,本教程内容中Spark采用Local模式进行安装,也就是在单机上运行Spark,因此,在安装Hadoop时,需要按照伪分布式模式进行安装。在单台机器上按照Hadoop(伪分布式)+Spark(Local模式)
这种方式进行Hadoop和Spark组合环境的搭建,可以较好满足入门级Spark学习的需求
1.1 安装Hadoop(伪分布式)
Spark的安装过程较为简单,在已安装好 Hadoop3.1.3(伪分布式) 的前提下,经过简单配置即可使用。
1.2 安装JAVA JDK
安装Hadoop3.1.3的过程就已经要求安装JAVA JDK1.8了。
1.3 安装Spark(Local模式)
#解压安装包
hadoop@hadoop-master:~$ sudo tar xf spark-2.4.0-bin-without-hadoop.tgz -C /usr/local/
hadoop@hadoop-master:~$ cd /usr/local
hadoop@hadoop-master:/usr/local$ sudo mv spark-2.4.0-bin-without-hadoop spark
#把spark目录权限赋予给hadoop用户:
hadoop@hadoop-master:/usr/local$ sudo chown -R hadoop:hadoop spark/
安装后,还需要修改Spark的配置文件spark-env.sh
hadoop@hadoop-master:/usr/local$ cd /usr/local/spark/
hadoop@hadoop-master:/usr/local/spark$ cp -a ./conf/spark-env.sh.template ./conf/spark-env.sh
编辑spark-env.sh文件
hadoop@hadoop-master:/usr/local/spark$ vim ./conf/spark-env.sh
hadoop@hadoop-master:/usr/local/spark$ head -1 ./conf/spark-env.sh
export SPARK_DIST_CLASSPATH=$(/usr/local/hadoop/bin/hadoop classpath)
配置完成后就可以直接使用,不需要像Hadoop运行启动命令。
通过运行Spark自带的示例,验证Spark是否安装成功。
hadoop@hadoop-master:/usr/local/spark$ ./bin/run-example SparkPi
执行时会输出非常多的运行信息,输出结果不容易找到,可以通过 grep 命令进行过滤(命令中的 2>&1 可以将所有的信息都输出到 stdout 中,否则由于输出日志的性质,还是会输出到屏幕中):
hadoop@hadoop-master:/usr/local/spark$ bin/run-example SparkPi 2>&1 | grep "Pi is"
Pi is roughly 3.1429757148785744
2、使用 Spark Shell 编写代码
学习Spark程序开发,建议首先通过spark-shell交互式学习,加深Spark程序开发的理解。
Spark shell 提供了简单的方式来学习 API,也提供了交互的方式来分析数据。
2.1 启动Spark Shell
hadoop@hadoop-master:/usr/local/spark$ ./bin/spark-shell
启动spark-shell后,会自动创建名为sc的SparkContext对象和名为spark的SparkSession对象,如图:
hadoop@hadoop-master:/usr/local/spark$ ./bin/spark-shell
2022-04-26 11:07:53 WARN NativeCodeLoader:60 - Unable to load native-hadoop library for your platform... using builtin-java classes where applicable
Setting default log level to "WARN".
To adjust logging level use sc.setLogLevel(newLevel). For SparkR, use setLogLevel(newLevel).
Spark context Web UI available at http://hadoop-master:4040
Spark context available as 'sc' (master = local[*], app id = local-1650942493059).
Spark session available as 'spark'.
Welcome to
____ __
/ __/__ ___ _____/ /__
_\ \/ _ \/ _ `/ __/ '_/
/___/ .__/\_,_/_/ /_/\_\ version 2.4.0
/_/
Using Scala version 2.11.12 (Java HotSpot(TM) 64-Bit Server VM, Java 1.8.0_162)
Type in expressions to have them evaluated.
Type :help for more information.
2.2 加载text文件
spark创建sc,可以加载本地文件和HDFS文件创建RDD。这里用Spark自带的本地文件README.md文件测试。
scala> val textFile = sc.textFile("file:///usr/local/spark/README.md")
textFile: org.apache.spark.rdd.RDD[String] = file:///usr/local/spark/README.md MapPartitionsRDD[1] at textFile at <console>:24
scala> textFile.count()
res0: Long = 105
加载HDFS文件和本地文件都是使用textFile,区别是添加前缀(hdfs://和file:///)进行标识。
2.3 简单RDD操作
#获取RDD文件textFile的第一行内容
scala> textFile.first()
res1: String = # Apache Spark
#获取RDD文件textFile所有项的计数
scala> textFile.count()
res2: Long = 105
#抽取含有“Spark”的行,返回一个新的RDD
scala> val lineWithSpark = textFile.filter(line => line.contains("Spark"))
lineWithSpark: org.apache.spark.rdd.RDD[String] = MapPartitionsRDD[2] at filter at <console>:25
#统计新的RDD的行数
scala> lineWithSpark.count()
res3: Long = 20
可以通过组合RDD操作进行组合,可以实现简易MapReduce操作
#找出文本中每行的最多单词数
scala> textFile.map(line => line.split(" ").size).reduce((a, b) => if (a > b) a else b)
res4: Int = 22
更多RDD的操作,请访问Spark官方文档RDD操作
2.4 退出Spark Shell
输入:quit
,即可退出spark shell
scala> :quit
3、独立应用程序编程
接着我们通过一个简单的应用程序 SimpleApp 来演示如何通过 Spark API 编写一个独立应用程序。使用 Scala 编写的程序需要使用 sbt (或者Maven)进行编译打包,相应地,Java 程序使用 Maven 编译打包,而 Python 程序通过 spark-submit 直接提交。
3.1 使用sbt对Scala独立应用程序进行编译打包
3.1.1 安装sbt
使用Scala语言编写的Spark程序,需要使用sbt进行编译打包。Spark中没有自带sbt,需要单独安装。可以到“http://www.scala-sbt.org”下载sbt安装文件sbt-1.3.8.tgz。
#解压安装包
hadoop@hadoop-master:~$ sudo tar xf sbt-1.3.8.tgz -C /usr/local/
#把sbt目录权限赋予给hadoop用户
hadoop@hadoop-master:~$ sudo chown -R hadoop:hadoop /usr/local/sbt/
#把bin目录下的sbt-launch.jar复制到sbt安装目录下
hadoop@hadoop-master:/usr/local/sbt$ cp -a ./bin/sbt-launch.jar .
接着在安装目录中使用下面命令创建一个Shell脚本文件,用于启动sbt:
hadoop@hadoop-master:/usr/local/sbt$ vim /usr/local/sbt/sbt
hadoop@hadoop-master:/usr/local/sbt$ cat /usr/local/sbt/sbt
#!/bin/bash
SBT_OPTS="-Xms512M -Xmx1536M -Xss1M -XX:+CMSClassUnloadingEnabled -XX:MaxPermSize=256M"
java $SBT_OPTS -jar `dirname $0`/sbt-launch.jar "$@"
保存后,还需要为该Shell脚本文件增加可执行权限:
hadoop@hadoop-master:/usr/local/sbt$ chmod +x sbt
然后,可以使用如下命令查看sbt版本信息:
hadoop@hadoop-master:/usr/local/sbt$ ./sbt sbtVersion
Java HotSpot(TM) 64-Bit Server VM warning: ignoring option MaxPermSize=256M; support was removed in 8.0
[info] [launcher] getting org.scala-sbt sbt 1.3.8 (this may take some time)...
......
[warn] No sbt.version set in project/build.properties, base directory: /usr/local/sbt
[info] Set current project to sbt (in build file:/usr/local/sbt/)
[info] 1.3.8
如果能够返回上述信息,就说明安装成功了。但是,这个过程会很漫长,甚至很坎坷,会花很长时间。
但是,只要安装成功,第2次开始运行./sbt sbtVersion
和编译打包命令,速度就比较快了。
之所以第一次运行sbt编译打包命令速度很慢,是因为这个过程需要到国外网站下载很多的依赖包,而国外网站下载速度很慢,所以,需要耗费很长时间。为了加快速度,可以尝试更改为国内的仓库地址,具体方法可以参考博客:安装最新版sbt工具方法和体会。
3.1.2 Scala应用程序代码
在终端中执行如下命令创建一个文件夹 sparkapp 作为应用程序根目录:
#创建应用程序根目录
hadoop@hadoop-master:~$ mkdir sparkapp
#创建所需的文件夹结构
hadoop@hadoop-master:~$ mkdir -p sparkapp/src/main/scala
在./sparkapp/src/main/scala
下建立一个名为SimpleApp.scala
的文件
hadoop@hadoop-master:~$ nano sparkapp/src/main/scala/SimpleApp.scala
hadoop@hadoop-master:~$ cat 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中添加如下内容,声明该独立应用程序的信息以及与 Spark 的依赖关系:
hadoop@hadoop-master:~/sparkapp$ nano simple.sbt
hadoop@hadoop-master:~/sparkapp$ cat simple.sbt
name := "Simple Project"
version := "1.0"
scalaVersion := "2.11.12"
libraryDependencies += "org.apache.spark" %% "spark-core" % "2.4.0"
文件 simple.sbt 需要指明 Spark 和 Scala 的版本。在上面的配置信息中,scalaVersion用来指定scala的版本,sparkcore用来指定spark的版本,这两个版本信息都可以在之前的启动 Spark shell 的过程中,从屏幕的显示信息中找到。
3.1.3 使用 sbt 打包 Scala 程序
为保证 sbt 能正常运行,先执行如下命令检查整个应用程序的文件结构:
hadoop@hadoop-master:~/sparkapp$ find .
.
./src
./src/main
./src/main/scala
./src/main/scala/SimpleApp.scala
./simple.sbt
接着,我们就可以通过如下代码将整个应用程序打包成 JAR(首次运行同样需要下载依赖包 ):
hadoop@hadoop-master:~/sparkapp$ /usr/local/sbt/sbt package
....
[info] Non-compiled module 'compiler-bridge_2.11' for Scala 2.11.12. Compiling...
[info] Compilation completed in 8.841s.
[success] Total time: 36 s, completed 2022-4-26 13:48:26
生成的 jar 包的位置为
hadoop@hadoop-master:~/sparkapp$ ll ~/sparkapp/target/scala-2.11/simple-project_2.11-1.0.jar
-rw-rw-r-- 1 hadoop hadoop 3583 4月 26 13:48 /home/hadoop/sparkapp/target/scala-2.11/simple-project_2.11-1.0.jar
3.1.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
上面命令执行后会输出太多信息,可以不使用上面命令,而使用下面命令查看想要的结果
最终得到的结果如下:
hadoop@hadoop-master:~/sparkapp$ /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: 31
自此,就完成了你的第一个 Spark 应用程序了。
3.2 使用Maven对Java独立应用程序进行编译打包
3.2.1 安装Maven
Ubuntu中没有自带安装maven,需要手动安装maven。可以访问maven官方下载自己下载。
#解压安装包
hadoop@hadoop-master:~$ sudo unzip apache-maven-3.6.3-bin.zip -d /usr/local/
hadoop@hadoop-master:~$ cd /usr/local
hadoop@hadoop-master:/usr/local$ sudo mv apache-maven-3.6.3 maven
#把sbt目录权限赋予给hadoop用户
hadoop@hadoop-master:/usr/local$ sudo chown -R hadoop:hadoop ./maven/
3.2.2 Java应用程序代码
在终端执行如下命令创建一个文件夹sparkapp2作为应用程序根目录
#创建应用程序根目录
hadoop@hadoop-master:~$ mkdir sparkapp2
#创建所需的文件夹结构
hadoop@hadoop-master:~$ mkdir -p sparkapp2/src/main/java
在 ./sparkapp2/src/main/java
下建立一个名为 SimpleApp.java
的文件
hadoop@hadoop-master:~$ nano sparkapp2/src/main/java/SimpleApp.java
hadoop@hadoop-master:~$ cat 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文件中添加内容如下,声明该独立应用程序的信息以及与Spark的依赖关系:
hadoop@hadoop-master:~$ cd sparkapp2/
hadoop@hadoop-master:~/sparkapp2$ nano pom.xml
hadoop@hadoop-master:~/sparkapp2$ cat pom.xml
<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.11</artifactId>
<version>2.4.0</version>
</dependency>
</dependencies>
</project>
关于Spark dependency的依赖关系,可以访问The Central Repository。搜索spark-core
可以找到相关依赖关系信息。
3.2.3 使用Maven打Java程序
为了保证maven能够正常运行,先执行如下命令检查整个应用程序的文件结构:
hadoop@hadoop-master:~/sparkapp2$ find .
.
./src
./src/main
./src/main/java
./src/main/java/SimpleApp.java
./pom.xml
接着,我们可以通过如下代码将这整个应用程序打包成Jar(注意:电脑需要保持连接网络的状态,而且首次运行同样下载依赖包,同样消耗几分钟的时间):
hadoop@hadoop-master:~/sparkapp2$ /usr/local/maven/bin/mvn package
....
[INFO] Building jar: /home/hadoop/sparkapp2/target/simple-project-1.0.jar
[INFO] ------------------------------------------------------------------------
[INFO] BUILD SUCCESS
[INFO] ------------------------------------------------------------------------
[INFO] Total time: 06:07 min
[INFO] Finished at: 2022-04-26T14:12:13+08:00
[INFO] ------------------------------------------------------------------------
如果运行Maven编译打包过程很慢,是因为需要到国外网站下载很多的依赖包,国外网站速度很慢,因此,要花费很长时间。为了加快速度,可以更改为国内的仓库地址,具体可以参考博客:将Maven源改为国内阿里云仓库。
3.2.4 通过spark-submit 运行程序
最后,可以通过将生成的jar包通过spark-submit提交到Spark中运行,如下命令:
/usr/local/spark/bin/spark-submit --class "SimpleApp" ~/sparkapp2/target/simple-project-1.0.jar
上面命令执行后会输出太多信息,可以不使用上面命令,而使用下面命令查看想要的结果
最终得到的结果如下:
hadoop@hadoop-master:~/sparkapp2$ /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: 31
3.3 使用Maven对Scala独立应用程序进行编译打包
3.3.1 安装Maven
略。。。
3.3.2 Scala应用程序代码
在终端中执行如下命令创建一个文件夹 sparkapp3作为应用程序根目录:
#创建应用程序根目录
hadoop@hadoop-master:~$ mkdir sparkapp3
#创建所需的文件夹结构
hadoop@hadoop-master:~$ mkdir -p sparkapp3/src/main/scala
在 ./sparkapp3/src/main/scala
下建立一个名为 SimpleApp.scala
的文件
hadoop@hadoop-master:~$ nano sparkapp3/src/main/scala/SimpleApp.scala
hadoop@hadoop-master:~$ cat 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/spar
k 为 Spark
的安装目录,如果不是该目录请自行修改。不同于 Spark shell
,独立应用程序需要通过 val sc = new SparkContext(conf)
初始化 SparkContext
,SparkContext
的参数 SparkConf
包含了应用程序的信息。
3.3.3 使用Maven进行编译打包
该程序依赖Spark Java API,因此我们需要通过Maven进行编译打包。在./sparkapp3目录中新建文件pom.xml文件中添加如下内容,用来声明该独立应用程序的信息以及与Spark的依赖关系:
hadoop@hadoop-master:~$ cd sparkapp3/
hadoop@hadoop-master:~/sparkapp3$ nano pom.xml
hadoop@hadoop-master:~/sparkapp3$ cat pom.xml
<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.11</artifactId>
<version>2.4.0</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.11.12</scalaVersion>
<args>
<arg>-target:jvm-1.8</arg>
</args>
</configuration>
</plugin>
</plugins>
</build>
</project>
为了保证Maven能够正常运行,先执行如下命令检查整个应用程序的文件结构:
hadoop@hadoop-master:~/sparkapp3$ find .
.
./src
./src/main
./src/main/scala
./src/main/scala/SimpleApp.scala
./pom.xml
接下来,我们可以通过如下代码将整个应用程序打包成JAR包(注意:计算机需要保持连接网络的状态,而且首次运行打包命令时,Maven会自动下载依赖包,需要消耗几分钟的时间):
hadoop@hadoop-master:~/sparkapp3$ /usr/local/maven/bin/mvn package
....
[INFO] BUILD SUCCESS
[INFO] ------------------------------------------------------------------------
[INFO] Total time: 23.869 s
[INFO] Finished at: 2022-04-26T14:54:34+08:00
[INFO] ------------------------------------------------------------------------
生成的应用程序JAR包的位置为
hadoop@hadoop-master:~/sparkapp3$ ll -d ~/sparkapp3/target/simple-project-1.0.jar
-rw-rw-r-- 1 hadoop hadoop 4886 4月 26 14:54 /home/hadoop/sparkapp3/target/simple-project-1.0.jar
如果运行Maven编译打包过程很慢,是因为需要到国外网站下载很多的依赖包,国外网站速度很慢,因此,要花费很长时间。为了加快速度,可以更改为国内的仓库地址,具体可以参考博客:将Maven源改为国内阿里云仓库。
3.3.4 通过 spark-submit 运行程序
最后,我们就可以将生成的 jar 包通过 spark-submit 提交到 Spark 中运行了,命令如下:
/usr/local/spark/bin/spark-submit --class "SimpleApp" ~/sparkapp3/target/simple-project-1.0.jar
上面命令执行后会输出太多信息,可以不使用上面命令,而使用下面命令查看想要的结果
最终得到的结果如下:
hadoop@hadoop-master:~/sparkapp3$ /usr/local/spark/bin/spark-submit --class "SimpleApp" ~/sparkapp3/target/simple-project-1.0.jar 2>&1 | grep "Lines with a:"
Lines with a: 62, Lines with b: 31
到此,就顺利完成 Spark 应用程序的Maven编译打包运行了。