分布式计算平台Spark

分布式计算平台Spark:基础入门

文章目录

  • 分布式计算平台Spark:基础入门
    • 一、课程
    • 二、目标
    • 三、Spark的起源与发展
      • 1、分布式计算发展
      • 2、Spark诞生与发展
      • 3、Spark功能与特点
      • 4、应用场景
    • 四、Spark环境部署测试
      • 1、版本与编译
      • 2、部署模式
      • 3、架构组成
      • 4、本地模式(Local)
      • 5、集群模式(Standalone)
      • 6、HA集群
    • 五、Spark应用组成
      • 1、应用组件
      • 2、Web监控
    • 六、开发环境搭建测试
      • 1、创建Maven工程引入依赖
      • 2、WordCount开发
      • 3、基础模板开发
      • 4、TopKey开发
    • 附录一:导入Spark环境虚拟机
      • 1、拷贝三台机器
      • 2、导入三台机器
      • 3、启动三台机器
      • 4、Windows配置映射
    • 附录二:本地模式安装
    • 附录三:Standalone集群模式
      • 1、恢复三台机器快照
      • 2、修改进程配置
      • 3、修改Worker配置
      • 4、日志级别调整
      • 5、分发
    • 附录四:Spark Maven依赖
    • 附录五:IDEA连接远程文件系统

20201216

一、课程

  1. 大数据组件

    • 分布式存储

      • Zookeeper:利用分布式存储系统实现小的核心数据的存储(加紧复习)

      • 抓紧复习

      • HDFS:离线大数据文件系统数据存储(加紧复习)

      • 抓紧复习

        • 为了解决大数据存储问题:分布式磁盘
      • Hive:离线数据仓库【表】

        • 为了解决统一化和规范化数据管理问题
      • Redis:实时内存式NOSQL数据库【所有数据都在内存中】

        • 为了解决数据高并发和高性能读写问题
      • HBASE:实时基于分布式内存的NoSQL数据库【内存+HDFS】(加紧复习)

      • 抓紧复习

        • 基于性能和大数据量之间做了一个平衡

        • 解决性能与存储之间的瓶颈的思想:冷热数据的分离

          • 冷数据:不经常被使用的数据

          • 热数据:经常被使用的数:最新的数据

            • 先产生的比较早的数据写入HDFS

            • 怎么保证读HDFS也能很快?

              • 构建数据存储的有序

              • 读缓存:BlockCache

                blockcache这个怎么实现的

              • 列族:存储:Store 如果不划分列族的情况下所有的列都存储在一个store

              • 设计列族的主要目的就是减少比较次数

          • 数据被使用的概率随着时间的流逝而逐渐降低

        • 二级索引:走两次索引,代替全表扫表

          • Phoenix
          • ES
      • Kafka:分布式实时消息队列【传递数据】(加紧复习)

        • 为了解决高可靠的实时场景下的数据实时缓存问题
        • 实时:磁盘文件、-》顺序写、pagecache:页缓存机制、zero copy
        • 核心:数据一次性语义
          • 有且仅处理一次,不重复,不丢失
      • ES:分布式全文检索搜索引擎

        • 构建全文索引
    • 分布式计算

      • 处理数据步骤:三步
        • step1:读取数据
          • 变量:Seq
        • step2:处理数据
          • 函数:map/filter/flatMap/zipwithindex/reduce/fold/group
        • step3:保存结果
      • MapReduce:离线批处理的分布式计算
        • Input:负责输入:InputFormat
          • TextInputFormat:文件
          • DBInputFormat:数据库
          • TableInputFormat:读HBASE
        • Map:MapTask处理每一个分片的数据
        • Shuffle:排序、分区、分组
        • Reduce:ReduceTask处理所有的数据
        • Output:负责输出
      • Spark
      • Flink
    • 数据采集

      • Flume
      • Sqoop
      • Logstash
      • FileBeat
    • 其他辅助性组件

      • Zookeeper:解决分布式存在的问题
        • 存储核心元数据信息:HBASE、Kafka
        • 解决HA问题
      • Hue:可视化操作平台
      • Oozie:分布式的调度平台
      • CM:集群管理平台

二、目标

  1. Spark的介绍

    • 什么是Spark?
    • Spark能实现什么功能?
    • 类似的工具,为什么选择Spark?
    • 基本的Spark的特点
  2. Spark环境部署

    • 架构

    • 集群搭建

    • 基本使用方式

三、Spark的起源与发展

1、分布式计算发展

  • 分布式计算发展

    • HPC:高性能计算
    • 云计算平台:虚拟机
      • 阿里云
      • 华为云
      • 亚马逊云
    • 大数据
      • 分布式存储
      • 分布式计算
  • 分布式计算平台的演变

    • 第一代:MapReduce

      • 设计:为了让廉价机器也能实现分布式处理
    • 第二代:Tez

    • 第三代:Spark

      • 设计:基于内存式的灵活性的编程计算框架
      • 以离线批处理为主
    • 第四代:Flink

      • 设计:流式高性能计算
  • 以实时数据流计算为主

为什么基于内存式的还没有流式的有优势?:见spark学习笔记中问题部分。

2、Spark诞生与发展

  • 诞生
    • 问题:最早使用MapReduce等工具实现分布式计算,出现了两个问题
      • MapReduce的计算过程非常慢,导致性能很差
      • Mapreduce编程非常死板(5大阶段不可调),不灵活
    • 解决:需要设计一些新的工具
      • databricks:研发一个新的工具,结合目前市场上很多分布式工具的特点,融合以后构建Spark
  • 发展
分布式计算平台Spark_第1张图片
  • 官网

    • spark.apache.org
    • databricks.com
  • 介绍

    分布式计算平台Spark_第2张图片

    Apache Spark is a lightning-fast unified analytics engine for big data and machine learning. It was originally developed at UC Berkeley in 2009.
    
    • lightning-fast:光速
    • unified analytics engine:统一化的分析引擎
      • 功能非常强大
      • 分析的类型
        • 离线代码开发
        • 交互式分析
        • 实时计算分析
        • Python
        • R
        • 机器学习
    • machine learning:机器学习
  • 定义:是一个分布式的统一化的计算框架;类似于前面学的MapReduce+yarn

3、Spark功能与特点

  • 官方对Spark的一个介绍

    At a high level, every Spark application consists of a driver program 
    #每个Spark程序都会包含一个驱动程序:Driver
    
    that runs the user’s main function 
    #这个driver运行在用户的main方法中
    
    and executes various parallel operations on a cluster. 
    #并且在集群中执行各种并行化操作 
     
    The main abstraction Spark provides is a resilient distributed dataset (RDD), 
    #Spark中提供了一个主要的抽象:RDD【弹性分布式数据集】【SparkCore中的核心数据结构】
    
    which is a collection of elements partitioned across the nodes of the cluster 
    # 被分区存储在各个节点中的一个元素的集合【类似于MapReduce中的分片的存在,所有分片构建一个RDD】
    
    that can be operated on in parallel.
    #可以被并行化的操作
    
    RDDs are created by starting with a file in the Hadoop file system (or any other Hadoop-supported file system), 
    #RDD可以被创建从一个Hadoop文件系统中被创建
    
    or an existing Scala collection in the driver program, and transforming it. 
    #或者从一个Scala的集合中进行创建,由driver来实现,并且对RDD进行转换
    
    Users may also ask Spark to persist an RDD in memory,
    #用户可以将RDD中的数据持久化【缓存】在内存中,
    【scala中结果会存在新生成的集合中这个集合可能会被回收:后边文档已有解决方案】
    allowing it to be reused efficiently across parallel operations. 
    #方便多次使用
    
    Finally, RDDs automatically recover from node failures.
    #最终,RDD会自动的从失败中恢复
    
    • RDD

      • 数据处理的流程

        • Input:读数据源,将数据源的数据封装到一个变量中
        • Transform:对这个变量的数据进行转换处理,得到结果
        • Output:将结果保存即可
      • MapReduce

        • 需求:1 + …… + 9

        • Input

          • 功能一:将数据进行分片,得到每个split

            • 目的:每个Task要处理一部分数据,先将数据划分
            • 举例:将1到9,分成若干个部分,分成3个部分
              • split1:1,2,3
              • split2:4,5,6
              • split3:7,8,9
          • 功能二:将每个分片的每条数据转换为KV结构

            • 目的:整个MapReduce中所有的数据都以KV结构进行存储和处理

              • split1

                (a,1)
                (a,2)
                (a,3)
                
              • split2

                (a,4)
                (a,5)
                (a,6)
                
              • split3

                (a,7)
                (a,8)
                (a,9)
                
        • Tranform

          • Map:每个Split启动MapTask进程进行处理,map方法
            • MapTask1:(a,6)
            • MapTask2:(a,15)
            • MapTask3:(a,24)
          • Reduce:启动一个ReduceTask来对所有Map的结果进行处理
            • ReduceTask:(a,45)
        • Output

        • 问题

          • MapReduce中的KV在很多场景下是不方便的
            • 只要存储一个值
            • 需要存储多个值
    • SparkCore

      • Input:读取数据

        • RDD:将读取到的所有数据放入RDD中

          • 问题:数据怎么划分?

            • RDD中的数据会被分区存储在不同的节点中
            • RDD的每个分区【partition】 = MapReduce中的每个分片【split】
          • 问题:RDD中存储的数据格式是什么样的?

            • RDD【T
              • RDD[String]
              • RDD[(String,Int)]
          • 理解:RDD类似于scala中的集合,但是RDD是分布式的,RDD集合中的数据分区存储在不同的机器上

            分布式计算平台Spark_第3张图片

            疑问这个rdd会随分区个数的变化重新将存储的数据分配到不同的节点上吗;会重新分配

      • TransForm:对RDD中的数据进行转换处理

        • RDD中很多的函数与Scala集合的函数是一致的
      • Output

    分布式计算平台Spark_第4张图片

  • Speed

    • 流程设计:读取、处理、保存

    • 保证整个流程中提高性能:积极的将数据存储在内存中

    • 问题:内存中的数据是不稳定的,空间较小

    • 解决

      • 如果内存不足以存放所有数据,将部分数据持久化persist在磁盘中 disk

      • 如果内存数据丢失,通过特殊的机制来保证数据可恢复或者可用

        • HDFS:副本机制

        • Redis:副本机制(内存、磁盘都有一份)

        • HBASE:WAL

        • WAL: Write-Ahead Logging [1] 预写日志系统;数据库中一种高效的日志算法,对于非内存数据库而言,磁盘I/O操作是数据库效率的一大瓶颈。在相同的数据量下,采用WAL日志的数据库系统在事务提交时,磁盘写操作只有传统的回滚日志的一半左右,大大提高了数据库磁盘I/O操作的效率,从而提高了数据库的性能。

        • Kafka:副本机制

        • ES:副本机制

        • Spark能不能选用副本机制?

          • 不能,如果选用副本机制会占用更多的内存,依旧不能解决稳定性问题
          • 解决方案:血脉【记录所有数据的来源】
  • Ease of Use

    • 好使
    • 支持的开发接口比较多
      • Java
      • Scala
      • SQL
      • Python
      • R
  • Generality

    • 功能非常全面

      分布式计算平台Spark_第5张图片

    • SparkCore:Spark中最核心的组件

      • 类似于MapReduce,替代了MapReduce
      • 用于实现离线的批处理,可以使用Java、Scala进行开发代码
    • SparkSQL :Spark中用于实现SQL处理的组件(源自于hive)

      • 类似于Hive,用于替代Hive实现SQL计算
      • 支持SQL语句对数据仓库中的数据或者表的数据进行处理
    • SparkStreaming:准实时计算

      • 类似于Storm,用于实现实时计算
      • 准实时:用微小为单位的批处理来模拟实时计算
        • 例如:每200ms处理一次
      • 真实时:Storm、Flink!!!
        • 以数据为单位进行计算,产生一条数据,处理一条数据
    • SparkStructStreaming:结构化流

      • SQL + Streaming
    • Spark MLlib:机器学习的算法库

      • 工作中用算法库来实现算法模型的构建
      • 推荐模型的算法
    • Spark Graphx:图计算

      • 数据结构的图

    分布式计算平台Spark_第6张图片

  • Runs Everywhere

    • Spark支持各种数据源(内部已将封装了这些api)

      • 流程:读取、处理、保存

      • 数据源:读取、保存

      • 常用的数据源

        • SparkCore:HDFS、HBASE
        • SparkSQL:Hive、结构化数据【MySQL、Json、文件、Parquet(列式存储)】
        • SparkStreaming(流式数据):Kafka、HBASE、Redis

        分布式计算平台Spark_第7张图片

    • 运行在各种分布式资源平台中

      • http://spark.apache.org/docs/2.4.5/

      • 资源平台

        分布式计算平台Spark_第8张图片

      • Standalone

        • Spark自带的集群资源管理平台
      • Messos

        • 类似于YARN,国内应用的不多
      • YARN

        • 将Spark的程序放在YARN运行,由YARN做资源管理
      • Kubernetes

        • 新一代的分布式资源容器,类似于Docker

4、应用场景

  • 功能:用于实现各种场景下的分布式计算
  • 应用场景
    • 数据仓库:SparkCore实现ETL(解密、过滤等操作)
    • 数据分析
      • SparkSQL来实现数据离线分析
      • SparkStreaming或者StructStreaming来实现实时数据分析(flink取代的是这部分)
    • 推荐系统
      • Spark MLlib
  • 特点
    • 好使
    • 通用性
    • 支持多数据源和多平台

四、Spark环境部署测试

1、版本与编译

  • 版本

    • 1.x:早期的大数据平台所使用的版本,功能性能都有一些缺陷
    • 2.x:目前企业中应用最多的版本
      • 2.4.5
    • 3.x:最新的版本,增加了很多新的特性,用来提高性能
      • 目前暂时没有对应的应用环境
  • 发行厂商

    • Apache:http://archive.apache.org/dist/spark/spark-2.4.5/
    • CDH
      • 为什么不用Apache,而选用Cloudera公司的产品
        • 基于稳定性的考虑
      • Cloudera所提供的Spark版本是有缺陷的
        • Spark的编译好的包中是没有SparkSQL的
        • Cloudera公司自己有Impala
  • 基于以上的问题,需要基于Cloudera公司的依赖,自己编译Spark自己编译啥意思呀?

    spark-2.4.5-bin-cdh5.16.2-2.11.tgz
    

2、部署模式

  • 本地模式
    • 一般用于测试开发,没有分布式的主从架构
    • 将程序直接在本地启动一个JVM来运行
  • 集群模式
    • 一般用于生产环境,有分布式主从架构
    • 将程序提交给分布式资源平台去运行
    • 第一种:Standalone
      • Spark自带的集群资源管理
    • 第二种:YARN
      • 将Spark程序提交给YARN运行

Deploying部署:

3、架构组成

分布式计算平台Spark_第9张图片

  • 主从架构模式

    • 主节点:管理集群
    • 从节点:负责实现计算
  • Standalone

    • 主:Master
    • 从:Worker
  • YARN

    • 主:ResourceManger
    • 从:NodeManager

    zookeeper解决单点故障问题,那么就自己实现了单点故障解决问题的功能

4、本地模式(Local)

[root@node1 spark]# hadoop-daemon.sh start namenode
[root@node1 spark]# hadoop-daemon.sh start datanode
#node1:50070端口
  • 参考附录一导入虚拟机

  • 参考附录二安装本地环境

    • 第一台机器恢复到快照3
    • 启动第一台机器即可
  • 启动HDFS

    hadoop-daemon.sh start namenode
    hadoop-daemon.sh start datanode
    
  • 测试

    • 启动Spark-shell

      cd /export/server/spark
      bin/spark-shell --master local[2]
      
      • spark-shell是Spark提供的一个交互式的Spark程序,可以通过命令行直接写Spark代码
      • –master:指定程序运行在哪个模式上
      • local:表示本地模式
        • [2]:运行这个程序,给定几核CPU
    • 创建测试文件

      hdfs dfs -mkdir /datas
      vim wordcount.data
      
      hadoop spark hbase
      hive hive hive hive
      hadoop spark spark
      
      hdfs dfs -put wordcount.data /datas
      #此文件在本地-》放到hdfs上
      
      
    - 观察Spark-shell日志
    
      ```shell
      Setting default log level to "WARN".
      #默认日志级别为WARN级别
      To adjust logging level use sc.setLogLevel(newLevel). For SparkR, use setLogLevel(newLevel).
      #如果你要修改日志级别,你要sc.setLogLevel(“INFO”)
      Spark context Web UI available at http://node1.itcast.cn:4040
      #每一个Spark程序都会自动开放一个Web监控界面,端口从4040开始,第二个程序的端口4041,依次类推
      Spark context available as 'sc' (master = local[2], app id = local-1608102687971).
      #创建了一个对象:sc:SparkContext
    Spark session available as 'spark'.
      #创建了一个对象:spark:SparkSession
    
    • SparkContext对象就是上午提到的driver programe
      • SparkSession对象是新一代的driver programe:里面包含了一个SparkContext对象
      • 用于替代老的SparkContext
  • 测试WordCount

    • Input:读HDFS中/datas/wordcount.data

      //调用sparkContext的方法读HDFS文件,存入RDD对象中
      scala> val inputRdd = sc.textFile("/datas/wordcount.data")
      inputRdd: org.apache.spark.rdd.RDD[String] = /datas/wordcount.data MapPartitionsRDD[1] at textFile at <console>:24
      //查看RDD的第一行数据
      scala> inputRdd.first
      res0: String = hadoop spark hbase
      //统计RDD的行数
      scala> inputRdd.count
      res1: Long = 3
      
        
    
      
    - Transform:实现词频统计
    
        - flatMap:RDD[String]
    
          ```scala
          
          scala> inputRdd.flatMap(line => line.trim.split("\\s+"))
          res2: org.apache.spark.rdd.RDD[String] = MapPartitionsRDD[2] at flatMap at :26
          
          scala> inputRdd.flatMap(line => line.trim.split("\\s+")).foreach(println)
          hadoop
          spark
          hbase
          hive
          hive
          hive
          hive
          hadoop
        spark
          spark
    
    - map:RDD[(String,Int)]
    
      ```
      scala> inputRdd.flatMap(line => line.trim.split("\\s+")).map(word => (word,1)).foreach(println)
      (hadoop,1)
      (spark,1)
      (hbase,1)
      (hive,1)
      (hive,1)
      (hive,1)
      (hive,1)
      (hadoop,1)
    (spark,1)
      (spark,1)
    ```
    
    - reduceByKey:功能 = groupByKey + reduce:RDD[(String, Int)]
    
      ```
      scala> val rsRDD = inputRdd.flatMap(line => line.trim.split("\\s+")).map(word => (word,1)).reduceByKey((tmp,item)=> tmp+item)
      rsRDD: org.apache.spark.rdd.RDD[(String, Int)] = ShuffledRDD[8] at reduceByKey at :25
      
      scala> rsRDD.foreach(println)
      (hive,4)
      (spark,3)
    (hadoop,2)
      (hbase,1)
    ```
    

    • Output
      rsRDD.saveAsTextFile("/datas/output/output1")
    

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-L55rTm6D-1610365374480)(Day38_分布式计算平台Spark:基础入门.assets/image-20201216155243915.png)]

    分布式计算平台Spark_第10张图片

    • 测试运行Jar包

      • spark-submit:用于运行Spark的jar包的

        • YARN语法

          yarn jar xxxx.jar  main_class args
          
      • Spark

        spark-submit 
        [选项]
        --class 指定运行哪个类
        xxxx.jar  
        args
        
      SPARK_HOME=/export/server/spark
      ${SPARK_HOME}/bin/spark-submit \
      --master local[2] \
      --class org.apache.spark.examples.SparkPi \
      ${SPARK_HOME}/examples/jars/spark-examples_2.11-2.4.5.jar \
      10
      

5、集群模式(Standalone)

  • 参考附录三安装集群环境

    • 先将第一台机器恢复到快照4

      分布式计算平台Spark_第11张图片

  • 启动Spark Standalone集群

    • 启动HDFS:第一台机器执行

      start-dfs.sh
      #创建一个目录,用于存储Spark程序的运行日志
      hdfs dfs -mkdir -p /spark/eventLogs/
      
    • 启动Master:第一台机器

      /export/server/spark/sbin/start-master.sh
      

      分布式计算平台Spark_第12张图片

    • 启动Worker:第一台机器

      /export/server/spark/sbin/start-slaves.sh
      

      分布式计算平台Spark_第13张图片

    • 查看WebUI

      node1:8080
      

      分布式计算平台Spark_第14张图片

    • 启动HistoryServer

      start-dfs.sh
      /export/server/spark/sbin/start-history-server.sh
      

      分布式计算平台Spark_第15张图片

    • 访问WebUI

      node1:18080
      

      分布式计算平台Spark_第16张图片

      分布式计算平台Spark_第17张图片

  • 测试

    SPARK_HOME=/export/server/spark
    ${SPARK_HOME}/bin/spark-submit \
    --master spark://node1:7077 \
    --class org.apache.spark.examples.SparkPi \
    ${SPARK_HOME}/examples/jars/spark-examples_2.11-2.4.5.jar \
    10
    

    分布式计算平台Spark_第18张图片

6、HA集群

  • 关闭所有Spark进程

    /export/server/spark/sbin/stop-slaves.sh 
    /export/server/spark/sbin/stop-master.sh 
    /export/server/spark/sbin/stop-history-server.sh
    
  • 修改配置文件

    cd /export/server/spark/conf/
    vim spark-env.sh
    
    #注释60行
    #SPARK_MASTER_HOST=node1
    #添加68行
    SPARK_DAEMON_JAVA_OPTS="-Dspark.deploy.recoveryMode=ZOOKEEPER -Dspark.deploy.zookeeper.url=node1:2181,node2:2181,node3:2181 -Dspark.deploy.zookeeper.dir=/spark-ha"
    
  • 分发

    cd /export/server/spark/conf
    scp -r spark-env.sh node2:$PWD
    scp -r spark-env.sh node3:$PWD
    
  • 启动ZK

    zookeeper-daemons.sh start
    zookeeper-daemons.sh status
    
  • 启动Master

    • 第一台

      /export/server/spark/sbin/start-master.sh
      
    • 第二台

      /export/server/spark/sbin/start-master.sh
      
  • 启动Worker

    /export/server/spark/sbin/start-slaves.sh 
    
  • 测试

    SPARK_HOME=/export/server/spark
    ${SPARK_HOME}/bin/spark-submit \
    --master spark://node1:7077,node2:7077 \
    --class org.apache.spark.examples.SparkPi \
    ${SPARK_HOME}/examples/jars/spark-examples_2.11-2.4.5.jar \
    100
    

五、Spark应用组成

1、应用组件

分布式计算平台Spark_第19张图片

  • Master:主节点进程

    • 类似于YARN中的ResourceManger
    • 管理集群以及所有从节点
    • 接受客户端请求
  • Worker:从节点进程:计算节点

    • 类似于YARN中的NodeManger
    • Work进程运行机器上:每个Work都能使用这台机器的一定的CPU和内存
  • HistoryServer:历史服务进程

  • Executor:Task真正运行的计算的进程

    • 类似于MapTask进程和ReduceTask进程
      • MapReduce以进程的方式来处理数据
      • Spark以线程的方式来实现数据处理
    • 就是Task运行所在的进程
    • 每个Executor运行在Work节点中
    • 每个Work节点会分配CPU和内存给每个Executor
    • 每个Work能用机器的1Core1GB
      • 每个Work上要启动Executor:每个Executor需要1core 512M的资源
      • 问:每个Worker上能启动几个Executor?、
  • Task:每个线程所处理的任务,每个线程需要1coreCPU来完成

  • Driver:每个Spark程序都要包含的一个进程,在代码中是:SparkContext对象

    • 负责解析构建所有Task
    • 分配以及监控和所有Task的运行

2、Web监控

分布式计算平台Spark_第20张图片

  • Application:一个Application就是一个Spark程序
  • job:一个程序中处理的单元
    • 以前MapReduce:一个Application就是一个Job
    • 现在Spark:一个Application可以多个job
  • Stage:每个Job会划分为多个阶段,每个阶段会用多个Task来实现这个阶段的处理的过程:执行计划
    • 为什么需要Stage?
      • 程序是基于lazy模式构建RDD,最终触发job的运行,通过DAG可以根据执行计划来一步步执行
    • stage的划分规则?
      • 是否产生shuffle过程
    • stage怎么变成Task呢?
      • Stage中每个RDD的每个分区需要使用一个Task来运行处理

六、开发环境搭建测试

1、创建Maven工程引入依赖

  • 附录四中依赖

2、WordCount开发

package bigdata.itcast.cn.spark.scala.wordcount

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

/**
  * @ClassName SparkCoreWordCount
  * @Description TODO 自己开发代码来实现Wordcount
  * @Date 2020/12/16 17:22
  * @Create By     Frank
  */
object SparkCoreWordCount {
     
  def main(args: Array[String]): Unit = {
     
    /**
      * step1:先构建SparkContext:初始化资源对象
      */

    //构建一个SparkConf:用于管理当前程序的所有配置
    val conf = new SparkConf()
      //给当前程序设置一个名字
      .setAppName(this.getClass.getSimpleName.stripSuffix("$"))
      //设置当前程序运行的模式
      .setMaster("local[2]")
    //构建一个SparkContext对象
    val sc = new SparkContext(conf)
    //调整日志级别
    sc.setLogLevel("WARN")

    /**
      * step2:处理数据
      */
    //todo:1-读取数据
    val inputRdd: RDD[String] = sc.textFile("/datas/wordcount.data")
    //todo:2-处理数据
    val rsRdd = inputRdd
        .filter(line => null != line && line.trim.length >0)
        .flatMap(line => line.trim.split("\\s+"))
        .map(word => word -> 1)
        .reduceByKey((tmp,item) => tmp+item)
    
    //todo:3-保存结果
    rsRdd.foreach(println)

    /**
      * step3:释放资源
      */
    Thread.sleep(1000000L)
    sc.stop()
  }
}

3、基础模板开发

package bigdata.itcast.cn.spark.scala.mode

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

/**
  * @ClassName SparkCoreMode
  * @Description TODO SparkCore的基础模板
  * @Date 2020/12/16 17:22
  * @Create By     Frank
  */
object SparkCoreMode {
     
  def main(args: Array[String]): Unit = {
     
    /**
      * step1:先构建SparkContext:初始化资源对象
      */

    //构建一个SparkConf:用于管理当前程序的所有配置
    val conf = new SparkConf()
      //给当前程序设置一个名字
      .setAppName(this.getClass.getSimpleName.stripSuffix("$"))
      //设置当前程序运行的模式
      .setMaster("local[2]")
    //构建一个SparkContext对象
    val sc = new SparkContext(conf)
    //调整日志级别
    sc.setLogLevel("WARN")

    /**
      * step2:处理数据
      */
    //todo:1-读取数据
    //todo:2-处理数据
    //todo:3-保存结果

    /**
      * step3:释放资源
      */
    Thread.sleep(1000000L)
    sc.stop()
  }
}

4、TopKey开发

package bigdata.itcast.cn.spark.scala.topkey

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

/**
  * @ClassName SparkCoreWordCount
  * @Description TODO 取单词最多的前3个
  * @Date 2020/12/16 17:22
  * @Create By     Frank
  */
object SparkCoreWordCountTopWord {
     
  def main(args: Array[String]): Unit = {
     
    /**
      * step1:先构建SparkContext:初始化资源对象
      */

    //构建一个SparkConf:用于管理当前程序的所有配置
    val conf = new SparkConf()
      //给当前程序设置一个名字
      .setAppName(this.getClass.getSimpleName.stripSuffix("$"))
      //设置当前程序运行的模式
      .setMaster("local[2]")
    //构建一个SparkContext对象
    val sc = new SparkContext(conf)
    //调整日志级别
    sc.setLogLevel("WARN")

    /**
      * step2:处理数据
      */
    //todo:1-读取数据
    val inputRdd: RDD[String] = sc.textFile("/datas/wordcount.data")
    //todo:2-处理数据
    inputRdd
        .filter(line => null != line && line.trim.length >0)
        .flatMap(line => line.trim.split("\\s+"))
        .map(word => word -> 1)
        .reduceByKey((tmp,item) => tmp+item)
        //排序方式一:sortByKey:按照Key进行排序
//        .map(tuple => tuple.swap)
//        .sortByKey(ascending = false)
        //排序方式二:sortBy :指定按照哪个值进行排序
        .sortBy(tuple => tuple._2,false)
        .take(3)
        .foreach(println)


    //todo:3-保存结果
//    rsRdd.foreach(println)

    /**
      * step3:释放资源
      */
    Thread.sleep(1000000L)
    sc.stop()
  }
}

附录一:导入Spark环境虚拟机

1、拷贝三台机器

分布式计算平台Spark_第21张图片

2、导入三台机器

分布式计算平台Spark_第22张图片

3、启动三台机器

  • 第二台、第三台启动会遇到这个报错,选择浏览
分布式计算平台Spark_第23张图片
  • 浏览中,选择第一台机器的vmx文件即可

    分布式计算平台Spark_第24张图片

4、Windows配置映射

分布式计算平台Spark_第25张图片

192.168.88.100   node1.itcast.cn   node1
192.168.88.101   node2.itcast.cn   node2
192.168.88.102   node3.itcast.cn   node3

附录二:本地模式安装

【以第一台机器为例】

  • 解压安装

    tar -zxvf /export/software/spark-2.4.5-bin-cdh5.16.2-2.11.tgz -C /export/server/
    ln -s /export/server/spark-2.4.5-bin-cdh5.16.2-2.11 /export/server/spark
    
    • 常见的目录
      • bin:客户端命令
      • sbin:集群管理命令,服务的启动和关闭
      • conf:配置文件目录
      • jars:存放jar包的目录
  • 修改配置

  • spark-env.sh.template 配置环境变量的

    cd /export/server/spark/conf
    mv spark-env.sh.template spark-env.sh
    vim spark-env.sh
    
    #22行-23行
    JAVA_HOME=/export/server/jdk
    SCALA_HOME=/export/server/scala
    #30行
    HADOOP_CONF_DIR=/export/server/hadoop/etc/hadoop
    

附录三:Standalone集群模式

1、恢复三台机器快照

  • 架构:分布式主从架构

    • 主:Master
      • 第一台机器
    • 从:Worker
      • 三台机器
  • 将三台机器恢复到《4、分布式环境》

  • 解压安装

    tar -zxvf /export/software/spark-2.4.5-bin-cdh5.16.2-2.11.tgz -C /export/server/
    ln -s /export/server/spark-2.4.5-bin-cdh5.16.2-2.11 /export/server/spark
    

2、修改进程配置

  • spark-env.sh

    cd /export/server/spark/conf/
    mv spark-env.sh.template spark-env.sh
    vim spark-env.sh
    
    #22行-23行
    JAVA_HOME=/export/server/jdk
    SCALA_HOME=/export/server/scala
    
    #30行
    HADOOP_CONF_DIR=/export/server/hadoop/etc/hadoop
    #60行
    #指定Master启动的地址
    SPARK_MASTER_HOST=node1
    #指定Master的通信端口
    SPARK_MASTER_PORT=7077
    #Master的Web端口
    SPARK_MASTER_WEBUI_PORT=8080
    #指定每个Work能使用这台机器的多少核CPU
    SPARK_WORKER_CORES=1
    #指定每个Work能使用这台机器的多少内存
    SPARK_WORKER_MEMORY=1g
    #Work的端口
    SPARK_WORKER_PORT=7078
    #Work的web端口
    SPARK_WORKER_WEBUI_PORT=8081
    #配置Spark程序日志的记录位置
    SPARK_HISTORY_OPTS="-Dspark.history.fs.logDirectory=hdfs://node1:8020/spark/eventLogs/ -Dspark.history.fs.cleaner.enabled=true"
    
    • MapReduce:JobHistoryServer
      • 用于记录之前所运行的所有MapReduce的程序
    • Spark:HistoryServer
      • 用于记录Spark中运行的所有程序,会将所有程序运行的日志存储在HDFS上
  • spark-defaults.conf:类似于我们以前讲的site文件

    cd /export/server/spark/conf/
    hdfs dfs -mkdir -p /spark/eventLogs/
    mv spark-defaults.conf.template spark-defaults.conf 
    vim spark-defaults.conf
    
    #28行
    #启用日志存储
    spark.eventLog.enabled true
    #日志存储位置
    spark.eventLog.dir hdfs://node1:8020/spark/eventLogs/
    #启用压缩存储日志
    spark.eventLog.compress true
    

3、修改Worker配置

cd /export/server/spark/conf/
mv slaves.template slaves 
vim slaves
node1
node2
node3

4、日志级别调整

cd /export/server/spark/conf/
mv log4j.properties.template log4j.properties
vim log4j.properties
#修改19行
log4j.rootCategory=WARN, console

5、分发

  • 所有节点配置免秘钥登录

    ssh-copy-id node1
    ssh-copy-id node2
    ssh-copy-id node3
    
  • 分发Spark

    cd /export/server/
    scp -r spark-2.4.5-bin-cdh5.16.2-2.11 node2:$PWD
    scp -r spark-2.4.5-bin-cdh5.16.2-2.11 node3:$PWD
    
  • 第二台和第三台创建软连接

    ln -s /export/server/spark-2.4.5-bin-cdh5.16.2-2.11 /export/server/spark
    

附录四:Spark Maven依赖

	
    <repositories>
        <repository>
            <id>aliyunid>
            <url>http://maven.aliyun.com/nexus/content/groups/public/url>
        repository>
        <repository>
            <id>clouderaid>
            <url>https://repository.cloudera.com/artifactory/cloudera-repos/url>
        repository>
        <repository>
            <id>jbossid>
            <url>http://repository.jboss.com/nexus/content/groups/publicurl>
        repository>
    repositories>

    <properties>
        <scala.version>2.11.12scala.version>
        <scala.binary.version>2.11scala.binary.version>
        <spark.version>2.4.5spark.version>
        <hadoop.version>2.6.0-cdh5.16.2hadoop.version>
    properties>

    <dependencies>
        <dependency>
            <groupId>org.scala-langgroupId>
            <artifactId>scala-libraryartifactId>
            <version>${scala.version}version>
        dependency>
        <dependency>
            <groupId>org.apache.sparkgroupId>
            <artifactId>spark-core_${scala.binary.version}artifactId>
            <version>${spark.version}version>
        dependency>
        <dependency>
            <groupId>org.apache.hadoopgroupId>
            <artifactId>hadoop-clientartifactId>
            <version>${hadoop.version}version>
        dependency>
    dependencies>

    <build>
        <outputDirectory>target/classesoutputDirectory>
        <testOutputDirectory>target/test-classestestOutputDirectory>
        <resources>
            <resource>
                <directory>${project.basedir}/src/main/resourcesdirectory>
            resource>
        resources>
        
        <plugins>
            <plugin>
                <groupId>org.apache.maven.pluginsgroupId>
                <artifactId>maven-compiler-pluginartifactId>
                <version>3.0version>
                <configuration>
                    <source>1.8source>
                    <target>1.8target>
                    <encoding>UTF-8encoding>
                configuration>
            plugin>
            <plugin>
                <groupId>net.alchim31.mavengroupId>
                <artifactId>scala-maven-pluginartifactId>
                <version>3.2.0version>
                <executions>
                    <execution>
                        <goals>
                            <goal>compilegoal>
                            <goal>testCompilegoal>
                        goals>
                    execution>
                executions>
            plugin>
        plugins>
    build>

附录五:IDEA连接远程文件系统

分布式计算平台Spark_第26张图片 分布式计算平台Spark_第27张图片 分布式计算平台Spark_第28张图片 分布式计算平台Spark_第29张图片

你可能感兴趣的:(#,Spark,大数据,分布式,分布式计算)