spark 层次结构 spark详解

目录

一、Spark概述

1.1spark框架与hadoop框架

1.2Spark的内置模块

1.3Spark的特点

 二、Spark的使用

2.1Spark的运行模式

2.2Local模式

2.3Spark集群中的角色介绍

 2.4Standalone模式

 2.5YARN模式

三、WordCount案例

---

一、Spark概述

        Spark是一种基于内存的快速、通用、可扩展的大数据分析计算引擎。

1.1spark框架与hadoop框架

1.2Spark的内置模块

        Spark Core：实现了Spark的基本功能，包含任务调度、内存管理、错误恢复、与存储系统交互等模块。Spark Core中还包含了对弹性分布式数据集(Resilient Distributed DataSet，简称RDD)的API定义。

        Spark SQL：是Spark用来操作结构化数据的程序包。通过Spark SQL，我们可以使用 SQL或者Apache Hive版本的HQL来查询数据。Spark SQL支持多种数据源，比如Hive表、Parquet以及JSON等。

        Spark Streaming：是Spark提供的对实时数据进行流式计算的组件。提供了用来操作数据流的API，并且与Spark Core中的 RDD API高度对应。

        Spark MLlib：提供常见的机器学习功能的程序库。包括分类、回归、聚类、协同过滤等，还提供了模型评估、数据 导入等额外的支持功能。

用于图形并行计算和图挖掘系统的组件。

        集群管理器：Spark设计为可以高效地在一个计算节点到数千个计算节点之间伸缩计算。为了实现这样的要求，同时获得最大灵活性，Spark支持在各种集群管理器（Cluster Manager）上运行，包括Hadoop YARN、Apache Mesos，以及Spark自带的一个简易调度器，叫作独立调度器。

        Spark得到了众多大数据公司的支持，这些公司包括Hortonworks、IBM、Intel、Cloudera、MapR、Pivotal、百度、阿里、腾讯、京东、携程、优酷土豆。当前百度的Spark已应用于大搜索、直达号、百度大数据等业务；阿里利用GraphX构建了大规模的图计算和图挖掘系统，实现了很多生产系统的推荐算法；腾讯Spark集群达到8000台的规模，是当前已知的世界上最大的Spark集群。

1.3Spark的特点

 二、Spark的使用

官网地址：Apache Spark™ - Unified Engine for large-scale data analytics

2.1Spark的运行模式

        部署Spark集群大体上分为两种模式：单机模式与集群模式

        大多数分布式框架都支持单机模式，方便开发者调试框架的运行环境。但是在生产环境中，并不会使用单机模式。

（1）Local模式：在本地部署单个Spark服务

（2）Standalone模式：Spark自带的任务调度模式。

（3）YARN模式：Spark使用Hadoop的YARN组件进行资源与任务调度。

（4）Mesos模式：Spark使用Mesos平台进行资源与任务的调度。

2.2Local模式

下载安装完成后进入spark-local，运行官网案例

bin/spark-submit \
--class org.apache.spark.examples.SparkPi \
--master local[2] \
./examples/jars/spark-examples_2.12-3.0.0.jar \
10
--class：表示要执行程序的主类；
--master local[2]
（1）local: 没有指定线程数，则所有计算都运行在一个线程当中，没有任何并行计算
（2）local[K]:指定使用K个Core来运行计算，比如local[2]就是运行2个Core来执行
（3）local[*]：默认模式。自动帮你按照CPU最多核来设置线程数。比如CPU有8核，Spark帮你自动设置8个线程计算。
spark-examples_2.12-3.0.0.jar：要运行的程序；
10：要运行程序的输入参数（计算圆周率π的次数，计算次数越多，准确率越高）；

查看所有参数

bin/spark-submit

官方wordcount案例

        注意：sc是SparkCore程序的入口；spark是SparkSQL程序入口；master = local[*]表示本地模式运行。

 启动spark-shell

bin/spark-shell

        登录hadoop102:4040，查看程序运行情况（注意：spark-shell窗口关闭掉，则hadoop102:4040页面关闭）本地模式下，默认的调度器为FIFO。

        运行WordCount程序

sc.textFile("/opt/module/spark-local/input").flatMap(_.split(" ")).map((_,1)).reduceByKey(_+_).collect

2.3Spark集群中的角色介绍

        Master与worker

  Master和Worker是Spark的守护进程、集群资源管理者，即Spark在特定模式(Standalone)下正常运行必须要有的后台常驻进程。

        driver和executor

        Driver和Executor是临时程序，当有具体任务提交到Spark集群才会开启的程序。

 2.4Standalone模式

       Standalone模式是Spark自带的资源调度引擎，构建一个由Master + Worker构成的Spark集群，Spark运行在集群中。

安装

        1.下载安装spark-standalone

       2. 进入spark-standalone/conf，在slaves.template中添加节点集群数

hadoop102
hadoop103
hadoop104

       3. 修改spark-env.sh文件，添加master节点

SPARK_MASTER_HOST=hadoop102
SPARK_MASTER_PORT=7077

        4.分发给集群其他节点

        5.启动

sbin/start-all.sh

hadoop102:8080

        7.官方案例

bin/spark-submit \
--class org.apache.spark.examples.SparkPi \
--master spark://hadoop102:7077 \
./examples/jars/spark-examples_2.12-3.0.0.jar \
10

参数：--master spark://hadoop102:7077指定要连接的集群的master

参数说明

bin/spark-submit \
--class org.apache.spark.examples.SparkPi \
--master spark://hadoop102:7077 \
--executor-memory 2G \
--total-executor-cores 2 \
./examples/jars/spark-examples_2.12-3.0.0.jar \
10

参数	解释	可选值举例
--class	Spark程序中包含主函数的类
--master	Spark程序运行的模式	本地模式：local[*]、spark://hadoop102:7077、 Yarn
--executor-memory 1G	指定每个executor可用内存为1G	符合集群内存配置即可，具体情况具体分析。
--total-executor-cores 2	指定所有executor使用的cpu核数为2个
application-jar	打包好的应用jar，包含依赖。这个URL在集群中全局可见。 比如hdfs:// 共享存储系统，如果是file:// path，那么所有的节点的path都包含同样的jar
application-arguments	传给main()方法的参数

配置历史服务器

        1.在spark-default.conf.template中配置日志存储路径

spark.eventLog.enabled          true
spark.eventLog.dir              hdfs://hadoop102:8020/directory

        2.修改spark-env.sh文件

export SPARK_HISTORY_OPTS="
-Dspark.history.ui.port=18080 
-Dspark.history.fs.logDirectory=hdfs://hadoop102:8020/directory 
-Dspark.history.retainedApplications=30"

        3.分发启动

hadoop102:18080

配置高可用

        1.启动zookeeper

        2.修改spark-env.sh文件

#注释掉如下内容：
#SPARK_MASTER_HOST=hadoop102
#SPARK_MASTER_PORT=7077

#添加上如下内容。配置由Zookeeper管理Master，在Zookeeper节点中自动创建/spark目录，用于管理：
export SPARK_DAEMON_JAVA_OPTS="
-Dspark.deploy.recoveryMode=ZOOKEEPER 
-Dspark.deploy.zookeeper.url=hadoop102,hadoop103,hadoop104 
-Dspark.deploy.zookeeper.dir=/spark"

#添加如下代码
#Zookeeper3.5的AdminServer默认端口是8080，和Spark的WebUI冲突
export SPARK_MASTER_WEBUI_PORT=8989

        3.分发启动

        4.高可用集群访问

bin/spark-shell \
--master spark://hadoop102:7077,hadoop103:7077 \
--executor-memory 2g \
--total-executor-cores 2

参数：--master spark://hadoop102:7077指定要连接的集群的master
注：一旦配置了高可用以后，master后面要连接多个master

运行流程

        Spark有standalone-client和standalone-cluster两种模式，主要区别在于：Driver程序的运行节点。

        客户端模式启动

bin/spark-submit \
--class org.apache.spark.examples.SparkPi \
--master spark://hadoop102:7077,hadoop103:7077 \
--executor-memory 2G \
--total-executor-cores 2 \
--deploy-mode client \
./examples/jars/spark-examples_2.12-3.0.0.jar \
10

        集群模式启动

bin/spark-submit \
--class org.apache.spark.examples.SparkPi \
--master spark://hadoop102:7077,hadoop103:7077 \
--executor-memory 2G \
--total-executor-cores 2 \
--deploy-mode cluster \
./examples/jars/spark-examples_2.12-3.0.0.jar \
10

 

 2.5YARN模式

安装

        1.下载安装，并将名字改为mv spark-3.0.0-bin-hadoop3.2/ spark-yarn

        2.修改hadoop配置文件hadoop-3.1.3/etc/hadoop/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>

        3.分发

        4.修改spark-yarn/conf/spark-env.sh

YARN_CONF_DIR=/opt/module/hadoop-3.1.3/etc/hadoop

        5.启动集群，运行案例

bin/spark-submit \
--class org.apache.spark.examples.SparkPi \
--master yarn \
./examples/jars/spark-examples_2.12-3.0.0.jar \
10

配置历史服务

        1.修改spark-default.conf.template名称，并添加内容

spark.eventLog.enabled          true
spark.eventLog.dir               hdfs://hadoop102:8020/directory

        2修改spark-env.sh文件

export SPARK_HISTORY_OPTS="
-Dspark.history.ui.port=18080 
-Dspark.history.fs.logDirectory=hdfs://hadoop102:8020/directory 
-Dspark.history.retainedApplications=30"

配置历史日志

        为了能从Yarn上关联到Spark历史服务器，需要配置spark历史服务器关联路径。

        目的：点击yarn（8088）上spark任务的history按钮，进入的是spark历史服务器（18080），而不再是yarn历史服务器（19888）。

        1.修改/spark-yarn/conf/spark-defaults.conf

spark.yarn.historyServer.address=hadoop102:18080
spark.history.ui.port=18080

        2.重启Spark历史服务，提交到yarn运行

bin/spark-submit \
--class org.apache.spark.examples.SparkPi \
--master yarn \
./examples/jars/spark-examples_2.12-3.0.0.jar \
10

        3.Web页面查看日志：http://hadoop103:8088/cluster

运行流程

   Spark有yarn-client和yarn-cluster两种模式，主要区别在于：Driver程序的运行节点。

        yarn-client：Driver程序运行在客户端，适用于交互、调试，希望立即看到app的输出。

        yarn-cluster：Driver程序运行在由ResourceManager启动的APPMaster，适用于生产环境。

客户端模式

bin/spark-submit \
--class org.apache.spark.examples.SparkPi \
--master yarn \
--deploy-mode client \
./examples/jars/spark-examples_2.12-3.0.0.jar \
10

集群模式

bin/spark-submit \
--class org.apache.spark.examples.SparkPi \
--master yarn \
--deploy-mode cluster \
./examples/jars/spark-examples_2.12-3.0.0.jar \
10

 

 模式对比

模式	Spark安装机器数	需启动的进程	所属者
Local	1	无	Spark
Standalone	3	Master及Worker	Spark
Yarn	1	Yarn及HDFS	Hadoop

端口号

1）Spark查看当前Spark-shell运行任务情况端口号：4040

2）Spark Master内部通信服务端口号：7077 （类比于yarn的8032(RM和NM的内部通信)端口）

3）Spark Standalone模式Master Web端口号：8080（类比于Hadoop YARN任务运行情况查看端口号：8088）

4）Spark历史服务器端口号：18080 （类比于Hadoop历史服务器端口号：19888）

三、WordCount案例

程序

package com.hpu

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

object spark {
  def main(args: Array[String]): Unit = {
  // 1. 创建配置对象
    val conf: SparkConf = new SparkConf()
          .setAppName("WC")
          .setMaster("local[*]")

 // 2. 创建sc
    val sc: SparkContext = new SparkContext(conf)
    // 3. 设计任务  执行任务
    // spark进行计算  只会记录运算的流程  不会真的计算
    val lineRDD: RDD[String] = sc.textFile(args(0))

    val wordRDD: RDD[String] = lineRDD.flatMap(_.split(" "))

   val wordToOneRDD: RDD[(String, Int)] = wordRDD.map((_, 1))

    val wordToSumRDD: RDD[(String, Int)] = wordToOneRDD.reduceByKey(_ + _)
 

    wordToSumRDD.saveAsTextFile(args(1))
 // 使用线程睡眠  可以到localhost:4040端口查看任务运行的流程
    //    Thread.sleep(60000)
    //sc.textFile(args(0)).flatMap(_.split(" ")).map((_, 1)).reduceByKey(_ + _).saveAsTextFile(args(1))
    sc.stop()
  }
}

依赖

<dependencies>
    <dependency>
        <groupId>org.apache.spark</groupId>
        <artifactId>spark-core_2.12</artifactId>
        <version>3.0.0</version>
    </dependency>
</dependencies>

<build>
	<finalName>WordCount</finalName>
    <plugins>
        <plugin>
            <groupId>net.alchim31.maven</groupId>
            <artifactId>scala-maven-plugin</artifactId>
            <version>3.4.6</version>
            <executions>
                <execution>
                   <goals>
                      <goal>compile</goal>
                      <goal>testCompile</goal>
                   </goals>
                </execution>
             </executions>
        </plugin>
    </plugins>
</build>

打包插件

<plugin>
    <groupId>org.apache.maven.plugins</groupId>
    <artifactId>maven-assembly-plugin</artifactId>
    <version>3.0.0</version>
    <configuration>
        <descriptorRefs>
            <descriptorRef>jar-with-dependencies</descriptorRef>
        </descriptorRefs>
    </configuration>
    <executions>
        <execution>
            <id>make-assembly</id>
            <phase>package</phase>
            <goals>
                <goal>single</goal>
            </goals>
        </execution>
    </executions>
</plugin>

清屏log4j.properties文件

log4j.rootCategory=ERROR, console
log4j.appender.console=org.apache.log4j.ConsoleAppender
log4j.appender.console.target=System.err
log4j.appender.console.layout=org.apache.log4j.PatternLayout
log4j.appender.console.layout.ConversionPattern=%d{yy/MM/dd HH:mm:ss} %p %c{1}: %m%n

# Set the default spark-shell log level to ERROR. When running the spark-shell, the
# log level for this class is used to overwrite the root logger's log level, so that
# the user can have different defaults for the shell and regular Spark apps.
log4j.logger.org.apache.spark.repl.Main=ERROR

# Settings to quiet third party logs that are too verbose
log4j.logger.org.spark_project.jetty=ERROR
log4j.logger.org.spark_project.jetty.util.component.AbstractLifeCycle=ERROR
log4j.logger.org.apache.spark.repl.SparkIMain$exprTyper=ERROR
log4j.logger.org.apache.spark.repl.SparkILoop$SparkILoopInterpreter=ERROR
log4j.logger.org.apache.parquet=ERROR
log4j.logger.parquet=ERROR

# SPARK-9183: Settings to avoid annoying messages when looking up nonexistent UDFs in SparkSQL with Hive support
log4j.logger.org.apache.hadoop.hive.metastore.RetryingHMSHandler=FATAL
log4j.logger.org.apache.hadoop.hive.ql.exec.FunctionRegistry=ERROR

打包成jar包，在HDFS端上传文件input，将结果存放于output

bin/spark-submit \
--class com.hpu.spark \
--master yarn \
WordCount.jar \
/input/input \
/output

本地调试

package com.hpu

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

object spark {
  def main(args: Array[String]): Unit = {
    val conf: SparkConf = new SparkConf()
          .setAppName("WC")
          .setMaster("local[*]")

    val sc: SparkContext = new SparkContext(conf)
    val lineRDD: RDD[String] = sc.textFile("E:/bigdata_study/wordcount/input")

    val wordRDD: RDD[String] = lineRDD.flatMap(_.split(" "))

   val wordToOneRDD: RDD[(String, Int)] = wordRDD.map((_, 1))

    val wordToSumRDD: RDD[(String, Int)] = wordToOneRDD.reduceByKey(_ + _)

    wordToSumRDD.collect().foreach(println)
    //sc.textFile(args(0)).flatMap(_.split(" ")).map((_, 1)).reduceByKey(_ + _).saveAsTextFile(args(1))
    sc.stop()
  }
}

debug技巧