SparkCoreSpark架构体系

Posted on by hackdl

Spark是一种快速、通用、可扩展的大数据分析引擎

Spark的特点

  • Speed：快速高效

  • 性能比Hadoop MapReduce快100倍。即便是不将数据cache到内存中，其速度也是MapReduce10 倍以上。

  • Ease of Use：简洁易用

  • Spark支持 Java、Scala、Python和R等编程语言编写应用程序

  • Generality：通用、全栈式数据处理

  • Runs Everywhere：可以运行在各种资源调度框架和读写多种数据源

  • Spark支持的多种部署方案：Standalone是Spark自带的资源调度模式；Spark可以运行在Hadoop的YARN上面；Spark 可以运行在Mesos上（Mesos是一个类似于YARN的资源调度框架）；Spark还可以Kubernetes实现容器化的资源调度

  • 丰富的数据源支持。Spark除了可以访问操作系统自身的本地文件系统和HDFS之外，还可以访问 Cassandra、HBase、Hive、Alluxio（Tachyon）以及任何 Hadoop兼容的数据源。这极大地方便了已经 的大数据系统进行顺利迁移到Spark。

面试题：MapReduce和Spark的本质区别：

  1. MR只能做离线计算，如果实现复杂计算逻辑，一个MR搞不定，就需要将多个MR按照先后顺序连成一串，一个MR计算完成后会将计算结果写入到HDFS中，下一个MR将上一个MR的输出作为输入，这样就要频繁读写HDFS，网络IO和磁盘IO会成为性能瓶颈。从而导致效率低下。

  1. spark既可以做离线计算，又可以做实时计算，提供了抽象的数据集（RDD、Dataset、DataFrame、DStream）

有高度封装的API，算子丰富，并且使用了更先进的DAG有向无环图调度思想，可以对执行计划优化后在执行，并且可以数据可以cache到内存中进行复用，shuffle时，数据可以不排序

MR和Spark在Shuffle时数据都落本地磁盘

  1. Spark架构体系

StandAlone模式是spark自带的集群运行模式，不依赖其他的资源调度框架，部署起来简单。

StandAlone模式又分为client模式和cluster模式，本质区别是Driver运行在哪里，如果Driver运行在SparkSubmit进程中就是Client模式，如果Driver运行在集群中就是Cluster模式

  1. Spark中重要角色

  • Master ：是一个Java进程，接收Worker的注册信息和心跳、移除异常超时的Worker、接收客户端提交的任务、负责资源调度、命令Worker启动Executor。

  • Worker ：是一个Java进程，负责管理当前节点的资源管理，向Master注册并定期发送心跳，负责启动Executor、并监控Executor的状态。

  • SparkSubmit ：是一个Java进程，负责向Master提交任务。

  • Driver ：是很多类的统称，可以认为SparkContext就是Driver，client模式Driver运行在SparkSubmit进程中，cluster模式单独运行在一个进程中，负责将用户编写的代码转成Tasks，然后调度到Executor中执行，并监控Task的状态和执行进度。

  • Executor ：是一个Java进程，负责执行Driver端生成的Task，将Task放入线程中运行。

  • 启动Spark Shell程序

  • 什么是Spark Shell

  1. spark shell是spark中的交互式命令行客户端，可以在spark shell中使用scala编写spark程序，启动后默认已经创建了SparkContext，别名为sc

/opt/apps/spark-3.2.3-bin-hadoop3.2/bin/spark-shell 
--master spark://node-1.51doit.cn:7077 --executor-memory 1g 
--total-executor-cores 3

 如果Master配置了HA高可用，需要指定两个Master（因为这两个Master任意一个都可能是Active状态）

/bigdata/spark-3.2.3-bin-hadoop3.2/bin/spark-shell 
--master spark://node-1.51doit.cn:7077,node-2.51doit.cn:7077 
--executor-memory 1g 
--total-executor-cores 3

参数说明：

–master 指定masterd地址和端口，协议为spark://，端口是RPC的通信端口

–executor-memory 指定每一个executor的使用的内存大小

–total-executor-cores指定整个application总共使用了cores

  • 在shell中编写第一个spark程序

sc.textFile("hdfs://node-1.51doit.cn:9000/words.txt").flatMap(_.split(" ")).map((_, 1)).reduceByKey(_+_).sortBy(_._2,false).saveAsTextFile("hdfs://node-1.51doit.cn:9000/out")

  1. Scala编写Spark的WorkCount

  1. 创建一个Maven项目

  1. 在pom.xml中添加依赖和插件



    8
    8
    UTF-8
    3.2.3
    2.12.15



    
    
        org.scala-lang
        scala-library
        ${scala.version}
    

    
    
        org.apache.spark
        spark-core_2.12
        ${spark.version}
    






    
        nexus-aliyun
        Nexus aliyun
        default
        http://maven.aliyun.com/nexus/content/groups/public
        
            false
            never
        
        
            true
            never
        
    




    
        ali-plugin
        http://maven.aliyun.com/nexus/content/groups/public/
        
            false
            never
        
        
            true
            never
        
    



    
        
            
            
                net.alchim31.maven
                scala-maven-plugin
                3.2.2
            
            
            
                org.apache.maven.plugins
                maven-compiler-plugin
                3.5.1
            
        
    
    
        
            net.alchim31.maven
            scala-maven-plugin
            
                
                    scala-compile-first
                    process-resources
                    
                        add-source
                        compile
                    
                
                
                    scala-test-compile
                    process-test-resources
                    
                        testCompile
                    
                
            
        

        
            org.apache.maven.plugins
            maven-compiler-plugin
            
                
                    compile
                    
                        compile
                    
                
            
        

        
        
            org.apache.maven.plugins
            maven-shade-plugin
            2.4.3
            
                
                    package
                    
                        shade
                    
                    
                        
                            
                                *:*
                                
                                    META-INF/*.SF
                                    META-INF/*.DSA
                                    META-INF/*.RSA

  1. 编写Spark程序

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

/**
  * 1.创建SparkContext
  * 2.创建RDD
  * 3.调用RDD的Transformation（s）方法
  * 4.调用Action
  * 5.释放资源
  */
object WordCount {

  def main(args: Array[String]): Unit = {

    val conf: SparkConf = new SparkConf().setAppName("WordCount")
    //创建SparkContext，使用SparkContext来创建RDD
    val sc: SparkContext = new SparkContext(conf)
    //spark写Spark程序，就是对抽象的神奇的大集合【RDD】编程，调用它高度封装的API
    //使用SparkContext创建RDD
    val lines: RDD[String] = sc.textFile(args(0))

    //Transformation 开始 //
    //切分压平
    val words: RDD[String] = lines.flatMap(_.split(" "))
    //将单词和一组合放在元组中
    val wordAndOne: RDD[(String, Int)] = words.map((_, 1))
    //分组聚合，reduceByKey可以先局部聚合再全局聚合
    val reduced: RDD[(String, Int)] = wordAndOne.reduceByKey(_+_)
    //排序
    val sorted: RDD[(String, Int)] = reduced.sortBy(_._2, false)
    //Transformation 结束 //

    //调用Action将计算结果保存到HDFS中
    sorted.saveAsTextFile(args(1))
    //释放资源
    sc.stop()
  }
}

  1. Java编写Spark的WordCount

  2. import org.apache.spark.SparkConf;
import org.apache.spark.api.java.JavaPairRDD;
import org.apache.spark.api.java.JavaRDD;
import org.apache.spark.api.java.JavaSparkContext;
import org.apache.spark.api.java.function.FlatMapFunction;
import org.apache.spark.api.java.function.Function2;
import org.apache.spark.api.java.function.PairFunction;
import scala.Tuple2;

import java.util.Arrays;
import java.util.Iterator;

public class JavaWordCount {

    public static void main(String[] args) {
        SparkConf sparkConf = new SparkConf().setAppName("JavaWordCount");
        //创建JavaSparkContext
        JavaSparkContext jsc = new JavaSparkContext(sparkConf);
        //使用JavaSparkContext创建RDD
        JavaRDD lines = jsc.textFile(args[0]);
        //调用Transformation（s）
        //切分压平
        JavaRDD words = lines.flatMap(new FlatMapFunction() {
            @Override
            public Iterator call(String line) throws Exception {
                return Arrays.asList(line.split(" ")).iterator();
            }
        });
        //将单词和一组合在一起
        JavaPairRDD wordAndOne = words.mapToPair(
                new PairFunction() {
                    @Override
                    public Tuple2 call(String word) throws Exception {
                        return Tuple2.apply(word, 1);
                    }
        });
        //分组聚合
        JavaPairRDD reduced = wordAndOne.reduceByKey(
                new Function2() {
            @Override
            public Integer call(Integer v1, Integer v2) throws Exception {
                return v1 + v2;
            }
        });
        //排序，先调换KV的顺序VK
        JavaPairRDD swapped = reduced.mapToPair(
                new PairFunction, Integer, String>() {
            @Override
            public Tuple2 call(Tuple2 tp) throws Exception {
                return tp.swap();
            }
        });
        //再排序
        JavaPairRDD sorted = swapped.sortByKey(false);
        //再调换顺序
        JavaPairRDD result = sorted.mapToPair(
                new PairFunction, String, Integer>() {
            @Override
            public Tuple2 call(Tuple2 tp) throws Exception {
                return tp.swap();
            }
        });
        //触发Action，将数据保存到HDFS
        result.saveAsTextFile(args[1]);
        //释放资源
        jsc.stop();
    }
}

  3. 使用Lambda表达式方式

import org.apache.spark.SparkConf;
import org.apache.spark.api.java.JavaPairRDD;
import org.apache.spark.api.java.JavaRDD;
import org.apache.spark.api.java.JavaSparkContext;
import scala.Tuple2;

import java.util.Arrays;

public class JavaLambdaWordCount {

    public static void main(String[] args) {
        SparkConf conf = new SparkConf().setAppName("JavaLambdaWordCount");
        //创建SparkContext
        JavaSparkContext jsc = new JavaSparkContext(conf);
        //创建RDD
        JavaRDD lines = jsc.textFile(args[0]);
        //切分压平
        JavaRDD words = lines.flatMap(line -> Arrays.asList(line.split(" ")).iterator());
        //将单词和一组合
        JavaPairRDD wordAndOne = words.mapToPair(word -> Tuple2.apply(word, 1));
        //分组聚合
        JavaPairRDD reduced = wordAndOne.reduceByKey((a, b) -> a + b);
        //调换顺序
        JavaPairRDD swapped = reduced.mapToPair(tp -> tp.swap());
        //排序
        JavaPairRDD sorted = swapped.sortByKey(false);
        //调换顺序
        JavaPairRDD result = sorted.mapToPair(tp -> tp.swap());
        //将数据保存到HDFS
        result.saveAsTextFile(args[1]);
        //释放资源
        jsc.stop();
    }
}

服务器托管，北京服务器托管，服务器租用 http://www.fwqtg.net

相关推荐: hdu 1166 敌兵布阵(线段树)

敌兵布阵 Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 65536/32768 K (Java/Others) Total Submission(s): 17672    Accepted Su…

服务器托管，北京服务器托管，服务器租用，机房机柜带宽租用

服务器托管

咨询：董先生

电话13051898268 QQ/微信93663045！

上一篇:
下一篇: