Spark安装和编程实践（Spark2.4.0）

安装Hadoop（伪分布式）

安装JAVA JDK

安装Spark（Local模式）

1. 下载安装包
   

2. 修改配置文件
   
   spark-env.sh文件(vim ./conf/spark-env.sh)，在第一行添加以下配置信息:

export SPARK_DIST_CLASSPATH=$(/usr/local/hadoop/bin/hadoop classpath)

配置完成后就可以直接使用，不需要像Hadoop运行启动命令

3. 运行Spark自带的示例
   
   得到π 的近似值

熟悉 Spark Shell

启动Spark Shell

cd /usr/local/spark
bin/spark-shell

加载text文件

spark创建sc，可以加载本地文件和HDFS文件创建RDD。这里用Spark自带的本地文件README.md文件测试。

val textFile = sc.textFile("file:///usr/local/spark/README.md")

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

简单RDD操作

//获取RDD文件textFile的第一行内容
textFile.first()
//获取RDD文件textFile所有项的计数
textFile.count()
//抽取含有“Spark”的行，返回一个新的RDD
val lineWithSpark = textFile.filter(line => line.contains("Spark"))
//统计新的RDD的行数
lineWithSpark.count()

组合RDD操作进行组合，可以实现简易MapReduce操作

//找出文本中每行的最多单词数
textFile.map(line => line.split(" ").size).reduce((a, b) => if (a > b) a else b)

使用Spark程序编写wordcount程序

退出Spark Shell

:quit

独立应用程序编程

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

1. 安装sbt

把sbt安装到“/usr/local/sbt”目录下

sudo mkdir /usr/local/sbt             　　　# 创建安装目录
cd ~/Downloads 
sudo tar -zxvf ./sbt-1.3.8.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

该脚本文件中的代码如下：

#!/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

慢慢等…

安装成功
只要安装成功，第2次开始运行“./sbt sbtVersion”和编译打包命令，速度就比较快了。

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 的安装目录，如果不是该目录请自行修改。

cd ~/sparkapp
vim simple.sbt

在~/sparkapp这个目录中新建文件simple.sbt，通过 sbt 进行编译打包

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

3. 使用 sbt 打包 Scala 程序

检查整个应用程序的文件结构：

cd ~/sparkapp
find .

将整个应用程序打包成 JAR

/usr/local/sbt/sbt package

慢慢等…下载依赖包

生成的 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.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:"

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

1. 安装Maven

sudo unzip ~/下载/apache-maven-3.6.3-bin.zip -d /usr/local
cd /usr/local
sudo mv apache-maven-3.6.3/ ./maven
sudo chown -R hadoop ./maven

2. Java应用程序代码

vim ./sparkapp2/src/main/java/SimpleApp.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);
    }
}

在./sparkapp2目录中新建文件pom.xml，通过Maven进行编译打包

cd ~/sparkapp2
vim 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.11</artifactId>
            <version>2.4.0</version>
        </dependency>
    </dependencies>
</project>  

3. 使用Maven打Java程序

检查文件结构

将这整个应用程序打包成Jar

/usr/local/maven/bin/mvn package

等待下载依赖包

生成Jar包成功

4. 通过spark-submit 运行程序

/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对Scala独立应用程序进行编译打包

1. 安装Maven

过程同上

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))
        }
    }

3.使用Maven进行编译打包

在./sparkapp3目录中新建文件pom.xml，通过Maven进行编译打包

cd ~/sparkapp3
vim pom.xml

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

cn.edu.xmu
simple-project
4.0.0
Simple Project
jar
1.0

    
        jboss
        JBoss Repository
        http://repository.jboss.com/maven2/
    


     
        org.apache.spark
        spark-core_2.11
        2.4.0
    

src/main/scala org.scala-tools maven-scala-plugin compile 2.11.12 -target:jvm-1.8

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

将整个应用程序打包成JAR包

cd  ~/sparkapp3    #一定把这个目录设置为当前目录
/usr/local/maven/bin/mvn  package

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

4.通过 spark-submit 运行程序

将生成的 jar 包通过 spark-submit 提交到 Spark 中运行了

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

完成 Spark 应用程序的Maven编译打包运行了