TOP

Spark Configuration
2018-12-24 13:04:14 】 浏览:351
Tags:Spark Configuration

Spark Properties

Spark属性控制大多数应用程序设置,并为每个应用程序单独配置。 可以直接在传递给SparkContext的SparkConf上设置这些属性。 SparkConf允许您通过set()方法配置一些常见属性(例如主URL和应用程序名称)以及任意键值对。 例如,我们可以使用两个线程初始化应用程序,如下所示:

请注意,我们使用local [2]运行,这意味着两个线程 - 代表“最小”并行性,这可以帮助检测仅在我们在分布式上下文中运行时存在的错误。

val conf = new SparkConf()
             .setMaster("local[2]")
             .setAppName("CountingSheep")
val sc = new SparkContext(conf)

请注意,我们可以在本地模式下拥有多个线程,在像Spark Streaming这样的情况下,我们实际上可能需要多个线程来防止出现任何类型的饥饿问题。

指定某个持续时间的属性应使用时间单位进行配置。 接受以下格式:

25ms (milliseconds)
5s (seconds)
10m or 10min (minutes)
3h (hours)
5d (days)
1y (years)

指定字节大小的属性应使用单位大小进行配置。 接受以下格式:

1b (bytes)
1k or 1kb (kibibytes = 1024 bytes)
1m or 1mb (mebibytes = 1024 kibibytes)
1g or 1gb (gibibytes = 1024 mebibytes)
1t or 1tb (tebibytes = 1024 gibibytes)
1p or 1pb (pebibytes = 1024 tebibytes)

虽然没有单位的数字通常被解释为字节,但有些数字被解释为KiB或MiB。 请参阅各个配置属性的文档。 在可能的情况下,需要指定单位。

Dynamically Loading Spark Properties

在某些情况下,您可能希望避免在SparkConf中对某些配置进行硬编码。 例如,如果您想使用不同的主服务器或不同的内存量运行相同的应用程序。 Spark允许您简单地创建一个空conf:

val sc = new SparkContext(new SparkConf())

然后,您可以在运行时提供配置值:

./bin/spark-submit --name "My app" --master local[4] --conf spark.eventLog.enabled=false
  --conf "spark.executor.extraJavaOptions=-XX:+PrintGCDetails -XX:+PrintGCTimeStamps" myApp.jar

Spark shell和spark-submit工具支持两种动态加载配置的方法。 第一个是命令行选项,例如–master,如上所示。 spark-submit可以使用–conf标志接受任何Spark属性,但是对于在启动Spark应用程序中起作用的属性使用特殊标志。 运行./bin/spark-submit –help将显示这些选项的完整列表。

bin / spark-submit还将读取conf / spark-defaults.conf中的配置选项,其中每一行由一个键和一个由空格分隔的值组成。 例如:

spark.master            spark://5.6.7.8:7077
spark.executor.memory   4g
spark.eventLog.enabled  true
spark.serializer        org.apache.spark.serializer.KryoSerializer

指定为flags或属性文件中的任何值都将传递给应用程序,并与通过SparkConf指定的值合并。直接在SparkConf上设置的属性取最高优先级,然后将标志传递给spark-submit或spark-shell,然后选择spark-defaults.conf文件中的选项。自早期版本的Spark以来,已经重命名了一些配置键;在这种情况下,旧的密钥名称仍然被接受,但优先级低于任何新密钥的实例。

Spark属性主要可以分为两种:一种与部署相关,如“spark.driver.memory”,“spark.executor.instances”,在运行时通过SparkConf以编程方式设置时,这种属性可能不受影响,或者行为取决于您选择的集群管理器和部署模式,因此建议通过配置文件或spark-submit命令行选项进行设置;另一个主要与Spark运行时控件有关,比如“spark.task.maxFailures”,这种属性可以以任何一种方式设置。

Viewing Spark Properties

位于http:// :4040的应用程序Web UI在“环境”选项卡中列出了Spark属性。 这是一个检查以确保您的属性设置正确的有用位置。 请注意,仅显示通过spark-defaults.conf,SparkConf或命令行显式指定的值。 对于所有其他配置属性,您可以假设使用默认值。

可用属性

控制内部设置的大多数属性都具有合理的默认值。 一些最常见的选项是:
Application Properties

Property Name Default Meaning
spark.app.name (none) 你应用的名字,这将显示在UI和日志数据中。
spark.driver.cores 1 仅在cluster模式下用于驱动程序进程的核心数。
spark.driver.maxResultSize 1g 每个Spark操作(例如,收集)的所有分区的序列化结果的总大小限制(以字节为单位)。 应至少为1M,或0为无限制。 如果总大小超过此限制,则将中止作业。 具有高限制可能会导致驱动程序中出现内存不足错误(取决于spark.driver.memory和JVM中对象的内存开销)。 设置适当的限制可以保护驱动程序免受内存不足错误的影响
spark.driver.memory 1g 除非另有说明(例如1g,2g),否则在MiB中用于驱动程序进程的内存量,即SparkContext初始化的内存量。注意:在client端模式下,不能直接在应用程序中通过SparkConf设置此配置,因为驱动程序JVM已在此时启动。 相反,请通过–driver-memory命令行选项或默认属性文件设置此项。
spark.driver.memoryOverhead driverMemory * 0.10, with minimum of 384 除非另有说明,否则在群集模式下为每个驱动程序分配的堆外内存量(MiB)。 这是一个内存,可以解决诸如VM开销,实习字符串,其他本地开销等问题。这会随着容器大小(通常为6-10%)而增长。 YARN和Kubernetes目前支持此选项
spark.executor.memory 1g 除非另有说明,否则每个执行程序进程使用的内存量(MiB)。 (例如2g,8g)。
spark.executor.memoryOverhead executorMemory * 0.10, with minimum of 384 除非另有说明,否则每个执行程序要分配的堆外内存量(MiB)。 这是内存,可以解决诸如VM开销,实习字符串,其他本机开销等问题。这会随着执行程序大小(通常为6-10%)而增长。 YARN和Kubernetes目前支持此选项。
spark.extraListeners (none) 以逗号分隔的实现SparkListener的类列表; 在初始化SparkContext时,将创建这些类的实例并使用Spark的侦听器总线进行注册。 如果一个类有一个接受SparkConf的单参数构造函数,那么将调用该构造函数; 否则,将调用零参数构造函数。 如果找不到有效的构造函数,SparkContext创建将失败并出现异常。
spark.local.dir /tmp 用于Spark中“临时”空间的目录,包括映射输出文件和存储在磁盘上的RDD。 这应该位于系统中的快速本地磁盘上。 它也可以是不同磁盘上多个目录的逗号分隔列表。 注意:在Spark 1.0及更高版本中,这将由集群管理器设置的SPARK_LOCAL_DIRS(Standalone,Mesos)或LOCAL_DIRS(YARN)环境变量覆盖。
spark.logConf false 启动SparkContext时,将有效的SparkConf记录为INFO。
spark.master (none) 要连接的集群管理器。 请参阅允许的主URL列表。
spark.submit.deployMode (none) Spark驱动程序的部署模式,“client”或“cluster”,这意味着在集群内的其中一个节点上本地(“client”)或远程(“cluster”)启动驱动程序。
spark.log.callerContext (none) 在Yarn / HDFS上运行时将写入Yarn RM log / HDFS审核日志的应用程序信息。 它的长度取决于Hadoop配置hadoop.caller.context.max.size。 它应该简洁,通常最多可包含50个字符。
spark.driver.supervise false 如果为true,则在失败且退出状态为非零时自动重新启动驱动程序。 仅在Spark standalone 模式或Mesos集群部署模式下有效。

除此之外,还提供以下属性,在某些情况下可能有用:
Runtime Environment

Property Name Default Meaning
spark.driver.extraClassPath (none) 额外的类路径条目,前置于驱动程序的类路径。注意:在client模式下,不能直接在应用程序中通过SparkConf设置此配置,因为驱动程序JVM已在此时启动。 相反,请通过–driver-class-path命令行选项或在默认属性文件中设置它。
spark.driver.extraJavaOptions (none) 要传递给驱动程序的一串额外JVM选项。 例如,GC设置或其他日志记录。 请注意,使用此选项设置最大堆大小(-Xmx)设置是非法的。 可以在群集模式下使用spark.driver.memory并在客户端模式下通过–driver-memory命令行选项设置最大堆大小设置。注意:在客户端模式下,不能直接在应用程序中通过SparkConf设置此配置,因为驱动程序JVM已在此时启动。 相反,请通过–driver-java-options命令行选项或在默认属性文件中设置它。
spark.driver.extraLibraryPath (none) 设置启动驱动程序JVM时要使用的特殊库路径。注意:在client模式下,不能直接在应用程序中通过SparkConf设置此配置,因为驱动程序JVM已在此时启动。 相反,请通过–driver-library-path命令行选项或在默认属性文件中设置它。
spark.driver.userClassPathFirst false (实验)在驱动程序中加载类时,是否优先使用用户添加的jar优先于Spark自己的jar。 此功能可用于缓解Spark的依赖项和用户依赖项之间的冲突。 它目前是一个实验性功能。 这仅在群集模式下使用。
spark.executor.extraClassPath (none) 额外的类路径条目,前置于执行程序的类路径。 这主要是为了向后兼容旧版本的Spark。 用户通常不需要设置此选项。
spark.executor.extraJavaOptions (none) 要传递给执行程序的一串额外JVM选项。 例如,GC设置或其他日志记录。 请注意,使用此选项设置Spark属性或最大堆大小(-Xmx)设置是非法的。 应使用SparkConf对象或spark-submit脚本使用的spark-defaults.conf文件设置Spark属性。 可以使用spark.executor.memory设置最大堆大小设置。
spark.executor.extraLibraryPath (none) 设置启动执行程序JVM时要使用的特殊库路径。
spark.executor.logs.rolling.maxRetainedFiles (none) 设置将由系统保留的最新滚动日志文件的数量。 旧的日志文件将被删除。 默认情况下禁用。
spark.executor.logs.rolling.enableCompression false 启用执行程序日志压缩。 如果已启用,则将压缩已滚动的执行程序日志。 默认情况下禁用。
spark.executor.logs.rolling.maxSize (none) 设置文件的最大大小(以字节为单位),执行程序日志将通过该字节翻转。 默认情况下禁用滚动。 请参阅spark.executor.logs.rolling.maxRetainedFiles以自动清除旧日志。
spark.executor.logs.rolling.strategy (none) 设置执行程序日志的滚动策略。 默认情况下,它被禁用。 它可以设置为“时间”(基于时间的滚动)或“大小”(基于大小的滚动)。 对于“time”,使用spark.executor.logs.rolling.time.interval设置滚动间隔。 对于“size”,使用spark.executor.logs.rolling.maxSize设置滚动的最大文件大小。
spark.executor.logs.rolling.time.interval daily 设置执行程序日志将被滚动的时间间隔。 默认情况下禁用滚动。 有效值为每日,每小时,每分钟或以秒为单位的任何间隔。 请参阅spark.executor.logs.rolling.maxRetainedFiles以自动清除旧日志。
spark.executor.userClassPathFirst false (实验)与spark.driver.userClassPathFirst功能相同,但应用于执行程序实例。
spark.executorEnv.[EnvironmentVariableName] (none) 将EnvironmentVariableName指定的环境变量添加到Executor进程。 用户可以指定其中的多个来设置多个环境变量。
spark.redaction.regex (i)secret | password 正则表达式决定驱动程序和执行程序环境中的哪些Spark配置属性和环境变量包含敏感信息。 当此正则表达式与属性键或值匹配时,将从环境UI和各种日志(如YARN和事件日志)中编辑该值。
spark.python.profile false 在Python worker中启用性能分析,配置文件结果将显示为sc.show_profiles(),否则将在驱动程序退出之前显示。 它也可以通过sc.dump_profiles(path)转储到磁盘中。 如果手动显示某些配置文件结果,则在驱动程序退出之前不会自动显示它们。 默认情况下,将使用pyspark.profiler.BasicProfiler,但可以通过将探查器类作为参数传递给SparkContext构造函数来覆盖它。
spark.python.profile.dump (none) 在驱动程序退出之前用于转储配置文件结果的目录。 结果将作为每个RDD的单独文件转储。 它们可以通过ptats.Stats()加载。 如果指定了此选项,则不会自动显示配置文件结果。
spark.python.worker.memory 512m 聚合期间每个python worker进程使用的内存量,格式与具有大小单位后缀(“k”,“m”,“g”或“t”)的JVM内存字符串相同(例如512m,2g)。 如果聚合期间使用的内存超过此数量,则会将数据溢出到磁盘中
spark.python.worker.reuse true 是否重用Python工作者。 如果是,它将使用固定数量的Python工作者,不需要为每个任务fork()一个Python进程。 如果有大型广播,那将非常有用,那么就不需要广播从JVM转移到Python工作人员来完成每项任务。
spark.files Comma-separated list of files to be placed in the working directory of each executor. Globs are allowed.
spark.submit.pyFiles 以逗号分隔的.zip,.egg或.py文件列表,放在Python应用程序的PYTHONPATH上。 允许使用全球。
spark.jars 以逗号分隔的jar列表,包含在驱动程序和执行程序类路径中。 允许使用全球。
spark.jars.packages 以逗号分隔的jar的Maven坐标列表,包含在驱动程序和执行程序类路径中。 坐标应为groupId:artifactId:version。 如果给出spark.jars.ivySettings,则将根据文件中的配置解析工件,否则将在本地maven repo中搜索工件,然后在maven central中搜索,最后由命令行选项提供的任何其他远程存储库 - 库。 有关更多详细信息,请参阅高级依赖关系管理。
spark.jars.excludes 逗号分隔的groupId:artifactId列表,在解析spark.jars.packages中提供的依赖项时排除,以避免依赖性冲突。
spark.jars.ivy 指定Ivy用户目录的路径,用于来自spark.jars.packages的本地Ivy缓存和包文件。 这将覆盖Ivy属性ivy.default.ivy.user.dir,默认为/ .ivy2。
spark.jars.ivySettings 常春藤设置文件的路径,用于自定义使用spark.jars.packages指定的jar的分辨率,而不是内置的默认值,例如maven central。 还将包括命令行选项–repositories或spark.jars.repositories提供的其他存储库。 用于允许Spark从防火墙后面解析工件,例如 通过像Artifactory这样的内部工件服务器。 有关设置文件格式的详细信息,请访问http://ant.apache.org/ivy/history/latest-milestone/settings.html
spark.jars.repositories 以逗号分隔的其他远程存储库列表,用于搜索使用–packages或spark.jars.packages指定的maven坐标。
spark.pyspark.driver.python Python二进制可执行文件,用于驱动程序中的PySpark。 (默认为spark.pyspark.python)
spark.pyspark.python Python二进制可执行文件,用于驱动程序和执行程序中的PySpark。

Shuffle Behavior

Property Name Default Meaning
spark.reducer.maxSizeInFlight 48m 除非另有说明,否则在MiB中同时从每个reduce任务获取的映射输出的最大大小。 由于每个输出都需要我们创建一个缓冲区来接收它,这表示每个reduce任务的固定内存开销,所以除非你有大量的内存,否则保持它很小。
col 2 is centered $12
spark.reducer.maxReqsInFlight Int.MaxValue 此配置限制在任何给定点获取块的远程请求数。 当群集中的主机数量增加时,可能会导致与一个或多个节点的入站连接数量非常大,从而导致工作负载失败。 通过允许它限制获取请求的数量,可以减轻此方案。
spark.reducer.maxBlocksInFlightPerAddress Int.MaxValue 此配置限制从给定主机端口每个reduce任务获取的远程块的数量。 当在单次提取中同时从给定地址请求大量块时,这可能会使服务执行程序或节点管理器崩溃。 这对于在启用外部随机播放时减少节点管理器上的负载特别有用。 您可以通过将其设置为较低的值来缓解此问题。
spark.maxRemoteBlockSizeFetchToMem Long.MaxValue 当块的大小高于此阈值(以字节为单位)时,远程块将被提取到磁盘。 这是为了避免巨大的请求占用太多内存。 我们可以通过设置特定值(例如200米)来启用此配置。 请注意,此配置将影响随机提取和块管理器远程块提取。 对于启用了外部shuffle服务的用户,只有当外部shuffle服务比Spark 2.2更新时,才能使用此功能。
spark.shuffle.compress true 是否压缩map输出文件。 一般来说是个好主意。 压缩将使用spark.io.compression.codec。
spark.shuffle.file.buffer 32k 除非另有说明,否则每个shuffle文件输出流的内存缓冲区大小(KiB)。 这些缓冲区减少了在创建中间shuffle文件时进行的磁盘搜索和系统调用的次数。
spark.shuffle.io.maxRetries 3 (仅限Netty)如果将此设置为非零值,则会自动重试因IO相关异常而失败的提取。 这种重试逻辑有助于在长时间GC暂停或瞬态网络连接问题时稳定大型混洗。
spark.shuffle.io.numConnectionsPerPeer 1 (仅限Netty)重用主机之间的连接,以减少大型群集的连接建立。 对于具有许多硬盘和少数主机的群集,这可能导致并发性不足以使所有磁盘饱和,因此用户可能会考虑增加此值。
spark.shuffle.io.preferDirectBufs true (仅限Netty)堆外缓冲区用于减少随机播放和缓存块传输期间的垃圾收集。 对于严格限制堆外内存的环境,用户可能希望将其关闭以强制Netty的所有分配都在堆上。
spark.shuffle.io.retryWait 5s (仅限Netty)在重试提取之间等待多长时间。 默认情况下,重试导致的最大延迟为15秒,计算为maxRetries * retryWait。
spark.shuffle.service.enabled false 启用外部随机服务。 此服务保留执行程序写入的随机文件,以便可以安全地删除执行程序。 如果spark.dynamicAllocation.enabled为“true”,则必须启用此选项。 必须设置外部随机服务才能启用它。 有关更多信息,请参阅动态分配配置和设置文档。
spark.shuffle.service.port 7337 将运行外部shuffle服务的端口。
spark.shuffle.service.index.cache.size 100m 缓存条目仅限于指定的内存占用(以字节为单位)
spark.shuffle.maxChunksBeingTransferred Long.MAX_VALUE 允许在随机服务上同时传输的最大块数。 请注意,当达到最大数量时,将关闭新的传入连接。 客户端将根据shuffle重试配置重试(请参阅spark.shuffle.io.maxRetries和spark.shuffle.io.retryWait),如果达到这些限制,则任务将因提取失败而失败。
spark.shuffle.sort.bypassMergeThreshold 200 (高级)在基于排序的shuffle管理器中,如果没有映射端聚合,则避免合并排序数据,并且最多存在多个reduce分区。
spark.shuffle.spill.compress true 是否压缩在随机播放期间溢出的数据。 压缩将使spark.io.compression.codec。
spark.shuffle.accurateBlockThreshold 100 * 1024 * 1024 以字节为单位的阈值,高于该阈值可准确记录HighlyCompressedMapStatus中随机块的大小。 这有助于通过避免在获取shuffle块时低估shuffle块大小来防止OOM
spark.shuffle.registration.timeout 5000 注册到外部shuffle服务的超时(以毫秒为单位)。
spark.shuffle.registration.maxAttempts 3 当我们未能注册到外部shuffle服务时,我们将重试maxAttempts次。
spark.io.encryption.enabled false 启用IO加密。 目前除了Mesos之外的所有模式都支持。 建议在使用此功能时启用RPC加密。
spark.io.encryption.keySizeBits 128 IO加密密钥大小(位)。 支持的值为128,192和256。
spark.io.encryption.keygen.algorithm HmacSHA1 生成IO加密密钥时使用的算法。 Java Cryptography体系结构标准算法名称文档的KeyGenerator部分中描述了支持的算法。

Spark UI

Property Name Default Meaning
spark.eventLog.logBlockUpdates.enabled false 是否为每个块更新记录事件,如果spark.eventLog.enabled为true。 警告:这会大大增加事件日志的大小。
spark.eventLog.compress false 是否压缩已记录的事件,如果spark.eventLog.enabled为true。 压缩将使用spark.io.compression.codec。
spark.eventLog.dir file:///tmp/spark-events 如果spark.eventLog.enabled为true,则记录Spark事件的基目录。 在此基本目录中,Spark为每个应用程序创建一个子目录,并将特定于该应用程序的事件记录在此目录中。 用户可能希望将其设置为统一位置(如HDFS目录),以便历史记录服务器可以读取历史记录文件。
spark.eventLog.enabled false 是否记录Spark事件,对于在应用程序完成后重建Web UI非常有用。
spark.eventLog.overwrite false 是否覆盖任何现有文件。
spark.eventLog.buffer.kb 100k 写入输出流时使用的缓冲区大小,以KiB表示,除非另有说明。
spark.ui.enabled true 是否为Spark应用程序运行Web UI。
spark.ui.killEnabled true 允许从Web UI中删除作业和阶段。
spark.ui.port 4040 应用程序仪表板的端口,显示内存和工作负载数据。
spark.ui.retainedJobs 1000 在垃圾收集之前,Spark UI和状态API记住了多少个作业。 这是目标最大值,在某些情况下可以保留更少的元素。
spark.ui.retainedStages 1000 在垃圾收集之前,Spark UI和状态API记住了多少个阶段。 这是目标最大值,在某些情况下可以保留更少的元素。
spark.ui.retainedTasks 100000 垃圾收集之前Spark UI和状态API记住了多少个任务。 这是目标最大值,在某些情况下可以保留更少的元素。
spark.ui.reverseProxy false 启用Spark Master作为工作程序和应用程序UI的反向代理。 在此模式下,Spark master将反向代理工作者和应用程序UI以启用访问,而无需直接访问其主机。 请谨慎使用,因为工作人员和应用程序UI无法直接访问,您只能通过spark master / proxy公共URL访问它们。 此设置会影响群集中运行的所有工作程序和应用程序UI,并且必须在所有工作程序,驱动程序和主服务器上进行设置。
spark.ui.reverseProxyUrl 这是运行代理的URL。 此URL用于在Spark Master前运行的代理。 这在运行代理进行身份验证时很有用 OAuth代理。 确保这是一个完整的URL,包括方案(http / https)和端口以访问您的代理。
spark.ui.showConsoleProgress true 在控制台中显示进度条。 进度条显示运行时间超过500毫秒的阶段的进度。 如果多个阶段同时运行,则会在同一行上显示多个进度条。
spark.worker.ui.retainedExecutors 1000 在垃圾收集之前,Spark UI和状态API记住了多少个已完成的执行程序。
spark.worker.ui.retainedDrivers 1000 在垃圾收集之前,Spark UI和状态API记住了多少个已完成的驱动程序。
spark.sql.ui.retainedExecutions 1000 在垃圾收集之前,Spark UI和状态API记住完成的执行次数。
spark.streaming.ui.retainedBatches 1000 在垃圾收集之前,Spark UI和状态API记住了多少批次。
spark.ui.retainedDeadExecutors 100 在垃圾收集之前,Spark UI和状态API记住了多少个死执行程序。

Compression and Serialization

Property Name Default Meaning
spark.broadcast.compress true 是否在发送之前压缩广播变量。 一般来说是个好主意。 压缩将使用spark.io.compression.codec。
spark.io.compression.codec lz4 用于压缩内部数据的编解码器,例如RDD分区,事件日志,广播变量和随机输出。 默认情况下,Spark提供了四种编解码器:lz4,lzf,snappy和zstd。 您还可以使用完全限定的类名来指定编解码器,例如 org.apache.spark.io.LZ4CompressionCodec,org.apache.spark.io.LZFCompressionCodec,org.apache.spark.io.SnappyCompressionCodec和org.apache.spark.io.ZstdCompressionCodec。
spark.io.compression.lz4.blockSize 32k 在使用LZ4压缩编解码器的情况下,LZ4压缩中使用的块大小(以字节为单位)。 当使用LZ4时,降低此块大小也会降低随机内存使用量。
spark.io.compression.snappy.blockSize 32k 在使用Snappy压缩编解码器的情况下,在Snappy压缩中使用的块大小(以字节为单位)。 使用Snappy时,降低此块大小也会降低随机内存使用量。
spark.io.compression.zstd.level 1 Zstd压缩编解码器的压缩级别。 增加压缩级别将导致更好的压缩,代价是更多的CPU和内存。
spark.io.compression.zstd.bufferSize 32k 在使用Zstd压缩编解码器的情况下,在Zstd压缩中使用的缓冲区大小(以字节为单位)。 降低此大小将降低使用Zstd时的随机内存使用量,但由于过多的JNI调用开销,可能会增加压缩成本。
spark.kryo.classesToRegister (none) 如果使用Kryo序列化,请提供以逗号分隔的自定义类名列表以向Kryo注册。 有关详细信息,请参阅调整指南。
spark.kryo.referenceTracking true 在使用Kryo序列化数据时是否跟踪对同一对象的引用,如果对象图形具有循环并且如果它们包含同一对象的多个副本,则这对于效率是有用的。 如果您知道不是这种情况,可以禁用以提高性能。
spark.kryo.registrationRequired false 是否要求注册Kryo。 如果设置为’true’,如果未注册的类被序列化,Kryo将抛出异常。 如果设置为false(默认值),Kryo将编写未注册的类名以及每个对象。 编写类名会导致显着的性能开销,因此启用此选项可以严格执行用户未从注册中省略的类。
spark.kryo.registrator (none) 如果您使用Kryo序列化,请提供以逗号分隔的类列表,这些类使用Kryo注册您的自定义类。 如果您需要以自定义方式注册类,则此属性非常有用,例如 指定自定义字段序列化程序。 否则spark.kryo.classesToRegister更简单。 它应该设置为扩展KryoRegistrator的类。 有关详细信息,请参阅调整指南。
spark.kryo.unsafe false 是否使用不安全的Kryo序列化程序。 使用基于不安全的IO可以大大加快速度。
spark.kryoserializer.buffer.max 64m 除非另有说明,否则MiB中Kryo序列化缓冲区的最大允许大小。 这必须大于您尝试序列化的任何对象,且必须小于2048米。 如果在Kryo中出现“超出缓冲区限制”异常,请增加此值。
spark.kryoserializer.buffer 64k 除非另有说明,否则Kryo序列化缓冲区的初始大小(KiB)。 请注意,每个worker上每个核心将有一个缓冲区。 如果需要,此缓冲区将长大为spark.kryoserializer.buffer.max。
spark.rdd.compress false 是否压缩序列化RDD分区(例如,Java中的StorageLevel.MEMORY_ONLY_SER和Python中的Scala或StorageLevel.MEMORY_ONLY)。 可以节省大量空间,但需要额外的CPU时间。 压缩将使用spark.io.compression.codec。
spark.serializer org.apache.spark.serializer.JavaSerializer 用于序列化将通过网络发送或需要以序列化形式缓存的对象的类。 Java序列化的默认设置适用于任何Serializable Java对象,但速度很慢,因此我们建议使用org.apache.spark.serializer.KryoSerializer并在需要速度时配置Kryo序列化。 可以是org.apache.spark.Serializer的任何子类。
spark.serializer.objectStreamReset 100 使用org.apache.spark.serializer.JavaSerializer进行序列化时,序列化程序会缓存对象以防止写入冗余数据,但是会停止对这些对象进行垃圾回收。 通过调用’reset’,您可以从序列化程序中清除该信息,并允许收集旧对象。 要关闭此定期重置,请将其设置为-1。 默认情况下,它将每100个对象重置序列化程序。

Memory Management

Property Name Default Meaning
spark.memory.fraction 0.6 用于执行和存储的(堆空间 - 300MB)的分数。 这个越低,溢出和缓存的数据驱逐就越频繁发生。 此配置的目的是在稀疏,异常大的记录的情况下为内部元数据,用户数据结构和不精确的大小估计留出内存。 建议将此值保留为默认值。 有关更多详细信息,包括有关在增加此值时正确调整JVM垃圾回收的重要信息,请参阅此说明。
spark.memory.storageFraction 0.5 存储记忆的数量不受驱逐的影响,表示为由spark.memory.fraction预留的区域大小的一部分。 这个越高,执行的工作内存越少,任务可能会更频繁地溢出到磁盘。 建议将此值保留为默认值。 有关更多详细信息,请参阅此说明。
spark.memory.offHeap.enabled false 如果为true,Spark将尝试使用堆外内存进行某些操作。 如果启用了堆外内存使用,则spark.memory.offHeap.size必须为正数。
spark.memory.offHeap.size 0 可用于堆外分配的绝对内存量(以字节为单位)。 此设置对堆内存使用没有影响,因此如果执行程序的总内存消耗必须符合某些硬限制,那么请确保相应地缩小JVM堆大小。 当spark.memory.offHeap.enabled = true时,必须将其设置为正值。
spark.memory.useLegacyMode false 是否启用Spark 1.5及之前使用的旧式内存管理模式。 传统模式将堆空间严格划分为固定大小的区域,如果未调整应用程序,可能会导致过多的溢出。 除非启用此命令,否则不会读取以下不推荐使用的内存分数配置:spark.shuffle.memoryFraction spark.storage.memoryFraction spark.storage.unrollFraction
spark.shuffle.memoryFraction 0.2 (不建议使用)如果启用了spark.memory.useLegacyMode,则只读它。 在随机播放期间用于聚合和cogroup的Java堆的分数。 在任何给定的时间,用于shuffle的所有内存映射的集合大小受此限制的限制,超过该限制,内容将开始溢出到磁盘。 如果经常出现溢出,请考虑以spark.storage.memoryFraction为代价来增加此值。
spark.storage.memoryFraction 0.6 (不建议使用)如果启用了spark.memory.useLegacyMode,则只读它。 用于Spark内存缓存的Java堆的分数。 这不应该大于JVM中的“旧”对象生成,默认情况下会给出0.6的堆,但如果配置自己的旧生成大小,则可以增加它。
spark.storage.unrollFraction 0.2 (不建议使用)如果启用了spark.memory.useLegacyMode,则只读它。 spark.storage.memoryFraction的一部分,用于在内存中展开块。 当没有足够的可用存储空间来完全展开新块时,通过删除现有块来动态分配。
spark.storage.replication.proactive false 为RDD块启用主动块复制。 如果存在任何可用的副本,则会因执行程序故障而丢失缓存的RDD块副本。 这会尝试将块的复制级别设置为初始编号。
spark.cleaner.periodicGC.interval 30min 控制触发垃圾回收的频率。仅当弱引用被垃圾收集时,此上下文清除程序才会触发清理。 在具有大型驱动程序JVM的长时间运行的应用程序中,驱动程序上的内存压力很小,这可能偶尔发生或根本不发生。 根本不清理可能会导致执行程序在一段时间后耗尽磁盘空间。
spark.cleaner.referenceTracking true 启用或禁用上下文清理。
spark.cleaner.referenceTracking.blocking true 控制清理线程是否应该阻止清除任务(除了shuffle,由spark.cleaner.referenceTracking.blocking.shuffle Spark属性控制)。
spark.cleaner.referenceTracking.blocking.shuffle false 控制清理线程是否应阻止随机清理任务。
spark.cleaner.referenceTracking.cleanCheckpoints false 控制是否在引用超出范围时清除检查点文件。

Execution Behavior

Property Name Default Meaning
spark.broadcast.blockSize 4m 除非另有说明,否则TorrentBroadcastFactory的块的每个块的大小,以KiB为单位。 太大的值会降低广播期间的并行度(使其变慢); 但是,如果它太小,BlockManager可能会受到性能影响。
spark.executor.cores 1 in YARN mode, all the available cores on the worker in standalone and Mesos coarse-grained modes. 每个执行程序使用的核心数。 在standalone和Mesos粗粒度模式中,有关更多详细信息,请参阅此说明。
spark.default.parallelism 对于像reduceByKey和join这样的分布式shuffle操作,父RDD中的分区数量最多。 对于没RDD并行化的操作,它取决于集群管理器:本地模式:本地计算机上的核心数Mesos细粒度模式:8其他:所有执行程序节点上的核心总数或2,以较大者为准 未由用户设置时,由join,reduceByKey和parallelize等转换返回的RDD中的默认分区数。
spark.executor.heartbeatInterval 10s 每个执行者的心跳与驾驶员之间的间隔。 Heartbeats让驱动程序知道执行程序仍处于活动状态,并使用正在进行的任务的度量标准对其进行更新。 spark.executor.heartbeatInterval应该远远小于spark.network.timeout
spark.files.fetchTimeout 60s 从驱动程序获取通过SparkContext.addFile()添加的文件时使用的通信超时。
spark.files.useFetchCache true 如果设置为true(默认值),则文件获取将使用由属于同一应用程序的执行程序共享的本地缓存,这可以在同一主机上运行多个执行程序时提高任务启动性能。 如果设置为false,则将禁用这些缓存优化,并且所有执行程序都将获取自己的文件副本。 可以禁用此优化以使用驻留在NFS文件系统上的Spark本地目录(有关更多详细信息,请参阅SPARK-6313)。
spark.files.overwrite false 当目标文件存在且其内容与源的文件不匹配时,是否覆盖通过SparkContext.addFile()添加的文件。
spark.files.maxPartitionBytes 134217728 (128 MB) 读取文件时打包到单个分区的最大字节数。
spark.files.openCostInBytes 4194304 (4 MB) 可以同时扫描通过字节数测量的打开文件的估计成本。 将多个文件放入分区时使用。 过度估计会更好,那么具有小文件的分区将比具有更大文件的分区更快。
spark.hadoop.cloneConf false 如果设置为true,则为每个任务克隆新的Hadoop配置对象。 应启用此选项以解决配置线程安全问题(有关详细信息,请参阅SPARK-2546)。 默认情况下禁用此选项,以避免不受这些问题影响的作业出现意外性能回归。
spark.hadoop.validateOutputSpecs true 如果设置为true,则验证saveAsHadoopFile和其他变体中使用的输出规范(例如,检查输出目录是否已存在)。 可以禁用此选项以消除由于预先存在的输出目录而导致的异常。 我们建议用户不要禁用此功能,除非尝试实现与以前版本的Spark的兼容性。 只需使用Hadoop的FileSystem API手动删除输出目录。 对于通过Spark Streaming的StreamingContext生成的作业,将忽略此设置,因为在检查点恢复期间可能需要将数据重写为预先存在的输出目录。
spark.storage.memoryMapThreshold 2m 块中的大小(以字节为单位),当从磁盘读取块时,Spark内存会映射到该块。 这可以防止Spark从内存映射非常小的块。 通常,对于接近或低于操作系统页面大小的块,内存映射具有高开销。
spark.hadoop.mapreduce.fileoutputcommitter.algorithm.version 1 文件输出提交者算法版本,有效算法版本号:1或2.版本2可能具有更好的性能,但是根据MAPREDUCE-4815,版本1可以在某些情况下更好地处理故障。

Networking

Property Name Default Meaning
spark.rpc.message.maxSize 128 “控制平面”通信中允许的最大消息大小(以MB为单位); 通常仅适用于执行程序和驱动程序之间发送的映射输出大小信息。 如果您正在运行具有数千个map和reduce任务的作业并查看有关RPC消息大小的消息,请增加此值。
spark.blockManager.port (random) 所有块管理器的端口都可以监听。 它们存在于驱动程序和执行程序中。
spark.driver.blockManager.port (value of spark.blockManager.port) 如果不能使用与执行程序相同的配置,则块管理器要侦听的特定于驱动程序的端口。
spark.driver.bindAddress (value of spark.driver.host) 主机名或IP地址绑定侦听套接字的位置。 此配置会覆盖SPARK_LOCAL_IP环境变量(请参见下文)。它还允许将与本地地址不同的地址通告给执行者或外部系统。 例如,在运行具有桥接网络的容器时,这很有用。 为了正常工作,需要从容器的主机转发驱动程序使用的不同端口(RPC,块管理器和UI)。
spark.driver.host (local hostname) 驱动程序的主机名或IP地址。 这用于与执行程序和独立主服务器通信。
spark.driver.port (random) 用于侦听的驱动程序的端口。 这用于与执行程序和独立主服务器通信。
spark.network.timeout 120s 所有网络交互的默认超时。 此配置将用于代替spark.core.connection.ack.wait.timeout,spark.storage.blockManagerSlaveTimeoutMs,spark.shuffle.io.connectionTimeout,spark.rpc.askTimeout或spark.rpc.lookupTimeout(如果未配置)。
spark.port.maxRetries 16 在放弃之前绑定到端口时的最大重试次数。 当端口被赋予特定值(非0)时,每次后续重试都会在重试之前将先前尝试中使用的端口增加1。 这实际上允许它尝试从指定的起始端口到端口+ maxRetries的一系列端口。
spark.rpc.numRetries 3 在RPC任务放弃之前重试的次数。 RPC任务将在此数字的大多数时间运行。
spark.rpc.retry.wait 3s RPC请求操作在重试之前等待的持续时间。
spark.rpc.askTimeout spark.network.timeout RPC请求操作在超时之前等待的持续时间。
spark.rpc.lookupTimeout 120s RPC远程端点查找操作在超时之前等待的持续时间。

Scheduling

Property Name Default Meaning
spark.cores.max (not set) 在“粗粒度”共享模式下在独立部署群集或Mesos群集上运行时,从群集(而非每台计算机)请求应用程序的最大CPU核心数量。 如果未设置,则默认为Spark的独立集群管理器上的spark.deploy.defaultCores,或Mesos上的无限(所有可用内核)。
spark.locality.wait 3s 很久以后,等待在放弃并在较少本地节点上启动数据本地任务之前。 相同的等待将用于逐步执行多个位置级别(进程本地,节点本地,机架本地,然后是任何)。 也可以通过设置spark.locality.wait.node等来自定义每个级别的等待时间。如果您的任务很长并且看到不良位置,则应该增加此设置,但默认情况通常很有效。
spark.locality.wait.node spark.locality.wait 自定义位置等待节点位置。 例如,您可以将此值设置为0以跳过节点位置并立即搜索机架位置(如果您的群集有机架信息)。
spark.locality.wait.process spark.locality.wait 自定义位置等待进程位置。 这会影响尝试访问特定执行程序进程中的缓存数据的任务。
spark.locality.wait.rack spark.locality.wait 自定义本地等待机架位置。
spark.scheduler.maxRegisteredResourcesWaitingTime 30s 在计划开始之前等待资源注册的最长时间。
spark.scheduler.minRegisteredResourcesRatio 0.8为KUBERNETES模式; YARN模式为0.8; 0.0表示独立模式和Mesos粗粒度模式 注册资源(注册资源/预期资源总量)的最小比率(资源是纱线模式和Kubernetes模式下的执行者,独立模式下的CPU核心和Mesos粗粒度模式[‘spark.cores.max’值是总预期资源 Mesos粗粒度模式])在调度开始之前等待。 指定为0.0和1.0之间的双精度。 无论是否达到最小资源比率,在调度开始之前等待的最长时间由config spark.scheduler.maxRegisteredResourcesWaitingTime控制。
spark.scheduler.mode FIFO 提交到同一SparkContext的作业之间的调度模式。 可以设置为FAIR以使用公平共享而不是一个接一个地排队工作。 对多用户服务很有用。
spark.scheduler.revive.interval 1s 调度程序恢复工作程序资源的间隔长度提供了运行任务。
spark.scheduler.listenerbus.eventqueue.capacity 10000 Spark侦听器总线中事件队列的容量必须大于0.如果删除侦听器事件,请考虑增加值(例如20000)。 增加此值可能会导致驱动程序使用更多内存。
spark.blacklist.enabled false 如果设置为“true”,则阻止Spark在由于任务失败太多而被列入黑名单的执行程序上计划任务。 黑名单算法可以通过其他“spark.blacklist”配置选项进一步控制。
spark.blacklist.timeout 1h (实验)在将节点或执行程序无条件地从黑名单中删除以尝试运行新任务之前,将整个应用程序列入黑名单的时间长度。
spark.blacklist.task.maxTaskAttemptsPerExecutor 1 (实验)对于给定任务,在执行者被列入黑名单之前,可以在一个执行程序上重试多少次。
spark.blacklist.task.maxTaskAttemptsPerNode 2 实验)对于给定任务,在整个节点被列入黑名单之前,可以在一个节点上重试多少次。
spark.blacklist.stage.maxFailedTasksPerExecutor 2 (实验)在执行者被列入该阶段的黑名单之前,在一个阶段内,一个执行者必须完成多少个不同的任务。
spark.blacklist.stage.maxFailedExecutorsPerNode 2 (实验)在整个节点被标记为阶段失败之前,在给定阶段将多少个不同的执行程序标记为黑名单。
spark.blacklist.application.maxFailedTasksPerExecutor 2 (实验)在执行程序被列入整个应用程序的黑名单之前,在一个执行程序中,在成功的任务集中,有多少个不同的任务必须失败。 在spark.blacklist.timeout指定的超时后,列入黑名单的执行程序将自动添加回可用资源池。 请注意,通过动态分配,执行程序可能会被标记为空闲并由集群管理器回收。
spark.blacklist.application.maxFailedExecutorsPerNode 2 (实验)在将节点列入整个应用程序的黑名单之前,必须将多个不同的执行程序列入黑名单。 在spark.blacklist.timeout指定的超时后,列入黑名单的节点将自动添加回可用资源池。 但请注意,通过动态分配,节点上的执行程序可能会被标记为空闲并由集群管理器回收。
spark.blacklist.killBlacklistedExecutors false (实验)如果设置为“true”,则允许Spark在被列入黑名单时自动终止并尝试重新创建执行程序。 请注意,当整个节点添加到黑名单时,该节点上的所有执行程序都将被终止。
spark.blacklist.application.fetchFailure.enabled false (实验)如果设置为“true”,Spark会在发生提取失败时立即将执行程序列入黑名单。 如果启用了外部随机服务,则整个节点将被列入黑名单。
spark.speculation false 如果设置为“true”,则执行任务的推测执行。 这意味着如果一个或多个任务在一个阶段中运行缓慢,它们将被重新启动。
spark.speculation.interval 100ms Spark经常检查要推测的任务。
spark.speculation.multiplier 1.5 任务的速度比投机的中位数慢多少倍。
spark.speculation.quantile 0.75 在为特定阶段启用推测之前必须完成的任务的分数。
spark.task.cpus 1 为每个任务分配的核心数。
spark.task.maxFailures 4 在放弃工作之前任何特定任务的失败次数。 在不同任务中传播的故障总数不会导致作业失败; 特定任务必须通过这么多尝试才能失败。 应大于或等于1.允许的重试次数=此值 - 1。
spark.task.reaper.enabled false 允许监视已终止/中断的任务。 设置为true时,执行程序将监视任何被杀死的任务,直到该任务实际完成执行。 有关如何控制此监视的确切行为的详细信息,请参阅其他spark.task.reaper。*配置。 设置为false(默认值)时,任务查杀将使用缺少此类监视的旧代码路径。
spark.task.reaper.pollingInterval 10s 当spark.task.reaper.enabled = true时,此设置控制执行程序轮询已终止任务状态的频率。 如果在轮询时仍然运行被杀死的任务,那么将记录一个警告,并且默认情况下将记录该任务的线程转储(可以通过spark.task.reaper.threadDump设置禁用此线程转储,这是 记录如下)。
spark.task.reaper.threadDump true 当spark.task.reaper.enabled = true时,此设置控制是否在定期轮询已终止任务期间记录任务线程转储。 将此属性设置为false可禁用线程转储的收集。
spark.task.reaper.killTimeout -1 当spark.task.reaper.enabled = true时,此设置指定超时,如果已终止的任务未停止运行,执行程序JVM将自行终止。 默认值-1禁用此机制并阻止执行程序自毁。 此设置的目的是充当安全网,以防止无法执行的无法执行的任务使执行程序无法使用。
spark.stage.maxConsecutiveAttempts 4 在中止阶段之前允许的连续阶段尝试次数。

动态分配

Property Name Default Meaning
spark.dynamicAllocation.enabled false 是否使用动态资源分配,该分配根据工作负载上下调整使用此应用程序注册的执行程序的数量。 有关更多详细信息,请参阅此处的说明。这需要设置spark.shuffle.service.enabled。 以下配置也是相关的:spark.dynamicAllocation.minExecutors,spark.dynamicAllocation.maxExecutors和spark.dynamicAllocation.initialExecutors
spark.dynamicAllocation.executorIdleTimeout 60s 如果启用了动态分配并且执行程序空闲时间超过此持续时间,则执行程序将被删除。 有关更多详细信息,请参阅此说明。
spark.dynamicAllocation.cachedExecutorIdleTimeout infinity 如果启用了动态分配并且具有高速缓存数据块的执行程序已空闲超过此持续时间,则将删除执行程序。 有关更多详细信息,请参阅此说明。
spark.dynamicAllocation.initialExecutors spark.dynamicAllocation.minExecutors 启用动态分配时要运行的初始执行程序数。如果设置了--num-executors(或spark.executor.instances)并且大于此值,它将被用作执行者的初始数量。
spark.dynamicAllocation.maxExecutors infinity 启用动态分配时执行程序数的上限。
spark.dynamicAllocation.minExecutors 0 启用动态分配时执行程序数量的下限。
spark.dynamicAllocation.schedulerBacklogTimeout 1s 如果启用了动态分配并且已有挂起的任务积压超过此持续时间,则将请求新的执行程序。 有关更多详细信息,请参阅此说明。
spark.dynamicAllocation.sustainedSchedulerBacklogTimeout schedulerBacklogTimeout 与spark.dynamicAllocation.schedulerBacklogTimeout相同,但仅用于后续执行程序请求。 有关更多详细信息,请参阅此说明。

Security

Property Name Default Meaning
spark.acls.enable false 是否应该启用Spark acls。 如果启用,则会检查用户是否具有查看或修改作业的访问权限。 请注意,这需要知道用户,因此如果用户遇到null,则不会进行任何检查。 可以使用过滤器对UI进行身份验证和设置用户。
spark.admin.acls Empty 以逗号分隔的用户/管理员列表,可以查看和修改对所有Spark作业的访问权限。 如果您在共享群集上运行并且有一组管理员或开发人员在事情不起作用时帮助调试,则可以使用此方法。 在列表中加上“*”表示任何用户都可以拥有admin权限。
spark.admin.acls.groups Empty 逗号分隔的组列表,具有查看和修改所有Spark作业的访问权限。 如果您有一组帮助维护和调试底层基础结构的管理员或开发人员,则可以使用此方法。 在列表中加上“*”表示任何组中的任何用户都可以拥有admin的权限。 用户组是从spark.user.groups.mapping指定的组映射提供程序的实例获取的。 检查条目spark.user.groups.mapping以获取更多详细信息。
spark.user.groups.mapping org.apache.spark.security.ShellBasedGroupsMappingProvider 用户的组列表由特征org.apache.spark.security.GroupMappingServiceProvider定义的组映射服务确定,该服务可由此属性配置。 提供了一个默认的基于unix shell的实现org.apache.spark.security.ShellBasedGroupsMappingProvider,可以指定该实现来解析用户的组列表。 注意:此实现仅支持基于Unix / Linux的环境。 目前不支持Windows环境。 但是,可以通过实现特征org.apache.spark.security.GroupMappingServiceProvider来支持新的平台/协议。
spark.authenticate false Spark是否验证其内部连接。 如果没有在YARN上运行,请参见spark.authenticate.secret。
spark.authenticate.secret None 设置用于Spark的密钥以在组件之间进行身份验证。 如果未在YARN上运行并且启用了身份验证,则需要设置此项。
spark.network.crypto.enabled false 使用commons-crypto库为RPC和块传输服务启用加密。 需要启用spark.authenticate。
spark.network.crypto.keyLength 128 要生成的加密密钥的位长度。 有效值为128,192和256。
spark.network.crypto.keyFactoryAlgorithm PBKDF2WithHmacSHA1 生成加密密钥时使用的密钥工厂算法。 应该是正在使用的JRE中的javax.crypto.SecretKeyFactory类支持的算法之一。
spark.network.crypto.saslFallback true 如果使用Spark的内部机制验证失败,是否回退到SASL身份验证。 当应用程序连接到不支持内部Spark身份验证协议的旧shuffle服务时,这非常有用。 在服务器端,这可用于阻止较旧的客户端对新的shuffle服务进行身份验证。
spark.network.crypto.config.* None commons-crypto库的配置值,例如要使用的密码实现。 配置名称应该是没有“commons.crypto”前缀的commons-crypto配置的名称。
spark.authenticate.enableSaslEncryption false 启用身份验证时启用加密通信。 块传输服务和RPC端点支持此功能。
spark.network.sasl.serverAlwaysEncrypt false 为支持SASL身份验证的服务禁用未加密的连接。
spark.core.connection.ack.wait.timeout spark.network.timeout 在超时和放弃之前连接等待ack的时间有多长。 为避免因GC等长时间停顿而导致的不必要的超时,您可以设置更大的值。
spark.modify.acls Empty 逗号分隔的用户列表,具有对Spark作业的修改权限。 默认情况下,只有启动Spark作业的用户才有权修改它(例如,将其删除)。 在列表中加上“*”表示任何用户都可以有权修改它。
spark.modify.acls.groups Empty 逗号分隔的组列表,具有对Spark作业的修改权限。 如果您有一组来自同一团队的管理员或开发人员有权控制该作业,则可以使用此方法。 在列表中加上“*”表示任何组中的任何用户都有权修改Spark作业。 用户组是从spark.user.groups.mapping指定的组映射提供程序的实例获取的。 检查条目spark.user.groups.mapping以获取更多详细信息。
spark.ui.filters None 逗号分隔的过滤器类名列表,以应用于Spark Web UI。 过滤器应该是标准的javax servlet过滤器。 也可以通过设置以下java系统属性来指定每个过滤器的参数:spark。<过滤器的类名> .params =’param1 = value1,param2 = value2’例如:-Dspark.ui.filters= com.test.filter1-Dspark.com.test.filter1.params= ‘的param1= FOO,参数2=测试’
spark.ui.view.acls Empty 逗号分隔的用户列表,具有对Spark Web ui的查看权限。 默认情况下,只有启动Spark作业的用户才具有视图访问权限。 在列表中加上“*”表示任何用户都可以拥有对此Spark作业的查看权限。
spark.ui.view.acls.groups Empty 逗号分隔的组列表,具有对Spark Web ui的查看访问权限,以查看Spark作业详细信息。 如果您有一组可以监视提交的Spark作业的管理员或开发人员或用户,则可以使用此方法。 在列表中添加“*”表示任何组中的任何用户都可以在Spark Web ui上查看Spark作业详细信息。 用户组是从spark.user.groups.mapping指定的组映射提供程序的实例获取的。 检查条目spark.user.groups.mapping以获取更多详细信息。

TLS / SSL

Property Name Default Meaning
spark.ssl.enabled false 是否在所有支持的协议上启用SSL连接。配置spark.ssl.enabled时,需要spark.ssl.protocol。所有SSL设置(如spark.ssl.xxx,其中xxx是特定的配置属性)表示所有支持的协议的全局配置。 为了覆盖特定协议的全局配置,必须在特定于协议的命名空间中覆盖这些属性。使用spark.ssl.YYY.XXX设置覆盖YYY表示的特定协议的全局配置。 YYY的示例值包括fs,ui,standalone和historyServer。 有关服务的分层SSL配置的详细信息,请参阅SSL配置。
spark.ssl.[namespace].port None SSL服务将侦听的端口。必须在命名空间配置中定义端口; 请参阅可用命名空间的SSL配置。未设置时,SSL端口将从同一服务的非SSL端口派生。 值“0”将使服务绑定到临时端口。
spark.ssl.enabledAlgorithms Empty 以逗号分隔的密码列表。 JVM必须支持指定的密码。 可以在此页面上找到的协议参考列表。 注意:如果未设置,它将使用JVM的默认密码套件。
spark.ssl.keyPassword None 密钥库中私钥的密码。
spark.ssl.keyStore None 密钥库文件的路径。 该路径可以是启动组件的目录的绝对路径或相对路径。
spark.ssl.keyStorePassword None 密钥库的密码。
spark.ssl.keyStoreType JKS 密钥库的类型。
spark.ssl.protocol None 协议名称。 JVM必须支持该协议。 可以在此页面上找到的协议参考列表。
spark.ssl.needClientAuth false 如果SSL需要客户端验证,则设置为true
spark.ssl.trustStore None 信任存储文件的路径。 该路径可以是启动组件的目录的绝对路径或相对路径。
spark.ssl.trustStorePassword None 信任存储区的密码。
spark.ssl.trustStoreType JKS 信任存储的类型。

Spark SQL
运行SET -v命令将显示SQL配置的完整列表。

// spark is an existing SparkSession
spark.sql("SET -v").show(numRows = 200, truncate = false)

Spark Streaming

Property Name Default Meaning
spark.streaming.backpressure.enabled false 启用或禁用Spark Streaming的内部背压机制(自1.5起)。 这使Spark Streaming能够根据当前的批处理调度延迟和处理时间来控制接收速率,以便系统只接收系统可以处理的速度。 在内部,这动态地设置接收器的最大接收速率。 如果设置了这个值,则上限受spark.streaming.receiver.maxRate和spark.streaming.kafka.maxRatePerPartition值的限制(见下文)。
spark.streaming.backpressure.initialRate not set 这是启用背压机制时每个接收器将接收第一批数据的初始最大接收速率。
spark.streaming.blockInterval 200ms Spark Streaming接收器接收的数据在存储到Spark之前被分块为数据块的时间间隔。 建议最低 - 50毫秒。 有关更多详细信息,请参阅Spark Streaming编程指南中的性能调整部分。
spark.streaming.receiver.maxRate not set 每个接收器将接收数据的最大速率(每秒记录数)。 实际上,每个流每秒最多将消耗此数量的记录。 将此配置设置为0或负数将不会对速率进行限制。 有关模式详细信息,请参阅Spark Streaming编程指南中的部署指南。
spark.streaming.receiver.writeAheadLog.enable false 启用接收器的预写日志。 通过接收器接收的所有输入数据将被保存到提前写入日志,以便在驱动程序失败后恢复。 有关更多详细信息,请参阅Spark Streaming编程指南中的部署指南。
spark.streaming.unpersist true Spark Streaming生成并持久化的强制RDD将自动从Spark的内存中取消。 Spark Streaming接收的原始输入数据也会自动清除。 将此设置为false将允许原始数据和持久RDD在流应用程序外部可访问,因为它们不会自动清除。 但它的代价是Spark中更高的内存使用量。
spark.streaming.stopGracefullyOnShutdown false 如果为true,Spark会在JVM关闭时正常关闭StreamingContext,而不是立即关闭。
spark.streaming.kafka.maxRatePerPartition not set 使用新Kafka直接流API时从每个Kafka分区读取数据的最大速率(每秒记录数)。 有关更多详细信息,请参阅Kafka集成指南。
spark.streaming.kafka.maxRetries 1 驱动程序为了在每个分区的leader上找到最新偏移量而进行的最大连续重试次数(默认值为1表示驱动程序最多会尝试2次)。 仅适用于新的Kafka直接流API。
spark.streaming.ui.retainedBatches 1000 在垃圾收集之前,Spark Streaming UI和状态API会记住多少批次。
spark.streaming.driver.writeAheadLog.closeFileAfterWrite false 是否在驱动程序上写入提前写入日志记录后关闭文件。 如果要将S3(或任何不支持刷新的文件系统)用于驱动程序上的元数据WAL,请将此项设置为“true”。
spark.streaming.receiver.writeAheadLog.closeFileAfterWrite false 是否在接收器上写入写入日志记录后关闭文件。 如果要将S3(或任何不支持刷新的文件系统)用于接收器上的数据WAL,请将此设置为“true”。

SparkR

Property Name Default Meaning
spark.r.numRBackendThreads 2 RBackend用于处理来自SparkR包的RPC调用的线程数。
spark.r.command Rscript 可执行以在驱动程序和工作程序的集群模式下执行R脚本。
spark.r.driver.command spark.r.command 在驱动程序的客户端模式下执行R脚本的可执行文件。 在群集模式下忽略。
spark.r.shell.command R 在驱动程序的客户端模式下执行sparkR shell的可执行文件。 在群集模式下忽略。 它与环境变量SPARKR_DRIVER_R相同,但优先于它。 spark.r.shell.command用于sparkR shell,而spark.r.driver.command用于运行R脚本。
spark.r.backendConnectionTimeout 6000 R进程在几秒钟内连接到RBackend时设置的连接超时。
spark.r.heartBeatInterval 100 从SparkR后端发送到R进程的心跳间隔,以防止连接超时。

GraphX

Property Name Default Meaning
spark.graphx.pregel.checkpointInterval -1 Pregel中图形和消息的检查点间隔。 它用于避免stackOverflowError,因为在经过大量迭代后,由于长谱系链。 默认情况下禁用检查点。

Deploy

Property Name Default Meaning
spark.deploy.recoveryMode NONE 恢复模式设置,用于在失败并重新启动时使用群集模式恢复提交的Spark作业。 这仅适用于使用Standalone或Mesos运行时的群集模式。
spark.deploy.zookeeper.url None spark.deploy.recoveryMode设置为ZOOKEEPER时,此配置用于设置要连接的zookeeper URL。
spark.deploy.zookeeper.dir None spark.deploy.recoveryMode设置为ZOOKEEPER时,此配置用于将zookeeper目录设置为存储恢复状态。

Cluster Managers
Spark中的每个集群管理器都有其他配置选项。 可以在每种模式的页面上找到配置:
YARN
Mesos
Kubernetes
Standalone Mode

Environment Variables

可以通过环境变量配置某些Spark设置,环境变量从安装Spark的目录中的conf / spark-env.sh脚本(或Windows上的conf / spark-env.cmd)中读取。 在Standalone和Mesos模式下,此文件可以提供机器特定信息,例如主机名。 它还在运行本地Spark应用程序或提交脚本时获取。
请注意,安装Spark时默认情况下不存在conf / spark-env.sh。 但是,您可以复制conf / spark-env.sh.template来创建它。 确保使副本可执行。
可以在spark-env.sh中设置以下变量:

Environment Variable Meaning
JAVA_HOME 安装Java的位置(如果它不在您的默认PATH上)。
PYSPARK_PYTHON 在驱动程序和工作程序中用于PySpark的Python二进制可执行文件(如果可用,默认为python2.7,否则为python)。 如果设置了属性spark.pyspark.python,则优先级
PYSPARK_DRIVER_PYTHON Python二进制可执行文件仅用于驱动程序中的PySpark(默认为PYSPARK_PYTHON)。 如果设置了属性spark.pyspark.driver.python,则优先级
SPARKR_DRIVER_R 用于SparkR shell的R二进制可执行文件(默认为R)。 如果设置了属性spark.r.shell.command优先级
SPARK_LOCAL_IP 要绑定的计算机的IP地址。
SPARK_PUBLIC_DNS 您的Spark程序的主机名将通告给其他计算机。

除上述内容外,还有用于设置Spark独立群集脚本的选项,例如每台计算机上使用的核心数和最大内存。
由于spark-env.sh是一个shell脚本,因此其中一些可以通过编程方式设置 - 例如,您可以通过查找特定网络接口的IP来计算SPARK_LOCAL_IP。
注意:在群集模式下在YARN上运行Spark时,需要使用conf / spark-defaults.conf文件中的spark.yarn.appMasterEnv。[EnvironmentVariableName]属性设置环境变量。 在spark-env.sh中设置的环境变量不会在群集模式下反映在YARN Application Master进程中。 有关更多信息,请参阅与YARN相关的Spark属性。

Configuring Logging

Spark使用log4j进行日志记录。 您可以通过在conf目录中添加log4j.properties文件来配置它。 一种方法是复制位于那里的现有log4j.properties.template。

Overriding configuration directory

要指定默认“SPARK_HOME / conf”以外的其他配置目录,可以设置SPARK_CONF_DIR。 Spark将使用此目录中的配置文件(spark-defaults.conf,spark-env.sh,log4j.properties等)。

Inheriting Hadoop Cluster Configuration

如果您计划使用Spark从HDFS读取和写入,则Spark的类路径中应包含两个Hadoop配置文件:

  • hdfs-site.xml,它为HDFS客户端提供默认行为。
  • core-site.xml,用于设置默认文件系统名称。

这些配置文件的位置因Hadoop版本而异,但常见位置在/ etc / hadoop / conf中。 有些工具可以即时创建配置,但提供了下载它们副本的机制。

要使这些文件对Spark可见,请将$ SPARK_HOME / conf / spark-env.sh中的HADOOP_CONF_DIR设置为包含配置文件的位置。

Custom(自定义) Hadoop/Hive Configuration

如果您的Spark应用程序正在与Hadoop,Hive或两者进行交互,则Spark的类路径中可能存在Hadoop / Hive配置文件。

多个正在运行的应用程序可能需要不同的Hadoop / Hive客户端配置。 您可以在Spark的类路径中为每个应用程序复制和修改hdfs-site.xml,core-site.xml,yarn-site.xml,hive-site.xml。 在YARN上运行的Spark群集中,这些配置文件在群集范围内设置,并且无法由应用程序安全地更改。

更好的选择是以spark.hadoop。*的形式使用spark hadoop属性。 它们可以被认为与普通火花属性相同,可以在$ SPARK_HOME / conf / spark-defaults.conf中设置

在某些情况下,您可能希望避免在SparkConf中对某些配置进行硬编码。 例如,Spark允许您简单地创建一个空conf并设置spark / spark hadoop属性。

val conf = new SparkConf().set("spark.hadoop.abc.def","xyz")
val sc = new SparkContext(conf)

此外,您可以在运行时修改或添加配置:

./bin/spark-submit \ 
  --name "My app" \ 
  --master local[4] \  
  --conf spark.eventLog.enabled=false \ 
  --conf "spark.executor.extraJavaOptions=-XX:+PrintGCDetails -XX:+PrintGCTimeStamps" \ 
  --conf spark.hadoop.abc.def=xyz \ 
  myApp.jar

Spark Configuration https://www.cppentry.com/bencandy.php?fid=116&id=200495

】【打印繁体】【投稿】【收藏】 【推荐】【举报】【评论】 【关闭】 【返回顶部
上一篇spark与MogoDB不得不说的故事 下一篇Spark与深度学习框架——H2O、dee..