一 spark简介
1.1版本
spark版本：spark-3.0.0
hadoop版本：hadoop-2.8.5
hbase版本：hbase-2.0.4
kafka版本：kafka_2.12-2.4.1
java版本：1.8
scala版本：2.12
1.2 什么是Spark
Spark是一种快速、通用、可扩展的大数据分析引擎，2009年诞生于加州大学伯克利分校AMPLab，2010年开源，2013年6月成为Apache孵化项目，2014年2月成为Apache的顶级项目，2014年5月发布spark1.0，2016年7月发布spark2.0，2020年6月18日发布spark3.0.0
1.2.1Spark的特点
- Speed：快速高效
Hadoop的MapReduce作为第一代分布式大数据计算引擎，在设计之初，受当时计算机硬件条件所限（内存、磁盘、cpu等），为了能够计算海量数据，需要将中间结果保存到HDFS中，那么就要频繁读写HDFS从而使得网络IO和磁盘IO成为性能瓶颈。Spark可以将中间结果写到本地磁盘或将中间cache到内存中，节省了大量的网络IO和磁盘IO开销。并且Spark使用更先进的DAG任务调度思想，可以将多个计算逻辑构建成一个有向无环图，并且还会将DAG先进行优化后再生成物理执行计划，同时 Spark也支持数据缓存在内存中的计算。性能比Hadoop MapReduce快100倍。即便是不将数据cache到内存中，其速度也是MapReduce10 倍以上。
2.Ease of Use：简洁易用
Spark支持 Java、Scala、Python和R等编程语言编写应用程序，大大降低了使用者的门槛。自带了80多个高等级操作算子，并且允许在Scala，Python，R 的使用命令进行交互式运行，可以非常方便的在Spark Shell中地编写spark程序。
3 Generality：通用、全栈式数据处理
Spark提供了统一的大数据处理解决方案，非常具有吸引力，毕竟任何公司都想用统一的平台去处理遇到的问题，减少开发和维护的人力成本和部署平台的物力成本。 同时Spark还支持SQL，大大降低了大数据开发者的使用门槛，同时提供了SparkStream和Structed Streaming可以处理实时流数据；MLlib机器学习库，提供机器学习相关的统计、分类、回归等领域的多种算法实现。其高度封装的API 接口大大降低了用户的学习成本；Spark GraghX提供分布式图计算处理能力；PySpark支持Python编写Spark程序；SparkR支持R语言编写Spark程序。
4 Runs Everywhere：可以运行在各种资源调度框架和读写多种数据源
Spark支持的多种部署方案：Standalone是Spark自带的资源调度模式；Spark可以运行在Hadoop的YARN上面；Spark 可以运行在Mesos上（Mesos是一个类似于YARN的资源调度框架）；Spark还可以Kubernetes实现容器化的资源调度
丰富的数据源支持。Spark除了可以访问操作系统自身的本地文件系统和HDFS之外，还可以访问 Cassandra、HBase、Hive、Alluxio（Tachyon）以及任何 Hadoop兼容的数据源。这极大地方便了已经 的大数据系统进行顺利迁移到Spark。
1.2.2Spark与MapReduce的对比
| 框架 | 优点 | 缺点 |
| MapReduce | 历史悠久、稳定 | 编程API不灵活、速度慢、只能做离线计算 |
| Spark | 通用、编程API简洁、快 | 跟MapReduce比暂无缺点 |
面试题：MapReduce和Spark的本质区别：
- MR只能做离线计算，如果实现复杂计算逻辑，一个MR搞不定，就需要将多个MR按照先后顺序连成一串，一个MR计算完成后会将计算结果写入到HDFS中，下一个MR将上一个MR的输出作为输入，这样就要频繁读写HDFS，网络IO和磁盘IO会成为性能瓶颈。从而导致效率低下。
- 既可以做离线计算，有可以做实时计算，提供了抽象的数据集（RDD、Dataset、DataFrame、DStream）有高度封装的API，算子丰富，并且使用了更先进的DAG有向无环图调度思想，可以对执行计划优化后在执行，并且可以数据可以cache到内存中进行复用。
注意：MR和Spark在Shuffle时数据都落本地磁盘
1.2.3Spark 3.0新特性
2020年6月18日，开发了近两年（自2018年10月份至今）的Apache Spark 3.0.0 正式发布，
Apache Spark 3.0.0版本解决并修复了包含3400多个补丁，是开源社区做出巨大贡献的结晶，在Python和SQL功能方面带来了重大进展并且将重点聚焦在了开发和生产的易用性上。同时，今年也是Spark开源10周年，这些举措反映了Spark自开源以来，是如何不断的满足更广泛的受众需求以及更多的应用场景。
spark3.0新特性介绍连接：https://spark.apache.org/releases/spark-release-3-0-0.html
重点：改进的Spark SQL引擎
即使由于缺乏或者不准确的数据统计信息和对成本的错误估算导致生成的初始计划不理想，但是自适应查询执行（Adaptive Query Execution）通过在运行时对查询执行计划进行优化，允许Spark Planner在运行时执行可选的执行计划，这些计划将基于运行时统计数据进行优化，从而提升性能。
- 动态合并shuffle partitions
- 动态调整join策略
- 动态优化倾斜的join
- 动态分区裁剪
- ANSI SQL兼容性
- Join hints
2 Spark架构体系
上图为逻辑视图,RDD不真正存在数据
2 .1Spark中重要角色
- Master ：是一个Java进程，接收Worker的注册信息和心跳、移除异常超时的Worker、接收客户端提交的任务、负责资源调度、命令Worker启动Executor。
- Worker ：是一个Java进程，负责管理当前节点的资源关联，向Master注册并定期发送心跳，负责启动Executor、并监控Executor的状态。
- SparkSubmit ：是一个Java进程，负责向Master提交任务。
- Driver ：是很多类的统称，可以认为SparkContext就是Driver，client模式Driver运行在SparkSubmit进程中，cluster模式单独运行在一个进程中，负责将用户编写的代码转成Tasks，然后调度到Executor中执行，并监控Task的状态和执行进度。
- Executor ：是一个Java进程，负责执行Driver端生成的Task，将Task放入线程中运行。
2.2Spark和Yarn角色对比
| Spark StandAlone的Client模式 | YARN |
| Master | ResourceManager |
| Worker | NodeManager |
| Executor | YarnChild |
| SparkSubmit（Driver） | ApplicationMaster |
3Spark环境搭建
3.1架构说明（standalone模式）
standalone模式是Spark自带的分布式集群模式，不依赖其他的资源调度框架
3.2搭建步骤
- 下载spark安装包，下载地址：https://spark.apache.org/downloads.html
- 上传spark安装包到Linux服务器上
- 解压spark安装包
| tar -xvf spark-3.0.0-bin-hadoop3.2.tgz -C /opt/apps |
4.进入到spark按照包目录并将conf目录下的spark-env.sh.template重命名为spark-env.sh，再修改
| export JAVA_HOME=/opt/apps/ jdk1.8.0_231 export SPARK_MASTER_HOST=linux02 |
5 将conf目录下的slaves.template重命名为slaves并修改，指定Worker的所在节点
6 将配置好的spark拷贝到其他节点
| for i in {2..4}; do scp -r spark-3.0.0-bin-hadoop3.2 linux02:$PWD; done |
7 启动Spark集群
8 在Spark的安装目录执行启动脚本
1 执行jps命令查看Java进程
2 在linux02上可用看见Master进程，在其他的节点上可用看见到Worker
3 访问Master的web管理界面，端口8080
4 启动Spark Shell编程
4.1什么是Spark Shell
spark shell是spark中的交互式命令行客户端，可以在spark shell中使用scala编写spark程序，启动后默认已经创建了SparkContext，别名为sc
4.2启动Spark Shell
| /opt/apps/spark-3.0.0-bin-hadoop2.7/bin/spark-shell --master spark://linux02:7077 --executor-memory 1g --total-executor-cores 3 |
参数说明：
--master 指定masterd地址和端口，协议为spark://，端口是RPC的通信端口
--executor-memory 指定每一个executor的使用的内存大小
--total-executor-cores指定整个application总共使用了cores
- 在shell中编写第一个spark程序
| sc.textFile("hdfs://linux01:9000/words.txt").flatMap(_.split(" ")).map((_, 1)).reduceByKey(_+_).sortBy(_._2,false).saveAsTextFile("hdfs://linux01:9000/out") |
5 Spark编程入门
5.1Scala编写Spark的WorkCount
5.2在pom.xml中添加依赖和插件
5.3创建一个Maven项目
<!-- 定义了一些常量 -->
<properties>
<maven.compiler.source>1.8</maven.compiler.source>
<maven.compiler.target>1.8</maven.compiler.target>
<scala.version>2.12.10</scala.version>
<spark.version>3.0.0</spark.version>
<hadoop.version>2.8.5</hadoop.version>
<encoding>UTF-8</encoding>
</properties>
<dependencies>
<!-- 导入scala的依赖 -->
<dependency>
<groupId>org.scala-lang</groupId>
<artifactId>scala-library</artifactId>
<version>${scala.version}</version>
</dependency>
<!-- 导入spark的依赖，core指的是RDD编程API -->
<dependency>
<groupId>org.apache.spark</groupId>
<artifactId>spark-core_2.12</artifactId>
<version>${spark.version}</version>
<exclusions>
<exclusion>
<groupId>org.apache.hadoop</groupId>
<artifactId>hadoop-client</artifactId>
</exclusion>
</exclusions>
</dependency>
<!-- 导入Hadoop依赖 -->
<dependency>
<groupId>org.apache.hadoop</groupId>
<artifactId>hadoop-client</artifactId>
<version>${hadoop.version}</version>
</dependency>
</dependencies>
<build>
<pluginManagement>
<plugins>
<!-- 编译scala的插件 -->
<plugin>
<groupId>net.alchim31.maven</groupId>
<artifactId>scala-maven-plugin</artifactId>
<version>3.2.2</version>
</plugin>
<!-- 编译java的插件 -->
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-compiler-plugin</artifactId>
<version>3.5.1</version>
</plugin>
</plugins>
</pluginManagement>
<plugins>
<plugin>
<groupId>net.alchim31.maven</groupId>
<artifactId>scala-maven-plugin</artifactId>
<executions>
<execution>
<id>scala-compile-first</id>
<phase>process-resources</phase>
<goals>
<goal>add-source</goal>
<goal>compile</goal>
</goals>
</execution>
<execution>
<id>scala-test-compile</id>
<phase>process-test-resources</phase>
<goals>
<goal>testCompile</goal>
</goals>
</execution>
</executions>
</plugin>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-compiler-plugin</artifactId>
<executions>
<execution>
<phase>compile</phase>
<goals>
<goal>compile</goal>
</goals>
</execution>
</executions>
</plugin>
<!-- 打jar插件 -->
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-shade-plugin</artifactId>
<version>2.4.3</version>
<executions>
<execution>
<phase>package</phase>
<goals>
<goal>shade</goal>
</goals>
<configuration>
<filters>
<filter>
<artifact>*:*</artifact>
<excludes>
<exclude>META-INF/*.SF</exclude>
<exclude>META-INF/*.DSA</exclude>
<exclude>META-INF/*.RSA</exclude>
</excludes>
</filter>
</filters>
</configuration>
</execution>
</executions>
</plugin>
</plugins>
</build>
|
5.4编写Spark程序
import org.apache.spark.rdd.RDD
import org.apache.spark.{SparkConf, SparkContext}
/**
* 1.创建SparkContext
* 2.创建RDD
* 3.调用RDD的Transformation（s）方法
* 4.调用Action
* 5.释放资源
*/
object WordCount {
def main(args: Array[String]): Unit = {
val conf: SparkConf = new SparkConf().setAppName("WordCount")
//创建SparkContext，使用SparkContext来创建RDD
val sc: SparkContext = new SparkContext(conf)
//spark写Spark程序，就是对抽象的神奇的大集合【RDD】编程，调用它高度封装的API
//使用SparkContext创建RDD
val lines: RDD[String] = sc.textFile(args(0))
//Transformation 开始 //
//切分压平
val words: RDD[String] = lines.flatMap(_.split(" "))
//将单词和一组合放在元组中
val wordAndOne: RDD[(String, Int)] = words.map((_, 1))
//分组聚合，reduceByKey可以先局部聚合再全局聚合
val reduced: RDD[(String, Int)] = wordAndOne.reduceByKey(_+_)
//排序
val sorted: RDD[(String, Int)] = reduced.sortBy(_._2, false)
//Transformation 结束 //
//调用Action将计算结果保存到HDFS中
sorted.saveAsTextFile(args(1))
//释放资源
sc.stop()
}
}
|
5.5 打架包
5.6提交任务
- 上传jar包到服务器，然后使用sparksubmit命令提交任务
| /opt/apps/spark-3.0.0-bin-hadoop2.7/bin/spark-submit --master spark://linux02:7077 --executor-memory 1g --total-executor-cores 4 --class cn.spark.demo1.WordCount /sparkData/hello-spark-1.0-SNAPSHOT.jar hdfs://linux01:9000/data/word.txt hdfs://linux01:9000/data/out |
| |
参数说明：
--master 指定masterd地址和端口，协议为spark://，端口是RPC的通信端口
--executor-memory 指定每一个executor的使用的内存大小
--total-executor-cores指定整个application总共使用了cores
--class 指定程序的main方法全类名
jar包路径 args0 args1
6.1使用匿名实现类方式
import org.apache.spark.SparkConf;
import org.apache.spark.api.java.JavaPairRDD;
import org.apache.spark.api.java.JavaRDD;
import org.apache.spark.api.java.JavaSparkContext;
import org.apache.spark.api.java.function.FlatMapFunction;
import org.apache.spark.api.java.function.Function2;
import org.apache.spark.api.java.function.PairFunction;
import scala.Tuple2;
import java.util.Arrays;
import java.util.Iterator;
public class JavaWordCount {
public static void main(String[] args) {
SparkConf sparkConf = new SparkConf().setAppName("JavaWordCount");
//创建JavaSparkContext
JavaSparkContext jsc = new JavaSparkContext(sparkConf);
//使用JavaSparkContext创建RDD
JavaRDD<String> lines = jsc.textFile(args[0]);
//调用Transformation（s）
//切分压平
JavaRDD<String> words = lines.flatMap(new FlatMapFunction<String, String>() {
@Override
public Iterator<String> call(String line) throws Exception {
return Arrays.asList(line.split(" ")).iterator();
}
});
//将单词和一组合在一起
JavaPairRDD<String, Integer> wordAndOne = words.mapToPair(
new PairFunction<String, String, Integer>() {
@Override
public Tuple2<String, Integer> call(String word) throws Exception {
return Tuple2.apply(word, 1);
}
});
//分组聚合
JavaPairRDD<String, Integer> reduced = wordAndOne.reduceByKey(
new Function2<Integer, Integer, Integer>() {
@Override
public Integer call(Integer v1, Integer v2) throws Exception {
return v1 + v2;
}
});
//排序，先调换KV的顺序VK
JavaPairRDD<Integer, String> swapped = reduced.mapToPair(
new PairFunction<Tuple2<String, Integer>, Integer, String>() {
@Override
public Tuple2<Integer, String> call(Tuple2<String, Integer> tp) throws Exception {
return tp.swap();
}
});
//再排序
JavaPairRDD<Integer, String> sorted = swapped.sortByKey(false);
//再调换顺序
JavaPairRDD<String, Integer> result = sorted.mapToPair(
new PairFunction<Tuple2<Integer, String>, String, Integer>() {
@Override
public Tuple2<String, Integer> call(Tuple2<Integer, String> tp) throws Exception {
return tp.swap();
}
});
//触发Action，将数据保存到HDFS
result.saveAsTextFile(args[1]);
//释放资源
jsc.stop();
}
}
|
6.2使用Lambda表达式方式
import org.apache.spark.SparkConf;
import org.apache.spark.api.java.JavaPairRDD;
import org.apache.spark.api.java.JavaRDD;
import org.apache.spark.api.java.JavaSparkContext;
import scala.Tuple2;
import java.util.Arrays;
public class JavaLambdaWordCount {
public static void main(String[] args) {
SparkConf conf = new SparkConf().setAppName("JavaLambdaWordCount");
//创建SparkContext
JavaSparkContext jsc = new JavaSparkContext(conf);
//创建RDD
JavaRDD<String> lines = jsc.textFile(args[0]);
//切分压平
JavaRDD<String> words = lines.flatMap(line ->
Arrays.asList(line.split(" ")).iterator());
//将单词和一组合
JavaPairRDD<String, Integer> wordAndOne = words.mapToPair(
word -> Tuple2.apply(word, 1));
//分组聚合
JavaPairRDD<String, Integer> reduced = wordAndOne.reduceByKey((a, b) -> a + b);
//调换顺序
JavaPairRDD<Integer, String> swapped = reduced.mapToPair(tp -> tp.swap());
//排序
JavaPairRDD<Integer, String> sorted = swapped.sortByKey(false);
//调换顺序
JavaPairRDD<String, Integer> result = sorted.mapToPair(tp -> tp.swap());
//将数据保存到HDFS
result.saveAsTextFile(args[1]);
//释放资源
jsc.stop();
}
}
|
6.3本地运行Spark和Debug
spark程序每次都打包上在提交到集群上比较麻烦且不方便调试，Spark还可以进行Local模式运行，方便测试和调试
6.3.1在本地运行
//Spark程序local模型运行,local[*]是本地运行，并开启多个线程
val conf: SparkConf = new SparkConf()
setAppName("WordCount")
setMaster("local[*]") //设置为local模式执行
|
输入运行参数
6.3.2读取HDFS中的数据
由于往HDFS中的写入数据存在权限问题，所以在代码中设置用户为HDFS目录的所属用户
//往HDFS中写入数据，将程序的所属用户设置成更HDFS一样的用户
System.setProperty("HADOOP_USER_NAME", "root")
|
本文介绍了Spark的基本概念、特点，对比了Spark与MapReduce的区别，着重强调了Spark 3.0的新特性，包括改进的SQL引擎。详细讲解了Spark的架构体系，提供了Spark环境的搭建步骤，从启动Spark Shell到编写Spark程序的入门指导，包括使用匿名实现类、Lambda表达式的方式以及本地运行和Debug的方法。
扫一扫
8549
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
