spark 大数据_spark大数据 - CSDN
精华内容
参与话题
  • 大数据----SparkSpark入门教程[1]

    千次阅读 2019-05-31 08:44:08
    本教程源于2016年3月出版书籍《Spark原理、机制及应用》 ,如有兴趣,请支持正版书籍。 随着互联网为代表的信息技术...如今业界大数据处理的主流平台非Hadoop和Spark莫属,本书主要介绍大数据平台的后起之秀Spark...

    本教程源于2016年3月出版书籍《Spark原理、机制及应用》 ,如有兴趣,请支持正版书籍。

    随着互联网为代表的信息技术深度发展,其背后由于历史积累产生了TB、PB甚至EB级数据量,由于传统机器的软硬件不足以支持如此庞大的数据量的存储、管理及分析能力,因而专门应对大数据的分布式处理技术应运而生。如今业界大数据处理的主流平台非Hadoop和Spark莫属,本书主要介绍大数据平台的后起之秀Spark,目的是通过系统学习让读者了解和应用大数据,进而提炼大数据中蕴藏的价值。 本章主要向读者介绍Spark的基础概念、发展历程、特点、与现有主流分布式应用框架的区别以及其生态系统中其他的重要组成部分(如Spark SQL、Spark Streaming、GraphX和MLlib等子项目)。目的在于让读者对分布式框架的背景及主流应用有一个宏观而全面的了解,具体细节将在后续章节向读者介绍。

    1.1 Spark初见

    Spark是一个基于内存的开源计算框架,于2009年诞生于加州大学伯克利分校AMPLab(AMP:Algorithms,Machines,People),它最初属于伯克利大学的研究性项目,后来在2010年正式开源,并于 2013 年成为了 
    Apache 基金项目,到2014年便成为 Apache 基金的顶级项目,该项目整个发展历程刚过六年时间,但其发展速度非常惊人。正由于Spark来自于大学,其整个发展过程都充满了学术研究的标记,是学术带动Spark
    核心架构的发展,如弹性分布式数据集(RDD,resilient distributed datasets)、流处理(Spark streaming)、机器学习(MLlib)、SQL分析(Spark SQL)和图计算(GraphX),本节将主要介绍Spark发展历程和特点。
    

    1.1.1Spark发展史及近况

    Spark起初只是一个学术性研究项目,从创立到如今蜚声海外并且在大数据领域成为风尖浪口的热门项目只花了6年左右的时间,其具体发展大事记如下。

    • 2009年Spark诞生于伯克利AMPLab。
    • 项目在2010年早些时候开源,很多早期关于Spark系统的思想在不同论文中发表。
    • 项目开源之后,在GitHub上成立了Spark开发社区并在2013年成为Apache孵化项目。
    • 该项目在2014年2月成为Apache顶级项目。
    • 2014年5月30日Spark 1.0.0版正式上线。
    • 截止到2015年,Spark官方维护运营公司Databricks已经组织并举办了三年Spark Summit技术峰会。

    Spark项目组核心成员在2013年创建了Databricks公司,到目前为止已经在San Francisco连续举办了从2013年到2015年的Spark Summit峰会。会议得到大数据主流厂商Hortonworks、IBM、cloudera、MAPR和Pivotal等公司的支持和大数据方案解决商Amazon、DATASTAX和SAP等公司的合作,Spark的用户和应用量一直在迅速增加,如图1-1所示。

    图1-1  截止2015年Spark的主要用户和应用

    从图1-1[ 图1-1引用自https://spark-summit.org/2015/中可以看出Spark的影响力在2014年(可参考2014年Spark峰会资料)的基础上不断扩大,已经有越来越多Spark用户使用该平台,其中包括传统工业厂商TOYOTA和著名O2O公司Uber与airbnb,说明Spark的用户领域不断深化到传统工业界和互联网与传统行业交叉的领域。不仅如此,越来越多的大数据商业版发行商例如Cloudera以及Hortonworks也开始将Spark纳入其部署范围,这无疑对Spark的商业应用和推广起到巨大作用,另一方面也显示Spark平台技术的先进性。 

    从Spark的版本演化速度看,说明这个平台旺盛的生命力以及社区的活跃度。尤其在2013年来,Spark进入了一个高速发展期,代码库提交与社区活跃度都有显著增长。以活跃度论,Spark在所有Aparch基金会开源项目中位列前三。相较于其他大数据平台或框架而言,Spark的代码库最为活跃,表现出强劲的发展势头,从图1-2中可以看到。

    过去6个月里 Spark代码活跃情况(从2014年6月30为基点)

    从2013年6月到2014年6月,参与贡献的开发人员从原来的68位增长到255位,截止到2015年6月参与开发的人员已经达到730位(数据引用自Spark Summit 2015中报告),参与贡献的公司逐渐有来自中国的阿里巴巴、百度、网易、腾讯和搜狐等公司。代码库的代码行也从2014年的17万行增长到2015年的40万行。下图为截止2014年Spark代码贡献者的增长曲线,如图1-3可以了解到。

    图1-3 截止2014年Spark代码贡献者每个月的增长曲线

    从图1-3可以看出Spark从2010年到2014年间社区开源工作者的数量不断增加,而且速度越来越快,从2010年初始到2015年,每月的代码贡献者增到到现在的135位,在这些代码贡献者中出现很多中国公司和开发者的身影。例如目前世界上最大的Spark集群在腾讯,拥有高达8000个节点;最大的单任务处理数据量达到1PB,这项记录是由阿里巴巴公司和databricks公司共同持有。中国之所以能在这方面发展迅速,因为中国市场体量巨大,信息产业发展背后积累了更多数据,进而产生更为迫切的大数据处理需求,最后通过市场需求来推动技术发展。 
    除了影响力巨大的Spark Summit之外,Spark社区还不定期地在全球各地召开小型的Meetup活动。其中在中国的北京、上海和深圳都有相应的Spark技术分享的Meetup[ Meetup是一家知名的在线活动组织平台。]活动,并且活动受到亚信、微软和InfoQ等公司的大力赞助。Spark Meetup Group已经遍布北美、欧洲、亚洲和大洋洲。下图1-4为Spark Meetup Groups在全球的分布图。 
    全球Meetup Groups分布情况 
    从以上近况可以看出Spark的迅猛发展态势,国内外工业界还是学术界都对其抱有极大兴趣,相信Spark有望成为未来大数据分析的主流平台。

    1.1.2 Spark特点

    Spark之所以这么受关注,主要是因为其有与其他大数据平台不同的特点,主要如下。 
    1.轻量级快速处理 
    大数据处理中速度往往被置于第一位,Spark允许传统Hadoop集群中的应用程序在内存中以100倍的速度运行,即使在磁盘上运行也能快10倍。Spark通过减少磁盘IO来达到性能的提升,它们将中间处理数据全部放到了内存中。Spark使用了RDD(Resilient Distributed Datasets)数据抽象,这允许它可以在内存中存储数据,只在需要时才持久化到磁盘。这种做法大大的减少了数据处理过程中磁盘的读写,大幅度的降低了运行时间。

    2.易于使用 
    Spark支持多语言。Spark允许Java、Scala、Python及R(Spark 1.4版最新支持),这允许更多的开发者在自己熟悉的语言环境下进行工作,普及了Spark的应用范围,它自带80多个高等级操作符,允许在shell中进行交互式查询,它多种使用模式的特点让应用更灵活。

    3.支持复杂查询 
    除了简单的map及reduce操作之外,Spark还支持filter、foreach、reduceByKey、aggregate以及SQL查询、流式查询等复杂查询。Spark更为强大之处是用户可以在同一个工作流中无缝的搭配这些功能,例如Spark可以通过Spark Streaming(1.2.2小节对Spark Streaming有详细介绍)获取流数据,然后对数据进行实时SQL查询或使用MLlib库进行系统推荐,而且这些复杂业务的集成并不复杂,因为它们都基于RDD这一抽象数据集在不同业务过程中进行转换,转换代价小,体现了统一引擎解决不同类型工作场景的特点。有关Streaming技术以及MLlib库和RDD将会这之后几个章节进行详述。

    4.实时的流处理 
    对比MapReduce只能处理离线数据,Spark还能支持实时流计算。Spark Streaming主要用来对数据进行实时处理,当然在YARN之后Hadoop也可以借助其他的工具进行流式计算。对于Spark Streaming,著名的大数据产品开发公司Cloudera曾经对Spark Streaming有如下评价: 
    1)简单、轻量且具备功能强大的API,Sparks Streaming允许用户快速开发流应用程序。 
    2)容错能力强,不像其他的流解决方案,比如使用Storm需要额外的配置,而Spark无需额外的代码和配置,因为直接使用其上层应用框架Spark Streaming就可以做大量的恢复和交付工作,让Spark的流计算更适应不同的需求。 
    3)集成性好,为流处理和批处理重用了同样的代码,甚至可以将流数据保存到历史数据中(如HDFS)。

    5.与已存Hadoop数据整合 
    Spark不仅可以独立的运行(使用standalone模式),还可以运行在当下的YARN管理集群中。它还可以读取已有的任何Hadoop数据,这是个非常大的优势,它可以运行在任何Hadoop数据源上,比如HBase、HDFS等。如果合适的话,这个特性让用户可以轻易迁移已有Hadoop应用。

    6.活跃和不断壮大的社区 
    Spark起源于2009年,当下已有超过50个机构730个工程师贡献过代码,与2014年6月相比2015年代码行数扩大了近三倍(数据源于Spark Summit 2015公布的数据),这是个惊人的增长。

    1.1.3 Spark的作用

    为什么现阶段Spark被如此众多的公司应用呢?从需求角度来看,信息行业数据量的不断积累膨胀,传统单机因本身软硬件限制无法处理,很需要能对大量数据进行存储和分析处理的系统,另一方面如Google、Yahoo等大型互联网公司因为业务数据量增长非常快,强劲的需求促进了数据存储和计算分析系统技术的发展,同时公司对大数据处理技术的高效实时性要求越来越高,Spark就是在这样一个需求导向的背景下出现,其设计的目的就是能快速处理多种场景下的大数据问题,能高效挖掘大数据中的价值,从而为业务发展提供决策支持。

    目前Spark已经在电商、电信、视频娱乐、零售、商业分析和金融等领域有广泛应用,在本书第四部分的应用篇能看到这些领域公司在Spark方面的应用分享,读者能从中一窥Spark的强大能力。

    1.1.4 Spark的体系结构

    如图1-5所示,Spark的体系结构不同于Hadoop的MapReduce和HDFS,Spark主要包括Spark Core和在Spark Core基础之上建立的应用框架Spark SQLSpark StreamingMLlibGraphX

    Core库中主要包括上下文(Spark Context)抽象数据集(RDD)调度器(Scheduler)洗牌(shuffle)序列化器(Serializer)。Spark系统中的计算、IO、调度和shuffle等系统基本功能都在其中。

    在Core库之上就根据业务需求分为用于交互式查询的SQL、实时流处理Streaming、机器学习Mllib和图计算GraphX四大框架,除此外还有一些其他实验性项目如Tachyon、BlinkDB和Tungsten等。这些项目共同组成Spark体系结构,当然Hadoop中的存储系统HDFS迄今仍是不可被替代,一直被各分布式系统所使用,它也是Spark主要应用的持久化存储系统。在1.3节和第四章可以更全面的学习到这四大应用框架的内容。

    Spark 体系结构

    1.1.5 Spark发展趋势

    不论国内外,信息技术都不断被企业和政府所重视,从德国的“工业4.0”到美国的“工业互联网”战略规划,再到中国的“中国制造2025”和“互联网+”,这其中无不体现政府对以云计算、物联网和大数据技术与传统工业深度融合,协同发展的期待,而中国本身是制造业大国,更需要先进的信息技术对接来提升工业制造水平来满足客户越来越个性化的需求。

    Spark平台技术本身也正被医疗、金融、电信、电商和政府等越来越多的领域所使用,相信在未来以大数据技术为代表的Spark平台以其优良的设计理念加上社区蓬勃的发展态势,极有可能在未来5到10年内成为大数据处理平台事实的标准。

    1.2 与现有分布式框架对比

    在讲述了关于Spark的背景、特点等内容后,还有一点值得提出的就是点燃大数据处理技术迅猛发展的技术平台应该是始于2004年的Hadoop,然而经过10多年的发展,传统以Hadoop为代表大数据处理技术因其当初设计目的缺
    陷,已经不能满足当前应用实时性以及迭代运算需求,一批新处理框架如雨后春笋般的出现,如流处理框架Storm、Samza、Spark Streaming和即席查询框架Spark SQL。本节将对他们进行对比,目的是让读者对新老框架的
    设计目的、应用及趋势有一定了解。
    

    1.2.1 批处理框架

    这里主要对比Hadoop与Spark在批处理方面的区别,他们在设计目的、计算模型和使用场景等方面进行对比,如表1-1所示。

    Hadoop与Spark的区别

    从表1-1中可以看出,发展10余年的Hadoop解决了处理大数据的问题,但因其设计之初没有考虑到效率,导致在面对迭代计算问题时效率很低,主要原因归结于其M/R计算模型太单一且计算过程中的Shuffle过程对本地硬盘的I/O消耗太大,不能适应复杂需求。不仅如此,当Hadoop要面对SQL交互式查询场景、实时流处理场景以及机器学习场景就力不从心,不得不跟其他第三方应用框架结合,导致不同类型业务(如流处理和SQL交互查询)在衔接过程中因涉及不同的数据格式,数据在共享和转换过程中要消耗大量资源。

    大家都知道内存计算速度比机械硬盘快几个数量级,Spark作为基于内存计算大数据处理平台以其高速、多场景适用的特点逐渐脱颖而出,体现了一个堆栈来解决各种场景(One stack rule all)的宗旨。

    1.2.2 流处理框架

    storm是一个分布式的、容错的实时计算系统,它由Twitter公司开源,专门用于数据实时处理的平台。它与Spark streaming功能相似,都是将流数据分成一个个小块的批(batch)数据进行
    数据处理,但也有很多不同,下面主要从处理延迟和容错两个方面进行分析:

    1.处理模型,延迟 虽然这两个框架都提供可扩展性和容错性,它们根本的区别在于他们的处理模型。Storm处理的是每次传入的一个事件,而Spark Streaming是处理某个时间段窗口内的事件流。因此,Storm处理一个事件可以达到秒内的延迟,而Spark Streaming则有秒级延迟。

    2.容错、数据保证 
    在容错数据保证方面,Spark Streaming提供了更好的支持容错状态计算。在Storm中,每个单独的记录当它通过系统时必须被跟踪,所以Storm能够至少保证每个记录将被处理一次,但是在从错误中恢复过来时候允许出现重复记录。这意味着可变状态可能被错误的更新两次。

    另一方面,Spark Streaming只需要在批级别进行跟踪处理,因此即便一个节点发生故障,也可以有效地保证每个批处理过程的数据将完全被处理一次。实际上Storm的Trident library库也提供了完全一次处理,但它依赖于事务更新状态,这比较慢,通常必须由用户实现。

    对于目前版本的Spark Streaming而言,最小选取的批数据量(Batch Size)可以在0.5-2秒钟之间(Storm目前最小的延迟是100ms左右),故Spark Streaming能够满足除对实时性要求非常高(如高频实时交易)之外的流式准实时(“准实时”表示数据延迟在秒级)计算场景。

    简而言之,如果需要毫秒级的延迟,Storm是一个不错的选择,而且没有数据丢失。如果需要有状态的计算,计算的时延是秒级,Spark Streaming则更好。Spark Streaming编程逻辑也可能更容易,因为它类似于批处理模型MapReduce,此外Spark因为融合了多种业务模型,如果面对融合不同业务场景,考虑到人工维护成本和数据转换成本,Spark平台能更符合需求。

    1.3 Spark生态系统

    Spark设计目的是全栈式解决批处理、结构化数据查询、流计算、图计算和机器学习业务场景,此外其通用性还体现在对存储层(如HDFS、cassandra[ cassandra:最初由Facebook开发的分布式NoSQL数据库,于2008年开源。])和资源管理层(MESOS[ MESOS:AMPLab最初开发的一个集群管理器,提供了有效的、跨分布式应用或框架的资源隔离和共享。]、YARN[ YARN:是一种新的 Hadoop 资源管理器,它是一个通用资源管理系统。])的支持。如图1-6是Spark生态系统,在Spark Core的上层有支持SQL查询的子项目Spark SQL、支持机器学习的MLlib库、支持图计算的GraphX以及支持流计算的Spark Streaming等。这样的生态圈让Spark的核心RDD抽象数据集能在不同应用中使用,大大减少数据转换的消耗和运维管理的资源。

    Spark生态系统

    图1-6所示的生态系统被AMPLab称为伯克利数据分析栈(BDAS:Berkeley Data Analytics Stack,),下面对BDAS中的主要项目进行介绍。

    1.Spark 
    作为Spark生态系统的核心,Spark主要提供基于内存计算的功能,不仅包含Hadoop的计算模型的MapReduce,还包含很多其他的如reduceByKey、groupByKey、foreach、join和filter等API。Spark将数据抽象为弹性分布式数据集,有效扩充了Spark编程模型,能让Spark成为多面手,能让交互式查询、流处理、机器学习和图计算的应用无缝交叉融合,极大的扩张了Spark的应用业务场景,同时Spark使用函数式编程语言Scala,让编程更简洁高效。

    2.SQL/Shark 
    Shark是为了将Hive应用移植到Spark平台下而出现的数据仓库。Shark在HQL(一般将Hive上对SQL支持的语言称为HQL)方面重用了Hive的HQL解析、逻辑计划翻译、执行计划优化等逻辑,可以认为仅将底层物理执行计划从Hadoop的MR作业转移到Spark作业,此外还赖Hive Metastore和Hive SerDe。这样做会导致执行计划过于依赖Hive,不方便添加新的优化策略,因此为了减少对Hive本身框架的依赖,引入Spark SQL解决上述问题。

    Spark SQL仅依赖HQL Parser、Hive metastore和Hive SerDe,即说明在解析SQL生成抽象语法树(Abstract Syntax Tree,AST)后的部分都是由Spark SQL自身的Calalyst负责(图1-7所示为Spark SQL与Hive之间的关系),利用scala模式匹配等函数式语言的特性,让Catalyst开发的执行计划优化策略比Hive更简洁。除了HQL以外,Spark SQL还内建了一个精简的SQL parser,以及一套Scala特定领域语言(Domain Specific Language, DSL)。也就是说,如果只是使用Spark SQL内建的SQL方言或Scala DSL对原生RDD对象进行关系查询,用户在开发Spark应用时完全不需要依赖Hive的任何东西,因而日后的发展趋势重点在Spark SQL,对Shark的支持会逐渐淡化。

    Spark SQL从Spark1.3开始支持提供一个抽象的编程结构DataFrames,能充当分布式SQL查询引擎。DataFrame本质就是一张关系型数据库中的表,但是底层有很多方面的优化,它能从多种数据源中转化而来,例如结构型数据文件(如Avro, Parquet, ORC, JSON和JDBC)、Hive表、外部数据库或已经存在的RDD。对于Spark SQL,本书将在之后的第4章4.1节对其展开进行更详细的介绍。

    这里写图片描述

    3.Spark Streaming 
    Spark Streaming是基于Spark的上层应用框架,使用内建API,能像写批处理文件一样编写流处理任务,易于使用,它还提供良好的容错特性,能在节点宕机情况下同时恢复丢失的工作和操作状态。

    在处理时间方面,Spark Streaming是基于时间片准实时处理,能达到秒级延迟,吞吐量比Storm大,此外还能和Spark SQL与Spark MLlib联合使用,构建强大的流状态运行即席(ad-hoc)查询和实时推荐系统。对于Spark Streaming,本书将在之后第4章4.2节对其展开进行更详细的介绍。

    4.GraphX 
    GraphX是另一个基于Spark的上层的分布式图计算框架,提供了类似Google图算法引擎Pregel的功能,主要处理社交网络等节点和边模型的问题。因为Spark能很好的支持迭代计算,故处理效率优势明显。GraphX的最新版(Spark 1.4.1)支持PageRank、SVD++和三角形计数等算法。目前国内的淘宝技术部在graphX方面的应用成果很多,可以参考http://rdc.taobao.org了解更多信息。对于GraphX,本书将在之后第4章4.3节对其展开进行更详细的介绍。

    5.MLlib 
    MLlib是Spark生态系统在机器学习领域的重要应用,它充分发挥Spark迭代计算的优势,能比传统MapReduce模型算法快100倍以上。 
    MLlib 1.3实现了逻辑回归、线性SVM、随机森林、K-means、奇异值分解等多种分布式机器学习算法,充分利用RDD的迭代优势,能对大规模数据应用机器学习模型,并能与Spark Streaming、Spark SQL进行协作开发应用,让机器学习算法在基于大数据的预测、推荐和模式识别等方面应用更广泛。对于MLlib以及其中支持的算法,本书将在之后第4章4.4节对其展开进行更详细的介绍。

    6.Tachyon 
    Tachyon是基于内存的分布式文件系统。过去Spark的计算功能和内存管理都在JVM中,导致JVM负载较高,同时各任务共享数据也不方便,当JVM崩溃后很多缓冲数据也会丢失,为了解决上述问题,从而衍生出Tachyon技术。

    其主要设计目的是分离Spark的计算功能和内存管理功能,让内存管理脱离JVM,专门设计Tachyon来在JVM外管理内存数据。这样做解决了Spark在数据共享、缓存数据丢失情况下效率较低的问题,还能减少JVM因为数据量过多导致经常的GC垃圾收集,有效提升了Spark的计算效率。从另一个角度看,Tachyon在Spark计算框架和基于磁盘HDFS之间可看成内存与硬盘之间的缓存,能有效提升数据读取速度。

    7.Mesos 
    Mesos是一个集群管理器,与YARN功能类似,提供跨分布式应用或框架的资源隔离与共享,上面运行Hadoop(一种类似Spark的分布式系统基础架构)、Hypertable(一种类似Google公司Bigtable的数据库)、Spark,。Mesos使用分布式应用程序协调服务Zookeeper实现容错,同时利用基于Linux的容器隔离任务,支持不同的资源分配计划。

    8.YARN 
    YARN(Yet Another Resource Negotiator)最初是为Hadoop生态设计的资源管理器,能在上面运行Hadoop、Hive、Pig(Pig是一种基于Hadoop平台的高级过程语言)、Spark等应用框架。在Spark使用方面,YARN与Mesos很大的不同是Mesos是AMPlab开发的资源管理器,对Spark支持力度很大,但国内主流使用仍是YARN,主要是YARN对Hadoop生态的适用性更好。

    9.BlinkDB 
    BlinkDB 是一个用于在海量数据上运行交互式SQL近似查询的大规模并行查询引擎。它允许用户在查询结果精度和时间上作出权衡,其数据的精度被控制在允许的误差范围内。BlinkDB达到这样目标的两个核心思想分别是提供一个自适应优化框架,从原始数据随着时间的推移建立并维护一组多维样本,另一个是使用一个动态样本选择策略,选择一个适当大小的示例,基于查询的准确性和响应时间来实现需求。

    1.4 Spark的数据存储

    Spark本身是基于内存计算的架构,数据的存储也主要分为内存和磁盘两个路径,Spark本身则根据存储位置、是否可序列化和副本数目这几个要素将数据存储分为多种存储级别。此外还可选择使用Tachyon来管理内存数据。

    为了适应迭代计算,Spark将经常被重用的数据缓存到内存中以提升数据读取速度,当内存容量有限的时候则将数据存入磁盘中或根据最近最少使用页面置换算法(Least Recently Used,LRU)算法将内存中使用频率较低的文件空间收回,从而让新的数据进来。

    Tachyon的出现主要是为了解决三个问题而设计。第一个是多应用数据共享问题,其次是JVM缓存数据丢失问题,再次是GC开销问题。它将过去的Spark中计算和内存管理两个部分分离,专门使用Tachyon在JVM堆外管理Spark计算所需要的数据,极大的减轻了Spark管理上的负担和JVM内存负担。这种设计思路能很好的解决以上三个问题并提升程序运行的稳定性和速度,在第5.4节能了解更多Tachyon的内容。

    1.5 本章小结

    本章首先对Spark进行概述,对Spark发展历程及目前应用态势进行详细说明,体现了Spark在全球和国内在大数据平台领域如火如荼的发展形势;然后对Spark平台与Hadoop平台在数据批处理以及流式处理方面进行对比分析,让读者知道大数据平台的来龙去脉和发展趋势。最后介绍了Spark的生态系统,Spark作为一个开源分析处理平台,为了应对现实环境中复杂的场景,必然要与不同的框架结合使用才能发挥更好的性能,其中的Spark SQL、Spark Streaming、MLlib和graphX被广泛的应用在工业界各领域,后面章节将对这些技术应用进行详细说明,下一章将学习Spark运行环境和源码阅读环境的搭建方法。

    本教程源于2016年3月出版书籍《Spark原理、机制及应用》 ,如有兴趣,请支持正版。

    展开全文
  • 大数据Spark

    千次阅读 2019-07-10 11:27:23
    一、Spark (一)Kafka 1.JMS 规范是什么 (1)JMS 的基础 JMS 是什么:JMS 是 Java 提供的一套技术规范,即 Java 消息服务(Java Message Service)应用程序接口。是一个 Java 平台中关于面向消息...

    一、Spark

    (一)Spark基础知识

    1、Spark的产生背景
    
     1. MapReduce的发展 
     
       1.1、MRv1的缺陷 
       
       (1)MRv1包括: 
        运行时环境(JobTracker和TaskTracker) 
        编程模型(MapReduce) 
        数据处理引擎(MapTask和ReduceTask) 
       (2)不足:
        可扩展性差:JobTracker既负责资源调度又负责任务调度
        可用性差:采用单节点Master,容易产生单点故障
        资源利用率低
        不能支持多种MapReduce框架
        
       1.2、MRv2的缺陷 
       
       (1)运行时环境被重构:
       	JobTracker拆分为:
       	资源调度平台(ResourceManager)、
       	节点管理器(NodeManager)
       	负责各个计算框架的任务调度模型(ApplicationMaster)
       (2)不足:
       	由于对HDFS的频繁操作(包括计算结果持久化、数据备份、资源下载及Shuffle等)
       	导致磁盘I/O成为系统性能的瓶颈,因此只适用于离线数据处理或批处理,而不能支持
       	对迭代式、交互式、流式数据的处理。
       	
       1.3、Spark的产生
       
       (1)减少磁盘I/O:Spark允许将map端的中间输出和结果存储在内存中,reduce端
       在拉取中间结果是避免了大量的磁盘I/O。Spark将应用程序上传的资源文件缓冲到Driver
       本地文件服务的内存中,当Executor执行任务时直接从Driver的内存中读取,也节省
       了大量的磁盘I/O。
       (2)增加并行度:Spark把不同的环节抽象为Stage,允许多个Stage既可以串行执行,
       又可以并行执行。
       (3)避免重新计算:当Spark中的某个分区的task执行失败后,会重新对此stage调度,
       但在调度的时候会过滤掉已经执行成功的分区任务,所以不会造成重复计算和资源浪费。
       (4)可选的Shuffle和排序:Hadoop MapReduce在Shuffle之前有着固定的排序
       操作(只能对key进行字典排序),Spark可以根据不同的场景选择在map端排序或者
       reduce端排序。
       (5)灵活的内存管理策略:Spark将内存分为堆上的存储内存、堆外的存储内存、堆上
       堆上的执行内存、堆外的执行内存。
       
    2、Spark特点
    
     1. 快速高效
     2. 简洁易用
     3. 全栈式数据处理
       3.1、支持批处理(SparkCore)
       3.2、支持交互式查询(SparkSQL)
       3.3、支持流式计算(SparkStreaming)
       3.4、 支持机器学习(Spark MLlib)
       3.5、 支持图计算(Spark GraghX)
       3.6、 支持Python操作(PySpark)
       3.7、支持R语言(SparkR)
     4. 兼容
       4.1、可用性高
       4.2、丰富的数据源支持
       
    3、Spark应用场景
    
     1. 复杂的批量处理(SparkCore)
     2. 基于历史数据的交互式查询(SparkSQL)
     3. 基于实时数据流的数据处理(SparkStreaming)
    

    (二)SparkCore

    1、Spark核心概念
    
     1.Application
     	表示应用程序,包含一个Driver Program和若干Executor
     2.Driver Program
     	Spark中的Driver,即运行上述Application的main()函数并且创建SparkContext,其中
     创建SparkContext的目的是为了准备Spark应用程序的运行环境。由SparkContext负责与
     Cluster Manager 通信,进行资源的申请,任务的分配和监控等。程序执行完毕后关闭
     SparkContext。
     3.ClusterManager
     	在standalone模式中即为Master(主节点),控制这个集群,监控Worker。在YARN模式
     中为资源管理器。
     4.SparkContext
     	整个应用的上下文,控制应用程序的生命周期,负责调度各个运算资源,协调各个Worker
     上的Executor。初始化的时候,会初始化DAGScheduler和TaskScheduler两个核心组件。
     5.RDD
     	Spark的基本计算单元,一组RDD可形成执行的有向无环图RDD Gragh。
     6.DAGScheduler
     	根据Job构建基于Stage的DAG,并提交Stage给TaskScheduler,其划分Stage的依据是
     RDD之间的依赖关系:宽依赖,也叫Shuffle依赖。
     7.TaskScheduler
     	将Taskset提交给Worker(集群)运行,每个Executor运行什么Task就是在此处分配的。
     8.Worker
     	集群中可以运行Application代码的节点。在Standalone模式中指的是通过slave文件配置的
     worker节点,在Spark on YARN模式中指的就是NodeManager节点。
     9.Executor
     	某个Application运行在Worker节点上的一个进程,该进程负责运行某些task,并且把数据
     存在内存或者磁盘上。
     10.Stage
     	每个Job会被拆成很多组Task,每组作为一个TaskSet,其名称为Stage。
     11.Job
     	包含多个Task组成的并行计算,是由Action行为触发的
     12.Task
     	在Executor进程中执行任务的工作单元,多个Task组成一个Stage。
     13.SparkEnv
     	线程级别的上下文,存储运行时的重要组件的引用。
     	SparkEnv内创建并包含如下一些重要组件的引用:
     		MapOutPutTracker:负责Shuffle元数据的存储
     		BroadcastManager:负责广播变量的控制与元信息的存储
     		BlockManager:负责存储管理、创建和查找块
     		MetricsSystem:监控运行时性能指标信息
     		SparkConf:负责存储配置信息
     		
    2、Spark核心功能
    
     1. SparkContext
     	通常而言,DriverApplication 的执行与输出都是通过 SparkContext 来完成的,
     在正式提交Application 之前,首先需要初始化 SparkContext。SparkContext 
     隐藏了网络通信、分布式部署、消息通信、存储能力、计算能力、缓存、测量系统、文件
     服务、Web 服务等内容,应用程序开发者只需要使用 SparkContext 提供的 API 完成
     功能开发。
    	SparkContext 内置的 DAGScheduler 负责创建 Job,将 DAG 中的 RDD 划分
     到不同的 Stage,提交 Stage 等功能。
    	SparkContext 内置的 TaskScheduler 负责资源的申请、任务的提交及请求集群
     对任务的调度等工作。
     2.存储体系
     	Spark 优先考虑使用各节点的内存作为存储,当内存不足时才会考虑使用磁盘,
     这极大地减少了磁盘 I/O,提升了任务执行的效率
     3.计算引擎
     	计算引擎由 SparkContext 中的 DAGScheduler、RDD 以及具体节点上的 Executor 
     负责执行的 Map 和 Reduce 任务组成。
     4.部署模式
      	通过使用 Standalone、YARN、Mesos、kubernetes、Cloud等部署模式为 Task 
     分配计算资源,提高任务的并发执行效率。
     
    3、Spark基本架构
    
     Spark集群组成:
     1.Cluster Manager:
     	Spark的集群管理器,主要负责资源的分配和管理。集群管理器分配的资源属于一级分配,
     它将各个Worker上的内存、CPU等资源分配给应用程序,但是并不负责对Executor的资源
     分配。目前,Standalone、YARN、Mesos、K8S,EC2 等都可以作为 Spark的集群管理
     器。
     2.Master:Spark集群的主节点
     3.Worker:
     	Spark的工作节点。对Spark应用程序而言,有集群管理器分配得到资源的Worker节点
     主要负责以下工作:创建Executor,将资源和任务进一步分配给Executor,
     同步资源信息给Cluster Manager。
     4.Executor:
     	执行计算任务的一些进程。主要负责任务的执行以及与Worker、Driver Application
     的信息同步。
     5.Driver Application:
     	客户端驱动程序,也可以理解为客户端应用程序,用于将任务程序转化为RDD和DAG,
     并与Cluster Manager进行通信和调度。
     
    4、Spark运行流程
    
     1.构建DAG
     	使用算子操作RDD进行各种Transformation操作,最后通过action操作出发Spark作业运行。
     提交之后Spark会根据转换过程所产生的RDD之间的依赖关系构建有向无环图。
     2.DAG切割
     	DAG切割主要根据RDD的依赖是否为宽依赖来决定切割节点,当遇到宽依赖就将任务划分为
     一个新的调度阶段(stage)。每个Stage中包含一个或多个Task。这些Task将形成任务集
     (Taskset),提交给底层调度器进行调度运行。
     3.任务调度
     	每一个Spark任务调度器只为一个SparkContext实例服务。当任务调度器收到任务集后负责
     把任务集以Task的形式分发给Worker节点的Executor进程中运行,如果某个任务执行失败,
     任务调度器负责重新分配该任务的计算。
     4.执行任务
     	当Executor收到发送过来的任务后,将以多线程(会在启动executor的时候就初始化好了一
     各线程池)的形式执行任务的计算,每个线程负责一个任务,任务结束后会根据任务的类型选
     择相应的返回形式将结果返回给任务调度器。
    
    5、RDD概述
    
     1.什么是RDD
     	RDD叫做分布式数据集,是Spark中最基本的抽象概念,它代表一个不可变、可分区、
     里面的元素可并行计算的集合。
     	1.1、数据集DataSet
     		RDD是数据集合的抽象,是复杂物理介质存在数据的一种逻辑视图。从外部来看,
     	RDD的确可以被看待成经过封装,带扩展特性的数据集合。
     	1.2、分布式Distributed
     		RDD的数据可能在物理上存储在多个节点的磁盘或内存中,也就是所谓的多级存储。
     	1.3、弹性Resilient
     		虽然RDD内部存储的数据是可读的,但是我们可以去修改并行计算单元的划分结构,
     	也就是分区的数量。
     2.RDD的特点
     	自动容错、位置感知性调度、可伸缩性
     3.RDD的属性
     	3.1、A list of partitions
     		一组分片(partition),及数据集的基本组成单位。分区的个数决定了并行的粒度。
     	分区的个数可以在创建RDD的时候进行设置,若没有,则默认为cores个数。每个partition
     	最终会bei被逻辑映射为BlockManager中的一个Block,而这个Block会被下一个Task使用
     	进行计算。
     	3.2、A function for computing each split
     		一个计算每个分区的函数,也就是算子。
     	3.3、A list of dependencies on other RDDs
     		RDD之间的依赖关系:宽依赖和窄依赖
     		宽依赖:一个子RDD中的分区可以依赖于父RDD分区中一个或多个完整分区。
     		窄依赖:父RDD的一个partition中的部分数据与RDDx的一个partition相关,而另一部分
     		数据则与RDDx中的另一个partition有关。
     	3.4、Optionally, a Partitioner for key-value RDDs (e.g. to say that the RDD is hash-partitioned)
     		一个partitioner,即RDD的分片函数。
     	3.5、Optionally, a list of preferred locations to compute each split on (e.g. block locations for an HDFS file)
     		一个列表,存储存取每个partition的优先位置。
     4.RDD创建
     	4.1、由一个已经存在的Scala数据集合创建
     		val rdd = sc.parallelize(Array(1,2,3,4,5,6,7,8))
            val rdd = sc.makeRDD(Array(1,2,3,4,5,6,7,8))
        4.2、由外部存储系统的数据集创建
        	val rdd = sc.textFile("hdfs://myha01/spark/wc/input/words.txt")
        4.3、扩展
        	从 HBase 当中读取
            从 ElasticSearch 中读取    
     5.Transformation转换
     	转换算子:map、filter、flatMap、mapPartitions、sample、union、intersection、
     	distinct、groupByKey、aggregateByKey、sortByKey、sortBy、join、coalesce、
     	repartition、foldByKey、combineByKey、partitionBy、cache、persist、substract、
     	leftOuterJoin、rightOuterJoin、subtractByKey
     	总结:Transformation返回值还是一个RDD。它使用l了链式调用的设计模式,对一个
     	RDD进行计算后,变换成另一个RDD,然后这个RDD又可以进行另外一次转换。这个
     	过程是分布式的。
     6.Action
     	Action算子:reduce、reduceByKeyLocally、collect、count、first、take、takeSample、
     	top、takeOrdered、countByKey、foreach、foreachPartition、fold、aggregate、
     	lookup、saveASTextFile、saveAsSequenceFile、saveAsObjectFile
     	总结:Action返回值不是一个RDD。它要么是一个Scala的普通集合,要么是一个值,
     	要么是空,最终返回到Driver程序,或把RDD写入到文件系统中。
     	
    6、Spark任务执行流程
    

    Spark任务执行流程

     7、Spark On StandAlone运行过程
    

    Spark On StandAlone运行过程

    8、Spark On YARN YARN-Client运行过程
    

    Spark On YARN YARN-Client运行过程

    9、Spark On YARN YARN-Cluster运行过程
    

    Spark On YARN YARN-Cluster运行过程

    10、YARN-Client 和 YARN-Cluster 区别
    
     1.YARN-Cluster模式下,Driver运行在AM(Application Master),它负责向YARN申请资源,
     并监督作业的运行状况。当用户提交了作业之后,就可以关掉Client,作业会继续在YARN
     上运行,因而YARN-Cluster模式不适合运行交互类型的作业。
     2.YARN-Client模式下,ApplicationMaster仅仅向Yarn请求Executor,Client会和请求的
     container通信来调度他们工作,也就是说client不能离开。
     
    11、Spark内存模型
     
     1.在执行Spark的应用程序时,Spark集群会启动Driver和Executor两种JVM进程。
     	1.1、前者为主控进程,负责创建Spark上下文对象SparkContext,提交Spark作业(job),
     	并将作业转换为计算任务(Task),在各个Executor进程间协调任务的调度。
     	1.2、后者负责在工作节点上执行具体的计算任务,并将结果返回给Driver,同时为需要持
     	久化的RDD提供存储功能。
     2.堆内和堆外内存规划
     	对堆内内存进行更为详尽的分配,引入堆外内存
     	2.1、堆内内存
     		堆内内存的大小,由Spark应用程序启动时的--executor-memory或
     	spark.executor.memory
     		(1)Executor内运行的并发任务共享JVM堆内内存,这些任务在缓存RDD数据集和
     		广播(Broadcast)数据时占用的内存被规划为存储内存。
     		(2)这些任务在执行Shuffle时占用的内存被规划为执行内存。
     		(3)剩余的部分不做特殊规划,那些Spark内部的对象实例,或者用户自定义的Spark
     		应用程序中的对象实例,均占用剩余的空间other。
     	    Spark申请内存:
     	    (1)Saprk在代码中new一个对象实例
     	    (2)JVM从堆内内存分配空间,创建对象并返回对象引用
     	    (3)Spark保存该对象的引用,记录该对象占用的内存
     	    Spark释放内存:
     	    (1)Spark记录该对象释放的内存,删除该对象的引用
     	    (2)等待JVM的垃圾回收机制释放该对象占用的堆内内存
     	   	JVM 的对象可以以序列化的方式存储,序列化的过程是将对象转换为二进制字节流,
     	本质上可以理解为将非连续空间的链式存储转化为连续空间或块存储,在访问时则需
     	要进行序列化的逆过程--反序列化,将字节流转化为对象,序列化的方式可以节省存储空 		
     	间,但增加了存储和读取时候的计算开销。对于 Spark 中序列化的对象,由于是字节流的形
     	式,其占用的内存大小可直接计算,而对于非序列化的对象,其占用的内存是通过周期性地
     	采样近似估算而得。
     	2.2、堆外内存
     		Spark 可以直接操作系统堆外内存,减少了不必要的内存开销,以及频繁的 GC 扫描和回
     	收,提升了处理性能。堆外内存可以被精确地申请和释放,而且序列化的数据占用的空间可
     	以被精确计算,所以相比堆内内存来说降低了管理的难度,也降低了误差。
     		在默认情况下堆外内存并不启用,可通过配置 spark.memory.offHeap.enabled 参数启
     	用,并由 spark.memory.offHeap.size 参数设定堆外空间的大小。
     	
    12、资源参数调优
    
     1.num-executors
     	1.1、参数说明:该参数用于设置 Spark 作业总共要用多少个 Executor 进程来执行。
     	1.2、参数调优建议:每个 Spark 作业的运行一般设置 50~100 个左右的 Executor 进程比较
     合适
     2.executor-memory
     	2.1、参数说明:该参数用于设置每个 Executor 进程的内存。
     	2.2、参数调优建议:每个 Executor 进程的内存设置 4G~8G 较为合适。
     3.executor-cores
     	3.1、参数说明:该参数用于设置每个 Executor 进程的 CPU core 数量。
     	3.2、参数调优建议:Executor 的 CPU core 数量设置为 2~4 个较为合适。
     4.driver-memory
     	4.1、参数说明:该参数用于设置 Driver 进程的内存。
     	4.2、参数调优建议:Driver 的内存通常来说不设置,或者设置 1G 左右应该就够了。唯一需
     要注意的一点是,如果需要使用 collect 算子将 RDD 的数据全部拉取到 Driver 上进行处理,
     那么必须确保 Driver 的内存足够大,否则会出现 OOM 内存溢出的问题。
     5.spark.default.parallelism
     	5.1、参数说明:该参数用于设置每个 stage 的默认 task 数量。
     	5.2、参数调优建议:Spark 作业的默认 task 数量为 500~1000 个较为合适。
     6.spark.storage.memoryFraction
     	6.1、参数说明:该参数用于设置 RDD 持久化数据在 Executor 内存中能占的比例,默认是 
     0.6。
     	6.2、参数调优建议:如果 Spark 作业中,有较多的 RDD 持久化操作,该参数的值可以适当
     提高一些,保证持久化的数据能够容纳在内存中。避免内存不够缓存所有的数据,导致数据只
     能写入磁盘中,降低了性能。但是如果 Spark 作业中的 shuffle 类操作比较多,而持久化操作
     比较少,那么这个参数的值适当降低一些比较合适。此外,如果发现作业由于频繁的 gc 导致
     运行缓慢(通过 spark web ui 可以观察到作业的 gc 耗时),意味着 task 执行用户代码的内存
     不够用,那么同样建议调低这个参数的值。
     7、spark.shuffle.memoryFraction
     	7.1、参数说明:该参数用于设置 shuffle 过程中一个 task 拉取到上个 stage 的 task 的输出
     后,进行聚合操作时能够使用的 Executor 内存的比例,默认是 0.2。
     	7.2、如果 Spark 作业中的 RDD 持久化操作较少,shuffle 操作较多时,建议降低持久化操
     作的内存占比,提高 shuffle 操作的内存占比比例,避免 shuffle 过程中数据过多时内存不够
     用,必须溢写到磁盘上,降低了性能。
    

    (三)Spark SQL

    1、Spark SQL概述
    
     1.Spark SQL是Spark用来处理结构化数据(结构化数据可以来自外部结构数据源也可以通
     过RDD获取)的一个模块,它提供了一个编程抽象DataFrame并且作为分布式SQL查询引擎的
     作用。
     2.工作机制是将 Spark SQL 的 SQL 查询转换成 Spark Core 的应用程序,然后提交到集群
     执行。
     3.Spark SQL特点
     	3.1、容易整合
     	3.2、统一的数据访问方式
     	3.3、兼容Hive
     	3.4、标准的数据连接
     4.Spark SQL编程
     	4.1、创建 SparkSession 对象,Spark-2.0.x之后找到SparkSession
     	4.2、通过程序入口构建一个 DataFrame 或 Dataset
     	4.3、在 DataFrame 或 Dataset 之上进行转换和 Action。最重要编写SQL语句。
     	4.4、对得到的数据结果进行处理
     	
    2、SparkSession
    
     1.SparkSession 是 Spark-2.0 引如的新概念。SparkSession 为用户提供了统一的切入点,来
     让用户学习 Spark 的各项功能。
     2.在 Spark 的早期版本中,SparkContext 是 Spark RDD API的主要切入点。在 Spark2.0 中,
     引入 SparkSession 作为 DataSet 和 DataFrame API 的切入点。
     	2.1、对于 Spark Streaming,我们需要使用 StreamingContext
    	2.2、对于 Spark SQL,使用 SQLContext
    	2.3、对于 Hive,使用 HiveContext
    	SparkSession 实质上是 SQLContext 和 HiveContext 的组合
     3.特点
     	3.1、为用户通过一个统一的切入点使用Spark的各项功能
     	3.2、允许用户通过它调用DataFrame和Dataset相关API来编写程序
     	3.3、减少了用户需要了解的一些概念,可以很容易的和Spark进行交互
     	3.4、与Spark交互之时不需要显示的创建SparkConf、SparkContext以及SQLContext,这些
     	对象以及封闭在SparkSession中
     	3.5、SparkSession提供对Hive特征的内部支持:用HiveSQL写SQL语句,访问HDFS,从
     	Hive表中读取数据。
     	
    3、RDD/DataFrame/Dataset
    
     1.RDD的局限性
     	1.1、RDD仅表示数据集,RDD没有元数据,也就是说没有字段语义定义
     	1.2、RDD需要用户自己优化程序
     	1.3、从不同数据源读取数据相对困难,读取到不同格式的数据都必须用户自己定义转换方
     	式。合并多个数据源中的数据也较困难。
     2.DataFrame
     	1.1、DataFrame = RDD + Schema((元数据) = SchemaRDD
     	1.2、内部数据无类型,统一为Row
     	1.3、DataFrame是一种特殊类型的Dataset
     	1.4、DataFrame自带优化器,可以自动优化程序
     	1.5、DataFrame提供了一整套的Data source API
     	
    4、Dataset的产生
    
     1.DataFrame的缺陷
     	1.1、Row运行时无提供编译时类型检查
     	1.2、Row不能直接操作domin对象
     	1.3、函数风格编程,没有面向对象风格的API
     2.DataFrame 和 Dataset 可以采用更加通用的语言(Scala 或 Python)来表达用户的查询请
     求。此外,Dataset 可以更快捕捉错误,因为 SQL 是运行时捕获异常,而 Dataset 是编译时
     检查错误。
    
    5、DataFrame常用操作
    
     1.DSL风格语法
     	1.1、打印DataFrame的Schema信息
     	studentDF.printSchema	
     	1.2、查看DataFrame中的所有内容
     	studentDF.show	
     	1.3、查看DataFrame部分列中的内容
     	studentDF.select("name","age").show	
     	studentDF.select(col("name"), col("age")).show
     	studentDF.select(studentDF.col("name"), studentDF.col("age")).show
     	1.4、查询所有的 name 和 age,并将 age+1
     	studentDF.select(col("id"),col("name"),col("age")+1).show
     	studentDF.select(studentDF ("id"), studentDF ("name"), studentDF ("age") + 1).show
     	1.5、过滤 age 大于等于 20 的
     	studentDF.filter(col("age") >= 20).show
     	1.6、按年龄进行分组并统计相同年龄的人数
     	studentDF.groupBy("age").count().show()
     2.SQL风格语法
     	2.1、Session 范围内的临时表
     	studentDF.createOrReplaceTempView(“t_student”)
     	只在 Session 范围内有效,Session 结束临时表自动销毁
     	2.2、全局范围内的临时表
     	studentDF.createGlobalTempView(“t_student”)
     	所有 Session 共享
     	2.3、查询年龄最大的前五名
     	sqlContext.sql("select * from t_student order by age desc limit 5").show
     	2.4、显示表的 Schema 信息
     	sqlContext.sql("desc t_student ").show
     	2.5、统计学生数超过 6 个的部门和该部门的学生人数。并且按照学生的个数降序排序
     	sqlContext.sql("select department, count(*) as total from t_student group by department
     	having total > 6 order by total desc").show
    

    (四)Spark Streaming

    1、Spark Streaming概述
    
     1.Spark Streaming用于流式数据的处理,例如实时推荐、实时网站性能分析等
     2.特点
     	2.1、高吞吐量
     	2.2、容错能力强
     	2.3、支持的数据输入源很多
     	2.4、结果能保存在很多地方
     3.处理机制
     		接收实时流的数据,并根据一定的时间间隔拆分成一批批的数据,然后通过Spark Engine
     	处理这些批数据,最终得到处理后的y一批批结果数据。对应的批数据,在Spark内核对应一
     	个RDD实例,因此,对应流的DStream可以看出是一组RDDs,即RDD的一个序列。
     		总结:Spark Streaming 的基本原理是将输入数据流以时间片(秒级)为单位进行拆分,然	
     	后以类似批处理的方式处理每个时间片数据。
     	
    2、Spark Streaming核心术语
    
      1.离散流或DStream
      	这是对Spark Streaming对内部持续的实时数据流的抽象描述,即我们处理的一个实时数据
      流,在Spark Streaming中对应着一个DStream实例。
      2.批数据
      	这是化整为零的第一步,将实时流数据以时间片为单位进行分批,将流处理转化为时间片数
      据的批处理。随着持续时间的推移,这些处理结果就形成了对应的结果数据流了。
      3.时间片或批处理时间间隔
      	这是人为的对流数据进行定量的标准,以时间片作为我们拆分流数据的依据。一个时间片的
      数据对应一个RDD实例。
      4.窗口长度
      	一个窗口覆盖的流数据的时间长度。必须是批处理时间间隔的倍数。
      5.滑动时间间隔
      	前一个窗口到后一个窗口所经过的时间长度。必须是批处理时间间隔的倍数。
      6.Input DStream
      	一个Input DStream是一个特殊的DStream,将Spark Streaming连接到一个外部数据源来读
      取数据。
      
    3、DStream相关操作
    
      1.特殊的Transformations
      	1.1、UpdateStateByKey Operation
      		UpdateStateByKey Operation原语用于记录历史记录。若不用UpdateStateByKey 来更新
      	状态,那么每次数据进来后分析完成后,结果输出后将不再保存。
      		要使用此功能,必须进行以下两个步骤:
      		(1)定义状态-状态可以是任意的数据类型
      		(2)定义状态更新函数-用一个函数指定如何使用先前的状态和从输入流中获取的新值更
      		新状态。
      	1.2、Transform Operation
      		Transfrom原语允许DStream上执行任意的RDD-to-RDD函数。通过该函数可以方便的扩
      	展Spark API。此外,机器学习以及图计算也是通过本函数来结合的。
      	1.3、Window Operations
      		Window Operations类似于Storm中的state,可以设置窗口的大小和滑动窗口的间隔来动
      	态的获取当前Streaming的状态。
      		在Spark Streaming中,数据处理是按批处理的,而数据采集是逐条进行的,因此会先设
      	置好批处理间隔,当超过批处理间隔的时候就会把采集到的数据汇总起来成为一批数据交给
      	系统去处理。
      		例如,批处理间隔是 1 个时间单位,窗口间隔是 3 个时间单位,滑动间隔是 2 个时间单
    	位。对于初始的窗口 time 1-time 3,只有窗口间隔满足了才触发数据的处理。这里需要注意
    	的一点是,初始的窗口有可能流入的数据没有撑满,但是随着时间的推进,窗口最终会被撑
    	满。当每隔 2 个时间单位,窗口滑动一次后,会有新的数据流入窗口,这时窗口会移去最早
    	的两个时间单位的数据,而与最新的两个时间单位的数据进行汇总形成新的窗口(time3-
    	time5)。
      2.Output Operations
     	Output Operations 可以将 DStream 的数据输出到外部的数据库或文件系统,当某个 Output 
     Operations 原语被调用时(与 RDD 的 Action 相同),Streaming 程序才会开始真正的计算过
     程。
     
    4、Spark Streaming编程步骤
    
     1.创建完成 StreamingContext
     2.通过输入源创建Input DStream
     3.对DStream进行Transformation和output操作,这样构成了后期流式计算的逻辑
     4.通过streamingContext.start()方法启动接收和处理数据的流程
     5.使用 streamingContext.awaitTermination()方法等待程序结束(手动停止或出错停止)
     6.也可以调用 streamingContext.stop()方法结束程序的运行
     关于StreamingContext值得注意:
     	(1)在StreamingContext启动之前,要定义好所有的计算逻辑。启动后,增加新的操作不
     	起作用。停止后,不能重新启动,若要重新计算,需要重新运行整个程序。
     	(2)在单个JVM中,一段时间内不能出现两个active状态的StreamingContext。
     	(3)当在调用streamingContext的stop方法时,默认情况下sparkContext也会被停止掉。如    
     	果希望保留sparkCOntext,则需要在stop方法中传入参数stopSparkContext=false。
     	(4)一个SparkContext可以创建多个StreamingContext,只要前一个StreamingContext已
     	经停止了。
     	
    5、InputDStreams和Receivers
    
     1.InputDStream指的是从数据流的源头接受的输入数据流。除文件流外,每个InputDStream都
    关联着一个Receiver对象,该Receiver对象接受数据源传来的数据并将其保持在内存中以便后
    期Spark处理。
     2.SparkStreaming支持的流数据源
     	2.1、basic sources(基础流数据源)
    	直接通过API创建,例如文件系统、sosocket连接以及akka的Actor
    	2.2、advanced sources(高级流数据源)
    	如kafka、flume等,需要借助外部工具类
    	2.3、custom sources(自定义流数据源)
    	用户自定义receivers
     3.注意
     	3.1、在本地运行Spark Streaming应用程序时,要使用‘local【n】’作为master url,n要大于
     	receivers都是数量。receivers自身就需要一个线程来运行。
     	3.2、在集群上运行Spark Streaming时,分配给程序的CPU核数也必须大于receivers的数
     	量,否则系统将只接受数据,无法处理数据。
    

    (五)Kafka

    1.JMS 规范是什么
    
    (1)JMS 的基础
    
    	JMS 是什么:JMS 是 Java 提供的一套技术规范,即 Java 消息服务(Java Message Service)应用程序接口。是一个 Java 平台中关于面向消息中间件
    	           的 API。用于在两个应用程序之间或分布式系统中发送消息,进行异步通信。Java 消息服务是一个与具体平台无关的 API
    	JMS 干什么用:用来异构系统集成通信,缓解系统瓶颈,提高系统的伸缩性增强系统用户体验,使得系统模块化和组件化变得可行并更加灵活
    	通过什么方式:生产消费者模式(生产者、服务器、消费者)通常消息传递有两种类型的消息模式可用一种是点对点 queue 队列模式(p2p),
    	           另一种是 topic 发布-订阅模式(public-subscribe)
    
    (2)JMS 消息传输模型
    
    	1、点对点模式(一对一,消费者主动拉取数据,消息收到后消息清除)
    		点对点模型通常是一个基于拉取或者轮询的消息传送模型,这种模型从队列中请求信息,而不是将消息推送到客户端。这个模型的特点是发送到队列的
    	消息被一个且只有一个接收者接收处理,即使有多个消息监听者也是如此。
    	2、发布/订阅模式(一对多,数据生产后,推送给所有订阅者)
    		发布订阅模型则是一个基于推送的消息传送模型。发布订阅模型可以有多种不同的订阅者,临时订阅者只在主动监听主题时才接收消息,而持久订阅者
    	则监听主题的所有消息,即时当前订阅者不可用,处于离线状态
    
    (3)JMS 核心组件
    	
    	1、Destination:消息发送的目的地,也就是前面说的 Queue 和 Topic
    	2、Message:从字面上就可以看出是被发送的消息
    		a、StreamMessage:Java 数据流消息,用标准流操作来顺序的填充和读取
    		b、MapMessage:一个 Map 类型的消息;名称为 string 类型,而值为 Java 的基本类型
    		c、TextMessage:普通字符串消息,包含一个 String
    		d、ObjectMessage:对象消息,包含一个可序列化的 Java 对象
    		e、BytesMessage:二进制数组消息,包含一个 byte[]
    		f、XMLMessage: 一个 XML 类型的消息
    		最常用的是 TextMessage 和 ObjectMessage
    	3、Producer:消息的生产者,要发送一个消息,必须通过这个生产者来发送
    	4、MessageConsumer:与生产者相对应,这是消息的消费者或接收者,通过它来接收一个消息
    	5、通过与 ConnectionFactory 可以获得一个 connection
    	6、通过 connection 可以获得一个 session 会话
    
    (4)常见的类 JMS 消息服务器
    	
    	1、JMS 消息服务器 ActiveMQ
    		ActiveMQ 是 Apache 出品,最流行的,能力强劲的开源消息总线。ActiveMQ 是一个完全支持 JMS1.1 和 J2EE 1.4 规范的
    		主要特点:
    		a、多种语言和协议编写客户端。语言: Java, C, C++, C#, Ruby, Perl, Python, PHP。应用协议:OpenWire,Stomp REST,WS Notification,XMPP,AMQP
    		b、完全支持 JMS1.1 和 J2EE 1.4 规范 (持久化,XA 消息,事务)
    		c、对 Spring 的支持,ActiveMQ 可以很容易内嵌到使用 Spring 的系统里面去,而且也支持Spring2.0 的特性
    		d、 通过了常见 J2EE 服务器(如 Geronimo,JBoss 4,GlassFish,WebLogic)的测试,其中通过JCA 1.5 resource adaptors 的配置,可以让 ActiveMQ 
    			可以自动的部署到任何兼容 J2EE 1.4商业服务器上可以自动的部署到任何兼容 J2EE 1.4商业服务器上
    		e、支持多种传送协议:in-VM,TCP,SSL,NIO,UDP,JGroups,JXTA
    		f、 支持通过 JDBC 和 journal 提供高速的消息持久化
    		g、 从设计上保证了高性能的集群,客户端-服务器,点对点
    		h、 支持 Ajax
    		i、 支持与 Axis 的整合
    		j、 可以很容易得调用内嵌 JMS provider 进行测试
    	
    	2、分布式消息中间件 Metamorphosis
    	
    		Metamorphosis(MetaQ) 是一个高性能、高可用、可扩展的分布式消息中间件,类似于 LinkedIn的 Kafka,具有消息存储顺序写、吞吐量大和支持本地
    	和 XA 事务等特性,适用于大吞吐量、顺序消息、广播和日志数据传输等场景,在淘宝和支付宝有着广泛的应用,现已开源
    	主要特点:
    		a、生产者、服务器和消费者都可分布
    		b、消息存储顺序写
    		c、性能极高,吞吐量大
    		d、支持消息顺序
    		e、支持本地和 XA 事务
    		f、客户端 pull,随机读,利用 sendfile 系统调用,zero-copy ,批量拉数据
    		i、支持消费端事务
    		j、支持消息广播模式
    		k、支持异步发送消息
    		l、支持 http 协议
    		m、支持消息重试和 recover
    		n、数据迁移、扩容对用户透明
    		o、消费状态保存在客户端
    		p、支持同步和异步复制两种 HA
    		q、支持 group commit
    	
    	3、分布式消息中间件 RocketMQ
    	
    		RocketMQ 是一款分布式、队列模型的消息中间件
    		主要特点:
    		a、能够保证严格的消息顺序
    		b、提供丰富的消息拉取模式
    		c、高效的订阅者水平扩展能力
    		d、实时的消息订阅机制
    		e、亿级消息堆积能力
    		f、Metaq3.0 版本改名,产品名称改为 RocketMQ
    	
    	4、其他 MQ
    	
    		a、.NET 消息中间件 DotNetMQ
    		b、基于 HBase 的消息队列 HQueue
    		c、Go 的 MQ 框架 KiteQ
    		d、AMQP 消息服务器 RabbitMQ
    		e、MemcacheQ 是一个基于 MemcacheDB 的消息队列服务器
    
    2.为什么需要消息队列
    
    消息系统的核心作用就是三点:解耦,异步和并行
    (1)用户注册的一般流程
    	用户注册---》发新手红包---》准备支付宝账号---》进行合法性验证---》通知SNS
    	问题:随着后端流程越来越多,每步流程都需要额外的耗费很多时间,从而会导致用户更长的等待延迟。
    (2)用户注册的并行执行
    	用户注册---》发新手红包,准备支付宝账号,进行合法性验证,通知SNS
    	问题:系统并行的发起了 4 个请求,4 个请求中,如果某一个环节执行 1 分钟,其他环节再快,用户也需要等待 1 分钟。如果其中一个环节异常之后,整个服务挂掉了
    (3)用户注册的最终一致
    	发送消息---》用户注册
    	1、 保证主流程的正常执行、执行成功之后,发送 MQ 消息出去。
    	2、 需要这个 destination 的其他系统通过消费数据再执行,最终一致。
    	消息队列投递---》发新手红包,准备支付宝账号,进行合法性验证,通知SNS
    
    3.Kafka 的优点
    
    (1)解耦
    (2)冗余
    (3)扩展性
    (4)灵活性 & 峰值处理能力
    (5)可恢复性
    (6)顺序保证
    (7)缓冲
    (8)异步通信
    
    4.Kafka 是什么
    
    (1)Kafka 概述
    	
    	1、在流式计算中,Kafka 一般用来缓存数据,Storm 通过消费 Kafka 的数据进行计算。经典架构:Flume + Kafka + Storm + Redis
    	2、Apache Kafka 最初是是由 LinkedIn 开发的一个基于发布订阅的分布式的消息系统,由 Scala编写,并于 2011 年初开源
    	3、Kafka 是一个分布式消息队列:具有生产者、消费者的功能。它提供了类似于 JMS 的特性,但是在设计实现上完全不同,此外它并不是 JMS 规范的实现
    	4、Kafka 对消息保存时根据 Topic 进行归类,发送消息者称为 Producer,消息接受者称为Consumer,此外 Kafka 集群有多个 Kafka 实例组成,每个实例(server)成为 broker。
    	5、无论是Kafka集群,还是Producer和Consumer都依赖于ZooKeeper集群保存一些meta信息,来保证系统可用性
    
    (2)Kafka 特性
    
    	1、高吞吐量、低延迟:kafka 每秒可以处理几十万条消息,它的延迟最低只有几毫秒,每个 topic可以分多个 partition,consumer group 对 partition 进行消费操作
    	2、可扩展性:kafka 集群支持热扩展
    	3、持久性、可靠性:消息被持久化到本地磁盘,并且支持数据备份防止数据丢失
    	4、容错性:允许集群中节点失败(若副本数量为 n,则允许 n-1 个节点失败)
    	5、高并发:支持数千个客户端同时读写
    
    5.Kafka 的应用场景
    
    (1)消息系统
    (2)跟踪网站活动
    (3)运营指标
    (4)日志聚合
    (5)流处理
    (6)采集日志
    (7)提交日志
    
    6.Kafka 核心组件
    
    (1)工作模式
    
    	Kafka 是 LinkedIn 用于日志处理的分布式消息队列,同时支持离线和在线日志处理。
    	发送消息者就是 Producer,消息的发布描述为 Producer
    	消息接受者就是 Consumer,消息的订阅描述为 Consumer
    	每个 Kafka 实例称为 Broker,将中间的存储阵列称作 Broker(代理)
    	Kafka 的大致工作模式:
    	1、启动 ZooKeeper 的 server
    	2、启动 Kafka 的 server
    	3、Producer 生产数据,然后通过 ZooKeeper 找到 Broker,再将数据 push 到 Broker 保存
    	4、Consumer 通过 ZooKeeper 找到 Broker,然后再主动 pull 数据
    
    (2)Kafka 的核心概念详解
    
    	1、Broker:Kafka 节点,一个 Kafka 节点就是一个 broker,多个 broker 可以组成一个 Kafka 集群。
    	2、Topic:一类消息,消息存放的目录即主题,例如 page view 日志、click 日志等都可以以 topic的形式存在,Kafka 集群能够同时负责多个 topic 的分发。
    	3、Partition:topic 物理上的分组,一个 topic 可以分为多个 partition,每个 partition 是一个有序的队列
    	每个分区其实都是有序且顺序不可变的记录集,并且不断地追加到结构化的 commit log 文件。
    	4、Segment:partition 物理上由多个 segment 组成,每个 Segment 存着 message 信息
    	5、Producer : 生产 message 发送到 topic
    	6、Consumer : 订阅 topic 消费 message,consumer 作为一个线程来消费
    		a、 一个 Partition 的消息只会被 group 中的一个 Consumer 消费
    		b、 可以认为一个 group 就是一个“订阅者”
    		c、 一个 Topic 中的每个 Partition 只会被一个“订阅者”中的一个 Consumer 消费
    	7、Consumer Group:一个 Consumer Group 包含多个 consumer,这个是预先在配置文件中配置好的
    	一般来说:
    		a、一个 Topic 的 Partition 数量大于等于 Broker 的数量,可以提高吞吐率。
    		b、同一个 Partition 的 Replica 尽量分散到不同的机器,高可用。
    

    (六)Storm

    1.概述
    
    		Apache Storm 是一个 Twitter 开源的分布式、实时、可扩展、容错的计算系统。Apache Storm可以很容易做到可靠地处理无限的数据流,
    	像 Hadoop 批量处理大数据一样。Storm 处理速度很快,每个节点每秒钟可以处理超过百万的数据组。	
    	常用于:实时分析、在线机器学习、持续计算、分布式 RPC、ETL 等等。
    	特点:快、可扩展、容错性、保证数据都能够被处理
    
    2.集群架构
    
    		Apache Storm 分布式集群主要节点由控制节点(Nimbus 节点)和工作节点(Supervisor 节点),控制节点可以一个,工作节点多个组成的,
    	而 Zookeeper 主要负责 Nimbus 节点和 Supervisor节点之间的协调工作。		
    
    (1)Nimbus:即 Storm 的 Master,负责资源分配和任务调度。一个 Storm 集群只有一个 Nimbus。
    (2)Supervisor:即Storm的Slave,负责接收Nimbus分配的任务,管理所有Worker,一个Supervisor节点中包含多个 Worker 进程。
    (3)Worker:进程,拓扑运行在一个或者多个 worker 上,每一 worker 是一个独立的 JVM 进程,进程里面包含一个或者多个 executor(线程),
                 一个线程会处理一个或者多个 Task(任务)。Config.TOPOLOGY_WORKERS 设置 worker 数量。
    (4)Task:任务,在 Storm 集群中每个 Spout 或者 Bolt 对应多个 Task 来执行,每个任务都与一个执行线程相对应。Spout 或者 Bolt 设置多个并行度(setSpout/setBolt),
              就有对应的多个 Task,Spout 的 nextTuple()或者 bolt 的 execute()会被执行。
    (5)ZooKeeper:Storm 的集群的状态信息(Nimbus 分发的任务Supervisor、worker 的心跳等)都保存在 Zookeeper 上,通过 zookeeper 的分布式系统
                   协调来保证 Storm 集群的稳定性
    
    3.核心概念
    
    	Apache Storm 是一个开源的分布式、实时计算应用,实时计算应用它是由 Topology、Stream、Spout、Bolt、Stream grouping 等元素组成的。
    	
    (1)Topology
    
    		Storm 的 Topology 是一个分布式实时计算应用、计算拓扑,Storm 的拓扑是对实时计算应用逻辑的封装,它的作用与 MapReduce 的任务(Job)很相似,
    	区别在于 MapReduce 的一个Job 在得到结果之后总会结束,而拓扑会一直在集群中运行,直到你手动去终止它 kill(stormkill topology-name [-w wait-time-secs])。
    	拓扑还可以理解成由一系列通过数据流(StreamGrouping)相互关联的 Spout 和 Bolt 组成的的拓扑结构
    	拓扑运行模式:本地模式和分布式模式
    	运行一个拓扑只要把代码打包成一个 jar,然后在 storm 集群环境下,执行命令storm jar topology-jar-path class........
    
    (2)Streams
    
    		Streams 是 storm 最核心的抽象概念,一个 Stream 是分布式环境中并行创建和处理的一个没有边界的 tuple 序列,Streams 是由 Tuple(元组)组成的,
    	Streams 是 storm 最核心的抽象概念,一个 Stream 是分布式环境中并行创建和处理的一个没有边界的 tuple 序列,Streams 是由 Tuple(元组)组成的,
    	Tuple 支持的类型有 Integer、Long、Short、Byte、String、Double、Float、Boolean、Byte Arrays
    	    当然,Tuple 也支持可序列化的对象。
    	    数据流可以由一种能够表述数据流中元组的域(fields)的模式来定义。
    	
    (3)Spouts 数据源 
    	
    	Spout 是拓扑的数据流的源头,Spout 不断的从外部读取数据(数据库、kafka 等外部资源),并发送到拓扑中进行实时的处理
    	Spout是主动模式,Spout继承 BaseRichSpout或者实现 IRichSpout接口不断的调用nextTuple()函数,然后通过 emit 发送数据流。
    
    (4)Bolts 
    
    	    Bolt 接收 Spout 或者上游的 Bolt 发来的 Tuple(数据流),拓扑中所有的数据处理均是由 Bolt完成的。通过数据过滤(filter)、函数处理(function)、
    	聚合(aggregations)、联结(joins)、数据库交互等功能,Bolt 几乎能够完成任何一种数据处理需求。一个 Bolt 可以实现简单的数据流转换,
    	而更复杂的数据流变换通常需要使用多个 Bolt 并通过多个步骤完成。
    	    Bolt 是被动模式,Bolt 继承 BaseBasicBolt 类或者实现 IRichBolt 接口等来实现,当 Bolt 接收Spout 或者上游的 Bolt 发来的 Tuple(数据流)时调用 execute 方法,
    	并对数据流进行处理完,OutputCollector 的 emit 发送数据流,execute 方法在 Bolt 中负责接收数据流和发送数据流。
    
    (5)Stream Grouping 
    
    	Storm 是通过 Stream Grouping 把 spouts 和 Bolts 串联起来组成了流数据处理结构
    	八种数据流分组方式:
    	1、Shuffle grouping(随机分组)
    	2、Fields grouping(字段分组)
    	3、Partial Key grouping(部分字段分组)
    	4、All grouping(完全分组)
    	5、Global grouping(全局分组)
    	6、None grouping(无分组)
    	7、Direct grouping(直接分组)
    	8、Local or shuffle grouping(本地或随机分组)
    
    4.并行度分析
    
    	    Topology 主要是由 Worker、Executor、Task 组成的、Topology 对应一个或者多个 worker(是一个独立的 JVM 进程),worker 下又有多个 Executor 线程,
    	Executor 下对应一个或者多个Task,默认情况下一个 Executor 对应一个 Task(spout/bolt),这些 Task 都是同一个 spout/bolt组件。
    	    我们在创建拓扑时,并配置 Worker 的数量、Executor 数量、Task 数量,也就是并行度,提高拓扑的并行度,能提高拓扑的计算能力。
    		说明:
    		Worker 数量:conf.setNumWorkers(num) /Config.TOPOLOGY_WORKERS
    		Executor 数量:builder.setBolt()/builder.setSpout()
    		Task 数量:builder.setBolt().setNumTasks(val)
    

    (七)Scala

    1.概述
    
    (1)什么是 Scala
    	Scala 是一种多范式的编程语言,其设计的初衷是要集成面向对象编程和函数式编程的各种特性。
    	Scala(Scala Language 的简称)语言是一种能够运行于 JVM和.Net 平台之上的通用编程语言,既可用于大规模应用程序开发,也可用于脚本编程
    (2)为什么要学 Scala
    	基于编程语言自身:
    	1、 优雅
    	2、 速度快
    	3、 能融合到 Hadoop 生态圈
    	基于活跃度:
    	1、作为流行的开源大数据内存计算引擎的源码编程语--Spark 有着良好的性能优势
    	2、Scala 将成为未来大数据处理的主流语言
    	3、最新 TIOBE 编程语言排行榜--Scala 进入前 20
    
    2.Scala 函数式编程特点
    
    (1)高阶函数(Higher-order functions)
    (2)闭包(closures)
    (3)模式匹配(Pattern matching)
    (4)单一赋值(Single assignment)
    (5)延迟计算(Lazy evaluation)
    (6)类型推导(Type inference)
    (7)尾部调用优化(Tail call optimization)
    (8)类型推导(Type inference)
    

    (八)RPC

    **Java RPC**
    
    1.概念
    	
    	    RPC(Remote Procedure Call)—远程过程调用,它是一种通过网络从远程计算机程序上请求服务,而不需要了解底层网络技术的协议。
    	RPC 跨越了传输层和应用层。
    		第一层:应用层。定义了用于在网络中进行通信和传输数据的接口;
    		第二层:表示层。定义不同的系统中数据的传输格式,编码和解码规范等;
    		第三层:会话层。管理用户的会话,控制用户间逻辑连接的建立和中断;
    		第四层:传输层。管理着网络中的端到端的数据传输;
    		第五层:网络层。定义网络设备间如何传输数据;
    		第六层:链路层。将上面的网络层的数据包封装成数据帧,便于物理层传输;
    		第七层:物理层。这一层主要就是传输这些二进制数据。
    	    实际应用过程中,五层协议结构里面是没有表示层和会话层的。应该说它们和应用层合并了。
    	    我们应该将重点放在应用层和传输层这两个层面。因为 HTTP 是应用层协议,而 TCP 是传输层协议。
    	    RPC 采用客户机/服务器模式。请求程序就是一个客户机,而服务提供程序就是一个服务器。
    	    通俗的说: RPC 是指远程过程调用,也就是说两台服务器 A,B,一个应用部署在 A 服务器,想要调用 B 服务器提供的函数和方法,由于不在一个内存空间,
    	不能直接调用,需要通过网络来表达调用的语义和传达调用的数据。也可以理解成不同进程之间的服务调用
    (1)要解决通讯的问题,主要是通过在客户端和服务器之间建立 TCP 连接,远程过程调用的所有交换的数据都在这个连接里传输
    (2)要解决寻址的问题,也就是说,A 服务器上的应用怎么告诉底层的 RPC 框架,如何连接到 B 服务器(如主机或 IP 地址)以及特定的端口,方法的名称名称是什么,这样才能完成调用。
    (3)当 A 服务器上的应用发起远程过程调用时,方法的参数需要通过底层的网络协议如TCP 传递到 B 服务器,通过寻址和传输将序列化的二进制发送给 B 服务器
    (4)第四,B 服务器收到请求后,需要对参数进行反序列化(序列化的逆操作),恢复为内存中的表达方式,然后找到对应的方法(寻址的一部分)进行本地调用,然后得到返回值。
    (5)第五,返回值还要发送回服务器 A 上的应用,也要经过序列化的方式发送,服务器 A 接到后,再反序列化,恢复为内存中的表达方式,交给 A 服务器上的应用
    
    2.为什么要有 RPC
    
    	RPC 框架的职责是:让调用方感觉就像调用本地函数一样调用远端函数、让服务提供方感觉就像实现一个本地函数一样来实现服务,并且屏蔽编程语言的差异性。
    	RPC 的主要功能目标是让构建分布式计算(应用)更容易,在提供强大的远程调用能力时不损失本地调用的语义简洁性。
    	简单的讲,对于客户端 A 来说,调用远程服务器 B 上的服务,就跟调用 A 上的自身服务一样。因为在客户端 A 上来说,会生成一个服务器 B 的代理。
    
    3.Java 中流行的 RPC 框架 
    
    (1)RMI(远程方法调用)
    (2)Hessian(基于 HTTP 的远程方法调用)
    (3)Dubbo(阿里开源的基于 TCP 的 RPC 框架)
    
    **Hadoop RPC**
    
    1.概述
    
     Hadoop RPC 分为四个部分:
    (1)序列化层:Client 与 Server 端通信传递的信息采用了 Hadoop 里提供的序列化类或自定义的 Writable 类型;
    (2)函数调用层:Hadoop RPC 通过动态代理以及 Java 反射实现函数调用;
    (3)网络传输层:Hadoop RPC 采用了基于 TCP/IP 的 socket 机制;
    (4)服务器端框架层:RPC Server利用Java NIO以及采用了事件驱动的I/O模型,提高RPC Server的并发处理能力;
    
    2.涉及的技术
    
    (1)代理
    (2)反射----动态加载类
    (3)序列化
    (4)非阻塞的异步 IO(NIO)
    
    3.对外提供的接口 
    
    (1)public static <T> ProtocolProxy <T> getProxy/waitForProxy(…)
    	构造一个客户端代理对象(该对象实现了某个协议),用于向服务器发送 RPC 请求。
    (2)public static Server RPC.Builder (Configuration).build()
    	为某个协议(实际上是 Java 接口)实例构造一个服务器对象,用于处理客户端发送的请求。
    
    4.使用 Hadoop RPC 构建应用的步骤 
    
    (1)定义 RPC 协议
    	RPC 协议是客户端和服务器端之间的通信接口,它定义了服务器端对外提供的服务接口。
    (2)实现 RPC 协议
    	Hadoop RPC 协议通常是一个 Java 接口,用户需要实现该接口。
    (3)构造和启动 RPC SERVER
    	直接使用静态类 Builder 构造一个 RPC Server,并调用函数 start()启动该 Server。
    (4)构造 RPC Client 并发送请求
    	使用静态方法 getProxy 构造客户端代理对象,直接通过代理对象调用远程端的方法。
    
    **Scala Actor**
    
    1.概念
    	Scala 中的 Actor 能够实现并行编程的强大功能,它是基于事件模型的并发机制,Scala 是运用消息(message)的发送、接收来实现多线程的。使用 Scala 能够更容易地实现多线程应用的开发。
    2.Actor 方法执行顺序
    	(1)首先调用 start()方法启动 Actor
    	(2)调用 start()方法后其 act()方法会被执行
    	(3)向 Actor 发送消息
    
    **Akka Actor**
    
    1.概述
    	
    	Akka 基于 Actor 模型,提供了一个用于构建可扩展的(Scalable)、弹性的(Resilient)、快速响应的(Responsive)应用程序的平台。
    	Actor 模型是一个并行计算(Concurrent Computation)模型,它把 actor 作为并行计算的基本元素来对待:为响应一个接收到的消息,一个 actor 能够自己做出一些决策,如创建更多的 actor,或发送更多的消息,或者确定如何去响应接收到的下一个消息。
    	Actor 是 Akka 中最核心的概念,它是一个封装了状态和行为的对象,Actor 之间可以通过交换消息的方式进行通信,每个 Actor 都有自己的收件箱(Mailbox)。通过 Actor 能够简化锁及线程管理,可以非常容易地开发出正确地并发程序和并行系统
    	Actor 具有如下特性:
    	(1)提供了一种高级抽象,能够简化在并发(Concurrency)/并行(Parallelism)应用场景下的编程开发
    	(2)提供了异步非阻塞的、高性能的事件驱动编程模型
    	(3)超级轻量级事件处理(每 GB 堆内存几百万 Actor)
    	重要的生命周期方法:
    	(1)preStart()方法:该方法在 Actor 对象构造方法执行后执行,整个 Actor 生命周期中仅执行一次。
    	(2)receive()方法:该方法在 Actor 的 preStart 方法执行完成后执行,用于接收消息,会被反复执行。
    
    Spark 的 RPC 是通过 Akka 类库实现的,Akka 用 Scala 语言开发,基于 Actor 并发模型实现,Akka 具有高可靠、高性能、可扩展等特点,使用 Akka 可以轻松实现分布式 RPC 功能。
    

    (九)JVM

    1.JVM 的组织结构
    
    (1)JVM 组织关系
    	1、类加载器(ClassLoader):在 JVM 启动时或者在类运行时将需要的 class 加载到 JVM 中
    	2、执行引擎:负责执行 class 文件中包含的字节码指令
    	3、内存区(也叫运行时数据区):是在 JVM 运行的时候操作所分配的内存区。运行时内存区主要可以划分为 5 个区域
    	4、本地方法接口:主要是调用 C 或 C++实现的本地方法及返回结果。
    	方法区和堆是所有线程共享的内存区域;
    	而 Java 栈、本地方法栈和程序员计数器是运行时线程私有的内存区域。
    (2)JVM 内存结构
    	JVM 内存结构主要有三大块:堆内存、方法区和栈
    	堆内存是 JVM 中最大的一块由年轻代和老年代组成,而年轻代内存又被分成三部分,Eden空间、From Survivor 空间、To Survivor 空间,默认情况下年轻代按照 8:1:1 的比例来分配方法区存储类信息、常量、静态变量等数据,是线程共享的区域,为与 Java 堆区分,方法区还有一个别名 Non-Heap(非堆)
    	栈又分为 Java 虚拟机栈和本地方法栈和程序计数器,主要用于方法的执行
    (3)控制参数
    	-Xms 设置堆的最小空间大小
    	-Xmx 设置堆的最大空间大小
    	-XX:NewSize 设置新生代最小空间大小
    	-XX:MaxNewSize 设置新生代最大空间大小
    	-XX:PermSize 设置永久代最小空间大小
    	-XX:MaxPermSize 设置永久代最大空间大小
    	-Xss 设置每个线程的堆栈大小
    	没有直接设置老年代的参数,但是可以设置堆空间大小和新生代空间大小两个参数来间接控制:老年代空间大小=堆空间大小-年轻代大空间大小
    
    2.JVM 各区域的作用
    
    (1)Java 堆(Heap)
    	
    	对于大多数应用来说,Java 堆(Java Heap)是 Java 虚拟机所管理的内存中最大的一块。Java堆是被所有线程共享的一块内存区域,在虚拟机启动时创建。此内存区域的唯一目的就是存放对象实例,几乎所有的对象实例都在这里分配内存。
    	Java 堆是垃圾收集器管理的主要区域,因此很多时候也被称做“GC 堆”。
    	Java 堆中还可以细分为:新生代和年老代;再细致一点话,新生代又分为 Eden 空间、From Survivor 空间、To Survivor空间等。
    	根据 Java 虚拟机规范的规定,Java 堆可以处于物理上不连续的内存空间中,只要逻辑上是连续的即可,就像我们的磁盘空间一样。在实现时,既可以实现成固定大小的,也可以是可扩展的,不过当前主流的虚拟机都是按照可扩展来实现的(通过-Xmx 和-Xms 控制)。如果在堆中没有内存完成实例分配,并且堆也无法再扩展时,将会抛出 OutOfMemoryError异常
    
    (2)方法区(Method Area)
    	
    	方法区(Method Area)与 Java 堆一样,是各个线程共享的内存区域,它用于存储已被虚拟机加载的类信息、常量、静态变量、即时编译器编译后的代码等数据。
    	根据 Java 虚拟机规范的规定,当方法区无法满足内存分配需求时,将抛出 OutOfMemoryError异常。
    
    (3)程序计数器(Program Counter Register)
    	
    	程序计数器(Program Counter Register)是一块较小的内存空间,它的作用可以看做是当前线程所执行的字节码的行号指示器。在虚拟机的概念模型里(仅是概念模型,各种虚拟机可能会通过一些更高效的方式去实现),字节码解释器工作时就是通过改变这个计数器的值来选取下一条需要执行的字节码指令,分支、循环、跳转、异常处理、线程恢复等基础功能都需要依赖这个计数器来完成。
    	为了线程切换后能恢复到正确的执行位置,每条线程都需要有一个独立的程序计数器,各条线程之间的计数器互不影响,独立存储,我们称这类内存区域为“线程私有”的内存。
    	此内存区域是唯一一个在 Java 虚拟机规范中没有规定任何 OutOfMemoryError 情况的区域
    
    (4)Java 虚拟机栈(JVM Stacks)
    	
    	Java 虚拟机栈(Java Virtual Machine Stacks)也是线程私有的,它的生命周期与线程相同。虚拟机栈描述的是 Java 方法执行的内存模型:每个方法被执行的时候都会同时创建一个栈帧(Stack Frame)用于存储局部变量表、操作栈、动态链接、方法出口等信息。每一个方法被调用直至执行完成的过程,就对应着一个栈帧在虚拟机栈中从入栈到出栈的过程。
    	在 Java 虚拟机规范中,对这个区域规定了两种异常状况:
    	1、如果线程请求的栈深度大于虚拟机所允许的深度,将抛出 StackOverflowError 异常;
    	2、如果虚拟机栈可以动态扩展(当前大部分的 Java 虚拟机都可动态扩展,只不过 Java 虚拟机规范中也允许固定长度的虚拟机栈),当扩展时无法申请到足够的内存时会抛出OutOfMemoryError 异常。
    
    (5)本地方法栈(Native Method Stacks)
    
    	本地方法栈(Native Method Stacks)与虚拟机栈所发挥的作用是非常相似的,其区别不过是
    	Java 虚拟机栈为虚拟机执行 Java 方法(也就是字节码)服务,而本地方法栈则是为虚拟机使用到的 Native 方法服务。
    
    3.JVM 垃圾回收
    
    (1)概述
    
    	JVM 中,程序计数器、虚拟机栈、本地方法栈都是随线程而生随线程而灭,栈帧随着方法的进入和退出做入栈和出栈操作,实现了自动的内存清理,因此,我们的内存垃圾回收主要集中于 Java 堆和方法区中,在程序运行期间,这部分内存的分配和使用都是动态的。
    
    (2)垃圾收集器(Garbage Collector (GC)) 
    
    	GC 其实是一种自动的内存管理工具,其行为主要包括 2 步
    	1、在 Java 堆中,为新创建的对象分配空间
    	2、在 Java 堆中,回收没用的对象占用的空间
    
    (3)为什么需要 GC?
    	
    	应用程序的回收目标是构建一个仅用来处理内存分配,而不执行任何真正的内存回收操作的GC。即仅当可用的 Java 堆耗尽的时候,才进行顺序的 JVM 停顿操作。
    
    (4)为什么需要多种 GC?
    	首先,Java 平台被部署在各种各样的硬件资源上,其次,在 Java 平台上部署和运行着各种各样的应用,并且用户对不同的应用的性能指标(吞吐率和延迟)预期也不同,为了满足不同应用的对内存管理的不同需求
    	性能指标:
    	最大停顿时长:垃圾回收导致的应用停顿时间的最大值
    	吞吐率:垃圾回收停顿时长和应用运行总时长的比例
    	现有的 GC 包括:
    	1、序列化 GC(serial garbage collector):适合占用内存少的应用
    	2、并行 GC 或吞吐率 GC(Parallel or throughput Garbage Collector):适合占用内存较多,多CPU,追求高吞吐率的应用
    	3、并发 GC:适合占用内存较多,多 CPU 的应用,对延迟有要求的应用
    
    (5)对象存活的判断
    
    	两种方式:
    	1、引用计数:每个对象有一个引用计数属性,新增一个引用时计数加 1,引用释放时计数减 1,计数为 0 时可以回收。此方法简单,缺点是无法解决对象相互循环引用的问题。
    	2、可达性分析(Reachability Analysis):从 GC Roots 开始向下搜索,搜索所走过的路径称为引用链。当一个对象到 GC Roots 没有任何引用链相连时,则证明此对象是不可用的不可达对象。可解决对象相互循环引用的问题。
    	GC Roots 包括:
    	1、虚拟机栈中引用的对象
    	2、方法区中类静态属性实体引用的对象
    	3、方法区中常量引用的对象
    	4、本地方法栈中 JNI 引用的对象
    
    (6)并发和并行
    	
    	并行(Parallel):指多条垃圾收集线程并行工作,但此时用户线程仍然处于等待状态。
    	并发(Concurrent):指用户线程与垃圾收集线程同时执行(但不一定是并行的,可能会交替执行),用户程序在继续运行,而垃圾收集程序运行于另一个 CPU 上。
    
    (7)Minor GC 和 Full GC
    
    	新生代 GC(Minor GC):指发生在新生代的垃圾收集动作,因为 Java 对象大多都具备朝生夕灭的特性,所以 Minor GC 非常频繁,一般回收速度也比较快。
    	老年代 GC(Major GC / Full GC):指发生在老年代的 GC,出现了 Major GC,经常会伴随至少一次的 Minor GC(但非绝对的,在 Parallel Scavenge 收集器的收集策略里就有直接进行Major GC 的策略选择过程)。Major GC 的速度一般会比 Minor GC 慢 10 倍以上。
    
    (8)垃圾回收算法
    
    	1、标记-清除算法
    
    	算法分为“标记”和“清除”两个阶段:首先标记出所有需要回收的对象,在标记完成后统一回收掉所有被标记的对象。
    	它的主要缺点有两个:
    		a、一个是效率问题,标记和清除过程的效率都不高;
    		b、另外一个是空间问题,标记清除之后会产生大量不连续的内存碎片,空间碎片太多可能会导致,当程序在以后的运行过程中需要分配较大对象时无法找到足够的连续内存而不得不提前触发另一次垃圾收集动作。
    	
    	2、复制算法
    	
    	“复制”(Copying)的收集算法,它将可用内存按容量划分为大小相等的两块,每次只使用其中的一块。当这一块的内存用完了,就将还存活着的对象复制到另外一块上面,然后再把已使用过的内存空间一次清理掉。
    	算法的代价是将内存缩小为原来的一半,持续复制长生存期的对象则导致效率降低。
    	在对象存活率较高时就要执行较多的复制操作,效率将会变低。在老年代一般不能直接选用这种算法。
    
    	3、标记-整理算法
    
    	标记过程仍然与“标记-清除”算法一样,但后续步骤不是直接对可回收对象进行清理,而是让所有存活的对象都向一端移动,然后直接清理掉端边界以外的内存
    
    	4、分代收集算法
    	
    	“分代收集”(Generational Collection)算法,把 Java 堆分为新生代和老年代,这样就可以根据各个年代的特点采用最适当的收集算法。
    	新生代:存活对象数量少,复制算法
    	年老代:对象存活率高,标记-清除 或者 标记-整理
    
    (9)垃圾收集器
    
    	收集算法是内存回收的方法论,垃圾收集器就是内存回收的具体实现
    
    	1、Serial 收集器
    
    	串行收集器是最古老,最稳定以及效率高的收集器,可能会产生较长的停顿,只使用一个线程去回收。新生代、老年代使用串行回收;新生代复制算法、老年代标记-压缩;垃圾收集的过程中会 Stop The World(服务暂停)
    	总结:单线程的 STW 模式
    	
    	2、ParNew 收集器
    	
    	ParNew 收集器其实就是 Serial 收集器的多线程版本。
    	新生代并行,老年代串行;新生代复制算法、老年代标记-整理
    	总结:Serial 收集器的多线程版本
    	
    	3、Parallel 收集器
    	
    	Parallel 收集器更关注系统的吞吐量
    	吞吐量=运行用户代码时间/(运行用户代码时间+垃圾收集时间),虚拟机总共运行了 100 分钟,其中垃圾收集花掉 1 分钟,那吞吐量就是 99%。
    	总结:关注吞吐量的多线程 ParNew 进化版
    	
    	4、CMS 收集器
    	
    	CMS(Concurrent Mark Sweep)收集器是一种以获取最短回收停顿时间为目标的收集器
    	CMS 收集器是基于“标记-清除”算法实现的
    	运作过程:
    		a、初始标记(CMS initial mark)
    		b、并发标记(CMS concurrent mark)
    		c、重新标记(CMS remark)
    		d、并发清除(CMS concurrent sweep)
    	CMS 收集器的内存回收过程是与用户线程一起并发地执行
    	优点:并发收集、低停顿
    	缺点:产生大量空间碎片、并发阶段会降低吞吐量
    	总结:追求最短回收停顿时间的业务线程和 GC 线程并行运行的垃圾收集器
    	
    	5、G1 收集器
    	
    	与 CMS 收集器相比 G1 收集器有以下特点:
    		a、空间整合,G1 收集器采用标记整理算法,不会产生内存空间碎片。分配大对象时不会因为无法找到连续空间而提前触发下一次 GC。
    		b、G1除了追求低停顿外,还能建立可预测的停顿时间模型
    	使用G1 收集器时,Java 堆的内存布局与其他收集器有很大差别,它将整个 Java 堆划分为多个大小相等的独立区域(Region),虽然还保留有新生代和老年代的概念,但新生代和老年代不再是物理隔阂了,它们都是一部分(可以不连续)Region 的集合。G1 的新生代收集跟 ParNew 类似,当新生代占用达到一定比例的时候,开始触发收集
    
    展开全文
  • Hadoop与Spark大数据框架介绍

    万次阅读 多人点赞 2018-10-24 16:10:43
    海量数据的存储问题很早就已经出现了,一些行业或者部门因为历史的积累,数据量也达到了一定的级别。很早以前,当一台电脑无法存储这么庞大的数据时,采用的解决方案是使用NFS(网络文件系统)将数据分开存储。...

    分类目录:《大数据与云计算》总目录

    海量数据的存储问题很早就已经出现了,一些行业或者部门因为历史的积累,数据量也达到了一定的级别。很早以前,当一台电脑无法存储这么庞大的数据时,采用的解决方案是使用NFS(网络文件系统)将数据分开存储。但是这种方法无法充分利用多台计算机同时进行分析数据。

    NFS系统架构

    一个实际的需求场景:日志分析

    日志分析是对日志中的每一个用户的流量进行汇总求和。对于一个日志文件,如果只有这么几行数据,我们一般会采用这样的处理方式

    1. 读取一行日志
    2. 抽取手机号和流量字段
    3. 累加到HashMap中
    4. 遍历输出结果

    如果数据量变得很大呢,比如一个日志文件里面有几个GB数据,仍然一行一行去读,那么就会因为磁盘的IO瓶颈导致效率太低,速度太慢。如果一次性加载到内存,那么就会因为单台计算机的内存空间有限而导致内存溢出。如果将中间结果全部缓存到HashMap中,那么也会因为单台计算机的内存空间有限而导致内存溢出。可以选择采用多线程处理,但是依然无法改变资源瓶颈的现实,因为一台计算器的CPU资源,内存资源,磁盘IO瓶颈是定,创建再多的线程也无法改变这个现实。

    解决思路一:纵向扩展

    升级硬件,提高单机性能(增加内存,增强CPU、用更高性能的磁盘(如固态硬盘),比如可以购买IBM的高端服务器。这种方法简单易行,但单台计算机的扩展空间有限,CPU、内存、磁盘再怎么扩展也是有限的,无法无限扩展。除此之外,成本较高,高端服务器常常非常昂贵,几百万甚至上千万一台,一般的小公司承受不起这样高昂的成本。

    解决思路二:横向扩展:

    用多台节点分布式集群处理 ,通过增加节点数量提高处理能力,这里说的节点指的就是一台计算机。其思想为任务分摊,通过协作来实现单节点无法实现的任务,且成本相对低(可采用普通机器) 、易于线性扩展。但是其系统复杂度增加,我们要将我们的web应用部署到每一个节点上面,而多个节点协同工作时就要考虑:如何调度资源、任务如何监控、中间结果如何调度、系统如何容错、如何实现众多节点间的协调等问题。

    Hadoop

    Hadoop是一个开源的可运行于大规模集群上的分布式文件系统和运行处理基础框架。其擅长于在廉价机器搭建的集群上进行海量数据(结构化与非结构化)的存储与离线处理。Hadoop就是一门用来处理大数据的技术,就是用来解决上述提到的分布式计算里面的5个技术难题的。

    Hadoop 由 Apache Software Foundation 公司于 2005 年秋天作为 Lucene 的子 项目 Nutch 的一部分正式引入。它受到最先由 Google Lab 开发的 MapReduce 和 Google File System 的启发。2006 年 3 月份,MapReduce 和 Nutch Distributed File System (NDFS) 分别被纳入称为 Hadoop 的项目中。  Hadoop 是最受欢迎的在 Internet 上对搜索关键字进行内容分类的工具,但它也可以解决许多要求极大伸缩性的问题。例如,如果您要 grep 一个 10TB 的巨型文件,会出现什么情况?在传统的系统上,这将需要很长的时间。但是 Hadoop 在设计时就考虑到这些问题,因此能大大提高效率。

    Hadoop的生态坏境

    Hadoop是一个能够对大量数据进行分布式处理的软件框架。具有可靠、高效、可伸缩的特点。Hadoop的核心是HDFS和Mapreduce,hadoop2.0还包括YARN。
    Hadoop生态系统

    HDFS(Hadoop分布式文件系统)

    HDFS(Hadoop Distributed File System)源自于Google的GFS论文,发表于2003年10月,HDFS是GFS克隆版。是Hadoop体系中数据存储管理的基础。它是一个高度容错的系统,能检测和应对硬件故障,用于在低成本的通用硬件上运行。HDFS简化了文件的一致性模型,通过流式数据访问,提供高吞吐量应用程序数据访问功能,适合带有大型数据集的应用程序。
    Hadoop分布式文件系统

    • Client:切分文件;访问HDFS;与NameNode交互,获取文件位置信息;与DataNode交互,读取和写入数据。
    • NameNode:Master节点,在hadoop1.X中只有一个,管理HDFS的名称空间和数据块映射信息,配置副本策略,处理客户端请求。
    • DataNode:Slave节点,存储实际的数据,汇报存储信息给NameNode。
    • Secondary NameNode:辅助NameNode,分担其工作量;定期合并fsimage和fsedits,推送给NameNode;紧急情况下,可辅助恢复NameNode,但Secondary NameNode并非NameNode的热备。

    YARN(Yet Another Resource Negotiator)

    YARN是一种 Hadoop 资源管理器,它是一个通用资源管理系统,可为上层应用提供统一的资源管理和调度,它的引入为集群在利用率、资源统一管理和数据共享等方面带来了巨大好处。
    #####Hadoop YARN产生背景
    直接源于MRv1在几个方面的缺陷:

    • 扩展性受限
    • 单点故障
    • 难以支持MR之外的计算

    除此之外,多计算框架各自为战,数据共享困难。比如:MapReduce(离线计算框架)、Storm(实时计算框架)、Spark(内存计算框架)。
    #####Hadoop YARN基本架构
    Hadoop YARN各模块组成

    • ResourceManager

      • 处理客户端请求
      • 启动/监控ApplicationMaster
      • 监控NodeManager
      • 资源分配与调度
    • NodeManager

      • 单个节点上的资源管理
      • 处理来自ResourceManager的命令
      • 处理来自ApplicationMaster的命令
    • ApplicationMaster

      • 数据切分
      • 为应用程序申请资源,并分配给内部任务
      • 任务监控与容错
        Hadoop YARN运行流程分析
    Hadoop YARN调度框架

    Hadoop YARN采用双层调度框架。首先,RM将资源分配给AM。其次,AM再将资源进一步分配给各个Task。YARN与“all or nothing”策略不同(Apache Mesos),其遵循基于资源预留的调度策略,当资源不够时,会为Task预留,直到资源充足。

    Hadoop YARN调度框架

    运行在YARN上的计算框架
    • 离线计算框架:MapReduce
    • DAG计算框架:Tez
    • 流式计算框架:Storm
    • 内存计算框架:Spark
    • 图计算框架:Giraph、GraphLib

    MapReduce(分布式计算框架)

    Hadoop MapReduce是google MapReduce 克隆版。
    分布式计算框架
    MapReduce是一种计算模型,用以进行大数据量的计算。其中Map对数据集上的独立元素进行指定的操作,生成键-值对形式中间结果。Reduce则对中间结果中相同“键”的所有“值”进行规约,以得到最终结果。MapReduce这样的功能划分,非常适合在大量计算机组成的分布式并行环境里进行数据处理。

    • JobTracker:Master节点,只有一个,管理所有作业,作业/任务的监控、错误处理等;将任务分解成一系列任务,并分派给TaskTracker。
    • TaskTracker:Slave节点,运行Map Task和Reduce Task;并与JobTracker交互,汇报任务状态。
    • Map Task:解析每条数据记录,传递给用户编写的map(),并执行,将输出结果写入本地磁盘(如果为map-only作业,直接写入HDFS)。
    • Reducer Task:从Map Task的执行结果中,远程读取输入数据,对数据进行排序,将数据按照分组传递给用户编写的reduce函数执行。
      MapReduce处理流程

    Hive(基于Hadoop的数据仓库)

    Hive由facebook开源,最初用于解决海量结构化的日志数据统计问题。Hive定义了一种类似SQL的查询语言(HQL),将SQL转化为MapReduce任务在Hadoop上执行,通常用于离线分析。
    HIVE

    HBase(分布式列存数据库)

    Hbae源自Google的Bigtable论文,发表于2006年11月,HBase是Google Bigtable克隆版。HBase是一个针对结构化数据的可伸缩、高可靠、高性能、分布式和面向列的动态模式数据库。和传统关系数据库不同,HBase采用了BigTable的数据模型:增强的稀疏排序映射表(Key/Value),其中,键由行关键字、列关键字和时间戳构成。HBase提供了对大规模数据的随机、实时读写访问,同时,HBase中保存的数据可以使用MapReduce来处理,它将数据存储和并行计算完美地结合在一起。
    HBase
    HBase和Hive在大数据架构中处在不同位置,HBase主要解决实时数据查询问题,Hive主要解决数据处理和计算问题,一般是配合使用。

    Zookeeper(分布式协作服务)

    源自Google的Chubby论文,发表于2006年11月,Zookeeper是Chubby克隆版
    解决分布式环境下的数据管理问题:统一命名,状态同步,集群管理,配置同步等。

    Sqoop(数据同步工具)

    Sqoop是SQL-to-Hadoop的缩写,主要用于传统数据库和Hadoop之前传输数据。数据的导入和导出本质上是Mapreduce程序,充分利用了MR的并行化和容错性。

    Pig(基于Hadoop的数据流系统)

    由yahoo!开源,设计动机是提供一种基于MapReduce的ad-hoc(计算在query时发生)数据分析工具。其定义了一种数据流语言—Pig Latin,将脚本转换为MapReduce任务在Hadoop上执行,通常用于进行离线分析。

    Spark

    Spark是UC Berkeley AMPLab开发的是一种计算框架,分布式资源工作交由集群管理软件(Mesos、YARN) 。

    ###Spark的特点

    • 先进架构
      • Spark采用Scala语言编写,底层采用了actor model的akka作为通讯框架,代码十分简洁高效。
      • 基于DAG图的执行引擎,减少多次计算之间中间结果写到Hdfs的开销。
      • 建立在统一抽象的RDD(分布式内存抽象)之上,使得它可以以基本一致的方式应对不同的大数据处理场景。
    • 高效
      • 提供Cache机制来支持需要反复迭代的计算或者多次数据共享,减少数据读取的IO开销。
      • 与Hadoop的MapReduce相比,Spark基于内存的运算比MR要快100倍;而基于硬盘的运算也要快10倍!
    • 易用
      • Spark提供广泛的数据集操作类型(20+种),不像Hadoop只提供了Map和Reduce两种操作。
      • Spark支持Java,Python和Scala API,支持交互式的Python和Scala的shell。
    • 提供整体解决方案
      • 以其RDD模型的强大表现能力,逐渐形成了一套自己的生态圈,提供了full-stack的解决方案。
      • 主要包括Spark内存中批处理,Spark SQL交互式查询,Spark Streaming流式计算, GraphX和MLlib提供的常用图计算和机器学习算法。
    • 与Hadoop无缝连接
      • Spark可以使用YARN作为它的集群管理器
      • 读取HDFS,HBase等一切Hadoop的数据

    Spark整体架构

    Spark整体架构
    Spark提供了多种高级工具,如: Shark SQL应用于即席查询(Ad-hoc query)、Spark Streaming应用于流式计算、 MLlib应用于机器学习、GraphX应用于图处理。Spark还可以基于自带的standalone集群管理器独立运行,也可以部署在Apache Mesos 和 Hadoop YARN 等集群管理器上运行。Spark可以访问存储在HDFS、 Hbase、Cassandra、Amazon S3、本地文件系统等等上的数据,Spark支持文本文件,序列文件,以及任何Hadoop的InputFormat。

    Spark核心概念

    Spark任务提供多层分解的概念,Spark组件将用户的应用程序分解为内部执行任务并提供执行容器,资源管理为spark组件提供资源管理和调度。

    Spark任务

    • 应用程序:由一个driver program和多个job构成
    • job:由多个stage组成
    • stage:对应一个taskset
    • taskset:对应一组关联的相互之间没有shuffle依赖关系的task组成。
    • task:任务最小的工作单元
      Spark任务

    Spark组件

    • Driver Program (驱动程序) :Spark 的核心组件
      • 构建SparkContext(Spark应用的入口,它负责和整个集群的交互,创建需要的变量,还包含集群的配置信息等)
      • 将用户提交的job转换为DAG图(类似数据处理的流程图)
      • 根据策略将DAG图划分为多个stage,根据分区从而生成一系列tasks
      • 根据tasks要求向资源管理器申请资源
      • 提交任务并检测任务状态
    • Executor
      • 真正执行task的单元,一个Worker Node上可以有多个Executor

    资资源管理组件

    • YARN(通用):Master/Slave结构
      • Resource Manager(RM):全局的资源管理器,负责系统的资源管理和分配
      • Node Manager(NM):每个节点上的资源和任务管理器
      • Application Master(AM):每个应用程序都有一个,负责任务的调度和监视,并与RM调度器协商为任务获取资源。
    • Standalone(Spark自带):Master/Slave结构
      • Master:类似于YARN的RM
      • Worker:类似于YARN的NM

    Spark端到端流程

    Spark的Driver Program (简称Driver)包含用户的应用程序,Driver完成task的解析和生成。

    1. Driver向Cluster Manager(集群资源管理器)申请运行task需要的资源。
    2. 集群资源管理器为task分配满足要求的节点,并在节点按照要求创建Executor
    3. 创建的Executor向Driver注册。
    4. Driver将Spark应用程序的代码和文件传送给分配的Executor
    5. Executor运行task,运行完之后将结果返回给Driver或者写入HDFS或其他介质。
      Spark端到端流程

    Spark流程

    Spark on Standalone

    Master和Worker是Standalone的角色,Driver和Executor是Spark的角色。Master负责分配资源,分配Driver和Executor,让Worker启动Driver和Executor,只管理到Executor层,不涉及任务。Driver负责生成task,并与Executor通信,进行任务的调度和结果跟踪,不涉及资源。

    Driver运行在Worker

    Driver运行在Worker

    1. 客户端把作业发布到Master
    2. Master让一个Worker启动Driver,并将作业推送给Driver
    3. Driver进程生成一系列task
    4. Driver向Master申请资源
    5. Master让调度的Worker启动Exeuctor
    6. Exeuctor启动后向Driver注册。
    7. Driver将task调度到Exeuctor执行。
    8. Executor执行结果写入文件或返回Driver
    Driver运行在Client

    Driver运行在Client

    1. 客户端启动后直接运行用户程序,启动Driver
    2. Driver进程生成一系列task
    3. Driver向Master申请资源
    4. Master让调度的Worker启动Exeuctor
    5. Exeuctor启动后向Driver注册。
    6. Driver将task调度到Exeuctor执行。
    7. Executor执行结果写入文件或返回Driver

    Spark的核心组件

    Spark的核心组件
    Spark的核心组件包括RDD、Scheduler、Storage、Shuffle四部分:

    • RDD是Spark最核心最精髓的部分,Spark将所有数据都抽象成RDD。
    • Scheduler是Spark的调度机制,分为DAGScheduler和TaskScheduler。
    • Storage模块主要管理缓存后的RDD、shuffle中间结果数据和broadcast数据
    • Shuffle分为Hash方式和Sort方式,两种方式的shuffle中间数据都写本地盘

    RDD(Resilient Distributed Datasets)

    RDD是弹性分布式数据集,是只读的分区记录集合。每个RDD有5个主要的属性:

    • 一组分片(Partition):数据集的最基本组成单位
    • 一个计算每个分片的函数:对于给定的数据集,需要做哪些计算
    • 依赖(Dependencies):RDD的依赖关系,描述了RDD之间的lineage
    • preferredLocations(可选):对于data partition的位置偏好
    • partitioner(可选):对于计算出来的数据结果如何分发

    作用于RDD上的Operation分为转换(transformantion)和动作(action)。 Spark中的所有“转换”都是惰性的,在执行“转换”操作,并不会提交Job,只有在执行“动作”操作,所有operation才会被提交到cluster中真正的被执行。这样可以大大提升系统的性能。

    • 转换:从现有的数据集创建一个新的数据集即数据集中的内容会发生更改,由数据集A转换成为数据集B
    • 动作:在数据集上运行计算后,返回一个值给驱动程序。 即数据集中的内容会被归约为一个具体的数值(Scala标量、集合类型的数据或存储)。

    RDD拥有的操作比MR丰富的多,不仅仅包括Map、Reduce操作,还包括右图的filter、sort、join、save、count等操作,所以Spark比MR更容易方便完成更复杂的任务。

    RDD持久化

    默认情况下,每一个转换过的RDD都会在它之上执行一个动作时被重新计算。如果RDD只被使用一次或者很少次,不需要持久化。如果RDD被重复使用或者计算其代价很高,才考虑持久化。另外,shuffle后生成的RDD尽量持久化,因为shuffle代价太高。RDD被缓存后,Spark将会在集群中,保存相关元数据,下次查询这个RDD时,它将能更快速访问,不需要计算。如果持久化无谓的RDD,会浪费内存(或硬盘)空间,反而降低系统整体性能

    RDD依赖关系

    RDD只能基于在稳定物理存储中的数据集和其他已有的RDD上执行确定性操作来创建。能从其他RDD通过确定操作创建新的RDD的原因是RDD含有从其他RDD衍生(即计算)出本RDD的相关信息(即Lineage)。Dependency代表了RDD之间的依赖关系,即血缘(Lineage),分为窄依赖和宽依赖:
    窄依赖和宽依赖

    • 窄依赖:一个父RDD最多被一个子RDD用在一个集群节点上管道式执行。比如map、filter、union等
    • 宽依赖:子RDD的分区依赖于父RDD的所有分区,这是因为shuffle类操作要求所有父分区可用。比如groupByKey、reduceByKey、 sort、partitionBy等

    根据RDD依赖关系的不同,Spark将每一个job分为不同的stage,stage之间的依赖关系形成了DAG图。对于窄依赖,Spark将其尽量划分在同一个stage中,因为它们可以进行流水线计算,而宽依赖往往意味着shuffle操作,这也是Spark划分stage的主要边界。
    RDD依赖关系
    宽/窄依赖的概念不止用在stage划分中,对容错也很有用。若Transformation操作中间发生计算失败,如果运算是窄依赖,只要把丢失的父RDD分区重算即可,跟其他节点没有依赖,这样可以大大加快场景恢复的开销,但如果运算是宽依赖,则需要父RDD的所有分区都存在, 重算代价就较高。当Lineage特别长时或者有宽依赖时,主动调用 checkpoint把当前数据写入稳定存储,作为检查点。

    Scheduler

    Scheduler模块作为Spark最核心的模块之一,充分体现了Spark与MapReduce的不同之处,体现了Spark DAG思想的精巧和设计的优雅。Scheduler模块分为两大主要部分,DAGScheduler和TaskScheduler。
    Scheduler
    DAGScheduler把一个spark作业转换成成stage的DAG(Directed Acyclic Graph有向无环图),根据RDD和stage之间的关系,找出开销最小的调度方法,然后把stage以TaskSet的形式提交给TaskScheduler。TaskScheduler模块用于与DAGScheduler交互,负责任务的具体调度和运行。任务调度模块基于两个Trait:TaskScheduler和 SchedulerBackend。

    Storage

    Storage模块主要分为两层:

    • 通信层:Storage模块采用的是master-slave结构来实现通信层,master和slave之间传输控制信息、状态信息,这些都是通过通信层来实现的。
    • 存储层:Storage模块需要把数据存储到disk或是memory上面,有可能还需replicate到远端,这都是由存储层来实现和提供相应接口。

    Storage模块提供了统一的操作类BlockManager,外部类与storage模块打交道都需要通过调用BlockManager相应接口来实现。Storage模块存取的最小单位是数据块(Block),Block与RDD中的Partition一一对应,所以所有的转换或动作操作最终都是对Block进行操作。

    Shuffle

    Shuffle 中Map任务产生的结果会根据所设置的partitioner算法填充到当前执行任务所在机器的每个桶中。Reduce任务启动时时,会根据任务的ID,所依赖的Map任务ID以及MapStatus从远端或本地的BlockManager获取相应的数据作为输入进行处理。Shuffle数据必须持久化磁盘,不能缓存在内存。

    Spark之上提供了四种应用库:

    • Spark SQL 是为处理结构化数据而设计的模块
    • Spark Streaming 可以很容易地创建可扩展和容错性的流式应用
    • MLlib 是Spark的可扩展机器学习库
    • GraphX 是Spark的并行图计算API

    Spark应用库

    以上便是对Hadoop、Spark的一些浅显的介绍。事实上,解决大数据处理相关的问题,往往要经过数据收集(Flume、Kafka、Sqoop)、数据存储(HDFS、HBase)、资源管理(YARN)、计算(MapReduce、Spark)、数据分析(Pandas、NumPy、R)、数据可视化(Echart、Tableau)等环节。各个环节都有其相应的工具,Hadoop和Spark就是大数据处理流程中非常常用的两个框架。

    展开全文
  • Spark 大数据分析-介绍

    2020-03-19 10:10:10
    这里写自定义目录标题关于Spark的几个概念新的改变功能快捷键合理的创建标题,有助于目录的生成如何改变文本的样式插入链接与图片如何插入一段漂亮的代码片生成一个适合你的列表创建一个表格设定内容居中、居左、居...


    Spark是一个以复杂计算为核心的大数据分析框架,是MapReduce的“后继者”,具备高效性、通用性等特点。

    Spark最初在2009年由加州大学伯克利分校的AMPLab开发,并于2010年成为Apache的开源项目之一,与Hadoop和Storm等其他大数据和MapReduce技术相比,Spark提供的技术更加全面,速度更快(比MapReduce快一百倍)。

    Spark的技术生态

    Spark的技术生态包含了各种丰富的组件,而不同的组件提供了不同功能,以适应不同场景。

    Spark core

    spark core包含Spark的基本功能,定义了RDD的API以及以此为基础的其他动作。Spark的其他库都构建在RDD和Spark Core之上。

    Spark SQL

    提供通过HiveQL与Spark进行交互的API。每个数据库表被当做一个RDD,Spark SQL的查询会被转换为Spark操作。

    Spark streaming

    对实时数据流进行处理和控制。Spark Streaming允许程序能够像普通RDD一样处理实时数据。严格来说Spark streaming并不是实时的,而是准实时(跟Storm相比)。

    MLlib

    一个基于RDD的机器学习算法库,包含了可扩展的机器学习算法。

    GraphX

    控制图、并行图操作和计算的一组算法和工具的集合。

    Spark的基本原理

    在这里插入图片描述

    Application

    Application是在使用spark-submit 提交的打包程序,也就是需要写的代码。
    完整的Application一般包含以下步骤:
    (1)获取数据
    (2)计算逻辑
    (3)输出结果(可以是存入HDFS,或者是其他存储介质)

    Executor

    Executor是一个Application运行在Worker节点上的一种进程,一个worker可以有多个Executor,一个Executor进程有且仅有一个executor对象。executor对象负责将Task包装成taskRunner,并从线程池抽取出一个空闲线程运行Task。每个进程能并行运行Task的个数就取决于分配给它的CPU core的数量。

    Worker

    Spark集群中可以用来运行Application的节点,在standalone模式下指的是slaves文件配置的worker节点,在spark on yarn模式下是NodeManager节点。

    Task

    在Excutor进程中执行任务的单元,执行相同代码段的多个Task组成一个Stage。

    Job

    由一个Action算子触发的一个调度。

    Stage

    Spark根据提交的作业代码划分出多个Stages,每个Stage有多个Tasks,这些Tasks负责并行处理他们所属的stage里面的代码。

    DAGScheduler

    根据Stage划分原则构建的DAG(有向无环图,理解为执行流程还行),并将Stage提交给Taskscheduler。

    TaskScheduler

    TaskScheduler将TaskSet提交给Worker运行。

    RDD

    弹性分布式数据集。
    Resilient Distributed Dataset,是Spark中最基本的数据抽象,它代表一个不可变、可分区、元素可并行计算的集合。简单点说,从数据文件中获取到的数据会被放到RDD中。
    它具有数据流模型的特点:自动容错、位置感知性调度和可伸缩性。它允许在执行多个查询时显式地将工作集缓存在内存中,后续的查询能够重用工作集,这极大地提升了查询速度。
    RDD的属性
    (1)一组分片(Partition),即数据集的基本组成单位。对于RDD来说,每个分片都会被一个计算任务处理,并决定并行计算的粒度。用户可以在创建RDD时指定RDD的分片个数,如果没有指定,那么就会采用默认值。默认值就是程序所分配到的CPU Core的数目。
    (2)一个计算每个分区的函数。Spark中RDD的计算是以分片为单位的,每个RDD都会实现compute函数以达到这个目的。compute函数会对迭代器进行复合,不需要保存每次计算的结果。
    (3)RDD之间的依赖关系。RDD的每次转换都会生成一个新的RDD,所以RDD之间就会形成类似于流水线一样的前后依赖关系。在部分分区数据丢失时,Spark可以通过这个依赖关系重新计算丢失的分区数据,而不是对RDD的所有分区进行重新计算。
    (4)一个Partitioner,即RDD的分片函数。当前Spark中实现了两种类型的分片函数,一个是基于哈希的HashPartitioner,另外一个是基于范围的RangePartitioner。只有对于于key-value的RDD,才会有Partitioner,非key-value的RDD的Parititioner的值是None。Partitioner函数不但决定了RDD本身的分片数量,也决定了parent RDD Shuffle输出时的分片数量。
    (5)一个列表,存储存取每个Partition的优先位置(preferred location)。对于一个HDFS文件来说,这个列表保存的就是每个Partition所在的块的位置。按照“移动数据不如移动计算”的理念,Spark在进行任务调度的时候,会尽可能地将计算任务分配到其所要处理数据块的存储位置。

    一些疑问

    如何定义一个Job

      /*
       * PageRank 即网页排名,又称网页级别,Google左侧排名,佩奇排名
       * */
      def pageRand():Unit={
        val sc = getSparkContext("com.scala.RecommendSystem.PageRank")
        val graph = GraphLoader.edgeListFile(sc, "E:\\Scala_TestData\\PageRank\\followers.txt")
        val ranks = graph.pageRank(0.0001).vertices
        val users = sc.textFile("E:\\Scala_TestData\\PageRank\\users.txt").filter(line=>line.length()>0)
        .map(line=>{
          val fields = line.split(",")
          (fields(0).toLong,fields(1))
        })
        val ranksByUsers = users.join(ranks).map{
          case(id,(username,rank))=>(username,rank)
        }
        ranksByUsers.foreach(println)
      }
    

    上面的foreach是一个action算子,这个算子会触发一个过程——从数据源(Data blocks)加载生成RDD,后将RDD经过一系列转换(包括基本类型转换和洗牌)最终得到计算结果(result),再将结果汇总到driver端。这个过程就是Job。Application每提交一个执行操作Spark就对应生成一个Job

    Stage和task的划分

    从后往前推算,遇到shuffleDependency就断开,遇到NarrowDependency就将其加入该stage。每个stage里面task的数目由该stage最后一个RDD中的partition个数决定。
    在这里插入图片描述
    reduceByKey是个transformation算子,但是它有shuffle,所以程序中遇到reduceByKey时,也会划分stage。

    一些结论

    (1)stage是根据shuffle算子来划分的。每一次shuffle很有可能会有一次节点间数据传输的过程。会造成性能上的影响。
    (2)同一个stage中的task执行一样的代码块。
    (3)Executor的内存主要会分成三块:第一块是让task执行代码时使用,默认占Executor总内存的20%;第二块是让task通过shuffle过程拉取了上一个stage的task的输出后,进行聚合等操作时使用,默认占Executor总内存的20%;第三块是让RDD持久化时使用,默认占Executor总内存的60%。
    (4)task的执行速度跟每个Executor进程的CPU core数量有直接关系。一个CPU core同一时间只能执行一个线程。而每个Executor进程分配到的tasks,都是以“每个task对应一个线程”的方式,多线程并发运行的。如果CPU core数量比较充足,而且分配到的task数量比较合理,那么就可以快速高效地执行task

    展开全文
  • Spark快速大数据分析

    2019-03-04 16:21:33
    文章目录Spark快速大数据分析一、Spark数据分析导论二、Spark下载与入门三、RDD编程四、键值对操作五、数据读取与保存六、Spark编程进阶七、在集群上运行Spark八、Spark调优与调试九、Spark SQL十、Spark Streaming...
  • 大数据--Spark简介

    千次阅读 2018-08-21 09:19:42
    在刚接触大数据的时候,我们主要接受的是关于hadoop的相关知识,虽然比较浅显,但是基本介绍了hadoop每一个过程或者组建的运行的原理以及架构,包括优缺点以及他的使用场景,例如hdfs、mapreduce、zookeeper以及hive...
  • 大数据-Spark实例

    千次阅读 2019-07-22 22:09:31
    Spark解析日志 需求一:求出访问图片最多的前两张 tomcat日志 110.52.250.126 - - [30/May/2018:17:38:20 +0800] "GET /source/plugin/wsh_wx/img/wsh_zk.css HTTP/1.1" 200 1482 27.19.74.143 - - [30/May/2018:17:...
  • 大数据处理之——简明Spark介绍

    万次阅读 2017-12-18 13:57:41
    很多涉及或者并行式机器学习工作或者大数据处理的岗位,基本都会有要求会使用Hadoop/Hive/Spark/Storm这几个开源工具,那么针对其中比较主流的Spark,我在这里做一个比较简单地总结。什么是Spark 为什么要用Spark ...
  • 大数据-Spark的介绍:前世今生

    千次阅读 2018-05-08 14:25:24
    一: 大数据的概述1.1 Spark是什么? Spark,是一种通用的大数据计算框架,正如传统大数据技术Hadoop的MapReduce、Hive引擎,以及Storm流式实时计算引擎等。 Spark包含了大数据领域常见的各种计算框架:比如Spark ...
  • 下载地址:百度网盘
  • Spark在美团的应用实践

    千人学习 2018-11-09 10:46:28
    该课程主页介绍Spark在美团的应用实践,包括Spark常见问题的解决方案、优化策略,以及对如何通过平台化的工具和手段提高Spark开发效率、降低使用门槛的一些思考和实践。
  • 大数据Spark实战视频教程

    万人学习 2019-12-19 12:46:49
    大数据Spark实战视频培训教程:本课程内容涉及,Spark虚拟机安装、Spark表配置、平台搭建、快学Scala入门、Spark集群通信、任务调度、持久化等实战内容。Spark是UC Berkeley AMP lab (加州大学伯克利分校的AMP实验室...
  • 一文读懂大数据两大核心技术

    千次阅读 2018-04-13 18:21:58
    今天小编给大家先分享一下大数据的两大核心技术,知己知彼才能百战不殆,学习大数据技术也是一样的道理,要先有一个清晰的了解,才能确保自己全身心的投入学习。 Hadoop是什么? Hadoop在2006年开始成为雅虎项目,...
  • 尚硅谷大数据全套视频

    千次阅读 2018-07-06 11:55:53
  • 一提到大数据,人们就会想到Hadoop,然而,最近又有个Spark似乎成了后起之秀,也变得很火,似乎比Hadoop更具优势,更有前景,那么,想要学习大数据的学员就要问了,在大数据学习中Hadoop和Spark哪个更好就业?...
  • Storm与Spark、Hadoop这三种框架,各有各的优点,每个框架都有自己的最佳应用场景。 所以,在不同的应用场景下,应该选择不同的框架。 Storm是最佳的流式计算框架,Storm由Java和Clojure写成,Storm的优点是全...
  • 什么是大数据开发?

    千次阅读 2019-06-05 11:30:38
    ♥️大数据开发是干什么的? 大数据作为时下火热的IT行业的词汇,随...大数据开发其实分两种,第一类是编写一些Hadoop、Spark的应用程序,第二类是对大数据处理系统本身进行开发。第一类工作感觉更适用于data ana...
  • 大数据学习路线(完整详细版)

    万次阅读 2019-01-22 11:46:07
    java(Java se,javaweb) Linux(shell,高并发架构,lucene,solr) Hadoop(Hadoop,HDFS,Mapreduce,yarn,hive,hbase,sqoop,zookeeper,flume) 机器学习(R,mahout) ...Spark(scala,spark,spark core,...
  • 大数据—Scala

    千人学习 2019-06-24 16:07:22
    近年来随着大数据的兴起,大数据核心框架Spark和Kafka也受到到广泛关注, Spark底层是Scala实现的, 因此也带火了Scala语言,目前Scala被全球知名公司(如:谷歌、百度、阿里、Twitter、京东等)广泛用于Spark开发。...
  • 大数据基础架构方案

    千次阅读 2016-06-07 00:09:48
    大数据架构方案,主要包括整个大数据的软件栈,主要功能包括:数据抽取,数据存储,数据分析,数据挖掘下面是整个架构设计图: 数据抽取 关系型数据库,通过sqoop导入 日志文件通过flume导入 数据存储 采用hdfs,...
1 2 3 4 5 ... 20
收藏数 68,961
精华内容 27,584
关键字:

spark 大数据