Spark资料总结

最新推荐文章于 2024-05-16 19:26:23 发布
最新推荐文章于 2024-05-16 19:26:23 发布
阅读量1.2k 收藏 11
点赞数
分类专栏： 大数据 文章标签： spark
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/hotdust/article/details/54290840
版权

一、学习

1，安装Spark，并了解基础操作

首先安装上Spark，再执行一下基础操作，就可以了。这里的目的是通过Spark的Shell，了解一下Spark的基础操作。接下来看看文章下面的一些概念和作用什么的就可以，不用看的太细。

2，了解如何使用Java编写Spark程序

（1）先看一下官方的文档。如果对于不了解Spark的人来说，直接看官方文档可能很难理解，所以在官方文档下面有一个中文版的官方文档。

（2）在看官方文档时，会看到关于RDD中使用Closure的问题，对于这个问题可以看一下下面3个文档来了解一一下。

（3）在看官方文档时，可能还会看到一些Driver、Node、Partition等词汇。想了解关于Spark的一些基础概念的话，可以看下面的文章。

（4）在看官方文档时，会看到一些Map和Reduce的API，下面的文章，让你能快速知道这个API的用法。

3，启动 spark 方法。

（1）学习文章

（2）常用命令

1，上传 jar 到 hdfs
hdfs dfs -put spark-test-1.0-SNAPSHOT.jar hdfs://nameservice1/test/sjp/monitor/spark-test.jar
2，启动 spark
spark2-submit --class test.SparkStreamingServiceDemo5 --deploy-mode cluster --master yarn hdf//nameservice1/test/sjp/monitor/spark-test.jar cloud_aggregation cm_input cm_output 10.31.187.4:9092

二、经验

1，安装完 YARN 后，安装 Spark 是否还需要 worker？

个人感觉不用。因为原来 Work 的工作，都由 NodeManager 来处理了。

2，停止正在运行在 yarn 上的 spark 程序。

1，使用下面的命令找出对应的 application。yarn application -list
2，杀死 application。yarn application -kill application_1537252157889_00023
参考：如何使用 Curl 停止 Spark 中某个正在运行的 Yarn 作业

3，关于 Spark 程序的打包

15，在打包时，使用 maven-shade-plugin 打包，org.apache.spark group 的依赖设置成 <scope>provided</scope>，这些包不用打包，在环境上都有。
jar 大小可以减少很多，包含 spark-core_2.11、spark-streaming_2.11、spark-streaming-kafka-0-10_2.11 的包有 100多M，不包含只有 500K。其它的 jar 还是要包含的。
参考：利用maven-shade-plugin打包包含所有依赖jar包

为了避免每次spark上传很大的依赖包，还可以把大部分依赖放到hdfs上,然后在spark_default中指明spark.yarn.jars到hdfs目录

4，本地程序调试，不使用 setMaster

VM options中输入“-Dspark.master=local”

5，如何在Windows中使用Intellij idea搭建远程Hadoop开发环境？

https://www.zhihu.com/question/50820730/answer/124755135
https://blog.csdn.net/qq_31806205/article/details/80451743

6，spark 设置 hadoop 等配置方法

1，在程序内部设置（测试过）
sparkConf.set(“spark.hadoop.dfs.replication”, “1”);

2，命令行设置（没有测试过）
spark-submit --conf spark.hadoop.fs.s3a.access.key=value

3，在程序内，读 hdfs-site.xml 等配置文件（没有测试过）
基本方法就是把这些文件放到 classpath 下，方法有 2 个。

更多参考：Spark Configuration

7，使用 saveAsHadoopFile 时生产 _SUCCESS 文件问题

使用 saveAsHadoopFile 保存文件时，有时候会产生 _SUCCESS 文件。使用下面的设置就可以不产生这个文件：

sparkConf.set(“spark.hadoop.mapreduce.fileoutputcommitter.marksuccessfuljobs”, “false”);

参考：How to avoid _success file in Mapreduce Output Folder.
我产生 _SUCCESS 文件的原因。

8，把 JavaPairDStream 输出到多个文件

（1）如果要输出到多个文件到指定目录，并且指定文件名的话，需要自己实现输出类。这个输出类要继承 MultipleOutputFormat 类。MultipleOutputFormat 是输出到多个文件的类，但如果要输出成我们指定的文件名的话，需要自己实现一些方法。

（2）在输出时，可以使用两个方式：

  • Dstream.saveAsHadoopFiles：这种方式加上面的 MultipleOutputFormat 实现类，可以完成我们的需要。但必须还要输出以 “prefix-TIME_IN_MS[.suffix]” 为名字的文件夹，而且是必须输出。
  • JavaRDD.saveAsHadoopFiles：可以不必须输出临时文件夹。但要输出一个 _SUCCESS 文件。设置sparkConf.set("spark.hadoop.mapreduce.fileoutputcommitter.marksuccessfuljobs", "false") 可以避免输出这个文件。

（3）在输出时，如果要输出到同一个文件中的话，可使用 rdd.coalesce(1) 把数据重新分区。如果 rdd 已经是 reduceByKey 这种已经分区完成的 rdd 的话，并且要按 key 相同的输出到一个文件的话，应该可以不使用 rdd.coalesce(1) 。要注意：如果不同的分区的数据，要交差输出到不同的文件的话，可能会有问题。

coalesce 功能是重新分区，相当于 repartition(x, true)。

pair.foreachRDD(rdd->{
    if (rdd.count() != 0) {
        rdd.saveAsHadoopFile("hdfs://localhost:9000/test/", String.class, String.class, RDDMultipleAppendTextOutputFormat.class);
//                rdd.coalesce(1).saveAsHadoopFile("hdfs://localhost:9000/test/", String.class, String.class, RDDMultipleAppendTextOutputFormat.class);

    }

});

参考：

9，Idea 开发时常配置的参数

在进行 Idea 开发时，需要配置一些本地开发用的参数。如果这些参数用代码写到程序中，在到生产环境使用时，忘记需要注释掉会很麻烦。所以，把一些参数在 Idea 的Run/Debug Configurations中进行设置，不会影响代码。常用配置如下：

(1)在 VM Option：

  • -Dspark.master=local ：设置本地启动
  • -Dspark.hadoop.dfs.replication=1 ：设置 hadoop 写的数据的副本为 1 份。一般在自己机器上安装 hadoop 时，都是单 dataNode 的。如果不设置这个，Append 数据时可能会产生一个错误。
  • -Dspark.hadoop.fs.default.name=hdfs://localhost:9000 ：设置 Hadoop 的 默认服务名。一般在自己机器上安装 hadoop 时，如果在这里设置些项目的话，使用hdfs:///xxx方式的话，会报错。如果写命名hdfs://nameserver/xxx的话不会报错，但这样程序的可移植性就低了。

10，注意进行 cache

请看下面的代码，下面的代码逻辑很简单：1，生成 pair 2，保存 pair。如果像下面这样做的话，生成 pair 代码里面的System.out.println("pair called");会输出 4 遍。但如果在生成 pair和保存pair代码之间加 pair.cache 的话，就会只输出 2 遍。这说明，不进行 cache 的话，保存时使用 pair 时候，又进行了一次和生成 pair一样的过程。所以要注意使用 cache 功能。

// 生成 pair
JavaPairDStream<String, String> pair = messages.map(ConsumerRecord::value)
        .mapToPair(log -> {
            System.out.println("pair called");
                return new Tuple2<>("", "");
            }
        });
// 保存 pair
pair.foreachRDD(rdd->{
    long rddCnt = rdd.count();
    if (rddCnt != 0) {
        rdd.saveAsHadoopFile("", String.class, String.class, CustomClass.class);
    }
});

可能又会想，如果把生成和保存操作，像下面这样连上写，会不会只生成 2 遍呢？经过测试，也会生成 4 遍。所以，要注意进行 cache。

// 生成并保存 pair
	messages.map(ConsumerRecord::value)
        .mapToPair(log -> {
            System.out.println("pair called");
                return new Tuple2<>("", "");
            }
        }).foreachRDD(rdd->{
			    long rddCnt = rdd.count();
			    if (rddCnt != 0) {
			        rdd.saveAsHadoopFile("", String.class, String.class, CustomClass.class);
			    }
		});

11，在 transform 中 print

spark 的设计是在 transform 时，我们想打印 transform 过程中的值。在本地测试时是可以看到的，但在 yarn cluster 模式下，看不到 print 的内容。例如：

JavaPairDStream<String, String> servicePair = messages.map(ConsumerRecord::value)
        .filter(log -> log.contains("\"logType\":\"service\""))
        .mapToPair(log -> {
            try {
                // 下面的输出，不会输出到 driver 的 stdout log 中，会输出到 Exectutor Log 中。
                System.out.println("service log:" + log);
                String key = ...省略...;
                return new Tuple2<>(key, ...省略...);
            } catch (Exception e) {
                e.printStackTrace();
                return new Tuple2<>("", "");
            }
        });

原因应该是，yarn cluster 收集的 stdout log 是 driver 的输出，不是 Executor 的输出。transform 中的 print 输出，输出到了 Exectutor log 中。想看 Executor log 的话，可以从 spark 的 WebUI 中看到。进入 WebUI 后，选择上面菜单栏中的Executors，然后可以看到 Executors 列表。在列表中，最后一列是 log 列，可以选择看 stdout 或 stderr log。

这篇文章 Spark losing println() on stdout 是 print 看不到相关的一篇文章，点赞最多的回答可能不是正确的，但每个回答下面的评论非常好，可以看看。

12，关于 Spark Streaming 中 LocationStrategies 的设置

  • LocationStrategies.PreferBrokers()：仅仅在你 spark 的 executor 在相同的节点上，优先分配到存在 kafka broker 的机器上；
  • LocationStrategies.PreferConsistent()：大多数情况下使用，一致性的方式分配分区所有 executor 上。（主要是为了分布均匀）
  • LocationStrategies.PreferFixed()：如果你的负载不均衡，可以通过这两种方式来手动指定分配方式，其他没有在 map 中指定的，均采用 preferConsistent() 的方式分配；

13，什么样的类需要声明 接口？

  • 在 Driver 里声明的类实例，在 Excecutor 里使用时，这个类需要声明 Serializable 接口。
  • 不需要实例化的工具类，不需要声明 Serializable 接口。
  • 每个实例都是在 Executor 上合建的类，不需要声明 Serializable 接口。

参考：

14，流式统计的几个难点

流式统计的几个难点

15，Spark Streaming 数据进行排序

使用 transform 或 transformToPair 进行排序。transform 可以把 rdd 转化成我们想要的类型，所以 transform 方法的 Function 需要返回一个 rdd。注意：这个 Function 是 spark 类包中的接口。

JavaPairDStream<Integer,String> sortedStream = swappedPair.transformToPair(
    new Function<JavaPairRDD<Integer,String>, JavaPairRDD<Integer,String>>() { 
     @Override 
     public JavaPairRDD<Integer,String> call(JavaPairRDD<Integer,String> jPairRDD) throws Exception { 
        return jPairRDD.sortByKey(false); 
        } 
});

Spark

一、Spark 与 hadoop

Hadoop有两个核心模块，分布式存储模块HDFS和分布式计算模块Mapreduce。spark本身并没有提供分布式文件系统，因此spark的分析大多依赖于Hadoop的分布式文件系统HDFS。Hadoop的Mapreduce与spark都可以进行数据计算，而相比于Mapreduce，spark的速度更快并且提供的功能更加丰富

二、Spark 名词

  • Application：Spark中的Application和Hadoop MapReduce中的概念是相似的，指的是用户编写的Spark应用程序，内含了一个Driver功能的代码和分布在集群中多个节点上运行的Executor代码

  • Driver Program：Spark中的Driver即运行上述Application的main()函数并且创建SparkContext，其中创建SparkContext的目的是为了准备Spark应用程序的运行环境。在Spark中由SparkContext负责和ClusterManager通信，进行资源的申请、任务的分配和监控等；当Executor部分运行完毕后，Driver负责将SparkContext关闭。通常用SparkContext代表Driver

  • Executor：Application运行在Worker节点上的一个进程，该进程负责运行Task，并且负责将数据存在内存或者磁盘上，每个Application都有各自独立的一批Executor。在Spark
    on Yarn模式下，其进程名称为CoarseGrainedExecutorBackend，类似于Hadoop MapReduce中的YarnChild。一个CoarseGrainedExecutorBackend进程有且仅有一个executor对象，它负责将Task包装成taskRunner，并从线程池中抽取出一个空闲线程运行Task。每个CoarseGrainedExecutorBackend 能并行运行Task的数量就取决于分配给它的CPU的个数了

  • Cluster Mananger：指的是在集群上获取资源的外部服务，目前有：

    • Standalone：Spark原生的资源管理，由Master负责资源的分配；
    • Hadoop Yarn：由YARN中的ResourceManager负责资源的分配；

  • Worker：集群中任何可以运行Application代码的节点，类似于YARN中的NodeManager节点。在Standalone模式中指的就是通过Slave文件配置的Worker节点，在Spark
    on Yarn模式中指的就是NodeManager节点

  • Job：包含多个Task组成的并行计算，往往由Spark Action催生，一个JOB包含多个RDD及作用于相应RDD上的各种Operation

  • Stage：每个Job会被拆分很多组Task，每组任务被称为Stage，也可称TaskSet，一个作业分为多个阶段

  • Task：被送到某个Executor上的工作任务

三、Spark 架构

spark 架构都是 Driver 通过 Cluster Manager 申请资源（Executor），然后 Driver 直接和 Executor 进行通信，Driver 分配 Task 给 Exectuor 去执行。

例如，下图就是前面说明的流程。SparkContext 就是 Driver，Driver 先去资源管理器（也就是 Cluster Manager）申请资源。Cluster Manager 分配它所管理的资源。然后资源直接和 Driver 进行通信，向 Driver 注册并申请 Task 进行执行。

在这里插入图片描述


Cluster Manager 的主要作用就是分配资源，分配完资源后，资源就直接和 Driver 进行工作。这种架构的好处是，Cluster Manager 是可以替换的，可以使用 Spark 自带的 Cluster Manager、Yarn、Mesos 等 Cluster Manager。下图就是架构的概括图，根据不同的 Cluster，各个部分的名称也不一样，稍后介绍每个 Cluster 。

在这里插入图片描述
这种架构的特点是：

  • 每个Application获取专属的executor进程，该进程在Application期间一直驻留，并以多线程方式运行Task。这种Application隔离机制是有优势的，无论是从调度角度看（每个Driver调度他自己的任务），还是从运行角度看（来自不同Application的Task运行在不同JVM中），当然这样意味着Spark Application不能跨应用程序共享数据，除非将数据写入外部存储系统。
  • Spark与资源管理器无关，只要能够获取executor进程，并能保持相互通信就可以了
    提交SparkContext的Client应该靠近Worker节点（运行Executor的节点），最好是在同一个Rack里，因为Spark Application运行过程中SparkContext和Executor之间有大量的信息交换。
  • Task采用了数据本地性和推测执行的优化机制

1，Spark standalone

Standalone模式使用Spark自带的资源调度框架，采用Master/Slaves的典型架构，选用ZooKeeper来实现Master的HA。框架结构图如下:
在这里插入图片描述

独立集群管理器支持两种部署模式。在这两种模式中，应用的驱动器程序运行在不 同的地方。

  • 在客户端模式中(默认情况)，驱动器程序会运行在你执行 spark-submit 的机 器上，是 spark-submit 命令的一部分。这意味着你可以直接看到驱动器程序的输出，也 可以直接输入数据进去(通过交互式 shell)，但是这要求你提交应用的机器与工作节点间有很快的网络速度，并且在程序运行的过程中始终可用。
  • 在集群模式下，驱动器程序会作为某个工作节点上一个独立的进程运行在独立集群管理器内部。它也会连接主节点来申请执行器节点。在这种模式下，spark-submit 是“一劳永逸”型，你可以在应用运行时关掉你的电脑。

你还可以通过集群管理器的网页用户界面访问应用的日志。向 spark- submit 传递 --deploy-mode cluster 参数可以切换到集群模式。

这种架构的具体的执行流程如下：
在这里插入图片描述

  1. SparkContext连接到Master，向Master注册并申请资源（CPU Core 和Memory）
  2. Master根据SparkContext的资源申请要求和Worker心跳周期内报告的信息决定在哪个Worker上分配资源，然后在该Worker上获取资源，然后启动StandaloneExecutorBackend；
  3. StandaloneExecutorBackend向SparkContext注册；
  4. SparkContext将Applicaiton代码发送给StandaloneExecutorBackend；并且SparkContext解析Applicaiton代码，构建DAG图，并提交给DAG Scheduler分解成Stage（当碰到Action操作时，就会催生Job；每个Job中含有1个或多个Stage，Stage一般在获取外部数据和shuffle之前产生），然后以Stage（或者称为TaskSet）提交给Task Scheduler，Task Scheduler负责将Task分配到相应的Worker，最后提交给StandaloneExecutorBackend执行；
  5. StandaloneExecutorBackend会建立Executor线程池，开始执行Task，并向SparkContext报告，直至Task完成
  6. 所有Task完成后，SparkContext向Master注销，释放资源

Spark on Yarn

Spark on YARN模式根据Driver在集群中的位置分为两种模式：一种是YARN-Client模式，另一种是YARN-Cluster（或称为YARN-Standalone模式）。Yarn-Client模式中，Driver在客户端本地运行，这种模式可以使得Spark Application和客户端进行交互，因为Driver在客户端，所以可以通过webUI访问Driver的状态，默认是http://hadoop1:4040访问，而YARN通过http:// hadoop1:8088访问。

YARN-client

在这里插入图片描述

  1. Spark Yarn Client向YARN的ResourceManager申请启动Application Master。同时在SparkContent初始化中将创建DAGScheduler和TASKScheduler等，由于我们选择的是Yarn-Client模式，程序会选择YarnClientClusterScheduler和YarnClientSchedulerBackend
  2. ResourceManager收到请求后，在集群中选择一个NodeManager，为该应用程序分配第一个Container，要求它在这个Container中启动应用程序的ApplicationMaster，与YARN-Cluster区别的是在该ApplicationMaster不运行SparkContext，只与SparkContext进行联系进行资源的分派
  3. Client中的SparkContext初始化完毕后，与ApplicationMaster建立通讯，向ResourceManager注册，根据任务信息向ResourceManager申请资源（Container）
    一旦ApplicationMaster申请到资源（也就是Container）后，便与对应的NodeManager通信，要求它在获得的Container中启动CoarseGrainedExecutorBackend，CoarseGrainedExecutorBackend启动后会向Client中的SparkContext注册并申请Task
  4. client中的SparkContext分配Task给CoarseGrainedExecutorBackend执行，CoarseGrainedExecutorBackend运行Task并向Driver汇报运行的状态和进度，以让Client随时掌握各个任务的运行状态，从而可以在任务失败时重新启动任务
  5. 应用程序运行完成后，Client的SparkContext向ResourceManager申请注销并关闭自己
YARN-Cluster

在YARN-Cluster模式中，当用户向YARN中提交一个应用程序后，YARN将分两个阶段运行该应用程序：

  • 第一个阶段是把Spark的Driver作为一个ApplicationMaster在YARN集群中先启动；
  • 第二个阶段是由ApplicationMaster创建应用程序，然后为它向ResourceManager申请资源，并启动Executor来运行Task，同时监控它的整个运行过程，直到运行完成

在这里插入图片描述

  1. Spark Yarn Client向YARN中提交应用程序，包括ApplicationMaster程序、启动ApplicationMaster的命令、需要在Executor中运行的程序等。
  2. ResourceManager收到请求后，在集群中选择一个NodeManager，为该应用程序分配第一个Container，要求它在这个Container中启动应用程序的ApplicationMaster，其中ApplicationMaster进行SparkContext等的初始化。
  3. ApplicationMaster向ResourceManager注册，这样用户可以直接通过ResourceManage查看应用程序的运行状态，然后它将采用轮询的方式通过RPC协议为各个任务申请资源，并监控它们的运行状态直到运行结束。
  4. 一旦ApplicationMaster申请到资源（也就是Container）后，便与对应的NodeManager通信，要求它在获得的Container中启动CoarseGrainedExecutorBackend，CoarseGrainedExecutorBackend启动后会向ApplicationMaster中的SparkContext注册并申请Task。这一点和Standalone模式一样，只不过SparkContext在Spark Application中初始化时，使用CoarseGrainedSchedulerBackend配合YarnClusterScheduler进行任务的调度，其中YarnClusterScheduler只是对TaskSchedulerImpl的一个简单包装，增加了对Executor的等待逻辑等
  5. ApplicationMaster中的SparkContext分配Task给CoarseGrainedExecutorBackend执行，CoarseGrainedExecutorBackend运行Task并向ApplicationMaster汇报运行的状态和进度，以让ApplicationMaster随时掌握各个任务的运行状态，从而可以在任务失败时重新启动任务。
  6. 应用程序运行完成后，ApplicationMaster向ResourceManager申请注销并关闭自己。
Yarn Client 和 Yarn Cluster 区别

理解YARN-Client和YARN-Cluster深层次的区别之前先清楚一个概念：Application Master。在YARN中，每个Application实例都有一个ApplicationMaster进程，它是Application启动的第一个容器。它负责和ResourceManager打交道并请求资源，获取资源之后告诉NodeManager为其启动Container。从深层次的含义讲YARN-Cluster和YARN-Client模式的区别其实就是ApplicationMaster进程的区别。

  • YARN-Cluster模式下，Driver运行在AM(Application Master)中，它负责向YARN申请资源，并监督作业的运行状况。当用户提交了作业之后，就可以关掉Client，作业会继续在YARN上运行，因而YARN-Cluster模式不适合运行交互类型的作业。
  • YARN-Client模式下，Application Master仅仅向YARN请求Executor，Client会和请求的Container通信来调度他们工作，也就是说Client不能离开。

Spark Standalone 和 Spark on Yarn 区别

相同点：

  • Client 模式下，Driver 在启动命令的本机上。
  • Cluster 模式下，Driver 是在 Cluster Manager 管理的结点上（Spark 的 Worker 或 Yarn 的 Node Manager）。

不同点：

  • Cluster Manager 和 资源结点：
    • Spark Standalone 架构上，Cluster Manager 叫做 Master，资源结点叫做Worker。
    • Spark on Yarn 架构上，Cluster Manager 叫做 Resource Manager，资源结点叫做NodeManager。

参考：
Spark(一): 基本架构及原理：这个最全，把 spark 架构、standalone、spark on yarn 架构结构都说了。
Spark的运行架构分析（一）之架构概述：第一篇文章拿出来一部分，加上自己的理解和讲解。
深入理解spark之架构与原理：第一篇文章拿出来一部分，加上自己的理解和讲解。

hotdust
关注
  • 0
    点赞
  • 踩
  • 11
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Spark总结
学习笔记
07-20 613
1. Spark 转为大规模数据处理设计的快速通用的计算引擎 基于内存,开源,并行计算 消除了mapreduce大量IO操作和仅支持批处理的缺陷 通过RDD弹性分布式数据集,提供交互式查询功能 基于scala面向函数语言编写,便于操作RDD 可通过YARN管理分配资源,利用HDFS存储数据 使用DAG有向无环图执行引擎,内存/磁盘计算速度均比MR快 支持java,python,scala,R和...
Spark知识点总结
wintershii的博客
02-29 654
Spark知识点总结 1.Spark基本架构 Cluster Manager : Spark的集群管理器, 主要负责对整个集群资源的分配与管理. Cluster Manager分配的资源属于一级资源, 它将各个Worker上的内存, CPU分配给Application, 但不负责对Executor的资源分配. 在standalone模式下即为Master主节点, 控制整个集群, 监控Worke...
hadoop的dfs.replication
weixin_34302798的博客
04-18 775
首先 dfs.replication这个参数是个client参数，即node level参数。需要在每台datanode上设置。其实默认为3个副本已经够用了，设置太多也没什么用。 一个文件，上传到hdfs上时指定的是几个副本就是几个。以后你修改了副本数，对已经上传了的文件也不会起作用。可以再上传文件的同时指定创建的副本数hadoop dfs -D dfs.replication=1 -put 7...
Spark输出自定义文件目录踩坑(Java)
wanghao112956的博客
09-20 1735
最近项目中，使用Spark做离线计算，结果需要输出一份结果到文件中保存，并且需要按Key来放置不同的目录。因为spark通过saveAsTextFile()方法默认输出是以part-0000的形式。 （想自学习编程的小伙伴请搜索圈T社区，更多行业相关资讯更有行业相关免费视频教程。完全免费哦!） 解决方法 通过搜索，很轻易的就能搜索到使用saveAsHadoopFile()方法可以将文件输出到自定义...
spark总结
最新发布
2302_81169928的博客
05-16 775
Spark是基于内存计算的通用大规模数据处理框架。Spark已经融入了Hadoop生态系统，可支持的作业类型和应用场景比MapReduce 更为广泛，并且具备了MapReduce所有的高容错性和高伸缩性特点。Spark支持离线批处理、流式计算和实时分析。Spark SQL是Spark用来处理结构化数据的一个模块，它提供了一个编程抽象结构叫做DataFrame的数据模型（即带有Schema信息的RDD），Spark SQL作为分布式SQL查询引擎，让用户可以通过。
Hive导出数据时输出_SUCCESS文件解决方案
热门推荐
u013332124的专栏
07-02 1万+
文章目录一、_SUCCESS的作用和实现1、 输出 _SUCCESS 文件的代码实现二、Hive任务导出数据时没生成_SUCCESS的原因三、解决方案1、自己实现一个OutputCommitter替代NullOutputCommitter(不建议)2、改写FileSinkOperator(不建议)3、改写MoveTask 一、_SUCCESS的作用和实现 我们在跑完mr或者spark程序时，会发现...
spark参数调优
xufwind的博客
06-23 570
引子 开发大数据的程序时间一长，就会发现和以前开发其它程序的方式有很大的不同。 除了要将更多的关注点放在数据上之外，一个很重要的事情是，你开发的程序在测试库运行的好好的， 到线上数据量大之后，程序执行就可能会出各种问题，有时狂加资源程序也不能很好的执行。 这其中就会涉及到一些spark程序调优方面的内容，网上一翻，会出现一大堆这种方面的东西， 有些还是很有用的，能解决工作中的实际问题。这里就将工作中碰到的调优问题和解决方案做分享 执行参数调优 spark的每一个参数格式及对参数的解释和默认值都能在官网上
限制Spark往HDFS写出数据时，生成_SUCCESS文件
qq_45124566的博客
10-28 2168
限制Spark/SparkSQL往HDFS写出数据时，生成_SUCCESS文件
spark资料笔记代码
03-28
尚硅谷的Spark资料笔记代码提供了一个深入学习和理解Spark的宝贵资源库，涵盖理论知识、实践案例以及代码示例。 一、Spark核心概念 Spark的核心在于其弹性分布式数据集（Resilient Distributed Datasets，简称RDD）...
spark 相关文档资料
12-10
总结，这个压缩包提供的资料覆盖了Spark的全面学习路径，从基础知识到高级应用，再到性能优化，对于想成为Spark开发者的读者来说是一份宝贵的资源。通过深入学习和实践，你可以掌握使用Spark处理大规模数据的技能，...
spark面试资料
10-16
### Spark面试资料详解 #### 一、Spark中的RDD概念与特性 **定义**: RDD (Resilient Distributed Dataset)，即弹性分布式数据集，是Spark的核心数据结构。它是一种只读的、可分区的数据集合，能够有效地支持并行...
spark全套学习资料.zip
06-30
笔记可能是个人学习Spark过程中的总结，包含了对某些主题的独特见解和实践心得。 通过这一系列的学习资料，读者可以逐步建立起对Spark的全面认知，从基础到高级，从理论到实践，逐步提升大数据处理的能力。无论是...
大数据spark实验报告
05-12
**大数据Spark实验报告** 在大数据领域，Spark作为一个高效、易用且可扩展的分布式计算框架，扮演着至关重要的角色。本实验报告旨在深入探讨...同时，实验报告提供了丰富的参考资料和文档，方便进一步学习和研究。
pyspark config设置、增加配置、限制_success文件生成；spark-submit 集群提交参数
weixin_42357472的博客
11-18 3413
1、pyspark增加config设置 java heap错误增加内存 2、spark-submit 参数 参考：https://www.cnblogs.com/weiweifeng/p/8073553.html nohup spark-submit --class com.tcl.video.search.recommend.SparkQueryApplication --executor-memory 6G --num-executors 6 --master yar
Spark自定义输出文件
m0_64640191的博客
03-23 780
本文将通过源码出发讲述spark如何调用hadoop几种OutputFormat,从而实现的文件输出，这里将讲述几种工作中常使用的算子，例如：saveAsTextFile(path) 、saveAsHadoopFile(path) saveAsTextFile(path)底层调用也是saveAsHadoopFile(path)，所以这里主要是讲述后者的源码；这一步也将带你认识到可以自定义的内容； 2.PairRDDFunctions 这里指定了OutputForm
Spark - 创建 _SUCCESS 文件与获取最新可用文件
BITDDD小栈
05-16 1056
Spark 为文件、文件夹生成 _SUCCESS 标识并获取最新可用文件。
spark编程中设置hadoop的属性
wk022的专栏
04-08 3532
当使用spark进行编程时，如果使用yarn-client方式提交，可以通过以下方式设置hadoop的属性 val conf = new SparkConf() conf.set("spark.hadoop.yarn.resourcemanager.address", "test01:8050") 源码分析： 当spark任务提交时采用yarn模式，程序会启动YarnClientSc
第九十四篇 Spark+HDFS centos7环境搭建
爱跳水的温文尔雅的laughing
01-18 2673
一、安装包下载： Spark 官网下载: https://spark.apache.org/downloads.html Hadoop 官网下载: https://hadoop.apache.org/releases.html 目前使用Spark 版本为: spark-2.4.3 Hadoop版本为: hadoop-2.10.1 二、配置自登陆 检测是否可以自登陆，不需要密码则配置正常: ssh localhost 在搭建Hadoop环境时，出现localhost.localdomain: Permis
Hadoop上部署Spark集群
m0_53317797的博客
10-08 1379
spark的装载，集群部署
SparkMLlib入门：机器学习与SparkMLlib详解
SparkMLlib是Apache Spark中的一个强大模块，专注于...总结来说，SparkMLlib是数据科学家和工程师必备的工具，它使得在Spark平台上进行高效机器学习成为可能，无论是基本的算法实现还是大规模数据分析，都能从中受益。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值