spark

　　（1） Hadoop 1.0　　第一代Hadoop，由分布式存储系统HDFS和分布式计算框架MapReduce组成，其中，HDFS由一个NameNode和多个DataNode组成，MapReduce由一个JobTracker和多个TaskTracker组成，对应Hadoop版本为Hadoop 1.x和0.21.X，0.22.x。　　（2） Hadoop 2.0　　第二代Hadoop，为克服Hadoop 1.0中HDFS和MapReduce存在的各种问题而提出的。针对Hadoop 1.0中的单NameNode制约HDFS的扩展性问题，提出了HDFS Federation，它让多个NameNode分管不同的目录进而实现访问隔离和横向扩展；针对Hadoop 1.0中的MapReduce在扩展性和多框架支持方面的不足，提出了全新的资源管理框架YARN(Yet Another Resource Negotiator)，它将JobTracker中的资源管理和作业控制功能分开，分别由组件ResourceManager和ApplicationMaster实现，其中，ResourceManager负责所有应用程序的资源分配，而ApplicationMaster仅负责管理一个应用程序。对应Hadoop版本为Hadoop 0.23.x和2.x。　　（3） MapReduce 1.0或者MRv1（MapReduceversion 1）　　第一代MapReduce计算框架，它由两部分组成：编程模型（programming model）和运行时环境（runtime environment）。它的基本编程模型是将问题抽象成Map和Reduce两个阶段，其中Map阶段将输入数据解析成key/value，迭代调用map()函数处理后，再以key/value的形式输出到本地目录，而Reduce阶段则将key相同的value进行规约处理，并将最终结果写到HDFS上。它的运行时环境由两类服务组成：JobTracker和TaskTracker，其中，JobTracker负责资源管理和所有作业的控制，而TaskTracker负责接收来自JobTracker的命令并执行它。　　（4）MapReduce 2.0或者MRv2（MapReduce version 2）或者NextGen MapReduc　　MapReduce 2.0或者MRv2具有与MRv1相同的编程模型，唯一不同的是运行时环境。MRv2是在MRv1基础上经加工之后，运行于资源管理框架YARN之上的MRv1，它不再由JobTracker和TaskTracker组成，而是变为一个作业控制进程ApplicationMaster，且ApplicationMaster仅负责一个作业的管理，至于资源的管理，则由YARN完成。　　简而言之，MRv1是一个独立的离线计算框架，而MRv2则是运行于YARN之上的MRv1。　　（5）Hadoop-MapReduce（一个离线计算框架）　　Hadoop是google分布式计算框架MapReduce与分布式存储系统GFS的开源实现，由分布式计算框架MapReduce和分布式存储系统HDFS（Hadoop Distributed File System）组成，具有高容错性，高扩展性和编程接口简单等特点，现已被大部分互联网公司采用。　　（6）Hadoop-YARN(Hadoop 2.0的一个分支，实际上是一个资源管理系统)　　YARN是Hadoop的一个子项目（与MapReduce并列），它实际上是一个资源统一管理系统，可以在上面运行各种计算框架（包括MapReduce、Spark、Storm、MPI等）。　　　　当前Hadoop版本比较混乱，让很多用户不知所措。实际上，当前Hadoop只有两个版本：Hadoop 1.0和Hadoop 2.0，其中，Hadoop 1.0由一个分布式文件系统HDFS和一个离线计算框架MapReduce组成，而Hadoop 2.0则包含一个支持NameNode横向扩展的HDFS，一个资源管理系统YARN和一个运行在YARN上的离线计算框架MapReduce。相比于Hadoop 1.0，Hadoop 2.0功能更加强大，且具有更好的扩展性、性能，并支持多种计算框架。　　　　Borg/YARN/Mesos/Torca/Corona一类系统可以为公司构建一个内部的生态系统，所有应用程序和服务可以“和平而友好”地运行在该生态系统上。有了这类系统之后，你不必忧愁使用Hadoop的哪个版本，是Hadoop 0.20.2还是 Hadoop 1.0，你也不必为选择何种计算模型而苦恼，因此各种软件版本，各种计算模型可以一起运行在一台“超级计算机”上了。　　从开源角度看，YARN的提出，从一定程度上弱化了多计算框架的优劣之争。YARN是在Hadoop MapReduce基础上演化而来的，在MapReduce时代，很多人批评MapReduce不适合迭代计算和流失计算，于是出现了Spark和Storm等计算框架，而这些系统的开发者则在自己的网站上或者论文里与MapReduce对比，鼓吹自己的系统多么先进高效，而出现了YARN之后，则形势变得明朗：MapReduce只是运行在YARN之上的一类应用程序抽象，Spark和Storm本质上也是，他们只是针对不同类型的应用开发的，没有优劣之别，各有所长，合并共处，而且，今后所有计算框架的开发，不出意外的话，也应是在YARN之上。这样，一个以YARN为底层资源管理平台，多种计算框架运行于其上的生态系统诞生了。　　　　目前spark是一个非常流行的内存计算（或者迭代式计算，DAG计算）框架，在MapReduce因效率低下而被广为诟病的今天，spark的出现不禁让大家眼前一亮。　　从架构和应用角度上看，spark是一个仅包含计算逻辑的开发库（尽管它提供个独立运行的master/slave服务，但考虑到稳定后以及与其他类型作业的继承性，通常不会被采用），而不包含任何资源管理和调度相关的实现，这使得spark可以灵活运行在目前比较主流的资源管理系统上，典型的代表是mesos和yarn，我们称之为“spark on mesos”和“spark on yarn”。将spark运行在资源管理系统上将带来非常多的收益，包括：与其他计算框架共享集群资源；资源按需分配，进而提高集群资源利用率等。　　FrameWork On YARN　　运行在YARN上的框架，包括MapReduce-On-YARN, Spark-On-YARN, Storm-On-YARN和Tez-On-YARN。　　（1）MapReduce-On-YARN：YARN上的离线计算；　　（2）Spark-On-YARN：YARN上的内存计算；　　（3）Storm-On-YARN：YARN上的实时/流式计算；　　（4）Tez-On-YARN：YARN上的DAG计算

一、调度器的选择在Yarn中有三种调度器可以选择：FIFO Scheduler，Capacity Scheduler，FairS cheduler。 FIFO Scheduler把应用按提交的顺序排成一个队列，这是一个先进先出队列，在进行资源分配的时候，先给队列中最头上的应用进行分配资源，待最头上的应用需求满足后再给下一个分配，以此类推。 FIFO Scheduler是最简单也是最容易理解的调度器，也不需要任何配置，但它并不适用于共享集群。大的应用可能会占用所有集群资源，这就导致其它应用被阻塞。在共享集群中，更适合采用Capacity Scheduler或Fair Scheduler，这两个调度器都允许大任务和小任务在提交的同时获得一定的系统资源。 下面 “Yarn调度器对比图” 展示了这几个调度器的区别，从图中可以看出，在FIFO 调度器中，小任务会被大任务阻塞。 而对于Capacity调度器，有一个专门的队列用来运行小任务，但是为小任务专门设置一个队列会预先占用一定的集群资源，这就导致大任务的执行时间会落后于使用FIFO调度器时的时间。 在Fair调度器中，我们不需要预先占用一定的系统资源，Fair调度器会为所有运行的job动态的调整系统资源。如下图所示，当第一个大job提交时，只有这一个job在运行，此时它获得了所有集群资源；当第二个小任务提交后，Fair调度器会分配一半资源给这个小任务，让这两个任务公平的共享集群资源。 需要注意的是，在下图Fair调度器中，从第二个任务提交到获得资源会有一定的延迟，因为它需要等待第一个任务释放占用的Container。小任务执行完成之后也会释放自己占用的资源，大任务又获得了全部的系统资源。最终的效果就是Fair调度器即得到了高的资源利用率又能保证小任务及时完成。 Yarn调度器对比图: 二、Capacity Scheduler（容器调度器）的配置 2.1 容器调度介绍 Capacity 调度器允许多个组织共享整个集群，每个组织可以获得集群的一部分计算能力。通过为每个组织分配专门的队列，然后再为每个队列分配一定的集群资源，这样整个集群就可以通过设置多个队列的方式给多个组织提供服务了。除此之外，队列内部又可以垂直划分，这样一个组织内部的多个成员就可以共享这个队列资源了，在一个队列内部，资源的调度是采用的是先进先出(FIFO)策略。 通过上面那幅图，我们已经知道一个job可能使用不了整个队列的资源。然而如果这个队列中运行多个job，如果这个队列的资源够用，那么就分配给这些job，如果这个队列的资源不够用了呢？其实Capacity调度器仍可能分配额外的资源给这个队列，这就是 “弹性队列”(queue elasticity) 的概念。 在正常的操作中，Capacity调度器不会强制释放Container，当一个队列资源不够用时，这个队列只能获得其它队列释放后的Container资源。当然，我们可以为队列设置一个最大资源使用量，以免这个队列过多的占用空闲资源，导致其它队列无法使用这些空闲资源，这就是”弹性队列”需要权衡的地方。 2.2 容器调度的配置 假设我们有如下层次的队列： root ├── prod └── dev ├── eng └── science 下面是一个简单的Capacity调度器的配置文件，文件名为capacity-scheduler.xml。在这个配置中，在root队列下面定义了两个子队列prod和dev，分别占40%和60%的容量。需要注意，一个队列的配置是通过属性yarn.sheduler.capacity..指定的，代表的是队列的继承树，如root.prod队列，一般指capacity和maximum-capacity。 我们可以看到，dev队列又被分成了eng和science两个相同容量的子队列。dev的maximum-capacity属性被设置成了75%，所以即使prod队列完全空闲dev也不会占用全部集群资源，也就是说，prod队列仍有25%的可用资源用来应急。我们注意到，eng和science两个队列没有设置maximum-capacity属性，也就是说eng或science队列中的job可能会用到整个dev队列的所有资源（最多为集群的75%）。而类似的，prod由于没有设置maximum-capacity属性，它有可能会占用集群全部资源。 Capacity容器除了可以配置队列及其容量外，我们还可以配置一个用户或应用可以分配的最大资源数量、可以同时运行多少应用、队列的ACL认证等。 2.3 队列的设置 关于队列的设置，这取决于我们具体的应用。比如，在MapReduce中，我们可以通过mapreduce.job.queuename属性指定要用的队列。如果队列不存在，我们在提交任务时就会收到错误。如果我们没有定义任何队列，所有的应用将会放在一个default队列中。 注意：对于Capacity调度器，我们的队列名必须是队列树中的最后一部分，如果我们使用队列树则不会被识别。比如，在上面配置中，我们使用prod和eng作为队列名是可以的，但是如果我们用root.dev.eng或者dev.eng是无效的。 三、Fair Scheduler（公平调度器）的配置 3.1 公平调度 Fair调度器的设计目标是为所有的应用分配公平的资源（对公平的定义可以通过参数来设置）。在上面的 “Yarn调度器对比图” 展示了一个队列中两个应用的公平调度；当然，公平调度在也可以在多个队列间工作。举个例子，假设有两个用户A和B，他们分别拥有一个队列。当A启动一个job而B没有任务时，A会获得全部集群资源；当B启动一个job后，A的job会继续运行，不过一会儿之后两个任务会各自获得一半的集群资源。如果此时B再启动第二个job并且其它job还在运行，则它将会和B的第一个job共享B这个队列的资源，也就是B的两个job会用于四分之一的集群资源，而A的job仍然用于集群一半的资源，结果就是资源最终在两个用户之间平等的共享。过程如下图所示： 3.2 启用Fair Scheduler 调度器的使用是通过yarn-site.xml配置文件中的yarn.resourcemanager.scheduler.class参数进行配置的，默认采用Capacity Scheduler调度器。如果我们要使用Fair调度器，需要在这个参数上配置FairScheduler类的全限定名：org.apache.hadoop.yarn.server.resourcemanager.scheduler.fair.FairScheduler。 3.3 队列的配置 Fair调度器的配置文件位于类路径下的fair-scheduler.xml文件中，这个路径可以通过yarn.scheduler.fair.allocation.file属性进行修改。若没有这个配置文件，Fair调度器采用的分配策略，这个策略和3.1节介绍的类似：调度器会在用户提交第一个应用时为其自动创建一个队列，队列的名字就是用户名，所有的应用都会被分配到相应的用户队列中。 我们可以在配置文件中配置每一个队列，并且可以像Capacity 调度器一样分层次配置队列。比如，参考capacity-scheduler.xml来配置fair-scheduler： 队列的层次是通过嵌套元素实现的。所有的队列都是root队列的孩子，即使我们没有配到元素里。在这个配置中，我们把dev队列有分成了eng和science两个队列。 Fair调度器中的队列有一个权重属性（这个权重就是对公平的定义），并把这个属性作为公平调度的依据。在这个例子中，当调度器分配集群40:60资源给prod和dev时便视作公平，eng和science队列没有定义权重，则会被平均分配。这里的权重并不是百分比，我们把上面的40和60分别替换成2和3，效果也是一样的。注意，对于在没有配置文件时按用户自动创建的队列，它们仍有权重并且权重值为1。 每个队列内部仍可以有不同的调度策略。队列的默认调度策略可以通过顶级元素进行配置，如果没有配置，默认采用公平调度。 尽管是Fair调度器，其仍支持在队列级别进行FIFO调度。每个队列的调度策略可以被其内部的元素覆盖，在上面这个例子中，prod队列就被指定采用FIFO进行调度，所以，对于提交到prod队列的任务就可以按照FIFO规则顺序的执行了。需要注意，prod和dev之间的调度仍然是公平调度，同样eng和science也是公平调度。 尽管上面的配置中没有展示，每个队列仍可配置最大、最小资源占用数和最大可运行的应用的数量。 3.4 队列的设置 Fair调度器采用了一套基于规则的系统来确定应用应该放到哪个队列。在上面的例子中，元素定义了一个规则列表，其中的每个规则会被逐个尝试直到匹配成功。例如，上例第一个规则specified，则会把应用放到它指定的队列中，若这个应用没有指定队列名或队列名不存在，则说明不匹配这个规则，然后尝试下一个规则。primaryGroup规则会尝试把应用放在以 用户所在的Unix组名 命名的队列中，如果没有这个队列，不创建队列转而尝试下一个规则。当前面所有规则不满足时，则触发default规则，把应用放在dev.eng队列中。 当然，我们可以不配置queuePlacementPolicy规则，调度器则默认采用如下规则：上面规则可以归结成一句话，除非队列被准确的定义，否则会以用户名为队列名创建队列。 还有一个简单的配置策略可以使得所有的应用放入同一个队列（default），这样就可以让所有应用之间平等共享集群而不是在用户之间。这个配置的定义如下：实现上面功能我们还可以不使用配置文件，直接设置yarn.scheduler.fair.user-as-default-queue=false，这样应用便会被放入default 队列，而不是各个用户名队列。另外，我们还可以设置yarn.scheduler.fair.allow-undeclared-pools=false，这样用户就无法创建队列了。 3.5 抢占（Preemption） 当一个job提交到一个繁忙集群中的空队列时，job并不会马上执行，而是阻塞直到正在运行的job释放系统资源。为了使提交job的执行时间更具预测性（可以设置等待的超时时间），Fair调度器支持抢占。 抢占就是允许调度器杀掉占用超过其应占份额资源队列的containers，这些containers资源便可被分配到应该享有这些份额资源的队列中。需要注意抢占会降低集群的执行效率，因为被终止的containers需要被重新执行。 可以通过设置一个全局的参数yarn.scheduler.fair.preemption=true来启用抢占功能。此外，还有两个参数用来控制抢占的过期时间（这两个参数默认没有配置，需要至少配置一个来允许抢占Container）： - minimum share preemption timeout - fair share preemption timeout 如果队列在minimum share preemption timeout指定的时间内未获得最小的资源保障，调度器就会抢占containers。我们可以通过配置文件中的顶级元素为所有队列配置这个超时时间；我们还可以在元素内配置元素来为某个队列指定超时时间。 与之类似，如果队列在fair share preemption timeout指定时间内未获得平等的资源的一半（这个比例可以配置），调度器则会进行抢占containers。这个超时时间可以通过顶级元素和元素级元素分别配置所有队列和某个队列的超时时间。上面提到的比例可以通过(配置所有队列)和(配置某个队列)进行配置，默认是0.5。

你好！ A sparkling crystal ball appears on the roof of 1 times square一个闪闪发光的水晶球出现在时报广场1号楼的屋顶

SQLContext具体的执行过程如下：（1）SQL | HQL语句经过SqlParse解析成UnresolvedLogicalPlan。（2）使用analyzer结合数据字典（catalog）进行绑定，生成resolvedLogicalPlan，在这个过程中，Catalog提取出SchemRDD，并注册类似case class的对象，然后把表注册进内存中。（3）Analyzed Logical Plan经过Catalyst Optimizer优化器优化处理后，生成Optimized Logical Plan，该过程完成以后，以下的部分在Spark core中完成。（4）Optimized Logical Plan的结果交给SparkPlanner，然后SparkPlanner处理后交给PhysicalPlan，经过该过程后生成Spark Plan。（5）使用SparkPlan将LogicalPlan转换成PhysicalPlan。（6）使用prepareForExecution()将PhysicalPlan转换成可执行物理计划。（7）使用execute()执行可执行物理计划。（8）生成DataFrame。登录后复制在整个运行过程中涉及到多个SparkSQL的组件，如SqlParse、analyzer、optimizer、SparkPlan等等某电商平台，需要对订单数据进行分析，已知订单数据包括两个文件，分别为订单数据orders和订单明细数据order_items，orders记录了用户购买商品的订单ID，订单号，用户ID及下单日期。order_items记录了商品ID，订单ID以及明细ID。它们的结构与关系如下图所示：orders表：（order_id,order_number,buyer_id,create_dt）订单ID 订单号 用户ID 下单日期 52304 111215052630 176474 2011-12-15 04:58:21 52303 111215052629 178350 2011-12-15 04:45:31 52302 111215052628 172296 2011-12-15 03:12:23 52301 111215052627 178348 2011-12-15 02:37:32 52300 111215052626 174893 2011-12-15 02:18:56 52299 111215052625 169471 2011-12-15 01:33:46 52298 111215052624 178345 2011-12-15 01:04:41 52297 111215052623 176369 2011-12-15 01:02:20 52296 111215052622 178343 2011-12-15 00:38:02 52295 111215052621 178342 2011-12-15 00:18:43 order_items表：（item_id,order_id,goods_id ）明细ID 订单ID 商品ID 252578 52293 1016840 252579 52293 1014040 252580 52294 1014200 252581 52294 1001012 252582 52294 1022245 252583 52294 1014724 252584 52294 1010731 252586 52295 1023399 252587 52295 1016840 252592 52296 1021134 252593 52296 1021133 252585 52295 1021840 252588 52295 1014040 252589 52296 1014040 252590 52296 1019043 登录后复制创建orders表和order_items表，并统计该电商网站都有哪些用户购买了什么商品。操作在spark-shell下，使用case class方式定义RDD，创建orders表val sqlContext = new org.apache.spark.sql.SQLContext(sc) import sqlContext.implicits._ case class Orders(order_id:String,order_number:String,buyer_id:String,create_dt:String) val dforders = sc.textFile("/myspark5/orders").map(_.split(" ")).map(line=>Orders(line(0),line(1),line(2),line(3))).toDF() dforders.registerTempTable("orders") 登录后复制验证创建的表是否成功。sqlContext.sql("show tables").map(t=>"tableName is:"+t(0)).collect().foreach(println) sqlContext.sql("select order_id,buyer_id from orders").collect 登录后复制在Spark Shell下，使用applyScheme方式定义RDD，创建order_items表。import org.apache.spark.sql._ import org.apache.spark.sql.types._ val rddorder_items = sc.textFile("/myspark5/order_items") val roworder_items = rddorder_items.map(_.split(" ")).map( p=>Row(p(0),p(1),p(2) ) ) val schemaorder_items = "item_id order_id goods_id" val schema = StructType(schemaorder_items.split(" ").map(fieldName=>StructField(fieldName,StringType,true)) ) val dforder_items = sqlContext.applySchema(roworder_items, schema) dforder_items.registerTempTable("order_items") 登录后复制验证创建表是否成功sqlContext.sql("show tables").map(t=>"tableName is:"+t(0)).collect().foreach(println) sqlContext.sql("select order_id,goods_id from order_items ").collect 登录后复制将order表及order_items表进行join操作，统计该电商网站，都有哪些用户购买了什么商品sqlContext.sql("select orders.buyer_id, order_items.goods_id from order_items join orders on order_items.order_id=orders.order_id ").collect登录后复制Spark SQLspark-sql创建表orders及表order_items。create table orders (order_id string,order_number string,buyer_id string,create_dt string) row format delimited fields terminated by " " stored as textfile; create table order_items(item_id string,order_id string,goods_id string) row format delimited fields terminated by " " stored as textfile; 登录后复制查看已创建的表。show tables; 登录后复制表名后的false意思是该表不是临时表。将HDFS中/myspark5下的orders表和order_items表中数据加载进刚创建的两个表中。load data inpath "/myspark5/orders" into table orders; load data inpath "/myspark5/order_items" into table order_items; 登录后复制14.验证数据是否加载成功。select * from orders; select * from order_items; 登录后复制15.处理文件，将order表及order_items表进行join操作，统计该电商网站，都有哪些用户购买了什么商品。

你网址输入的不对！！http://www.sparke.cn知道错在哪里了吧？？

学编程的人不要以为一辈子只能打代码，你们有很多我们一辈子比不上的优势基本功我的许多下属被我的手下调到管理部门，他们中的一些人开始沉默寡言，沉默寡言，没有人觉得他们会管理，但姐把这类人培养成严谨甚至冷血的干将工作忙没多少时间，之前没有多少编程基础，数学仅仅停留在大学的概率论，英语不好看英文版会疯，所以这份书单很适合时间不多，数学没基础，看不懂英文的朋友，这本书就是《spark快速大数据分析》。200页左右，很适合初学者。提升有一个笑话是没有详细说明的，因为这本书不是一本关于火花的入门书，是一本应用书，很多情况需要跟踪，姐当时零基础想学数据分析，是逆推回去学的，从复习高数概率论到机器学习入门，再慢慢熟悉spark然后深入研究机器学习，都是利用下班空闲时间做的。这本书就是《spark高级数据分析》官方版一定要阅读官方文件。官方文件很好，比大多数都好。spark更新太快了，市面上书都是基于spark1.2以前的版本，而最新的1.4和以前的版本已经有了相当大的改变。尤其是dataframe，mllib，改动非常大。我的同事写了一本书，但他推荐我去看官方文件。由于spark的更新速度非常快，所以需要半年的时间才能完成写作，而且很多内容需要更新。

spark：触发 发动 鼓舞 正常运转 火花remains：遗骨，遗体，残骸，残余，遗迹; 废墟，遗址，遗迹，剩余（物），余额; 仍然是; 保持; 留下( remain 的第三人称单数); 留待

平行宇宙里面未来的思帕克

仅在语义上有细微差别。spark sth off：be the immediate cause of (usu sth bad); lead to sth 直接导致（尤指坏事）; 引发某事。这个off不能省略，且强调了【尤指坏事】。trigger （off）：be the cause of a sudden (often) violent reaction; set an action or a process in motion成为突然发生的（常为激烈的）反应的原因; 发动; 引发。这个off是可以且常常省略的，且强调【引发的是本来就很紧张的情况】，可参考成语【一触即发】。并且不一定就是【坏事】，不带明显感情色彩。结论：语义上有差别，不能同等替换。

仅在语义上有细微差别。spark sth off：be the immediate cause of (usu sth bad); lead to sth 直接导致（尤指坏事）; 引发某事。这个off不能省略，且强调了【尤指坏事】。trigger （off）：be the cause of a sudden (often) violent reaction; set an action or a process in motion成为突然发生的（常为激烈的）反应的原因; 发动; 引发。这个off是可以且常常省略的，且强调【引发的是本来就很紧张的情况】，可参考成语【一触即发】。并且不一定就是【坏事】，不带明显感情色彩。结论：语义上有差别，不能同等替换。

hadoop包括hdfs、mapreduce、yarn、核心组件。hdfs用于存储，mapreduce用于计算,yarn用于资源管理。spark包括spark sql、saprk mllib、spark streaming、spark 图计算。saprk的这些组件都是进行计算的。spark sql离线计算，spark streaming 流计算，spark mllib机器学习。mpi高性能计算。hahoop只有mapreduce是和spark一样用来计算，要比较的话，只能比较mapreduce与spark区别。mapreduce叠代计算中间结果放在磁盘，适合大数据离线计算。spark技术先进，统一使用rdd,结果可放在内存，pipeline，计算速度比mapreduce快。建议大数据存储使用hadoop的hdfs,资源管理用hadoop的yarn,计算使用spark或mpi

完全分布式HA 服务器规划 技术栈包含 hdfs hive on spark presto doris superset azkaban kafka fluentflume sqoopkettleflink-cdc atlas 禁用swap/selinux 修改 IP/修改主机名/及主机名和 IP 地址的映射 时间同步/设置时区/自动时间同步 关闭防火墙 关闭SELINUX 新建用户 免密登录（先升级openssh） 发送密钥（dw01上执行） 授权 Tencent Kona v8.0.8-GA 腾讯开源的konaJDK，针对大数据场景下优化 解压并重命名至安装地址：/usr/local/java/ zookeeper-3.5.9 解压并重命名至安装地址：/usr/local/zookeeper apache-hadoop-3.1.3 解压至安装地址：/usr/local/hadoop 修改环境变量 /usr/local/zookeeper/conf 启动zookeeper集群（每台执行） 三台服务器启动 格式化namenode（dw01执行） 启动namenode(dw01上执行) 在[nn2]和[nn3]上分别执行，同步 nn1 的元数据信息 启动nn2 nn3，分别执行 所有节点上启动datanode 将[nn1]切换为 Active 查看状态 配置yarn-site.xml 配置mapred-site.xml 分发配置文件，启动yarn(dw03 启动) dw03节点 dw01节点 dw01执行 dw03执行 测试样例 启动脚本 HA切换namenode手动 修改yarn显示log的bug

Fire, 大火；spark: 火花flame： 火焰；火舌

fire 包括火焰,热气,烟雾在内. spark 火星. flame 火焰,火舌.

Jordin Sparks - Freeze 保持的姿势 一个完美的画面 只是让我记得你看着像今晚 随它去吧，现在的日子过去了， 站在黑暗中，我们开灯 今晚我们会否认 这是经过时间 这是你和我也离开 冻结... 目前， 它从来没有这么好过 冻结... 遍 我们不会永远持续下去 你说你很抱歉 推我，然后笑着，当我睁开眼睛 我还是要冻结我们在一起时，一时 保一方平安 过去的事了 走出地认为我们促成作出光雨 在这里，并没有这么软 宽容的感情，我们提出了雨 今晚我们会否认 这是经过时间 这是你和我也离开 冻结... 目前， 它从来没有这么好过 冻结... 遍 我们不会永远持续下去 你说你很抱歉 推我，然后笑着，当我睁开眼睛 我还是要冻结我们在一起时，一时 不要停得知道你得到了什么 即使世界上没有第二次机会在生活中， 不打破它，总得给你带什么 当你.... 冻结... 目前， 它从来没有这么好过 冻结... 遍 我们不会永远持续下去 冻结... 目前， 它从来没有这么好过 冻结... 遍 我们不会永远持续下去 你看着我 随着你眼里的真相 和你不是说好了，你可以去 我要 冻结... 这一刻， 当我们在一起 冻结的时刻。

Spark已经取代Hadoop成为最活跃的开源大数据项目，但是，在选择大数据框架时，企业不能因此就厚此薄彼近日，著名大数据专家Bernard Marr在一篇文章中分析了Spark和 Hadoop 的异同Hadoop和Spark均是大数据框架，都提供了一些执行常见大数据任务的工具，但确切地说，它们所执行的任务并不相同，彼此也并不排斥虽然在特定的情况下，Spark据称要比Hadoop快100倍，但它本身没有一个分布式存储系统而分布式存储是如今许多大数据项目的基础，它可以将 PB 级的数据集存储在几乎无限数量的普通计算机的硬盘上，并提供了良好的可扩展性，只需要随着数据集的增大增加硬盘因此，Spark需要一个第三方的分布式存储，也正是因为这个原因，许多大数据项目都将Spark安装在Hadoop之上，这样，Spark的高级分析应用程序就可以使用存储在HDFS中的数据了与Hadoop相比，Spark真正的优势在于速度，Spark的大部分操作都是在内存中，而Hadoop的MapReduce系统会在每次操作之后将所有数据写回到物理存储介质上，这是为了确保在出现问题时能够完全恢复，但Spark的弹性分布式数据存储也能实现这一点另外，在高级数据处理（如实时流处理、机器学习）方面，Spark的功能要胜过Hadoop在Bernard看来，这一点连同其速度优势是Spark越来越受欢迎的真正原因实时处理意味着可以在数据捕获的瞬间将其提交给分析型应用程序，并立即获得反馈在各种各样的大数据应用程序中，这种处理的用途越来越多，比如，零售商使用的推荐引擎、制造业中的工业机械性能监控Spark平台的速度和流数据处理能力也非常适合机器学习算法，这类算法可以自我学习和改进，直到找到问题的理想解决方案这种技术是最先进制造系统（如预测零件何时损坏）和无人驾驶汽车的核心Spark有自己的机器学习库MLib，而Hadoop系统则需要借助第三方机器学习库，如Apache Mahout实际上，虽然Spark和Hadoop存在一些功能上的重叠，但它们都不是商业产品，并不存在真正的竞争关系，而通过为这类免费系统提供技术支持赢利的公司往往同时提供两种服务例如，Cloudera 就既提供 Spark服务也提供 Hadoop服务，并会根据客户的需要提供最合适的建议Bernard认为，虽然Spark发展迅速，但它尚处于起步阶段，安全和技术支持基础设施方还不发达，在他看来，Spark在开源社区活跃度的上升，表明企业用户正在寻找已存储数据的创新用法

《18小时内掌握Spark》课程模块第1堂课：Spark的架构设计第2堂课：实战使用三种语言开发Spark 第3堂课：快速掌握Scala 第4堂课：Spark集群的安装和设置 第5堂课：编写Spark程序 第6堂课：SparkContext解析和数据加载以及存储第7堂课：深入实战RDD 第8堂课：spark的原理和使用第9堂课：Spark程序的测试第10堂课：Spark的优化第11堂课：Spark的其它主题介绍

spark和hadoop的区别如下：1、诞生的先后顺序：hadoop属于第一代开源大数据处理平台，而spark属于第二代。属于下一代的spark肯定在综合评价上要优于第一代的hadoop。2、计算不同：spark和hadoop在分布式计算的具体实现上，又有区别；hadoop中的mapreduce运算框架，一个运算job，进行一次map-reduce的过程；而spark的一个job中，可以将多个map-reduce过程级联进行。3、平台不同：spark是一个运算平台，而hadoop是一个复合平台（包含运算引擎，还包含分布式文件存储系统，还包含分布式运算的资源调度系统），所以，spark跟hadoop来比较的话，hadoop主要是它的运算部分日渐式微，而spark目前如日中天，相关技术需求量大，offer好拿。4、数据存储：Hadoop的 MapReduce进行计算时，每次产生的中间结果都是存储在本地磁盘中；而Spark在计算时产生的中间结果存储在内存中。5、数据处理：Hadoop在每次执行数据处理时，都需要从磁盘中加载数据，导致磁盘的I/O开销较大；而Spark在执行数据处理时，只需要将数据加载到内存中，之后直接在内存中加载中间结果数据集即可，减少了磁盘的1O开销。

解决问题的层面不一样　　首先，Hadoop和Apache Spark两者都是大数据框架，但是各自存在的目的不尽相同。Hadoop实质上更多是一个分布式数据基础设施: 它将巨大的数据集分派到一个由普通计算机组成的集群中的多个节点进行存储，意味着您不需要购买和维护昂贵的服务器硬件。　　同时，Hadoop还会索引和跟踪这些数据，让大数据处理和分析效率达到前所未有的高度。Spark，则是那么一个专门用来对那些分布式存储的大数据进行处理的工具，它并不会进行分布式数据的存储。　　两者可合可分　　Hadoop除了提供为大家所共识的HDFS分布式数据存储功能之外，还提供了叫做MapReduce的数据处理功能。所以这里我们完全可以抛开Spark，使用Hadoop自身的MapReduce来完成数据的处理。　　相反，Spark也不是非要依附在Hadoop身上才能生存。但如上所述，毕竟它没有提供文件管理系统，所以，它必须和其他的分布式文件系统进行集成才能运作。这里我们可以选择Hadoop的HDFS,也可以选择其他的基于云的数据系统平台。但Spark默认来说还是被用在Hadoop上面的，毕竟，大家都认为它们的结合是最好的。　　以下是天地会珠海分舵从网上摘录的对MapReduce的最简洁明了的解析，其中把人理解成计算机就好了:　　我们要数图书馆中的所有书。你数1号书架，我数2号书架。这就是“Map”。我们人越多，数书就更快。　　现在我们到一起，把所有人的统计数加在一起。这就是“Reduce”。　　Spark数据处理速度秒杀MapReduce　　Spark因为其处理数据的方式不一样，会比MapReduce快上很多。MapReduce是分步对数据进行处理的: ”从集群中读取数据，进行一次处理，将结果写到集群，从集群中读取更新后的数据，进行下一次的处理，将结果写到集群，等等...“ Booz Allen Hamilton的数据科学家Kirk Borne如此解析。　　反观Spark，它会在内存中以接近“实时”的时间完成所有的数据分析：“从集群中读取数据，完成所有必须的分析处理，将结果写回集群，完成，” Born说道。Spark的批处理速度比MapReduce快近10倍，内存中的数据分析速度则快近100倍。　　如果需要处理的数据和结果需求大部分情况下是静态的，且你也有耐心等待批处理的完成的话，MapReduce的处理方式也是完全可以接受的。　　但如果你需要对流数据进行分析，比如那些来自于工厂的传感器收集回来的数据，又或者说你的应用是需要多重数据处理的，那么你也许更应该使用Spark进行处理。　　大部分机器学习算法都是需要多重数据处理的。此外，通常会用到Spark的应用场景有以下方面：实时的市场活动，在线产品推荐，网络安全分析，机器日记监控等。

下面对集中部署模式进行详细介绍 该模式运行任务不会提交在集群中，只在本节点执行，有两种情况 运行该模式非常简单，只需要把Spark的安装包解压后，改一些常用的配置即可使用，而不用启动Spark的Master、Worker守护进程( 只有集群的Standalone方式时，才需要这两个角色)，也不用启动Hadoop的各服务（除非你要用到HDFS）。 Spark不一定非要跑在hadoop集群，可以在本地，起多个线程的方式来指定。将Spark应用以多线程的方式直接运行在本地，一般都是为了方便调试，本地单机模式分三类： 搭建步骤： （中间有报错：raise IllegalArgumentException(s.split(": ", 1)[1], stackTrace) pyspark.sql.utils.IllegalArgumentException: u"Unable to locate hive jars to connect to metastore. Please set spark.sql.hive.metastore.jars."，网上提示查看jdk版本，发现ubuntu 18.04默认是openjdk-11-jdk包(java -version提示10.0.1)。重新安装openjdk-8-jdk版本不报错） 运行： 使用spark-shell、spark-submit、pyspark 例如使用spark-shell： local：单机、单核运行 local[k]:启动k个executor local[ ]：启动跟cpu数目相同的 executor* 上述情况中，local[N]与local[*]相当于用单机的多个线程来模拟spark分布式计算，通常用来检验开发出来的程序逻辑上有没有问题。 其中N代表可以使用N个线程，每个线程拥有一个core。 这些任务的线程，共享在一个进程中，可以开到，在程序的执行过程中只会产生一个进程，这个进程揽下了所有的任务，既是客户提交任务的client进程，又是spark的driver程序，还是spark执行task的executor 这种运行模式，和Local[N]很像，不同的是，它会在单机启动多个进程来模拟集群下的分布式场景，而不像Local[N]这种多个线程只能在一个进程下委屈求全的共享资源。通常也是用来验证开发出来的应用程序逻辑上有没有问题，或者想使用Spark的计算框架而没有太多资源。 用法：提交应用程序时使用local-cluster[x,y,z]参数：x代表要生成的executor数，y和z分别代表每个executor所拥有的core和memory数。 上面这条命令代表会使用2个executor进程，每个进程分配3个core和1G的内存，来运行应用程序。可以看到，在程序执行过程中，会生成如下几个进程：

Flink 和 Spark 都是基于内存计算、支持实时/批处理等多种计算模式的统一框架 Spark的技术理念是使用微批来模拟流的计算,基于Micro-batch,数据流以时间为单位被切分为一个个批次,通过分布式数据集RDD进行批量处理,是一种伪实时。 而Flink是基于事件驱动的，它是一个面向流的处理框架, Flink基于每个事件一行一行地流式处理，是真正的流式计算. 另外他也可以基于流来模拟批进行计算实现批处理,所以他在技术上具有更好的扩展性,未来可能会成为一个统一的大数据处理引擎 因为他们技术理念的不同,也就导致了性能相关的指标的差别,spark是基于微批的,而且流水线优化做的很好,所以说他的吞入量是最大的,但是付出了延迟的代价,它的延迟是秒级;而Flink是基于事件的,消息逐条处理,而且他的容错机制很轻量级,所以他能在兼顾高吞吐量的同时又有很低的延迟,它的延迟能够达到毫秒级; SparkStreaming只支持处理时间, 折中地使用processing time来近似地实现event time相关的业务。显然，使用processing time模拟event time必然会产生一些误差， 特别是在产生数据堆积的时候，误差则更明显，甚至导致计算结果不可用 Structured streaming 支持处理时间和事件时间，同时支持 watermark 机制处理滞后数据 Flink 支持三种时间机制：事件时间，注入时间，处理时间，同时支持 watermark 机制处理迟到的数据,说明Flink在处理乱序大实时数据的时候,优势比较大 其实和Kafka结合的区别还是跟他们的设计理念有关,SparkStreaming是基于微批处理的,所以他采用DirectDstream的方式根据计算出的每个partition要取数据的Offset范围,拉取一批数据形成Rdd进行批量处理,而且该Rdd和kafka的分区是一一对应的; Flink是真正的流处理,他是基于事件触发机制进行处理,在KafkaConsumer拉取一批数据以后,Flink将其经过处理之后变成,逐个Record发送的事件触发式的流处理 另外,Flink支持动态发现新增topic或者新增partition,而SparkStreaming和0.8版本的kafka结合是不支持的,后来跟0.10版本的kafka结合的时候,支持了,看了源码;

Apache Spark是一个基于内存计算的开源的集群计算系统，目的是让数据分析更加快速。Spark非常小巧玲珑，由加州伯克利大学AMP实验室的Matei为主的小团队所开发。使用的语言是Scala，项目的core部分的代码只有63个Scala文件，非常短小精悍。Apache Spark的5大优势：1.更高的性能，因为数据被加载到集群主机的分布式内存中。数据可以被快速的转换迭代，并缓存用以后续的频繁访问需求。很多对Spark感兴趣的朋友可能也会听过这样一句话——在数据全部加载到内存的情况下，Spark可以比Hadoop快100倍，在内存不够存放所有数据的情况下快Hadoop 10倍。2.通过建立在Java、Scala、Python、SQL(应对交互式查询)的标准API以方便各行各业使用，同时还含有大量开箱即用的机器学习库。3.与现有Hadoop v1 (SIMR) 和2.x (YARN) 生态兼容，因此机构可以进行无缝迁移。4.方便下载和安装。方便的shell(REPL: Read-Eval-Print-Loop)可以对API进行交互式的学习。5.借助高等级的架构提高生产力，从而可以讲精力放到计算上。同时，Apache Spark由Scala实现，代码非常简洁。

随着大数据集群的使用，大数据的安全受到越来越多的关注一个安全的大数据集群的使用，运维必普通的集群更为复杂。 集群的安全通常基于kerberos集群完成安全认证。kerberos基本原理可参考 ：一张图了解Kerberos访问流程 Spark应用(On Yarn模式下)在安全的hadoop集群下的访问，需要访问各种各样的组件/进程，如ResourceManager，NodeManager，NameNode，DataNode,Kafka,Hmaster,HregionServer，MetaStore等等。尤其是在长时运行的应用，如sparkStreaming，StructedStreaming，如何保证用户认证后的长期有效性，其安全/认证更为复杂。 一个Spark应用提交用户要先在kdc中完成用户的认证，及拿到对应service服务的票据之后才能访问对应的服务。由于Spark应用运行时涉及yarnclient，driver，applicationMaster，executor等多个服务，这其中每个进程都应当是同一个用户启动并运行，这就涉及到多个进程中使用同一个用户的票据来对各种服务进行访问，本文基于Spark2.3对此做简要分析。 spark应用的提交用户认证之后才能提交应用，所以在yarnclient/driver的逻辑中必然会执行到kerberos认证相关的登录认证。然而其他的进程如applicationMaster，executor等均需要经过认证，应用提交后才由用户启动，这些进程则可以不进行kerberos认证而是利用Hadoop的token机制完成认证，减小kerberos服务压力，同时提高访问效率。 Hadoop的token实现基类为org.apache.hadoop.security.token.Token， 不同的服务也可hadoop的token来交互，只要使用不同的identifer来区分token即可。 如NMTokenIdentifier, AMRMTokenIdentifier,AuthenticationTokenIdentifier等不同的tokenIdentifier来区分不同的服务类型的token。 此处yarnclient指的是向ResourceManager提交yarn应用的客户端。在spark中，向yarn提交应用有两种应用有yarn-client,yarn-cluster模式。在这两种应用模式下提交应用，yarn client逻辑有些许不同。 安全hadoop场景下spark的用户登录认证机制 在client的submitApplication方法中提交app，之后创建amContext，准备本地资源，此时会将本地的文件上传至HDFS，其中就包括keytab文件，同时会生成 spark_conf .properties配置文件以供am使用，该配置文件中会包含keytab的配置 其中的amKeytabFileName是在setUpCredentials时设置如下，该值为指定的keytab文件加上随机的字符串后缀，骑在am重点使用，可参考下节的介绍。 获取相关组件的token，注意：此处的token均非与yarn服务交互相关token，这里只有与HDFS，HBASE，Hive服务交互的token。 } Spark中常访问的服务使用token机制的有hive，hbase，hdfs，对应的tokenProvider如下： 以HbaseDelegationTokenProvider为例，主要是通过反射调用hbase的TokenUtil类的obtainTOken方法，对应的obtainDelegationTokens方法如下： PS ： HBase的token获取的用户需要具有hbase:meta表的exec权限，否则无法成功获取token 在获取token后，将token设置到amContainer中，并放入appContext中 在yarn-client模式下，driver在yarnclient进程中启动，同样需要访问业务层及集群的相关组件如hdfs。driver通过读取am更新在hdfs路径下的credentials文件来保证driver节点的token有效。 在yarn-cluster模式下，driver运行在applicationMaster的JVM中，其安全相关由Am同一操作 applicationMaster是Yarn进行应用调度/管理的核心，需要与RM/NM等进行交互以便应用运行。其中相关的交互均通过token完成认证，认证实现由Yarn内部框架完成。查看am日志发现，即是在非安全（非kerberos）的场景下，同样会使用到token。而与hdfs，hbase等服务交互使用的token则需Spark框架来实现。 在ResourceManager接收到应用提交的ApplicationSubmissionContext后，在其AmLauncher.java的run方法中为am设置生成“YARN_AM_RM_TOKEN，该token用于am于rm通信使用” Am在启动之后，会向ResourceManager申请container，并与对应的NodeManager通信以启动container。然而AM与NM通信的token是如何得到的呢？ 查看AMRMClientImpl类可以看到，AM向RM发送分配请求，RM接收到请求后，将container要分配至的NM节点的Token放置response中返回给AM。Am接收到response后，会保存NMToken，并判定是否需要更新YARN_AM_RM_TOKEN RM通过ApplicationMasterService响应allocation请求 AM在准备启动container时，将当前用户的token都设置进ContainerLaunchContext中 查看Am启动命令大致如下，可以发现有指定配置文件，而该配置文件即为yarnclient生成上传至hdfs，在am启动前由NodeManager从hdfs中copy至本地路径，供container使用： 查看此配置文件可以看到有如下配置项： 下图为am进程使用到的资源文件 如上可以看出，am虽然运行在集群中，但运行时认证相关的资源已经准备就绪。下面分析其运行中关于安全的逻辑 在applicationMaster中，定期更新token，并写入文件到hdfs的相关目录，并清理旧文件以供各executor使用。 在ApplicationMaster启动后，进行login登录并启动名为am-kerberos-renewer的dameon线程定期登录，保证用户认证的有效性 private val ugi = { val original = UserGroupInformation.getCurrentUser() 在am中启动AMCredentialRenewerStarter线程,调度认证登录及token renew逻辑 在scheduleLoginFromKeytab中，会周期调度登录，token获取更新写入hdfs文件等操作。 其核心逻辑如下 调度周期： 调度流程： executor的认证同样使用的是token机制。executor启动之后，根据driver启动设置的${spark.yarn.credentials.file}启动token更新： Executor中的token更新是读取hdfs目录 {timeStamp}-${nextSuffix}目录下的文件，读取到缓存中，以便保证读取到的是更新后的token使用。 Spark框架完成的kerberos认证及使用token与其他服务交互的机制使用较为简单，只需要在提交应用时的spark-submit命令行中加入--principal appuserName --keytab /path/to/user.keytab即可

一直以来，基于Akka实现的RPC通信框架是Spark引以为豪的主要特性，也是与Hadoop等分布式计算框架对比过程中一大亮点，但是时代和技术都在演化，从Spark1.3.1版本开始， 为了解决大块数据（如Shuffle）的传输问题 ，Spark引入了Netty通信框架，到了1.6.0版本，Netty完全取代了Akka，承担Spark内部所有的RPC通信以及数据流传输。 JAVA IO也经历了几次演化，从最早的BIO（阻塞式/非阻塞IO），到1.4版本的NIO（IO复用），到1.7版本的NIO2.0/AIO（异步IO）。 基于早期BIO来实现高并发网络服务器都是依赖多线程来实现，但是线程开销较大，BIO的瓶颈明显，NIO的出现解决了这一大难题， 基于IO复用解决了IO高并发 。 但是NIO有也有几个缺点： 因为这几个原因，促使了很多JAVA-IO通信框架的出现，Netty就是其中一员，它也因为高度的稳定性，功能性，性能等特性，成为Java开发的首选 首先是NIO的上层封装，Netty提供了NioEventLoopGroup / NioSocketChannel / NioServerSocketChannel的组合来完成实际IO操作，继而在此之上实现数据流Pipeline以及EventLoop线程池等功能。 另外它又重写了NIO，JDK-NIO底层是基于Epoll的LT模式来实现，而Netty是基于Epoll的ET模式实现的一组IO操作EpollEventLoopGroup / EpollSocketChannel / EpollServerSocketChannel Netty对两种实现进行完美的封装，可以根据业务的需求来选择不同的实现 从Akka出现背景来说，它是基于Actor的RPC通信系统，它的核心概念也是Message，它是基于协程的，性能不容置疑；基于scala的偏函数，易用性也没有话说，但是它毕竟只是RPC通信，无法适用大的package/stream的数据传输，这也是Spark早期引入Netty的原因。 首先不容置疑的是Akka可以做到的，Netty也可以做到，但是Netty可以做到，Akka却无法做到。原因是啥？在软件栈中，Akka相比Netty要Higher一点，它专门针对RPC做了很多事情，而Netty相比更加基础一点， 可以为不同的应用层通信协议（RPC，FTP，HTTP等）提供支持 ，在早期的Akka版本，底层的NIO通信就是用的Netty。 其次一个优雅的工程师是不会允许一个系统中容纳两套通信框架！最后，虽然Netty没有Akka协程级的性能优势，但是Netty内部高效的Reactor线程模型，无锁化的串行设计，高效的序列化，零拷贝，内存池等特性也保证了Netty不会存在性能问题。 那么Spark是怎么用Netty来取代Akka呢？一句话，利用偏函数的特性，基于Netty“仿造”出一个简约版本的Actor模型。 对于Network通信，不管传输的是序列化后的对象还是文件，在网络上表现的都是字节流。在传统IO中，字节流表示为Stream；在NIO中，字节流表示为ByteBuffer；在Netty中字节流表示为ByteBuff或FileRegion；在Spark中，针对Byte也做了一层包装，支持对Byte和文件流进行处理，即ManagedBuffer； ManagedBuffer包含了三个函数createInputStream()，nioByteBuffer()，convertToNetty()来对Buffer进行“类型转换”，分别获取stream，ByteBuffer，ByteBuff或FileRegion；NioManagedBuffer / NettyManagedBuffer / FileSegmentManagedBuffer也是针对性提供了具体的实现。 更好的理解ManagedBuffer ：比如Shuffle BlockManager模块需要在内存中维护本地executor生成的shuffle-map输出的文件引用，从而可以提供给shuffleFetch进行远程读取，此时文件表示为FileSegmentManagedBuffer，shuffleFetch远程调用FileSegmentManagedBuffer.nioByteBuffer / createInputStream函数从文件中读取为Bytes，并进行后面的网络传输。如果已经在内存中bytes就更好理解了，比如将一个字符数组表示为NettyManagedBuffer。 协议是应用层通信的基础，它提供了应用层通信的数据表示，以及编码和解码的能力。在Spark Network Common中，继承AKKA中的定义，将协议命名为Message，它继承Encodable，提供了encode的能力。 Message根据请求响应可以划分为RequestMessage和ResponseMessage两种；对于Response，根据处理结果，可以划分为Failure和Success两种类型；根据功能的不同，主要划分为Stream，ChunkFetch，Rpc。 Server构建在Netty之上，它提供两种模型NIO和Epoll，可以通过参数（spark.[module].io.mode)进行配置，最基础的module就是shuffle，不同的IOMode选型，对应了Netty底层不同的实现，Server的Init过程中，最重要的步骤就是根据不同的IOModel完成EventLoop和Pipeline的构造 其中，MessageEncoder/Decoder针对网络包到Message的编码和解码，而最为核心就TransportRequestHandler，它封装了对所有请求/响应的处理； TransportChannelHandler内部实现也很简单，它封装了responseHandler和requestHandler，当从Netty中读取一条Message以后，根据判断路由给相应的responseHandler和requestHandler。 Sever提供的RPC，ChunkFecth，Stream的功能都是依赖TransportRequestHandler来实现的；从原理上来说，RPC与ChunkFecth / Stream还是有很大不同的，其中RPC对于TransportRequestHandler来说是功能依赖，而ChunkFecth / Stream对于TransportRequestHandler来说只是数据依赖。 怎么理解？即TransportRequestHandler已经提供了ChunkFecth / Stream的实现，只需要在构造的时候，向TransportRequestHandler提供一个streamManager，告诉RequestHandler从哪里可以读取到Chunk或者Stream。而RPC需要向TransportRequestHandler注册一个rpcHandler，针对每个RPC接口进行功能实现，同时RPC与ChunkFecth / Stream都会有同一个streamManager的依赖，因此注入到TransportRequestHandler中的streamManager也是依赖rpcHandler来实现，即rpcHandler中提供了RPC功能实现和streamManager的数据依赖。 Server是通过监听一个端口，注入rpcHandler和streamManager从而对外提供RPC，ChunkFecth，Stream的服务，而Client即为一个客户端类，通过该类，可以将一个streamId / chunkIndex对应的ChunkFetch请求，streamId对应的Stream请求，以及一个RPC数据包对应的RPC请求发送到服务端，并监听和处理来自服务端的响应；其中最重要的两个类即为TransportClient和TransportResponseHandler分别为上述的“客户端类”和“监听和处理来自服务端的响应"。 那么TransportClient和TransportResponseHandler是怎么配合一起完成Client的工作呢？ 由TransportClient将用户的RPC，ChunkFecth，Stream的请求进行打包并发送到Server端，同时将用户提供的回调函数注册到TransportResponseHandler，TransportResponseHandler是TransportChannelHandler的一部分，在TransportChannelHandler接收到数据包，并判断为响应包以后，将包数据路由到TransportResponseHandler中，在TransportResponseHandler中通过注册的回调函数，将响应包的数据返回给客户端 无论是BlockTransfer还是ShuffleFetch都需要跨executor的数据传输，在每一个executor里面都需要运行一个Server线程（后面也会分析到，对于Shuffle也可能是一个独立的ShuffleServer进程存在）来提供对Block数据的远程读写服务 在每个Executor里面，都有一个BlockManager模块，它提供了对当前Executor所有的Block的“本地管理”，并对进程内其他模块暴露getBlockData(blockId: BlockId): ManagedBuffer的Block读取接口，但是这里GetBlockData仅仅是提供本地的管理功能，对于跨远程的Block传输，则由NettyBlockTransferService提供服务。 NettyBlockTransferService本身即是Server，为其他其他远程Executor提供Block的读取功能，同时它即为Client，为本地其他模块暴露fetchBlocks的接口，支持通过host/port拉取任何Executor上的一组的Blocks。 源码位置 spark-core: org.apache.spark.network.netty NettyBlockTransferService作为一个Server，与Executor或Driver里面其他的服务一样，在进程启动时，由SparkEnv初始化构造并启动服务，在整个运行时的一部分。 一个Server的构造依赖RpcHandler提供RPC的功能注入以及提供streamManager的数据注入。对于NettyBlockTransferService，该RpcHandler即为NettyBlockRpcServer，在构造的过程中，需要与本地的BlockManager进行管理，从而支持对外提供本地BlockMananger中管理的数据 RpcHandler提供RPC的功能注入 在这里还是属于比较“简陋的”，毕竟他是属于数据传输模块，Server中提供的chunkFetch和stream已经足够满足他的功能需要，那现在问题就是怎么从streamManager中读取数据来提供给chunkFetch和stream进行使用呢？ 就是NettyBlockRpcServer作为RpcHandler提供的一个Rpc接口之一：OpenBlocks，它接受由Client提供一个Blockids列表，Server根据该BlockIds从BlockManager获取到相应的数据并注册到streamManager中，同时返回一个StreamID，后续Client即可以使用该StreamID发起ChunkFetch的操作。 从NettyBlockTransferService作为一个Server，我们基本可以推测NettyBlockTransferService作为一个Client支持fetchBlocks的功能的基本方法： 同时，为了提高服务端稳定性，针对fetchBlocks操作NettyBlockTransferService提供了非重试版本和重试版本的BlockFetcher，分别为OneForOneBlockFetcher和RetryingBlockFetcher，通过参数（spark.[module].io.maxRetries)进行配置，默认是重试3次 在Spark，Block有各种类型，可以是ShuffleBlock，也可以是BroadcastBlock等等，对于ShuffleBlock的Fetch，除了由Executor内部的NettyBlockTransferService提供服务以外，也可以由外部的ShuffleService来充当Server的功能，并由专门的ExternalShuffleClient来与其进行交互，从而获取到相应Block数据。功能的原理和实现，基本一致，但是问题来了， 为什么需要一个专门的ShuffleService服务呢？ 主要原因还是为了做到任务隔离，即减轻因为fetch带来对Executor的压力，让其专心的进行数据的计算。 在目前Spark中，也提供了这样的一个AuxiliaryService：YarnShuffleService，但是对于Spark不是必须的，如果你考虑到需要“ 通过减轻因为fetch带来对Executor的压力 ”，那么就可以尝试尝试。 同时，如果启用了外部的ShuffleService，对于shuffleClient也不是使用上面的NettyBlockTransferService，而是专门的ExternalShuffleClient，功能逻辑基本一致！ Akka的通信模型是基于Actor，一个Actor可以理解为一个Service服务对象，它可以针对相应的RPC请求进行处理，如下所示，定义了一个最为基本的Actor： Actor内部只有唯一一个变量（当然也可以理解为函数了），即Receive，它为一个偏函数，通过case语句可以针对Any信息可以进行相应的处理，这里Any消息在实际项目中就是消息包。 另外一个很重要的概念就是ActorSystem，它是一个Actor的容器，多个Actor可以通过name->Actor的注册到Actor中，在ActorSystem中可以根据请求不同将请求路由给相应的Actor。ActorSystem和一组Actor构成一个完整的Server端，此时客户端通过host:port与ActorSystem建立连接，通过指定name就可以相应的Actor进行通信，这里客户端就是ActorRef。所有Akka整个RPC通信系列是由Actor，ActorRef，ActorSystem组成。 Spark基于这个思想在上述的Network的基础上实现一套自己的RPC Actor模型，从而取代Akka。其中RpcEndpoint对应Actor，RpcEndpointRef对应ActorRef，RpcEnv即对应了ActorSystem。 RpcEndpoint与Actor一样，不同RPC Server可以根据业务需要指定相应receive/receiveAndReply的实现，在Spark内部现在有N多个这样的Actor，比如Executor就是一个Actor，它处理来自Driver的LaunchTask/KillTask等消息。 RpcEnv相对于ActorSystem： RpcEndpointRef即为与相应Endpoint通信的引用，它对外暴露了send/ask等接口，实现将一个Message发送到Endpoint中。 这就是新版本的RPC框架的基本功能，它的实现基本上与Akka无缝对接，业务的迁移的功能很小，目前基本上都全部迁移完了。 RpcEnv不仅从外部接口与Akka基本一致，在内部的实现上，也基本差不多，都是按照MailBox的设计思路来实现的； RpcEnv即充当着Server，同时也为Client内部实现。 当作为Server ，RpcEnv会初始化一个Server，并注册NettyRpcHandler。RpcHandler的receive接口负责对每一个请求进行处理，一般情况下，简单业务可以在RpcHandler直接完成请求的处理，但是考虑一个RpcEnv的Server上会挂载了很多个RpcEndpoint，每个RpcEndpoint的RPC请求频率不可控，因此需要对一定的分发机制和队列来维护这些请求，其中Dispatcher为分发器，InBox即为请求队列； 在将RpcEndpoint注册到RpcEnv过程中，也间接的将RpcEnv注册到Dispatcher分发器中，Dispatcher针对每个RpcEndpoint维护一个InBox，在Dispatcher维持一个线程池（线程池大小默认为系统可用的核数，当然也可以通过spark.rpc.netty.dispatcher.numThreads进行配置），线程针对每个InBox里面的请求进行处理。当然实际的处理过程是由RpcEndpoint来完成。 其次RpcEnv也完成Client的功能实现 ，RpcEndpointRef是以RpcEndpoint为单位，即如果一个进程需要和远程机器上N个RpcEndpoint服务进行通信，就对应N个RpcEndpointRef（后端的实际的网络连接是公用，这个是TransportClient内部提供了连接池来实现的），当调用一个RpcEndpointRef的ask/send等接口时候，会将把“消息内容+RpcEndpointRef+本地地址”一起打包为一个RequestMessage，交由RpcEnv进行发送。注意这里打包的消息里面包括RpcEndpointRef本身是很重要的，从而可以由Server端识别出这个消息对应的是哪一个RpcEndpoint。 和发送端一样，在RpcEnv中，针对每个remote端的host:port维护一个队列，即OutBox，RpcEnv的发送仅仅是把消息放入到相应的队列中，但是和发送端不一样的是：在OutBox中没有维护一个所谓的线程池来定时清理OutBox，而是通过一堆synchronized来实现的，add之后立刻消费。 摘自：Github/ColZer

Spark和Hadoop是两个不同的开源大数据处理框架，Spark可以在Hadoop上运行，并且可以替代Hadoop中的某些组件，如MapReduce。但是，Spark和Hadoop并非直接的竞争关系，而是可以协同工作，提高大数据处理的效率和性能。Hadoop是一种分布式存储和计算的框架，可以用来存储和处理大规模数据。其中的HDFS（Hadoop分布式文件系统）用于存储数据，而MapReduce用于进行数据处理。Hadoop已经有十多年的历史，是大数据领域的重要基础架构之一，得到了广泛的应用。Spark是一种通用的大数据处理框架，可以用来进行数据处理、机器学习、图像处理等任务。Spark在计算速度、内存使用效率等方面优于Hadoop的MapReduce，因此在处理大规模数据时具有更高的效率和性能。虽然Spark在某些方面优于Hadoop，但Spark也有一些局限性，例如对于大规模数据的处理效率并不一定比Hadoop更好。此外，Hadoop的生态系统也比Spark更加完善，有更多的组件和工具可供选择。因此，Spark并不会直接取代Hadoop，而是与Hadoop一起使用，以提高大数据处理的效率和性能。Spark和Hadoop可以根据数据的大小、种类、处理方式等因素进行选择和组合，以实现更好的处理效果。

Spark是一个为速度和通用目标设计的集群计算平台。从速度的角度看，Spark从流行的MapReduce模型继承而来，可以更有效地支持多种类型的计算，如交互式查询和流处理。速度在大数据集的处理中非常重要，它可以决定用户可以交互式地处理数据，还是等几分钟甚至几小时。Spark为速度提供的一个重要特性是其可以在内存中运行计算，即使对基于磁盘的复杂应用，Spark依然比MapReduce更有效。从通用性来说，Spark可以处理之前需要多个独立的分布式系统来处理的任务，这些任务包括批处理应用、交互式算法、交互式查询和数据流。通过用同一个引擎支持这些任务，Spark使得合并不同的处理类型变得简单，而合并操作在生产数据分析中频繁使用。而且，Spark降低了维护不同工具的管理负担。

DJI大疆精灵3 SE （Phantom 3 SE）Phantom 3 SE 是 Phantom 3 系列的最新产品，其通过 Wi-Fi 信号与 DJI GO App 连接，图像传输和控制距离远达4公里，支持4k视频录制。配备视觉定位系统，在室内等无 GPS 信号的环境下也能精准悬停，稳定飞行。SPARK-点亮精彩瞬间小身型，大身手。障碍感知结合机器视觉，操控易如反掌。机械云台配以 UltraSmooth，航拍稳定流畅。最高时速 50 公里1，2 公里高清图传2，手掌大小的 “晓” Spark，让你尽享飞行乐趣。1.快速启动开机后 25 秒内准备就绪，放上手掌3开启人脸检测，解锁后启动升空，随时为你拍照。2.简单操控飞行、拍摄、返航，这些原本需要移动设备或遥控器的操作，现在挥挥手也可以完成。3.轻松拍摄只需在移动设备上轻轻一点，即使你从未接触过无人机，也能拍出精彩的航拍视频4.剪辑分享自动剪辑、加入滤镜、套上模板，全在 DJI GO 4 应用实现，并一键在社交网络上分享。

Spark已经取代Hadoop成为最活跃的开源大数据项目，但是，在选择大数据框架时，企业不能因此就厚此薄彼近日，著名大数据专家Bernard Marr在一篇文章中分析了Spark和 Hadoop 的异同Hadoop和Spark均是大数据框架，都提供了一些执行常见大数据任务的工具，但确切地说，它们所执行的任务并不相同，彼此也并不排斥虽然在特定的情况下，Spark据称要比Hadoop快100倍，但它本身没有一个分布式存储系统而分布式存储是如今许多大数据项目的基础，它可以将 PB 级的数据集存储在几乎无限数量的普通计算机的硬盘上，并提供了良好的可扩展性，只需要随着数据集的增大增加硬盘因此，Spark需要一个第三方的分布式存储，也正是因为这个原因，许多大数据项目都将Spark安装在Hadoop之上，这样，Spark的高级分析应用程序就可以使用存储在HDFS中的数据了与Hadoop相比，Spark真正的优势在于速度，Spark的大部分操作都是在内存中，而Hadoop的MapReduce系统会在每次操作之后将所有数据写回到物理存储介质上，这是为了确保在出现问题时能够完全恢复，但Spark的弹性分布式数据存储也能实现这一点另外，在高级数据处理（如实时流处理、机器学习）方面，Spark的功能要胜过Hadoop在Bernard看来，这一点连同其速度优势是Spark越来越受欢迎的真正原因实时处理意味着可以在数据捕获的瞬间将其提交给分析型应用程序，并立即获得反馈在各种各样的大数据应用程序中，这种处理的用途越来越多，比如，零售商使用的推荐引擎、制造业中的工业机械性能监控Spark平台的速度和流数据处理能力也非常适合机器学习算法，这类算法可以自我学习和改进，直到找到问题的理想解决方案这种技术是最先进制造系统（如预测零件何时损坏）和无人驾驶汽车的核心Spark有自己的机器学习库MLib，而Hadoop系统则需要借助第三方机器学习库，如Apache Mahout实际上，虽然Spark和Hadoop存在一些功能上的重叠，但它们都不是商业产品，并不存在真正的竞争关系，而通过为这类免费系统提供技术支持赢利的公司往往同时提供两种服务例如，Cloudera 就既提供 Spark 服务也提供 Hadoop服务，并会根据客户的需要提供最合适的建议Bernard认为，虽然Spark发展迅速，但它尚处于起步阶段，安全和技术支持基础设施方还不发达，在他看来，Spark在开源社区活跃度的上升，表明企业用户正在寻找已存储数据的创新用法

歌曲名:Spark歌手:Morethanever专辑:Give Us Our Hearts BackWordList 21proceed 前进，继续下去，进行procession 行列，队伍process 进程，过程，（生产）工序，（法律）程序procedure 程序，手续，步骤proceeding （会议等的）的过程，公报，诉讼precede 在…之前，先于precedent 先例，惯例preceding 在先的，在前的，在前面的exceed 超出（限度），越出excess 超越，过量，额外的excessive 过度的，过分的，过多的exceeding 过度的，极度的，非常的excessively 过分地，过度地exceedingly 极其，非常concede 让步，认输，承认失败，（不情愿地）承认，允许concession 让步，特许，承认recede 退，退去，缩进recession （经济的）衰退，衰退期access 接近（或进入）的机会，通道，接近accessory 附件，装饰品，同谋predecessor 前任，前辈，前身produce 生产，显示，上演，制作produce （农）产品product 产品，产物，积production 生产，作品，出示producer 生产者，制片人reproduce 复制，繁殖，生殖productive 多产的，富饶的，富有成效的productivity 生产力，生产率professor 教授profess 教授，讲明，表示，承认profession 职业，公开表示professional 职业的，专业的，专业人员confess 坦白，承认confession 自白，坦白，供认manifest 显然的,使显现,证明prophesy 预言prophecy 预言，预言能力prophet 预言，先知progress 前进，进展progress 前进，进展progressive 进步的，前进的，进行式的aggress 侵略aggressive 侵略的,有进取心的congress 代表大会，国会promise 允诺，有…可能，承诺promissory 约定的，约定支付的promising 有希望的，有前途的compromise 妥协，妥协，危及，放弃premise 前提，假设，经营场址pronounce 发音，宣布，宣判pronunciation 发音pronouncement 宣告，声明announce 宣布，声称，预示denounce 谴责，指责，告发proper 适合的，正当的，正派的，固有的，本身的propriety 适当，得体，礼貌，礼仪property 财产，性质，房产appropriate 适当的，侵吞，拨出供专用improper 不适合的impropriety 不适当，不得体inappropriate 不适当的，不侵吞impropriate 把财产据为己有expropriate 没收财产protect 保护，保卫protection 保护，防护protected （受人）保护的protective 保护的，防护的detect 发现，察觉，查明detection 察觉，发觉，侦查detective 侦探，私人侦探architect 建筑师，设计师architecture 建筑学，建筑式样proud 骄傲的（褒），自豪的，傲慢的（贬）pride 自豪，骄傲，自尊，使自豪prove 证明，结果是proof 证据，校样，校对approve 对…进行验证,批准，赞成approval 赞成，同意，批准improve 改进，改善，变得更好improvement 改进，增进，改进处public 公开的，公共的，公众的publish 出版，刊印，公布publication 出版物，出版，公布publicity 公开的，公众的，宣传pub 酒吧，酒馆republic 共和国，共和政体republican 共和政体的,共和党人punish 惩罚，处罚punishment 惩罚，处罚impunity 不受惩罚，免罪penal 刑罚的，刑事的penalty 处罚，惩罚，罚金pure 纯的，纯理论的，完全的purify 使纯净，使纯洁purity 纯净，纯正，纯洁put 放，摆，记下，表达，提出input 输入，把…输入计算机output 产量，输出，输出（信息，数据等）quality 质，品德，优良的quantify 量，数量qualitative （性）质的，定性的quantitative （数）量的,定量的qualify 使符合质量要求quantify 确定…的数量，量化qualify （使）合格，（使）胜任，（使）合适qualification 资格，资格证明，限制question 问题,疑问,难题,询问questionnaire 问卷,征求意见表quest 搜索，寻求，追求request 请求，要求acquire 取得，获得，学到inquire 打听，询问inquiry 打听，调查inquiry 打听，调查require 需要，要求，规定requirement 要求，必要条件acquisition 获得物，增添的人exquisite 精美的，敏锐的，剧烈的requisite 必要的，必需的radio 无线电，无线电广播（台），用无线电传送（或广播）radar 雷达radiant 光辉灿烂的,容光焕发的radiate 辐射，发出（光或热），流露，显示radiation 放射物，辐射radioactive 放射性的，有辐射能的radioactivity 放射性,放射现象radius 半径，半径范围ray 光线，射线X-ray X射线，X光eradicate 连根拔除，根除radical 根本的，基本的，激进分子railway 铁路rail 铁轨，轨道，栏杆，横杆rain 雨，下雨snow 雪，下雪storm 暴风雨，猛攻，怒气冲冲地走wind 风，气息，呼吸rainy 下雨的，多雨的snowy 雪的，多雪的stormy 暴风雨的，多风暴的，激烈的windy 多风的，刮风的raise 举起，提高，筹集，唤起，养育，提出，增加，提升rise 升起，起立，上涨，起义，上涨，兴起arise 出现，由…引起，起身rouse 惊起，唤起，唤醒arouse 引起，激起，唤醒rapid 快的，迅速的，急流rape 强奸（罪），强夺rare 稀有的，稀薄的，珍奇的scarce 缺乏的，不足的，稀少的，罕见的rarely 很少，难得，非常scarcely 几乎不，简直不，决不rate 比率，速度，价格，给…定级rating 等级，收视率，收听率ratio 比，比率rational 理性的，合理的irrational 无理性的，不合理的read 朗读，读懂，读数为，读，阅读，载明reader （人）读者，（物）读本，读物reading 朗读，读物，阅读http://music.baidu.com/song/15047174

Spark 的运行模式有 Local(也称单节点模式），Standalone(集群模式），Spark on Yarn(运行在Yarn上），Mesos以及K8s等常用模式，本文介绍前三种模式。 Spark-shell 参数 Spark-shell 是以一种交互式命令行方式将Spark应用程序跑在指定模式上，也可以通过Spark-submit提交指定运用程序，Spark-shell 底层调用的是Spark-submit,二者的使用参数一致的，通过- -help 查看参数： sparkconf的传入有三种方式： 1.通过在spark应用程序开发的时候用set()方法进行指定 2.通过在spark应用程序提交的时候用过以上参数指定，一般使用此种方式，因为使用较为灵活 3.通过配置spark-default.conf，spark-env.sh文件进行指定，此种方式较shell方式级别低 Local模式 Local 模式是最简单的一种Spark运行方式，它采用单节点多线程（cpu)方式运行，local模式是一种OOTB（开箱即用）的方式，只需要在spark-env.sh导出JAVA_HOME,无需其他任何配置即可使用，因而常用于开发和学习 方式：./spark-shell - -master local[n] ，n代表线程数 Standalone模式 Spark on Yarn on Yarn的俩种模式 客户端的Driver将应用提交给Yarn后，Yarn会先后启动ApplicationMaster和excutor,另外ApplicationMaster和executor都装在在container里运行，container默认的内存是1g，ApplicationMaster分配的内存是driver-memory,executor分配的内存是executor-memory.同时，因为Driver在客户端，所以程序的运行结果可以在客户端显示，Driver以进程名为SparkSubmit的形式存在。 Cluster 模式 1.由client向ResourceManager提交请求，并上传Jar到HDFS上 这期间包括四个步骤: a).连接到RM b).从RM ASM(applicationsManager)中获得metric，queue和resource等信息。 c).upload app jar and spark-assembly jar d).设置运行环境和container上下文 2.ResourceManager向NodeManager申请资源，创建Spark ApplicationMaster（每个SparkContext都有一个ApplicationManager） 3.NodeManager启动Spark App Master，并向ResourceManager ASM注册 4.Spark ApplicationMaster从HDFS中找到jar文件，启动DAGScheduler和YARN Cluster Scheduler 5.ResourceManager向ResourceManager ASM注册申请container资源(INFO YarnClientImpl: Submitted application) 6.ResourceManager通知NodeManager分配Container，这是可以收到来自ASM关于container的报告。(每个container的对应一个executor) 7.Spark ApplicationMaster直接和container(executor)进行交互，完成这个分布式任务。 进入spark安装目录下的conf文件夹 [atguigu@hadoop102 module] mv slaves.template slaves [atguigu@hadoop102 conf] vim slaves hadoop102 hadoop103 hadoop104 4）修改spark-env.sh文件，添加如下配置： [atguigu@hadoop102 conf]$ vim spark-env.sh SPARK_MASTER_HOST=hadoop102 SPARK_MASTER_PORT=7077 5）分发spark包 [atguigu@hadoop102 module] sbin/start-all.sh 注意：如果遇到 “JAVA_HOME not set” 异常，可以在sbin目录下的spark-config.sh 文件中加入如下配置： export JAVA_HOME=XXXX 官方求PI案例 spark-submit --class org.apache.spark.examples.SparkPi --master spark://server-2:7077 --executor-memory 1G --total-executor-cores 2 /home/xxx/software/spark-2.4.4-bin-hadoop2.7/examples/jars/spark-examples_2.11-2.4.4.jar 100 spark-shell --master spark://server-2:7077 --executor-memory 1g --total-executor-cores 2 spark-shell --master spark://server-2:7077 --executor-memory 1g --total-executor-cores 2 参数：--master spark://server-2:7077 指定要连接的集群的master Spark客户端直接连接Yarn，不需要额外构建Spark集群。有yarn-client和yarn-cluster两种模式，主要区别在于：Driver程序的运行节点。 yarn-client：Driver程序运行在客户端，适用于交互、调试，希望立即看到app的输出 yarn-cluster：Driver程序运行在由RM（ResourceManager）启动的AP（APPMaster）适用于生产环境。 安装使用 1）修改hadoop配置文件yarn-site.xml,添加如下内容： 2）修改spark-env.sh，添加如下配置： [atguigu@hadoop102 conf]$ vi spark-env.sh YARN_CONF_DIR=/opt/module/hadoop-2.7.2/etc/hadoop 3）分发配置文件 [atguigu@hadoop102 conf] xsync spark-env.sh 4）执行一个程序 spark-submit --class org.apache.spark.examples.SparkPi --master yarn --deploy-mode client /home/xxx/software/spark-2.4.4-bin-hadoop2.7/examples/jars/spark-examples_2.11-2.4.4.jar 100 注意：在提交任务之前需启动HDFS以及YARN集群。 日志查看 修改配置文件spark-defaults.conf 添加如下内容： spark.yarn.historyServer.address=server-2:18080 spark.history.ui.port=18080 2）重启spark历史服务 [atguigu@hadoop102 spark] sbin/start-history-server.sh starting org.apache.spark.deploy.history.HistoryServer, logging to /opt/module/spark/logs/spark-atguigu-org.apache.spark.deploy.history.HistoryServer-1-hadoop102.out 3）提交任务到Yarn执行 spark-submit --class org.apache.spark.examples.SparkPi --master yarn --deploy-mode client /home/xxx/software/spark-2.4.4-bin-hadoop2.7/examples/jars/spark-examples_2.11-2.4.4.jar 100

LS回复的很经典。。。

Spark作为一个基于内存的分布式计算引擎，其内存管理模块在整个系统中扮演着非常重要的角色。 在执行Spark的应用程序时，Spark集群会启动Driver和Executor两种JVM进程： Spark管理的内存主要划分为4个区域： Executor作为一个JVM进程，它的内存管理建立在JVM的内存管理之上，Spark对JVM的堆内（On-heap）空间进行了更为详细的分配，以充分利用内存。同时，Spark引入了堆外（Off-heap）内存，使之可以直接在工作节点的系统内存中开辟空间，进一步优化了内存的使用。 堆内内存的大小，由 Spark 应用程序启动时的 executor-memory 或 spark.executor.memory 参数配置。Executor 内运行的并发任务共享 JVM 堆内内存，这些任务在缓存 RDD 数据和广播（Broadcast）数据时占用的内存被规划为存储（Storage）内存，而这些任务在执行 Shuffle 时占用的内存被规划为执行（Execution）内存，剩余的部分不做特殊规划，那些 Spark 内部的对象实例，或者用户定义的 Spark 应用程序中的对象实例，均占用剩余的空间。不同的管理模式下，这三部分占用的空间大小各不相同。 Spark 对堆内内存的管理是一种逻辑上的"规划式"的管理，因为对象实例占用内存的申请和释放都由 JVM 完成，Spark 只能在申请后和释放前记录这些内存，我们来看其具体流程： 为了进一步优化内存的使用以及提高 Shuffle 时排序的效率，Spark 引入了堆外（Off-heap）内存，使之可以直接在工作节点的系统内存中开辟空间，存储经过序列化的二进制数据。利用 JDK Unsafe API（从 Spark 2.0 开始），在管理堆外的存储内存时不再基于 Tachyon，而是与堆外的执行内存一样，基于 JDK Unsafe API 实现，Spark 可以直接操作系统堆外内存，减少了不必要的内存开销，以及频繁的 GC 扫描和回收，提升了处理性能。堆外内存可以被精确地申请和释放，而且序列化的数据占用的空间可以被精确计算，所以相比堆内内存来说降低了管理的难度，也降低了误差。 在默认情况下堆外内存并不启用，可通过配置 spark.memory.offHeap.enabled 参数启用，并由 spark.memory.offHeap.size 参数设定堆外空间的大小。除了没有 other 空间，堆外内存与堆内内存的划分方式相同，所有运行中的并发任务共享存储内存和执行内存。 Spark 1.6 之后默认为统一管理（UnifiedMemoryManager）方式，1.6 之前采用的静态管理（StaticMemoryManager）方式仍被保留，可通过配置 spark.memory.useLegacyMode=true 参数启用静态内存管理方式。下面我们介绍下两种内存管理模型的进化。 在 Spark 最初采用的静态内存管理机制下，存储内存、执行内存和其他内存的大小在 Spark 应用程序运行期间均为固定的，但用户可以应用程序启动前进行配置，堆内内存的分配如下所示： Spark 1.6 之后引入的统一内存管理机制，与静态内存管理的区别在于存储内存和执行内存共享同一块空间，可以动态占用对方的空闲区域。如下图所示： 其中最重要的优化在于动态占用机制，其规则如下： 新的版本引入了新的配置项： 凭借统一内存管理机制，Spark 在一定程度上提高了堆内和堆外内存资源的利用率，降低了开发者维护 Spark 内存的难度，但并不意味着开发者可以高枕无忧。譬如，所以如果存储内存的空间太大或者说缓存的数据过多，反而会导致频繁的全量垃圾回收，降低任务执行时的性能，因为缓存的 RDD 数据通常都是长期驻留内存的。所以要想充分发挥 Spark 的性能，需要开发者进一步了解存储内存和执行内存各自的管理方式和实现原理。

我们公司yarn node节点的可用资源配置为：单台node节点可用资源数：核数33cores、内存110G。Hive on Spark任务的基础配置，主要配置对象包括：Executor和Driver内存，Executor配额，任务并行度。 配置参数为spark.executor.memory和spark.executor.cores。如果要最大化使用core，建议将core设置为4、5、6，且满足core的个数尽量可以整除yarn资源核数。yarn资源可用33核，建议spark.executor.cores设置为4，最多剩下一个core，如果设置为5，6都会有3个core剩余。 spark.executor.cores=4，由于总共有33个核，那么最大可以申请的executor数是8。总内存处以8，也即是 110/8，可以得到每个executor约13.75GB内存。 建议 spark.executor.memoryOverhead（spark的executor堆外内存）站总内存的 15%-20%。 那么最终 spark.executor.memoryOverhead=2.75 G 和spark.executor.memory=11 G 注意：默认情况下 spark.executor.memoryOverhead = max(executorMemory * 0.10, 384M)，正常情况下不需要手动设置spark堆外内存，如果spark任务出现如下报错，可以手动提高堆外内存大小。 注意：默认情况下 spark.executor.memoryOverhead = max(executorMemory * 0.10, 384M)，正常情况下不需要手动设置spark堆外内存，如果spark任务出现如下报错，可以手动提高堆外内存大小。 Container killed by YARN for exceeding memory limits. 16.9 GB of 16 GB physical memory used. Consider boosting spark.yarn.executor.memoryOverhead. 对于drvier的内存配置，主要有两个参数： Driver的内存通常来说不设置，或者设置1G左右应该就够了。需要注意的是，如果需要使用collect算子将RDD的数据全部拉取到Driver端进行处理，那么必须确保Driver的内存足够大，否则会出现OOM内存溢出的问题。 配置参数为spark.executor.instances。该参数用于设置Spark作业总共要用多少个Executor进程来执行。 executor的数目是由每个节点运行的executor数目和集群的节点数共同决定。我们离线集群27个节点，那么离线spark任务使用的最大executor数就是 216(27*8). 最大数目可能比这个小点，因为driver也会消耗核数和内存。 该参数可以结合spark.executor.cores设置，默认单个spark任务最大不超过60cores，spark.executor.cores设置为4，则spark.executor.instances不超过15。 设置spark任务的并行度参数为spark.default.parallelism。spark任务每个stage的task个数=max(spark.default.parallelism, HDFS的block数量)。如果不设置该参数，Spark自己根据底层HDFS的block数量来设置task的数量，默认是一个HDFS block对应一个task。spark默认spark.default.parallelism配置较少，如果task个数比较少的话，前面spark资源配置没有意义。官网建议：该参数设置为 num-executors * executor-cores的2~3倍较为合适。 当一个运行时间比较长的spark任务，如果分配给他多个Executor，可是却没有task分配给它，而此时有其他的yarn任务资源紧张，这就造成了很大的资源浪费和资源不合理的调度。动态资源调度就是为了解决这种场景，根据当前应用任务的负载情况，实时的增减Executor个数，从而实现动态分配资源，使整个Spark系统更加健康。 开启spark动态资源分配后，application会在task因没有足够资源被挂起的时候去动态申请资源。当任务挂起或等待spark.dynamicAllocation.schedulerBacklogTimeout(默认1s)的时间后，会开始动态资源分配；之后每隔spark.dynamicAllocation.sustainedSchedulerBacklogTimeout(默认1s)时间申请一次，直到申请到足够的资源。每次申请的资源量是指数增长的，即1,2,4,8等。 当application的executor空闲时间超过spark.dynamicAllocation.executorIdleTimeout（默认60s）后，就会被回收。 使用场景：同一个SQL语句需要同时更新多个分区，类似于如下SQL语句：

首次使用SPARK需要激活，激活晓 SPARK可以通过以下两种方式：1、把移动设备连接至飞行器，通过 DJI GO 4 提示完成激活流程。2、可以点击 DJI GO 4 主界面右上角图标，选择扫描二维码，将移动设备的相机朝向电池仓 SSID 旁的二维码，然后根据 DJI GO 4 的提示完成激活流程。SPARK支持手势控制，无须通过移动设备和遥控器，即可使飞行器掌上起飞/降落。具体如下图所示。

Spark已经取代Hadoop成为最活跃的开源大数据项目，但是，在选择大数据框架时，企业不能因此就厚此薄彼近日，著名大数据专家Bernard Marr在一篇文章中分析了Spark和 Hadoop 的异同Hadoop和Spark均是大数据框架，都提供了一些执行常见大数据任务的工具，但确切地说，它们所执行的任务并不相同，彼此也并不排斥虽然在特定的情况下，Spark据称要比Hadoop快100倍，但它本身没有一个分布式存储系统而分布式存储是如今许多大数据项目的基础，它可以将 PB 级的数据集存储在几乎无限数量的普通计算机的硬盘上，并提供了良好的可扩展性，只需要随着数据集的增大增加硬盘因此，Spark需要一个第三方的分布式存储，也正是因为这个原因，许多大数据项目都将Spark安装在Hadoop之上，这样，Spark的高级分析应用程序就可以使用存储在HDFS中的数据了与Hadoop相比，Spark真正的优势在于速度，Spark的大部分操作都是在内存中，而Hadoop的MapReduce系统会在每次操作之后将所有数据写回到物理存储介质上，这是为了确保在出现问题时能够完全恢复，但Spark的弹性分布式数据存储也能实现这一点另外，在高级数据处理（如实时流处理、机器学习）方面，Spark的功能要胜过Hadoop在Bernard看来，这一点连同其速度优势是Spark越来越受欢迎的真正原因实时处理意味着可以在数据捕获的瞬间将其提交给分析型应用程序，并立即获得反馈在各种各样的大数据应用程序中，这种处理的用途越来越多，比如，零售商使用的推荐引擎、制造业中的工业机械性能监控Spark平台的速度和流数据处理能力也非常适合机器学习算法，这类算法可以自我学习和改进，直到找到问题的理想解决方案这种技术是最先进制造系统（如预测零件何时损坏）和无人驾驶汽车的核心Spark有自己的机器学习库MLib，而Hadoop系统则需要借助第三方机器学习库，如Apache Mahout实际上，虽然Spark和Hadoop存在一些功能上的重叠，但它们都不是商业产品，并不存在真正的竞争关系，而通过为这类免费系统提供技术支持赢利的公司往往同时提供两种服务例如，Cloudera 就既提供 Spark服务也提供 Hadoop服务，并会根据客户的需要提供最合适的建议Bernard认为，虽然Spark发展迅速，但它尚处于起步阶段，安全和技术支持基础设施方还不发达，在他看来，Spark在开源社区活跃度的上升，表明企业用户正在寻找已存储数据的创新用法

Spark的框架使用Scala语言编写的，简洁而优雅； Spark的开发目前主要可以使用三种语言：Scala、Java、Python

有以下四个步骤。1.构建SparkApplication的运行环境（启动SparkContext），SparkContext向资源管理器（可以是Standalone、Mesos或YARN）注册并申请运行Executor资源。2.资源管理器分配Executor资源并启动StandaloneExecutorBackend，Executor运行情况将随着心跳发送到资源管理器上。3.SparkContext构建成DAG图，将DAG图分解成Stage，并把Taskset发送给TaskScheduler。Executor向SparkContext申请Task，TaskScheduler将Task发放给Executor运行同时SparkContext将应用程序代码发放给Executor。4.Task在Executor上运行，运行完毕释放所有资源。ApacheSpark是专为大规模数据处理而设计的快速通用的计算引擎。Spark是UCBerkeleyAMPlab(加州大学伯克利分校的AMP实验室)所开源的类HadoopMapReduce的通用并行框架，Spark，拥有HadoopMapReduce所具有的优点；但不同于MapReduce的是——Job中间输出结果可以保存在内存中，从而不再需要读写HDFS，因此Spark能更好地适用于数据挖掘与机器学习等需要迭代的MapReduce的算法。

介绍 本地模式 Spark单机运行，一般用于开发测试。 Standalone模式 构建一个由Master+Slave构成的Spark集群，Spark运行在集群中。 Spark on Yarn模式 Spark客户端直接连接Yarn。不需要额外构建Spark集群。 Spark on Mesos模式 Spark客户端直接连接Mesos。不需要额外构建Spark集群。 启动方式: spark-shell.sh(Scala) spark-shell通过不同的参数控制采用何种模式进行。 涉及两个参数： 对于Spark on Yarn模式和Spark on Mesos模式还可以通过 –deploy-mode参数控制Drivers程序的启动位置。 进入本地模式： 进入Standalone模式： 备注：测试发现MASTER_URL中使用主机名替代IP地址无法正常连接(hosts中有相关解析记录)，即以下命令连接不成功： ./spark-shell --master spark://ctrl:7077 # 连接失败 Spark on Yarn模式 备注：Yarn的连接信息在Hadoop客户端的配置文件中指定。通过spark-env.sh中的环境变量HADOOPCONFDIR指定Hadoop配置文件路径。 Spark on Mesos模式： 启动方式: pyspark(Python) 参数及用法与Scala语言的spark-shell相同，比如：

Spark作为分布式计算引擎的一颗璀璨之星，继承了MapReduce分布式并行计算的优点，并改进了MapReduce明显的缺陷。MapReduce是基于进程的计算，任务调度和启动开销大。此外Map中间结果要落地到磁盘，网络I/O和磁盘I/O十分频繁，延迟高，处理效率低，无法充分利用内存；Map端和Reduce端均需要排序，耗费时间；不适合迭代计算，交互式处理(数据挖掘)和流式处理(点击日志分析)，无法满足实时性较高的业务。编程不够灵活，因其是用Java编写的，编写一个完整的MapReduce任务代码的数据行数要远远大于Spark实现相同的功能。

和初次见面的女生只有单独两人太过多情 在我选出的Favorite Club角落里你和她 积极地互动中我的目光也就这样停住 看见你的瞬间 oh 直到我能占有你的那天为止 想要诱惑你 让你更想要我 现在关心只围绕著你 I"ll do anything for you Cuz" it"s the fire in your eves 留在我心底深处 但却听不见我隐藏地爱的声音 即使晃动不已也要 告诉我你的到来 虽然你四周有许多带著微笑的女生们 There"s no chance Cuz I"ll dance 一定要给我安慰不要发现我在等你虽然没有任何表情 但我用心感受我悄悄地观察人与人间的关系 现在不要再隐藏心意了 I"ll do anything for you 走向你开启的大门无法和人分享 我努力付出最深的爱 无法放弃 停留在你眼底的人 一定要是我才行就 像停留在我的期待中般 你也要和我一样 Cuz" it"s the fire in your eves 留在我心底深处 但却听不见我隐藏地 爱的声音 即使晃动不已你先到来时 Come on 即使晃动不已也要告诉往我怀里扑来的你

hadoop分布式计算更多释义>>[网络短语]Hadoop Apache Hadoop,大数据分析,工程师hadoop distcp 群间数据同步Hadoop platform Hadoop平台详细用法>>

Application：应用程序 Driver：驱动程序 Deploy mode：应用程序部署模式 Cluster Manager：集群管理器 Worker：工作节点 Executor：执行者 Spark Context job：作业 Stage：阶段 Task：任务

华为云初创扶持计划(Spark)是华为云面向全球初创企业推出的全球性扶持计划，主要目的是帮助和加速科技初创企业/生态伙伴业务成长。符合条件的初创企业，均可申请加入计划并申请免费云资源及专业技术培训和营销权益。华为云通过Spark计划持续赋能初创企业，扩大华为云在全球的影响力，并丰富华为云生态伙伴圈。

2.1.2　在Windows上安装与配置Spark本节介绍在Windows系统上安装Spark的过程。在Windows环境下需要安装Cygwin模拟Linux的命令行环境来安装Spark。（1）安装JDK相对于Linux、Windows的JDK安装更加自动化，用户可以下载安装Oracle JDK或者OpenJDK。只安装JRE是不够的，用户应该下载整个JDK。安装过程十分简单，运行二进制可执行文件即可，程序会自动配置环境变量。（2）安装CygwinCygwin是在Windows平台下模拟Linux环境的一个非常有用的工具，只有通过它才可以在Windows环境下安装Hadoop和Spark。具体安装步骤如下。1）运行安装程序，选择install from internet。2）选择网络最好的下载源进行下载。3）进入Select Packages界面（见图2-2），然后进入Net，选择openssl及openssh。因为之后还是会用到ssh无密钥登录的。另外应该安装“Editors Category”下面的“vim”。这样就可以在Cygwin上方便地修改配置文件。最后需要配置环境变量，依次选择“我的电脑”→“属性”→“高级系统设置”→“环境变量”命令，更新环境变量中的path设置，在其后添加Cygwin的bin目录和Cygwin的usrin两个目录。（3）安装sshd并配置免密码登录1）双击桌面上的Cygwin图标，启动Cygwin，执行ssh-host-config -y命令，出现如图2-3所示的界面。2）执行后，提示输入密码，否则会退出该配置，此时输入密码和确认密码，按回车键。最后出现Host configuration finished.Have fun!表示安装成功。3）输入net start sshd，启动服务。或者在系统的服务中找到并启动Cygwin sshd服务。注意，如果是Windows 8操作系统，启动Cygwin时，需要以管理员身份运行（右击图标，选择以管理员身份运行），否则会因为权限问题，提示“发生系统错误5”。（4）配置SSH免密码登录1）执行ssh-keygen命令生成密钥文件，如图2-4所示。2）执行此命令后，在你的Cygwinhome用户名路径下面会生成.ssh文件夹，可以通过命令ls -a /home/用户名 查看，通过ssh -version命令查看版本。3）执行完ssh-keygen命令后，再执行下面命令，生成authorized_keys文件。cd ~/.ssh/ cp id_dsa.pub authorized_keys 这样就配置好了sshd服务。（5）配置Hadoop修改和配置相关文件与Linux的配置一致，读者可以参照上文Linux中的配置方式，这里不再赘述。（6）配置Spark修改和配置相关文件与Linux的配置一致，读者可以参照上文Linux中的配置方式，这里不再赘述。（7）运行Spark1）Spark的启动与关闭①在Spark根目录启动Spark。./sbin/start-all.sh ②关闭Spark。./sbin/stop-all.sh 2）Hadoop的启动与关闭①在Hadoop根目录启动Hadoop。./sbin/start-all.sh ②关闭Hadoop。./sbin/stop-all.sh 3）检测是否安装成功正常状态下会出现如下内容。-bash-4.1# jps 23526 Jps 2127 Master 7396 NameNode 7594 SecondaryNameNode 7681 ResourceManager 1053 DataNode 31935 NodeManager 1405 Worker 如缺少进程请到logs文件夹下查看相应日志，针对具体问题进行解决。

1. Spark是基于内存的迭代计算框架，适用于需要多次操作特定数据集的应用场合。需要反复操作的次数越多，所需读取的数据量越大，受益越大，数据量小但是计算密集度较大的场合，受益就相对较小;2. 由于RDD的特性，Spark不适用那种异步细粒度更新状态的应用，例如web服务的存储或者是增量的web爬虫和索引。就是对于那种增量修改的应用模型不适合：3. 数据量不是特别大，但是要求实时统计分析需求。

Spark是一个基于内存计算的开源的集群计算系统，目的是让数据分析更加快速。Spark非常小巧玲珑，由加州伯克利大学AMP实验室的Matei为主的小团队所开发。使用的语言是Scala，项目的core部分的代码只有63个Scala文件，非常短小精悍。Spark 是一种与 Hadoop 相似的开源集群计算环境，但是两者之间还存在一些不同之处，这些有用的不同之处使 Spark 在某些工作负载方面表现得更加优越，换句话说，Spark 启用了内存分布数据集，除了能够提供交互式查询外，它还可以优化迭代工作负载。Spark 是在 Scala 语言中实现的，它将 Scala 用作其应用程序框架。与 Hadoop 不同，Spark 和 Scala 能够紧密集成，其中的 Scala 可以像操作本地集合对象一样轻松地操作分布式数据集。尽管创建 Spark 是为了支持分布式数据集上的迭代作业，但是实际上它是对 Hadoop 的补充，可以在 Hadoop 文件系统中并行运行。通过名为Mesos的第三方集群框架可以支持此行为。Spark 由加州大学伯克利分校 AMP 实验室 (Algorithms, Machines, and People Lab) 开发，可用来构建大型的、低延迟的数据分析应用程序。Spark 集群计算架构虽然 Spark 与 Hadoop 有相似之处，但它提供了具有有用差异的一个新的集群计算框架。首先，Spark 是为集群计算中的特定类型的工作负载而设计，即那些在并行操作之间重用工作数据集（比如机器学习算法）的工作负载。为了优化这些类型的工作负载，Spark 引进了内存集群计算的概念，可在内存集群计算中将数据集缓存在内存中，以缩短访问延迟。Spark 还引进了名为弹性分布式数据集(RDD) 的抽象。RDD 是分布在一组节点中的只读对象集合。这些集合是弹性的，如果数据集一部分丢失，则可以对它们进行重建。重建部分数据集的过程依赖于容错机制，该机制可以维护 "血统"（即允许基于数据衍生过程重建部分数据集的信息）。RDD 被表示为一个 Scala 对象，并且可以从文件中创建它；一个并行化的切片（遍布于节点之间）；另一个 RDD 的转换形式；并且最终会彻底改变现有 RDD 的持久性，比如请求缓存在内存中。Spark 中的应用程序称为驱动程序，这些驱动程序可实现在单一节点上执行的操作或在一组节点上并行执行的操作。与 Hadoop 类似，Spark 支持单节点集群或多节点集群。对于多节点操作，Spark 依赖于 Mesos 集群管理器。Mesos 为分布式应用程序的资源共享和隔离提供了一个有效平台。该设置充许 Spark 与 Hadoop 共存于节点的一个共享池中。

Spark是基于内存，是云计算领域的继Hadoop之后的下一代的最热门的通用的并行计算框架开源项目，尤其出色的支持Interactive Query、流计算、图计算等。Spark在机器学习方面有着无与伦比的优势，特别适合需要多次迭代计算的算法。同时Spark的拥有非常出色的容错和调度机制，确保系统的稳定运行，Spark目前的发展理念是通过一个计算框架集合SQL、Machine Learning、Graph Computing、Streaming Computing等多种功能于一个项目中，具有非常好的易用性。目前SPARK已经构建了自己的整个大数据处理生态系统，如流处理、图技术、机器学习、NoSQL查询等方面都有自己的技术，并且是Apache顶级Project，可以预计的是2014年下半年在社区和商业应用上会有爆发式的增长。Spark最大的优势在于速度，在迭代处理计算方面比Hadoop快100倍以上；Spark另外一个无可取代的优势是：“One Stack to rule them all”，Spark采用一个统一的技术堆栈解决了云计算大数据的所有核心问题，这直接奠定了其一统云计算大数据领域的霸主地位；

spark支持c++。根据查询相关资料：Spark的作者们自己重写了一个C++版本的SparkSQL，取名为photon。比原来的SparkSQL快，并且，这是一个闭源项目。技术经验积累够了，该收钱了。

请看下面这张图： 狭义的Hadoop 也就是最初的版本：只有HDFS Map Reduce 后续出现很多存储，计算，管理 框架。 如果说比较的话就 Hadoop Map Reduce 和 Spark 比较，因为他们都是大数据分析的计算框架。 Spark 有很多行组件，功能更强大，速度更快。1、解决问题的层面不一样 首先，Hadoop和Apache Spark两者都是大数据框架，但是各自存在的目的不尽相同。Hadoop实质上更多是一个分布式数据基础设施: 它将巨大的数据集分派到一个由普通计算机组成的集群中的多个节点进行存储，意味着您不需要购买和维护昂贵的服务器硬件。 同时，Hadoop还会索引和跟踪这些数据，让大数据处理和分析效率达到前所未有的高度。Spark，则是那么一个专门用来对那些分布式存储的大数据进行处理的工具，它并不会进行分布式数据的存储。 2、两者可合可分 Hadoop除了提供为大家所共识的HDFS分布式数据存储功能之外，还提供了叫做MapReduce的数据处理功能。所以这里我们完全可以抛开Spark，使用Hadoop自身的MapReduce来完成数据的处理。 相反，Spark也不是非要依附在Hadoop身上才能生存。但如上所述，毕竟它没有提供文件管理系统，所以，它必须和其他的分布式文件系统进行集成才能运作。这里我们可以选择Hadoop的HDFS,也可以选择其他的基于云的数据系统平台。但Spark默认来说还是被用在Hadoop上面的，毕竟，大家都认为它们的结合是最好的。 以下是从网上摘录的对MapReduce的最简洁明了的解析：3、Spark数据处理速度秒杀MapReduce Spark因为其处理数据的方式不一样，会比MapReduce快上很多。MapReduce是分步对数据进行处理的: ”从集群中读取数据，进行一次处理，将结果写到集群，从集群中读取更新后的数据，进行下一次的处理，将结果写到集群，等等…“ Booz Allen Hamilton的数据科学家Kirk Borne如此解析。 反观Spark，它会在内存中以接近“实时”的时间完成所有的数据分析：“从集群中读取数据，完成所有必须的分析处理，将结果写回集群，完成，” Born说道。Spark的批处理速度比MapReduce快近10倍，内存中的数据分析速度则快近100倍。 如果需要处理的数据和结果需求大部分情况下是静态的，且你也有耐心等待批处理的完成的话，MapReduce的处理方式也是完全可以接受的。 但如果你需要对流数据进行分析，比如那些来自于工厂的传感器收集回来的数据，又或者说你的应用是需要多重数据处理的，那么你也许更应该使用Spark进行处理。 大部分机器学习算法都是需要多重数据处理的。此外，通常会用到Spark的应用场景有以下方面：实时的市场活动，在线产品推荐，网络安全分析，机器日记监控等。 4、灾难恢复 两者的灾难恢复方式迥异，但是都很不错。因为Hadoop将每次处理后的数据都写入到磁盘上，所以其天生就能很有弹性的对系统错误进行处理。Spark的数据对象存储在分布于数据集群中的叫做弹性分布式数据集(RDD: Resilient Distributed Dataset)中。这些数据对象既可以放在内存，也可以放在磁盘，所以RDD同样也可以提供完成的灾难恢复功能。

Hadoop是大数据生态系统，是集成了文件存储，文件抽取，批量计算，资源管理等等，而spark设计初衷是实时并行计算，而目前spark可以作为计算引擎嵌入hive，同时解决了批量与实时计算的问题。

（1） Hadoop 1.0第一代Hadoop，由分布式存储系统HDFS和分布式计算框架MapReduce组成，其中，HDFS由一个NameNode和多个DataNode组成，MapReduce由一个JobTracker和多个TaskTracker组成，对应Hadoop版本为Hadoop 1.x和0.21.X，0.22.x。（2） Hadoop 2.0第二代Hadoop，为克服Hadoop 1.0中HDFS和MapReduce存在的各种问题而提出的。针对Hadoop 1.0中的单NameNode制约HDFS的扩展性问题，提出了HDFS Federation，它让多个NameNode分管不同的目录进而实现访问隔离和横向扩展；针对Hadoop 1.0中的MapReduce在扩展性和多框架支持方面的不足，提出了全新的资源管理框架YARN(Yet Another Resource Negotiator)，它将JobTracker中的资源管理和作业控制功能分开，分别由组件ResourceManager和ApplicationMaster实现，其中，ResourceManager负责所有应用程序的资源分配，而ApplicationMaster仅负责管理一个应用程序。对应Hadoop版本为Hadoop 0.23.x和2.x。（3） MapReduce 1.0或者MRv1（MapReduceversion 1）第一代MapReduce计算框架，它由两部分组成：编程模型（programming model）和运行时环境（runtime environment）。它的基本编程模型是将问题抽象成Map和Reduce两个阶段，其中Map阶段将输入数据解析成key/value，迭代调用map()函数处理后，再以key/value的形式输出到本地目录，而Reduce阶段则将key相同的value进行规约处理，并将最终结果写到HDFS上。它的运行时环境由两类服务组成：JobTracker和TaskTracker，其中，JobTracker负责资源管理和所有作业的控制，而TaskTracker负责接收来自JobTracker的命令并执行它。（4）MapReduce 2.0或者MRv2（MapReduce version 2）或者NextGen MapReducMapReduce 2.0或者MRv2具有与MRv1相同的编程模型，唯一不同的是运行时环境。MRv2是在MRv1基础上经加工之后，运行于资源管理框架YARN之上的MRv1，它不再由JobTracker和TaskTracker组成，而是变为一个作业控制进程ApplicationMaster，且ApplicationMaster仅负责一个作业的管理，至于资源的管理，则由YARN完成。简而言之，MRv1是一个独立的离线计算框架，而MRv2则是运行于YARN之上的MRv1。（5）Hadoop-MapReduce（一个离线计算框架）Hadoop是google分布式计算框架MapReduce与分布式存储系统GFS的开源实现，由分布式计算框架MapReduce和分布式存储系统HDFS（Hadoop Distributed File System）组成，具有高容错性，高扩展性和编程接口简单等特点，现已被大部分互联网公司采用。（6）Hadoop-YARN(Hadoop 2.0的一个分支，实际上是一个资源管理系统)YARN是Hadoop的一个子项目（与MapReduce并列），它实际上是一个资源统一管理系统，可以在上面运行各种计算框架（包括MapReduce、Spark、Storm、MPI等）。当前Hadoop版本比较混乱，让很多用户不知所措。实际上，当前Hadoop只有两个版本：Hadoop 1.0和Hadoop 2.0，其中，Hadoop 1.0由一个分布式文件系统HDFS和一个离线计算框架MapReduce组成，而Hadoop 2.0则包含一个支持NameNode横向扩展的HDFS，一个资源管理系统YARN和一个运行在YARN上的离线计算框架MapReduce。相比于Hadoop 1.0，Hadoop 2.0功能更加强大，且具有更好的扩展性、性能，并支持多种计算框架。Borg/YARN/Mesos/Torca/Corona一类系统可以为公司构建一个内部的生态系统，所有应用程序和服务可以“和平而友好”地运行在该生态系统上。有了这类系统之后，你不必忧愁使用Hadoop的哪个版本，是Hadoop 0.20.2还是 Hadoop 1.0，你也不必为选择何种计算模型而苦恼，因此各种软件版本，各种计算模型可以一起运行在一台“超级计算机”上了。从开源角度看，YARN的提出，从一定程度上弱化了多计算框架的优劣之争。YARN是在Hadoop MapReduce基础上演化而来的，在MapReduce时代，很多人批评MapReduce不适合迭代计算和流失计算，于是出现了Spark和Storm等计算框架，而这些系统的开发者则在自己的网站上或者论文里与MapReduce对比，鼓吹自己的系统多么先进高效，而出现了YARN之后，则形势变得明朗：MapReduce只是运行在YARN之上的一类应用程序抽象，Spark和Storm本质上也是，他们只是针对不同类型的应用开发的，没有优劣之别，各有所长，合并共处，而且，今后所有计算框架的开发，不出意外的话，也应是在YARN之上。这样，一个以YARN为底层资源管理平台，多种计算框架运行于其上的生态系统诞生了。目前spark是一个非常流行的内存计算（或者迭代式计算，DAG计算）框架，在MapReduce因效率低下而被广为诟病的今天，spark的出现不禁让大家眼前一亮。从架构和应用角度上看，spark是一个仅包含计算逻辑的开发库（尽管它提供个独立运行的master/slave服务，但考虑到稳定后以及与其他类型作业的继承性，通常不会被采用），而不包含任何资源管理和调度相关的实现，这使得spark可以灵活运行在目前比较主流的资源管理系统上，典型的代表是mesos和yarn，我们称之为“spark on mesos”和“spark on yarn”。将spark运行在资源管理系统上将带来非常多的收益，包括：与其他计算框架共享集群资源；资源按需分配，进而提高集群资源利用率等。FrameWork On YARN运行在YARN上的框架，包括MapReduce-On-YARN, Spark-On-YARN, Storm-On-YARN和Tez-On-YARN。（1）MapReduce-On-YARN：YARN上的离线计算；（2）Spark-On-YARN：YARN上的内存计算；（3）Storm-On-YARN：YARN上的实时/流式计算；（4）Tez-On-YARN：YARN上的DAG计算

科普Spark，Spark是什么，如何使用Spark1.Spark基于什么算法的分布式计算（很简单）2.Spark与MapReduce不同在什么地方3.Spark为什么比Hadoop灵活4.Spark局限是什么5.什么情况下适合使用Spark什么是SparkSpark是UCBerkeleyAMPlab所开源的类HadoopMapReduce的通用的并行计算框架，Spark基于mapreduce算法实现的分布式计算，拥有HadoopMapReduce所具有的优点；但不同于MapReduce的是Job中间输出和结果可以保存在内存中，从而不再需要读写HDFS，因此Spark能更好地适用于数据挖掘与机器学习等需要迭代的mapreduce的算法。其架构如下图所示：Spark与Hadoop的对比Spark的中间数据放到内存中，对于迭代运算效率更高。Spark更适合于迭代运算比较多的ML和DM运算。因为在Spark里面，有RDD的抽象概念。Spark比Hadoop更通用Spark提供的数据集操作类型有很多种，不像Hadoop只提供了Map和Reduce两种操作。比如map,filter,flatMap,sample,groupByKey,reduceByKey,union,join,cogroup,mapValues,sort,partionBy等多种操作类型，Spark把这些操作称为Transformations。同时还提供Count,collect,reduce,lookup,save等多种actions操作。这些多种多样的数据集操作类型，给给开发上层应用的用户提供了方便。各个处理节点之间的通信模型不再像Hadoop那样就是唯一的DataShuffle一种模式。用户可以命名，物化，控制中间结果的存储、分区等。可以说编程模型比Hadoop更灵活。不过由于RDD的特性，Spark不适用那种异步细粒度更新状态的应用，例如web服务的存储或者是增量的web爬虫和索引。就是对于那种增量修改的应用模型不适合。容错性在分布式数据集计算时通过checkpoint来实现容错，而checkpoint有两种方式，一个是checkpointdata，一个是loggingtheupdates。用户可以控制采用哪种方式来实现容错。可用性Spark通过提供丰富的Scala,Java，PythonAPI及交互式Shell来提高可用性。Spark与Hadoop的结合Spark可以直接对HDFS进行数据的读写，同样支持SparkonYARN。Spark可以与MapReduce运行于同集群中，共享存储资源与计算，数据仓库Shark实现上借用Hive，几乎与Hive完全兼容。Spark的适用场景Spark是基于内存的迭代计算框架，适用于需要多次操作特定数据集的应用场合。需要反复操作的次数越多，所需读取的数据量越大，受益越大，数据量小但是计算密集度较大的场合，受益就相对较小（大数据库架构中这是是否考虑使用Spark的重要因素）由于RDD的特性，Spark不适用那种异步细粒度更新状态的应用，例如web服务的存储或者是增量的web爬虫和索引。就是对于那种增量修改的应用模型不适合。总的来说Spark的适用面比较广泛且比较通用。运行模式本地模式Standalone模式Mesoes模式yarn模式Spark生态系统Shark(HiveonSpark):Shark基本上就是在Spark的框架基础上提供和Hive一样的HiveQL命令接口，为了最大程度的保持和Hive的兼容性，Shark使用了Hive的API来实现queryParsing和LogicPlangeneration，最后的PhysicalPlanexecution阶段用Spark代替HadoopMapReduce。通过配置Shark参数，Shark可以自动在内存中缓存特定的RDD，实现数据重用，进而加快特定数据集的检索。同时，Shark通过UDF用户自定义函数实现特定的数据分析学习算法，使得SQL数据查询和运算分析能结合在一起，最大化RDD的重复使用。Sparkstreaming:构建在Spark上处理Stream数据的框架，基本的原理是将Stream数据分成小的时间片断（几秒），以类似batch批量处理的方式来处理这小部分数据。SparkStreaming构建在Spark上，一方面是因为Spark的低延迟执行引擎（100ms+）可以用于实时计算，另一方面相比基于Record的其它处理框架（如Storm），RDD数据集更容易做高效的容错处理。此外小批量处理的方式使得它可以同时兼容批量和实时数据处理的逻辑和算法。方便了一些需要历史数据和实时数据联合分析的特定应用场合。Bagel:PregelonSpark，可以用Spark进行图计算，这是个非常有用的小项目。Bagel自带了一个例子，实现了Google的PageRank算法。End.

Spark采用一个统一的技术堆栈解决了云计算大数据的如流处理、图技术、机器学习、NoSQL查询等方面的所有核心问题，具有完善的生态系统，这直接奠定了其一统云计算大数据领域的霸主地位；要想成为Spark高手，需要经历一下阶段：第一阶段：熟练地掌握Scala语言1， Spark框架是采用Scala语言编写的，精致而优雅。要想成为Spark高手，你就必须阅读Spark的源代码，就必须掌握Scala,；2， 虽然说现在的Spark可以采用多语言Java、Python等进行应用程序开发，但是最快速的和支持最好的开发API依然并将永远是Scala方式的API，所以你必须掌握Scala来编写复杂的和高性能的Spark分布式程序；3， 尤其要熟练掌握Scala的trait、apply、函数式编程、泛型、逆变与协变等；第二阶段：精通Spark平台本身提供给开发者API1， 掌握Spark中面向RDD的开发模式，掌握各种transformation和action函数的使用；2， 掌握Spark中的宽依赖和窄依赖以及lineage机制；3， 掌握RDD的计算流程，例如Stage的划分、Spark应用程序提交给集群的基本过程和Worker节点基础的工作原理等第三阶段：深入Spark内核此阶段主要是通过Spark框架的源码研读来深入Spark内核部分：1， 通过源码掌握Spark的任务提交过程；2， 通过源码掌握Spark集群的任务调度；3， 尤其要精通DAGScheduler、TaskScheduler和Worker节点内部的工作的每一步的细节；第四阶级:掌握基于Spark上的核心框架的使用Spark作为云计算大数据时代的集大成者，在实时流处理、图技术、机器学习、NoSQL查询等方面具有显著的优势，我们使用Spark的时候大部分时间都是在使用其上的框架例如Shark、Spark Streaming等：1， Spark Streaming是非常出色的实时流处理框架，要掌握其DStream、transformation和checkpoint等；2， Spark的离线统计分析功能，Spark 1.0.0版本在Shark的基础上推出了Spark SQL，离线统计分析的功能的效率有显著的提升，需要重点掌握；3， 对于Spark的机器学习和GraphX等要掌握其原理和用法；第五阶级:做商业级别的Spark项目通过一个完整的具有代表性的Spark项目来贯穿Spark的方方面面，包括项目的架构设计、用到的技术的剖析、开发实现、运维等，完整掌握其中的每一个阶段和细节，这样就可以让您以后可以从容面对绝大多数Spark项目。第六阶级：提供Spark解决方案1， 彻底掌握Spark框架源码的每一个细节；

百度词典说　spark　可数名词　 n. [C]spark名词 n. [C]1.火花,火星A cigarette spark started the fire.

熟悉Hadoop的人应该都知道，用户先编写好一个程序，我们称为Mapreduce程序，一个Mapreduce程序就是一个Job，而一个Job里面可以有一个或多个Task，Task又可以区分为Map Task和Reduce Task.　　而在Spark中，也有Job概念，但是这里的Job和Mapreduce中的Job不一样，它不是作业的最高级别的粒度，在它只上还有Application的概念。我们先来看看Spark文档是怎么定义Application，Task ，Job和Stage的：Application：User program built on Spark. Consists of a driver program and executors on the cluster.Task：A unit of work that will be sent to one executorJob：A parallel computation consisting of multiple tasks that gets spawned in response to a Spark action (e.g. save, collect); you"ll see this term used in the driver"s logs.Stage：Each job gets divided into smaller sets of tasks called stages that depend on each other (similar to the map and reduce stages in MapReduce); you"ll see this term used in the driver"s logs.　　一个Application和一个SparkContext相关联，每个Application中可以有一个或多个Job，可以并行或者串行运行Job。Spark中的一个Action可以触发一个Job的运行。在Job里面又包含了多个Stage，Stage是以Shuffle进行划分的。在Stage中又包含了多个Task，多个Task构成了Task Set。　　Mapreduce中的每个Task分别在自己的进程中运行，当该Task运行完的时候，该进程也就结束了。和Mapreduce不一样的是，Spark中多个Task可以运行在一个进程里面，而且这个进程的生命周期和Application一样，即使没有Job在运行。　　这个模型有什么好处呢？可以加快Spark的运行速度！Tasks可以快速地启动，并且处理内存中的数据。但是这个模型有的缺点就是粗粒度的资源管理，每个Application拥有固定数量的executor和固定数量的内存。 这些就是他们之间的区别啦。希望帮到您。

最主要的问题是内存，内存不稳定特别是shuffle阶段内存分配不足容易失败，对数据不均匀比较敏感

1）应用场景不同Hadoop和Spark两者都是大数据框架，但是各自应用场景是不同的。Hadoop是一个分布式数据存储架构，它将巨大的数据集分派到一个由普通计算机组成的集群中的多个节点进行存储，降低了硬件的成本。Spark是那么一个专门用来对那些分布式存储的大数据进行处理的工具，它要借助hdfs的数据存储。2）处理速度不同hadoop的MapReduce是分步对数据进行处理的，从磁盘中读取数据，进行一次处理，将结果写到磁盘，然后在从磁盘中读取更新后的数据，再次进行的处理，最后再将结果存入磁盘，这存取磁盘的过程会影响处理速度。spark从磁盘中读取数据，把中间数据放到内存中，，完成所有必须的分析处理，将结果写回集群，所以spark更快。3）容错性不同Hadoop将每次处理后的数据都写入到磁盘上，基本谈不上断电或者出错数据丢失的情况。Spark的数据对象存储在弹性分布式数据集 RDD，RDD是分布在一组节点中的只读对象集合，如果数据集一部分丢失，则可以根据于数据衍生过程对它们进行重建。而且RDD 计算时可以通过 CheckPoint 来实现容错。

2.1.2　在Windows上安装与配置Spark本节介绍在Windows系统上安装Spark的过程。在Windows环境下需要安装Cygwin模拟Linux的命令行环境来安装Spark。（1）安装JDK相对于Linux、Windows的JDK安装更加自动化，用户可以下载安装Oracle JDK或者OpenJDK。只安装JRE是不够的，用户应该下载整个JDK。安装过程十分简单，运行二进制可执行文件即可，程序会自动配置环境变量。（2）安装CygwinCygwin是在Windows平台下模拟Linux环境的一个非常有用的工具，只有通过它才可以在Windows环境下安装Hadoop和Spark。具体安装步骤如下。1）运行安装程序，选择install from internet。2）选择网络最好的下载源进行下载。3）进入Select Packages界面（见图2-2），然后进入Net，选择openssl及openssh。因为之后还是会用到ssh无密钥登录的。另外应该安装“Editors Category”下面的“vim”。这样就可以在Cygwin上方便地修改配置文件。最后需要配置环境变量，依次选择“我的电脑”→“属性”→“高级系统设置”→“环境变量”命令，更新环境变量中的path设置，在其后添加Cygwin的bin目录和Cygwin的usrin两个目录。（3）安装sshd并配置免密码登录1）双击桌面上的Cygwin图标，启动Cygwin，执行ssh-host-config -y命令，出现如图2-3所示的界面。2）执行后，提示输入密码，否则会退出该配置，此时输入密码和确认密码，按回车键。最后出现Host configuration finished.Have fun!表示安装成功。3）输入net start sshd，启动服务。或者在系统的服务中找到并启动Cygwin sshd服务。注意，如果是Windows 8操作系统，启动Cygwin时，需要以管理员身份运行（右击图标，选择以管理员身份运行），否则会因为权限问题，提示“发生系统错误5”。（4）配置SSH免密码登录1）执行ssh-keygen命令生成密钥文件，如图2-4所示。2）执行此命令后，在你的Cygwinhome用户名路径下面会生成.ssh文件夹，可以通过命令ls -a /home/用户名 查看，通过ssh -version命令查看版本。3）执行完ssh-keygen命令后，再执行下面命令，生成authorized_keys文件。cd ~/.ssh/ cp id_dsa.pub authorized_keys 这样就配置好了sshd服务。（5）配置Hadoop修改和配置相关文件与Linux的配置一致，读者可以参照上文Linux中的配置方式，这里不再赘述。（6）配置Spark修改和配置相关文件与Linux的配置一致，读者可以参照上文Linux中的配置方式，这里不再赘述。（7）运行Spark1）Spark的启动与关闭①在Spark根目录启动Spark。./sbin/start-all.sh ②关闭Spark。./sbin/stop-all.sh 2）Hadoop的启动与关闭①在Hadoop根目录启动Hadoop。./sbin/start-all.sh ②关闭Hadoop。./sbin/stop-all.sh 3）检测是否安装成功正常状态下会出现如下内容。-bash-4.1# jps 23526 Jps 2127 Master 7396 NameNode 7594 SecondaryNameNode 7681 ResourceManager 1053 DataNode 31935 NodeManager 1405 Worker 如缺少进程请到logs文件夹下查看相应日志，针对具体问题进行解决。

Hadoop框架比较侧重离线大批量计算，而spark框架则侧重于内存和实时计算。Hadoop和Apache Spark两者都是大数据框架，但是各自存在的目的不尽相同。Hadoop实质上更多是一个分布式数据基础设施：它将巨大的数据集分派到一个由普通计算机组成的集群中的多个节点进行存储，意味着您不需要购买和维护昂贵的服务器硬件。同时，Hadoop还会索引和跟踪这些数据，让大数据处理和分析效率达到前所未有的高度。Spark，则是那么一个专门用来对那些分布式存储的大数据进行处理的工具，它并不会进行分布式数据的存储。Hadoop除了提供为大家所共识的HDFS分布式数据存储功能之外，还提供了叫做MapReduce的数据处理功能。所以这里我们完全可以抛开Spark，使用Hadoop自身的MapReduce来完成数据的处理。相反，Spark也不是非要依附在Hadoop身上才能生存。但如上所述，毕竟它没有提供文件管理系统，所以，它必须和其他的分布式文件系统进行集成才能运作。这里我们可以选择Hadoop的HDFS,也可以选择其他的基于云的数据系统平台。但Spark默认来说还是被用在Hadoop上面的，毕竟，大家都认为它们的结合是最好的。

hadoop:是分布式存储系统，同时提供分布式计算环境，存储称为hdfs，计算称为mapreduce 简称MR。spark：是一个分布式计算框架，类似于hadoop的运算环境，但是比mapreduce提供了更多支持，与其他系统的对接，一些高级算法等，可以独立运行，也可以使用hdfs上的数据，调度任务也可以基于hadoop的yarn来管理。由于整个计算都可以在内存中完成，所以速度自然比传统的MR计算的快。除此之外spark运行时占用的系统资源也比MR小得多，相比较属于轻量级运行。最核心的也是它提供的分析学习算法，这个大部分分布式架构不具有的。一般spark下的编程多数基于scala来完成，而非java，所以想学习spark一定要学习scala语言

雪佛兰斯帕可（Spark)是上海通用汽车雪佛兰推出的首款1.0排量高端进口微型车，原名乐驰。于2010年12月底正式上市，排量均为1.0的两款车型分别是斯帕可1.0 SE MT（经济手动款）和斯帕可1.0 SX AT(豪华自动款），售价为6.78-8.86万元，油耗为5.6L-6.2L，主要竞争对手定位为大众POLO，现代i30、瑞纳（两厢），东风悦达起亚K2（两厢），铃木雨燕、北斗星等A00级小型车。名称定义SPARK 在英文当中是“火花”的意思。用这个词来形容上汽通用五菱2003年12月8日上市10余年，全球总销量接近110万辆。国产的Spark改挂雪佛兰标志，整车与国外车型并无两样。扩展资料2019年雪佛兰Spark有四种装饰级别，主要区别于标准功能内容。Spark LS是基本型号，1LT增加了更多功能。该2LT拥有更多的便利和驾驶员辅助功能，而ACTIV模型增加了离地间隙和图钉的车顶行李架更积极的生活方式。所有Sparks都配备1.4升四缸发动机，可产生98马力和94磅 - 英尺的扭矩。发动机通过五速手动变速器或无级变速自动变速器（CVT）驱动前轮。Spark LS配备15英寸钢轮，空调，后视摄像头，7英寸触摸屏，Android Auto和Apple CarPlay功能，蓝牙和USB连接，四扬声器音响系统以及雪佛兰OnStar通信系统，包括4G LTE车载Wi-Fi热点。该1LT包括铝合金轮毂，动力配件（窗口，反射镜和门锁），巡航控制，远程无钥匙进入，雾灯，和六扬声器音频系统。接下来就是Activ。 它增加了模拟皮革座椅表面，加热前排座椅，皮革包裹的方向盘，车顶纵梁，特殊的15英寸车轮和车身，以及提升0.4英寸额外离地间隙的凸起悬架。或者，去2LT。与1LT相比，它配备了后部停车传感器，模拟皮革座椅表面，按钮启动，升级的驾驶员信息显示，加热前排座椅，镀铬门把手和装饰。1LT和2LT装饰可选择天窗。仅对于2LT，您可以获得驾驶员信心包，其中添加了具有低速紧急自动制动和车道偏离警告系统的前方碰撞警告系统。2019年Spark的小型四缸发动机最适合在城镇周围使用。CVT自动装备的Spark需要11秒才能从停止时间达到60英里/小时，因此高速公路上坡需要一些规划。令人惊讶的是，Spark在城镇周围非常灵活，整体上提供了良好的驾驶体验。虽然它很吵，但Spark与同级车中的其他车型相比毫不逊色。座椅位置直立，侧向支撑最小。后排座椅最适合较小的乘客。是的，Spark很小，但它的内部布局很实用。高高的车顶线条使其具有良好的通道和可视性。但其他超小型车提供更多后排腿部空间。使用后座的货舱很小。但折叠座椅，并有足够的存储空间来解决适合这款超小型掀背车的典型差事。信息娱乐系统增添了Spark的现代氛围。菜单直观，图形清晰。触摸屏支持Apple CarPlay和Android Auto连接。您还可以通过OnStar系统获得板载Wi-Fi。参考资料来源：百度百科-通用雪佛兰SPARK

n.火花; 火星A cigarette spark started the forest fire.香烟的火星引起了这场森林火灾。丝毫, 略微, 一点点vi.发出火星; 发出闪光Fireflies sparked in the darkness.萤火虫在黑暗中发光。vt.使大感兴趣

1、n.火花; 火星; 电火花; (指品质或感情)一星，丝毫，一丁点;2、v.引发; 触发; 冒火花; 飞火星; 产生电火花;3、[例句]A spark ignites the fuel in a car engine.汽车发动机中的燃料由火花点燃。4、[其他]第三人称单数：sparks 复数：sparks 现在分词：sparking 过去式：sparked 过去分词：sparked

1、 Spark VSHadoop有哪些异同点？ Hadoop:分布式批处理计算，强调批处理，常用于数据挖掘、分析 Spark:是一个基于内存计算的开源的集群计算系统，目的是让数据分析更加快速, Spark 是一种与 Hadoop 相似的开源集群计算环境，但是两者之间还存在一些不同之处，这些有用的不同之处使 Spark 在某些工作负载方面表现得更加优越，换句话说，Spark 启用了内存分布数据集，除了能够提供交互式查询外，它还可以优化迭代工作负载。 Spark 是在 Scala 语言中实现的，它将 Scala 用作其应用程序框架。与 Hadoop 不同，Spark 和 Scala 能够紧密集成，其中的 Scala 可以像操作本地集合对象一样轻松地操作分布式数据集。 尽管创建 Spark 是为了支持分布式数据集上的迭代作业，但是实际上它是对 Hadoop 的补充，可以在 Hadoop 文件系统中并行运行。通过名为Mesos的第三方集群框架可以支持此行为。Spark 由加州大学伯克利分校 AMP 实验室 (Algorithms,Machines,and People Lab) 开发，可用来构建大型的、低延迟的数据分析应用程序。 虽然 Spark 与 Hadoop 有相似之处，但它提供了具有有用差异的一个新的集群计算框架。首先，Spark 是为集群计算中的特定类型的工作负载而设计，即那些在并行操作之间重用工作数据集（比如机器学习算法）的工作负载。为了优化这些类型的工作负载，Spark 引进了内存集群计算的概念，可在内存集群计算中将数据集缓存在内存中，以缩短访问延迟. 在大数据处理方面相信大家对hadoop已经耳熟能详，基于GoogleMap/Reduce来实现的Hadoop为开发者提供了map、reduce原语，使并行批处理程序变得非常地简单和优美。Spark提供的数据集操作类型有很多种，不像Hadoop只提供了Map和Reduce两种操作。比如map,filter, flatMap,sample, groupByKey, reduceByKey, union,join, cogroup,mapValues, sort,partionBy等多种操作类型，他们把这些操作称为Transformations。同时还提供Count,collect, reduce, lookup, save等多种actions。这些多种多样的数据集操作类型，给上层应用者提供了方便。各个处理节点之间的通信模型不再像Hadoop那样就是唯一的Data Shuffle一种模式。用户可以命名，物化，控制中间结果的分区等。可以说编程模型比Hadoop更灵活.2、Spark在容错性方面是否比其他工具更有优越性？ 从Spark的论文《Resilient Distributed Datasets: AFault-TolerantAbstraction for In-Memory Cluster Computing》中没看出容错性做的有多好。倒是提到了分布式数据集计算，做checkpoint的两种方式，一个是checkpoint data，一个是loggingthe updates。貌似Spark采用了后者。但是文中后来又提到，虽然后者看似节省存储空间。但是由于数据处理模型是类似DAG的操作过程，由于图中的某个节点出错，由于lineage chains的依赖复杂性，可能会引起全部计算节点的重新计算，这样成本也不低。他们后来说，是存数据，还是存更新日志，做checkpoint还是由用户说了算吧。相当于什么都没说，又把这个皮球踢给了用户。所以我看就是由用户根据业务类型，衡量是存储数据IO和磁盘空间的代价和重新计算的代价，选择代价较小的一种策略。取代给中间结果进行持久化或建立检查点，Spark会记住产生某些数据集的操作序列。因此，当一个节点出现故障时，Spark会根据存储信息重新构造数据集。他们认为这样也不错，因为其他节点将会帮助重建。3、Spark对于数据处理能力和效率有哪些特色？ Spark提供了高的性能和大数据处理能力，使得用户可以快速得到反馈体验更好。另一类应用是做数据挖掘，因为Spark充分利用内存进行缓存，利用DAG消除不必要的步骤，所以比较合适做迭代式的运算。而有相当一部分机器学习算法是通过多次迭代收敛的算法，所以适合用Spark来实现。我们把一些常用的算法并行化用Spark实现，可以从R语言中方便地调用，降低了用户进行数据挖掘的学习成本。Spark配有一个流数据处理模型，与Twitter的 Storm框架相比，Spark采用了一种有趣而且独特的办法。Storm基本上是像是放入独立事务的管道，在其中事务会得到分布式的处理。相反，Spark采用一个模型收集事务，然后在短时间内（我们假设是5秒）以批处理的方式处理事件。所收集的数据成为他们自己的RDD，然后使用Spark应用程序中常用的一组进行处理。作者声称这种模式是在缓慢节点和故障情况下会更加稳健，而且5秒的时间间隔通常对于大多数应用已经足够快了。这种方法也很好地统一了流式处理与非流式处理部分。总结 这几天在看Hadoop权威指南、hbase权威指南、hive权威指南、大规模分布式存储系统、zoopkeeper、大数据互联网大规模数据挖掘与分布式处理等书同时补充，能静下心来好好的完整的看完一本书，是相当不错的。

大讲台Hadoop为你解答：1. Hadoop 3.0简介 Hadoop 2.0是基于JDK 1.7开发的，而JDK 1.7在2015年4月已停止更新，这直接迫使Hadoop社区基于JDK 1.8重新发布一个新的Hadoop版本，而这正是hadoop 3.0。 Hadoop 3.0的alpha版预计今年夏天发布，GA版本11月或12月发布。 Hadoop 3.0中引入了一些重要的功能和优化，包括HDFS 可擦除编码、多Namenode支持、MR Native Task优化、YARN基于cgroup的内存和磁盘IO隔离、YARN container resizing等。 2. Hadoop 3.0新特性 Hadoop 3.0在功能和性能方面，对hadoop内核进行了多项重大改进，主要包括： 2.1 Hadoop Common （1）精简Hadoop内核，包括剔除过期的API和实现，将默认组件实现替换成最高效的实现（比如将FileOutputCommitter缺省实现换为v2版本，废除hftp转由webhdfs替代，移除Hadoop子实现序列化库org.apache.hadoop.Records （2）Classpath isolation以防止不同版本jar包冲突，比如google Guava在混合使用Hadoop、HBase和Spark时，很容易产生冲突。（3）Shell脚本重构。 Hadoop 3.0对Hadoop的管理脚本进行了重构，修复了大量bug，增加了新特性，支持动态命令等。

Spark是一个基于内存计算的开源的集群计算系统，目的是让数据分析更加快速。Spark非常小巧玲珑，由加州伯克利大学AMP实验室的Matei为主的小团队所开发。使用的语言是Scala，项目的core部分的代码只有63个Scala文件，非常短小精悍。Spark 是一种与 Hadoop 相似的开源集群计算环境，但是两者之间还存在一些不同之处，这些有用的不同之处使 Spark 在某些工作负载方面表现得更加优越，换句话说，Spark 启用了内存分布数据集，除了能够提供交互式查询外，它还可以优化迭代工作负载。Spark 是在 Scala 语言中实现的，它将 Scala 用作其应用程序框架。与 Hadoop 不同，Spark 和 Scala 能够紧密集成，其中的 Scala 可以像操作本地集合对象一样轻松地操作分布式数据集。尽管创建 Spark 是为了支持分布式数据集上的迭代作业，但是实际上它是对 Hadoop 的补充，可以在 Hadoop 文件系统中并行运行。通过名为Mesos的第三方集群框架可以支持此行为。Spark 由加州大学伯克利分校 AMP 实验室 (Algorithms, Machines, and People Lab) 开发，可用来构建大型的、低延迟的数据分析应用程序。Spark 集群计算架构虽然 Spark 与 Hadoop 有相似之处，但它提供了具有有用差异的一个新的集群计算框架。首先，Spark 是为集群计算中的特定类型的工作负载而设计，即那些在并行操作之间重用工作数据集（比如机器学习算法）的工作负载。为了优化这些类型的工作负载，Spark 引进了内存集群计算的概念，可在内存集群计算中将数据集缓存在内存中，以缩短访问延迟。Spark 还引进了名为弹性分布式数据集(RDD) 的抽象。RDD 是分布在一组节点中的只读对象集合。这些集合是弹性的，如果数据集一部分丢失，则可以对它们进行重建。重建部分数据集的过程依赖于容错机制，该机制可以维护 "血统"（即允许基于数据衍生过程重建部分数据集的信息）。RDD 被表示为一个 Scala 对象，并且可以从文件中创建它；一个并行化的切片（遍布于节点之间）；另一个 RDD 的转换形式；并且最终会彻底改变现有 RDD 的持久性，比如请求缓存在内存中。Spark 中的应用程序称为驱动程序，这些驱动程序可实现在单一节点上执行的操作或在一组节点上并行执行的操作。与 Hadoop 类似，Spark 支持单节点集群或多节点集群。对于多节点操作，Spark 依赖于 Mesos 集群管理器。Mesos 为分布式应用程序的资源共享和隔离提供了一个有效平台。该设置充许 Spark 与 Hadoop 共存于节点的一个共享池中。

park 是一个通用引擎，可用它来完成各种各样的运算，包括 SQL 查询、文本处理、机器学习等，而在 Spark 出现之前，我们一般需要学习各种各样的引擎来分别处理这些需求。

波司登spark是活力的意思。spark的意思是火花，火星，在衣服上常会看到这个词，也指代活力的意思。

大疆晓Spark飞行器状态指示灯分为机头指示灯和飞行器状态指示灯。机头指示灯有红、绿、黄三种颜色。红灯常亮时，表示机头方向指示；红灯慢闪时，表示飞行器低电量报警；红灯快闪时，表示飞行器严重低电量报警；红灯间歇闪烁，表示飞行器执行系统自检；红灯和蓝灯交替闪烁，表示飞行器进入指南针数据错误，需要进行校准。飞行器状态指示灯也分为红、绿、黄三种颜色。绿灯常亮时，表示飞行器已经解锁，准备起飞；绿灯慢闪时，表示飞行器使用GPS定位；绿灯双闪时，表示飞行器使用视觉系统定位；黄灯慢闪时，表示飞行器无GPS无视觉定位；蓝灯闪时，表示已加锁，GPS搜星中。当出现黄灯双闪的情况时，表示系统拒绝解锁，需要进行故障排查。请注意，在操作飞行器之前，一定要详细阅读用户手册并遵循飞行器的操作指南和安全准则。对于其他飞行器或者设备的使用和操作，也请参考相应的用户手册和安全准则进行操作。

Hadoop是一个由Apache基金会所开发的分布式系统基础架构。Hadoop也是apache开源大数据的一个生态圈总称,里面包含跟大数据开源框架的一些软件,包含hdfs,hive,zookeeper,hbase等等;Hadoop的框架最核心的设计就是：HDFS和MapReduce。HDFS为海量的数据提供了存储，则MapReduce为海量的数据提供了计算。Hive是基于Hadoop的一个数据仓库工具，可以将结构化的数据文件映射为一张数据库表，并提供简单的sql查询功能，可以将sql语句转换为MapReduce任务进行运行。 其优点是学习成本低，可以通过类SQL语句快速实现简单的MapReduce统计，不必开发专门的MapReduce应用，十分适合数据仓库的统计分析。Spark 是一种与 Hadoop 相似的开源集群计算环境，但是两者之间还存在一些不同之处，这些有用的不同之处使 Spark 在某些工作负载方面表现得更加优越，换句话说，Spark 启用了内存分布数据集，除了能够提供交互式查询外，它还可以优化迭代工作负载。尽管创建 Spark 是为了支持分布式数据集上的迭代作业，但是实际上它是对 Hadoop 的补充，可以在 Hadoop 文件系统中并行运行。通过名为 Mesos 的第三方集群框架可以支持此行为。hadoop(hive)<-spark(扩展)

spark是汽车牌子。雪佛兰斯帕可（Spark）是上海通用汽车雪佛兰推出的首款1.0排量高端进口微型车，原名乐驰。这款车的名字是根据英文名直接音译过来的，而“SPARK”原意有“火花”的意思，意在厂家希望这款车能在汽车市场产生一片属于精彩火花。2010年12月，雪佛兰全新Spark亮相广州车展，同时中文由原先的“乐驰”改名为斯帕可。这款作为在许多国家都有上市销售的全球车型，一经推出便深受全球创意年轻人的喜爱，全新雪佛兰SPARK在短时间内就引爆了全球个性化微型车市场。这款车外形小巧却又有几分威猛，具备一定的时尚、运动风格，整体造型上有着一股欧洲气息。这样的小车身比较吸引女孩子的目光，适合女生或是年轻个人日常代步驾驶。当前这款车的市场主要竞争对手为大众POLO、起亚K2两厢、铃木雨燕等。雪佛兰介绍：作为通用汽车旗下最为国际化和大众化的品牌，雪佛兰拥有强大的技术和市场资源，其品牌定位是一个大众化的值得信赖的国际汽车品牌。雪佛兰品牌个性是：值得信赖、聪明务实、亲和友善、充满活力。

Spark为结构化数据处理引入了一个称为Spark SQL的编程模块。简而言之，sparkSQL是Spark的前身，是在Hadoop发展过程中，为了给熟悉RDBMS但又不理解MapReduce的技术人员提供快速上手的工具。sparkSQL提供了一个称为DataFrame（数据框）的编程抽象，DF的底层仍然是RDD，并且可以充当分布式SQL查询引擎。SparkSql有哪些特点呢？1）引入了新的RDD类型SchemaRDD，可以像传统数据库定义表一样来定义SchemaRDD。2）在应用程序中可以混合使用不同来源的数据，如可以将来自HiveQL的数据和来自SQL的数据进行Join操作。3）内嵌了查询优化框架，在把SQL解析成逻辑执行计划之后，最后变成RDD的计算。

火星

Storm优势就在于Storm是实时的连续性的分布式的计算框架,一旦运行起来,除非你将它杀掉,否则它一直处理计算或等待计算的状态.Spark和hadoop都做不到.当然它们各自都有其应用场景,各有各的优势.可以配合使用.下面我转一份别人的资料,讲的很清楚.Storm与Spark、Hadoop这三种框架，各有各的优点，每个框架都有自己的最佳应用场景。所以，在不同的应用场景下，应该选择不同的框架。Storm是最佳的流式计算框架，Storm由Java和Clojure写成，Storm的优点是全内存计算，所以它的定位是分布式实时计算系统，按照Storm作者的说法，Storm对于实时计算的意义类似于Hadoop对于批处理的意义。Storm的适用场景：1）流数据处理Storm可以用来处理源源不断流进来的消息，处理之后将结果写入到某个存储中去。2）分布式RPC。由于Storm的处理组件是分布式的，而且处理延迟极低，所以可以作为一个通用的分布式RPC框架来使用。SparkSpark是一个基于内存计算的开源集群计算系统，目的是更快速的进行数据分析。Spark由加州伯克利大学AMP实验室Matei为主的小团队使用Scala开发开发，类似于Hadoop MapReduce的通用并行计算框架，Spark基于Map Reduce算法实现的分布式计算，拥有Hadoop MapReduce所具有的优点，但不同于MapReduce的是Job中间输出和结果可以保存在内存中，从而不再需要读写HDFS，因此Spark能更好地适用于数据挖掘与机器学习等需要迭代的Map Reduce的算法。Spark的适用场景：1）多次操作特定数据集的应用场合Spark是基于内存的迭代计算框架，适用于需要多次操作特定数据集的应用场合。需要反复操作的次数越多，所需读取的数据量越大，受益越大，数据量小但是计算密集度较大的场合，受益就相对较小。2）粗粒度更新状态的应用由于RDD的特性，Spark不适用那种异步细粒度更新状态的应用，例如Web服务的存储或者是增量的Web爬虫和索引。就是对于那种增量修改的应用模型不适合。总的来说Spark的适用面比较广泛且比较通用。Hadoop是实现了MapReduce的思想，将数据切片计算来处理大量的离线数据数据。Hadoop处理的数据必须是已经存放在HDFS上或者类似HBase的数据库中，所以Hadoop实现的时候是通过移动计算到这些存放数据的机器上来提高效率。Hadoop的适用场景：1）海量数据的离线分析处理2）大规模Web信息搜索3）数据密集型并行计算简单来说：Hadoop适合于离线的批量数据处理适用于对实时性要求极低的场景Storm适合于实时流数据处理，实时性方面做得极好Spark是内存分布式计算框架，试图吞并Hadoop的Map-Reduce批处理框架和Storm的流处理框架，但是Spark已经做得很不错了，批处理方面性能优于Map-Reduce，但是流处理目前还是弱于Storm，产品仍在改进之中

　　本文前提是已经正确安装好scala,sbt以及spark了 简述将程序挂载到集群上运行的步骤：　　1、构建sbt标准的项目工程结构：SBT项目工程结构图其中：~/build.sbt文件用来配置项目的基本信息（项目名、组织名、项目版本、使用的scala版本或者再次配置些项目所需的依赖包）；project/build.properties文件配置你要使用什么版本的sbt对项目操作；project/plugins.sbt文件是给项目添加所需的插件；project/Build.scala文件是对项目进行些复杂的高级配置；详细的sbt安装配置实用参见博文：　　2、到相应目录下编写程序，spark程序必须要创建一个SparkContext实例。SparkContext("master", "projectName", "SPARK_HOME", "yourProject.jar path")　　3、sbt compile命令编译程序无错后，sbt package命令将程序打包。默认打包的jar文件存放路径为：项目根目录/target/scala-xx.xx.xx/your-project-name_xx.xx.xx-xx.jar　　4、将打包好的jar问价添加到SPAK_CLASSPATH中（在linux中根据作用范围的不同有多种更改环境变量的方式，这里只说我的配置方式：spark根目录下的conf/spark-env.sh文件添加SPARK_CLASSPATH:xxxxxxxx）　　5、配置好环境变量后就可以在spark的根目录下使用./run脚本运行你的程序了例如：./run spark.examples.SparkPi spark://masterIP:port注意，如果程序涉及IO操作起默认路径为SPARK_HOME；至于如何修改这个路径，有待研究转载，仅供参考。

本质上spark跟mapreduce一样都是计算框架apache spark是通过hadoop yarn管理的，需要运行在hadoop集群上

一、hadoop、Storm该选哪一个？为了区别hadoop和Storm，该部分将回答如下问题：1.hadoop、Storm各是什么运算2.Storm为什么被称之为流式计算系统3.hadoop适合什么场景，什么情况下使用hadoop4.什么是吞吐量首先整体认识：Hadoop是磁盘级计算，进行计算时，数据在磁盘上，需要读写磁盘；Storm是内存级计算，数据直接通过网络导入内存。读写内存比读写磁盘速度快n个数量级。根据Harvard CS61课件，磁盘访问延迟约为内存访问延迟的75000倍。所以Storm更快。注释：1. 延时 ， 指数据从产生到运算产生结果的时间，“快”应该主要指这个。2. 吞吐， 指系统单位时间处理的数据量。storm的网络直传、内存计算，其时延必然比hadoop的通过hdfs传输低得多；当计算模型比较适合流式时，storm的流式处理，省去了批处理的收集数据的时间；因为storm是服务型的作业，也省去了作业调度的时延。所以从时延上来看，storm要快于hadoop。从原理角度来讲：Hadoop M/R基于HDFS，需要切分输入数据、产生中间数据文件、排序、数据压缩、多份复制等，效率较低。Storm 基于ZeroMQ这个高性能的消息通讯库，不持久化数据。为什么storm比hadoop快，下面举一个应用场景说一个典型的场景，几千个日志生产方产生日志文件，需要进行一些ETL操作存入一个数据库。假设利用hadoop，则需要先存入hdfs，按每一分钟切一个文件的粒度来算（这个粒度已经极端的细了，再小的话hdfs上会一堆小文件），hadoop开始计算时，1分钟已经过去了，然后再开始调度任务又花了一分钟，然后作业运行起来，假设机器特别多，几钞钟就算完了，然后写数据库假设也花了很少的时间，这样，从数据产生到最后可以使用已经过去了至少两分多钟。而流式计算则是数据产生时，则有一个程序去一直监控日志的产生，产生一行就通过一个传输系统发给流式计算系统，然后流式计算系统直接处理，处理完之后直接写入数据库，每条数据从产生到写入数据库，在资源充足时可以在毫秒级别完成。同时说一下另外一个场景：如果一个大文件的wordcount，把它放到storm上进行流式的处理，等所有已有数据处理完才让storm输出结果，这时候，你再把它和hadoop比较快慢，这时，其实比较的不是时延，而是比较的吞吐了。--------------------------------------------------------------------------------------------------------------------------------最主要的方面：Hadoop使用磁盘作为中间交换的介质，而storm的数据是一直在内存中流转的。两者面向的领域也不完全相同，一个是批量处理，基于任务调度的；另外一个是实时处理，基于流。以水为例，Hadoop可以看作是纯净水，一桶桶地搬；而Storm是用水管，预先接好（Topology），然后打开水龙头，水就源源不断地流出来了。--------------------------------------------------------------------------------------------------------------------------------Storm的主工程师Nathan Marz表示： Storm可以方便地在一个计算机集群中编写与扩展复杂的实时计算，Storm之于实时处理，就好比Hadoop之于批处理。Storm保证每个消息都会得到处理，而且它很快——在一个小集群中，每秒可以处理数以百万计的消息。更棒的是你可以使用任意编程语言来做开发。Storm的主要特点如下：1.简单的编程模型。类似于MapReduce降低了并行批处理复杂性，Storm降低了进行实时处理的复杂性。2.可以使用各种编程语言。你可以在Storm之上使用各种编程语言。默认支持Clojure、Java、Ruby和Python。要增加对其他语言的支持，只需实现一个简单的Storm通信协议即可。3.容错性。Storm会管理工作进程和节点的故障。4.水平扩展。计算是在多个线程、进程和服务器之间并行进行的。5.可靠的消息处理。Storm保证每个消息至少能得到一次完整处理。任务失败时，它会负责从消息源重试消息。6.快速。系统的设计保证了消息能得到快速的处理，使用MQ作为其底层消息队列。7.本地模式。Storm有一个“本地模式”，可以在处理过程中完全模拟Storm集群。这让你可以快速进行开发和单元测试。--------------------------------------------------------------------------------------------------------------------------------在消耗资源相同的情况下，一般来说storm的延时低于mapreduce。但是吞吐也低于mapreduce。storm是典型的流计算系统，mapreduce是典型的批处理系统。下面对流计算和批处理系统流程这个个数据处理流程来说大致可以分三个阶段：1. 数据采集与准备2. 数据计算（涉及计算中的中间存储）， 题主中的“那些方面决定”应该主要是指这个阶段处理方式。3. 数据结果展现（反馈）1）数据采集阶段，目前典型的处理处理策略：数据的产生系统一般出自页面打点和解析DB的log，流计算将数据采集中消息队列（比如kafaka,metaQ,timetunle）等。批处理系统一般将数据采集进分布式文件系统（比如HDFS），当然也有使用消息队列的。我们暂且把消息队列和文件系统称为预处理存储。二者在延时和吞吐上没太大区别，接下来从这个预处理存储进入到数据计算阶段有很大的区别，流计算一般在实时的读取消息队列进入流计算系统（storm）的数据进行运算，批处理一系统一般会攒一大批后批量导入到计算系统（hadoop），这里就有了延时的区别。2）数据计算阶段，流计算系统（storm）的延时低主要有一下几个方面（针对题主的问题）A： storm 进程是常驻的，有数据就可以进行实时的处理mapreduce 数据攒一批后由作业管理系统启动任务，Jobtracker计算任务分配，tasktacker启动相关的运算进程B： stom每个计算单元之间数据之间通过网络（zeromq）直接传输。mapreduce map任务运算的结果要写入到HDFS，在于reduce任务通过网络拖过去运算。相对来说多了磁盘读写，比较慢C： 对于复杂运算storm的运算模型直接支持DAG（有向无环图）mapreduce 需要肯多个MR过程组成，有些map操作没有意义的3）数据结果展现流计算一般运算结果直接反馈到最终结果集中（展示页面，数据库，搜索引擎的索引）。而mapreduce一般需要整个运算结束后将结果批量导入到结果集中。实际流计算和批处理系统没有本质的区别，像storm的trident也有批概念，而mapreduce可以将每次运算的数据集缩小（比如几分钟启动一次），facebook的puma就是基于hadoop做的流计算系统。二、高性能并行计算引擎Storm和Spark比较Spark基于这样的理念，当数据庞大时，把计算过程传递给数据要比把数据传递给计算过程要更富效率。每个节点存储（或缓存）它的数据集，然后任务被提交给节点。所以这是把过程传递给数据。这和Hadoop map/reduce非常相似，除了积极使用内存来避免I/O操作，以使得迭代算法（前一步计算输出是下一步计算的输入）性能更高。Shark只是一个基于Spark的查询引擎（支持ad-hoc临时性的分析查询）而Storm的架构和Spark截然相反。Storm是一个分布式流计算引擎。每个节点实现一个基本的计算过程，而数据项在互相连接的网络节点中流进流出。和Spark相反，这个是把数据传递给过程。两个框架都用于处理大量数据的并行计算。Storm在动态处理大量生成的“小数据块”上要更好（比如在Twitter数据流上实时计算一些汇聚功能或分析）。Spark工作于现有的数据全集（如Hadoop数据）已经被导入Spark集群，Spark基于in-memory管理可以进行快讯扫描，并最小化迭代算法的全局I/O操作。不过Spark流模块（Streaming Module）倒是和Storm相类似（都是流计算引擎），尽管并非完全一样。Spark流模块先汇聚批量数据然后进行数据块分发（视作不可变数据进行处理），而Storm是只要接收到数据就实时处理并分发。不确定哪种方式在数据吞吐量上要具优势，不过Storm计算时间延迟要小。总结下，Spark和Storm设计相反，而Spark Steaming才和Storm类似，前者有数据平滑窗口（sliding window），而后者需要自己去维护这个窗口。

SPARK-点亮精彩瞬间小身型，大身手。障碍感知结合机器视觉，操控易如反掌。机械云台配以 UltraSmooth，航拍稳定流畅。最高时速 50 公里1，2 公里高清图传2，手掌大小的 “晓” Spark，让你尽享飞行乐趣。1.快速启动开机后 25 秒内准备就绪，放上手掌3开启人脸检测，解锁后启动升空，随时为你拍照。2.简单操控飞行、拍摄、返航，这些原本需要移动设备或遥控器的操作，现在挥挥手也可以完成。3.轻松拍摄只需在移动设备上轻轻一点，即使你从未接触过无人机，也能拍出精彩的航拍视频4.剪辑分享自动剪辑、加入滤镜、套上模板，全在 DJI GO 4 应用实现，并一键在社交网络上分享。

　　Spark是UC Berkeley AMP lab (加州大学伯克利分校的AMP实验室)所开源的类Hadoop MapReduce的通用并行框架，Spark，拥有Hadoop MapReduce所具有的优点；但不同于MapReduce的是Job中间输出结果可以保存在内存中，从而不再需要读写HDFS，因此Spark能更好地适用于数据挖掘与机器学习等需要迭代的MapReduce的算法　　数据科学家为了回答一个问题或进行深入研究，会使用相关的技术分析数据。通常，他们的工作包含特殊的分析，所以他们使用交互式shell，以使得他们能在最短的时间内看到查询结果和代码片段。Spark的速度和简单的API接口很好地符合这个目标，它的内建库意味着很多算法可以随时使用。　　Spark通过若干组件支持不同的数据科学任务。Spark shell使得用Python或Scala进行交互式数据分析变得简单。Spark SQL也有一个独立的SQL shell，可以用SQL进行数据分析，也可以在Spark程序中或Spark shell中使用Spark SQL。MLlib库支持机器学习和数据分析。而且，支持调用外部的MATLAB或R语言编写的程序。Spark使得数据科学家可以用R或Pandas等工具处理包含大量数据的问题。

spark 英[spɑ:k] 美[spɑrk] n. 燃烧的颗粒;火星，火花，余火;（金属的）发光的颗粒;电火花 vi. 发出火星，发出闪光;热烈赞同;正常运转 vt. 发动，触发;激起运动，鼓舞 [例句]Rekindling the spark in a marriage may seem impossible.重燃婚姻的火花似乎是不可能的。