Spark基础篇-初识Spark

最新推荐文章于 2024-07-06 05:35:14 发布
最新推荐文章于 2024-07-06 05:35:14 发布
阅读量397 收藏 1
点赞数 1
分类专栏： Spark 文章标签： 大数据 spark hadoop mapreduce
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/angeliacmm/article/details/116431032
版权

Spark系列文章目录

第一章 初识Spark
第二章 Spark-Core核心模型（一）
第二章 Spark-Core核心模型（二）
第三章 Spark-Core编程进阶（一）
第三章 Spark-Core编程进阶（二）
第四章 Spark-SQL基础（一）
第四章 Spark-SQL基础（二）
第五章 Spark-SQL进阶（一）
第五章 Spark-SQL进阶（二）
第五章 Spark-SQL进阶（三）

第一章 初识Spark

1.认识Spark

Spark是加州大学伯克利分校AMP实验室开发基于内存的通用并行计算框架。

思考：已经学习了MapReduce，为什么要学习Spark？

1.1并行计算

并行计算（Parallel Computing）是指同时使用多种计算资源解决计算问题的过程，是提高计算机系统计算速度和处理能力的一种有效手段。

它的基本思想是：用多个处理器来协同求解同一问题。

注意，其实就是将被求解的问题分解成若干个部分，各部分均由一个独立的处理机来并行计算

并行计算系统：

  • 既可以是专门设计的、含有多个处理器的超级计算
  • 也可以是以某种方式互连的若干台的独立计算机构成的集群

通过并行计算集群完成数据的处理，再将处理的结果返回给用

1.2 MapReduce

MapReduce是面向大数据并行处理的计算模型、框架和平台，它隐含了以下三层含义：

  1. MapReduce是一个基于集群的高性能并行计算平台（Cluster Infrastructure）

    它允许用市场上普通的商用服务器构成一个包含数十、数百至数千个节点的分布和并行计算集群。

  2. MapReduce是一个并行计算与运行软件框架（Software Framework）

    • 能自动完成计算任务的并行化处理
    • 能自动划分计算数据和计算任务
    • 能自动分配和执行任务
    • 能收集计算结果
    • 能将数据分布存储、数据通信、容错处理等并行计算涉的很多系统底层的复杂细节处理
    • 能大大减少了软件开发人员的负担

  3. MapReduce是一个并行程序设计模型与方法（Programming Model & Methodology）

    它借助于函数式程序设计语言Lisp的设计思想。

    • 提供了一种简便的并行程序设计方法，用Map和Reduce两个函数编程实现基本的并行计算任务
    • 提供了抽象的操作和并行编程接口，以简单方便地完成大规模数据的编程和计算处理
1.2.1 优点

  • Mapreduce易于编程

    • 简单的实现一些接口，就可以完成一个分布式程序

  • 良好的扩展性

    • 当项目计算资源得不到满足的时候，可以简单的通过增加机器来扩展它的计算能力

  • 高容错性

    • 当一个机器挂了，可以把上面的计算任务转移到另一个节点上运行，此过程由框架自行完成

  • 适合PB级以上海量数据的离线处理

1.2.2 缺点

  • 实时计算

    • MapReduce无法像Oracle或MySQL那样在毫米或秒级内返回结果，如果需要大数据量的毫秒级响应，可以考虑使用HBase。

  • 流式计算

    • 流计算的输入数据是动态的，而MapReduce的输入数据是静态的，不能动态变化，这是因为MapReduce自身的设计特点决定了数据源必须是静态的。如果需要处理流式数据可以用Storm、Spark Steaming、Flink。

  • 数据挖掘、 DAG(有向图)、机器学习等迭代计算

    • 多个应用程序存在依赖关系，后一个应用程序的输入为前一个的输出。在这种情况下，MapReduce并不是不能做，而是使用后，每个MapReduce作业的输出结果都会写入磁盘，会造成大量的磁盘IO导致性能非常低下，此时可以考虑用Spark等迭代计算框架。

1.3 Spark由来

发展历程

  • 2009年由 Berkeley’s AMPLab 开始编写最初的源代码；

  • 2010年开放源代码；

  • 2013年6月进入Apache孵化器项目；

  • 2014年2月成为Apache的顶级项目（8 个月时间）；

  • 2014年5月底Spark1.0.0发布；

    ……………………

  • 2016年3月Spark1.6.1发布；

  • 2016年7月Spark2.0发布；

    ……………………

  • 2020年2月Spark2.4.5发布；

  • 2020年6月Spark3.0.0发布；

Spark官网地址

在这里插入图片描述

1.4 Spark特点

在Spark官网上介绍，它具有运行速度快、易用性好、通用性强和随处运行等特点。

  1. 运行速度快

Spark拥有DAG执行引擎，支持在内存中对数据进行迭代计算。官方提供的数据表明，如果数据由磁盘读取，速度是Hadoop MapReduce的10倍以上，如果数据从内存中读取，速度可以高达100多倍。

在这里插入图片描述

  1. 易用性好

支持4种语⾔言的API：Scala、Java、Python、R。特别是Scala是一种高效、可拓展的语言，能够用简洁的代码处理较为复杂的处理工作。

//Sprark-Core RDD
//词频统计 SparkContext
val text_file:RDD[String]=sc.textFile("hdfs://...")
text_file.flatMap(_.split(" ")).map(word => (word,1)).reduceByKey(_+_)

//Sprark-Sql  Dataset SparkSession
//从Spark2.2.0之后,推荐使用 Dataset API
val textFile:Dataset[String] = spark.read.textFile("README.md")
val wordCounts = textFile.flatMap(line => line.split(" ")).groupByKey(identity).count()
  1. 通用性强

Spark技术栈是由以下五个组件组成，分别为：

在这里插入图片描述

这些组件分别提供以下功能：

  • Spark Core提供内存计算
  • SparkStreaming提供实时计算
  • Spark SQL提供即时查询
  • MLlib提供机器学习
  • GraphX提供图处理

它们都是由AMP实验室提供，能够无缝的集成并提供一站式解决平台。

注意，Spark其他项目都会依赖于核心项目 Spark-Core的中的组件模块。

  1. 随处运行
  • Spark可以读取HDFS、HBase、Cassandra S3中的数据
  • 可以运行在Mesos、YARN和Standalone等资源管理调度器
    在这里插入图片描述

Spark生态圈：也称为BDAS（伯克利数据分析栈），是伯克利APMLab实验室打造的，力图在算法（Algorithms）、机器（Machines）、人（People）之间通过大规模集成来展现大数据应用的一个平台。

运用大数据、云计算、通信等各种资源以及各种灵活的技术方案，对海量不透明的数据进行甄别并转化为有用的信息，以供人们更好的理解世界。

该生态圈已经涉及到机器学习、数据挖掘、数据库、信息检索、自然语言处理和语音识别等多个领域。

2.Spark安装

2.1 Spark模式

Spark的部署/运行模式默认为local[*]。

2.1.1 本地模式

Local模式是在一台计算机上的运行模式，适合于学习与测试。

设置本地模式的三种方式：

  1. local 用单线程来运行

  2. local[Number] 用Number个线程模式并行

  3. local[*] *代表该计算机的CPU核数

2.1.2 Yarn模式

Spark-On-Yarn模式是在Yarn集群中运行，适合于生产环境。

​ yarn

2.1.3 Standalone模式

Spark-Standalone模式是在Spark独立集群中运行，适合于生产环境。需要提前搭建好Spark集群，国内使用较少。

spark://host:port

2.1.4 Mesos模式

Mesos是Apache下的开源分布式资源管理框架，它被称为是分布式系统的内核。Mesos最初是由加州大学伯克利分校的AMPLab开发的，后在Twitter得到广泛使用。

​ mesos://host:port

2.1.5 K8S模式

kubernetes，简称K8s，是用8代替8个字符“ubernete”而成的缩写。是一个开源的，用于管理云平台中多个主机上的容器化的应用。

​ k8s://https://host:port

2.2 Spark安装

2.2.1 单机配置
  1. 解压

​ tar -xvf spark.2.2.1-bin-hadoop2.7.tar

  1. 移动到opt/software目录中

​ mv spark.2.4.5-bin-hadoop2.7 /opt/software/

  1. 创建软连接

​ sudo ln -s software/spark.2.4.5-bin-hadoop2.7 spark

  1. 修改环境变量：

​ vi ～/.bashrc

export SPARK_HOME=/opt/spark
export PATH=$PATH:$SPARK_HOME/bin:$PATH:$SPARK_HOME/sbin

source ～/.bashrc

  1. 可选-修改 $SPARK_HOME/conf/log4j.properties下的log4j的级别

  2. 可选-拷贝一份hive-site.xml到spark安装目录的conf目录下

  3. 测试spark是否安装成功

    在终端输入：spark-shell --version

  4. 成功效果
    在这里插入图片描述

2.2.2 Spark-on-Yarn环境搭建
  1. 事先准备：Hadoop集群上的三个配置文件
  • core-site.xml
  • yarn-site.xml
  • hdfs-site.xml

将三个文件存储到一个空目录中。

例如：/opt/spark/spark-yarn/目录下。

  1. 在$SPARK_HOME/conf/spark-env.sh环境配置文件中添加如下配置

​ export HADOOP_CONF_DIR =/opt/spark/spark-yarn/

​ export SPARK_LOCAL_IP=机器IP地址或者是主机名

  1. 优化配置

在spark-defaults.conf配置文件里添加如下配置：

​ spark.yarn.jars hdfs://HDFS集群的主节点IP:9000/spark_lib/jars/*
​ 或者
​ spark.yarn.archive hdfs://HDFS集群的主节点IP:9000/spark_lib/jars

注意，此配置需先将Spark的家目录的jars文件夹上传到hdfs上。

上传操作具体如下：

hdfs dfs -mkdir /spark_lib
hdfs dfs -put /opt/spark/jars /spark_lib/

2.2.3 Spark-Standalone环境搭建

  1. 修改Spark配置文件 (路径为$SPARK_HOME/conf/下)
    复制slaves.template和 spark-env.sh.template各一份

    cp spark-env.sh.template spark-env.sh

    cp slaves.template slaves

  2. vi slaves，此文件是指定子节点的主机,直接添加从节点主机名即可(前提是在/etc/hosts里面配置了).例如：

    briup0

    briup1

    briup2

  3. 在spark-env.sh末端添加如下几行：

必须配置

#主节点的IP地址
export SPARK_MASTER_IP=192.168.1.200

可选配置

#主节点的端口号
export SPARK_MASTER_PORT=7077
#指定Spark用来混洗数据的本地存储路径
export SPARK_LOCAL_DIRS=/data/spark/dirs,/home/briup/spark/dirs
#（一定要注意这个混洗数据的路径的权限）		
#Worker的WebUI端口号
export SPARK_WORKER_WEBUI_PORT=8081 
#主节点的WEBUI端口号
export SPARK_MASTER_WEBUI_PORT=8099
#每个Worker使用的CPU核数,默认1个
export SPARK_WORKER_CORES=2 
#每个Slave中启动几个Worker实例,默认1个
export SPARK_WORKER_INSTANCES=2
#每个Worker使用多大的内存,默认1g
export SPARK_WORKER_MEMORY=2g 
#驱动器节点Driver使用的内存
export SPARK_DRIVER_MEMORY=2g

  1. 启动start-all.sh命令或者是

    ​ start-master.sh/start-slave.sh spark://host:7077

  2. 测试是否成功，在集群的所有机器上输入

    ​ jps

  3. 打开浏览器输入http://localhost:8080查看集群资源页面

    测试spark-submit命令
    $Spark_home/spark-submit --master spark://localhost:7077 --class org.apache.spark.examples.SparkPi examples/jars/spark-examples_2.11-2.2.1.jar 10

2.2.4 Spark-on-Hive环境搭建
  1. 将hive-site.xml添加到$SPARK_HOME/conf/目录下

hive-site.xml文件内容如下：

<configuration>
  <property>
    <name>javax.jdo.option.ConnectionDriverName</name>
    <value>com.mysql.jdbc.Driver</value>
  </property>
  <property>
    <name>javax.jdo.option.ConnectionURL</name>
    <value>jdbc:mysql://127.0.0.1:3306/hive_spark?createDatabaseIfNotExist=true</value>
  </property>
  <property>
    <name>javax.jdo.option.ConnectionUserName</name>
    <value>spark</value>
  </property>
  <property>
    <name>javax.jdo.option.ConnectionPassword</name>
    <value>spark</value>
  </property>
  <property>
    <name>hive.metastore.schema.verification</name>
    <value>false</value>
  </property>
  <property>
    <name>hive.server2.thrift.port</name>
    <value>10000</value>
  </property>
  <property>
    <name>hive.server2.thrift.bind.host</name>
    <value>0.0.0.0</value>
  </property>
  <property>
    <name>hive.metastore.warehouse.dir</name>
    <value>/user/hive/warehouse</value>
  </property>
</configuration>
  1. 修改spark-defaults.conf文件
#集群运行模式下，需要将Hive的元数据的连接jar包配置到执行器节点
spark.executor.extraClassPath     $HIVE_HOME/lib/mysql-connector-java-5.1.22.jar
#设置warehouse
spark.sql.warehouse.dir hdfs://computer1.cloud.briup.com:9000/user/hive/warehouse/

  1. 添加Mysql连接jar包

    将mysql的依赖mysql-connector-java-5.1.22.jar添加到spark的安装目录，并上传到HDFS的/spark_lib/jars目录下

  2. 命令行测试

    spark-sql --driver-class-path $HIVE_HOME/lib/mysql-connector-java-5.1.22.jar

  3. 编码测试

//构建支持Spark-On-Hive的SparkSession对象
object FirstSpark{
  def main(args:Array[String])={
    val spark=SparkSession.builder()
      .appName("应用名称")
      .master("运行模式")
      .config("spark.sql.warehouse.dir","Hive数据仓库地址")
    	//需要先在hive服务器中启动该命令hive --service metastore 
      .config("hive.metastore.uris","thrift://Hive所在服务器的IP地址:9083")
      .enableHiveSupport()
      .getOrCreate();
     import spark.implicits._
  }
}

注意 ，如果在代码中没有指定支持Hive的配置，需要在resources目录下添加hive-site.xml配置文件

配置文件内容如下：

<configuration>
  <!--第一种方式:指定hive的地址，用户名，密码等信息 -->
  <property>
    <name>javax.jdo.option.ConnectionDriverName</name>
    <value>com.mysql.jdbc.Driver</value>
  </property>
  <property>
    <name>javax.jdo.option.ConnectionURL</name>
    <value>jdbc:mysql://127.0.0.1:3306/hive_spark?createDatabaseIfNotExist=true</value>
  </property>
  <property>
    <name>javax.jdo.option.ConnectionUserName</name>
    <value>spark</value>
  </property>
  <property>
    <name>javax.jdo.option.ConnectionPassword</name>
    <value>spark</value>
  </property>
  <!--第二种方式:借助于thriftserver协议 -->
  <!--先在hive服务器中启动该命令hive 两个-service metastore &-->
  <property>
    <name>hive.metastore.uris</name>
    <value>thrift://172.16.0.4:9083</value>
  </property>
</configuration>

3.Spark架构

3.1 通用运行架构

在这里插入图片描述

说明 ：

  • ClusterManager

    集群管理者，负责集群整体资源管理和调度

    在Spark Standalone模式中为Master，控制整个集群，监控Worker。

    在Spark on Yarn模式中为资源管理器RecourceManager。

  • Worker

    从节点，负责控制计算的节点
    ​启动Executor或Driver。在Spark on Yarn模式中为NodeManager。

  • Driver

    驱动器，运行Application的main()函数并且创建SparkContext的进程。

    当全部的Executor运行完毕后，Driver负责将SparkContext关闭。

  • SparkContext

    是整个 Spark 应用程序的上下文，控制应用的生命周期，通常用SparkContext代表Driver。

    • 负责与ClusterManager通信
    • 负责资源的申请
    • 负责任务的分配
    • 负责任务的监控
    • 负责创建RDD、累加器、广播变量

    注意，每个JVM里只能存在一个处于激活状态的SparkContext。

  • Executor

    执行器，Application运行在worker节点上的一个进程。

    • 负责将Task包装成线程池(TaskRunner)
    • 负责启动线程池
    • 负责从线程池中抽取出一个空闲线程运行任务(Task)
    • 负责将数据存在内存或磁盘上

    注意，每个执行器能(Executor)并行运行 Task 的数量就取决于分配给它的 CPU 个数。

3.2 Spark On Yarn运行架构

在这里插入图片描述

在这里插入图片描述

在YARN中，每个Application实例都有一个ApplicationMaster进程，它是Application启动的第一个容器。

  • 它负责和ResourceManager打交道并请求资源
  • 获取资源之后告诉NodeManager为其启动Container

从深层次的含义讲YARN-Cluster和YARN-Client模式的区别其实就是ApplicationMaster进程的区别。

  • YARN-Cluster模式下

    • Driver运行在AM(Application Master)中，负责向YARN申请资源，并监督作业的运行状况
    • 当用户提交了作业之后，就可以关掉Client，作业会继续在YARN上运行
    • 因而YARN-Cluster模式不适合运行交互类型的作业

  • YARN-Client模式下

    • Application Master仅仅向YARN请求Executor
    • Client会和请求的Container通信来调度他们工作
    • 也就是说Client不能离开

3.3 Spark Standalone运行架构

在这里插入图片描述

4.Spark命令

4.1 spark-shell

Spark提供的终端命令，允许在终端中使用Scala、Java编程语言编写Spark程序。适用于学习测试环境。

语法:

​ Usage: ./bin/spark-shell [options]

帮助命令:

​ spark-shell —help

4.2 spark-sql

Spark提供的终端命令，允许在终端使用Sql语言操作数据。适用于学习测试环境。

语法:

​ Usage: ./bin/spark-sql [options] [cli option]

帮助命令:

​ spark-sql —help

4.3 spark-submit

Spark提供的作业提交命令，允许将打包好的程序提交到集群中运行。适用于生产环境。

语法：

​ Usage: spark-submit [options] <app jar | python file | R file> [app arguments]

​ Usage: spark-submit --kill [submission ID] --master [spark://...]

​ Usage: spark-submit --status [submission ID] --master [spark://...]

​ Usage: spark-submit run-example [options] example-class [example args]

帮助命令:

​ spark-submit —help

含义解释:

  • app jar 表示应用入口的jar包，必须传递
  • app arguments 表示传递给主方法的参数，可以省略
  • options 表示可选配置，可以省略
  • submission ID 表示提交作业的ID，可以省略
  • run-example 表示运行官方自带案例
  • example-class 表示官方自带案例所在类的全类名

可选配置(options):

  • --master 运行模式，默认为local[*]
  • --class 主方法所在类名
  • --name 应用名称
  • --deploy-mode Yarn的客户端还是集群模式，默认为client,可以修改为cluster
  • --executor-memory 执行器内存大小，默认为1g
  • --driver-memory 驱动器内存大小,默认为1g
  • --num-executors 执行器的个数，默认为2
  • --executor-cores 每个执行器的CPU个数，默认为1
  • --driver-cores 驱动器的CPU个数，默认为1，只支持cluster模式下修改
  • --jars 额外依赖的第三方jar包
  • --files 需要分发到各节点的数据文件
  • --total-executor-cores 执行器的CPU个数，默认为集群中全部可用CPU个数，只支持Standalone,Mesos，K8s运行模式下生效

5.编程流程

在这里插入图片描述

6.Spark案例

6.1 构建Spark-maven项目

  1. 直接构建一个Maven-Project项目

  2. 将以下内容添加到pom.xml文件标签内之后，在src目录下依次构建main/scala目录，更新maven项目


<properties>
  <scala.version>2.12.8</scala.version>
  <spark.scala.version>2.12</spark.scala.version>
  <spark.version>3.0.1</spark.version>
</properties>

<dependencies>
  <dependency>
    <groupId>org.scala-lang</groupId>
    <artifactId>scala-library</artifactId>
    <version>${scala.version}</version>
  </dependency>
  <!--引入Spark-core核心依赖-->
  <dependency>
    <groupId>org.apache.spark</groupId>
    <artifactId>spark-core_${spark.scala.version}</artifactId>
    <version>${spark.version}</version>
  </dependency>
</dependencies>

<build>
  <plugins>
    <plugin>
      <groupId>org.scala-tools</groupId>
      <artifactId>maven-scala-plugin</artifactId>
      <version>2.15.0</version>
      <executions>
        <execution>
          <goals>
            <goal>compile</goal>
            <goal>testCompile</goal>
          </goals>
        </execution>
      </executions>
    </plugin>
    <plugin>
      <groupId>org.apache.maven.plugins</groupId>
      <artifactId>maven-surefire-plugin</artifactId>
      <version>2.6</version>
      <configuration>
        <useFile>false</useFile>
        <disableXmlReport>true</disableXmlReport>
        <includes>
          <include>**/*Test.*</include>
          <include>**/*Suite.*</include>
        </includes>
      </configuration>
    </plugin>
  </plugins>
</build>

6.2 WordCount案例

  1. 新建一个package

base

  1. 在该包下创建一个scala object

WordCount

  1. 在该对象的中构建main方法
package com.briup.base

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

object WordCount {
  def main(args: Array[String]): Unit = {
    if(args.length<2){
      println("请输入需要进行词频统计的文件路径以及结果存储路径！！")
      System.exit(0)
    }
    //目的：获取Spark上下文对象
    //1.获取SparkConf对象
    val conf=new SparkConf();
    conf.setMaster("local[*]")
    conf.setAppName("词频统计案例")
    //2.获取SparkContext对象
    val sc=new SparkContext(conf);
    sc.setLogLevel("warn")
    println(sc)
    //3.借助于sc的方法获取RDD对象
    val fileRDD: RDD[String] = sc.textFile(args(0))
    //4.根据业务逻辑调用RDD中一系列方法(转化方法和行动方法)
    //统计words.txt中每个单词出现的频次
    //将字符串分割成一个个单词
    val mapRDD: RDD[String] = fileRDD.flatMap( (x:String)=> x.split(" ") )
    //转化，将每个单词转化为二元元组
    val wordAndNumRDD=mapRDD.map( (word:String) => (word,1) )
    //按照key相同，value进行相加
    val wordCountRDD=wordAndNumRDD.reduceByKey(_+_)
    //将词频统计结果输出到控制台
    wordCountRDD.foreach(println)
    //将计算结果存储到文本文件中
    wordCountRDD.saveAsTextFile(args(1))
    //5.关闭SparkContext对象
    sc.stop()
  }
}

7.作业流程

在这里插入图片描述

说明 ：

  • Application

    应用，用户编写的 Spark 应用程序

    • 包含了运行在Driver上的代码
    • 包含了运行在 Executor上的代码
    • 将应用提交后集群之后，集群管理者为该Application分配资源并将程序转换并执行

  • RDD
    弹性分布式数据集(Resillient Distributed Dataset)，Spark 的基本计算单元

  • DAG
    有向无环图( DirectedSched Acycle graph)，反应 RDD 之间的依赖关系

  • Job

    作业，由RDD Action算子触发，在SparkContext通过runJob方法向Spark提交Job

    • 一个Application中可以包含多个Job
    • 一个Job转化为一个DAG

  • DAG
    有向无环图(DirectedSched Acycle graph)，反应 RDD 之间的依赖关系

    • 一个DAG交给一个DAG Scheduler

  • DAG Scheduler

    有向无环图调度器，负责将DAG根据宽依赖关系划分为Stage，并提交 Stage给 TaskScheduler

    • 一个DAG默认为一个Stage
    • 一个宽依赖关系Stage加一
    • 一个Stage交给一个TaskScheduler

  • Stage

    阶段

    • 一个Stage包含一组相同的Task，这一组Task也叫做TaskSet
    • 一个Stage包含的Task个数取决于分区个数
    • 一个分区对应一个Task

  • Task Scheduler
    任务调度器，将Task分发给Executor执行

  • Task

    任务，执行RDD中对应Stage中所包含的算子

  • SparkEnv
    线程级别的上下文，存储运行时的重要组件的引用，可以进行shuffle管理或广播变量等的管理

文字描述：

  1. 用户在Client端通过spark-submit命令将Application提交到ClusterManager；
  2. ClusterManager接收到App之后，会找一个Worker启动Driver；
  3. Driver程序创建SparkContext，将其作为调度的总入口；
  4. SparkContext在初始化过程中分别创建DAGScheduler（进行Stage调度）和TaskScheduler（进行Task调度）两个模块。同时SparkContext会将App拆分成多个RDD DAG；
  5. 每一个DAG会提交给一个DAGScheduler,DAGScheduler会根据它们的依赖关系拆分成不同的Stage(TaskSets)，每一个Stage提交给一个TaskScheduler；
  6. TaskScheduler会将这些Task任务不断的分发到Worker节点的中的Executor中执行；
  7. Executor会启动多线程，将每一个任务交给一个线程执行；
  8. SparkEnv会启动一些控制组件，进行shuffle管理或广播变量等的管理；
  9. Driver管理Task状态，Task完成，Stage完成，作业完成。
angeliacmm
关注
专栏目录
Spark SQL 初识
2401_84052244的博客
07-31 299
Spark SQL 是Spark 的最最核心的组件，也是Spark中代码量最大，社区花费大量精力的模块。Spark SQL可以很方便高效的完成数据清洗数据分析的业务逻辑，主要是性能高和使用方便。Spark SQL提供了三种编程模式，以及SQL 命令行可以配合Hive 一起使用，这也是使用最广泛的场景。
一文带你了解 Spark 架构设计与原理思想
大数据梦想家
11-08 5011
Spark 架构设计与原理思想，性能调优与故障处理 ...
Spark学习之路 （一）Spark初识
weixin_33737134的博客
04-19 291
一、官网介绍 1、什么是Spark 官网地址：http://spark.apache.org/ Apache Spark™是用于大规模数据处理的统一分析引擎。 从右侧最后一条新闻看，Spark也用于AI人工智能 spark是一个实现快速通用的集群计算平台。它是由加州大学伯克利分校AMP实验室 开发的通用内存并行计算框架，用来构建大型的、低延迟的数据分析应用程序。它扩展了广泛使用的...
实验3-Spark基础-Spark的安装
最新发布
想要AC的sjh的博客空间
07-06 1058
PYTHONPATH环境变量主要是为了在Python3中引入Pyspark库，对于不同版本的Spark , 其py4j-0.10.7-src.zip文件名是不同的，要进入相应目录 $SPARK_HOME/python/lib/ 下具体查看确定具体名称，再对PYTHONPATH环境变量的相应值加以修改。配置完成的文件如图所示。此指导书中使用的 Spark 版本为 spark-2.3.3-bin-hadoop2.7.tgz ，实验环境中存放在 /hadoop-packages/ 目录下。本实验平台不需要下载。
spark 初识
Antg的博客
11-19 1412
一.概述 大数据领域分类 离线处理 实时处理 大数据开发瓶颈 IO 绝大多数的瓶颈都卡在这里 计算 一般涉及到深度学习,人工智能等领域会遇到计算瓶颈,一般放在GPU上去跑 spark mapreduce遇到的瓶颈 操作类型有限,仅支持map和reduce两种操作 编程复杂较高,学习成本高 处理效率低 map中间结果xie磁盘,reduce结果xiehdfs,多个mr之间通过hdfs交换数据 任务调度和启动开销比较大 在机器学习,图计算方面支持有限,性能较差 定义:一个
Spark学习（1）——初识spark
wangzq2213的博客
07-14 1326
Spark是什么？   Spark是一种通用的大数据计算框架，就像传统的大数据技术Hadoop的MapReduce，Hive以及Storm流式实时计算引擎等。   Spark包含了大数据领域常见的各种计算框架；比如Spark Core勇于离线计算，Spark SQL用于交互式查询，Spark Streaming用于实时流式计算，Spark MLlib 用于机器学习，Spark GraphX用于...
大数据基础：Spark工作原理及基础概念
QcloudCommunity的博客
11-13 8964
导语 |Apache Spark 是专为大规模数据处理而设计的快速通用计算引擎，在数据挖掘和机器学习领域有着广泛的应用，现在也已形成一个高速发展、应用广泛的生态系统。本文将为大家详细介...
Spark学习笔记（一）Spark初识【特性、组成、应用】
08-25
本篇文章将对Spark的基本特性、组成和应用场景进行深入探讨。 首先，Spark 的四大特性是其广受欢迎的关键因素： 1. 高效性：Spark 采用DAG（有向无环图）调度程序，配合优化的查询执行引擎，可以实现批量和流数据...
[spark]-结构化数据查询之初识篇
03-16
在初识篇中，我们可以学习如何使用Spark SQL来进行结构化数据查询，包括如何创建表格、执行SQL查询、过滤数据、聚合数据等。这些基础知识可以帮助我们更好地理解和使用Spark中的结构化数据查询功能。
10小时入门大数据：第2章-初识Hadoop
muyingmiao的专栏
08-26 226
Hadoop概述 · hadoop名字，玩具命名 · hadoop.apache.org · 包含的模块框架 · common公用 · hdfs分布式文件系统 · yarn作业的调度和集群资源的管理 · MapReduce基于yarn的并行的处理数据的框架 · 介绍 ·...
spark入门教程
10-24
spark入门学习教程，包含spark各个模块的介绍及使用方式，总共16讲内容，入门教程
初识 Spark
yuzx2008的博客
12-10 704
初识 Spark因为本人已经有搭建好的 hadoop 和 hbase 集群，所以，选择 spark 版本为 without-hadoop 1.5.2。安装tar -xf /home/yuzx/data/download/spark-1.5.2-bin-without-hadoop.tgz -C /home/yuzx/server ln -sf -T /home/yuzx/server/spark-1
Spark 基础教程
qq_43057549的博客
10-27 1634
Spark是基于内存计算的大数据并行计算框架，可用于构建大型的、低延迟的数据分析应用程序。 Spark特点 运行速度快：Spark使用先进的DAG(Directed Acyclic Graph，有向无环图)执行引擎，以支持循环数据流与内存计算，基于内存的执行速度可比Hadoop MapReduce快上百倍，基于磁盘的执行速度也能快10倍。 容易使用：Spark支持使用Scala、Java、Python和R语言进行编程，简洁的API设计有助于用户轻松构建并行程序，并且可以通过Spark Shell进行交互式
Spark基础教程
SDKLHKJAS的博客
05-21 240
Spark最初由美国加州伯克利大学的AMP实验室于2009年开发，是基于内存计算的大数据并行计算框架，可用于构建大型的、低延迟的数据分析应用程序。 Spark特点 Spark具有如下几个主要特点： 运行速度快：Spark使用先进的DAG（Directed Acyclic Graph，有向无环图）执行引擎，以支持循环数据流与内存计算，基于内存的执行速度可比Hadoop MapReduce快上百倍，基于磁盘的执行速度也能快十倍； 容易使用：Spark支持使用Scala、Java、Python和R语言进行编程
Spark入门教程
m0_75198698的博客
05-10 1871
Spark中最基本的抽象数据类型是弹性分布式数据集（Resilient Distributed Datasets，简称RDD），它是Spark中的数据处理基本单位，类似于其他分布式计算框架中的数据集。当然，还有很多关于Spark的知识需要深入学习，例如使用Spark Streaming进行实时处理、使用Spark GraphX进行图形处理、使用Spark MLlib进行机器学习等等。Spark是一种基于内存计算的大数据处理框架，它提供了高效的分布式数据处理能力，使得处理大规模数据变得更加容易。
Spark 基础教程 一文看懂 spark 常用操作汇总
fanghailiang2016的博客
04-02 1561
Spark 基础教程 一文看懂 spark 常用操作汇总
Spark的认识与理解
草莓猿
07-19 1349
...
Spark性能优化基础篇：开发与资源调优
"Spark性能优化指南——基础篇"深入探讨了在大数据计算领域广泛应用的Spark平台，其强大的功能使其在离线批处理、SQL查询、实时流处理、机器学习和图计算等方面表现出色。在美团和大众点评等企业，Spark因其快速执行...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值