Spark入门篇

最新推荐文章于 2024-08-26 15:45:04 发布
最新推荐文章于 2024-08-26 15:45:04 发布
阅读量738 收藏 5
点赞数 1
分类专栏： # Spark入门 文章标签： spark
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zmzdmx/article/details/109489808
版权

文章目录

第1章 Spark概述

1.1 什么是Spark

Spark是一种基于内存的快速、通用、可扩展的大数据分析计算引擎。

1.2 Spark框架

1、Hadoop MR框架

从数据源获取数据，经过分析计算后，将结果输出到指定位置，核心是一次计算，不适合迭代计算。

image-20201102111430426

2、Spark框架

支持迭代式计算，图形计算

Spark框架计算比MR快的原因是：中间结果不落盘。注意Spark的Shuffle也是落盘的。

image-20201102111505561

1.3 Spark内置模块

image-20201102111547084

Spark Core：实现了Spark的基本功能，包含任务调度、内存管理、错误恢复、与存储系统交互等模块。Spark Core中还包含了对弹性分布式数据集(Resilient Distributed DataSet，简称RDD)的API定义。

Spark SQL：是Spark用来操作结构化数据的程序包。通过Spark SQL，我们可以使用 SQL或者Apache Hive版本的HQL来查询数据。Spark SQL支持多种数据源，比如Hive表、Parquet以及JSON等。

Spark Streaming：是Spark提供的对实时数据进行流式计算的组件。提供了用来操作数据流的API，并且与Spark Core中的 RDD API高度对应。

Spark MLlib：提供常见的机器学习功能的程序库。包括分类、回归、聚类、协同过滤等，还提供了模型评估、数据 导入等额外的支持功能。

Spark GraphX：主要用于图形并行计算和图挖掘系统的组件。

集群管理器：Spark设计为可以高效地在一个计算节点到数千个计算节点之间伸缩计算。为了实现这样的要求，同时获得最大灵活性，Spark支持在各种集群管理器(Cluster Manager)上运行，包括Hadoop YARN、Apache Mesos，以及Spark自带的一个简易调度器，叫作独立调度器。

1.4 Spark特点

1）快：与Hadoop的MapReduce相比，Spark基于内存的运算要快100倍以上，基于硬盘的运算也要快10倍以上。Spark实现了高效的DAG执行引擎，可以通过基于内存来高效处理数据流。计算的中间结果是存在于内存中的。

2）易用：Spark支持Java、Python和Scala的API，还支持超过80种高级算法，使用户可以快速构建不同的应用。而且Spark支持交互式的Python和Scala的Shell，可以非常方便地在这些Shell中使用Spark集群来验证解决问题的方法。

3）通用：Spark提供了统一的解决方案。Spark可以用于，交互式查询（Spark SQL）、实时流处理（Spark Streaming）、机器学习（Spark MLlib）和图计算（GraphX）。这些不同类型的处理都可以在同一个应用中无缝使用。减少了开发和维护的人力成本和部署平台的物力成本。

4）兼容性：Spark可以非常方便地与其他的开源产品进行融合。比如，Spark可以使用Hadoop的YARN和Apache Mesos作为它的资源管理和调度器，并且可以处理所有Hadoop支持的数据，包括HDFS、HBase等。这对于已经部署Hadoop集群的用户特别重要，因为不需要做任何数据迁移就可以使用Spark的强大处理能力。

第2章 Spark运行模式

部署Spark集群大体上分为两种模式：单机模式与集群模式
大多数分布式框架都支持单机模式，方便开发者调试框架的运行环境。但是在生产环境中，并不会使用单机模式。因此，后续直接按照集群模式部署Spark集群。

下面详细列举了Spark目前支持的部署模式。

1）Local模式：在本地部署单个Spark服务

2）Standalone模式：Spark自带的任务调度模式。（国内常用）

3）YARN模式：Spark使用Hadoop的YARN组件进行资源与任务调度。（国内常用）

4）Mesos模式：Spark使用Mesos平台进行资源与任务的调度。

2.1 Spark安装地址

下载地址：https://spark.apache.org/downloads.html

2.2 Local模式

Local模式就是运行在一台计算机上的模式，通常就是用于在本机上练手和测试。

2.2.1 安装使用

1）上传并解压Spark安装包

tar -zxvf spark-2.4.5-bin-hadoop2.6.tgz

mv spark-2.4.5-bin-hadoop2.6 spark245

2）添加环境变量

export SPARK_HOME=/opt/spark245
export PATH=$PATH:$SPARK_HOME/bin

source /etc/profile

3）配置文件

进入配置文件夹

cd /opt/spark245/conf/

复制一份配置文件，并修改

 cp spark-env.sh.template spark-env.sh

在末尾添加

export JAVA_HOME=/opt/jdk1.8.0_221
export SCALA_HOME=/opt/scala
export SPARK_HOME=/opt/spark245
export SPARK_MASTER_IP=192.168.83.100
export SPARK_EXECUTOP_MEMORY=1G

再次复制

cp slaves.template slaves

在配置集群时，需要将全部机器添加到这里

image-20201102115849684

4）官方求PI案例

bin/spark-submit \
--class org.apache.spark.examples.SparkPi \
--master local[2] \
./examples/jars/spark-examples_2.11-2.4.5.jar \
10

–class：表示要执行程序的主类；

–master local[2]

（1）local: 没有指定线程数，则所有计算都运行在一个线程当中，没有任何并行计算

（2）local[K]:指定使用K个Core来运行计算，比如local[2]就是运行2个Core来执行

（3）local[*]: 自动帮你按照CPU最多核来设置线程数。比如CPU有4核，Spark帮你自动设置4个线程计算。

  • spark-examples_2.11-2.4.5.jar：要运行的程序；
  • 10：要运行程序的输入参数（计算圆周率π的次数，计算次数越多，准确率越高）；

5）结果展示

该算法是利用蒙特·卡罗算法求PI

image-20201102120239893

2.2.2 官方WordCount案例

1）需求：读取多个输入文件，统计每个单词出现的总次数。

2）需求分析：过对单词的分割统计进行计数

3）代码实现：

（1）准备文件

mkdir input

在input下创建2个文件1.txt和2.txt，并输入以下内容

hello scala
hello spark
hello world
hello java
hello python

（2）启动spark-shell

spark-shell

image-20201102121144614

注意：sc是SparkCore程序的入口；spark是SparkSQL程序入口；master = local[*]表示本地模式运行。

（3）再开启一个hadoop001远程连接窗口，发现了一个SparkSubmit进程

image-20201102121334468

运行任务方式说明：spark-submit，是将jar上传到集群，执行Spark任务；spark-shell，相当于命令行工具，本身也是一个Application。

（4）登录hadoop001:4040，查看程序运行情况（注意：spark-shell窗口关闭掉，则hadoop001:4040页面关闭）

image-20201102121458951

说明：本地模式下，默认的调度器为FIFO。

（5）运行WordCount程序

scala> sc.textFile("/root/input").flatMap(_.split(" ")).map((_,1)).reduceByKey(_+_).collect
res4: Array[(String, Int)] = Array((scala,2), (python,2), (hello,10), (java,2), (world,2), (spark,2))

注意：只有collect开始执行时，才会加载数据。

可登录hadoop001:4040查看程序运行结果

image-20201102122729755

2.3 集群角色

2.3.1 Master和Worker

image-20201102160009378

2.3.2 Driver和Executor

image-20201102160031889

2.3.3 通用运行流程

总结：Master和Worker是Spark的守护进程，即Spark在特定模式下正常运行所必须的进程。Driver和Executor是临时程序，当有具体任务提交到Spark集群才会开启的程序。

2.4 Standalone模式

Standalone模式是Spark自带的资源调动引擎，构建一个由Master + Slave构成的Spark集群，Spark运行在集群中。

这个要和Hadoop中的Standalone区别开来。这里的Standalone是指只用Spark来搭建一个集群，不需要借助其他的框架。是相对于Yarn和Mesos来说的。

2.4.1 安装使用

1）集群规划

hadoop001hadoop002hadoop003
SparkMasterWorkerWorkerWorker

2）再解压一份Spark安装包，并修改解压后的文件夹名称为spark-standalone

tar -zxvf spark-2.4.5-bin-hadoop2.6.tgz
mv spark-2.4.5-bin-hadoop2.6 spark-standalone

image-20201102160808380

3）进入Spark的配置目录/opt/spark-standalone/conf

cd /opt/spark-standalone/conf/

4）修改slave文件，添加work节点

mv slaves.template slaves

vi slaves

image-20201102164105169

5）修改spark-env.sh文件，添加master节点

mv spark-env.sh.template spark-env.sh

vi spark-env.sh

添加

export JAVA_HOME=/opt/jdk1.8.0_221
export SCALA_HOME=/opt/scala
export SPARK_HOME=/opt/spark-standalone
export SPARK_MASTER_IP=192.168.83.101
export SPARK_MASTER_PORT=7077
export SPARK_EXECUTOP_MEMORY=1G

6）分发spark-standalone包

scp -r spark-standalone/ root@hadoop002:/opt
scp -r spark-standalone/ root@hadoop003:/opt

7）启动spark集群

这里最好先取消掉之前单机配置的环境变量，不然容易产生冲突，另外不能直接start-all.sh，会与之前配置的hadoop命令冲突

sbin/start-all.sh

image-20201102164204311

注意：如果遇到 “JAVA_HOME not set” 异常，可以在sbin目录下的spark-config.sh 文件中加入如下配置：

export JAVA_HOME=XXXX

8）网页查看：192.168.83.101:8080（master web的端口，相当于hadoop的50070端口）

image-20201102164417388

9）官方求PI案例

bin/spark-submit \
--class org.apache.spark.examples.SparkPi \
--master spark://hadoop001:7077 \
./examples/jars/spark-examples_2.11-2.4.5.jar \
10

参数：–master spark://hadoop001:7077指定要连接的集群的master

10）页面查看http://hadoop001:8080/，发现执行本次任务，默认采用三台服务器节点的总核数3核，每个节点内存1024M。

8080：master的webUI

4040：application的webUI的端口号

image-20201102165813882

2.4.2 参数说明

1）配置Executor可用内存为2G，使用CPU核数为2个

bin/spark-submit \
--class org.apache.spark.examples.SparkPi \
--master spark://hadoop001:7077 \
--executor-memory 2G \
--total-executor-cores 2 \
./examples/jars/spark-examples_2.11-2.4.5.jar \
10

2）页面查看http://hadoop001:8080/

image-20201102170624352

3）基本语法

bin/spark-submit \
--class <main-class>
--master <master-url> \
... # other options
<application-jar> \
[application-arguments]

4）参数说明

参数解释可选值举例
–classSpark程序中包含主函数的类
–masterSpark程序运行的模式本地模式：local[*]、spark://hadoop001:7077、Yarn
–executor-memory 1G指定每个executor可用内存为1G符合集群内存配置即可，具体情况具体分析。
–total-executor-cores 2指定****所有****executor使用的cpu核数为2个
application-jar打包好的应用jar，包含依赖。这个URL在集群中全局可见。 比如hdfs:// 共享存储系统，如果是file:// path，那么所有的节点的path都包含同样的jar
application-arguments传给main()方法的参数

2.4.3 配置历史服务

注意端口区别！

hadoop2.7.x80209870
hadoop3.1.x900050070

由于spark-shell停止掉后，hadoop101:4040页面就看不到历史任务的运行情况，所以开发时都配置历史服务器记录任务运行情况。

1）修改spark-default.conf.template名称

mv spark-defaults.conf.template spark-defaults.conf

2）修改spark-default.conf文件，配置日志存储路径，并分发

vi spark-defaults.conf

image-20201102172433005

注意：需要启动Hadoop集群，HDFS上的目录需要提前存在。

hadoop fs -mkdir /directory

3）修改spark-env.sh文件，添加如下配置：

export SPARK_HISTORY_OPTS="
-Dspark.history.ui.port=18080 
-Dspark.history.fs.logDirectory=hdfs://hadoop001:9000/directory 
-Dspark.history.retainedApplications=30"

# 参数1含义：WEBUI访问的端口号为18080

# 参数2含义：指定历史服务器日志存储路径

# 参数3含义：指定保存Application历史记录的个数，如果超过这个值，旧的应用程序信息将被删除，这个是内存中的应用数，而不是页面上显示的应用数。

4）分发配置文件

scp spark-env.sh root@hadoop002:$PWD
scp spark-env.sh root@hadoop003:$PWD

5）启动历史服务

sbin/start-history-server.sh

image-20201103152819665

6）再次执行任务

bin/spark-submit \
--class org.apache.spark.examples.SparkPi \
--master spark://hadoop001:7077 \
--executor-memory 2G \
--total-executor-cores 2 \
./examples/jars/spark-examples_2.11-2.4.5.jar \
10

7）查看Spark历史服务地址：hadoop001:18080

image-20201103152201210

2.4.4 配置高可用（HA）

1）高可用原理

image-20201103152500907

2）配置高可用

（0）停止集群

sbin/stop-all.sh

（1）Zookeeper正常安装并启动

https://blog.csdn.net/zmzdmx/article/details/108470867

image-20201103154850194

（2）修改spark-env.sh文件添加如下配置：

注释掉如下内容：
#SPARK_MASTER_HOST=hadoop001
#SPARK_MASTER_PORT=7077

添加上如下内容。配置由Zookeeper管理Master，在Zookeeper节点中自动创建/spark目录，用于管理：
export SPARK_DAEMON_JAVA_OPTS="
-Dspark.deploy.recoveryMode=ZOOKEEPER 
-Dspark.deploy.zookeeper.url=hadoop001,hadoop002,hadoop003
-Dspark.deploy.zookeeper.dir=/spark"

添加如下代码
Zookeeper3.5的AdminServer默认端口是8080，和Spark的WebUI冲突
export SPARK_MASTER_WEBUI_PORT=8989

（3）分发配置文件

scp spark-env.sh root@hadoop002:$PWD
scp spark-env.sh root@hadoop003:$PWD

（4）在hadoop001上启动全部节点

sbin/start-all.sh

（5）在hadoop002上单独启动master节点

sbin/start-master.sh

image-20201103160420403

hadoop002作为备胎master,在hadoop001挂掉后开始作为master执行程序

（6）在启动一个hadoop001窗口，将input数据上传到hadoop集群的/input目录

hdfs dfs -put input/ /input

（7）Spark HA集群访问

bin/spark-shell \
--master spark://hadoop001:7077,hadoop002:7077 \
--executor-memory 2g \
--total-executor-cores 2

参数：–master spark://hadoop001:7077,hadoop002:7077指定要连接的集群的master

（8）执行WordCount程序

scala> sc.textFile("hdfs://hadoop001:9000/input/input").flatMap(_.split(" ")).map((_,1)).reduceByKey(_+_).collect
res1: Array[(String, Int)] = Array((scala,2), (python,2), (hello,10), (java,2), (world,2), (spark,2))

3）高可用测试

​ （1）查看hadoop001的master进程

13280 NameNode
15904 Jps
15029 Master
13403 DataNode
14715 QuorumPeerMain
15116 Worker
14237 HistoryServer

（2）Kill掉hadoop001的master进程，页面中观察http://hadoop002:8080/的状态是否切换为active。

image-20201103162012776

（3）再启动hadoop001的master进程

sbin/start-master.sh

2.4.5 运行流程

Spark有standalone-client和standalone-cluster两种模式，主要区别在于：Driver程序的运行节点。

1）客户端模式

bin/spark-submit \
--class org.apache.spark.examples.SparkPi \
--master spark://hadoop001:7077,hadoop002:7077 \
--executor-memory 1G \
--total-executor-cores 2 \
--deploy-mode client \
./examples/jars/spark-examples_2.11-2.4.5.jar \
10

–deploy-mode client，表示Driver程序运行在本地客户端

image-20201103163127678

2）集群模式模式

bin/spark-submit \
--class org.apache.spark.examples.SparkPi \
--master spark://hadoop001:7077,hadoop002:7077 \
--executor-memory 1G \
--total-executor-cores 2 \
--deploy-mode cluster \
./examples/jars/spark-examples_2.11-2.4.5.jar \
10

–deploy-mode cluster，表示Driver程序运行在集群

image-20201103163936094

​ （1）查看http://hadoop002:8080/页面，点击Completed Drivers里面的Worker

image-20201103164118762

​ （2）跳转到Spark Worker页面，点击Finished Drivers中Logs下面的stdout

image-20201103164203187

​ （3）最终打印结果如下

image-20201103172227818

2.5 Yarn模式（重点）

Spark客户端直接连接Yarn，不需要额外构建Spark集群。

2.5.1 安装使用

0）停止Standalone模式下的spark集群

sbin/stop-all.sh

hadoop002

sbin/stop-master.sh

1）为了防止和Standalone模式冲突，再单独解压一份spark

tar -zxvf spark-2.4.5-bin-hadoop2.6.tgz

2）修改名称为spark-yarn

mv spark-2.4.5-bin-hadoop2.6 spark-yarn

3）修改hadoop配置文件"/opt/hadoop/etc/hadoop/yarn-env.sh"，添加如下内容

​ 因为测试环境虚拟机内存较少，防止执行过程进行被意外杀死，做如下配置

<!--是否启动一个线程检查每个任务正使用的物理内存量，如果任务超出分配值，则直接将其杀掉，默认是true -->
<property>
     <name>yarn.nodemanager.pmem-check-enabled</name>
     <value>false</value>
</property>

<!--是否启动一个线程检查每个任务正使用的虚拟内存量，如果任务超出分配值，则直接将其杀掉，默认是true -->
<property>
     <name>yarn.nodemanager.vmem-check-enabled</name>
     <value>false</value>
</property>

4）分发配置文件

5）修改"/opt/spark-yarn/conf/spark-env.sh"，添加YARN_CONF_DIR配置，保证后续运行任务的路径都变成集群路径

 mv spark-env.sh.template spark-env.sh

添加如下内容

YARN_CONF_DIR=/opt/hadoop/etc/hadoop

image-20201103194947833

6）分发spark-yarn

7）启动HDFS以及YARN集群

start-all.sh

8）执行一个程序

bin/spark-submit \
--class org.apache.spark.examples.SparkPi \
--master yarn \
./examples/jars/spark-examples_2.11-2.4.5.jar \
10

参数：–master yarn，表示Yarn方式运行；–deploy-mod表示客户端方式运行程序

9）如果运行的时候，抛出如下异常

ClassNotFoundException:com.sun.jersey.api.client.config.ClientConfig

-原因分析
	Spark2中jersey版本是2.22，但是yarn中还需要依赖1.9，版本不兼容
-解决方式
在yarn-site.xml中，添加
	<property>
	    <name>yarn.timeline-service.enabled</name>
		<value>false</value>
</property>

10）查看hadoop002:8088页面，点击History，查看历史页面image-20201103200156315

2.5.2 配置历史服务

由于是重新解压的Spark压缩文件，所以需要针对Yarn模式，再次配置一下历史服务器。

1）修改spark-default.conf.template名称

mv spark-defaults.conf.template spark-defaults.conf

2）修改spark-default.conf文件，配置日志存储路径，并分发

spark.eventLog.enabled          true
spark.eventLog.dir               hdfs://hadoop001:9000/directory

3）修改spark-env.sh文件，添加如下配置：

export SPARK_HISTORY_OPTS="
-Dspark.history.ui.port=18080 
-Dspark.history.fs.logDirectory=hdfs://hadoop001:9000/directory 
-Dspark.history.retainedApplications=30"

# 参数1含义：WEBUI访问的端口号为18080

# 参数2含义：指定历史服务器日志存储路径

# 参数3含义：指定保存Application历史记录的个数，如果超过这个值，旧的应用程序信息将被删除，这个是内存中的应用数，而不是页面上显示的应用数。

4）分发配置文件

2.5.3 配置查看历史日志

为了从Yarn上关联到Spark历史服务器，需要配置关联路径。

1）修改配置文件"/opt/spark-yarn/conf/spark-defaults.conf"

添加如下内容：

spark.yarn.historyServer.address=hadoop001:18080
spark.history.ui.port=18080

2）同步spark-defaults.conf配置文件

3）重启Spark历史服务

sbin/stop-history-server.sh

sbin/start-history-server.sh

4）提交任务到Yarn执行

bin/spark-submit \
--class org.apache.spark.examples.SparkPi \
--master yarn \
./examples/jars/spark-examples_2.11-2.4.5.jar \
10

5）Web页面查看日志：http://hadoop002:8088/cluster

2.5.4 运行流程

Spark有yarn-client和yarn-cluster两种模式，主要区别在于：Driver程序的运行节点。

yarn-client：Driver程序运行在客户端，适用于交互、调试，希望立即看到app的输出。

yarn-cluster：Driver程序运行在由ResourceManager启动的APPMaster适用于生产环境。

1）客户端模式（默认）

bin/spark-submit \
--class org.apache.spark.examples.SparkPi \
--master yarn \
--deploy-mode client \
./examples/jars/spark-examples_2.11-2.4.5.jar \
10

image-20201104142508653

2）集群模式

bin/spark-submit \
--class org.apache.spark.examples.SparkPi \
--master yarn \
--deploy-mode cluster \
./examples/jars/spark-examples_2.11-2.4.5.jar \
10

（1）查看http://hadoop002:8088/cluster页面，点击History按钮，跳转到历史详情页面

image-20201104142622864

（2）点击Executors->点击driver中的stdout

image-20201104142641728

image-20201104142656559

*可能碰到的问题:*

如果在 yarn 日志端无法查看到具体的日志, 则在yarn-site.xml中添加如下配置并启动Yarn历史服务器

image-20201104142733160

<property>
    <name>yarn.log.server.url</name>
    <value>http://hadoop003:19888/jobhistory/logs</value>
</property>

注意：hadoop历史服务器也要启动 mr-jobhistory-daemon.sh start historyserver

image-20201104142833644

2.6 Mesos模式（了解）

Spark客户端直接连接Mesos；不需要额外构建Spark集群。国内应用比较少，更多的是运用Yarn调度。

2.7 几种模式对比

模式Spark安装机器数需启动的进程所属者
Local1无Spark
Standalone3Master及WorkerSpark
Yarn1Yarn及HDFSHadoop

2.8 端口号总结

1）Spark历史服务器端口号：18080 （类比于Hadoop历史服务器端口号：19888）

2）Spark Master Web端口号：8080（类比于Hadoop的NameNode Web端口号：9870(50070)）

3）Spark Master内部通信服务端口号：7077 （类比于Hadoop的8020(9000)端口）

4）Spark查看当前Spark-shell运行任务情况端口号：4040

5）Hadoop YARN任务运行情况查看端口号：8088

第3章 WordCount案例实操

Spark Shell仅在测试和验证我们的程序时使用的较多，在生产环境中，通常会在IDE中编制程序，然后打成Jar包，然后提交到集群，最常用的是创建一个Maven项目，利用Maven来管理Jar包的依赖。

3.1 编写程序

1）创建一个Maven项目WordCount

2）输入文件夹准备：在新建的WordCount项目名称上右键=》新建input文件夹=》在input文件夹上右键=》分别新建1.txt和2.txt。每个文件里面准备一些word单词。

3）导入项目依赖

<dependency>
      <groupId>org.scala-lang</groupId>
      <artifactId>scala-library</artifactId>
      <version>2.11.8</version>
    </dependency>
    <!-- https://mvnrepository.com/artifact/org.apache.spark/spark-sql -->
    <dependency>
      <groupId>org.apache.spark</groupId>
      <artifactId>spark-sql_2.11</artifactId>
      <version>2.1.1</version>
    </dependency>


    <dependency>
      <groupId>org.apache.spark</groupId>
      <artifactId>spark-core_2.11</artifactId>
      <version>2.1.1</version>
    </dependency>

    <dependency>
      <groupId>log4j</groupId>
      <artifactId>log4j</artifactId>
      <version>1.2.17</version>
    </dependency>

    <dependency>
      <groupId>org.slf4j</groupId>
      <artifactId>slf4j-api</artifactId>
      <version>1.7.21</version>
    </dependency>

4）创建伴生对象WordCount，编写代码

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

object WordCount {

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

        //1.创建SparkConf并设置App名称
        val conf = new SparkConf().setAppName("WC").setMaster("local[*]")

        //2.创建SparkContext，该对象是提交Spark App的入口
        val sc: SparkContext = SparkContext.getOrCreate(conf)

        //3.读取指定位置文件:hello atguigu atguigu
        val lineRdd: RDD[String] = sc.textFile("input")

        //4.读取的一行一行的数据分解成一个一个的单词（扁平化）
        val wordRdd: RDD[String] = lineRdd.flatMap(line => line.split(" "))

        //5. 将数据转换结构
        val wordToOneRdd: RDD[(String, Int)] = wordRdd.map(word => (word, 1))

        //6.将转换结构后的数据进行聚合处理
        val wordToSumRdd: RDD[(String, Int)] = wordToOneRdd.reduceByKey((v1, v2) => v1 + v2)

        //7.将统计结果采集到控制台打印
        val wordToCountArray: Array[(String, Int)] = wordToSumRdd.collect()
        wordToCountArray.foreach(println)

        //一行搞定
        //sc.textFile(args(0)).flatMap(_.split(" ")).map((_, 1)).reduceByKey(_ + _).saveAsTextFile(args(1))

        //8.关闭连接
        sc.stop()
    }
}

5）打包插件

<plugin>
    <groupId>org.apache.maven.plugins</groupId>
    <artifactId>maven-assembly-plugin</artifactId>
    <version>3.0.0</version>
    <configuration>
        <archive>
            <manifest>
                <mainClass>c这里写main函数的全类名</mainClass>
            </manifest>
        </archive>
        <descriptorRefs>
            <descriptorRef>jar-with-dependencies</descriptorRef>
        </descriptorRefs>
    </configuration>
    <executions>
        <execution>
            <id>make-assembly</id>
            <phase>package</phase>
            <goals>
                <goal>single</goal>
            </goals>
        </execution>
    </executions>
</plugin>

6）打包到集群测试

​ （1）点击package打包，然后，查看打完后的jar包

image-20201103234737577

image-20201103234802095

（2）将wc.jar上传到linux目录

（3）在HDFS上创建，存储输入文件的路径/input

hadoop fs -mkdir /input

（4）上传输入文件到/input路径

hadoop fs -put /input/1.txt /input

（5）执行任务

bin/spark-submit \
--class nj.WordCount \
--master yarn \
wc.jar \
/input \
/output

注意：input和ouput都是HDFS上的集群路径。

（6）查询运行结果

hadoop fs -cat /output/*

注意：如果运行发生压缩类没找到，可以参考如下方案解决

https://blog.csdn.net/dkcgx/article/details/44833425

3.2 本地调试

本地Spark程序调试需要使用Local提交模式，即将本机当做运行环境，Master和Worker都为本机。运行时直接加断点调试即可。如下：

object WordCount {

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

        //1.创建SparkConf并设置App名称，设置本地模式运行
        val conf = new SparkConf().setAppName("WC").setMaster("local[*]")

        //2.创建SparkContext，该对象是提交Spark App的入口
        val sc = new SparkContext(conf)

        //3.使用sc创建RDD，输入和输出路径都是本地路径
        sc.textFile("input").flatMap(_.split(" ")).map((_, 1)).reduceByKey(_ + _).saveAsTextFile("output")

        //4.关闭连接
        sc.stop()
    }
}

3.3 关联源码

1）按住ctrl键，点击RDD

image-20201104142108079

2）提示下载或者绑定源码

image-20201104142127082

3.4 异常处理

如果本机操作系统是Windows，如果在程序中使用了Hadoop相关的东西，比如写入文件到HDFS，则会遇到如下异常：

image-20201104142205695

出现这个问题的原因，并不是程序的错误，而是用到了hadoop相关的服务，解决办法

  1. 配置HADOOP_HOME环境变量

  2. 在IDEA中配置Run Configuration，添加HADOOP_HOME变量

子清.
关注
专栏目录
Spark入门
fengfengchen95的博客
05-22 590
一、Spark概述Apache Spark是一种闪电般的群集计算技术，专为快速计算而设计。 它基于Hadoop MapReduce，它扩展了MapReduce模型以便将其用于更多类型的计算，其中包括交互式查询和流处理。Spark的主要特点是其内存集群计算，可提高应用程序的处理速度，Spark旨在涵盖各种工作负载，如批处理应用程序，迭代算法，交互式查询和流式处理。 除了在各自的系统中支持所有这些工作...
用Apache Spark进行大数据处理——第一部分：入门介绍
tyb1222的专栏
04-02 2065
转自：http://www.infoq.com/cn/articles/apache-spark-introduction 什么是Spark Apache Spark是一个围绕速度、易用性和复杂分析构建的大数据处理框架。最初在2009年由加州大学伯克利分校的AMPLab开发，并于2010年成为Apache的开源项目之一。 与Hadoop和Storm等其他大数据和MapRe
0基础学习spark
最新发布
u014142328的博客
08-26 1160
0基础学习spark的一些笔记和总结
spark入门小例子
测试
03-01 428
1，pyspark2，spark-shellspark网页管理页面：http://127.0.0.1:4040/jobs/3，设置日志输出：log4j.properties.template。把这个日志设置模版文件复制一份到conf/log4j.properties 来作为日志设置文件，接下来找到下面这一行：log4j.rootCategory=INFO, console然后通过下面的设定降低...
Spark 入门篇之spark&spark sql
02-17 4138
Spark 入门篇 1      概述        Spark是一个通用的快速的大数据处理引擎，是类似于hadoop的map reduce大数据并行处理引擎。它的数据源可以是hdfs、cassandra、hbase等，除常规编程模式外，它还是支持sql使用方式。Spark支持streaming流式计算（秒级延迟）、机器学习库MLib、图计算GraphX、Bagel（Google的pregel
Spark入门篇——RDD的血缘
真一居士的博客
10-21 1613
目录 RDD的血缘 概述 划分依赖的背景 划分以来的依据 窄依赖 宽依赖 join的依赖 宽依赖 窄依赖 依赖与Stage的划分 Stage的类别 依赖与容错 转换算子中间发生失败 DAG的生成 总结 RDD的血缘 概述 RDD可以从本地集合并行化、从外部文件系统、其他RDD转化得到，能从其他RDD通过Transformation创建新的RDD的原因是R...
Spark入门篇——RDD的缓存/持久化
真一居士的博客
11-04 1089
目录 RDD的缓存/持久化 缓存的意义 RDD的缓存方式 cache注意事项 Checkpoint 原理 流程 缓存和checkpoint的比较 例子 RDD的缓存/持久化 Spark速度非常快的原因之一，就是在不同操作中可以在内存中持久化或缓存数据集。当持久化某个RDD之后，每一个节点都将把计算的分片结果保存在内存中，并且对此RDD或衍生出的RDD进行的其他动作重用。这使得...
Spark入门篇——RDD与算子
真一居士的博客
10-16 482
目录 RDD与算子 简介 创建RDD 集合并行化 外部文件系统创建 父类RDD转换成新的子RDD RDD的属性 RDD的分区 RDD编程 RDD算子 Transformation Action RDD与算子 简介 RDD（Redilient Distrobuted Dataset） 是Spark的计算模型，叫做弹性的分布式数据集，是Spark中最基本的数据抽象，它代表...
Spark基础入门篇 | MapReduce原理 + Spark原理 + PySpark环境搭建 + 简单实战
weixin_43646592的博客
05-31 924
Spark基础入门篇 | MapReduce原理 + Spark原理 + PySpark环境搭建 + 简单实战
spark-windows helloword入门例子
03-08
spark-windows helloword入门例子 spark-windows helloword入门例子
分享的spark简单的应用代码（入门级）
05-19
分享的spark简单的应用代码（入门级），使用IDEA开发的java与scala代码，与博客关联。
大数据技术之Spark入门（一）概述
大数据Spark教程
12-12 879
1.1 什么是Spark 1.2 Spark内置模块 Spark Core：实现了Spark的基本功能，包含任务调度、内存管理、错误恢复、与存储系统交互等模块。Spark Core中还包含了对弹性分布式数据集(Resilient Distributed DataSet，简称RDD)的API定义。 Spark SQL：是Spark用来操作结构化数据的程序包。通过Spark ...
Spark快速入门：Python接口详解
"Spark入门（Python版）" 这篇文章主要介绍了Spark作为大数据处理工具的优势，以及其相对于Hadoop MapReduce的改进。Spark是一个快速、通用且可扩展的分布式计算系统，尤其适合于处理需要迭代和交互式的计算任务，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值