spark core 总结

最新推荐文章于 2024-04-18 04:54:42 发布

mizui_i

最新推荐文章于 2024-04-18 04:54:42 发布

阅读量353

点赞数

分类专栏： spark 文章标签： spark hadoop big data

本文链接：https://blog.csdn.net/mizui_i/article/details/121724395

版权

spark 专栏收录该内容

4 篇文章 0 订阅

订阅专栏

一.Spark 架构设计

架构设计图在这里插入图片描述

二.相关术语名词解释

RDD (Resilient Distributed DataSet)
- 弹性分布式数据集，是对数据集在spark存储和计算过程中的一种抽象。
- 是一组只读、可分区的的分布式数据集合。
- 一个RDD 包含多个分区Partition(类似于MapReduce中的InputSplit)，分区是依照一定的规则的，将具有相同规则的属性的数据记录放在一起。
- 横向上可切分并行计算，以分区Partition为切分后的最小存储和计算单元。
- 纵向上可进行内外存切换使用，即当数据在内存不足时，可以用外存磁盘来补充。
Partition（分区）
- Partition类似hadoop的Split，计算是以partition为单位进行的，提供了一种划分数据的方式。
- opartition的划分依据有很多，常见的有Hash分区、范围分区等，也可以自己定义的，像HDFS文件，划分的方式就和MapReduce一样，以文件的block来划分不同的partition。
- 一个Partition交给一个Task去计算处理
算子
- 英文简称：Operator，简称op
- 广义上讲，对任何函数进行某一项操作都可以认为是一个算子
- 通俗上讲，算子即为映射、关系、变换。
- MapReduce算子，主要分为两个，即为Map和Reduce两个主要操作的算子，导致灵活可用性比较差。
- Spark算子，分为两大类，即为Transformation和Action类，合计有80多个。
Transformation类算子
- 操作是延迟计算的，也就是说从一个RDD 转换生成另一个 RDD 的转换操作不是马上执行，需要等到有Action 操作的时候才会真正触发运算。
- 细分类
  - Value数据类型的Transformation算子
  - Key-Value数据类型的Transfromation算子
Action类算子
- 会触发 Spark 提交作业（Job），并将数据输出 Spark系统。
窄依赖
- 如果一个父RDD的每个分区只被子RDD的一个分区使用 ----> 一对一关系
宽依赖
- 如果一个父RDD的每个分区要被子RDD 的多个分区使用 ----> 一对多关系
Application
- Spark Application的概念和MapReduce中的job或者yarn中的application类似，指的是用户编写的Spark应用程序，包含了一个Driver功能的代码和分布在集群中多个节点上运行的Executor代码
- 一般是指整个Spark项目从开发、测试、布署、运行的全部。
Driver
- 运行main函数并且创建SparkContext的程序。
- 称为驱动程序，Driver Program类似于hadoop的wordcount程序中的driver类的main函数。
Cluster Manager
- 集群的资源管理器，在集群上获取资源的服务。如Yarn、Mesos、Spark Standalone等。
- 以Yarn为例，驱动程序会向Yarn申请计算我这个任务需要多少的内存，多少CPU等，后由Cluster Manager会通过调度告诉驱动程序可以使用，然后驱动程序将任务分配到既定的Worker Node上面执行。
WorkerNode
- 集群中任何一个可以运行spark应用代码的节点。
- Worker Node就是物理机器节点，可以在上面启动Executor进程。
Executor
- Application运行在Worker节点上的一个进程，该进程负责运行Task，并且负责将数据存在内存或者磁盘上，每个Application都有各自独立专享的一批Executor。
- Executor即为spark概念的资源容器，类比于yarn的container容器，真正承载Task的运行与管理，以多线程的方式运行Task，更加高效快速。
Task
- 与Hadoop中的Map Task或者Reduce Task是类同的
- 分配到executor上的基本工作单元，执行实际的计算任务。
- Task分为两类，即为ShuffleMapTask和ResultTask。
  - ShuffleMapTask：即为Map任务和发生Shuffle的任务的操作，由Transformation操作组成，其输出结果是为下个阶段任务(ResultTask)进行做准备，不是最终要输出的结果。
  - ResultTask：即为Action操作触发的Job作业的最后一个阶段任务，其输出结果即为Application最终的输出或存储结果。
Job（作业）
- Spark RDD里的每个action的计算会生成一个job。
- 用户提交的Job会提交给DAGScheduler（Job调度器），Job会被分解成Stage去执行，每个Stage由一组相同计算规则的Task组成，该组Task也称为TaskSet，实际交由TaskScheduler去调度Task的机器执行节点，最终完成作业的执行。
Stage（阶段）
- Stage是Job的组成部分，每个Job可以包含1个或者多个Stage。
- Job切分成Stage是以Shuffle作为分隔依据，Shuffle前是一个Stage，Shuffle后是一个Stage。即为按RDD宽窄依赖来划分Stage。
- 每个Job会被拆分很多组Task，每组任务被称为Stage，也可称TaskSet，一个作业可以被分为一个或多个阶段

三.saprk运行模式

在这里插入图片描述
四.spark用户的交互方式
最主要使用的是spark-shell,spark-submit,spark-sql

spark-shell:spark命令行方式来操作spark作业。
- 多用于简单的学习、测试、简易作业操作。
spark-submit:通过程序脚本，提交相关的代码、依赖等来操作spark作业。
- 最多见的提交任务的交互方式，简单易用、参数齐全。
spark-sql:通过sql的方式操作spark作业。
- sql相关的学习、测试、生产环境研发均可以使用该直接操作交互方式。
spark-class:最低层的调用方式，其它调用方式多是最终转化到该方式中去提交。
- 直接使用较少
sparkR,sparkPython:通过其它非java、非scala语言直接操作spark作业的方式。
- R、python语言使用者的交互方式。

五.spark-shell

启动方式

前置环境：已将spark-shell等交互式脚本已加入系统PATH变量，可在任意位置使用。

以本地2个线程来模拟运行spark相关操作，该数量一般与本机的cpu核数相一致为最佳spark-shell --master local[2]示例

# 启动
spark-shell --master local[2]

# 构建一个列表并输出
scala> var list = List(1,2,3,4)
list: List[Int] = List(1, 2, 3, 4)

scala> list.foreach(println)
1
2
3
4


# 通过scala list构建一个rdd,并进行基本操作
scala> var listRDD = sc.parallelize(List(1,2,3,4))
listRDD: org.apache.spark.rdd.RDD[Int] = ParallelCollectionRDD[0] at parallelize at <console>:24

scala> listRDD.count
res2: Long = 4

scala> listRDD.first
res3: Int = 1

# 通过本地文件构建RDD
scala> var localFileRDD = sc.textFile("file:///home/job018/fujunhua/data/a.txt")
localFileRDD: org.apache.spark.rdd.RDD[String] = file:///home/job018/fujunhua/data/a.txt MapPartitionsRDD[2] at textFile at <console>:24

# 通过hdfs文件构建RDD
scala> var hdfsFileRDD = sc.textFile("hdfs:///user/fujunhua/data/a.txt")
hdfsFileRDD: org.apache.spark.rdd.RDD[String] = hdfs:///user/fujunhua/data/a.txt MapPartitionsRDD[4] at textFile at <console>:24

# 对rdd进行字符串过滤操作
scala> localFileRDD.filter(x=>x=="tom").foreach(println)
tom

# 求最大值
scala> listRDD.reduce((a,b)=>if(a>b) a else b)
res5: Int = 4

# 对输入进行wodcount计算-无排序
scala> var rdd1 = sc.parallelize(List("a","b","c","a","c"))
rdd1: org.apache.spark.rdd.RDD[String] = ParallelCollectionRDD[6] at parallelize at <console>:24

scala> rdd1.map(word=>(word,1)).reduceByKey((a,b)=>a+b).collect().foreach(println)
(b,1)
(a,2)
(c,2)

# 对输入进行wodcount计算-有排序(false就是降序输出)
scala> rdd1.map(word=>(word,1)).reduceByKey((a,b)=>a+b).sortBy(_._2,false).collect().foreach(println)
(a,2)
(c,2)
(b,1)

六.spark-submit

最常用的通过程序脚本，提交相关的代码、依赖等来操作spark作业的方式。
启动方式

spark-submit提交任务的模板
spark-submit \
  --class <main-class> \
  --master <master-url> \
  --jars jar_list_by_comma \
  --conf <key>=<value> \
  ... # other options
  <application-jar> \
  [application-arguments]

参数说明

在这里插入图片描述
关于–master取值的特别说明

七.java实现 spark wordcount

配置winutils.exe
- 作用
  - hadoop基于linux开发和布署运行，故不能将hadoop环境原始运行在windows上。
  - 操作系统环境差异说明
    - linux环境不需要
    - windows下运行需要该文件
      - 配置到运行环境当前目录下的null/bin目录下
maven pom配置

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

 

    <groupId>com.antg</groupId>
    <artifactId>spark-wc</artifactId>
    <version>1.0-SNAPSHOT</version>

    <properties>
        <maven.compiler.source>8</maven.compiler.source>
        <maven.compiler.target>8</maven.compiler.target>
    </properties>

    <dependencies>
        <dependency><groupId>org.apache.spark</groupId>
            <artifactId>spark-core_2.11</artifactId>
            <version>2.3.2</version>
            <scope>provided</scope>
        </dependency>
        <!-- log4j依赖添加 -->
        <dependency>
            <groupId>log4j</groupId>
            <artifactId>log4j</artifactId>
            <version>1.2.17</version>
            <scope>provided</scope>
        </dependency>
    </dependencies>

    <build>
        <finalName>spark_wc</finalName>
        <plugins>
            <plugin>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>2.3.2</version>
                <configuration>
                    <source>1.8</source>
                    <target>1.8</target>
                    <encoding>UTF-8</encoding>
                </configuration>
            </plugin>
            <plugin>
                <artifactId>maven-assembly-plugin</artifactId>
                <configuration>
                    <descriptorRefs>
                        <descriptorRef>jar-with-dependencies</descriptorRef>
                    </descriptorRefs>
                </configuration>
                <executions>
                    <execution>
                        <id>make-assembly</id>
                        <phase>package</phase>
                        <goals>
                            <goal>assembly</goal>
                        </goals>
                    </execution>
                </executions>
            </plugin>
        </plugins>
    </build>

</project>

代码

package com.antg.main;

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;
import java.util.List;

/**
 * @Description: java版实现 spark wc
 * @Author 子兔Antg
 * @Date 2021/11/18
 **/
public class WordCount {
    public static void main(String[] args) {
        //1. 初始化 spark conf 设置app name
        SparkConf conf = new SparkConf();
        conf.setAppName("fjh-java-spark-wc");
        conf.setMaster("local[*]");

        //2. 构建spark content
        JavaSparkContext jsc = new JavaSparkContext(conf);

        //3. 定义输入文件
        if (args == null || args.length != 1) {
            System.err.println("参数错误");
            System.exit(1);
        }
        String filePath = args[0];

        //4. 构建rdd
        JavaRDD<String> rdd = jsc.textFile(filePath);

        //5. lines rdd -> word rdd
        JavaRDD<String> wordRDD = rdd.flatMap(new FlatMapFunction<String, String>() {
                    @Override
                    public Iterator<String> call(String line) throws Exception {
                        return Arrays.asList(line.split("\\s+")).iterator();
                    }
                });

        //6. word rdd -> (word,1)的rdd
        JavaPairRDD<String, Integer> kvPairRDD = wordRDD.mapToPair(new PairFunction<String, String, Integer>() {
                    @Override
                    public Tuple2<String, Integer> call(String word)
                            throws Exception {
                        return new Tuple2<String, Integer>(word, 1);
                    }
                });
        //7. (word,1)的rdd -> (word,freq)的rdd
        JavaPairRDD<String, Integer> wcPairRDD = kvPairRDD.reduceByKey(new Function2<Integer, Integer, Integer>() {
                    @Override
                    public Integer call(Integer v1, Integer v2)
                            throws Exception {
                        return v1 + v2;
                    }
                });
        //8. 将(word,freq) rdd -> collect落地形成本地对象数
        List<Tuple2<String, Integer>> pairList = wcPairRDD.collect();

        //9. 将对象数据打印出来
        for (Tuple2<String, Integer> tuple2 : pairList) {
            System.out.println(tuple2);
        }
        //10. 关闭上下文环境
        jsc.stop();

        System.out.println("done!!");
    }
}

注意 : 如果报错类找不到,就将pom中的<scope>provided</scope>注释掉

八.运行方式

本地运行

直接run主类即可在这里插入图片描述

linux本地方式-local-生产环境

        mvn clean package
        上传
        编写shell

#! /bin/sh
# 配置成hadoop配置文件存放目录
export HADOOP_CONF_DIR=/usr/hdp/3.1.0.0-78/hadoop/conf
spark-submit \
--class com.antg.main.WordCount \
--master local \
--driver-memory 512m \
--executor-memory 512m \
--num-executors 2 \
/home/job018/fujunhua/myjar/spark_wc-jar-with-dependencies.jar \
file:///home/job018/fujunhua/data/a.txt

结果

在这里插入图片描述
集群方式

注意:这里不可以使用本地文件了,只能用hdfs文件
yarn-client

#! /bin/sh
# 配置成hadoop配置文件存放目录
export HADOOP_CONF_DIR=/usr/hdp/3.1.0.0-78/hadoop/conf
spark-submit \
--class com.antg.main.WordCount \
--master yarn-client \
--driver-memory 512m \
--executor-memory 512m \
--num-executors 2 \
/home/job018/fujunhua/myjar/spark_wc-jar-with-dependencies.jar \
hdfs:///user/fujunhua/data/a.txt

结果

在这里插入图片描述
yarn-cluster

#! /bin/sh
# 配置成hadoop配置文件存放目录
export HADOOP_CONF_DIR=/usr/hdp/3.1.0.0-78/hadoop/conf
spark-submit \
--class com.antg.main.WordCount \
--master yarn-cluster \
--driver-memory 512m \
--executor-memory 512m \
--num-executors 2 \
/home/job018/fujunhua/myjar/spark_wc-jar-with-dependencies.jar \
hdfs:///user/fujunhua/data/a.txt

结果

在这里插入图片描述
这里的输出结果仅可以再日志中查看

在这里插入图片描述

mizui_i

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
打赏
0
评论
spark core 总结

一.Spark 架构设计架构设计图二.相关术语名词解释RDD (Resilient Distributed DataSet) 弹性分布式数据集，是对数据集在spark存储和计算过程中的一种抽象。是一组只读、可分区的的分布式数据集合。一个RDD 包含多个分区Partition(类似于MapReduce中的InputSplit)，分区是依照一定的规则的，将具有相同规则的属性的数据记录放在一起。横向上可切分并行计算，以分区Partition为切分后的最小存储和计算单元。 .
复制链接

扫一扫