spark-参数配置总结_spark-sql parquest 存 hdfs 不压缩-CSDN博客

本文围绕Spark属性配置展开，介绍了动态加载Spark属性的方法，如创建空conf并在运行时提供配置值。还说明了查看属性的方式，可通过应用程序Web UI的“环境”选项卡查看。同时列举了各类可用属性，包括应用、运行环境等方面，以及环境变量、日志记录等配置要点。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

Spark属性控制大多数应用程序设置，并为每个应用程序单独配置。这些属性可以直接在传递给你的SparkConf上设置 SparkContext。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。请参阅各个配置属性的文档。在可能的情况下，需要指定单位。

动态加载Spark属性

在某些情况下，您可能希望避免对某些配置进行硬编码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应用程序中起作用的属性使用特殊标志。Running ./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属性主要可以分为两种：一种与deploy相关，如“spark.driver.memory”，“spark.executor.instances”，这种属性SparkConf在运行时以编程方式设置时可能不会受到影响，或者行为取决于您选择的集群管理器和部署模式，因此建议通过配置文件或spark-submit命令行选项进行设置; 另一个主要与Spark运行时控件有关，比如“spark.task.maxFailures”，这种属性可以以任何一种方式设置。

查看Spark属性

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

可用属性

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

应用属性

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

除此之外，还提供以下属性，在某些情况下可能有用：

运行环境

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

随机行为

属性名称	默认	含义
`spark.reducer.maxSizeInFlight`	48米	除非另有说明，否则在MiB中同时从每个reduce任务获取的映射输出的最大大小。由于每个输出都需要我们创建一个缓冲区来接收它，这表示每个reduce任务的固定内存开销，所以除非你有大量的内存，否则保持它很小。
`spark.reducer.maxReqsInFlight`	Int.MaxValue	此配置限制在任何给定点获取块的远程请求数。当群集中的主机数量增加时，可能会导致与一个或多个节点的入站连接数量非常大，从而导致工作负载失败。通过允许它限制获取请求的数量，可以减轻此方案。
`spark.reducer.maxBlocksInFlightPerAddress`	Int.MaxValue	此配置限制从给定主机端口每个reduce任务获取的远程块的数量。当在单次提取中同时从给定地址请求大量块时，这可能会使服务执行程序或节点管理器崩溃。这对于在启用外部随机播放时减少节点管理器上的负载特别有用。您可以通过将其设置为较低的值来缓解此问题。
`spark.maxRemoteBlockSizeFetchToMem`	Long.MaxValue	当块的大小高于此阈值（以字节为单位）时，远程块将被提取到磁盘。这是为了避免巨大的请求占用太多内存。我们可以通过设置特定值（例如200米）来启用此配置。请注意，此配置将影响随机提取和块管理器远程块提取。对于启用了外部shuffle服务的用户，只有当外部shuffle服务比Spark 2.2更新时，才能使用此功能。
`spark.shuffle.compress`	真正	是否压缩地图输出文件。一般来说是个好主意。压缩将使用`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`	真正	（仅限Netty）堆外缓冲区用于减少随机播放和缓存块传输期间的垃圾收集。对于严格限制堆外内存的环境，用户可能希望将其关闭以强制Netty的所有分配都在堆上。
`spark.shuffle.io.retryWait`	5S	（仅限Netty）在重试提取之间等待多长时间。默认情况下，重试导致的最大延迟为15秒，计算方式为`maxRetries * retryWait`。
`spark.shuffle.service.enabled`	假	启用外部随机服务。此服务保留执行程序写入的随机文件，以便可以安全地删除执行程序。如果`spark.dynamicAllocation.enabled`为“true”，则必须启用此选项。必须设置外部随机服务才能启用它。有关更多信息，请参阅动态分配配置和设置文档。
`spark.shuffle.service.port`	7337	将运行外部shuffle服务的端口。
`spark.shuffle.service.index.cache.size`	百米	缓存条目仅限于指定的内存占用（以字节为单位）
`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`	真正	是否压缩在随机播放期间溢出的数据。压缩将使用`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`	假	启用IO加密。目前除了Mesos之外的所有模式都支持。建议在使用此功能时启用RPC加密。
`spark.io.encryption.keySizeBits`	128	IO加密密钥大小（位）。支持的值为128,192和256。
`spark.io.encryption.keygen.algorithm`	HMACSHA1	生成IO加密密钥时使用的算法。Java Cryptography体系结构标准算法名称文档的KeyGenerator部分中描述了支持的算法。

Spark UI

属性名称	默认	含义
`spark.eventLog.logBlockUpdates.enabled`	假	是否为每个块更新记录事件，if是否`spark.eventLog.enabled`为真。警告：这会大大增加事件日志的大小。
`spark.eventLog.compress`	假	是否压缩已记录的事件，if是否`spark.eventLog.enabled`为真。压缩将使用`spark.io.compression.codec`。
`spark.eventLog.dir`	文件：/// TMP /火花事件	记录Spark事件的基目录，如果`spark.eventLog.enabled`为true。在此基本目录中，Spark为每个应用程序创建一个子目录，并将特定于该应用程序的事件记录在此目录中。用户可能希望将其设置为统一位置（如HDFS目录），以便历史记录服务器可以读取历史记录文件。
`spark.eventLog.enabled`	假	是否记录Spark事件，对于在应用程序完成后重建Web UI非常有用。
`spark.eventLog.overwrite`	假	是否覆盖任何现有文件。
`spark.eventLog.buffer.kb`	100K	写入输出流时使用的缓冲区大小，以KiB表示，除非另有说明。
`spark.ui.enabled`	真正	是否为Spark应用程序运行Web UI。
`spark.ui.killEnabled`	真正	允许从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`	假	启用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`	真正	在控制台中显示进度条。进度条显示运行时间超过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记住了多少个死执行程序。

压缩和序列化

属性名称	默认	含义
`spark.broadcast.compress`	真正	是否在发送之前压缩广播变量。一般来说是个好主意。压缩将使用`spark.io.compression.codec`。
`spark.io.compression.codec`	LZ4	用于压缩内部数据的编解码器，例如RDD分区，事件日志，广播变量和随机输出。默认情况下，星火提供了四个编解码器：`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`	（没有）	如果使用Kryo序列化，请提供以逗号分隔的自定义类名列表以向Kryo注册。有关详细信息，请参阅调整指南。
`spark.kryo.referenceTracking`	真正	在使用Kryo序列化数据时是否跟踪对同一对象的引用，如果对象图形具有循环并且如果它们包含同一对象的多个副本，则这对于效率是有用的。如果您知道不是这种情况，可以禁用以提高性能。
`spark.kryo.registrationRequired`	假	是否要求注册Kryo。如果设置为'true'，如果未注册的类被序列化，Kryo将抛出异常。如果设置为false（默认值），Kryo将写入未注册的类名以及每个对象。编写类名会导致显着的性能开销，因此启用此选项可以严格执行用户未从注册中省略的类。
`spark.kryo.registrator`	（没有）	如果您使用Kryo序列化，请提供以逗号分隔的类列表，这些类使用Kryo注册您的自定义类。如果您需要以自定义方式注册类，例如指定自定义字段序列化程序，则此属性非常有用。否则`spark.kryo.classesToRegister`更简单。它应该设置为扩展的类。有关详细信息，请参阅调整指南。 `KryoRegistrator`
`spark.kryo.unsafe`	假	是否使用不安全的Kryo序列化程序。使用基于不安全的IO可以大大加快速度。
`spark.kryoserializer.buffer.max`	64米	除非另有说明，否则MiB中Kryo序列化缓冲区的最大允许大小。这必须大于您尝试序列化的任何对象，且必须小于2048米。如果在Kryo中出现“超出缓冲区限制”异常，请增加此值。
`spark.kryoserializer.buffer`	64K	除非另有说明，否则Kryo序列化缓冲区的初始大小（KiB）。请注意，每个worker上每个核心将有一个缓冲区。`spark.kryoserializer.buffer.max`如果需要，此缓冲区将增长。
`spark.rdd.compress`	假	是否压缩序列化RDD分区（例如，用于`StorageLevel.MEMORY_ONLY_SER`Java和Scala或`StorageLevel.MEMORY_ONLY`Python）。可以节省大量空间，但需要额外的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个对象重置序列化程序。

内存管理

属性名称	默认	含义
`spark.memory.fraction`	0.6	用于执行和存储的（堆空间 - 300MB）的分数。这个越低，溢出和缓存的数据驱逐就越频繁发生。此配置的目的是在稀疏，异常大的记录的情况下为内部元数据，用户数据结构和不精确的大小估计留出内存。建议将此值保留为默认值。有关更多详细信息，包括有关在增加此值时正确调整JVM垃圾回收的重要信息，请参阅此说明。
`spark.memory.storageFraction`	0.5	存储记忆的数量不受驱逐的影响，表示为预留区域大小的一小部分`spark.memory.fraction`。这个越高，执行的工作内存越少，任务可能会更频繁地溢出到磁盘。建议将此值保留为默认值。有关更多详细信息，请参阅此说明。
`spark.memory.offHeap.enabled`	假	如果为true，Spark将尝试使用堆外内存进行某些操作。如果启用了堆外内存使用，则`spark.memory.offHeap.size`必须为正数。
`spark.memory.offHeap.size`	0	可用于堆外分配的绝对内存量（以字节为单位）。此设置对堆内存使用没有影响，因此如果执行程序的总内存消耗必须符合某些硬限制，那么请确保相应地缩小JVM堆大小。这必须设置为正值`spark.memory.offHeap.enabled=true`。
`spark.memory.useLegacyMode`	假	是否启用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`	假	为RDD块启用主动块复制。如果存在任何可用的副本，则会因执行程序故障而丢失缓存的RDD块副本。这会尝试将块的复制级别设置为初始编号。
`spark.cleaner.periodicGC.interval`	30分钟	控制触发垃圾回收的频率。仅当弱引用被垃圾收集时，此上下文清除程序才会触发清理。在具有大型驱动程序JVM的长时间运行的应用程序中，驱动程序上的内存压力很小，这可能偶尔发生或根本不发生。根本不清理可能会导致执行程序在一段时间后耗尽磁盘空间。
`spark.cleaner.referenceTracking`	真正	启用或禁用上下文清理。
`spark.cleaner.referenceTracking.blocking`	真正	控制清理线程是否应该阻止清除任务（除了由`spark.cleaner.referenceTracking.blocking.shuffle`Spark属性控制的shuffle）。
`spark.cleaner.referenceTracking.blocking.shuffle`	假	控制清理线程是否应阻止随机清理任务。
`spark.cleaner.referenceTracking.cleanCheckpoints`	假	控制是否在引用超出范围时清除检查点文件。

执行行为

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

联网

属性名称	默认	含义
`spark.rpc.message.maxSize`	128	“控制平面”通信中允许的最大消息大小（以MB为单位）; 通常仅适用于执行程序和驱动程序之间发送的映射输出大小信息。如果您正在运行具有数千个map和reduce任务的作业并查看有关RPC消息大小的消息，请增加此值。
`spark.blockManager.port`	（随机）	所有块管理器的端口都可以监听。它们存在于驱动程序和执行程序中。
`spark.driver.blockManager.port`	（spark.blockManager.port的值）	如果不能使用与执行程序相同的配置，则块管理器要侦听的特定于驱动程序的端口。
`spark.driver.bindAddress`	（spark.driver.host的值）	主机名或IP地址绑定侦听套接字的位置。此配置会覆盖SPARK_LOCAL_IP环境变量（请参见下文）。它还允许将与本地地址不同的地址通告给执行者或外部系统。例如，在运行具有桥接网络的容器时，这很有用。为了正常工作，需要从容器的主机转发驱动程序使用的不同端口（RPC，块管理器和UI）。
`spark.driver.host`	（本地主机名）	驱动程序的主机名或IP地址。这用于与执行程序和独立主服务器通信。
`spark.driver.port`	（随机）	用于侦听的驱动程序的端口。这用于与执行程序和独立主服务器通信。
`spark.network.timeout`	120秒	所有网络交互的默认超时。该配置将替代使用`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`	120秒	RPC远程端点查找操作在超时之前等待的持续时间。

调度

属性名称	默认	含义
`spark.cores.max`	（没有设置）	当一个上运行的独立的部署簇或在“粗粒度”共享模式Mesos簇，CPU核心的最大数量，以请求从跨集群（未从每个机）中的应用。如果未设置，则默认值将`spark.deploy.defaultCores`在Spark的独立集群管理器上，或者在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`	30多岁	在计划开始之前等待资源注册的最长时间。
`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`	1秒	调度程序恢复工作程序资源的间隔长度提供了运行任务。
`spark.scheduler.listenerbus.eventqueue.capacity`	10000	Spark侦听器总线中事件队列的容量必须大于0.如果侦听器事件被删除，请考虑增加值（例如20000）。增加此值可能会导致驱动程序使用更多内存。
`spark.blacklist.enabled`	假	如果设置为“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`	假	（实验）如果设置为“true”，则允许Spark在被列入黑名单时自动终止并尝试重新创建执行程序。请注意，当整个节点添加到黑名单时，该节点上的所有执行程序都将被终止。
`spark.blacklist.application.fetchFailure.enabled`	假	（实验）如果设置为“true”，Spark会在发生提取失败时立即将执行程序列入黑名单。如果启用了外部随机服务，则整个节点将被列入黑名单。
`spark.speculation`	假	如果设置为“true”，则执行任务的推测执行。这意味着如果一个或多个任务在一个阶段中运行缓慢，它们将被重新启动。
`spark.speculation.interval`	100毫秒	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`	假	允许监视已终止/中断的任务。设置为true时，执行程序将监视任何被杀死的任务，直到该任务实际完成执行。有关`spark.task.reaper.*`如何控制此监视的确切行为的详细信息，请参阅其他配置。设置为false（默认值）时，任务查杀将使用缺少此类监视的旧代码路径。
`spark.task.reaper.pollingInterval`	10S	何时`spark.task.reaper.enabled = true`，此设置控制执行程序轮询已终止任务状态的频率。如果在轮询时仍然运行被杀死的任务，则会记录警告，并且默认情况下将记录任务的线程转储（可以通过`spark.task.reaper.threadDump`设置禁用此线程转储，如下所述）。
`spark.task.reaper.threadDump`	真正	何时`spark.task.reaper.enabled = true`，此设置控制是否在定期轮询已终止任务期间记录任务线程转储。将此属性设置为false可禁用线程转储的收集。
`spark.task.reaper.killTimeout`	-1	何时`spark.task.reaper.enabled = true`，此设置指定超时，如果已终止的任务未停止运行，执行程序JVM将自行终止。默认值-1禁用此机制并阻止执行程序自毁。此设置的目的是充当安全网，以防止无法执行的无法执行的任务使执行程序无法使用。
`spark.stage.maxConsecutiveAttempts`	4	在中止阶段之前允许的连续阶段尝试次数。

动态分配

属性名称	默认	含义
`spark.dynamicAllocation.enabled`	假	是否使用动态资源分配，该分配根据工作负载上下调整使用此应用程序注册的执行程序的数量。有关更多详细信息，请参阅此处的说明。这需要`spark.shuffle.service.enabled`设置。下面的配置也与此有关： `spark.dynamicAllocation.minExecutors`，`spark.dynamicAllocation.maxExecutors`，和`spark.dynamicAllocation.initialExecutors`
`spark.dynamicAllocation.executorIdleTimeout`	60年代	如果启用了动态分配并且执行程序空闲时间超过此持续时间，则执行程序将被删除。有关更多详细信息，请参阅此说明。
`spark.dynamicAllocation.cachedExecutorIdleTimeout`	无穷	如果启用了动态分配并且具有高速缓存数据块的执行程序已空闲超过此持续时间，则将删除执行程序。有关更多详细信息，请参阅此说明。
`spark.dynamicAllocation.initialExecutors`	`spark.dynamicAllocation.minExecutors`	启用动态分配时要运行的初始执行程序数。如果设置了`--num-executors`（或`spark.executor.instances`）并且大于此值，它将被用作执行者的初始数量。
`spark.dynamicAllocation.maxExecutors`	无穷	启用动态分配时执行程序数的上限。
`spark.dynamicAllocation.minExecutors`	0	启用动态分配时执行程序数量的下限。
`spark.dynamicAllocation.schedulerBacklogTimeout`	1秒	如果启用了动态分配并且已有挂起的任务积压超过此持续时间，则将请求新的执行程序。有关更多详细信息，请参阅此说明。
`spark.dynamicAllocation.sustainedSchedulerBacklogTimeout`	`schedulerBacklogTimeout`	与之相同`spark.dynamicAllocation.schedulerBacklogTimeout`，但仅用于后续执行程序请求。有关更多详细信息，请参阅此说明。

安全

属性名称	默认	含义
`spark.acls.enable`	假	是否应该启用Spark acls。如果启用，则会检查用户是否具有查看或修改作业的访问权限。请注意，这需要知道用户，因此如果用户遇到null，则不会进行任何检查。可以使用过滤器对UI进行身份验证和设置用户。
`spark.admin.acls`	空	以逗号分隔的用户/管理员列表，可以查看和修改对所有Spark作业的访问权限。如果您在共享群集上运行并且有一组管理员或开发人员在事情不起作用时帮助调试，则可以使用此方法。在列表中加上“*”表示任何用户都可以拥有admin权限。
`spark.admin.acls.groups`	空	逗号分隔的组列表，具有查看和修改所有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`	假	Spark是否验证其内部连接。看看 `spark.authenticate.secret`是否没有在YARN上运行。
`spark.authenticate.secret`	没有	设置用于Spark的密钥以在组件之间进行身份验证。如果未在YARN上运行并且启用了身份验证，则需要设置此项。
`spark.network.crypto.enabled`	假	使用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`	真正	如果使用Spark的内部机制验证失败，是否回退到SASL身份验证。当应用程序连接到不支持内部Spark身份验证协议的旧shuffle服务时，这非常有用。在服务器端，这可用于阻止较旧的客户端对新的shuffle服务进行身份验证。
`spark.network.crypto.config.*`	没有	commons-crypto库的配置值，例如要使用的密码实现。配置名称应该是没有“commons.crypto”前缀的commons-crypto配置的名称。
`spark.authenticate.enableSaslEncryption`	假	启用身份验证时启用加密通信。块传输服务和RPC端点支持此功能。
`spark.network.sasl.serverAlwaysEncrypt`	假	为支持SASL身份验证的服务禁用未加密的连接。
`spark.core.connection.ack.wait.timeout`	`spark.network.timeout`	在超时和放弃之前连接等待ack的时间有多长。为避免因GC等长时间停顿而导致的不必要的超时，您可以设置更大的值。
`spark.modify.acls`	空	逗号分隔的用户列表，具有对Spark作业的修改权限。默认情况下，只有启动Spark作业的用户才有权修改它（例如，将其删除）。在列表中加上“*”表示任何用户都可以有权修改它。
`spark.modify.acls.groups`	空	逗号分隔的组列表，具有对Spark作业的修改权限。如果您有一组来自同一团队的管理员或开发人员有权控制该作业，则可以使用此方法。在列表中加上“*”表示任何组中的任何用户都有权修改Spark作业。用户组是从指定的组映射提供程序的实例获取的`spark.user.groups.mapping`。查看条目`spark.user.groups.mapping` 以获取更多详细信息。
`spark.ui.filters`	没有	逗号分隔的过滤器类名列表，以应用于Spark Web UI。过滤器应该是标准的 javax servlet过滤器。也可以通过设置java系统属性来指定每个过滤器的参数： `spark.<class name of filter>.params='param1=value1,param2=value2'` 例如： `-Dspark.ui.filters=com.test.filter1` `-Dspark.com.test.filter1.params='param1=foo,param2=testing'`
`spark.ui.view.acls`	空	逗号分隔的用户列表，具有对Spark Web ui的查看权限。默认情况下，只有启动Spark作业的用户才具有视图访问权限。在列表中加上“*”表示任何用户都可以拥有对此Spark作业的查看权限。
`spark.ui.view.acls.groups`	空	逗号分隔的组列表，具有对Spark Web ui的查看访问权限，以查看Spark作业详细信息。如果您有一组可以监视提交的Spark作业的管理员或开发人员或用户，则可以使用此方法。在列表中添加“*”表示任何组中的任何用户都可以在Spark Web ui上查看Spark作业详细信息。用户组是从指定的组映射提供程序的实例获取的`spark.user.groups.mapping`。查看条目`spark.user.groups.mapping`以获取更多详细信息。

TLS / SSL

属性名称	默认	含义
`spark.ssl.enabled`	假	是否在所有支持的协议上启用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`	没有	SSL服务将侦听的端口。必须在命名空间配置中定义端口; 请参阅可用命名空间的SSL配置。未设置时，SSL端口将从同一服务的非SSL端口派生。值“0”将使服务绑定到临时端口。
`spark.ssl.enabledAlgorithms`	空	以逗号分隔的密码列表。JVM必须支持指定的密码。可以在此页面上找到的协议参考列表。注意：如果未设置，它将使用JVM的默认密码套件。
`spark.ssl.keyPassword`	没有	密钥库中私钥的密码。
`spark.ssl.keyStore`	没有	密钥库文件的路径。该路径可以是启动组件的目录的绝对路径或相对路径。
`spark.ssl.keyStorePassword`	没有	密钥库的密码。
`spark.ssl.keyStoreType`	JKS	密钥库的类型。
`spark.ssl.protocol`	没有	协议名称。JVM必须支持该协议。可以在此页面上找到的协议参考列表。
`spark.ssl.needClientAuth`	假	如果SSL需要客户端验证，则设置为true
`spark.ssl.trustStore`	没有	信任存储文件的路径。该路径可以是启动组件的目录的绝对路径或相对路径。
`spark.ssl.trustStorePassword`	没有	信任存储区的密码。
`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

属性名称	默认	含义
`spark.streaming.backpressure.enabled`	假	启用或禁用Spark Streaming的内部背压机制（自1.5起）。这使Spark Streaming能够根据当前的批处理调度延迟和处理时间来控制接收速率，以便系统只接收系统可以处理的速度。在内部，这动态地设置接收器的最大接收速率。这个速率的上限取决于值`spark.streaming.receiver.maxRate`，`spark.streaming.kafka.maxRatePerPartition`如果设置了它们（见下文）。
`spark.streaming.backpressure.initialRate`	没有设置	这是启用背压机制时每个接收器将接收第一批数据的初始最大接收速率。
`spark.streaming.blockInterval`	200毫秒	Spark Streaming接收器接收的数据在存储到Spark之前被分块为数据块的时间间隔。建议最低 - 50毫秒。有关更多详细信息，请参阅Spark Streaming编程指南中的性能调整部分。
`spark.streaming.receiver.maxRate`	没有设置	每个接收器将接收数据的最大速率（每秒记录数）。实际上，每个流每秒最多将消耗此数量的记录。将此配置设置为0或负数将不会对速率进行限制。有关模式详细信息，请参阅Spark Streaming编程指南中的部署指南。
`spark.streaming.receiver.writeAheadLog.enable`	假	启用接收器的预写日志。通过接收器接收的所有输入数据将被保存到提前写入日志，以便在驱动程序失败后恢复。有关更多详细信息，请参阅Spark Streaming编程指南中的部署指南。
`spark.streaming.unpersist`	真正	Spark Streaming生成并持久化的强制RDD将自动从Spark的内存中取消。Spark Streaming接收的原始输入数据也会自动清除。将此设置为false将允许原始数据和持久RDD在流应用程序外部可访问，因为它们不会自动清除。但它的代价是Spark中更高的内存使用量。
`spark.streaming.stopGracefullyOnShutdown`	假	如果`true`，Spark `StreamingContext`在JVM关闭时优先关闭而不是立即关闭。
`spark.streaming.kafka.maxRatePerPartition`	没有设置	使用新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`	假	是否在驱动程序上写入提前写入日志记录后关闭文件。如果要将S3（或任何不支持刷新的文件系统）用于驱动程序上的元数据WAL，请将此项设置为“true”。
`spark.streaming.receiver.writeAheadLog.closeFileAfterWrite`	假	是否在接收器上写入写入日志记录后关闭文件。如果要将S3（或任何不支持刷新的文件系统）用于接收器上的数据WAL，请将此设置为“true”。

SparkR

属性名称	默认	含义
`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`，但优先于它。用于运行R脚本的`spark.r.shell.command`sparkR shell `spark.r.driver.command`。
`spark.r.backendConnectionTimeout`	6000	R进程在几秒钟内连接到RBackend时设置的连接超时。
`spark.r.heartBeatInterval`	100	从SparkR后端发送到R进程的心跳间隔，以防止连接超时。

GraphX

属性名称	默认	含义
`spark.graphx.pregel.checkpointInterval`	-1	Pregel中图形和消息的检查点间隔。它用于避免stackOverflowError，因为在经过大量迭代后，由于长谱系链。默认情况下禁用检查点。

部署

属性名称	默认	含义
`spark.deploy.recoveryMode`	没有	恢复模式设置，用于在失败并重新启动时使用群集模式恢复提交的Spark作业。这仅适用于使用Standalone或Mesos运行时的群集模式。
`spark.deploy.zookeeper.url`	没有	当`spark.deploy.recoveryMode`设置为ZOOKEEPER时，此配置用于设置要连接的zookeeper URL。
`spark.deploy.zookeeper.dir`	没有	当`spark.deploy.recoveryMode`设置为ZOOKEEPER时，此配置用于将zookeeper目录设置为存储恢复状态。

集群管理器

Spark中的每个集群管理器都有其他配置选项。可以在每种模式的页面上找到配置：

YARN

Mesos

Kubernetes

独立模式

环境变量

某些Spark设置可以通过环境变量进行配置，这些变量是从conf/spark-env.sh安装Spark的目录（或conf/spark-env.cmdWindows）中的脚本中读取的。在Standalone和Mesos模式下，此文件可以提供机器特定信息，例如主机名。它还在运行本地Spark应用程序或提交脚本时获取。

请注意，conf/spark-env.sh安装Spark时默认情况下不存在。但是，您可以复制conf/spark-env.sh.template以创建它。确保使副本可执行。

可以在以下位置设置以下变量spark-env.sh：

环境变量	含义
`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脚本，因此可以通过编程方式设置其中一些脚本 - 例如，您可以SPARK_LOCAL_IP通过查找特定网络接口的IP来进行计算。

注意：在cluster模式下在YARN上运行Spark时，需要使用文件中的spark.yarn.appMasterEnv.[EnvironmentVariableName]属性设置环境变量conf/spark-defaults.conf。设置的环境变量spark-env.sh不会在cluster模式下的YARN Application Master进程中反映出来。有关更多信息，请参阅与YARN相关的Spark属性。

配置日志记录

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

覆盖配置目录

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

继承Hadoop集群配置

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

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

这些配置文件的位置因Hadoop版本而异，但是内部有一个共同的位置/etc/hadoop/conf。有些工具可以即时创建配置，但提供了下载它们副本的机制。

为了使这些文件可见星火，设置HADOOP_CONF_DIR在$SPARK_HOME/conf/spark-env.sh 包含配置文件的位置。

自定义Hadoop / Hive配置

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

多个正在运行的应用程序可能需要不同的Hadoop / Hive客户端配置。您可以复制和修改hdfs-site.xml，core-site.xml，yarn-site.xml，hive-site.xmlSpark中的类路径中为每个应用程序。在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