[DB] Spark Core (1)

生态

• Spark Core：最重要，其中最重要的是RDD（弹性分布式数据集）
• Spark SQL
• Spark Streaming
• Spark MLLib：机器学习算法
• Spark Graphx：图计算

特点

• 针对大规模数据处理的快速通用引擎
• 基于内存计算
• 速度快，易用，兼容性强

体系架构

• 主节点：Cluster Manager（Standalone时叫Master）
• 从节点：Worker（占用节点上所有资源，耗内存，没用内存管理机制，易OOM）

安装部署

• 安装jdk，配置主机名，配置免密码登录
• 伪分布（Standalone）：一台机器上模拟分布式环境（Master+Worker）
  • 核心配置文件：conf/spark-env.sh
    • cp spark-env.sh.template spark-env.sh
    • export JAVA_HOME=/root/training/jdk1.8.0_144
    • export SPARK_MASTER_HOST=bigdata111
    • export SPARK_MASTER_PORT=7077
  • 启动：sbin/start-all.sh
  • Web Console：http://192.168.174.111:8080/
• 全分布：先在主节点上安装，再把装好的目录复制到从节点上　
  • scp -r spark-2.1.0-bin-hadoop2.7/ root@bigdata114:/root/training
  • 在主节点上启动集群

HA

• 基于文件目录
  • 本质还是只有一个主节点
  • 创建恢复目录保存状态信息
  • 主要用于开发和测试
  • mkdir /root/training/spark-2.1.0-bin-hadoop2.7/recovery
  • spark-env.sh
  • export SPARK_DAEMON_JAVA_OPTS="-Dspark.deploy.recoveryMode=FILESYSTEM -Dspark.deploy.recoveryDirectory=/root/training/spark-2.1.0-bin-hadoop2.7/recovery"

• 基于zookeeper
  • 用于生产环境
  • 相当于数据库
  • 数据同步，选举功能，分布式锁（秒杀）
  • 步骤
    • 设置时间同步
    • date -s 2020-06-03
    • 启动zk
    • 配置spark-env.sh，注释掉最后两行，添加：
    • export SPARK_DAEMON_JAVA_OPTS="-Dspark.deploy.recoveryMode=ZOOKEEPER -Dspark.deploy.zookeeper.url=bigdata112:2181,bigdata113:2181,bigdata114:2181 -Dspark.deploy.zookeeper.dir=/spark"
    • bigdata112上启动spark集群后，在bigdata114上启动Master

  

工具

• spark-submit：用于提交Spark任务（jar包）　
  • bin/spark-submit --master spark://bigdata111:7077 --class org.apache.spark.examples.SparkPi examples/jars/spark-examples_2.11-2.1.0.jar 100
• spark-shell：相当于REPL，命令行工具　
  • 本地模式
    • bin/spark-shell
    • 不需连接到Spark集群上，在本地（Eclipse）直接运行，用于开发和测试
  • 集群模式
    • bin/spark-shell --master spark://bigdata111:7077
    • WordCount
      • sc.textFile("/root/temp/data.txt").flatMap(_.split(" ")).map((_,1)).reduceByKey(_+_).collect

• • • •  sc.textFile("hdfs://bigdata111:9000/input/data.txt").flatMap(_.split(" ")).map((_,1)).reduceByKey(_+_)saveAsTextFile("hdfs://bigdata111:9000/output/1025")

• • • • val rdd1 = sc.textFile("/root/temp/input/data.txt")　
      • val rdd2 = rdd1.flatMap(_.split(" ")) 
      • val rdd3 = rdd2.map((_,1)) 【完整：val rdd3 = rdd2.map((word:String)=>(word,1) )】
      • val rdd4 = rdd3.reduceByKey(_+_)【完整：val rdd4 = rdd3.reduceByKey((a:Int,b:Int)=> a+b)】
      • rdd4.collect

IDE开发WordCount

• Scala版本
  • 本地模式

package day0605

import org.apache.spark.SparkConf
import org.apache.spark.SparkContext

object MyWordCount {
  def main(args:Array[String]):Unit = {
    //创建一个任务的配置信息
    //设置Master=local，表示运行在本地模式上
    //集群模式不需设置Master
    val conf = new SparkConf().setAppName("MyWordCount").setMaster("local")
    
    //创建一个SparkContext对象
    val sc = new SparkContext(conf)
    
    //执行WordCount
    val result = sc.textFile("hdfs://192.168.174.111:9000/input/data.txt")
    .flatMap(_.split(" ")).map((_,1))
    .reduceByKey(_+_).collect
    
    //打印结果
    result.foreach(println)
    
    //停止SparkContext
    sc.stop()
  }
}

• • 集群模式
    • bin/spark-submit --master spark://bigdata111:7077 --class day0605.MyWordCount /root/temp/demo1.jar hdfs://bigdata111:9000/input/data.txt hdfs://bigdata111:9000/output/0605/demo1

package day0605

import org.apache.spark.SparkConf
import org.apache.spark.SparkContext

//通过spark-submit提交

object MyWordCount {
  def main(args:Array[String]):Unit = {
    //创建一个任务的配置信息
    //设置Master=local，表示运行在本地模式上
    //集群模式不需设置Master
    val conf = new SparkConf().setAppName("MyWordCount")
    
    //创建一个SparkContext对象
    val sc = new SparkContext(conf)
    
    //执行WordCount
    val result = sc.textFile(args(0))
    .flatMap(_.split(" "))
    .map((_,1))
    .reduceByKey(_+_)
    
    //输出到hdfs
    result.saveAsTextFile(args(1))
    
    //停止SparkContext
    sc.stop()
  }
}

• Java版本

package demo;

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

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;

/*
 * 使用spark submit提交
 * bin/spark-submit --master spark://bigdata111:7077 --class demo.JavaWordCount /root/temp/demo2.jar hdfs://bigdata111:9000/input/data.txt
 */

public class JavaWordCount {

    public static void main(String[] args) {
        //运行在本地模式，可以设置断点
        SparkConf conf = new SparkConf().setAppName("JavaWordCount").setMaster("local");
        
        //运行在集群模式
        //SparkConf conf = new SparkConf().setAppName("JavaWordCount");
        
        //创建一个SparkContext对象： JavaSparkContext对象
        JavaSparkContext sc = new JavaSparkContext(conf);
        
        //读入HDFS的数据
        JavaRDD<String> rdd1 = sc.textFile(args[0]);
        
        /*
         * 分词
         * FlatMapFunction：接口，用于处理分词的操作
         * 泛型:String 读入的每一句话
         *     U:      返回值 ---> String 单词
         */
        JavaRDD<String> rdd2 = rdd1.flatMap(new FlatMapFunction<String, String>() {

            @Override
            public Iterator<String> call(String input) throws Exception {
                //数据: I love Beijing
                //分词
                return Arrays.asList(input.split(" ")).iterator();
            }
        });
        
        /*
         * 每个单词记一次数  (k2  v2)
         * Beijing ---> (Beijing,1)
         * 参数：
         * String：单词
         * k2 v2不解释
         */
        JavaPairRDD<String, Integer> rdd3 = rdd2.mapToPair(new PairFunction<String, String, Integer>() {

            @Override
            public Tuple2<String, Integer> call(String word) throws Exception {
                return new Tuple2<String, Integer>(word, 1);
            }
            
        });
        
        //执行Reduce的操作
        JavaPairRDD<String, Integer> rdd4 = rdd3.reduceByKey(new Function2<Integer, Integer, Integer>() {
            
            @Override
            public Integer call(Integer a, Integer b) throws Exception {
                //累加
                return a+b;
            }
        });
        
        //执行计算(Action)，把结果打印在屏幕上
        List<Tuple2<String,Integer>> result = rdd4.collect();
        
        for(Tuple2<String,Integer> tuple:result){
            System.out.println(tuple._1+"	"+tuple._2);
        }
        
        //停止JavaSparkContext对象
        sc.stop();
    }
}

参考

spark.apache.org