Spark端口总结

Spark的端口总结

Master节点的web端口是8080,work节点的web端口是8081

spark master web ui 默认端口为8080，当系统有其它程序也在使用该接口（比如:Tomcat）时，启动master时也不会报错，spark自己会改用其它端口，自动端口号加1,也可以自行设置,修改方法:

1、cd $SPARK_HOME/sbin

2、vi start-mastersh

if [ "$SPARK_MASTER_WEBUI_PORT" = "" ]; then

SPARK_MASTER_WEBUI_PORT=8080 #可以修改端口号

fi

8080端口:master WEB端口

8081端口:work WEB端口

7077端口:

master通信端口

18080端口:spark历史服务器端口

相关配置：

conf目录下

cp spark-defaultsconftemplate spark-defaultsconf

编辑spark-defaultsconf这个文件

编辑spark-envsh文件

使用sbin/start-history-serversh脚本启动

启动日志:

执行spark任务

启动日志：

Web界面

4040端口:

23  Spark当前执行的任务页面查看端口4040（例如：使用spark-shell启动spark，此时的任务可以在4040端口页面查看），如果任务结束了4040端口页面不能访问

默认是4040，我改配置改了下

一直以来，基于Akka实现的RPC通信框架是Spark引以为豪的主要特性，也是与Hadoop等分布式计算框架对比过程中一大亮点，但是时代和技术都在演化，从Spark131版本开始， 为了解决大块数据（如Shuffle）的传输问题 ，Spark引入了Netty通信框架，到了160版本，Netty完全取代了Akka，承担Spark内部所有的RPC通信以及数据流传输。

JAVA IO也经历了几次演化，从最早的BIO（阻塞式/非阻塞IO），到14版本的NIO（IO复用），到17版本的NIO20/AIO（异步IO）。

基于早期BIO来实现高并发网络服务器都是依赖多线程来实现，但是线程开销较大，BIO的瓶颈明显，NIO的出现解决了这一大难题， 基于IO复用解决了IO高并发 。

但是NIO有也有几个缺点：

因为这几个原因，促使了很多JAVA-IO通信框架的出现，Netty就是其中一员，它也因为高度的稳定性，功能性，性能等特性，成为Java开发的首选

首先是NIO的上层封装，Netty提供了NioEventLoopGroup / NioSocketChannel / NioServerSocketChannel的组合来完成实际IO操作，继而在此之上实现数据流Pipeline以及EventLoop线程池等功能。

另外它又重写了NIO，JDK-NIO底层是基于Epoll的LT模式来实现，而Netty是基于Epoll的ET模式实现的一组IO操作EpollEventLoopGroup / EpollSocketChannel / EpollServerSocketChannel

Netty对两种实现进行完美的封装，可以根据业务的需求来选择不同的实现

从Akka出现背景来说，它是基于Actor的RPC通信系统，它的核心概念也是Message，它是基于协程的，性能不容置疑；基于scala的偏函数，易用性也没有话说，但是它毕竟只是RPC通信，无法适用大的package/stream的数据传输，这也是Spark早期引入Netty的原因。

首先不容置疑的是Akka可以做到的，Netty也可以做到，但是Netty可以做到，Akka却无法做到。原因是啥？在软件栈中，Akka相比Netty要Higher一点，它专门针对RPC做了很多事情，而Netty相比更加基础一点， 可以为不同的应用层通信协议（RPC，FTP，HTTP等）提供支持 ，在早期的Akka版本，底层的NIO通信就是用的Netty。

其次一个优雅的工程师是不会允许一个系统中容纳两套通信框架！最后，虽然Netty没有Akka协程级的性能优势，但是Netty内部高效的Reactor线程模型，无锁化的串行设计，高效的序列化，零拷贝，内存池等特性也保证了Netty不会存在性能问题。

那么Spark是怎么用Netty来取代Akka呢？一句话，利用偏函数的特性，基于Netty“仿造”出一个简约版本的Actor模型。

对于Network通信，不管传输的是序列化后的对象还是文件，在网络上表现的都是字节流。在传统IO中，字节流表示为Stream；在NIO中，字节流表示为ByteBuffer；在Netty中字节流表示为ByteBuff或FileRegion；在Spark中，针对Byte也做了一层包装，支持对Byte和文件流进行处理，即ManagedBuffer；

ManagedBuffer包含了三个函数createInputStream()，nioByteBuffer()，convertToNetty()来对Buffer进行“类型转换”，分别获取stream，ByteBuffer，ByteBuff或FileRegion；NioManagedBuffer / NettyManagedBuffer / FileSegmentManagedBuffer也是针对性提供了具体的实现。

更好的理解ManagedBuffer ：比如Shuffle BlockManager模块需要在内存中维护本地executor生成的shuffle-map输出的文件引用，从而可以提供给shuffleFetch进行远程读取，此时文件表示为FileSegmentManagedBuffer，shuffleFetch远程调用FileSegmentManagedBuffernioByteBuffer / createInputStream函数从文件中读取为Bytes，并进行后面的网络传输。如果已经在内存中bytes就更好理解了，比如将一个字符数组表示为NettyManagedBuffer。

协议是应用层通信的基础，它提供了应用层通信的数据表示，以及编码和解码的能力。在Spark Network Common中，继承AKKA中的定义，将协议命名为Message，它继承Encodable，提供了encode的能力。

Message根据请求响应可以划分为RequestMessage和ResponseMessage两种；对于Response，根据处理结果，可以划分为Failure和Success两种类型；根据功能的不同，主要划分为Stream，ChunkFetch，Rpc。

Server构建在Netty之上，它提供两种模型NIO和Epoll，可以通过参数（spark[module]iomode)进行配置，最基础的module就是shuffle，不同的IOMode选型，对应了Netty底层不同的实现，Server的Init过程中，最重要的步骤就是根据不同的IOModel完成EventLoop和Pipeline的构造

其中，MessageEncoder/Decoder针对网络包到Message的编码和解码，而最为核心就TransportRequestHandler，它封装了对所有请求/响应的处理；

TransportChannelHandler内部实现也很简单，它封装了responseHandler和requestHandler，当从Netty中读取一条Message以后，根据判断路由给相应的responseHandler和requestHandler。

Sever提供的RPC，ChunkFecth，Stream的功能都是依赖TransportRequestHandler来实现的；从原理上来说，RPC与ChunkFecth / Stream还是有很大不同的，其中RPC对于TransportRequestHandler来说是功能依赖，而ChunkFecth / Stream对于TransportRequestHandler来说只是数据依赖。

怎么理解？即TransportRequestHandler已经提供了ChunkFecth / Stream的实现，只需要在构造的时候，向TransportRequestHandler提供一个streamManager，告诉RequestHandler从哪里可以读取到Chunk或者Stream。而RPC需要向TransportRequestHandler注册一个rpcHandler，针对每个RPC接口进行功能实现，同时RPC与ChunkFecth / Stream都会有同一个streamManager的依赖，因此注入到TransportRequestHandler中的streamManager也是依赖rpcHandler来实现，即rpcHandler中提供了RPC功能实现和streamManager的数据依赖。

Server是通过监听一个端口，注入rpcHandler和streamManager从而对外提供RPC，ChunkFecth，Stream的服务，而Client即为一个客户端类，通过该类，可以将一个streamId / chunkIndex对应的ChunkFetch请求，streamId对应的Stream请求，以及一个RPC数据包对应的RPC请求发送到服务端，并监听和处理来自服务端的响应；其中最重要的两个类即为TransportClient和TransportResponseHandler分别为上述的“客户端类”和“监听和处理来自服务端的响应"。

那么TransportClient和TransportResponseHandler是怎么配合一起完成Client的工作呢？ 由TransportClient将用户的RPC，ChunkFecth，Stream的请求进行打包并发送到Server端，同时将用户提供的回调函数注册到TransportResponseHandler，TransportResponseHandler是TransportChannelHandler的一部分，在TransportChannelHandler接收到数据包，并判断为响应包以后，将包数据路由到TransportResponseHandler中，在TransportResponseHandler中通过注册的回调函数，将响应包的数据返回给客户端

无论是BlockTransfer还是ShuffleFetch都需要跨executor的数据传输，在每一个executor里面都需要运行一个Server线程（后面也会分析到，对于Shuffle也可能是一个独立的ShuffleServer进程存在）来提供对Block数据的远程读写服务

在每个Executor里面，都有一个BlockManager模块，它提供了对当前Executor所有的Block的“本地管理”，并对进程内其他模块暴露getBlockData(blockId: BlockId): ManagedBuffer的Block读取接口，但是这里GetBlockData仅仅是提供本地的管理功能，对于跨远程的Block传输，则由NettyBlockTransferService提供服务。

NettyBlockTransferService本身即是Server，为其他其他远程Executor提供Block的读取功能，同时它即为Client，为本地其他模块暴露fetchBlocks的接口，支持通过host/port拉取任何Executor上的一组的Blocks。

源码位置 spark-core: orgapachesparknetworknetty

NettyBlockTransferService作为一个Server，与Executor或Driver里面其他的服务一样，在进程启动时，由SparkEnv初始化构造并启动服务，在整个运行时的一部分。

一个Server的构造依赖RpcHandler提供RPC的功能注入以及提供streamManager的数据注入。对于NettyBlockTransferService，该RpcHandler即为NettyBlockRpcServer，在构造的过程中，需要与本地的BlockManager进行管理，从而支持对外提供本地BlockMananger中管理的数据

RpcHandler提供RPC的功能注入 在这里还是属于比较“简陋的”，毕竟他是属于数据传输模块，Server中提供的chunkFetch和stream已经足够满足他的功能需要，那现在问题就是怎么从streamManager中读取数据来提供给chunkFetch和stream进行使用呢？

就是NettyBlockRpcServer作为RpcHandler提供的一个Rpc接口之一：OpenBlocks，它接受由Client提供一个Blockids列表，Server根据该BlockIds从BlockManager获取到相应的数据并注册到streamManager中，同时返回一个StreamID，后续Client即可以使用该StreamID发起ChunkFetch的操作。

从NettyBlockTransferService作为一个Server，我们基本可以推测NettyBlockTransferService作为一个Client支持fetchBlocks的功能的基本方法：

同时，为了提高服务端稳定性，针对fetchBlocks操作NettyBlockTransferService提供了非重试版本和重试版本的BlockFetcher，分别为OneForOneBlockFetcher和RetryingBlockFetcher，通过参数（spark[module]iomaxRetries)进行配置，默认是重试3次

在Spark，Block有各种类型，可以是ShuffleBlock，也可以是BroadcastBlock等等，对于ShuffleBlock的Fetch，除了由Executor内部的NettyBlockTransferService提供服务以外，也可以由外部的ShuffleService来充当Server的功能，并由专门的ExternalShuffleClient来与其进行交互，从而获取到相应Block数据。功能的原理和实现，基本一致，但是问题来了， 为什么需要一个专门的ShuffleService服务呢？ 主要原因还是为了做到任务隔离，即减轻因为fetch带来对Executor的压力，让其专心的进行数据的计算。

在目前Spark中，也提供了这样的一个AuxiliaryService：YarnShuffleService，但是对于Spark不是必须的，如果你考虑到需要“ 通过减轻因为fetch带来对Executor的压力 ”，那么就可以尝试尝试。

同时，如果启用了外部的ShuffleService，对于shuffleClient也不是使用上面的NettyBlockTransferService，而是专门的ExternalShuffleClient，功能逻辑基本一致！

Akka的通信模型是基于Actor，一个Actor可以理解为一个Service服务对象，它可以针对相应的RPC请求进行处理，如下所示，定义了一个最为基本的Actor：

Actor内部只有唯一一个变量（当然也可以理解为函数了），即Receive，它为一个偏函数，通过case语句可以针对Any信息可以进行相应的处理，这里Any消息在实际项目中就是消息包。

另外一个很重要的概念就是ActorSystem，它是一个Actor的容器，多个Actor可以通过name->Actor的注册到Actor中，在ActorSystem中可以根据请求不同将请求路由给相应的Actor。ActorSystem和一组Actor构成一个完整的Server端，此时客户端通过host:port与ActorSystem建立连接，通过指定name就可以相应的Actor进行通信，这里客户端就是ActorRef。所有Akka整个RPC通信系列是由Actor，ActorRef，ActorSystem组成。

Spark基于这个思想在上述的Network的基础上实现一套自己的RPC Actor模型，从而取代Akka。其中RpcEndpoint对应Actor，RpcEndpointRef对应ActorRef，RpcEnv即对应了ActorSystem。

RpcEndpoint与Actor一样，不同RPC Server可以根据业务需要指定相应receive/receiveAndReply的实现，在Spark内部现在有N多个这样的Actor，比如Executor就是一个Actor，它处理来自Driver的LaunchTask/KillTask等消息。

RpcEnv相对于ActorSystem：

RpcEndpointRef即为与相应Endpoint通信的引用，它对外暴露了send/ask等接口，实现将一个Message发送到Endpoint中。

这就是新版本的RPC框架的基本功能，它的实现基本上与Akka无缝对接，业务的迁移的功能很小，目前基本上都全部迁移完了。

RpcEnv不仅从外部接口与Akka基本一致，在内部的实现上，也基本差不多，都是按照MailBox的设计思路来实现的；

RpcEnv即充当着Server，同时也为Client内部实现。

当作为Server ，RpcEnv会初始化一个Server，并注册NettyRpcHandler。RpcHandler的receive接口负责对每一个请求进行处理，一般情况下，简单业务可以在RpcHandler直接完成请求的处理，但是考虑一个RpcEnv的Server上会挂载了很多个RpcEndpoint，每个RpcEndpoint的RPC请求频率不可控，因此需要对一定的分发机制和队列来维护这些请求，其中Dispatcher为分发器，InBox即为请求队列；

在将RpcEndpoint注册到RpcEnv过程中，也间接的将RpcEnv注册到Dispatcher分发器中，Dispatcher针对每个RpcEndpoint维护一个InBox，在Dispatcher维持一个线程池（线程池大小默认为系统可用的核数，当然也可以通过sparkrpcnettydispatchernumThreads进行配置），线程针对每个InBox里面的请求进行处理。当然实际的处理过程是由RpcEndpoint来完成。

其次RpcEnv也完成Client的功能实现 ，RpcEndpointRef是以RpcEndpoint为单位，即如果一个进程需要和远程机器上N个RpcEndpoint服务进行通信，就对应N个RpcEndpointRef（后端的实际的网络连接是公用，这个是TransportClient内部提供了连接池来实现的），当调用一个RpcEndpointRef的ask/send等接口时候，会将把“消息内容+RpcEndpointRef+本地地址”一起打包为一个RequestMessage，交由RpcEnv进行发送。注意这里打包的消息里面包括RpcEndpointRef本身是很重要的，从而可以由Server端识别出这个消息对应的是哪一个RpcEndpoint。

和发送端一样，在RpcEnv中，针对每个remote端的host:port维护一个队列，即OutBox，RpcEnv的发送仅仅是把消息放入到相应的队列中，但是和发送端不一样的是：在OutBox中没有维护一个所谓的线程池来定时清理OutBox，而是通过一堆synchronized来实现的，add之后立刻消费。

摘自：Github/ColZer

在windows中spark的本地模式如何配置

1、在Spark中采用本地模式启动pyspark的命令主要包含以下参数：master：这个参数表示当前的pyspark要连接到哪个master，如果是local[]，就是使用本地模式启动pyspark，其中，中括号内的星号表示需要使用几个CPU核心(core)。

2、肯定第一步是配置spark环境：包括linux系统的安装，java，ssh，Hadoop，Scala，spark的安装与环境变量设置。虽说简单，但对于初学者说，尤其是没有使用过linux系统的，还是有些挑战。其中遗漏一些细节问题，都会出错。

3、Spark on Yarn模式 备注：Yarn的连接信息在Hadoop客户端的配置文件中指定。通过spark-envsh中的环境变量HADOOPCONFDIR指定Hadoop配置文件路径。

4、最后的PhysicalPlan execution阶段用Spark代替Hadoop MapReduce。通过配置Shark参数，Shark可以自动在内存中缓存特定的RDD，实现数据重用，进而加快特定数据集的检索。

代号spark怎么组队

打开代号spark应用程序。 点击底部的“我”选项卡。 在个人资料页面上，找到“邀请好友”选项。 选择您要使用的邀请方式：通过电话短信、电子邮件或复制链接发送邀请。

在该平台上搜索代号Spark的账号。你可以在搜索栏中输入代号Spark的名字或账号名来查找他/她。 找到代号Spark的账号后，进入他/她的个人主页。在个人主页上，你可以找到添加好友的按钮或链接。

代号spark服务器到7个使用专门的集群管理工具。如ApacheMesos、ApacheHadoopYARN或Kubernetes，来管理这些服务器，这些工具可以帮助自动化任务调度、资源分配和监控，确保服务器资源的最佳利用。

具体方法如下： 打开Spark游戏客户端，在主界面点击右上角的“设置”按钮。 在设置界面中选择“账户”。 点击“退出当前账号”。 回到Spark主界面，选择“游客登录”。

代号spark游客登录怎么换一个游客

：使用游客账号登录游戏，确认当前角色为游客账号对应角色。2：在游戏中切换或退出到账号登录界面。3：在游客账号登录界面直接点击注册账号，注册一个全新的VIVO账号后，即可将原游客信息与该VIVO账号绑定。

绝地求生未来之役有两个游客账号换号在打大厅里面点设置更换重新就可以了，绝地求生未来之役依旧采用原来的吃鸡模式。

首先，打开游戏《原神》。然后，在游戏主界面下方选择“设置”。进入设置界面后，在右上角找到“账号管理”选项，点击进入。选择“切换账号”。

用游客身份进入游戏，切换帐号之后会导致你的角色消失，可以按照下面的步骤：首先是登录常见问题，先按游客登录游戏。选择了游客登录之后之后若已经进入游戏，则可以点击设置，选择用户中心进入之后点击“绑定游戏帐号”。

首先在手机上打开刺激战场游戏，然后完成游客登录。进入游戏主界面后，点击该界面右下角的设置按钮。然后进入游戏的设置界面，点击左下角的退出登录按钮。接着弹出一个退出登录提示，点击确定就可以了。

代号spark怎么修东西

代号spark炼钢炉在建造菜单中。代号spark游戏内可以通过升级解锁炼钢炉，然后在建造菜单中显示。用炼钢炉可消耗材料以制造钢锭。在部分据点内，炼钢炉作为公共设施，任何人都可使用。

它的操作步骤如下：根据游戏《代号：Spark》官方资料显示，选择一个铁匠铺或熔炉，这些地方通常可以在城镇或村庄中找到。将精铁矿石放入熔炉或铁匠铺中，并添加煤炭或木炭作为燃料。

首先，检查程序是否有错误或者代码是否有Bug，并进行修复。其次，检查计算机的内存是否充足，内存不足，可以通过关闭一些程序或者扩充内存的方式来解决。

自我解脱需要从自身的心态和状态入手，需要一定的时间和努力才能实现。2 首先，代号spark可以通过调整自己的工作和生活方式，减轻负担，缓解压力，以达到更好的心态和状态。

熔炉制造。根据查询代号spark游戏官网得知，代号Spark炼钢炉可以使用熔炉制造。代号Spark官网版是一个可玩性超高的开放世界生存竞技手游。

学习Spark的相关技术、安装和配置Spark。学习Spark的相关技术：包括Spark的核心概念、SparkSQL、SparkStreaming、SparkMLlib、SparkGraphX等技术。安装和配置Spark：下载并安装Spark，进行相关配置，在本地运行Spark应用程序。

1、百度搜索Spark，找到Downloads | Apache Spark点击进入Spark官方下载页面。

2、点击选择你的hadoop版本所对应的Spark版本。

3、这里点击第一个，选择要安装的目录。

4、编辑spark-envsh文件(vim /conf/spark-envsh)，在第一行添加以下配置信息。

5、验证Spark安装和配置，通过运行Spark自带的示例，验证Spark是否安装成功。

6、运行结果如下图所示，可以得到π 的 14位小数近似值。

Spark 的运行模式有 Local(也称单节点模式），Standalone(集群模式），Spark on Yarn(运行在Yarn上），Mesos以及K8s等常用模式，本文介绍前三种模式。

Spark-shell 参数

Spark-shell 是以一种交互式命令行方式将Spark应用程序跑在指定模式上，也可以通过Spark-submit提交指定运用程序，Spark-shell 底层调用的是Spark-submit,二者的使用参数一致的，通过- -help 查看参数：

sparkconf的传入有三种方式：

1通过在spark应用程序开发的时候用set()方法进行指定

2通过在spark应用程序提交的时候用过以上参数指定，一般使用此种方式，因为使用较为灵活

3通过配置spark-defaultconf，spark-envsh文件进行指定，此种方式较shell方式级别低

Local模式

Local 模式是最简单的一种Spark运行方式，它采用单节点多线程（cpu)方式运行，local模式是一种OOTB（开箱即用）的方式，只需要在spark-envsh导出JAVA_HOME,无需其他任何配置即可使用，因而常用于开发和学习

方式：/spark-shell - -master local[n] ，n代表线程数

Standalone模式

Spark on Yarn

on Yarn的俩种模式

客户端的Driver将应用提交给Yarn后，Yarn会先后启动ApplicationMaster和excutor,另外ApplicationMaster和executor都装在在container里运行，container默认的内存是1g，ApplicationMaster分配的内存是driver-memory,executor分配的内存是executor-memory同时，因为Driver在客户端，所以程序的运行结果可以在客户端显示，Driver以进程名为SparkSubmit的形式存在。

Cluster 模式

1由client向ResourceManager提交请求，并上传Jar到HDFS上

这期间包括四个步骤:

a)连接到RM

b)从RM ASM(applicationsManager)中获得metric，queue和resource等信息。

c)upload app jar and spark-assembly jar

d)设置运行环境和container上下文

2ResourceManager向NodeManager申请资源，创建Spark ApplicationMaster（每个SparkContext都有一个ApplicationManager）

3NodeManager启动Spark App Master，并向ResourceManager ASM注册

4Spark ApplicationMaster从HDFS中找到jar文件，启动DAGScheduler和YARN Cluster Scheduler

5ResourceManager向ResourceManager ASM注册申请container资源(INFO YarnClientImpl: Submitted application)

6ResourceManager通知NodeManager分配Container，这是可以收到来自ASM关于container的报告。(每个container的对应一个executor)

7Spark ApplicationMaster直接和container(executor)进行交互，完成这个分布式任务。

进入spark安装目录下的conf文件夹

[atguigu@hadoop102 module] mv slavestemplate slaves

[atguigu@hadoop102 conf] vim slaves

hadoop102

hadoop103

hadoop104

4）修改spark-envsh文件，添加如下配置：

[atguigu@hadoop102 conf]$ vim spark-envsh

SPARK_MASTER_HOST=hadoop102

SPARK_MASTER_PORT=7077

5）分发spark包

[atguigu@hadoop102 module] sbin/start-allsh

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

export JAVA_HOME=XXXX

官方求PI案例

spark-submit

--class orgapachesparkexamplesSparkPi

--master spark://server-2:7077

--executor-memory 1G

--total-executor-cores 2

/home/xxx/software/spark-244-bin-hadoop27/examples/jars/spark-examples_211-244jar

100

spark-shell

--master spark://server-2:7077

--executor-memory 1g

--total-executor-cores 2

spark-shell --master spark://server-2:7077 --executor-memory 1g --total-executor-cores 2

参数：--master spark://server-2:7077 指定要连接的集群的master

Spark客户端直接连接Yarn，不需要额外构建Spark集群。有yarn-client和yarn-cluster两种模式，主要区别在于：Driver程序的运行节点。

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

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

安装使用

1）修改hadoop配置文件yarn-sitexml,添加如下内容：

2）修改spark-envsh，添加如下配置：

[atguigu@hadoop102 conf]$ vi spark-envsh

YARN_CONF_DIR=/opt/module/hadoop-272/etc/hadoop

3）分发配置文件

[atguigu@hadoop102 conf] xsync spark-envsh

4）执行一个程序

spark-submit

--class orgapachesparkexamplesSparkPi

--master yarn

--deploy-mode client

/home/xxx/software/spark-244-bin-hadoop27/examples/jars/spark-examples_211-244jar

100

注意：在提交任务之前需启动HDFS以及YARN集群。

日志查看

修改配置文件spark-defaultsconf

添加如下内容：

sparkyarnhistoryServeraddress=server-2:18080

sparkhistoryuiport=18080

2）重启spark历史服务

[atguigu@hadoop102 spark] sbin/start-history-serversh

starting orgapachesparkdeployhistoryHistoryServer, logging to /opt/module/spark/logs/spark-atguigu-orgapachesparkdeployhistoryHistoryServer-1-hadoop102out

3）提交任务到Yarn执行

spark-submit

--class orgapachesparkexamplesSparkPi

--master yarn

--deploy-mode client

/home/xxx/software/spark-244-bin-hadoop27/examples/jars/spark-examples_211-244jar

100