Spark（一）

最新推荐文章于 2021-08-29 22:30:58 发布

小雨光

最新推荐文章于 2021-08-29 22:30:58 发布

阅读量238

点赞数 1

分类专栏：大数据文章标签： spark

本文链接：https://blog.csdn.net/weixin_44079636/article/details/119493775

版权

大数据专栏收录该内容

41 篇文章 8 订阅

订阅专栏

一、简介

Apache Spark 是专为大规模数据处理而设计的快速通用的计算引擎。拥有Hadoop MapReduce所具有的优点；但不同于MapReduce的是——Job中间输出结果可以保存在内存中，从而不再需要读写HDFS，因此Spark能更好地适用于数据挖掘与机器学习等需要迭代的MapReduce的算法。

二、特点

1.高级 API 剥离了对集群本身的关注，Spark 应用开发者可以专注于应用所要做的计算本身。
2.Spark 很快，支持交互式计算和复杂算法。（内存计算下，Spark 比 Hadoop 快100倍。）
3.Spark 是一个通用引擎，可用它来完成各种各样的运算，包括 SQL 查询、文本处理、机器学习等，而在 Spark 出现之前，我们一般需要学习各种各样的引擎来分别处理这些需求。

三、SPARK架构和生态

在这里插入图片描述

spark主要包括Spark Core和在Spark Core基础上建立的应用框架：数据分析引擎SparkSQL、图计算框架GraphX、机器学习库MLlib、流计算引擎Spark Streaming。Core库主要包括上下文（Spark Context）、数据抽象集（RDD、DataFrame和DataSet）、调度器（Scheduler）、洗牌（shuffle）和序列化器（Serializer）等。
在Core库之上就根据业务需求分为用于交互式查询的SQL、实时流处理Streaming、机器学习Mllib和图计算GraphX四大框架，除此外还有一些其他实验性项目如Tachyon、BlinkDB和Tungsten等。Hdfs是Spark主要应用的持久化存储系统。
Spark SQL：提供通过Apache Hive的SQL变体Hive查询语言（HiveSQL）与Spark进行交互的API，每个数据表被当作一个RDD，SparkSQL查询被转换为Spark操作。
Spark Streaming：对实时数据流进行处理和控制。Spark Streaming允许程序能够像普通RDD一样处理实时数据。
MLlib：一个常用机器学习算法库，算法被实现为对RDD的Spark操作。这个库包含可扩展的学习算法，比如分类、回归等需要对大量数据集进行迭代的操作。
GraphX：控制图、并行图操作和计算的一组算法和工具的集合。GraphX扩展了RDD API，包含控制图、创建子图、访问路径上所有顶点的操作。

四、名词解释

4.1 Driver（驱动器）

Spark的驱动器是执行开发程序中的main方法的进程。它负责开发人员编写的用来创建SparkContext、创建RDD，以及进行RDD的转化操作和行动操作代码的执行。如果你是用spark shell，那么当你启动Spark shell的时候，系统后台自启了一个Spark驱动器程序，就是在Spark shell中预加载的一个叫作 sc的SparkContext对象。如果驱动器程序终止，那么Spark应用也就结束了。主要负责：

1）把用户程序转为作业（JOB）
2）跟踪Executor的运行状况
3）为执行器节点调度任务
4）UI展示应用运行状况

4.2 Executor（执行器）

Spark Executor是一个工作进程，负责在 Spark 作业中运行任务，任务间相互独立。Spark 应用启动时，Executor节点被同时启动，并且始终伴随着整个 Spark 应用的生命周期而存在。如果有Executor节点发生了故障或崩溃，Spark 应用也可以继续执行，会将出错节点上的任务调度到其他Executor节点上继续运行。主要负责：
1）负责运行组成 Spark 应用的任务，并将结果返回给驱动器进程；
2）通过自身的块管理器（Block Manager）为用户程序中要求缓存的RDD提供内存式存储。RDD是直接缓存在Executor进程内的，因此任务可以在运行时充分利用缓存数据加速运算。

五、伪分布式安装

安装前：安装JDK、Hadoop(启动hdfs)

上传压缩包，解压改名字

tar -zxf spark-2.4.3-bin-hadoop2.7.tgz  -C  /opt/installs
	
mv spark-2.4.3-bin-hadoop2.7 spark2.4.3 
 
cd spark2.4.3/conf

修改配置文件slaves和 park-env.sh

[root@spark1 conf]# mv slaves.template slaves
[root@spark1 conf]# mv spark-env.sh.template spark-env.sh
[root@spark1 conf]# vi slaves 
#配置Spark集群节点主机名
hadoop10
[root@spark1 conf]# cat spark-env.sh 
#声明Spark集群中Master的主机名和端口号
SPARK_MASTER_HOST=hadoop10
SPARK_MASTER_PORT=7077

修改spark-config.sh

[root@spark1 conf]# cd ..
[root@spark1 spark]# cd sbin
[root@spark1 sbin]# vi spark-config.sh 
#在最后增加 JAVA_HOME 配置
export JAVA_HOME=/opt/installs/jdk1.8

启动spark

[root@spark1 spark]# sbin/start-all.sh
[root@spark1 spark]# jps            
2054 Jps
2008 Worker
1933 Master

六、测试spark实现wordcount

1.Java中编写代码在IDEA中运行

1。创建一个maven项目，并且导入相关依赖

<dependencies>
        <!-- spark依赖-->
        <dependency>
            <groupId>org.apache.spark</groupId>
            <artifactId>spark-core_2.11</artifactId>
            <version>2.4.3</version>
        </dependency>

    </dependencies>
    <!-- maven项目对scala编译打包 -->
    <build>
        <plugins>
            <plugin>
                <groupId>net.alchim31.maven</groupId>
                <artifactId>scala-maven-plugin</artifactId>
                <version>4.0.1</version>
                <executions>
                    <execution>
                        <id>scala-compile-first</id>
                        <phase>process-resources</phase>
                        <goals>
                            <goal>add-source</goal>
                            <goal>compile</goal>
                        </goals>
                    </execution>
                </executions>
            </plugin>
        </plugins>
    </build>

2.创建一个Scala的Object类

新建一个a.txt如下，并且上传到hdfs之上
在windows的f:/datas/a.txt下也创建这个文件
hello hello hello
world world hello

package com.demo.test1
import org.apache.spark.{SparkConf, SparkContext}
object SparkWordCount {
  def main(args: Array[String]): Unit = {
     //1.创建SparkContext
    val sparkConf: SparkConf =new SparkConf().setMaster("local[*]").setAppName("wc")
    //local: 只启动一个executor,local[k] : 启动k个executor,local[*] : 启动跟cpu数目相同的executor
    val sc = new SparkContext(sparkConf)

    //2.读取文件内容，执行SparkRDD任务
    sc.textFile("file:///f:/datas/a.txt")
      .flatMap(_.split(" "))
      .map((_, 1))
      .groupBy(_._1)
      .map(t => (t._1, t._2.size))
      .saveAsTextFile("file:///f:/datas/results")

    //3.关闭SparkContext
    sc.stop()
  }
}

3.点击运行在IDEA中查看效果

2.Java中编写代码上传到Linux上使用Standalone模式执行

1。创建一个maven项目，并且导入相关依赖

<dependencies>
        <!-- spark依赖-->
        <dependency>
            <groupId>org.apache.spark</groupId>
            <artifactId>spark-core_2.11</artifactId>
            <version>2.4.3</version>
        </dependency>

    </dependencies>
    <!-- maven项目对scala编译打包 -->
    <build>
        <plugins>
            <plugin>
                <groupId>net.alchim31.maven</groupId>
                <artifactId>scala-maven-plugin</artifactId>
                <version>4.0.1</version>
                <executions>
                    <execution>
                        <id>scala-compile-first</id>
                        <phase>process-resources</phase>
                        <goals>
                            <goal>add-source</goal>
                            <goal>compile</goal>
                        </goals>
                    </execution>
                </executions>
            </plugin>
        </plugins>
    </build>

2.创建一个Scala的Object类

package com.demo.test1

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

object SparkWordCount {
  def main(args: Array[String]): Unit = {
    //1.创建SparkContext
    val sparkConf: SparkConf =
          new SparkConf().setMaster("spark://hadoop10:7077").setAppName("test1")
    val sc = new SparkContext(sparkConf)

    //2.读取文件内容，执行SparkRDD任务
    sc.textFile("hdfs://hadop10:9000/a.txt")
      .flatMap(_.split(" "))
      .map((_, 1))
      .groupBy(_._1)
      .map(t => (t._1, t._2.size))
      .saveAsTextFile("hdfs://hadoop10:9000/results")

    //3.关闭SparkContext
    sc.stop()
  }
}

3.点击maven中的package打包，然后将打好的jar包上传到linux服务器中
4。在Linux中进入spark的安装路径中执行命令进行测试

[root@spark1 spark]# bin/spark-submit --master spark://hadoop10:7077 --class com.demo.test1.SparkWordCount /opt/spark-day1-1.0-SNAPSHOT.jar

5.在Hadoop10 的hdfs 中查看运行结果

3.在Linux实现 Standalone模式测试

1.在spark 安装目录下执行

bin/spark-shell --master spark://spark1:7077
scala> sc.textFile("hdfs://spark1:9000/a.txt")
		 .flatMap(_.split(" "))
		 .map((_,1))
		 .groupBy(_._1)
		 .map(t=>(t._1,t._2.size))
		 .collect
//输出结果为：Array[(String, Int)] = Array((hello,4), (world,2))

4.JobHistoryServer配置

修改spark-default.conf.template名称, 修改spark-default.conf文件，开启Log

[root@spark1 conf]# mv spark-defaults.conf.template spark-defaults.conf
[root@spark1 conf]# vi spark-defaults.conf
spark.eventLog.enabled           true
spark.eventLog.dir               hdfs://hadoop10:9000/spark-logs

修改spark-env.sh文件，添加如下配置

[root@spark1 conf]# vi spark-env.sh
SPARK_HISTORY_OPTS="-Dspark.history.fs.logDirectory=hdfs://hadoop10:9000/spark-logs"

启动yarn后启动history-server

[root@spark1 spark]# sbin/start-history-server.sh 
[root@spark1 spark]# jps
9645 HistoryServer    # 对应启动的进程名称

进入浏览器查看

   http://hadoop10:18080

5.使用Yarn模式运行spark

1.修改yarn配置文件：yarn-site.xml文件

<!--是否启动一个线程检查每个任务正使用的物理内存量，如果任务超出分配值，则直接将其杀掉，默认是true -->
<property>
	<name>yarn.nodemanager.pmem-check-enabled</name>
	<value>false</value>
</property>
		
<!--是否启动一个线程检查每个任务正使用的虚拟内存量，如果任务超出分配值，则直接将其杀掉，默认是true -->
<property>
	<name>yarn.nodemanager.vmem-check-enabled</name>
	<value>false</value>
</property>

2.修改spark-env.sh，添加如下配置：

注意和standalone的区别，不需要在配置SPARK_MASTER_HOST和SPARK_MASTER_PORT
SPARK_HISTORY_OPTS可以继续使用
[root@spark1 conf]# vi spark-env.sh
YARN_CONF_DIR=/opt/hadoop2.9.2/etc/hadoop

3.执行一个程序
3.1.在linux中的spark目录下执行测试

[root@spark1 spark]# bin/spark-shell --master yarn
scala> sc.textFile("hdfs://hadoop10:9000/a.txt")
          .flatMap(_.split(" "))
          .map((_,1))
          .groupBy(_._1)
          .map(t=>(t._1,t._2.size))

3.2写一个Java项目打包后上传到 Linux然后执行

jar包对应的程序中设置master为yarn new SparkConf().setMaster("yarn").setAppName("wc")
[root@spark1 spark]# bin/spark-submit --master yarn --class com.demo.test1.SparkWordCount /opt/spark-day1-1.0-SNAPSHOT.jar

小雨光

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Spark（一）

一、简介Apache Spark 是专为大规模数据处理而设计的快速通用的计算引擎。拥有Hadoop MapReduce所具有的优点；但不同于MapReduce的是——Job中间输出结果可以保存在内存中，从而不再需要读写HDFS，因此Spark能更好地适用于数据挖掘与机器学习等需要迭代的MapReduce的算法。二、特点1.高级 API 剥离了对集群本身的关注，Spark 应用开发者可以专注于应用所要做的计算本身。2.Spark 很快，支持交互式计算和复杂算法。（内存计算下，Spark 比 Hadoo
复制链接

扫一扫