Haddoop大数据教程笔记_13_Spark基础

最新推荐文章于 2022-08-02 20:57:17 发布

Snowing_inhope

最新推荐文章于 2022-08-02 20:57:17 发布

阅读量344

点赞数

分类专栏：大数据Hadoop教程文章标签： spark hadoop 大数据

本文链接：https://blog.csdn.net/Snowing_inhope/article/details/105970275

版权

大数据Hadoop教程专栏收录该内容

13 篇文章 2 订阅

订阅专栏

spark版本与scala版本不对应可能出现的问题：

idea编写spark程序

1.maven工程的spark pom依赖：

2.ScalaWordCount

3.JavaLamdaWordCount

Spark基础

Spark简介

Spark是一种快速、通用、可扩展的大数据分析引擎，2009年诞生于加州大学伯克利分校AMPLab，

2010年开源，2013年6月成为Apache孵化项目，2014年2月成为Apache顶级项目。

目前，Spark生态系统已经发展成为一个包含多个子项目的集合，其中包含SparkSQL、Spark Streaming、GraphX、MLlib等子项目，

Spark是基于内存计算的大数据并行计算框架。Spark基于内存计算，提高了在大数据环境下数据处理的实时性，

同时保证了高容错性和高可伸缩性，允许用户将Spark部署在大量廉价硬件之上，形成集群。

作为MapReduce的替代方案,spark有以下优点：

1.快,Spark实现了高效的DAG执行引擎，可以通过基于内存来高效处理数据流,磁盘计算也比MapReduce快

2.易用性 Spark支持Java、Python和Scala的API，还支持超过80种高级算法，使用户可以快速构建不同的应用。

3.通用性 Spark提供了统一的解决方案。

Spark可以用于批处理、交互式查询（Spark SQL）、实时流处理（Spark Streaming）、机器学习（Spark MLlib）和图计算（GraphX）。

4.兼容性

Spark可以使用Hadoop的YARN和Apache Mesos作为它的资源管理和调度器，器，并且可以处理所有Hadoop支持的数据，包括HDFS、HBase和Cassandra等。

这对于已经部署Hadoop集群的用户特别重要，因为不需要做任何数据迁移就可以使用Spark的强大处理能力。

Spark也可以不依赖于第三方的资源管理和调度器，它实现了Standalone作为其内置的资源管理和调度框架，

这样进一步降低了Spark的使用门槛，使得所有人都可以非常容易地部署和使用Spark。

此外，Spark还提供了在EC2上部署Standalone的Spark集群的工具。

Spark安装

下载

地址：(http://spark.apache.org/) 以当前最新的release版本为例 (后面因调试方便修改为2.3.4版本)

https://mirror.bit.edu.cn/apache/spark/spark-2.4.5/spark-2.4.5-bin-hadoop2.7.tgz

解压安装：

tar -zxvf spark-2.4.5-bin-hadoop2.7.tgz -C /root/apps

配置环境变量

修改配置文件：

1.conf目录并重命名并修改spark-env.sh.template文件：

在该配置文件中添加如下配置

      export JAVA_HOME=/usr/local/jdk
      export SPARK_MASTER_IP=master
      export SPARK_MASTER_PORT=7077

# zookeeper 监控集群实现HA 因为要启用多个master,故删除 export SPARK_MASTER_IP=master配置

      export SPARK_DAEMON_JAVA_OPTS="-Dspark.deploy.recoveryMode=ZOOKEEPER -Dspark.deploy.zookeeper.url=hdp-01:2181,hdp-02:2181,hdp-03:2181 -Dspark.deploy.zookeeper.dir=/spark"

2.重命名并修改slaves.template文件

mv slaves.template slaves

vi slaves

在该文件中添加子节点所在的位置（Worker节点）

hdp-01

hdp-02

hdp-03

3.复制到其他节点：

scp -r /root/apps/

启动：

    /root/apps/spark-2.4.5-bin-hadoop2.7/sbin/start-all.sh
    /root/apps/spark-2.4.5-bin-hadoop2.7/sbin/start-master.sh  #master的 standby节点

web验证：

8080：master的webUI，sparkwebUI的端口

7077：提交任务的端口

8081：worker的webUI的端口

18080：historyServer的webUI的端口

4040: Application Jobs web端口

web端口 8080被占用时,会顺延监听 8081 8082 ....

Spark运行原理

spark使用方式：

1.spark-shell 直接启动 scala交互界面,使用的是本地模式,本地模拟集群运行过程

      sc.textFile("hdfs://master:9000/wordcount/input/a.log").flatMap(_.split(" ")).map((_, 1)).reduceByKey(_+_).sortBy(_._2, false).collect

2.spark-submit 向集群提交spark任务

      spark-submit --master spark://master:7077,hdp-01:7077 --executor-memory 512m --total-executor-cores 6 --class cn.edu360.spark.ScalaWordCount /root/SparkTest-1.0-SNAPSHOT.jar  hdfs://mycluster/wordcount/input hdfs://mycluster/wordcount/out0001

Spark运行原理：

1.spark集群启动后分为 master,worker节点,master负责资源调度，worker复制启动Executor执行具体任务

2.客户端提交spark任务,需要启动一个SparkSubmint（Driver）来提交任务

3.SparkSubmint（Driver）提交后,首先连接spark集群的master,申请任务所需的计算资源memory,cores

4.master 根据driver要求将任务分发给worker,同时监控worker状态

5.worker 根据master的要求启动固定资源的executor,同时监控executor,并像master汇报

6.executor 启动后通过worker与master通信,主动连接driver

7.Driver 产生实际的task,通过网络通信发送给executor

8.executor执行真正的计算逻辑

Yarn和Spark的StandAlone调度模式对比

----------------------------

ResouceManager	Master	管理子节点、资源调度、接收任务请求
NodeManger	Worker	管理当前节点，并管理子进程
YarnChild	Executor	运行真正的计算逻辑的（Task）
Client	SparkSubmit	（Client + ApplicaitonMaster）提交app，管理该任务的Executor 并将Task提交到（Executor）
ApplicaitonMaster

----------------------------

spark版本与scala版本不对应可能出现的问题：

1.spark 2.4.x 官方提供的对应scala版本是 2.12.x

但是在spark安装包的jars中的依赖包,都是2.11.12.

因此,如果用scala-2.12.x 编译打包,运行时还是会报版本不匹配的错误：

        scala.Predef$.refArrayOps([Ljava/lang/Object;)[Ljava/lang/Object

2.解决办法：

方法一：

替换spark安装包的scala-2.11.x jar 替换为 2.12.x版本,但可能存在版本不稳定的问题

方法二：

pom依赖更换为2.11.12. ....

3.spark 2.4.x 版本与 scala 2.11.x 版本搭配,在调试过程中也会有各种问题.

因此建议稳定版本选择：

spark-2.3.4 scala-2.11.12

经验证稳定可用版的对应pom依赖：(下文见)

注：spark 安装包已经有了内置的scala版本,只运行spark程序的话,无需再安装scala版本

而在window idea做编译时需要scala的编译版本才会出现以上的问题.

idea编写spark程序

1.maven工程的spark pom依赖：

    <?xml version="1.0" encoding="UTF-8"?>
    <project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
      <modelVersion>4.0.0</modelVersion>


      <groupId>cn.edu360.spark</groupId>
      <artifactId>SparkTest</artifactId>
      <version>1.0-SNAPSHOT</version>


      <properties>
        <maven.compiler.source>1.8</maven.compiler.source>
        <maven.compiler.target>1.8</maven.compiler.target>
        <scala.version>2.11.12</scala.version>
        <spark.version>2.3.4</spark.version>
        <hadoop.version>2.10.0</hadoop.version>
        <encoding>UTF-8</encoding>
      </properties>


      <dependencies>
        <!-- 导入scala的依赖 -->
        <dependency>
          <groupId>org.scala-lang</groupId>
          <artifactId>scala-library</artifactId>
          <version>${scala.version}</version>
        </dependency>


        <!-- 导入spark的依赖 -->
        <dependency>
          <groupId>org.apache.spark</groupId>
          <artifactId>spark-core_2.11</artifactId>
          <version>${spark.version}</version>
        </dependency>


        <!-- 指定hadoop-client API的版本 -->
        <dependency>
          <groupId>org.apache.hadoop</groupId>
          <artifactId>hadoop-client</artifactId>
          <version>${hadoop.version}</version>
        </dependency>


      </dependencies>


      <build>
        <pluginManagement>
          <plugins>
            <!-- 编译scala的插件 -->
            <plugin>
              <groupId>net.alchim31.maven</groupId>
              <artifactId>scala-maven-plugin</artifactId>
              <version>4.3.1</version>
            </plugin>
            <!-- 编译java的插件 -->
            <plugin>
              <groupId>org.apache.maven.plugins</groupId>
              <artifactId>maven-compiler-plugin</artifactId>
              <version>3.8.1</version>
            </plugin>
          </plugins>
        </pluginManagement>
        <plugins>
          <plugin>
            <groupId>net.alchim31.maven</groupId>
            <artifactId>scala-maven-plugin</artifactId>
            <executions>
              <execution>
                <id>scala-compile-first</id>
                <phase>process-resources</phase>
                <goals>
                  <goal>add-source</goal>
                  <goal>compile</goal>
                </goals>
              </execution>
              <execution>
                <id>scala-test-compile</id>
                <phase>process-test-resources</phase>
                <goals>
                  <goal>testCompile</goal>
                </goals>
              </execution>
            </executions>
          </plugin>


          <plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-compiler-plugin</artifactId>
            <executions>
              <execution>
                <phase>compile</phase>
                <goals>
                  <goal>compile</goal>
                </goals>
              </execution>
            </executions>
          </plugin>


          <!-- 打jar插件 -->
          <plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-shade-plugin</artifactId>
            <version>3.2.3</version>
            <executions>
              <execution>
                <phase>package</phase>
                <goals>
                  <goal>shade</goal>
                </goals>
                <configuration>
                  <filters>
                    <filter>
                      <artifact>*:*</artifact>
                      <excludes>
                        <exclude>META-INF/*.SF</exclude>
                        <exclude>META-INF/*.DSA</exclude>
                        <exclude>META-INF/*.RSA</exclude>
                      </excludes>
                    </filter>
                  </filters>
                </configuration>
              </execution>
            </executions>
          </plugin>
        </plugins>
      </build>
    </project>

2.ScalaWordCount

    object ScalaWordCount {
      def main(args: Array[String]): Unit = {
      // create SpatkConf ,setAppName(),setMaster()  "local[*]" local model * cores  *系统默认最大核数
      val conf: SparkConf = new SparkConf().setAppName("ScalaWordCount01").setMaster("local[*]")
      // create SparkContext() set conf
      val sc: SparkContext = new SparkContext(conf)
      // RDD 弹性分布式数据集
      val lines: RDD[String] = sc.textFile(args(0))
      // flatMap 数据 分切压平
      val words: RDD[String] = lines.flatMap(_.split(" "))
      // map
      val wordmaps: RDD[(String, Int)] = words.map((_, 1))
      // reduce
      val reduced: RDD[(String, Int)] = wordmaps.reduceByKey(_ + _)
      // sorted
      val sorted: RDD[(String, Int)] = reduced.sortBy(_._2,false)
      println(sorted.collect().toBuffer)
      // save
      sorted.saveAsTextFile(args(1))
      // release
      sc.stop()
      }
    }

3.JavaLamdaWordCount

    public class JavaLamdaWordCount {
      public static void main(String[] args) {
        SparkConf conf = new SparkConf().setAppName("JavaLamdaWordCount").setMaster("local[*]");
        JavaSparkContext jsc = new JavaSparkContext(conf);


        JavaRDD<String> lines = jsc.textFile(args[0]);
        JavaRDD<String> words = lines.flatMap(line -> Arrays.asList(line.split(" ")).iterator());
        // JavaPairRDD<String, Integer> map = words.mapToPair(word -> Tuple2.apply(word, 1));
        JavaPairRDD<String, Integer> maps = words.mapToPair(word -> new Tuple2<>(word,1));
        JavaPairRDD<String, Integer> reduced = maps.reduceByKey((m, n) -> m + n);
        JavaPairRDD<Integer, String> swaped = reduced.mapToPair(tp -> tp.swap());
        JavaPairRDD<Integer, String> sorted = swaped.sortByKey(false);
        JavaPairRDD<String, Integer> result = sorted.mapToPair(tp -> tp.swap());


        result.saveAsTextFile(args[1]);
        jsc.stop();
      }
    }

Snowing_inhope

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Haddoop大数据教程笔记_13_Spark基础

Spark基础Spark简介Spark是一种快速、通用、可扩展的大数据分析引擎，2009年诞生于加州大学伯克利分校AMPLab，2010年开源，2013年6月成为Apache孵化项目，2014年2月成为Apache顶级项目。目前，Spark生态系统已经发展成为一个包含多个子项目的集合，其中包含SparkSQL、Spark Streaming、GraphX、MLlib等子项...
复制链接

扫一扫

专栏目录