spark

最新推荐文章于 2024-07-14 16:41:48 发布
最新推荐文章于 2024-07-14 16:41:48 发布
阅读量121 收藏
点赞数
文章标签： spark
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wanghenghengheng/article/details/90168788
版权 
scala> val rdd = sc.textFile("hdfs://hadoop-senior.ibeifeng.com:8020/user/beifeng/mapreduce/wordcount/input/wc.input")

scala> val wordRdd = rdd.flatMap(_.split(" "))

scala> val kvRdd = wordRdd.map((_,1))

scala> val wordCountRdd = kvRdd.reduceByKey(_ + _)

scala> wordCountRdd.collect

scala> wordCountRdd.saveAsTextFile("hdfs://hadoop-senior.ibeifeng.com:8020/user/beifeng/mapreduce/wordcount/sparkOutput")

hdfs -> rdd  -> wordRdd  -> kvRdd  -> wordCountRdd -> hdfs

RDD lineage 生命线 ，保存如何转换得来的

=====================================================
针对 Key-Value类型的RDD，可以指定分区函数

map-01
   					reduce-01
map-02
   					reduce-02
map-03



处理RDD split进行计算时，split数据在哪里，我们尽量在那台机器上进行计算


【移动计算而不是移动数据】


=====================================================
val keyRdd = kvRdd.groupByKey(2)

wordRdd 				kvRdd 						keyRdd
-------      map
spark 					(spark,1)					(spark,list(1,1,1,1,1))
hadoop   				(hadoop,1)					(rdd,list(1,1))	
hdfs					(hdfs,1)					
spark 					(spark,1)
--------    map
spark 					(spark,1)
yarn					(yarn,1)					--------------------
rdd 					(rdd,1)						(hadoop,list(1))
spark 					(spark,1)					(hdfs,list(1))
---------   map 									(yarn,list(1))
spark 					(spark,1)
rdd 					(rdd,1)
----------------------------------------------------------------------------------------------

Spark Standalone 部署
	Master
	Work

## WordCount
val rdd = sc.textFile("hdfs://hadoop-senior.ibeifeng.com:8020/user/beifeng/mapreduce/wordcount/input/wc.input")
val wordcount = rdd.flatMap(_.split(" ")).map((_,1)).reduceByKey(_ + _)
wordcount.collect
wordcount.saveAsTextFile("hdfs://hadoop-senior.ibeifeng.com:8020/user/beifeng/mapreduce/wordcount/sparkOutput99")

======result
(hive,2)
(mapreduce,1)
(mapreduce2,1)
(hadoop,5)
(hdfs,1)
发现：
	Spark 运行WordCoun程序，并没有像MapReduce程序那样，对Key进行排序。
## Key Sort
wordcount.sortByKey().collect    ## 默认情况是 升序
wordcount.sortByKey(true).collect	
wordcount.sortByKey(false).collect		
	
===============================================================	
------result
(hive,2)
(mapreduce,1)
(mapreduce2,1)
(hadoop,5)
(hdfs,1)	
需求：
	按照value值进行降序
## Value Sort
wordcount.map(x => (x._2,x._1)).sortByKey(false).collect
wordcount.map(x => (x._2,x._1)).sortByKey(false).map(x => (x._2,x._1)).collect
	
## Top N
wordcount.map(x => (x._2,x._1)).sortByKey(false).map(x => (x._2,x._1)).take(3)

+++++++++++++++++++++++++++++++++++++++++++
Group Top Key
	WordCount 程序，前KEY值

需求：
	类似MapReduce中的二次排序
	1) 按照第一个字段进行分组
	2) 对分组中的第二字段进行排序(降序)
	3) 获取每个分组Top N，比如获取前三个值
aa 78
bb 98
aa 80
cc 98				
aa 69
cc 87
bb 97
cc 86
aa 97
bb 78
bb 34
cc 85
bb 92
cc 72
bb 32
bb 23	
	
功能分析：
	(aa,list(78,80,69,97)) ->  (aa,list(69,78,80,97))  -> (aa,list(69,78,80))
	
val rdd = sc.textFile("hdfs://hadoop-senior.ibeifeng.com:8020/user/beifeng/spark/grouptop/input/score.input")
	
rdd.map(_.split(" ")).collect	
	Array(aa, 78)
	
rdd.map(_.split(" ")).map(x => (x(0),x(1))).collect  //x(0)取第一个元素
	(aa,78)
	
rdd.map(_.split(" ")).map(x => (x(0),x(1))).groupByKey.collect
	(aa,CompactBuffer(78, 80, 69, 97))

rdd.map(_.split(" ")).map(x => (x(0),x(1))).groupByKey.map(
    x => {
       val xx = x._1   //位置，取第一个位置
       val yy = x._2
       yy
    }
).collect


	Iterable[String]
	
Iterable 方法：
	def toList: List[A]
	返回包含此遍历的迭代器的所有元素的列表
	
rdd.map(_.split(" ")).map(x => (x(0),x(1))).groupByKey.map(
    x => {
       val xx = x._1
       val yy = x._2
       yy.toList   
    }
).collect
	List[String]
	List(78, 80, 69, 97)
	
List 方法：	
	def sorted[B >: A]: List[A]
	根据排序对列表进行排序
rdd.map(_.split(" ")).map(x => (x(0),x(1))).groupByKey.map(
    x => {
       val xx = x._1
       val yy = x._2
       yy.toList.sorted
    }
).collect	
	List[String]
	List(69, 78, 80, 97)
	
List 方法：	
	def reverse: List[A]
	返回新列表，在相反的顺序元素
rdd.map(_.split(" ")).map(x => (x(0),x(1))).groupByKey.map(
    x => {
       val xx = x._1
       val yy = x._2
       yy.toList.sorted.reverse
    }
).collect
	List[String]
	List(97, 80, 78, 69)

List 方法：	
	def take(n: Int): List[A]
	返回前n个元素
	
	def takeRight(n: Int): List[A]
	返回最后n个元素
rdd.map(_.split(" ")).map(x => (x(0),x(1))).groupByKey.map(
    x => {
       val xx = x._1
       val yy = x._2
       yy.toList.sorted.reverse.take(3)
    }
).collect

要求返回的是一个元组对
rdd.map(_.split(" ")).map(x => (x(0),x(1))).groupByKey.map(
    x => {
       val xx = x._1
       val yy = x._2
       (xx,yy.toList.sorted.reverse.take(3))
    }
).collect

val groupTopKeyRdd = rdd.map(_.split(" ")).map(x => (x(0),x(1))).groupByKey.map(
    x => {
       val xx = x._1
       val yy = x._2
       (xx,yy.toList.sorted.reverse.take(3))
    }
)
groupTopKeyRdd.saveAsTextFile("hdfs://hadoop-senior.ibeifeng.com:8020/user/beifeng/spark/grouptop/output")


==================================================================

bin/spark-submit \
  --master spark://hadoop-senior.ibeifeng.com:7077 \
  jars/sparkApp.jar
--------------------------------------------------------------------------------

Spark Core
	>> 四大优势
	>> 编译
		依据不同版本的Hadoop以及Hive进行编译
	>> local mode
		spark-shell
	>> cluster
		安装配置部署Standalone
	>> RDD
		五大特性
		transformation、action、persistent
		WordCount
	>> Spark Core案例
		如何导入源码IDEA、查看源码
	>> Spark 调度
		DAG -> Task -> Run on Executor
	>> 如何配置HistoryServer
		jetty
		类似于MapReduce中JobHistoryServer
	>> Spark Application 编程模型
		如何在IDEA中开发一个Spark应用、测试、打包、运行
	>> Spark on YARN
		deploy-mode
			cluster
			client
常见面试题：
	第一、RDD 理解、五大特性
	第二、Spark Applicaiton Scheduler
	第三、Spark on yarn

=========================================================================

Spark Streaming Demo

从Socket实时读取数据，进行实时处理
# rpm -ivh nc-1.84-22.el6.x86_64.rpm

## 运行nc针对于端口号9999
$ nc -lk 9999

## 运行Demo
bin/run-example streaming.NetworkWordCount hadoop-senior.ibeifeng.com 9999

-------------------------------------
nc -lk 9991
成功 spark-submit --master local[*] --class org.apache.spark.examples.streaming.NetworkWordCount --name wordCount /opt/cloudera/parcels/CDH-5.3.6-1.cdh5.3.6.p0.11/jars/spark-examples-1.2.0-cdh5.3.6-hadoop2.5.0-cdh5.3.6.jar master 9999
hadoop spark hdfs a b hadoop spark hdfs a b hadoop spark hdfs a b hadoop spark hdfs

---------------------------------------
=====================Initializing StreamingContext===================
import org.apache.spark._
import org.apache.spark.streaming._
import org.apache.spark.streaming.StreamingContext._ 

val conf = new SparkConf().setMaster("local[2]").setAppName("NetworkWordCount")
val ssc = new StreamingContext(conf, Seconds(5))

// read data
val lines = ssc.socketTextStream("localhost", 9999)

// process
val words = lines.flatMap(_.split(" "))
val pairs = words.map(word => (word, 1))
val wordCounts = pairs.reduceByKey(_ + _)
wordCounts.print()
 
ssc.start()             // Start the computation
ssc.awaitTermination()  // Wait for the computation to terminate



=====================HDFS ===================
import org.apache.spark._
import org.apache.spark.streaming._
import org.apache.spark.streaming.StreamingContext._ 

val ssc = new StreamingContext(sc, Seconds(5))

// read data
val lines = ssc.textFileStream("hdfs://hadoop-senior.ibeifeng.com:8020/user/beifeng/streaming/input/hdfs/")

// process
val words = lines.flatMap(_.split("\t"))
val pairs = words.map(word => (word, 1))
val wordCounts = pairs.reduceByKey(_ + _)
wordCounts.print()
 
ssc.start()             // Start the computation
ssc.awaitTermination()  // Wait for the computation to terminate

-----------------------------------
如何在Spark-shell中执行某个scala代码
:load /opt/cdh-5.3.6/spark-1.3.0-bin-2.5.0-cdh5.3.6/HDFSWordCount.scala

==========================将处理数据保存到HDFS================================
import org.apache.spark._
import org.apache.spark.streaming._
import org.apache.spark.streaming.StreamingContext._ 

val ssc = new StreamingContext(sc, Seconds(5))

// read data
val lines = ssc.textFileStream("hdfs://hadoop-senior.ibeifeng.com:8020/user/beifeng/streaming/input/hdfs/")

// process
val words = lines.flatMap(_.split("\t"))
val pairs = words.map(word => (word, 1))
val wordCounts = pairs.reduceByKey(_ + _)
wordCounts.saveAsTextFiles("hdfs://hadoop-senior.ibeifeng.com:8020/user/beifeng/streaming/output/")
 
ssc.start()             // Start the computation
ssc.awaitTermination()  // Wait for the computation to terminate


===============Spark Streaming + Flume Integration=================
Flume有三个组件
	Source  --->   Channel  --->   Sink(Spark Streaming)

import org.apache.spark._
import org.apache.spark.streaming._
import org.apache.spark.streaming.StreamingContext._ 
import org.apache.spark.streaming.flume._
import org.apache.spark.storage.StorageLevel

val ssc = new StreamingContext(sc, Seconds(5))

// read data
val stream = FlumeUtils.createStream(ssc, "hadoop-senior.ibeifeng.com", 9999, StorageLevel.MEMORY_ONLY_SER_2)

stream.count().map(cnt => "Received " + cnt + " flume events." ).print()

ssc.start()             // Start the computation
ssc.awaitTermination()  // Wait for the computation to terminate

------------------
bin/spark-shell --jars \
/opt/cdh-5.3.6/spark-1.3.0-bin-2.5.0-cdh5.3.6/externallibs/spark-streaming-flume_2.10-1.3.0.jar,/opt/cdh-5.3.6/spark-1.3.0-bin-2.5.0-cdh5.3.6/externallibs/flume-avro-source-1.5.0-cdh5.3.6.jar,/opt/cdh-5.3.6/spark-1.3.0-bin-2.5.0-cdh5.3.6/externallibs/flume-ng-sdk-1.5.0-cdh5.3.6.jar

------
run command:
	bin/flume-ng agent -c conf -n a2 -f conf/flume-spark-push.sh -Dflume.root.logger=DEBUG,console


====================================================================

启动Kafka集群
	nohup bin/kafka-server-start.sh config/server.properties & 

创建topic命令
	bin/kafka-topics.sh --create --zookeeper hadoop-senior.ibeifeng.com:2181 --replication-factor 1 --partitions 1 --topic test

查看已用topic
	bin/kafka-topics.sh --list --zookeeper hadoop-senior.ibeifeng.com:2181

生产数据
	bin/kafka-console-producer.sh --broker-list hadoop-senior.ibeifeng.com:9092 --topic test

消费数据
	bin/kafka-console-consumer.sh --zookeeper hadoop-senior.ibeifeng.com:2181 --topic test --from-beginning



===============Spark Streaming + Kafka Integration=================
import java.util.HashMap
import org.apache.spark._
import org.apache.spark.streaming._
import org.apache.spark.streaming.StreamingContext._ 
import org.apache.spark.streaming.kafka._

val ssc = new StreamingContext(sc, Seconds(5))

val topicMap = Map("test" -> 1)

// read data
val lines = KafkaUtils.createStream(ssc, "hadoop-senior.ibeifeng.com:2181", "testWordCountGroup", topicMap).map(_._2)

val words = lines.flatMap(_.split(" "))
val wordCounts = words.map(x => (x, 1)).reduceByKey(_ + _)
wordCounts.print()

ssc.start()             // Start the computation
ssc.awaitTermination()  // Wait for the computation to terminate

------------------
bin/spark-shell --jars \
/opt/cdh-5.3.6/spark-1.3.0-bin-2.5.0-cdh5.3.6/externallibs/spark-streaming-kafka_2.10-1.3.0.jar,/opt/cdh-5.3.6/spark-1.3.0-bin-2.5.0-cdh5.3.6/externallibs/kafka_2.10-0.8.2.1.jar,/opt/cdh-5.3.6/spark-1.3.0-bin-2.5.0-cdh5.3.6/externallibs/kafka-clients-0.8.2.1.jar,/opt/cdh-5.3.6/spark-1.3.0-bin-2.5.0-cdh5.3.6/externallibs/zkclient-0.3.jar,/opt/cdh-5.3.6/spark-1.3.0-bin-2.5.0-cdh5.3.6/externallibs/metrics-core-2.2.0.jar

第两种方式
===============Spark Streaming + Kafka Integration=================
import kafka.serializer.StringDecoder
import org.apache.spark._
import org.apache.spark.streaming._
import org.apache.spark.streaming.StreamingContext._ 
import org.apache.spark.streaming.kafka._

val ssc = new StreamingContext(sc, Seconds(5))

val kafkaParams = Map[String, String]("metadata.broker.list" -> "hadoop-senior.ibeifeng.com:9092")
val topicsSet = Set("test")

// read data
val messages = KafkaUtils.createDirectStream[String, String, StringDecoder, StringDecoder](ssc, kafkaParams, topicsSet)

val lines = messages.map(_._2)
val words = lines.flatMap(_.split(" "))
val wordCounts = words.map(x => (x, 1)).reduceByKey(_ + _)
wordCounts.print()

ssc.start()             // Start the computation
ssc.awaitTermination()  // Wait for the computation to terminate

------------------
bin/spark-shell --jars \
/opt/cdh-5.3.6/spark-1.3.0-bin-2.5.0-cdh5.3.6/externallibs/spark-streaming-kafka_2.10-1.3.0.jar,/opt/cdh-5.3.6/spark-1.3.0-bin-2.5.0-cdh5.3.6/externallibs/kafka_2.10-0.8.2.1.jar,/opt/cdh-5.3.6/spark-1.3.0-bin-2.5.0-cdh5.3.6/externallibs/kafka-clients-0.8.2.1.jar,/opt/cdh-5.3.6/spark-1.3.0-bin-2.5.0-cdh5.3.6/externallibs/zkclient-0.3.jar,/opt/cdh-5.3.6/spark-1.3.0-bin-2.5.0-cdh5.3.6/externallibs/metrics-core-2.2.0.jar

================UpdataStateByKey===============================
import kafka.serializer.StringDecoder
import org.apache.spark._
import org.apache.spark.streaming._
import org.apache.spark.streaming.StreamingContext._ 
import org.apache.spark.streaming.kafka._

val ssc = new StreamingContext(sc, Seconds(5))
ssc.checkpoint(".")

val kafkaParams = Map[String, String]("metadata.broker.list" -> "hadoop-senior.ibeifeng.com:9092")
val topicsSet = Set("test")

val updateFunc = (values: Seq[Int], state: Option[Int]) => {
	val currentCount = values.sum
	val previousCount = state.getOrElse(0)
	Some(currentCount + previousCount)
}

// read data
val messages = KafkaUtils.createDirectStream[String, String, StringDecoder, StringDecoder](ssc, kafkaParams, topicsSet)

val lines = messages.map(_._2)
val words = lines.flatMap(_.split(" "))
val wordDstream = words.map(x => (x, 1))

val stateDstream = wordDstream.updateStateByKey[Int](updateFunc)

stateDstream.print()

ssc.start()             // Start the computation
ssc.awaitTermination()  // Wait for the computation to terminate


=====================
在scala中，有一个很重要的功能，就是隐式转换
	比如
		A类对象，->通过一个函数将对象转换成另外一个对象   B类对象

/**
   * Return a new "state" DStream where the state for each key is updated by applying
   * the given function on the previous state of the key and the new values of each key.
   * Hash partitioning is used to generate the RDDs with Spark's default number of partitions.
   * @param updateFunc State update function. If `this` function returns None, then
   *                   corresponding state key-value pair will be eliminated.
   * @tparam S State type
   */
  def updateStateByKey[S: ClassTag](
      updateFunc: (Seq[V], Option[S]) => Option[S]
    ): DStream[(K, S)] = ssc.withScope {
    updateStateByKey(updateFunc, defaultPartitioner())
  }
wanghenghengheng
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
大数据｜Spark介绍
因为健忘，所以记点有的没的〒▽〒
05-18 8252
park为了解决以往分布式计算框架存在的一些问题(重复计算、资源共享、系统组合)，提出了一个分布式数据集的抽象数据模型：RDD(Resilient Distributed Datasets)弹性分布式数据集。
Spark的简介
qq_45724328的博客
04-27 6343
1.spark是一门大规模数据处理的同一分析引擎. 2.Spark可以对任意类型的数据进行自定义计算,结构化,半结构化,非结构化的数据都可以进行处理. 3. Hadoop Spark 基础平台, 包含计算, 存储, 调度 纯计算工具（分布式） 海量数据批处理（磁盘迭代计算） 海量数据的批处理（内存迭代计算、交互式计算）、海量数据流计算 对机器要求低, 便宜 对内存有要求 相对较贵 编程范式 Map+Reduce, API 较为底层, 算法适应性差 RDD组成DAG有向无环
Spark简介
lydms的博客
10-22 1万+
部署Spark集群大体上分为两种模式：单机模式与集群模式大多数分布式框架都支持单机模式，方便开发者调试框架的运行环境。
Spark基础入门
热门推荐
桃李不言下自成蹊
12-14 3万+
sparkcore sparksql sparkstreaming structedstreming
Spark大数据分析与实战笔记（第二章 Spark基础-01）
想你依然心痛的博客
01-01 3万+
Spark在2013年加入Apache孵化器项目，之后获得迅猛的发展，并于2014年正式成为Apache软件基金会的顶级项目。Spark生态系统已经发展成为一个可应用于大规模数据处理的统一分析引擎，它是基于内存计算的大数据并行计算框架，适用于各种各样的分布式平台的系统。在Spark生态圈中包含了Spark SQL、Spark Streaming、GraphX、MLlib等组件。如下图所示：Spark Core。
spark简介
难得糊涂
04-23 1万+
序言 Apache Spark 是专为大规模数据处理而设计的快速通用的计算引擎。Spark是UC Berkeley AMP lab (加州大学伯克利分校的AMP实验室)所开源的类Hadoop MapReduce的通用并行框架，Spark，拥有Hadoop MapReduce所具有的优点；但不同于MapReduce的是——Job中间输出结果可以保存在内存中，从而不再需要读写HDFS，因此Spark能更好地适用于数据挖掘与机器学习等需要迭代的MapReduce的算法。 Spark 是一种与 Hadoop 相
Spark Shell 的使用
12-16 3万+
现在我们已经执行了行动操作，执行这些操作需要从磁盘读取数据，Spark在处理这些操作的时候，会把数据缓存起来，后续不管对该RDD执行转换操作还是行动操作，都将直接从内存读取，而不需要和磁盘进行交互。如果数据已经存在外部文件系统，例如本地文件系统，HDFS，HBase，Cassandra，S3 等，可以使用这种方式，即调用 SparkContext 的 textFile 方法，并把文件目录或者路径作为参数。操作，RDD并不会立即缓存，直到执行行动（Action）操作，数据才会真正缓存在内存中。
Spark端口
tangfatter的博客
12-23 5362
一、4040端口 spark任务运行后，会将Driver所在机器绑定到4040端口，提供当前任务的监控页面。 此端口号默认为4040，展示信息如下： 调度器阶段和任务列表 RDD大小和内存使用情况 环境信息 正在运行的executors的信息 演示如下： 通过spark的java接口启动spark SparkConf sc = new SparkConf(); // 创建一个SpakrConf对象用于配置Spark sc.setAppName("name") // 设定程序名字
Spark
upupfeng的博客
05-30 2841
简介 Spark是使用Scala语言编写、基于内存运算的大数据计算框架。 以Spark core为核心，提供了Spark SQL、Spark Streaming、MLlib几大功能组件 中文文档：https://spark.apachecn.org/#/ github地址：https://github.com/apache/spark Spark Core Spark提供了多种资源调度框架，基于内...
spark期末复习资料
06-07
大学生期末复习《spark编程基础（python版）》
spark相关jar包
06-14
Spark是Apache软件基金会下的一个开源大数据处理框架，以其高效、灵活和可扩展的特性而闻名。Spark的核心设计是基于内存计算，它极大地提高了数据处理的速度，使得数据科学家和开发人员能够在处理大规模数据集时获得...
spark-3.5.1-bin-hadoop3.tgz
04-22
Apache Spark 是专为大规模数据处理而设计的快速通用的计算引擎。Spark是UC Berkeley AMP lab (加州大学伯克利分校的AMP实验室)所开源的类Hadoop MapReduce的通用并行框架，Spark，拥有Hadoop MapReduce所具有的优点...
spark3.0入门到精通
04-10
├─Spark-day01 │ 01-[了解]-Spark发展历史和特点介绍.mp4 │ 03-[掌握]-Spark环境搭建-Standalone集群模式.mp4 │ 06-[理解]-Spark环境搭建-On-Yarn-两种模式.mp4 │ 07-[掌握]-Spark环境搭建-On-Yarn-两种...
spark-3.4.3-bin-hadoop3.tgz
04-22
Apache Spark 是专为大规模数据处理而设计的快速通用的计算引擎。Spark是UC Berkeley AMP lab (加州大学伯克利分校的AMP实验室)所开源的类Hadoop MapReduce的通用并行框架，Spark，拥有Hadoop MapReduce所具有的优点...
spark运行报错：Container killed by YARN for exceeding memory limits
linweidong的专栏
07-11 809
通常情况下，Executor 的内存需求可能超过你为其分配的内存，这是因为除了应用程序的堆内存（Heap Memory）之外，还有一些额外的开销，例如操作系统本身、JVM 的非堆内存（如代码缓存、线程栈等）、以及 Spark 的内部开销。在 Spark 中，每个 Executor 进程都会有自己的容器，并且这个容器的内存使用是由 YARN 监控的。如果你确定你的应用程序不会滥用虚拟内存，并且你的节点有足够的交换空间来处理可能的内存溢出，你可以禁用 YARN 的虚拟内存检查，通过设置。
超时导致SparkContext构造失败的问题探究
最新发布
小昌昌的博客
07-14 427
我们线上一个Client模式下运行的Spark Application偶尔发生客户端超时，超时时间达到10min以上。从客户端看到的日志是SparkContext构造时与ApplicationMaster连接超时，似乎是连接问题导致的。后来发现并不是这样。本文详细记录我们对该事故的处理过程和我们总结的一些方法论，顺带介绍了Spark的不同角色之间的通信流程和架构，对整个过程的原理进行了详细探究。
Spark RDD优化
weixin_74292291的博客
07-10 1208
分区优化、持久化优化、依赖优化、共享变量优化、提交模式与运行模式优化、其他优化
Spark-RDD和共享变量
lu070828的博客
07-10 1120
每个Spark应用程序都由一个组成，该驱动程序运行我们编写的main函数，并在集群上执行各种操作。Spark提供的主要抽象是一个弹性分布式数据集，它是一个跨集群节点分区的元素集合，可以并行操作。RDD是通过从Hadoop文件系统（或任何其他Hadoop支持的文件系统）中的文件或中现有的Scala集合开始并转换它来创建的。用户还可以要求Spark在内存中持久化，允许它在并行操作中有效地重用。最后，RDD会自动从节点故障中恢复。Spark中的第二个抽象是可以在并行操作中使用的。
spark中的floor函数
2301_77836489的博客
07-11 508
spark中的floor函数
工信部Spark初级考前辅导.pdf
05-23
本文档是针对大数据应用技术中的Apache Spark进行初级考前辅导的材料。首先，它回顾了Hadoop的基础知识，因为Spark与Hadoop有着密切的关系。Hadoop的核心组件包括Hadoop Distributed File System (HDFS)、MapReduce...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值