Spark安装与基本使用

最新推荐文章于 2023-09-24 23:05:03 发布
最新推荐文章于 2023-09-24 23:05:03 发布
阅读量587 收藏
点赞数
文章标签： java ui 数据库
原文链接：https://my.oschina.net/u/2474629/blog/3068298
版权

简介

Spark是专为大规模数据处理而设计的快速通用的计算引擎，第一次看到这句话估计会比较抽象。其实可以和MySQL数据库类比。

只不过侧重点不同，MySQL的侧重点在数据存储和查询，Spark的侧重点在于数据处理。MySQL处理的是预定义格式的数据，Spark处理的是没有预定义格式的数据，包括各种日志文件、用户行为之类的数据量比较大的文件数据分析处理。

例如，从大量用户行为日志中分析用户可能对哪些商品有兴趣，这个可以根据用户在页面驻留的时间，进入的次数等分析。

这种随时都在收集的，日志量非常的大的数据显然不适合直接存储在MySQL之类的关系数据库中，一般都是直接写日志。

那么分析这类日志Spark就非常合适了。

Spark下载与安装

scala下载

scala下载

scala下载列表

spark下载

spark下载

下载之后解压就可以了

spark目录

单机基本不需要额外的配置，可以直接运行spark-shell

spark-UI

spark UI界面

集群

拷贝conf目录下的spark-env.sh.template并且重命名为spark-env.sh，添加配置如下：

export JAVA_HOME=/usr/local/java/jdk873
export HADOOP_CONF_DIR=/usr/local/hadoop/hadoop-3.0.2/etc/hadoop
export SPARK_MASTER_HOST=192.168.9.6
# 提交Application的端口
export SPARK_MASTER_PORT=7077
# 每一个Worker最多可以使用的cpu
export SPARK_WORKER_CORES=1
# 每一个Worker最多可以使用的内存
export SPARK_WORKER_MEMORY=1g

export HADOOP_CONF_DIR=/usr/hadoop/xxx

不是必须的，但是如果要使用yarn方式提交就必须配置，就是使用下面的命令提交：

spark-submit 
  --class org.curitis.Start 
  --master yarn 
  --deploy-mode cluster
  start.jar

Spark提交方式后面详细介绍。

如果要使用ZK，使用下面的配置代替SPARK_MASTER_PORT=7077

export SPARK_DAEMON_JAVA_OPTS="-Dspark.deploy.recoveryMode=ZOOKEEPER -Dspark.deploy.zookeeper.url=192.168.9.7,192.168.9.8,192.168.9.9 -Dspark.deploy.zookeeper.dir=/zk"

url是zk部署的地址。

拷贝slaves.template并且重命名为slaves，添加其他节点：

192.168.9.7
192.168.9.8
192.168.9.9

在主节点运行：

start-all.sh

sparkUI:http://192.168.9.6:4040 提交Application的端口:http://192.168.9.6:7077

RDD

Spark是一个独立的计算引擎，不依赖hadoop，所以可以直接解压spark就可以使用了。Spark的核心是RDD(Resilient Distributed Dataset，弹性分布式数据集)，处理数据集合。可以使用hdfs做为数据源，也可以使用HBase、Hive甚至文件做为数据源。

这里先简单的介绍一下RDD创建，可以使用下面的命令打开一个spark shell交互窗口：

spark-shell

从集合中创建RDD

主要使用parallelize和makeRDD函数

sc.parallelize(List(1,2,3))
sc.makeRDD(List(1,2,3))
sc.parallelize(Array(1 to 10))

从外部存储创建RDD

sc.textFile("hdfs://127.0.0.1:9000/tmp/in.txt")
sc.textFile("file://G:/tmp/in2.txt")

Java API

import org.apache.spark.SparkConf;
import org.apache.spark.api.java.JavaRDD;
import org.apache.spark.api.java.JavaSparkContext;
import org.apache.spark.sql.SparkSession;

import java.util.Arrays;
import java.util.List;
import java.util.Scanner;

/**
 * http://spark.apache.org/docs/latest/submitting-applications.html
 */
public class SparkStart {

    public static void main(String[] args) {
        SparkConf sparkConf = new SparkConf();
        sparkConf.setAppName("create JavaSparkContext");
        sparkConf.setMaster("local[*]");
        //spark ui http://localhost:4040/jobs/
        JavaSparkContext sc = new JavaSparkContext(sparkConf);
        List<Integer> data = Arrays.asList(1, 2, 3, 4, 5);
        JavaRDD<Integer> distData = sc.parallelize(data);
        Integer sum = distData.reduce((a, b) -> a + b);
        System.out.println(sum);
        Scanner scanner = new Scanner(System.in);
        scanner.nextLine();
    }

    private static JavaSparkContext createSparkContext(){
        SparkConf sparkConf = new SparkConf();
        sparkConf.setAppName("create JavaSparkContext");
        sparkConf.setMaster("local[*]");
        sparkConf.set("spark.yarn.tags","");//逗号分隔的字符串，传递YARN应用tags。其值将出现在YARN Application Reports中，可以用来过滤和查询YARN应用。
        sparkConf.set("spark.yarn.maxAppAttempts","");//提交应用最大尝试次数。不应大于YARN全局配置的最大尝试次数。 (yarn.resourcemanager.am.max-attempts in YARN)
        sparkConf.set("spark.yarn.user.classpath.first","");//是否将用户jars放在Spark类路径之前
        sparkConf.set("spark.yarn.config.gatewayPath","");//与spark.yarn.config.replacementPath配合使用
        sparkConf.set("spark.yarn.config.replacementPath","");//某些路径，可能在网关主机上能正常访问，而在其他节点上的访问方式可能不同。对于这样的路径，需要本属性配合 spark.yarn.config.replacementPath组合使用，对于支持异构配置的集群，必须配置好这两个值，Spark才能正确地启动远程进程。replacement path 通常包含一些YARN导出的环境变量（因此，对Spark containers可见）。例如，如果网关节点上Hadoop库安装在 /disk1/hadoop，并且其导出环境变量为 HADOOP_HOME，就需要将 spark.yarn.config.gatewayPath 设置为 /disk1/hadoop 并将 replacement path设为 $HADOOP_HOME，这样才能在远程节点上以正确的环境变量启动进程。
        sparkConf.set("spark.yarn.queue","");//yarn上使用的队列名，默认为default
        sparkConf.set("spark.yarn.historyServer.address","");//Spark history server地址，如：host.com:18080 。这个地址不要包含协议头（http://）。默认不设置，因为history server是可选的。应用程序结束以后，YARN资源管理器web UI通过这个地址链接到Spark history server UI。对于这属性，可以使用YARN属性变量，且这些变量是Spark在运行时组装的。例如，如果Spark history server和YARN资源管理器（ResourceManager）部署在同一台机器上运行，那么这个属性可以设置为 ${hadoopconf-yarn.resourcemanager.hostname}:18080
        sparkConf.set("spark.yarn.archive","");//包含带有Spark类的jar文件的归档文件的位置
        sparkConf.set("spark.yarn.jars","");//Spark jar文件位置，如果需要覆盖默认位置，请设定这个值。默认的，Spark on YARN会使用本地的Spark jar包，但Spark jar包同样可以使用整个集群可读的HDFS文件位置。这使YARN可以在各节点上缓存Spark jar包，而不需要每次运行一个应用的时候都要分发。使用 hdfs:///some/path 来指定HDFS上jar包文件路径。
        sparkConf.set("spark.yarn.dist.archives","");//逗号分隔的文档列表，其指向的文档将被提取到每个执行器的工作目录下，默认无
        sparkConf.set("spark.yarn.dist.files","");//逗号分隔的文件列表，其指向的文件将被复制到每个执行器的工作目录下，默认无
        sparkConf.set("spark.yarn.dist.jars","");//
        sparkConf.set("spark.yarn.preserve.staging.files","");//是否保存HDFS中由于job产生的临时文件，默认为 false 。如果设置为true，那么在作业运行完之后，会避免工程jar等文件被删除掉
        sparkConf.set("spark.yarn.submit.file.replication","");//由spark提交到HDFS的文件的副本数，比如工程jar，依赖jar，配置文件等，默认 1
        sparkConf.set("spark.yarn.stagingDir","");//提交应用时，staging的目录
        sparkConf.set("spark.yarn.submit.waitAppCompletion","");//cluster mode下，client是否等到作业运行完再退出，默认为true
        sparkConf.set("spark.yarn.report.interval","");//cluster mode下，当前app状态报告的间隔,默认1s
        sparkConf.set("spark.yarn.am.waitTime","");//cluster模式下，Application Master要等待SparkContext初始化的时长; client模式下，application master等待driver来连接它的时长，默认 100s
        sparkConf.set("spark.yarn.am.nodeLabelExpression","");//一个YARN节点标签表达式（node label expression），以此来限制AM可以被调度到哪些节点上执行。只有Hadoop 2.6+才能支持节点标签表达式，所以如果用其他版本运行，这个属性将被忽略。
        sparkConf.set("spark.yarn.containerLauncherMaxThreads","");//application master能用来启动executor container的最大线程数量 ，默认25
        sparkConf.set("spark.yarn.max.executor.failures","");//整个作业判定为失败之前，executor最大的失败次数 ，默认 executor数量*2，最小3
        sparkConf.set("spark.yarn.scheduler.reporterThread.maxFailures","");//
        sparkConf.set("spark.yarn.scheduler.heartbeat.interval-ms","");//application master向resourcemanager发送心跳的间隔，单位ms ，默认3000ms
        sparkConf.set("spark.yarn.scheduler.initial-allocation.interval","");//Spark AM的初始带外心跳间隔（有待定的资源申请时）。其值不应该大于 spark.yarn.scheduler.heartbeat.interval-ms。该资源分配间隔会在每次带外心跳成功后但仍有待定资源申请时倍增，直至达到 spark.yarn.scheduler.heartbeat.interval-ms 所设定的值，默认为 200ms
        sparkConf.set("spark.yarn.services","");//要添加到调度程序中的服务的类名的逗号分隔列表
        sparkConf.set("spark.yarn.am.cores","");//Application Master使用的cpu数量，默认 1
        sparkConf.set("spark.yarn.am.extraJavaOptions","");//client-mode下AM的JVM参数
        sparkConf.set("spark.yarn.am.extraLibraryPath","");//client-mode下AM的额外库路径
        sparkConf.set("spark.yarn.am.memoryOverhead","");//每个am的堆外内存大小，用来存放诸如常量字符串等东西,默认为AM内存的7%
        sparkConf.set("spark.yarn.am.memory","");//YARN Application Master使用的内存总量,默认512MB
        sparkConf.set("spark.driver.cores","");//cluster模式下，driver使用的cpu core数量，driver与Application Master运行在一个进程中，所以也控制了Application Master的cpu数量,默认 为1
        sparkConf.set("spark.yarn.driver.memoryOverhead","");//每个driver的堆外内存大小，用来存放诸如常量字符串等东西,默认为driver内存 * 0.10或者 384MB中较大者
        sparkConf.set("spark.executor.cores","");//
        sparkConf.set("spark.yarn.executor.memoryOverhead","");//每个executor的堆外内存大小，用来存放诸如常量字符串等东西,默认为executor内存 * 0.10或者 384MB中较大者
        sparkConf.set("spark.yarn.executor.nodeLabelExpression","");//一个YARN节点标签表达式（node label expression），以此来限制执行器可以被调度到哪些节点上启动。只有Hadoop 2.6+才能支持节点标签表达式，所以如果在其他版本上运行时，这个属性将被忽略
        sparkConf.set("spark.executor.instances","");//执行器个数。注意，这个属性和 spark.dynamicAllocation.enabled是不兼容的。如果同时设置了 spark.dynamicAllocation.enabled，那么动态分配将被关闭，并使用 spark.executor.instances 所设置的值。 默认2
        sparkConf.set("spark.yarn.credentials.file.retention.count","");//
        sparkConf.set("spark.yarn.credentials.file.retention.days","");//
        sparkConf.set("spark.yarn.credentials.file.retention.days","");//
        sparkConf.set("spark.yarn.access.namenodes","");//spark作业能访问的hdfs namenode地址
        sparkConf.set("spark.yarn.credentials.file","");//
        sparkConf.set("spark.yarn.user.jar","");//内部配置，将用户jar的位置传播到驱动程序/执行程序
        sparkConf.set("spark.yarn.secondary.jars","");//内部配置，以传播任何额外jar的位置，以添加到执行器的类路径中
        sparkConf.set("spark.yarn.cache.filenames","");//
        sparkConf.set("spark.yarn.cache.sizes","");//
        sparkConf.set("spark.yarn.cache.timestamps","");//
        sparkConf.set("spark.yarn.cache.visibilities","");//
        sparkConf.set("spark.yarn.cache.types","");//
        sparkConf.set("spark.yarn.cache.confArchive","");//conf archive在HDFS中的路径
        JavaSparkContext sc = new JavaSparkContext(sparkConf);
        return sc;
    }

//spark sql
    private static SparkSession createSparkSession(){
        SparkSession sparkSession = SparkSession
                .builder()
                .appName("create SparkSession")
                .master("local[*]")
                .config("spark.yarn.tags", "")//逗号分隔的字符串，传递YARN应用tags。其值将出现在YARN Application Reports中，可以用来过滤和查询YARN 应用。
                .config("spark.yarn.maxAppAttempts", "")//提交应用最大尝试次数。不应大于YARN全局配置的最大尝试次数。 (yarn.resourcemanager.am.max-attempts in YARN)
                .config("spark.yarn.user.classpath.first", "")//是否将用户jars放在Spark类路径之前
                .config("spark.yarn.config.gatewayPath", "")//与spark.yarn.config.replacementPath配合使用
                .config("spark.yarn.config.replacementPath", "")//某些路径，可能在网关主机上能正常访问（Spark应用启动的地方），而在其他节点上的访问方式（路径）可能不同。对于这样的路径，需要本属性配合 spark.yarn.config.replacementPath组合使用，对于支持异构配置的集群，必须配置好这两个值，Spark才能正确地启动远程进程。replacement path 通常包含一些YARN导出的环境变量（因此，对Spark containers可见）。例如，如果网关节点上Hadoop库安装在 /disk1/hadoop，并且其导出环境变量为 HADOOP_HOME，就需要将 spark.yarn.config.gatewayPath 设置为 /disk1/hadoop 并将 replacement path设为 $HADOOP_HOME，这样才能在远程节点上以正确的环境变量启动进程。
                .config("spark.yarn.queue", "")//yarn上使用的队列名，默认为default
                .config("spark.yarn.historyServer.address", "")//Spark history server地址，如：host.com:18080 。这个地址不要包含协议头（http://）。默认不设置，因为history server是可选的。应用程序结束以后，YARN资源管理器web UI通过这个地址链接到Spark history server UI。对于这属性，可以使用YARN属性变量，且这些变量是Spark在运行时组装的。例如，如果Spark history server和YARN资源管理器（ResourceManager）部署在同一台机器上运行，那么这个属性可以设置为 ${hadoopconf-yarn.resourcemanager.hostname}:18080
                .config("spark.yarn.archive", "")//包含带有Spark类的jar文件的归档文件的位置
                .config("spark.yarn.jars", "")//Spark jar文件位置，如果需要覆盖默认位置，请设定这个值。默认的，Spark on YARN会使用本地的Spark jar包，但Spark jar包同样可以使用整个集群可读的HDFS文件位置。这使YARN可以在各节点上缓存Spark jar包，而不需要每次运行一个应用的时候都要分发。使用 hdfs:///some/path 来指定HDFS上jar包文件路径。
                .config("spark.yarn.dist.archives", "")//逗号分隔的文档列表，其指向的文档将被提取到每个执行器的工作目录下，默认无
                .config("spark.yarn.dist.files", "")//逗号分隔的文件列表，其指向的文件将被复制到每个执行器的工作目录下，默认无
                .config("spark.yarn.dist.jars", "")//
                .config("spark.yarn.preserve.staging.files", "")//是否保存HDFS中由于job产生的临时文件，默认为 false 。如果设置为true，那么在作业运行完之后，会避免工程jar等文件被删除掉
                .config("spark.yarn.submit.file.replication", "")//由spark提交到HDFS的文件的副本数，比如工程jar，依赖jar，配置文件等，默认 1
                .config("spark.yarn.stagingDir", "")//提交应用时，staging的目录
                .config("spark.yarn.submit.waitAppCompletion", "")//cluster mode下，client是否等到作业运行完再退出，默认为true
                .config("spark.yarn.report.interval", "")//cluster mode下，当前app状态报告的间隔,默认1s
                .config("spark.yarn.am.waitTime", "")//cluster模式下，Application Master要等待SparkContext初始化的时长; client模式下，application master等待driver来连接它的时长，默认 100s
                .config("spark.yarn.am.nodeLabelExpression", "")//一个YARN节点标签表达式（node label expression），以此来限制AM可以被调度到哪些节点上执行。只有Hadoop 2.6+才能支持节点标签表达式，所以如果用其他版本运行，这个属性将被忽略。
                .config("spark.yarn.containerLauncherMaxThreads", "")//application master能用来启动executor container的最大线程数量 ，默认25
                .config("spark.yarn.max.executor.failures", "")//整个作业判定为失败之前，executor最大的失败次数 ，默认 executor数量*2，最小3
                .config("spark.yarn.scheduler.reporterThread.maxFailures", "")//
                .config("spark.yarn.scheduler.heartbeat.interval-ms", "")//application master向resourcemanager发送心跳的间隔，单位ms ，默认3000ms
                .config("spark.yarn.scheduler.initial-allocation.interval", "")//Spark AM的初始带外心跳间隔（有待定的资源申请时）。其值不应该大于 spark.yarn.scheduler.heartbeat.interval-ms。该资源分配间隔会在每次带外心跳成功后但仍有待定资源申请时倍增，直至达到 spark.yarn.scheduler.heartbeat.interval-ms 所设定的值，默认为 200ms
                .config("spark.yarn.services", "")//要添加到调度程序中的服务的类名的逗号分隔列表
                .config("spark.yarn.am.cores", "")//Application Master使用的cpu数量，默认 1
                .config("spark.yarn.am.extraJavaOptions", "")//client-mode下AM的JVM参数
                .config("spark.yarn.am.extraLibraryPath", "")//client-mode下AM的额外库路径
                .config("spark.yarn.am.memoryOverhead", "")//每个am的堆外内存大小，用来存放诸如常量字符串等东西,默认为AM内存的7%
                .config("spark.yarn.am.memory", "")//YARN Application Master使用的内存总量,默认512MB
                .config("spark.driver.cores", "")//cluster模式下，driver使用的cpu core数量，driver与Application Master运行在一个进程中，所以也控制了Application Master的cpu数量,默认 为1
                .config("spark.yarn.driver.memoryOverhead", "")//每个driver的堆外内存大小，用来存放诸如常量字符串等东西,默认为driver内存 * 0.10或者 384MB中较大者
                .config("spark.executor.cores", "")//
                .config("spark.yarn.executor.memoryOverhead", "")//每个executor的堆外内存大小，用来存放诸如常量字符串等东西,默认为executor内存 * 0.10或者 384MB中较大者
                .config("spark.yarn.executor.nodeLabelExpression", "")//一个YARN节点标签表达式（node label expression），以此来限制执行器可以被调度到哪些节点上启动。只有Hadoop 2.6+才能支持节点标签表达式，所以如果在其他版本上运行时，这个属性将被忽略
                .config("spark.executor.instances", "")//执行器个数。注意，这个属性和 spark.dynamicAllocation.enabled是不兼容的。如果同时设置了 spark.dynamicAllocation.enabled，那么动态分配将被关闭，并使用 spark.executor.instances 所设置的值。 默认2
                .config("spark.yarn.credentials.file.retention.count", "")//
                .config("spark.yarn.credentials.file.retention.days", "")//
                .config("spark.yarn.credentials.file.retention.days", "")//
                .config("spark.yarn.access.namenodes", "")//spark作业能访问的hdfs namenode地址
                .config("spark.yarn.credentials.file", "")//
                .config("spark.yarn.user.jar", "")//内部配置，将用户jar的位置传播到驱动程序/执行程序
                .config("spark.yarn.secondary.jars", "")//内部配置，以传播任何额外jar的位置，以添加到执行器的类路径中
                .config("spark.yarn.cache.filenames", "")//
                .config("spark.yarn.cache.sizes", "")//
                .config("spark.yarn.cache.timestamps", "")//
                .config("spark.yarn.cache.visibilities", "")//
                .config("spark.yarn.cache.types", "")//
                .config("spark.yarn.cache.confArchive", "")//conf archive在HDFS中的路径
                .getOrCreate();
        return sparkSession;
    }
}

pom

<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>org.curitis</groupId>
    <packaging>jar</packaging>
    <artifactId>spark-learn</artifactId>
    <version>1.0.0</version>

    <properties>
        <spring.test.version>5.1.8.RELEASE</spring.test.version>
        <junit.test.version>4.11</junit.test.version>
        <spark.version>2.4.3</spark.version>
    </properties>
    <dependencies>
        <dependency>
            <groupId>org.apache.spark</groupId>
            <artifactId>spark-core_2.12</artifactId>
            <version>${spark.version}</version>
        </dependency>
        <dependency>
            <groupId>org.apache.spark</groupId>
            <artifactId>spark-sql_2.12</artifactId>
            <version>${spark.version}</version>
        </dependency>

        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>1.2.56</version>
        </dependency>

        <!--test-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-test</artifactId>
            <version>${spring.test.version}</version>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>${junit.test.version}</version>
            <scope>test</scope>
        </dependency>
    </dependencies>
    <build>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <configuration>
                    <source>8</source>
                    <target>8</target>
                </configuration>
            </plugin>
        </plugins>
    </build>
</project>

Spark提交方式

Local方式

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

  1. local: 所有计算都运行在一个线程当中，没有任何并行计算，用于本机执行一些测试代码
  2. local[K]: 指定使用K个线程来运行计算，比如local[4]就是运行4个worker线程
  3. local[*]: 按照cpu数量来设置worker线程数了
  4. local[K,F]: K个工作线程，最多失败F个
spark-submit --master local[*]

cluster方式

cluster方式就是使用集群运行的方式，它又包含3中模式：

standalone模式

这种模式下，Spark会自己负责资源的管理调度。它将cluster中的机器分为master机器和worker机器，master通常就一个，管理worker的节点，worker就是负责计算任务节点

spark-submit --cluster cluster_name --master spark://host:port

--master就是指定master那台机器的地址和端口

mesos模式

使用mesos来管理资源调度，自然就应该用mesos模式了

spark-submit --cluster cluster_name --master mesos://host:port
yarn模式

yarn来管理资源调度，由于很多时候我们需要和mapreduce使用同一个集群，所以都采用Yarn来管理资源调度，这也是生产环境大多采用yarn模式的原因。yarn模式又分为yarn cluster模式和yarn client模式。

  1. yarn cluster: 这个就是生产环境常用的模式，所有的资源调度和计算都在集群环境上运行。
  2. yarn client: 这个是说Spark Driver和ApplicationMaster进程均在本机运行，而计算任务在cluster上
spark-submit --cluster cluster_name --master yarn-cluster

spark-submit --class org.curitis.Start --name 'Start' --master yarn --driver-memory 1g --executor-memory 6g --executor-cores 4 --deploy-mode cluster --jars hdfs:///user/root/spark/spark-2.4/lib/user_lib/*.jar start.jar

文档

集群模式 spark提交 spark文档 spark java spark example spark sql

RDD的常用操作

RDD的操作分为两种，一种是转化(transformation)操作，一种是执行(action)操作，类似于SQL中的聚合函数。

转化(transformation)

转化操作并不会立即执行，而是到了执行操作才会被执行转化操作。

map

参数是函数，函数应用于RDD每一个元素，返回值是新的RDD

flatMap

参数是函数，函数应用于RDD每一个元素，将元素数据进行拆分，变成迭代器，返回值是新的RDD

filter

参数是函数，函数会过滤掉不符合条件的元素，返回值是新的RDD

distinct

没有参数，将RDD里的元素进行去重操作

union

参数是RDD，生成包含两个RDD所有元素的新RDD

intersection

参数是RDD，求出两个RDD的共同元素

subtract

参数是RDD，将原RDD里和参数RDD里相同的元素去掉

cartesian

参数是RDD，求两个RDD的笛卡儿积

行动(action)

collect

返回RDD所有元素

count

RDD里元素个数

val textFile = spark.read.textFile("file:///G:/tmp/in2.txt")
textFile.count()
textFile.first()

注意使用spark.read.textFile读取本地文件是以/开头的。

会把读到的数据按行拆分放到Datasets中。

countByValue

各元素在RDD中出现次数

reduce

并行整合所有RDD数据，例如求和操作

fold

和reduce功能一样，不过fold带有初始值

aggregate

和reduce功能一样，但是返回的RDD数据类型和原RDD不一样

foreach

对RDD每个元素都是使用特定函数

转载于:https://my.oschina.net/u/2474629/blog/3068298

chinuoye3292
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
关于spark yarn模式下的常用属性
Lestat.Z.的博客
05-11 3395
前言 整理了spark官网提供的一些常用的spark属性。 Spark属性 属性名 默认值 描述 spark.yarn.am.memory 512m 在Client模式下用于YARN Application Master的内存量，格式与JVM内存字符串相同（例如512m，2g）。在Cluster模式下，请改用spark.driver.memory。使用小写后缀，例如 k，m，g，t和...
Spark-Framework:Spark精简web框架
07-02
Spark-Framework Spark精简web框架
Spark1.6.0安装与使用
04-22
详细描述了Spark1.6.0的安装过程和使用方法。严格按照教程安装基本上都能成功。与各位同仁共勉。
Spark源码解析-Yarn部署流程（ApplicationMaster）
越是学习的人，越能清醒地认识自身的局限，不断拓宽自己的路
10-13 920
Spark源码解析-Yarn部署流程（ApplicationMaster） 可微信搜索 知了小巷 ，关注公众号支持一下，谢谢。另外，公众号后台回复 资料 ，可领取大数据2020学习视频资料。 前文【Spark源码解析Yarn部署流程（SparkSubmit）】 中 createContainerLaunchContext 用来运行ApplicationMaster。 主要调用是在： yarnClient.submitApplication(appContext)。 RM：ResourceManager。
spark：spark-submit 提交任务及参数说明（yarn）
热门推荐
不花的花和尚的博客
02-02 1万+
spark-submit 可以提交任务到 spark 集群执行，也可以提交到 hadoop 的 yarn 集群执行。 1. 例子 一个最简单的例子，部署 spark standalone 模式后，提交到本地执行。 ./bin/spark-submit \ --master spark://localhost:7077 \ examples/src/main/python/pi.py 如果...
Spark 在YARN上运行
大强博客
01-31 4977
在YARN上运行Spark 安全 在YARN上启动Spark 添加其他JAR 准备工作 组态 调试您的应用程序 Spark特性 重要笔记 的Kerberos YARN特定的Kerberos配置 Kerberos故障排除 配置外部随机播放服务 使用Apache Oozie启动您的应用程序 使用Spark History Server替换Spark Web U...
Spark的安装与使用
孤独の根号三
03-22 2189
目录：一、Spark的安装1.安装环境：2.Spark的下载：3.安装步骤：3.1 配置Job History Server【Standalone】3.2 配置Spark HA【Standalone】3.3 配置Spark【Yarn】二、Spark的使用1.执行spark程序（standalone）2.执行spark程序（yarn）3.启动Spark Shell4.在IDEA中使用Spark本地调...
Spark on YARN的重要参数
qq_15300683的博客
04-24 4626
Spark属性或者去源码找Class类 SparkSubmitArguments，最全了属性名称默认含义spark.yarn.am.memory512m用于客户端模式下的YARN Application Master的内存量，格式与JVM内存字符串（例如512m，2g）相同。在集群模式下，spark.driver.memory改为使用。使用小写字母后缀，例如k，m，g，t，和p，为kibi-，me...
spark参数说明
liuwei063608的专栏
03-04 2341
应用配置 参数 默认值 说明 建议 spark.driver.maxResultSize 1g 对Spark每个action结果集大小的限制.。 spark.driver.memoryOverhead driverMemory * 0.10, with minimum of 384 为driver分配的堆外内存。支持on yarn和Kubernetes。 spark.executor.memo...
PySpark yarn优化以及使用(依赖解决、python虚拟环境使用)————附带解释和代码
韩江雪de 小屋
02-21 3074
文章目录1 spark yarn的常见模式以及区分1.1 模式1.2 使用2 yarn模式下的自编写包依赖解决2.1 准备知识2.2 使用3 yarn模式下的jar包依赖解决3.1 spark运行时需要的包3.2 非spark运行时必要的包附录 1 spark yarn的常见模式以及区分 1.1 模式 1，client 提交方式： –master yarn –deploy-mode client 特点： 1，driver运行在提交作业的机器上(可以看到程序打印日志)； 2，cluster
spark-2.2.2安装流程
05-06
RDD：Spark的基本计算单元，一组RDD可形成执行的有向无环图RDD Graph。 DAG Scheduler：实现将Spark作业分解成一到多个Stage，每个Stage根据RDD的Partition个数决定Task的个数，然后生成相应的Task set放到Task...
spark大作业.zip
11-13
1、熟悉Linux系统、MySQL、Spark、HBase、Hive、Sqoop、R、Eclipse、IntelliJ Idea等系统和软件的安装和使用； 2、了解大数据处理的基本流程； 3、熟悉数据预处理方法； 4、熟悉在不同类型数据库之间进行数据相互...
深入理解Spark 核心思想与源码分析
10-06
《深入理解SPARK：核心思想与源码分析》结合大量图和示例，对Spark的架构、部署模式和工作模块的设计理念、实现源码与使用技巧进行了深入的剖析与解读。, 《深入理解SPARK：核心思想与源码分析》一书对Spark1.2.0...
大数据Spark纯净版安装包，用于快速集成Hive on Spark
最新发布
03-26
纯净版安装包旨在提供一个轻量级、简单易用的Spark安装选项，适用于用户希望快速部署Spark并开始使用其基本功能的场景。 该安装包通常包含Spark的核心组件，如Spark Core、Spark SQL、Spark Streaming等，以及一些...
Spark提交任务到Yarn并查看任务日志
wangleigiser的博客
07-01 821
spark提交任务到yarn 查看yarn任务
Spark内核原理和Spark on yarn
qq_45749457的博客
07-05 550
spark内核原理理解和spark on yarn部署模式的原理理解
Spark的安装和使用方法
MusicDancing的博客
08-29 4874
1. 安装Spark 2. 在Spark shell中运行代码 Spark Shell本身就是一个Driver，Driver包mian()和分布式数据集。 启动Spark Shell 命令： ./bin/spark-shell --master <master-url> Spark的运行模式取决于传递给SparkContext的Master URL的值，可以有如下选择： 1. local 使用一个Worker线程来本地化运行Spark，非并行。 2. local[*] 使用
spark的安装与部署
weixin_65195823的博客
06-28 8465
为了避免MapReduce框架中多次读写磁盘带来的消耗，以及更充分地利用内存，加州大学伯克利分校的AMP Lab提出了一种新的、开源的、类Hadoop MapReduce的内存编程模型Spark。一、spark是什么？Spark是一个基于内存的大数据并行处理框架，其最初由加州大学伯克利分校的AMP Lab研发，现已成为Apache软件基金会的顶级项目之一。Spark不仅提供了可扩展、高容错、高性能的分布式数据处理，还提供了内存级的数据处理。
大数据与云计算——Spark的安装和配置
未来社会二十年发展的核心技术趋势由ABCD四个字母组成，分别是AI（人工智能）、BlockChain（区块链）、Cloud（云）、和Data（大数据）每一次进步都有新的认知和感触
09-24 1977
Apache Spark是一个基于内存的分布式计算框架，它提供了高效、强大的数据处理和分析能力。与传统的Hadoop MapReduce相比，Spark的主要优势在于其能够将数据集缓存在内存中，从而大大减少了磁盘I/O操作，提高了数据处理速度。
spark的安装与使用
05-19
Spark是一个基于Hadoop的开源计算框架，用于大规模数据处理和分析。以下是Spark的安装和使用步骤： 1. 下载Spark：访问Spark官网（https://spark.apache.org/）下载最新版本的Spark。 2. 安装Java：Spark需要Java环境。确保已经安装了Java 8或更高版本。 3. 安装Hadoop：如果要在Hadoop上运行Spark，则需要安装Hadoop。如果不需要，则可以跳过此步骤。 4. 解压Spark：将Spark文件解压缩到您选择的目录中。 5. 设置环境变量：设置SPARK_HOME和PATH环境变量，以便在任何位置轻松访问Spark。 6. 启动Spark：在终端中运行Spark Shell或Spark应用程序。例如，要启动Spark Shell，请在终端中输入以下命令： ``` $ spark-shell ``` 7. 运行Spark应用程序：编写Spark应用程序并使用以下命令运行： ``` $ spark-submit [options] <app jar> [app arguments] ``` 这些是Spark的基本安装和使用步骤。您可以在Spark官方网站上找到更多详细信息和文档。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值