Spark的四大运行模式以及原理

1.Local模式

Spark的本地模式，在eclipse 或 IDEA中开发spark程序要用local模式，本地模式，多用于测试，下面我分别用java和 scala语言举出一个local模式的例子，这里我们以WordCount为例。

java代码如下：

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 org.apache.spark.api.java.function.VoidFunction;
import scala.Tuple2;

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

public class JavaSparkWordCount {
    public static void main(String[] args) {
       /*
          conf
          1.可以设置spark的运行模式，setMaster
          2.可以设置spark在webui中显示的application的名称  setAppName
          3.可以设置当前spark application运行所需资源(内存+core)  set
        */
        SparkConf conf = new SparkConf();
        conf.setMaster("local");
        conf.setAppName(JavaSparkWordCount.class.getSimpleName());

         /*
             SparkContext是通往集群的唯一通道
          */
        JavaSparkContext sc =new JavaSparkContext(conf);
        JavaRDD<String> lines=sc.textFile("java_WordCount/woeds");
        //切割压平   flatMap（）  两个参数，一个输入类型，一个输出类型
        JavaRDD<String> rdd=lines.flatMap(new FlatMapFunction<String, String>() {
            @Override
            public Iterator<String> call(String s) throws Exception {
                //该方法的返回类型是Iterator，需要把Array类型的结果转换为迭代器类型的
                return Arrays.asList(s.split(" ")).iterator();
            }

        });
        //和1组合成元组  mapToPair() 第一个参数，输入数据类型，第二个参数是元组的key类型，第三个参数是元组的value类型
        JavaPairRDD<String, Integer> pairRDD= rdd.mapToPair(new PairFunction<String, String, Integer>() {
            @Override
            public Tuple2<String, Integer> call(String s) throws Exception {
                return new Tuple2<String,Integer>(s,1);
            }
        });
        //分组聚合  reduceByKey（）  (a,b)=>a+b  第三个参数：返回值的类型
        JavaPairRDD<String, Integer> javaPairRDD= pairRDD.reduceByKey(new Function2<Integer, Integer, Integer>() {
            @Override
            public Integer call(Integer v1, Integer v2) throws Exception {
                return v1+v2;
            }
        });
        //测试...
       /* javaPairRDD.foreach(new VoidFunction>() {
            @Override
            public void call(Tuple2 stringIntegerTuple2) throws Exception {
                System.out.println(stringIntegerTuple2);
            }
        });*/
       //进行排序
        JavaPairRDD<Integer, String> stringJavaPairRDD=javaPairRDD.mapToPair(new PairFunction<Tuple2<String, Integer>, Integer, String>() {
            @Override
            public Tuple2<Integer, String> call(Tuple2<String, Integer> stringIntegerTuple2) throws Exception {
                return stringIntegerTuple2.swap();
            }
        });
         //默认是倒序   false代表正序
        JavaPairRDD<Integer, String> byKey=stringJavaPairRDD.sortByKey(false);

        JavaPairRDD<String, Integer> pair=byKey.mapToPair(new PairFunction<Tuple2<Integer, String>, String, Integer>() {
            @Override
            public Tuple2<String, Integer> call(Tuple2<Integer, String> integerStringTuple2) throws Exception {
                return integerStringTuple2.swap();
            }
        });

        pair.foreach(new VoidFunction<Tuple2<String, Integer>>() {
            @Override
            public void call(Tuple2<String, Integer> stringIntegerTuple2) throws Exception {
                System.out.println(stringIntegerTuple2);
            }
        });
    }
}

scala代码如下：

package com.zhiyou.spark.test

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

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

    val conf = new SparkConf()
    conf.setMaster("local").setAppName("ScalaWordCount")
    val sc = new SparkContext(conf)
    val lines = sc.textFile("scala_WordCount/woeds")
    val words =lines.flatMap(line=>{
      line.split(" ")
    })
    val pairWords =words.map(word=>{
      new Tuple2(word,1)
    })
    /*
       先分组 后聚合 在排序
     */
   val result = pairWords.reduceByKey((v1:Int,v2:Int)=>{v1+v2})
    //排序
   val res= result.sortBy(tuple=>{tuple._2},false)
   //按照sortByKey排序
    //val re=result.map(tuple=>{tuple.swap})
    //val r=re.sortByKey(false)
    //val r1=r.map(tuple=>{tuple.swap})
    result.foreach(println)
    sc.stop()

  }
}

2.Standalone模式

spark 自带的资源调度框架，支持分布式搭建，Spark任务可以依赖stanalone调度资源，它有基于Standalone-client和Standalone-cluster两种提交模式，这里我以sparkPI为例，环境是Spark1.6

• Standalne-client模式提交任务：
  
  Standalne-client模式提交任务，会在客户端看到task的执行情况和结果。当客户端提交多个application时，每个application都会启动自己的Driver，Driver与集群worker有大量的通信，会造成客户端网卡流量激增的问题。这种模式适用于程序测试，不适用于生产环境

• Standalne-cluster模式提交任务:
  
  Standalne-cluster模式提交任务，Driver会在集群中的随机一台worker上启动，如果提交多个application，那么每个application的driver会分散到集群的worker节点，相当于将client模式的客户端网卡流量激增问题分散到集群中。这种模式适用于生产环境。

3.Yarn模式

yarn ----hadoop生态圈中资源调度框架，spark 也可以基于yarn调度资源，它有基于Yarn-client和Yarn-cluster两种提交模式。

• Yarn-client模式提交任务：
  
  Standalne-client模式提交任务，Driver在客户端启动，当提交多个application，每个application都会在客户端启动，也会有客户端网卡流量激增的问题，这种模式适用于程序测试，不适用于生产环境，在客户端可以看到执行的任务和结果。
• Yarn-cluster模式提交任务:
  
  Yarn-cluster模式提交任务，使用于生产环境，AM（Driver）随机在一台NM节点上启动，当提交多个application时，每个application的Driver会分散到集群中的NM中启动，相当于将Yarn-client模式的客户端网卡流量激增问题分散到集群中，在客户端看不到task执行和结果，要去webui中查看。

4.Mesos

这里大家可以参照这篇文章：https://yq.aliyun.com/ziliao/494404