我们知道Apache Spark现在是一项蓬勃发展的技术。因此，了解Apache Spark的各个方面以及Spark面试问题非常重要。我将介绍Spark的每个方面，这也可能是经常被问到的Spark面试问题。此外，我将尽力提供每个问题，从现在开始，您搜索最佳和所有Spark面试问题将在此结束。

Apache Spark面试问题答案

一,什么是Apache Spark？

Apache Spark是一个功能强大的开源灵活数据处理框架，围绕速度，易用性和复杂的分析而构建.Apache Spark在集群计算系统中正在快速发展。Spark可以在Hadoop上运行，独立运行或在云中运行，并且能够访问来自各种来源的数据，包括HDFS，HBase，Cassandra或其他。

由于Spark中的集群内计算，它不需要在磁盘内外进行混洗。这样可以更快地处理spark中的数据。

与其他大数据和MapReduce技术（如Hadoop和Storm）相比，Spark具有多项优势。其中很少是：

1.Speed

它可以在内存中运行程序比Hadoop-MapReduce快100倍，在磁盘上运行速度快10倍。

2.易用性

Spark具有易于使用的API，可用于大型数据集。这包括100多个用于

转换数据的运算符和用于处理半结构化数据的熟悉数据帧API 的集合。

我们可以用Java，Scala，Python，R编写应用程序。

3. Unified Engine

Spark附带更高级别的库，包括对SQL查询，流数据，机器学习和图形处理的支持。

4.Runs Everywhere

Spark可以在Hadoop，Mesos，独立或云端运行。

Spark生态系统

以下是Spark生态系统及其组件的简要概述。

它包括：

Spark Streaming： Spark Streaming用于处理实时流数据。

Spark SQL： Spark SQL组件是一个位于Spark集群之上的库，通过使用我们可以在Spark数据上运行SQL查询。

Spark MLlib： MLlib是Spark的可扩展机器学习库。

Spark GraphX： GraphX用于图形和图形并行计算。

二.为何选择Apache Spark？

基本上，我们有很多通用的集群计算工具。例如Hadoop MapReduce，Apache Storm，Apache Impala，Apache Storm，Apache Giraph等等。但每个人的功能也有一些限制。如：

1. Hadoop MapReduce只允许批量处理。

2.如果我们谈论流处理，只有Apache Storm / S4可以执行。

3.再次进行交互式处理，我们需要Apache Impala / Apache Tez。

4.虽然我们需要执行图形处理，但我们选择Neo4j / Apache Giraph。

因此，没有一个引擎可以一起执行所有任务。因此，对强大的引擎有很大的需求，可以实时（流）和批处理模式处理数据。

此外，它可以响应亚秒级并执行内存处理

通过这种方式，Apache Spark出现了。它是一个功能强大的开源引擎，提供交互式处理，实时流处理，图形处理，内存处理以及批处理。即使速度非常快，易于使用，同时也是标准接口。

三. Apache Spark Ecosystem的组件是什么？

Apache spark由以下组件组成：

1.Spark Core

2.Spark SQL

3.Spark Streaming

4.MLlib

5.GraphX

spark streaming：spark streaming包含的基本功能spark，包括任务调度，内存管理，故障恢复成分，与存储系统交互，等等。Spark Core也是API的所在地，它定义了弹性分布式数据集（RDD），这是Spark的主要编程抽象。它还提供了许多用于构建和操作这些RDDS的API。

Spark SQL：Spark SQL提供了一个处理结构化数据的接口。它允许在SQL中查询以及SQL（HQL）的Apache Hive变体。它支持许多源。

Spark Streaming：Spark组件，可以处理实时数据流。

MLlib：Spark附带了一个名为MLlib的通用机器学习包

GraphX：GraphX是一个用于操纵图形（例如，社交网络的朋友图）和执行图形并行计算的库。

四，.什么是Spark Core？

Spark Core是整个Spark项目的基本单元。它提供了各种功能，如任务调度，调度和输入输出操作等.Spark使用称为RDD（弹性分布式数据集）的特殊数据结构。它是API的主页，用于定义和操作RDD。Spark Core是分布式执行引擎，其顶部附加了所有功能。例如，MLlib，SparkSQL，GraphX，Spark Streaming。因此，允许单一平台上的各种工作负载。Apache Spark的所有基本功能类似于内存计算，容错，内存管理，监控，任务调度由Spark Core提供。

除此之外，Spark还提供与数据源的基本连接。例如，HBase，Amazon S3，HDFS等。

五，Apache Spark支持哪些语言？

Apache Spark是用Scala语言编写的。Spark在Scala，Python和Java中提供了一个API，以便与Spark进行交互。它还提供R语言的API。

六，Apache Spark如何比Hadoop更好？

Apache Spark正在提升快速集群计算工具。由于其非常快速的内存数据分析处理能力，它比 Hadoop MapReduce快100倍。

Apache Spark是一个大数据框架。Apache Spark是一种通用数据处理引擎，通常用于HDFS之上。Apache Spark适用于从批处理到数据流的各种数据处理要求。

Hadoop是一个开源框架，用于处理存储在 HDFS中的数据。Hadoop可以处理结构化，非结构化或半结构化数据。Hadoop MapReduce只能以批处理模式处理数据。

在许多情况下，Apache Spark超过Hadoop，例如

1.处理内存中的数据，这在Hadoop中是不可能的

.2。处理批量，迭代，交互和流式传输的数据，即实时模式。而Hadoop仅以批处理模式处理。

3. Spark更快，因为它可以减少磁盘读写操作的数量，因为它可以将中间数据存储在内存中。而在Hadoop MapReduce中间输出是Map（）的输出总是写在本地硬盘

4上.Apache Spark很容易编程，因为它有数百个带RDD的高级操作符（弹性分布式数据集）

5.与Hadoop MapReduce相比，Apache Spark代码更紧凑。使用Scala使其非常简短，减少了编程工作。另外，星火提供了丰富的各种语言，比如Java，API的斯卡拉，Python和[R 。

6. Spark和Hadoop都具有高度的容错能力。

7.在Hadoop集群中运行的Spark应用程序在磁盘上的速度比Hadoop MapReduce快10倍。

七，在Apache Hadoop上运行Spark有哪些不同的方法？

而不是MapReduce，我们可以在Hadoop生态系统上使用spark -spark with HDFS 你可以在HDFS中读取和写入数据 -spark with Hive 你可以读取和分析并写回到hive

八，Apache Spark中的SparkContext是什么？

SparkContext是Spark执行环境的客户端，它充当Spark应用程序的主服务器。SparkContext设置内部服务并建立与Spark执行环境的连接。您可以在创建SparkContext之后创建RDD，累加器和广播变量，访问Spark服务并运行作业（直到SparkContext停止）。每个JVM只能激活一个SparkContext。您必须在创建新的SparkContext之前停止（）活动的SparkContext。

在Spark shell中，已经为名为sc的变量中的用户创建了一个特殊的解释器感知SparkContext。

任何Spark驱动程序应用程序的第一步是创建SparkContext。SparkContext允许Spark驱动程序应用程序通过资源管理器访问集群。资源管理器可以是YARN，也可以是Spark的Cluster Manager。

SparkContext提供的功能很少：

1。我们可以获取Spark应用程序的当前状态，例如配置，应用程序名称。

2.我们可以设置配置，如主URL，默认日志级别。

3.可以创建像RDD这样的分布式实体。

九， Apache Spark中的SparkSession是什么？

从Apache Spark 2.0开始，Spark Session是Spark应用程序的新入口点。

在2.0之前，SparkContext是spark工作的切入点。RDD是当时的主要API之一，它是使用Spark Context创建和操作的。对于每个其他API，都需要不同的上下文 - 对于SQL，需要SQL上下文; 对于Streaming，需要Streaming Context; 对于Hive，需要Hive Context。

但是从2.0开始，RDD以及DataSet及其子集DataFrame API正在成为标准API，并且是Spark中数据抽象的基本单元。所有用户定义的代码都将根据DataSet和DataFrame API以及RDD进行编写和评估。

因此，需要一个新的入口点构建来处理这些新的API，这就是引入Spark Session的原因。Spark Session还包括不同上下文中可用的所有API - Spark Context，SQL Context，Streaming Context，Hive Context。

十，Apache Spark中的SparkSession vs SparkContext。

在 Spark 2.0.0之前，sparkContext被用作访问所有spark功能的通道。

spark驱动程序使用spark context通过资源管理器（ YARN或 Mesos ..）连接到集群。

sparkConf是创建spark上下文对象所必需的，它存储配置参数，如appName（用于标识您的spark驱动程序），应用程序，核心数量以及在工作节点上运行的执行程序的内存大小。

为了使用SQL，HIVE和Streaming的 API， 需要创建单独的上下文。

示例：

创建sparkConf：

val conf = new SparkConf().setAppName(“RetailDataAnalysis”).setMaster(“spark://master:7077”).set(“spark.executor.memory”, “2g”)

creation of sparkContext:

val sc = new SparkContext(conf)

Spark会议：

从SPARK 2.0.0开始，SparkSession提供了与基础Spark功能交互的单一入口点，并

允许使用DataFrame和Dataset API 编写Spark 。sparkContext中提供的所有功能也可在sparkSession中使用。

为了使用SQL，HIVE和Streaming的API，不需要创建单独的上下文，因为sparkSession包含所有API。

一旦SparkSession被实例化，我们就可以配置Spark的运行时配置属性。

例：

创建Spark会话：

val spark = SparkSession

.builder

.appName（“

WorldBankIndex ”）。getOrCreate（）

配置属性：

spark.conf.set（“spark.sql.shuffle.partitions”，6）

spark.conf.set（“spark.executor.memory”，“2g”）

从Spark 2.0.0开始，最好使用sparkSession，因为它提供了对sparkContext所具有的所有spark功能的访问。此外，它还提供了API来处理DataFrame和数据集。

十一，Apache Spark的抽象是什么？

Apache Spark有几个抽象：

1. RDD：

RDD指的是弹性分布式数据集。RDD是记录的只读分区集合。它是Spark的核心抽象，也是Spark的基本数据结构。它提供在大型集群上进行内存计算。即使是以容错的方式。有关RDD.follow链接的更详细见解：Spark RDD - RDD的简介，功能和操作

2. DataFrames：

它是一个组织成命名列的数据集。DataFrames等同于R / Python 中的关系数据库或数据框架中的表。换句话说，我们可以说它是一个具有良好优化技术的关系表。它是一个不可变的分布式数据集合。允许更高级别的抽象，它允许开发人员将结构强加到分布式数据集合上。有关DataFrame的更详细的见解。参考链接：Spark SQL DataFrame教程 - DataFrame简介

3. Spark Streaming：

它是Spark的核心扩展，允许从多个来源进行实时流处理。例如Flume和Kafka。为了提供可用于交互式和批量查询的统一，连续的DataFrame抽象，这两个源一起工作。它提供可扩展，高吞吐量和容错处理。有关Spark Streaming的更详细的见解。参考链接：初学者的Spark Streaming教程

4. GraphX

这是专门数据抽象的又一个例子。它使开发人员能够分析社交网络。此外，其他图表与Excel类似的二维数据一起。

十二，如何在Apache Spark中创建RDD？

弹性分布式数据集（RDD）是spark的核心抽象，是一个弹性分布式数据集。

它是一个不可变（只读）的分布式对象集合。RDD中的

每个数据集被划分为逻辑分区，

其可以在集群的不同节点上计算。

包括用户定义的类，RDD可以包含任何类型的Python，Java或Scala对象。

我们可以通过3种方式在Apache Spark中创建RDD ：

1。通过分发对象集合

2.通过加载外部数据集

3.从现有的Apache Spark RDDs

1. 使用并行化集合

RDD通常通过并行化现有集合来创建，

即通过在程序中获取现有集合并将

其传递给SparkContext的 parallelize（）方法。

scala> val data = Array（1,2,3,4,5）

scala> val dataRDD = sc.parallelize（data）

scala> dataRDD.count

2. 外部数据集

在Spark中，可以从Hadoop支持的任何数据源构建分布式数据集。

val dataRDD = spark.read.textFile（“F：/BigData/DataFlair/Spark/Posts.xml”）。rdd

3. 从现有RDD创建RDD

转换是从现有RDD创建RDD的方法。

转换作为一种功能，可以吸收RDD并产生另一个结果RDD。

输入RDD不会改变，RDD上应用的

一些操作是：filter，Map，FlatMap

val dataRDD = spark.read.textFile（“F：/Mritunjay/BigData/DataFlair/Spark/Posts.xml”）。rdd

val resultRDD = data.filter {line => {line.trim（）。startsWith（“<row”）} }

十三，为什么Spark RDD不可变？

以下是原因：

- 不可变数据始终可以安全地共享多个进程以及多个线程。

- 由于RDD是不可变的，我们可以随时重新创建RDD。（来自谱系图）。

- 如果计算耗时，我们可以缓存RDD，从而提高性能。

如果我遗漏了某些东西，请添加更多分数

RDD也是容错的，并且可以懒惰地评估以获取更多信息。

十四，在Apache Spark中解释配对RDD这个术语

简介

配对RDD是具有键值对的分布式数据集合。它是Resilient Distributed Dataset的子集。因此它具有RDD的所有功能和键值对的一些新功能。配对RDD 有许多转换操作可用。配对RDD上的这些操作对于解决许多需要排序，分组，减少某些值/功能的用例非常有用。

配对RDD上常用的操作有：groupByKey（）reduceByKey（）countByKey（）join（）等

创建配对RDD：

val pRDD：[（String），（Int）] = sc.textFile（“path_of_your_file”）。

flatMap（ line => line.split（“”））。map

{word =>（word，word.length）}

同样使用subString方法（如果我们有一个带有id和某个值的文件，我们可以创建配对的rdd，id为key，value为其他细节）

val pRDD2 [（Int），（String）] = sc.textFile（“path_of_your_file”）。

keyBy（line => line.subString（1,5）.trim（）。toInt）

。mapValues（line => line.subString （10,30）.trim（））

十五，Spark中的RDD与Distributed Storage Management有何不同？

RDD和分布式存储之间的一些区别如下：

弹性分布式数据集（RDD）是Apache Spark框架的主要数据抽象。

分布式存储只是一个可在多个节点上运行的文件系统。

RDD将数据存储在内存中（除非显式缓存）。

Distributed Storage将数据存储在持久存储中。

在发生故障或数据丢失的情况下，RDD可以重新计算自身。

如果数据从分布式存储系统中丢失，它将永远消失（除非有内部复制系统）

十六，在Apache Spark中解释RDD中的转换和操作

转换是对RDD的操作，用于创建一个或多个新RDD。例如map，filter，reduceByKey等。换句话说，转换是将RDD作为输入并产生一个或多个RDD作为输出的函数。输入RDD没有变化，但它总是通过应用它们所代表的计算产生一个或多个新的RDD。变换是惰性的，即不立即执行。只有在调用动作后才会执行转换。

操作是生成非RDD值的RDD操作。换句话说，返回任何类型但RDD的值的RDD操作是一个动作。它们触发执行RDD转换以返回值。简单地说，一个动作评估RDD沿袭图。例如收集，减少，计数，foreach等。

十七，Apache Spark转换的类型有哪些？

为了更好地理解转换的类型，让我们从Apache Spark中的转换简介开始 。

Spark

Spark Transformation中的转换是一种从现有RDD生成新RDD的函数。它将RDD作为输入并生成一个或多个RDD作为输出。每当我们应用任何转换时它都会创建新的RDD。由于RDD本质上是不可变的，因此无法更改输入RDD。

RDD谱系，通过应用使用最终RDD的整个父RDD构建的转换构建。换句话说，它也被称为RDD运算符图或RDD依赖图。它是一个逻辑执行计划，即它是RDD的整个父RDD的有向无环图（DAG）。

转换本质上是懒惰的，即当我们调用一个动作时它们会被执行。它们不会立即执行。两种最基本的转换类型是map（），filter（）。

结果RDD始终与其父RDD不同。它可以更小（例如过滤，计数，不同，样本），更大（例如flatMap（），union（），Cartesian（））或相同大小（例如map）。

现在，让我们关注这个问题，基本上有两种类型的转换：

1.窄变换 -

在讨论窄变换时，在单个分区中计算记录所需的所有元素都位于父RDD的单个分区中。为了计算结果，使用有限的分区子集。此转换是map（），filter（）的结果。

2.广泛转换 -

广泛转换意味着计算单个分区中记录所需的所有元素可能存在于父RDD的许多分区中。分区可以驻留在父RDD的许多不同分区中。此转换是groupbyKey（）和reducebyKey（）的结果

十八，解释RDD属性

RDD（弹性分布式数据集）是Apache Spark中的基本抽象。RDD是群集上不可变的，分区的元素集合，可以并行操作。每个RDD的特点是五个主要属性：以下操作是谱系操作。1.列表或分区集。2.其他（父）RDD的依赖关系列表3.计算每个分区的函数以下操作用于执行期间的优化。4.可选的首选位置[即HDFS文件的块位置] [它是关于数据位置]5.可选的分区信息[即键/值对的哈希分区 - >当数据混洗时数据将如何传播]示例：#HadoopRDD：HadoopRDD 使用旧版MapReduce API（org.apache.hadoop.mapred）提供读取存储在Hadoop（HDFS，HBase，Amazon S3 ..）中的数据的核心功能HadoopRDD的属性：1.分区列表或分区：每个HDFS块一个2.父RDD依赖项列表：无3.计算每个分区的功能：读取相应的HDFS块4.可选首选位置：HDFS块位置5.可选分区信息：没有#FilteredRDD：FilteredRDD的属性：1.分区列表或分区集：与父RDD相同的分区数2. 父RDD上的依赖项列表：作为父项的“一对一”（与父项相同）3。计算每个分区的函数：计算父项然后过滤它4.可选首选位置：无（询问父级）5。可选分区信息：无

十九， Apache Spark中的血统图是什么？

在谱系图上添加更多点：

您可以使用rdd0.toDebugString检查两个RDD之间的谱系。这会返回从当前rdd到RDD之前所有依赖关系的沿袭图。见下文。每当你看到toDebugString输出中的“+ - ”符号时，就意味着从下一个操作开始就会有下一个阶段。这表示识别创建了多少个阶段。

scala> val rdd0 = sc.parallelize（List（“Ashok Vengala”，“Ashok Vengala”，“DataFlair”））

rdd0：org.apache.spark.rdd.RDD [String] = ParallelCollectionRDD [10]并行化在<console >：31

scala> val count = rdd0.flatMap（rec => rec.split（“”））。map（word =>（word，1））。reduceByKey（_ + _）

count：org.apache.spark.rdd.RDD [（String，Int）] =在<console>：33处的reduceByKey处的ShuffledRDD [13]

scala> count.toDebugString

res24：String =

（2）在<console>处的reduceByKey处的ShuffledRDD [13]：33 []

+ - （2）MapPartitionsRDD [12]在地图处<console>：33 []

| MapPartitionsRDD [11]在flatMap的<console>：33 []

| ParallelCollectionRDD [10]并行化在<console>：31 []

从下到上（即最后三行）：这些将在阶段0中执行。第一行（ShuffledRDD）：这将在第一阶段进行操作。

在toDebugString输出中，我们看到的是ParallelCollectionRDD，MapPartitionsRDD和ShuffleRDD。这些都是RDD抽象

二十，解释术语Spark Partitions和Partitioners

分区：

分区在HDFS中也称为“分裂”，是数据集的逻辑块，可以在Petabyte，Terabytes范围内并分布在群集中。默认情况下，Spark为文件的每个块创建一个分区（对于HDFS）HDFS块的默认块大小为64 MB（Hadoop版本1）/ 128 MB（Hadoop版本2），因此分割大小。但是，可以明确指定要创建的分区数。分区基本上用于加速数据处理。分区：定义键值对RDD中的元素如何按键分区的对象。将每个键映射到分区ID，从0到（分区数 - 1）分区程序捕获输出处的数据分布。调度程序可以根据分区程序的类型优化将来的操作。（即如果我们执行任何操作，说需要在节点之间移动的转换或动作，我们可能需要分区器。请在论坛中引用reduceByKey（）转换）Spark中基本上有三种类型的分区器：（1）哈希分区程序（2）范围分区程序（3）可以制作自定义分区程序属性名称： spark.default.parallelism 默认值：对于像reduceByKey和join这样的分布式shuffle操作，是父RDD中最大的分区数。对于没有父RDD并行化的操作，它取决于集群管理器：•本地模式：本地计算机上的核心数量•Mesos细粒度模式：8 •其他：所有执行程序节点上的核心总数或2，以较小者为准更大含义：通过转换（如join）返回的RDD中的默认分区数

二十一，默认情况下，Apache Spark中的RDD中创建了多少个分区？

默认情况下，Spark为文件的每个块创建一个分区（对于HDFS）HDFS块的默认块大小为64 MB（Hadoop版本1）/ 128 MB（Hadoop版本2）。但是，可以明确指定要创建的分区数。例1：没有指定分区val rdd1 = sc.textFile("/home/hdadmin/wc-data.txt")例2：以下代码创建了10个分区的RDD，因为我们指定了no。分区。val rdd1 = sc.textFile("/home/hdadmin/wc-data.txt", 10)可以通过以下方式查询分区数：rdd1.partitions.length<strong>OR</strong>rdd1.getNumPartitions最佳情况是我们应该按照以下方式制作RDD：Cluster中的核心数量=否。分区

二十二，什么是Spark DataFrames？

DataFrame由两个单词data和frame组成，意味着数据必须适合某种帧。我们可以将框架理解为关系数据库的模式。

在Spark中，DataFrame是通过网络和一些模式的分布式数据的集合。我们可以将其理解为格式化为行/列方式的数据。可以从Hive数据，JSON文件，CSV，结构化数据或可以在结构化数据中构建框架的原始数据创建DataFrame。如果可以在该RDD上应用某些模式，我们还可以从RDD创建DataFrame 。

临时视图或表也可以从DataFrame创建，因为它具有数据和模式。我们还可以在创建的表/视图上运行SQL查询以获得更快的结果。

它也被懒惰地评估（懒惰评估）以获得更好的资源利用率。

二十三，Spark中DataFrame的好处是什么？

以下是DataFrames的优点。

1.DataFrame是分布式数据集合。在DataFrames中，数据在命名列中组织。

它们在概念上类似于关系数据库中的表。此外，还有更丰富的优化。

3. DataFrames授权SQL查询和DataFrame API。

4.我们可以通过它处理结构化和非结构化数据格式。如：Avro，CSV，弹性搜索和Cassandra。此外，它还涉及存储系统HDFS，HIVE表，MySQL等。

5.在DataFrames中，Catalyst支持优化（催化剂优化器）。有一般库可用于表示树木。在四个阶段中，DataFrame使用Catalyst树转换：

- 分析逻辑计划以解决参考

- 逻辑计划优化

- 物理规划

- 用于将查询的一部分编译为Java字节码的代码生成。

6. DataFrame API有各种编程语言版本。例如爪哇，Scala中，Python和- [R 。

7.它提供Hive兼容性。我们可以在现有的Hive仓库上运行未修改的Hive查询。

8.它可以从单个笔记本电脑上的千字节数据扩展到大型集群上的数PB数据。

9. DataFrame通过Spark核心提供与大数据工具和框架的轻松集成。

二十四，什么是Spark数据集？

甲数据集是对象的不可变集合，那些被映射到一个关系模式。它们本质上是强类型的。

数据集API的核心有一个编码器。该编码器负责在JVM对象和

表格表示之间进行转换。通过使用Spark的内部二进制格式，存储表格表示，允许对序列化数据执行操作并提高内存利用率。它还支持为各种类型自动生成编码器，包括基本类型（例如String，Integer，Long）和Scala案例类。它提供了许多功能转换 （例如map，flatMap，filter）。

二十五，数据集在spark中有哪些优点？

1）静态类型 -

使用Dataset的静态类型功能，开发人员可以在编译时捕获错误（这节省了时间和成本）。

2）运行时安全性： -

数据集 API都表示为lambda函数和JVM类型对象，

在编译时将检测到任何类型参数的不匹配。此外，使用数据集时，也可以在编译时检测分析错误，

从而节省开发人员的时间和成本。

3）性能和优化

数据集API构建于Spark SQL引擎之上，它使用Catalyst生成优化的逻辑和物理查询计划，提供空间和速度效率。

4）处理需求，如高级表达式，过滤器，地图，聚合，平均值，总和，

SQL查询，列式访问以及在半结构化数据上使用lambda函数，DataSet最好。

5）数据集提供丰富的语义，高级抽象和特定于域的API

二十六，Apache Spark中的定向非循环图是什么？

在数学术语中，有向无环图是具有不定向的循环的图。DAG是一个图表，其中包含应用于RDD的所有操作的集合。在调用任何操作时的RDD上。Spark创建DAG并将其提交给DAG调度程序。只有在构建DAG之后，Spark才会创建查询优化计划。DAG调度程序将运算符划分为任务阶段。阶段由基于输入数据的分区的任务组成。DAG调度程序将运营商连接在一起。

使用有向非循环图在Spark中实现容错。通过使用DAG，可以在Spark中进行查询优化。因此，我们通过使用DAG获得更好的性能。

二十七， Spark DAG需要什么？

在Spark中需要DAG

我们知道Hadoop MapReduce存在一些局限性。为了克服这些限制，Apache Software在Spark中引入了DAG 。让我们首先研究MapReduce的计算过程。它通常分三步进行：

1. HDFS用于读取数据。

2.之后，我们应用Map和Reduce操作。

3.再次将计算结果写回HDFS。

在Hadoop中，每个MapReduce操作都是相互独立的。甚至HADOOP也不知道接下来会有哪些Map减少。因此，有时在一些迭代中读取和写回两个map-reduce作业之间的立即结果是无关紧要的。结果，磁盘存储器或稳定存储器（HDFS）中的存储器被浪费。

当我们谈论多步骤时，所有作业从一开始就被阻止，直到完成上一个作业。因此，复杂的计算可能需要较长的时间和较小的数据量。

但是，在Spark中引入DAG之后，执行计划已经过优化，例如，最大限度地减少了混乱数据。由于形成了连续计算级的DAG（有向无环图）。

二十八，DAG和Lineage有什么区别？

为了更好地理解这些差异，我们将逐一讨论每个主题：

谱系图

我们知道，只要在RDD上执行一系列转换，就不会立即评估它们，而是懒惰（懒惰评估）。当从现有RDD创建新RDD时，该新RDD包含指向父RDD的指针。同样，RDD之间的所有依赖关系都将记录在图形中，而不是实际数据中。该图称为谱系图。

现在来到DAG，

Apache Spark中的定向非循环图（DAG）

DAG 是顶点和边缘的组合。在DAG中，顶点表示RDD，边表示要应用于RDD的操作。DAG中的每个边缘都是从一个序列中的较早到后一个。当我们调用一个Action时，创建的DAG将被提交给DAG Scheduler，后者会进一步将图形拆分为任务的各个阶段

二十九，Apache Spark中的缓存和持久性有什么区别？

Cache和Persist都是Spark计算的优化技术。

Cache是​​具有MEMORY_ONLY存储级别的Persist的同义词（即）使用Cache技术我们可以仅在需要时将中间结果保存在内存中。

Persist 使用存储级别为持久性标记RDD，存储级别可以是MEMORY，MEMORY_AND_DISK，MEMORY_ONLY_SER，MEMORY_AND_DISK_SER，DISK_ONLY，MEMORY_ONLY_2，MEMORY_AND_DISK_2

仅仅因为你可以在内存中缓存RDD并不意味着你应该盲目地这样做。根据访问数据集的次数以及执行此操作所涉及的工作量，通过增加的内存压力可以更快地重新计算。

不言而喻，如果你只读一个数据集，一旦没有缓存它，它实际上会使你的工作变慢

三十，Apache Spark有哪些限制？

现在，Apache Spark被认为是行业广泛使用的下一代Gen Big数据工具。但Apache Spark存在一定的局限性。他们是：

Apache Spark的局限性：

1.无文件管理系统

Apache Spark依赖于其他平台，如Hadoop或其他基于云的平台文件管理系统。这是Apache Spark的主要问题之一。

2.延迟

使用Apache Spark时，它具有更高的延迟。

3.不支持实时处理

在Spark Streaming中，到达的实时数据流被分成预定义间隔的批次，每批数据被视为Spark Resilient Distributed Database（RDD）。然后使用map，reduce，join等操作处理这些RDD。这些操作的结果是批量返回的。因此，它不是实时处理，但Spark接近实时数据的实时处理。微批处理在Spark Streaming中进行。

4.手动优化

手动优化是优化Spark作业所必需的。此外，它适用于特定数据集。如果我们想要在Spark中进行分区和缓存是正确的，我们需要手动控制。

少一点。算法

Spark MLlib在Tanimoto距离等许多可用算法方面落后。

6.窗口标准

Spark不支持基于记录的窗口标准。它只有基于时间的窗口标准。

7.迭代处理

在Spark中，数据分批迭代，每次迭代都是单独调度和执行的。

8.

当我们想要经济高效地处理大数据时，昂贵内存容量可能成为瓶颈，因为在内存中保存数据非常昂贵。此时内存消耗非常高，并且不以用户友好的方式处理。Spark的成本非常高，因为Apache Spark需要大量的RAM才能在内存中运行

三十一，Apache Spark的不同运行模式

我们可以用四种模式启动spark应用程序：

1）本地模式（本地[*]，本地，本地[2] ......等）

- >当您启动spark-shell而没有控制/配置参数时，它将以本地模式启动

spark-shell --master local [1 ]

- > spark-submit --class com.df.SparkWordCount SparkWC.jar local [1]

2）Spark Standalone集群管理器：

- > spark-shell --master spark：// hduser：7077

- > spark-submit --class com.df.SparkWordCount SparkWC.jar spark：// hduser：7077

3）纱线模式（客户端/群集模式）：

- > spark-shell --master yarn或

（或）

- > spark-shell --master yarn --deploy-mode client

以上两个命令都是相同的。

要在集群模式下启动spark应用程序，我们必须使用spark-submit命令。我们不能通过spark-shell运行yarn-cluster模式，因为当我们运行spark应用程序时，驱动程序将作为部件应用程序主容器/进程运行。因此无法通过spark-shell运行集群模式。

- > spark-submit --class com.df.SparkWordCount SparkWC.jar yarn-client

- > spark-submit --class com.df.SparkWordCount SparkWC.jar yarn-cluster

4）Mesos模式：

- > spark-shell --master mesos：// HOST：5050

三十二，在Spark中表示数据的不同方法有哪些？

基本上，在Apache Spark中有3种不同的方式来表示数据。要么我们可以通过RDD表示它，要么我们使用DataFrames，或者我们也可以选择DataSet来表示我们在Spark中的数据。让我们详细讨论它们中的每一个：

1. RDD

RDD指的是“弹性分布式数据集”。RDD是Apache Spark的核心抽象和基础数据结构。它是一个不可变的对象集合，可以在集群的不同节点上进行计算。我们知道RDD是不可变的，虽然我们不能对其进行任何更改，但我们可以对它们应用以下操作，如Transformation和Actions。它以容错方式对大型集群执行内存计算。基本上，有三种方法可以在Spark中创建RDD，例如 - 稳定存储中的数据，其他RDD，以及并行化驱动程序中已有的集合。按照此链接详细了解Spark RDD。

2. DataFrame

在DataFrame中，数据组织成命名列。此表与关系数据库中的表类似。DataFrames也是一个不可变的分布式数据集合。它允许开发人员将结构强加到分布式数据集合上，从而实现更高级别的抽象。请点击此链接详细了解Spark DataFrame。

3. Spark数据集API

它是DataFrame API的扩展。它提供了类型安全的，面向对象的编程接口。它利用Spark的Catalyst优化器，将数据字段和表达式公开给查询计划器。

三十三，什么是Spark中的日志写入（日志记录）？

任何Apache Spark作业中都有两种类型的故障- 驱动程序故障或工作程序故障。

当任何工作节点发生故障时，将终止在该工作节点中运行的执行程序进程，并且在该工作节点上调度的任务将自动移动到任何其他正在运行的工作节点，并且将完成任务。

当驱动程序或主节点发生故障时，运行执行程序的所有关联工作程序节点将与每个执行程序内存中的数据一起被终止。在从可靠和容错的文件系统（如HDFS）读取文件的情况下，始终保证零数据丢失，因为数据随时可以从文件系统中读取。通过定期以特定间隔保存应用程序数据，检查点还可确保Spark中的容错。

在Spark Streaming应用程序的情况下，并不总是保证零数据丢失，因为数据将被缓冲在执行程序的内存中，直到它们被处理为止。如果驱动程序失败，则所有执行程序都将被终止，其内存中的数据将无法恢复。

为了克服这种数据丢失情况，Apache Spark 1.2中引入了写入前向记录（WAL）。启用WAL后，首先在日志文件中记下操作的意图，这样如果驱动程序失败并重新启动，则该日志文件中的注释操作可以应用于数据。对于读取流数据的源，如Kafka或Flume，接收器将接收数据，这些数据将存储在执行程序的内存中。启用WAL后，这些接收的数据也将存储在日志文件中。

可以通过执行以下操作启用WAL：

1.使用streamingContext.checkpoint（path）设置检查点目录

2.通过将spark.stream.receiver.WriteAheadLog.enable设置为True来启用WAL日志记录

三十四，在Apache Spark中解释催化剂查询优化器。

pache Spark最重要的组件是Spark SQL，它处理DataFrame API和SQL查询。在Spark SQL中，有一个名为Catalyst Query Optimizer的优化器。使用此Spark创建可扩展的查询优化器。此查询优化器Spark基于Scala的函数式编程构造。

需要查询优化器：

要获得解决方案来解决Bigdata的各种问题。作为扩展优化器的解决方案。

我们分四个阶段使用催化剂通用树转换框架工作

分析逻辑优化。物理规划。代码生成。

三十五，Apache Spark中的共享变量是什么？

共享变量只不过是可以在并行操作中使用的变量。默认情况下，当Apache Spark并行运行一个函数作为不同节点上的一组任务时，它会将函数中使用的每个变量的副本发送给每个任务。有时，变量需要跨任务共享，或者在任务和驱动程序之间共享。Spark支持两种类型的共享变量：广播变量，可用于缓存所有节点的内存中的值; 累加器，它们是仅“添加”到的变量，例如计数器和总和。

三十六，Apache Spark如何处理累积的元数据？

由于随机操作，元数据在驱动程序上累积。在长期工作中变得特别乏味。

要处理累积元数据的问题，有两种选择：

首先，设置spark.cleaner.ttl参数以触发自动清理。但是，这将消除任何持久的RDD。另一种解决方案是简单地将长时间运行的作业分成批处理并将中间结果写入磁盘。这有利于每个批次的新环境，而不必担心元数据的建立。

三十七，什么是Apache Spark Machine学习库？

Apache Spark中的机器学习库

它是一个可扩展的机器学习库，可以讨论高速和高质量的算法。

为了使机器学习可扩展且简单，创建了MLlib。有机器学习库包括各种机器学习算法的实现。例如，聚类，回归，分类和协同过滤。MLlib中也存在一些较低级别的机器学习原语，如通用梯度下降优化算法。

在Apache Spark Version 2.0中，基于RDD的API在spark中。MLlib包进入维护模式。在此版本中，基于DataFrame的API是Spark的主要机器学习API。因此，MLlib不会向基于RDD的API添加任何新功能。

基于 DataFrame的API是它比 RDD更加用户友好，因此MLlib正在切换到DataFrame API。使用DataFrames的一些好处是它包括Spark数据源， Spark SQL DataFrame查询Tungsten和 Catalyst优化，以及跨语言的统一API。这个机器学习库也使用线性代数包Breeze。Breeze是用于数值计算和机器学习的库的集合。

三十八，列出常用的机器学习算法。

基本上，有三种类型的机器学习算法：

（1）监督学习算法

（2）无监督学习算法

（3）强化学习算法

>最常用的机器学习算法如下：

（1）线性回归

（2）Logistic回归

（3）决策树

（4）K-Means

（5）KNN

（6）SVM

（7）随机森林

（8）朴素贝叶斯

（9） 降维算法

（10）梯度升压和Adaboos

三十九，DSM和RDD有什么区别？

在几个特征的基础上，RDD和DSM之间的区别是：

一世。读

RDD -在读操作RDD要么是粗粒度或细粒度。粗粒度意味着我们可以转换整个数据集，但不能转换数据集上的单个元素。虽然细粒度意味着我们可以转换数据集上的单个元素。

DSM - 分布式共享内存中的读取操作是细粒度的。

II。写

RDD - RDD中的写操作是粗粒度的。

DSM - Write操作在分布式共享系统中是细粒度的。

III。一致性

RDD - RDD的一致性是微不足道的，这意味着它本质上是不可变的。我们无法识别RDD的内容，即RDD的任何变化都是永久性的。因此，一致性水平非常高。

DSM - 系统保证如果程序员遵守规则，内存将保持一致。此外，内存操作的结果将是可预测的。

IV。故障恢复机制

RDD - 通过随时使用沿袭图，可以在Spark RDD中轻松恢复丢失的数据。因此，对于每次转换，形成新的RDD。由于RDD本质上是不可变的，因此很容易恢复。

DSM - 通过检查点技术实现容错，该技术允许应用程序回滚到最近的检查点而不是重新启动。

v。斯特拉格勒减灾

总的来说，Stragglers是那些比同龄人需要更多时间才能完成的人。这可能是由于许多原因造成的，例如负载不平衡，I / O块，垃圾收集等。

落后者的问题是当并行计算之后是同步，例如减少导致所有并行任务等待其他人。

RDD - 可以通过在RDD中使用备份任务来缓解落后者。

DSM - 实现落后缓解，非常困难。

六。行为如果没有足够的RAM

RDD - 由于没有足够的空间将RDD存储在RAM中，因此RDD会转移到磁盘。

DSM - 如果RAM用完存储，性能会降低，在这种类型的系统中

四十，列出Apache Spark中Parquet文件的优点

Parquet是Hadoop的开源文件格式。与传统方法相比，Parquet以扁平柱状格式存储嵌套数据结构，其中数据以行面向方式存储，镶木地板在存储和性能方面更有效。

柱状格式有几个优点：

1）按列进行组织可以实现更好的压缩，因为数据更加均匀。在Hadoop集群的规模上，节省的空间非常明显。

2）I / O将减少，因为我们可以在读取数据时有效地仅扫描列的子集。更好的压缩还可以减少读取输入所需的带宽。

3）当我们在每列中存储相同类型的数据时，我们可以通过使指令分支更可预测来使用更适合现代处理器管道的编码

四十一，什么是Spark的懒惰评估？

简介

延迟评估意味着在触发操作之前不会启动执行。转换本质上是懒惰的，即当我们在RDD上调用某些操作时，它不会立即执行。Spark将它们添加到DAG计算中，并且只有当驱动程序请求某些数据时，才会执行此DAG

懒惰评估的优点。

1）这是一种优化技术，即它通过减少查询数量来提供优化。

2）它节省了驱动程序和集群之间的往返，从而加快了进程

四十二， Spark懒惰评估的好处是什么？

Apache Spark使用延迟评估以获得好处：

1）对RDD应用转换操作或“将数据加载到RDD”不会立即执行，直到它看到一个动作。对RDD的转换和在RDD中存储数据进行了懒惰的评估。如果Spark使用惰性评估，将以更好的方式利用资源。

2）Spark使用延迟评估来减少通过将操作分组在一起而必须接管的数据。在MapReduce的情况下，用户/开发人员必须花费大量时间来将操作组合在一起，以便最小化MapReduce传递的数量。在spark中，编写单个复杂映射而不是将许多简单操作链接在一起没有任何好处。用户可以将他们的火花程序组织成较小的操作。通过使用延迟评估，Spark将非常有效地管理所有操作

3）延迟评估有助于优化Spark中的磁盘和内存使用。

4）一般来说，在对数据进行计算时，我们必须考虑两个方面，即空间和时间的复杂性。使用火花懒惰评估，我们可以克服两者。仅在需要数据时才会触发操作。它减少了开销。

5）它还节省了计算量并提高了速度。延迟评估将在节省计算开销方面发挥关键作用。

只计算必要的值而不是整个数据集（它全部取决于操作操作，也很少

转换）

四十三，Apache火花比Hadoop快多少？

当数据适合内存时， Apache Spark工作得更快，Spark处理内存中的数据，这使得处理速度更快，而 MapReduce在处理后将数据推送到磁盘。使用 DAG有助于进行大量优化，它可以在一个阶段中优化和进行计算，并且还可以避免不必要的减速器任务。Spark可以在内存中缓存部分或完整数据，从而避免大量磁盘I / O. 据说商业Spark比 Hadoop快100倍

四十四，通过YARN启动Apache Spark有哪些方法？

Apache Spark有两种在YARN上运行应用程序的模式：集群和客户端

spark-submit或spark-shell --master yarn-cluster或--master yarn-client

四十五。.解释Apache Spark中的各种集群管理器？

Apache Spark是一种可以在群集上以分布式模式运行的大型数据处理引擎。Spark应用程序作为集群上的独立进程集运行，所有这些都由中央协调器协调。这个中央协调器可以连接三个不同的集群管理器，Spark的Standalone，Apache Mesos和Hadoop YARN。

在群集上以分布式模式运行应用程序时，Spark使用主/从体系结构和中央协调器，也称为驱动程序

此驱动程序进程负责将用户应用程序转换为称为任务的较小执行单元。然后，这些任务由执行程序执行，执行程序是运行各个任务的工作进程。

Spark Standalone

Spark Standalone集群管理器是一个简单的集群管理器，可作为Spark发行版的一部分。它具有主服务器的HA，对工作人员故障具有弹性，具有管理每个应用程序资源的功能，并且可以与现有Hadoop部署一起运行并访问HDFS（Hadoop分布式文件系统）数据。该分发包括脚本，以便在Amazon EC2上本地或在云中轻松部署。它可以在Linux，Windows或Mac OSX上运行。

Apache Mesos

Mesos通过动态资源共享和隔离来处理分布式环境中的工作负载。在大规模集群环境中部署和管理应用程序是健康的Mesos许多物理资源都是俱乐部成为单个虚拟资源Apache Mesos的三个组件是Mesos master，Mesos slave，Frameworks。

Mesos Master是群集的一个实例。群集具有许多提供容错的Mesos主服务器。从属是Mesos实例，为群集提供资源。Mesos Framework允许应用程序从集群请求资源

YARN> / strong>

YARN数据计算框架是ResourceManager，Nodemanager的组合。

资源管理器 - 管理系统中所有应用程序之间的资源。在资源管理器具有调度器和应用程序管理器。

Scheduler将资源分配给各种正在运行的应用程序。它是纯调度程序，执行应用程序状态的监视或跟踪。

Application Manager管理所有节点上的应用程序。

纱线节点管理器包含应用程序主和容器。容器是一个工作单元发生的地方。Application Master是一个特定于框架的库。它旨在协调资源管理器中的资源。它继续使用节点管理器来执行和观察任务。

四十六，什么是Apache Spark中的推测执行？

在投机性任务在Apache的火花是验证任务推测，这意味着运行速度比成功完成任务的任务表中位数较慢的任务任务的运行速度比在job.It任务的其余部分慢是健康检查过程。这些任务被提交给另一名工人。它并行运行新副本，而不是关闭慢速任务。

在集群部署模式，线程开始为TaskSchedulerImp1 与启用spark.speculation 。它在初始spark.speculation.interval通过后定期执行每个spark.speculation.interval

四十七，.使用Apache Spark时，如何最大限度地减少数据传输？

在Spark中，可以通过避免导致数据混洗的操作来减少数据传输。

避免重新分区和合并，ByBey操作（如groupByKey和reduceByKey）以及联合操作（如cogroup和join）之类的操作。

Spark Shared Variables有助于减少数据传输。共享变量有两种类型 - 广播变量和累加器。

广播变量：

如果我们有一个大型数据集，而不是为每个任务传输数据集的副本，我们可以使用一个广播变量，该变量可以一次复制到每个节点，

并为该节点中的每个任务共享相同的数据。广播变量有助于为每个节点提供大型数据集。

首先，我们需要使用SparkContext.broadcast创建一个广播变量，然后将其广播到驱动程序的所有节点。值方法

可用于访问共享值。仅当多个阶段的任务使用相同数据时，才会使用广播变量。

累加器：

Spark函数使用驱动程序中定义的变量，并生成变量的本地复制。累加器是共享变量，有助于

在执行期间并行更新变量，并将工作者的结果共享给驱动程序。

四十八。 Apache Spark超越Hadoop的情况是什么？

我们可以比较下面区域的Hadoop和Spark：

存储计算计算速度资源

与Hadoop相比，Spark的主要优势在于其计算速度.Spark具有：

闪电般快速的集群计算。Apache Spark是一种用于大规模数据处理的快速通用引擎。

这个优点是因为RDD是火花的基本抽象。

除此之外，Spark架构和Spark执行引擎是Apache Spark与Hadoop相比速度更快的两个原因。

Hadoop是批处理的理想选择，而Spark可以进行批处理以及迭代，交互式流处理。

四十九。什么是动作，它如何在apache spark中处理数据

动作返回RDD计算/操作的最终结果。它使用沿袭图触发执行以将数据加载到原始RDD中，并执行所有中间转换并将最终结果返回给Driver程序或将其写出到文件系统。

例如：首先，take，reduce，collect，count，aggregate是spark中的一些动作。

Action会将值返回给Apache Spark驱动程序。它可能会触发先前构造的，懒惰的RDD进行评估。这是一个生成非RDD值的RDD操作。Action函数实现Spark程序中的值。所以基本上一个动作是RDD操作，它返回任何类型的值，但RDD [T]是一个动作。操作是从执行程序向驱动程序发送数据的两种方法之一（另一种是累加器）

五十，如何在Apache Spark中实现容错？

Apache Spark中容错的基本语义是，所有Spark RDD都是不可变的。它通过在DAG中创建的沿袭图表记住操作中涉及的每个RDD之间的依赖关系，并且在任何失败的情况下，Spark指的是应用相同操作来执行任务的沿袭图。

有两种类型的故障 - 工作者或驱动程序故障。如果工作程序失败，该工作节点中的执行程序将与其内存中的数据一起被终止。使用沿袭图，这些任务将在任何其他工作节点中完成。数据也会复制到其他工作节点以实现容错。有两种情况：

1. 接收和复制的数据 - 从源接收数据，并在工作节点之间复制数据。在任何故障的情况下，数据复制将有助于实现容错。

2.已接收但尚未复制的数据 - 从源接收数据但缓冲以进行复制。如果发生任何故障，则需要从源检索数据。

对于基于接收器的流输入，容错基于接收器的类型：

可靠的接收器 - 一旦接收和复制数据，就会向源发送确认。如果接收器发生故障，源将不会收到对接收数据的确认。当接收器重新启动时，源将重新发送数据以实现容错。不可靠的接收器 - 接收的数据将不会被确认。在这种情况下，如果发生任何故障，源将不知道数据是否已被接收，并且它将不会重新发送数据，因此会丢失数据。为了克服这种数据丢失情况，Apache Spark 1.2中引入了写入前向记录（WAL）。启用WAL后，首先在日志文件中记下操作的意图，这样如果驱动程序失败并重新启动，则该日志文件中的注释操作可以应用于数据。对于读取流数据的源，如Kafka或Flume，接收器将接收数据，这些数据将存储在执行程序的内存中。启用WAL后，这些接收的数据也将存储在日志文件中。可以通过执行以下操作启用WAL：使用streamingContext.checkpoint（path）设置检查点目录通过将spark.stream.receiver.WriteAheadLog.enable设置为True来启用WAL日志记录

希望大家多多关注，明天更新下半部，