Spark Configuration Guide

梦里梦外; 2023-06-19 02:00 16阅读 0赞

**Table of Contents**

Spark Properties

动态加载配置

查看 spark 配置

可用的属性

Application Properties

Runtime Environment

Shuffle Behavior

Spark UI

Compression and Serialization

Memory Management

Execution Behavior

Networking

Scheduling

Dynamic Allocation

Security

Encryption

Spark SQL

Spark Streaming

SparkR

Deploy

集群管理

环境变量

日志配置

重写配置文件

继承 Hadoop 集群配置

--------------------

# Spark Properties #

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

> 注意，我们使用本地\[2\]运行，这意味着两个线程，表示“最小”并行性，这有助于检测只有在分布式上下文中运行时才存在的bug。

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

指定某个持续时间的属性应该配置为时间单位。接受下列格式：

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)

## 动态加载配置 ##

在某些情况下，可能希望避免在 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 还将从 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

作为标志或在属性文件中指定的任何值都将传递给应用程序，并与通过 SparkConf 指定的值合并。直接在 SparkConf 上设置的属性具有最高的优先级，然后将标志传递给 spark-submit 或 spark-shell，然后传递给 spark-default .conf 文件中的选项。

## 查看 spark 配置 ##

http://<driver>:4040 的应用程序 web UI 在“Environment”选项卡中列出了 Spark 属性。注意，只有通过 spark-defaults 显式指定的值。将出现conf、SparkConf或命令行。对于所有其他配置属性，可以假设使用默认值。

## 可用的属性 ##

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

### Application Properties ###

<table> 
 <tbody> 
  <tr> 
   <th style="width:205.5px;">Property Name</th> 
   <th style="width:1px;">Default</th> 
   <th>Meaning</th> 
  </tr> 
  <tr> 
   <td style="width:205.5px;"><code>spark.app.name</code></td> 
   <td style="width:1px;">(none)</td> 
   <td>应用程序的名称。这将出现在UI和日志数据中。</td> 
  </tr> 
  <tr> 
   <td style="width:205.5px;"><code>spark.driver.cores</code></td> 
   <td style="width:1px;">1</td> 
   <td>driver 程序使用的 core 的数量，仅限于集群模式下</td> 
  </tr> 
  <tr> 
   <td style="width:205.5px;"><code>spark.driver.maxResultSize</code></td> 
   <td style="width:1px;">1g</td> 
   <td> <p>&nbsp;</p> <p>Spark action 的所有分区的序列化结果的总大小限制。最少 1M 或者 0 表示无限大小。如果总大小超过这个大小，作业将被停止。值过大可能会导致 OOM。应该根据 JVM 对象的内存开销适当的配置。</p> </td> 
  </tr> 
  <tr> 
   <td style="width:205.5px;"><code>spark.driver.memory</code></td> 
   <td style="width:1px;">1g</td> 
   <td>用于驱动程序进程的内存量，即在何处初始化 SparkContext。(例如1 g, 2 g)。<br> 注意:在客户端模式下，不能通过应用程序中的 SparkConf 直接设置此配置，因为<span style="color:#f33b45;">此时驱动程序 JVM 已经启动</span>。相反，请通过 --driver-memory 命令行选项或在默认属性文件中设置。</td> 
  </tr> 
  <tr> 
   <td style="width:205.5px;"><code>spark.executor.memory</code></td> 
   <td style="width:1px;">1g</td> 
   <td>每个执行器进程要使用的内存量(例如2g、8g)。</td> 
  </tr> 
  <tr> 
   <td style="width:205.5px;"><code>spark.extraListeners</code></td> 
   <td style="width:1px;">(none)</td> 
   <td>实现 SparkListener 的类的逗号分隔列表；在初始化 SparkContext 时，这些类的实例将被创建并注册到 Spark 的侦听器总线中。如果一个类有一个接受 SparkConf 的单参数构造函数，那么这个构造函数将被调用；否则，将调用零参数构造函数。如果找不到有效的构造函数，则创建 SparkContext 将失败，并出现异常。</td> 
  </tr> 
  <tr> 
   <td style="width:205.5px;"><code>spark.local.dir</code></td> 
   <td style="width:1px;">/tmp</td> 
   <td>spark 缓存目录，用于存储输出文件和存储在磁盘的 rdd，在系统的本地磁盘，也可以是多个目录，以逗号分隔。注意:在Spark 1.0或更高版本中，集群管理器设置的SPARK_LOCAL_DIRS(Standalone、Mesos)或LOCAL_DIRS(yarn)环境变量将覆盖此变量。</td> 
  </tr> 
  <tr> 
   <td style="width:205.5px;"><code>spark.logConf</code></td> 
   <td style="width:1px;">false</td> 
   <td> <p>sparkcontext 启动之后，sparkconf 以 info 日志级别打印</p> </td> 
  </tr> 
  <tr> 
   <td style="width:205.5px;"><code>spark.master</code></td> 
   <td style="width:1px;">(none)</td> 
   <td><code>local，local[K]，local[*]，mesos://HOST:PORT，spark://HOST:PORT，yarn</code></td> 
  </tr> 
  <tr> 
   <td style="width:205.5px;"><code>spark.submit.deployMode</code></td> 
   <td style="width:1px;">(none)</td> 
   <td>"client" or "cluster"</td> 
  </tr> 
 </tbody> 
</table>

### Runtime Environment ###

<table> 
 <tbody> 
  <tr> 
   <th style="width:237px;">Property Name</th> 
   <th style="width:43px;">Default</th> 
   <th>Meaning</th> 
  </tr> 
  <tr> 
   <td style="width:237px;"><code>spark.driver.extraClassPath</code></td> 
   <td style="width:43px;">(none)</td> 
   <td>在驱动程序的类路径之前添加额外的类路径条目。<br> 注意:在客户端模式下，不能通过应用程序中的SparkConf直接设置此配置，因为此时驱动程序JVM已经启动。相反，应该使用 --driver-class-path命令行选项或在默认属性文件中设置它。</td> 
  </tr> 
  <tr> 
   <td style="width:237px;"><code>spark.driver.extraJavaOptions</code></td> 
   <td style="width:43px;">(none)</td> 
   <td> <p>传递给驱动程序的一串额外的JVM选项。例如，GC设置或其他日志记录。注意，使用此选项设置最大堆大小(-Xmx)是非法的。集群模式使用 spark.dirver.memory，客户端使用 --driver-memory</p> <p>注意：在客户端模式下，不能通过应用程序中的 SparkConf 直接设置此配置，因为此时驱动程序 JVM 已经启动。相反，请通过 --driver-java-options命令行选项或在您的默认选项中设置此选项</p> </td> 
  </tr> 
  <tr> 
   <td style="width:237px;"><code>spark.driver.extraLibraryPath</code></td> 
   <td style="width:43px;">(none)</td> 
   <td>设置在启动驱动程序 JVM 时使用的特殊库路径。<br> 注意:在客户端模式下，不能通过应用程序中的 SparkConf 直接设置此配置，因为此时驱动程序JVM已经启动。相反，请通过 --driver-library-path命令行选项或在默认属性文件中设置。</td> 
  </tr> 
  <tr> 
   <td style="width:237px;"><code>spark.driver.userClassPathFirst</code></td> 
   <td style="width:43px;">false</td> 
   <td>(实验性的)在驱动程序中加载类时，是否让用户添加的jar优先于Spark自己的jar。此功能可用于缓解Spark依赖项和用户依赖项之间的冲突。它目前是一个实验性的功能。这仅在集群模式下使用。</td> 
  </tr> 
  <tr> 
   <td style="width:237px;"><code>spark.executor.extraClassPath</code></td> 
   <td style="width:43px;">(none)</td> 
   <td>在 executor 的类路径之前添加额外的类路径条目。这主要是为了向后兼容旧版本的 Spark。用户通常不需要设置此选项。</td> 
  </tr> 
  <tr> 
   <td style="width:237px;"><code>spark.executor.extraJavaOptions</code></td> 
   <td style="width:43px;">(none)</td> 
   <td>传递给 executer 的一串额外的 JVM 选项。例如，GC 设置或其他日志记录。注意，使用此选项设置 Spark 属性或最大堆大小(-Xmx)设置是非法的。应该使用 SparkConf 对象或与 Spark -submit 脚本一起使用的 spark-defaults.conf 文件设置 Spark 属性。可以使用 spark.executor.memory 设置最大堆大小。</td> 
  </tr> 
  <tr> 
   <td style="width:237px;"><code>spark.executor.extraLibraryPath</code></td> 
   <td style="width:43px;">(none)</td> 
   <td>设置在启动 executor JVM 时使用的特殊库路径。</td> 
  </tr> 
  <tr> 
   <td style="width:237px;"><code>spark.executor.logs.rolling.maxRetainedFiles</code></td> 
   <td style="width:43px;">(none)</td> 
   <td>设置系统将保留的最新滚动日志文件的数量。旧的日志文件将被删除。默认情况下禁用。</td> 
  </tr> 
  <tr> 
   <td style="width:237px;"><code>spark.executor.logs.rolling.enableCompression</code></td> 
   <td style="width:43px;">false</td> 
   <td>启用执行程序日志压缩。如果启用了此选项，则将压缩已滚动的执行器日志。默认情况下禁用。</td> 
  </tr> 
  <tr> 
   <td style="width:237px;"><code>spark.executor.logs.rolling.maxSize</code></td> 
   <td style="width:43px;">(none)</td> 
   <td>executer log 文件的最大大小，默认关闭。<code>spark.executor.logs.rolling.maxRetainedFiles 用于自动清除日志</code></td> 
  </tr> 
  <tr> 
   <td style="width:237px;"><code>spark.executor.logs.rolling.strategy</code></td> 
   <td style="width:43px;">(none)</td> 
   <td>设定执行器日志的滚动策略。默认情况下它是禁用的。它可以设置为“时间”(基于时间的滚动)或“大小”(基于大小的滚动)。对于“时间”，使用spark.executor.logs.rolling.time.interval 设置滚动间隔。对于“大小”，使用spark.executor.logs.rolling.<code>maxRetainedFiles&nbsp;</code>设置滚动的最大文件大小。</td> 
  </tr> 
  <tr> 
   <td style="width:237px;"><code>spark.executor.logs.rolling.time.interval</code></td> 
   <td style="width:43px;">daily</td> 
   <td>设置将滚动执行程序日志的时间间隔。默认情况下禁用滚动。有效值为&nbsp;<code>daily</code>, <code>hourly</code>, <code>minutely 或以秒为单位的任意间隔。spark.executor.logs.rolling.maxRetainedFiles 用于自动清除旧日志</code></td> 
  </tr> 
  <tr> 
   <td style="width:237px;"><code>spark.executor.userClassPathFirst</code></td> 
   <td style="width:43px;">false</td> 
   <td><code>与 spark.driver.userClassPathFirst 相同，但是只用于 executer 实例</code></td> 
  </tr> 
  <tr> 
   <td style="width:237px;"><code>spark.executorEnv.[EnvironmentVariableName]</code></td> 
   <td style="width:43px;">(none)</td> 
   <td>将由 EnvironmentVariableName 指定的环境变量添加到 executer 进程。用户可以指定多个这样的变量来设置多个环境变量。</td> 
  </tr> 
  <tr> 
   <td style="width:237px;"><code>spark.python.profile</code></td> 
   <td style="width:43px;">false</td> 
   <td>在Python工作程序中启用概要分析，概要结果将由sc.show_profiles()显示，或者在驱动程序退出之前显示。它还可以通过sc.dump_profiles(路径)转储到磁盘。如果一些配置文件结果是手动显示的，在驱动程序退出之前，它们不会自动显示。默认使用&nbsp;<code>pyspark.profiler.BasicProfiler，</code>但是可以通过将分析器类作为参数传递给SparkContext构造函数来覆盖它。</td> 
  </tr> 
  <tr> 
   <td style="width:237px;"><code>spark.python.profile.dump</code></td> 
   <td style="width:43px;">(none)</td> 
   <td>用于在驱动程序退出之前转储配置文件结果的目录。结果将作为每个RDD的独立文件转储。它们可以由ptats.Stats()加载。如果指定了此选项，配置文件结果将不会自动显示。</td> 
  </tr> 
  <tr> 
   <td style="width:237px;"><code>spark.python.worker.memory</code></td> 
   <td style="width:43px;">512m</td> 
   <td>每个python工作进程在聚合期间使用的内存量，其格式与JVM内存字符串相同(如512m、2g)。如果聚合期间使用的内存超过这个数量，就会将数据溢出到磁盘中。</td> 
  </tr> 
  <tr> 
   <td style="width:237px;"><code>spark.python.worker.reuse</code></td> 
   <td style="width:43px;">true</td> 
   <td>是否重用 Python worker。如果是，它将使用固定数量的Python worker，不需要为每个任务 fork()一个Python进程。如果存在大型广播，那么将不需要为每个任务将广播从JVM传输到Python worker</td> 
  </tr> 
  <tr> 
   <td style="width:237px;"><code>spark.files</code></td> 
   <td style="width:43px;">&nbsp;</td> 
   <td>要放置在每个执行程序的工作目录中的文件的逗号分隔列表。</td> 
  </tr> 
  <tr> 
   <td style="width:237px;"><code>spark.submit.pyFiles</code></td> 
   <td style="width:43px;">&nbsp;</td> 
   <td>以逗号分隔的.zip、.egg或.py文件列表，可放置在 Python 应用程序的 PYTHONPATH 上。</td> 
  </tr> 
  <tr> 
   <td style="width:237px;"><code>spark.jars</code></td> 
   <td style="width:43px;">&nbsp;</td> 
   <td>以逗号分隔的本地 jar 列表，包括在驱动程序和执行程序类路径上。</td> 
  </tr> 
  <tr> 
   <td style="width:237px;"><code>spark.jars.packages</code></td> 
   <td style="width:43px;">&nbsp;</td> 
   <td>包含在驱动程序和执行程序类路径上的jar的 maven 坐标列表(以逗号分隔)。将搜索本地 maven repo，然后是 maven central 和 spark.jar .ivy 提供的任何其他远程存储库。坐标的格式应该是groupId:artifactId:version。</td> 
  </tr> 
  <tr> 
   <td style="width:237px;"><code>spark.jars.excludes</code></td> 
   <td style="width:43px;">&nbsp;</td> 
   <td>用逗号分隔的 groupId:artifactId，用于在解析 spark.jar 中提供的依赖项时排除包以避免依赖冲突。</td> 
  </tr> 
  <tr> 
   <td style="width:237px;"><code>spark.jars.ivy</code></td> 
   <td style="width:43px;">&nbsp;</td> 
   <td>逗号分隔的附加远程存储库列表，用于搜索 spark.jar.packages 提供的坐标。</td> 
  </tr> 
  <tr> 
   <td style="width:237px;"><code>spark.pyspark.driver.python</code></td> 
   <td style="width:43px;">&nbsp;</td> 
   <td>Python 二进制可执行文件，用于驱动程序中的PySpark。(默认为 spark.pyspark.python)</td> 
  </tr> 
  <tr> 
   <td style="width:237px;"><code>spark.pyspark.python</code></td> 
   <td style="width:43px;">&nbsp;</td> 
   <td>Python 二进制可执行文件，用于驱动程序和执行程序中的 PySpark。</td> 
  </tr> 
 </tbody> 
</table>

### Shuffle Behavior ###

<table> 
 <tbody> 
  <tr> 
   <th style="width:289px;">Property Name</th> 
   <th style="width:66px;">Default</th> 
   <th>Meaning</th> 
  </tr> 
  <tr> 
   <td style="width:289px;"><code>spark.reducer.maxSizeInFlight</code></td> 
   <td style="width:66px;">48m</td> 
   <td>要同时从每个 reduce 任务获取的映射输出的最大大小。由于每个输出都要求我们创建一个缓冲区来接收它，这表示每个 reduce 任务有固定的内存开销，因此，除非您有大量的内存，否则请保持较小的内存开销。</td> 
  </tr> 
  <tr> 
   <td style="width:289px;"><code>spark.reducer.maxReqsInFlight</code></td> 
   <td style="width:66px;">Int.MaxValue</td> 
   <td>这种配置限制了在任何给定点获取块的远程请求的数量。当集群中的主机数量增加时，可能会导致到一个或多个节点的大量内接连接，导致 worker 在负载下失败。通过允许它限制获取请求的数量，可以缓解这种情况。</td> 
  </tr> 
  <tr> 
   <td style="width:289px;"><code>spark.shuffle.compress</code></td> 
   <td style="width:66px;">true</td> 
   <td>是否压缩映射输出文件。压缩将使用 spark.io.compression.codec。</td> 
  </tr> 
  <tr> 
   <td style="width:289px;"><code>spark.shuffle.file.buffer</code></td> 
   <td style="width:66px;">32k</td> 
   <td>每个 shuffle 文件输出流的内存缓冲区大小。这些缓冲区减少了在创建中间 shuffle 文件时进行的磁盘查找和系统调用的数量。</td> 
  </tr> 
  <tr> 
   <td style="width:289px;"><code>spark.shuffle.io.maxRetries</code></td> 
   <td style="width:66px;">3</td> 
   <td>如果设置为非零值，则由于与io相关的异常而失败的获取将自动重试。这种重试逻辑有助于在面对长时间 GC 暂停或瞬态网络连接问题时的稳定</td> 
  </tr> 
  <tr> 
   <td style="width:289px;"><code>spark.shuffle.io.numConnectionsPerPeer</code></td> 
   <td style="width:66px;">1</td> 
   <td>(Netty only)主机之间的连接被重用，以减少大型集群的连接累积。对于拥有大量硬盘和少量主机的集群，这可能导致并发性不足，无法满足所有磁盘，因此用户可以考虑增加这个值。</td> 
  </tr> 
  <tr> 
   <td style="width:289px;"><code>spark.shuffle.io.preferDirectBufs</code></td> 
   <td style="width:66px;">true</td> 
   <td>(Netty only)堆外缓冲区用于减少垃圾收集期间 shuffle 和缓存块转移。对于堆外内存受到严格限制的环境，用户可能希望关闭这个选项，以强制所有Netty分配到堆上。</td> 
  </tr> 
  <tr> 
   <td style="width:289px;"><code>spark.shuffle.io.retryWait</code></td> 
   <td style="width:66px;">5s</td> 
   <td>多长时间等待重试之间的fetches。默认情况下，重试导致的最大延迟为15秒，计算方法为maxRetries * retryWait。</td> 
  </tr> 
  <tr> 
   <td style="width:289px;"><code>spark.shuffle.service.enabled</code></td> 
   <td style="width:66px;">false</td> 
   <td>启用外部洗牌服务。该服务保留了执行人编写的 shuffle 文件，因此可以安全地删除执行人。如果&nbsp;<code>spark.dynamicAllocation.enabled 为 true，则必须启用此选项。</code>必须设置外部洗牌服务才能启用它</td> 
  </tr> 
  <tr> 
   <td style="width:289px;"><code>spark.shuffle.service.port</code></td> 
   <td style="width:66px;">7337</td> 
   <td>外部 shuffle 服务将在其上运行的端口。</td> 
  </tr> 
  <tr> 
   <td style="width:289px;"><code>spark.shuffle.service.index.cache.entries</code></td> 
   <td style="width:66px;">1024</td> 
   <td>保留在 shuffle 服务的索引缓存中的最大条目数。</td> 
  </tr> 
  <tr> 
   <td style="width:289px;"><code>spark.shuffle.sort.bypassMergeThreshold</code></td> 
   <td style="width:66px;">200</td> 
   <td>(Advanced) 在基于排序的 shuffle manager 中，如果没有 mao 端聚合，并且最多有这么多 reduce 分区，则应避免合并排序数据。</td> 
  </tr> 
  <tr> 
   <td style="width:289px;"><code>spark.shuffle.spill.compress</code></td> 
   <td style="width:66px;">true</td> 
   <td>是否压缩 shuffle 过程中溢出的数据。压缩将使用spark.io.compression.codec。</td> 
  </tr> 
  <tr> 
   <td style="width:289px;"><code>spark.io.encryption.enabled</code></td> 
   <td style="width:66px;">false</td> 
   <td>使IO加密。目前支持所有模式，除了 Mesos。建议在使用此功能时启用 RPC 加密。</td> 
  </tr> 
  <tr> 
   <td style="width:289px;"><code>spark.io.encryption.keySizeBits</code></td> 
   <td style="width:66px;">128</td> 
   <td>IO 加密密钥的大小(以位为单位)。支持的值是128、192和256。</td> 
  </tr> 
  <tr> 
   <td style="width:289px;"><code>spark.io.encryption.keygen.algorithm</code></td> 
   <td style="width:66px;">HmacSHA1</td> 
   <td>生成 IO 加密密钥时使用的算法。所支持的算法在 Java 密码体系结构标准算法名称文档的密钥生成器部分进行了描述。</td> 
  </tr> 
 </tbody> 
</table>

### Spark UI ###

<table> 
 <tbody> 
  <tr> 
   <th style="width:271px;">Property Name</th> 
   <th style="width:86px;">Default</th> 
   <th>Meaning</th> 
  </tr> 
  <tr> 
   <td style="width:271px;"><code>spark.eventLog.compress</code></td> 
   <td style="width:86px;">false</td> 
   <td>是否压缩已记录的事件，前提&nbsp;<code>spark.eventLog.enabled</code> is true.</td> 
  </tr> 
  <tr> 
   <td style="width:271px;"><code>spark.eventLog.dir</code></td> 
   <td style="width:86px;">file:///tmp/spark-events</td> 
   <td>记录 Spark 事件的基本目录，前提 <code>spark.eventLog.enabled</code> is true。在这个基本目录中，Spark 为每个应用程序创建一个子目录，并记录特定于此目录中的应用程序的事件。用户可能希望将其设置为一个统一的位置，如 HDFS 目录，以便历史记录服务器可以读取历史文件。</td> 
  </tr> 
  <tr> 
   <td style="width:271px;"><code>spark.eventLog.enabled</code></td> 
   <td style="width:86px;">false</td> 
   <td>是否记录 Spark 事件，这对于在应用程序完成后重建 Web UI 非常有用。</td> 
  </tr> 
  <tr> 
   <td style="width:271px;"><code>spark.ui.enabled</code></td> 
   <td style="width:86px;">true</td> 
   <td>是否为Spark应用程序运行web UI。</td> 
  </tr> 
  <tr> 
   <td style="width:271px;"><code>spark.ui.killEnabled</code></td> 
   <td style="width:86px;">true</td> 
   <td>允许从web UI杀死 job 和 stage。</td> 
  </tr> 
  <tr> 
   <td style="width:271px;"><code>spark.ui.port</code></td> 
   <td style="width:86px;">4040</td> 
   <td>应用程序仪表板的端口，它显示内存和工作负载数据。</td> 
  </tr> 
  <tr> 
   <td style="width:271px;"><code>spark.ui.retainedJobs</code></td> 
   <td style="width:86px;">1000</td> 
   <td>在垃圾收集之前，Spark UI和状态api记住了多少 job?</td> 
  </tr> 
  <tr> 
   <td style="width:271px;"><code>spark.ui.retainedStages</code></td> 
   <td style="width:86px;">1000</td> 
   <td>在垃圾收集之前，Spark UI和状态api要记住多少个&nbsp; stage?</td> 
  </tr> 
  <tr> 
   <td style="width:271px;"><code>spark.ui.retainedTasks</code></td> 
   <td style="width:86px;">100000</td> 
   <td>在垃圾收集之前，Spark UI和状态api记住了多少 task。</td> 
  </tr> 
  <tr> 
   <td style="width:271px;"><code>spark.ui.reverseProxy</code></td> 
   <td style="width:86px;">false</td> 
   <td>启用正在运行的Spark Master作为worker和应用程序ui的反向代理。在此模式下，Spark master将反向代理worker和应用程序ui，以启用访问，而不需要直接访问它们的主机。请谨慎使用，因为worker和应用程序UI不能直接访问，您只能通过spark master/proxy公共URL访问它们。此设置影响集群中运行的所有worker和应用程序ui，<span style="color:#f33b45;">必须在所有worker、驱动程序和主机上设置此设置。</span></td> 
  </tr> 
  <tr> 
   <td style="width:271px;"><code>spark.ui.reverseProxyUrl</code></td> 
   <td style="width:86px;">&nbsp;</td> 
   <td>这是您的代理正在运行的URL。</td> 
  </tr> 
  <tr> 
   <td style="width:271px;"><code>spark.worker.ui.retainedExecutors</code></td> 
   <td style="width:86px;">1000</td> 
   <td>在垃圾收集之前，记录有多少完成执行的Spark UI和状态api。</td> 
  </tr> 
  <tr> 
   <td style="width:271px;"><code>spark.worker.ui.retainedDrivers</code></td> 
   <td style="width:86px;">1000</td> 
   <td>在垃圾收集之前，Spark UI和状态api记住了多少已完成的 driver?</td> 
  </tr> 
  <tr> 
   <td style="width:271px;"><code>spark.sql.ui.retainedExecutions</code></td> 
   <td style="width:86px;">1000</td> 
   <td>在垃圾收集之前，Spark UI和状态api记得执行了多少次。</td> 
  </tr> 
  <tr> 
   <td style="width:271px;"><code>spark.streaming.ui.retainedBatches</code></td> 
   <td style="width:86px;">1000</td> 
   <td>在垃圾收集之前，Spark UI和状态api 记住了多少个已完成的批。</td> 
  </tr> 
  <tr> 
   <td style="width:271px;"><code>spark.ui.retainedDeadExecutors</code></td> 
   <td style="width:86px;">100</td> 
   <td>在垃圾收集之前，记录有多少死的执行器 Spark UI 和状态 api。</td> 
  </tr> 
 </tbody> 
</table>

### Compression and Serialization ###

<table> 
 <tbody> 
  <tr> 
   <th style="width:336px;">Property Name</th> 
   <th style="width:82px;">Default</th> 
   <th style="width:510px;">Meaning</th> 
  </tr> 
  <tr> 
   <td style="width:336px;"><code>spark.broadcast.compress</code></td> 
   <td style="width:82px;">true</td> 
   <td style="width:510px;">是否在发送广播变量之前压缩它们。</td> 
  </tr> 
  <tr> 
   <td style="width:336px;"><code>spark.io.compression.codec</code></td> 
   <td style="width:82px;">lz4</td> 
   <td style="width:510px;">用于压缩内部数据(如RDD分区、广播变量和 shuffle 输出)的编解码器。默认情况下，Spark提供三个编解码器:lz4、lzf和snappy。您还可以使用完全限定的类名来指定编解码器，例如org.apache.spark.io。LZ4CompressionCodec org.apache.spark.io。LZFCompressionCodec, org.apache.spark.io.SnappyCompressionCodec。</td> 
  </tr> 
  <tr> 
   <td style="width:336px;"><code>spark.io.compression.lz4.blockSize</code></td> 
   <td style="width:82px;">32k</td> 
   <td style="width:510px;">块大小用于 LZ4 压缩，在使用 LZ4 压缩编解码器的情况下。当使用LZ4 时，降低这个块的大小也会降低 shuffle 内存的使用。</td> 
  </tr> 
  <tr> 
   <td style="width:336px;"><code>spark.io.compression.snappy.blockSize</code></td> 
   <td style="width:82px;">32k</td> 
   <td style="width:510px;">块大小在 Snappy 压缩中使用，在使用 Snappy 压缩编解码器的情况下。当使用Snappy时，降低这个块的大小也会降低 shuffle 内存的使用。</td> 
  </tr> 
  <tr> 
   <td style="width:336px;"><code>spark.kryo.classesToRegister</code></td> 
   <td style="width:82px;">(none)</td> 
   <td style="width:510px;">如果使用 Kryo 序列化，请提供一个以逗号分隔的自定义类名列表，以便向 Kryo 注册。</td> 
  </tr> 
  <tr> 
   <td style="width:336px;"><code>spark.kryo.referenceTracking</code></td> 
   <td style="width:82px;">true</td> 
   <td style="width:510px;">在使用 Kryo 序列化数据时是否跟踪对同一对象的引用，如果对象图有循环，这是必要的，如果它们包含同一对象的多个副本，这对提高效率是有用的。<span style="color:#f33b45;">如果您知道情况并非如此，可以禁用它来提高性能。</span></td> 
  </tr> 
  <tr> 
   <td style="width:336px;"><code>spark.kryo.registrationRequired</code></td> 
   <td style="width:82px;">false</td> 
   <td style="width:510px;">是否需要注册Kryo。如果设置为“true”，那么在序列化未注册的类时，Kryo 将抛出一个异常。如果设置为false(默认值)，Kryo 将在每个对象中写入未注册的类名。编写类名可能会导致的性能开销变大，因此启用此选项可以严格执行用户没有从注册中遗漏类。</td> 
  </tr> 
  <tr> 
   <td style="width:336px;"><code>spark.kryo.registrator</code></td> 
   <td style="width:82px;">(none)</td> 
   <td style="width:510px;">如果使用 Kryo 序列化，请提供一个用逗号分隔的类列表，这些类向 Kryo 注册自定义类。如果您需要以自定义方式注册类，例如指定自定义字段序列化器，则此属性非常有用。<span style="color:#f33b45;">除此之外，spark.kryo.classesToRegister 更简单。</span>它应该被设置为扩展KryoRegistrator的类。</td> 
  </tr> 
  <tr> 
   <td style="width:336px;"><code>spark.kryo.unsafe</code></td> 
   <td style="width:82px;">false</td> 
   <td style="width:510px;">是否使用基于不安全的 Kryo 序列化器。使用不安全的IO可以大大加快速度。</td> 
  </tr> 
  <tr> 
   <td style="width:336px;"><code>spark.kryoserializer.buffer.max</code></td> 
   <td style="width:82px;">64m</td> 
   <td style="width:510px;">Kryo 序列化缓冲区的最大允许大小。它必须比您试图序列化的任何对象都大。<span style="color:#f33b45;">如果在 Kryo 中出现“缓冲区超出限制”异常，请增加这个值。</span></td> 
  </tr> 
  <tr> 
   <td style="width:336px;"><code>spark.kryoserializer.buffer</code></td> 
   <td style="width:82px;">64k</td> 
   <td style="width:510px;">Kryo 的序列化缓冲区的初始大小。注意，每个 worker 上的每个内核都有一个缓冲区。如果需要，这个缓冲区将生成 spark. kryoseriizer .buffer.max。</td> 
  </tr> 
  <tr> 
   <td style="width:336px;"><code>spark.rdd.compress</code></td> 
   <td style="width:82px;">false</td> 
   <td style="width:510px;">是否压缩序列化的RDD分区(e.g. for <code>StorageLevel.MEMORY_ONLY_SER</code> in Java and Scala or <code>StorageLevel.MEMORY_ONLY</code> in Python)。可以节省大量的空间，但要付出一些额外的CPU时间。</td> 
  </tr> 
  <tr> 
   <td style="width:336px;"><code>spark.serializer</code></td> 
   <td style="width:82px;">org.apache.spark.serializer.<br> JavaSerializer</td> 
   <td style="width:510px;">类用于序列化将通过网络发送或需要以序列化形式缓存的对象。 Java 序列化的默认值适用于任何可序列化的 Java 对象，但是速度很慢，因此我们建议使用 org.apache.spark.serializer.KryoSerializer 和配置 Kryo 序列化时，速度是必要的。可以是org.apache.spark.Serializer 的任何子类。</td> 
  </tr> 
  <tr> 
   <td style="width:336px;"><code>spark.serializer.objectStreamReset</code></td> 
   <td style="width:82px;">100</td> 
   <td style="width:510px;">使用 org.apache.spark.serializer.JavaSerializer 进行序列化时。序列化器缓存对象来防止写冗余数据，但是这样会停止对那些对象的垃圾收集。通过调用'reset'，您可以从序列化程序中刷新该信息，并允许收集旧对象。要关闭这个周期性的重置，将其设置为-1。默认情况下，它将每100个对象重置一次序列化器。</td> 
  </tr> 
 </tbody> 
</table>

### Memory Management ###

<table> 
 <tbody> 
  <tr> 
   <th style="width:272.5px;">Property Name</th> 
   <th style="width:1px;">Default</th> 
   <th>Meaning</th> 
  </tr> 
  <tr> 
   <td style="width:272.5px;"><code>spark.memory.fraction</code></td> 
   <td style="width:1px;">0.6</td> 
   <td>用于执行和存储的部分(堆空间- 300MB)。这个值越低，发生溢出和缓存数据清除的频率就越高。这个配置的目的是为内部元数据、用户数据结构和在稀疏、异常大的记录情况下不精确的大小估计留出内存。建议将其保留为默认值。</td> 
  </tr> 
  <tr> 
   <td style="width:272.5px;"><code>spark.memory.storageFraction</code></td> 
   <td style="width:1px;">0.5</td> 
   <td>这个值越高，可用来执行的工作内存就越少，任务可能更频繁地溢出到磁盘。建议将其保留为默认值。</td> 
  </tr> 
  <tr> 
   <td style="width:272.5px;"><code>spark.memory.offHeap.enabled</code></td> 
   <td style="width:1px;">false</td> 
   <td>如果为 true，Spark 将尝试为某些操作使用堆外内存。如果启用了堆外内存使用，那么 spark.memory.offHeap.size 必须为正。</td> 
  </tr> 
  <tr> 
   <td style="width:272.5px;"><code>spark.memory.offHeap.size</code></td> 
   <td style="width:1px;">0</td> 
   <td>可用作堆外分配的内存(以字节为单位)的绝对数量。这个设置对堆内存使用没有影响，所以如果执行器的总内存消耗必须符合某个硬限制，那么一定要相应地缩小JVM堆大小。当 spark.memory.offHeap.enabled=true 时，该值必须设置为正。</td> 
  </tr> 
  <tr> 
   <td style="width:272.5px;"><code>spark.memory.useLegacyMode</code></td> 
   <td style="width:1px;">false</td> 
   <td>是否启用Spark 1.5及以前使用的遗留内存管理模式。遗留模式严格地将堆空间划分为大小固定的区域，如果应用程序没有进行调优，则可能导致过度溢出。除非启用此选项，否则不读取下列已废弃的内存分数配置: <code>spark.shuffle.memoryFraction</code><br><code>spark.storage.memoryFraction</code><br><code>spark.storage.unrollFraction</code></td> 
  </tr> 
  <tr> 
   <td style="width:272.5px;"><code>spark.shuffle.memoryFraction</code></td> 
   <td style="width:1px;">0.2</td> 
   <td>(不赞成)<code>spark.memory.useLegacyMode</code>&nbsp;开启后只读。在变换过程中用于聚合和分组的 Java 堆的一部分。在任何给定的时间，用于 shuffle 的所有内存映射的集合大小都受此限制，超过此限制，内容将开始溢出到磁盘。如果经常发生溢出，可以考虑以牺牲 spark.storage.memoryFraction 为代价来增加这个值。</td> 
  </tr> 
  <tr> 
   <td style="width:272.5px;"><code>spark.storage.memoryFraction</code></td> 
   <td style="width:1px;">0.6</td> 
   <td>(不赞成)<code>spark.memory.useLegacyMode</code>&nbsp;开启后只读。用于Spark内存缓存的Java堆的一部分。这应该不会比JVM中“老”代的对象大，默认情况下，堆的大小是0.6，但是如果您配置自己的老代大小，则可以增加堆的大小。</td> 
  </tr> 
  <tr> 
   <td style="width:272.5px;"><code>spark.storage.unrollFraction</code></td> 
   <td style="width:1px;">0.2</td> 
   <td>(不赞成)<code>spark.memory.useLegacyMode</code>&nbsp;开启后只读。用于在内存中分隔的比例。这是通过在没有足够的空闲存储空间来完整地展开新块时删除现有块来动态分配的。</td> 
  </tr> 
 </tbody> 
</table>

### Execution Behavior ###

<table> 
 <tbody> 
  <tr> 
   <th style="width:268.5px;">Property Name</th> 
   <th style="width:1px;">Default</th> 
   <th>Meaning</th> 
  </tr> 
  <tr> 
   <td style="width:268.5px;"><code>spark.broadcast.blockSize</code></td> 
   <td style="width:1px;">4m</td> 
   <td>每个块的大小对于 TorrentBroadcastFactory。太大的值会降低广播期间的并行性(使其变慢);但是，如果它太小，BlockManager 的性能可能会受到影响。</td> 
  </tr> 
  <tr> 
   <td style="width:268.5px;"><code>spark.executor.cores</code></td> 
   <td style="width:1px;">1 in YARN mode, all the available cores on the worker in standalone and Mesos coarse-grained modes.</td> 
   <td>要在每个执行器上使用的内核数。在独立模式和Mesos粗粒度模式中，设置此参数允许应用程序在同一个worker上运行多个executor，前提是该worker上有足够多的内核。否则，每个应用程序只能在每个worker上运行一个executor。</td> 
  </tr> 
  <tr> 
   <td style="width:268.5px;"><code>spark.default.parallelism</code></td> 
   <td style="width:1px;">对于像 reduceByKey 和 join 这样的分布式 shuffle 算子，这是一个父RDD中最大的分区数。对于像没有父 RDDs 的并行化算子，这取决于集群管理器:: 
    <ul> 
     <li>Local mode: number of cores on the local machine</li> 
     <li>Mesos fine grained mode: 8</li> 
     <li>Others: total number of cores on all executor nodes or 2, whichever is larger</li> 
    </ul></td> 
   <td>在未由用户指定时，join、reduceByKey 和 parallelize 等转换返回的 RDDs 中的默认分区数。</td> 
  </tr> 
  <tr> 
   <td style="width:268.5px;"><code>spark.executor.heartbeatInterval</code></td> 
   <td style="width:1px;">10s</td> 
   <td>每个执行者心跳到驱动程序的间隔。心跳让驱动程序知道执行者仍然活着，并用正在执行的任务的度量更新它。spark.executor.heartbeatinterval 应该明显小于spark.net .timeout</td> 
  </tr> 
  <tr> 
   <td style="width:268.5px;"><code>spark.files.fetchTimeout</code></td> 
   <td style="width:1px;">60s</td> 
   <td>从驱动程序中获取通过SparkContext.addFile()添加的文件时使用的通信超时。</td> 
  </tr> 
  <tr> 
   <td style="width:268.5px;"><code>spark.files.useFetchCache</code></td> 
   <td style="width:1px;">true</td> 
   <td>如果设置为 true(默认值)，文件获取将使用属于同一应用程序的执行器共享的本地缓存，这可以在同一主机上运行多个执行器时提高任务启动性能。如果设置为 false，这些缓存优化将被禁用，所有执行器将获取自己的文件副本。为了使用驻留在 NFS 文件系统上的Spark本地目录</td> 
  </tr> 
  <tr> 
   <td style="width:268.5px;"><code>spark.files.overwrite</code></td> 
   <td style="width:1px;">false</td> 
   <td>当目标文件存在且其内容与源文件不匹配时，是否覆盖通过SparkContext.addFile()添加的文件。</td> 
  </tr> 
  <tr> 
   <td style="width:268.5px;"><code>spark.files.maxPartitionBytes</code></td> 
   <td style="width:1px;">134217728 (128 MB)</td> 
   <td>读取文件时要装入单个分区的最大字节数。</td> 
  </tr> 
  <tr> 
   <td style="width:268.5px;"><code>spark.files.openCostInBytes</code></td> 
   <td style="width:1px;">4194304 (4 MB)</td> 
   <td>打开一个文件的估计成本，通过同时扫描的字节数来衡量。这是在将多个文件放入一个分区时使用的。最好是高估，那么带有小文件的分区将比带有大文件的分区更快。</td> 
  </tr> 
  <tr> 
   <td style="width:268.5px;"><code>spark.hadoop.cloneConf</code></td> 
   <td style="width:1px;">false</td> 
   <td>如果设置为 true，则为每个任务克隆一个新的 Hadoop 配置对象。应该启用此选项来解决配置线程安全问题。<span style="color:#f33b45;">默认情况下禁用此选项，以避免不受这些问题影响的作业出现意外的性能退化。</span></td> 
  </tr> 
  <tr> 
   <td style="width:268.5px;"><code>spark.hadoop.validateOutputSpecs</code></td> 
   <td style="width:1px;">true</td> 
   <td>如果设置为 true，则验证 saveAsHadoopFile 和其他使用的输出规范(例如，检查输出目录是否已经存在)。可以禁用此选项以使由于预先存在的输出目录而导致的异常。<span style="color:#f33b45;">我们建议用户不要禁用此功能，除非试图实现与以前版本的Spark的兼容性。</span>只需使用 Hadoop的FileSystem API 手动删除输出目录。对于通过 Spark 流的 StreamingContext 生成的作业，此设置将被忽略，因为在签入期间可能需要将数据重写到预先存在的输出目录</td> 
  </tr> 
  <tr> 
   <td style="width:268.5px;"><code>spark.storage.memoryMapThreshold</code></td> 
   <td style="width:1px;">2m</td> 
   <td>当从磁盘读取一个块时，上面的块的大小会触发内存映射。这可以防止内存映射非常小的块。通常，对于接近或低于操作系统页面大小的块，内存映射的开销很高。</td> 
  </tr> 
 </tbody> 
</table>

### Networking ###

<table> 
 <tbody> 
  <tr> 
   <th style="width:232px;">Property Name</th> 
   <th style="width:135px;">Default</th> 
   <th>Meaning</th> 
  </tr> 
  <tr> 
   <td style="width:232px;"><code>spark.rpc.message.maxSize</code></td> 
   <td style="width:135px;">128</td> 
   <td>允许“控制平面”通信的最大消息大小(以MB为单位);通常只适用于在执行器和驱动程序之间发送的 map 输出大小信息。<span style="color:#f33b45;">如果您正在运行带有成千上万个 map 和 reduce 任务的作业，并查看关于 RPC 消息大小的消息，请增加这个值。</span></td> 
  </tr> 
  <tr> 
   <td style="width:232px;"><code>spark.blockManager.port</code></td> 
   <td style="width:135px;">(random)</td> 
   <td>所有块管理器监听的端口。这些都存在于驱动程序和执行者中。</td> 
  </tr> 
  <tr> 
   <td style="width:232px;"><code>spark.driver.blockManager.port</code></td> 
   <td style="width:135px;">(value of spark.blockManager.port)</td> 
   <td>块管理器侦听的特定于驱动程序的端口，用于它不能使用与executor相同的配置的情况。</td> 
  </tr> 
  <tr> 
   <td style="width:232px;"><code>spark.driver.bindAddress</code></td> 
   <td style="width:135px;">(value of spark.driver.host)</td> 
   <td>将监听套接字绑定到的主机名或IP地址。此配置覆盖 SPARK_LOCAL_IP 环境变量(参见下面)。<br> 它还允许从本地地址向执行者或外部系统发布不同的地址。例如，当运行带有桥接网络的容器时。为了使其正常工作，需要从容器的主机转发驱动程序(RPC、块管理器和UI)使用的不同端口。</td> 
  </tr> 
  <tr> 
   <td style="width:232px;"><code>spark.driver.host</code></td> 
   <td style="width:135px;">(local hostname)</td> 
   <td>驱动程序的主机名或IP地址。这用于与执行器和 standalone master。</td> 
  </tr> 
  <tr> 
   <td style="width:232px;"><code>spark.driver.port</code></td> 
   <td style="width:135px;">(random)</td> 
   <td> <p>供 driver 监听的端口。这用于与执行器和 standalone mater。</p> </td> 
  </tr> 
  <tr> 
   <td style="width:232px;"><code>spark.network.timeout</code></td> 
   <td style="width:135px;">120s</td> 
   <td>所有网络交互的默认超时。如果&nbsp;<code>spark.core.connection.ack.wait.timeout</code>, <code>spark.storage.blockManagerSlaveTimeoutMs</code>, <code>spark.shuffle.io.connectionTimeout</code>, <code>spark.rpc.askTimeout</code> or <code>spark.rpc.lookupTimeout 没有配置则会被替代</code></td> 
  </tr> 
  <tr> 
   <td style="width:232px;"><code>spark.port.maxRetries</code></td> 
   <td style="width:135px;">16</td> 
   <td>在放弃之前绑定到端口时重试的最大次数。当一个端口被赋予一个特定的值(非0)时，每个后续的重试将在重试之前将前一次尝试中使用的端口增加1。这实际上允许它尝试从指定的开始端口到 port + maxretry的一系列端口。</td> 
  </tr> 
  <tr> 
   <td style="width:232px;"><code>spark.rpc.numRetries</code></td> 
   <td style="width:135px;">3</td> 
   <td>在RPC任务放弃之前重试的次数。RPC任务将在这个数字的大多数时候运行。</td> 
  </tr> 
  <tr> 
   <td style="width:232px;"><code>spark.rpc.retry.wait</code></td> 
   <td style="width:135px;">3s</td> 
   <td>RPC请求操作在重试之前等待的持续时间。</td> 
  </tr> 
  <tr> 
   <td style="width:232px;"><code>spark.rpc.askTimeout</code></td> 
   <td style="width:135px;"><code>spark.network.timeout</code></td> 
   <td>RPC请求操作在超时之前等待的持续时间。</td> 
  </tr> 
  <tr> 
   <td style="width:232px;"><code>spark.rpc.lookupTimeout</code></td> 
   <td style="width:135px;">120s</td> 
   <td>RPC远程端点查找操作在超时之前等待的时间。</td> 
  </tr> 
 </tbody> 
</table>

### Scheduling ###

<table> 
 <tbody> 
  <tr> 
   <th style="width:385px;">Property Name</th> 
   <th style="width:70px;">Default</th> 
   <th>Meaning</th> 
  </tr> 
  <tr> 
   <td style="width:385px;"><code>spark.cores.max</code></td> 
   <td style="width:70px;">(not set)</td> 
   <td>在独立部署集群或Mesos集群上以“粗粒度”共享模式运行时，跨集群(而不是每台机器)请求应用程序的最大CPU内核数量。如果没有设置，默认值将是&nbsp;<code>spark.deploy.defaultCores</code></td> 
  </tr> 
  <tr> 
   <td style="width:385px;"><code>spark.locality.wait</code></td> 
   <td style="width:70px;">3s</td> 
   <td>在放弃并在非本地节点上启动数据本地任务之前，要等待多长时间?还可以通过设置 spark.local .wait.node 来定制每个级别的等待时间。<span style="color:#f33b45;">如果您的任务很长，并且位置不好，您应该增加这个设置</span>，但是推荐默认设置。</td> 
  </tr> 
  <tr> 
   <td style="width:385px;"><code>spark.locality.wait.node</code></td> 
   <td style="width:70px;">spark.locality.wait</td> 
   <td>自定义等待节点位置。例如，您可以将其设置为0，以跳过节点位置并立即搜索机架位置(如果您的集群具有机架信息)。</td> 
  </tr> 
  <tr> 
   <td style="width:385px;"><code>spark.locality.wait.process</code></td> 
   <td style="width:70px;">spark.locality.wait</td> 
   <td>自定义局部性，等待进程局部性。这将影响试图访问特定执行程序进程中缓存数据的任务。</td> 
  </tr> 
  <tr> 
   <td style="width:385px;"><code>spark.locality.wait.rack</code></td> 
   <td style="width:70px;">spark.locality.wait</td> 
   <td>自定义等待机架位置。</td> 
  </tr> 
  <tr> 
   <td style="width:385px;"><code>spark.scheduler.maxRegisteredResourcesWaitingTime</code></td> 
   <td style="width:70px;">30s</td> 
   <td>在调度开始之前等待资源注册的最长时间。</td> 
  </tr> 
  <tr> 
   <td style="width:385px;"><code>spark.scheduler.minRegisteredResourcesRatio</code></td> 
   <td style="width:70px;">0.8 for YARN mode; 0.0 for standalone mode and Mesos coarse-grained mode</td> 
   <td>注册资源的最小比率(注册资源/总期望资源)(资源是 yarn 模式下的执行者，独立模式下的 CPU 核心和 Mesos 粗粒度模式['spark.core]。max 的值是 Mesos 粗粒度模式])在调度开始前等待的总期望资源。指定为0.0和1.0之间的双精度值。无论是否达到了资源的最小比率，它在调度开始之前等待的最大时间量都是由配置&nbsp; spark.scheduler.maxRegisteredResourcesWaitingTime 控制的。</td> 
  </tr> 
  <tr> 
   <td style="width:385px;"><code>spark.scheduler.mode</code></td> 
   <td style="width:70px;">FIFO</td> 
   <td>提交到相同SparkContext的作业之间的调度模式。可以设置为 FAIR，而不是排队作业一个接一个。适用于多用户服务。</td> 
  </tr> 
  <tr> 
   <td style="width:385px;"><code>spark.scheduler.revive.interval</code></td> 
   <td style="width:70px;">1s</td> 
   <td>调度程序恢复工作资源的间隔长度提供了运行任务的时间。</td> 
  </tr> 
  <tr> 
   <td style="width:385px;"><code>spark.blacklist.enabled</code></td> 
   <td style="width:70px;">false</td> 
   <td>如果设置为“true”，则防止Spark在执行器上调度由于太多任务失败而被列入黑名单的任务。黑名单算法可以由另一个&nbsp;spark.blacklist 选项配置</td> 
  </tr> 
  <tr> 
   <td style="width:385px;"><code>spark.blacklist.task.maxTaskAttemptsPerExecutor</code></td> 
   <td style="width:70px;">1</td> 
   <td>(实验性的)对于给定的任务，在某个执行程序被列入该任务的黑名单之前，可以在该执行程序上重试多少次。</td> 
  </tr> 
  <tr> 
   <td style="width:385px;"><code>spark.blacklist.task.maxTaskAttemptsPerNode</code></td> 
   <td style="width:70px;">2</td> 
   <td>(实验性的)对于给定的任务，在整个节点被列入该任务的黑名单之前，可以在一个节点上重试多少次。</td> 
  </tr> 
  <tr> 
   <td style="width:385px;"><code>spark.blacklist.stage.maxFailedTasksPerExecutor</code></td> 
   <td style="width:70px;">2</td> 
   <td>(实验性的)在一个执行器上，在一个阶段中，在执行器被列入该阶段的黑名单之前，必须有多少不同的任务在一个执行器上失败。</td> 
  </tr> 
  <tr> 
   <td style="width:385px;"><code>spark.blacklist.stage.maxFailedExecutorsPerNode</code></td> 
   <td style="width:70px;">2</td> 
   <td>(实验)在指定阶段的整个节点被标记为失败之前，有多少不同的执行者被标记为黑名单。</td> 
  </tr> 
  <tr> 
   <td style="width:385px;"><code>spark.speculation</code></td> 
   <td style="width:70px;">false</td> 
   <td>如果设置为“true”，则执行推测性的任务执行。这意味着<span style="color:#f33b45;">如果一个或多个任务在一个阶段运行缓慢，它们将重新启动。</span></td> 
  </tr> 
  <tr> 
   <td style="width:385px;"><code>spark.speculation.interval</code></td> 
   <td style="width:70px;">100ms</td> 
   <td>Spark将检查任务以进行推测的频率。</td> 
  </tr> 
  <tr> 
   <td style="width:385px;"><code>spark.speculation.multiplier</code></td> 
   <td style="width:70px;">1.5</td> 
   <td>一个任务比预期的中位数慢多少倍。</td> 
  </tr> 
  <tr> 
   <td style="width:385px;"><code>spark.speculation.quantile</code></td> 
   <td style="width:70px;">0.75</td> 
   <td>在特定阶段启用推测之前必须完成的任务的一部分。</td> 
  </tr> 
  <tr> 
   <td style="width:385px;"><code>spark.task.cpus</code></td> 
   <td style="width:70px;">1</td> 
   <td>为每个任务分配的内核数量。</td> 
  </tr> 
  <tr> 
   <td style="width:385px;"><code>spark.task.maxFailures</code></td> 
   <td style="width:70px;">4</td> 
   <td>在放弃工作之前，任何特定任务的失败次数。分散在不同任务中的失败总数不会导致作业失败;某个特定任务必须在此次数的尝试中失败。应该大于等于1。允许重试的次数=此值- 1。</td> 
  </tr> 
  <tr> 
   <td style="width:385px;"><code>spark.task.reaper.enabled</code></td> 
   <td style="width:70px;">false</td> 
   <td> <p>启用对已杀死/中断任务的监视。当设置为true时，执行程序将监视任何被终止的任务，直到该任务实际执行完毕。<code>spark.task.reaper.* 配置</code>有关如何控制此监视的确切行为的详细信息。</p> <p>当设置为false(默认值)时，任务终止将使用一个较旧的代码路径，该路径没有此类监视。</p> </td> 
  </tr> 
  <tr> 
   <td style="width:385px;"><code>spark.task.reaper.pollingInterval</code></td> 
   <td style="width:70px;">10s</td> 
   <td>当 <code>spark.task.reaper.enabled = true</code>，此设置控制执行器轮询已死任务状态的频率。如果在轮询时已关闭的任务仍在运行，那么将记录一个警告，并且默认情况下，将记录任务的线程转储(可以通过 <code>spark.task.reaper.threadDump&nbsp;</code>设置，下面将对此进行说明)。</td> 
  </tr> 
  <tr> 
   <td style="width:385px;"><code>spark.task.reaper.threadDump</code></td> 
   <td style="width:70px;">true</td> 
   <td>当 <code>spark.task.reaper.enabled = true</code>，此设置控制任务线程转储是否在定期轮询已死任务期间被记录。<span style="color:#f33b45;">将此设置为 false 以禁用线程转储的收集。</span></td> 
  </tr> 
  <tr> 
   <td style="width:385px;"><code>spark.task.reaper.killTimeout</code></td> 
   <td style="width:70px;">-1</td> 
   <td>当 <code>spark.task.reaper.enabled = true</code>，此设置指定一个超时，在此超时之后，如果终止的任务没有停止运行，则执行程序 JVM 将杀死自己。默认值-1禁用此机制并防止执行程序自毁。此设置的目的是充当安全网，防止失控的不可取消任务导致执行者不可用。</td> 
  </tr> 
 </tbody> 
</table>

### Dynamic Allocation ###

<table> 
 <tbody> 
  <tr> 
   <th style="width:387px;">Property Name</th> 
   <th style="width:9px;">Default</th> 
   <th>Meaning</th> 
  </tr> 
  <tr> 
   <td style="width:387px;"><code>spark.dynamicAllocation.enabled</code></td> 
   <td style="width:9px;">false</td> 
   <td> <p>是否使用动态资源分配，它根据工作负载将注册到此应用程序的执行者数量向上或向下调整。</p> <p><br> This requires <code>spark.shuffle.service.enabled</code> to be set. The following configurations are also relevant: <code>spark.dynamicAllocation.minExecutors</code>, <code>spark.dynamicAllocation.maxExecutors</code>, and <code>spark.dynamicAllocation.initialExecutors</code></p> </td> 
  </tr> 
  <tr> 
   <td style="width:387px;"><code>spark.dynamicAllocation.executorIdleTimeout</code></td> 
   <td style="width:9px;">60s</td> 
   <td>如果启用了动态分配，并且某个执行程序空闲的时间超过此持续时间，则将删除该执行程序。</td> 
  </tr> 
  <tr> 
   <td style="width:387px;"><code>spark.dynamicAllocation.cachedExecutorIdleTimeout</code></td> 
   <td style="width:9px;">infinity</td> 
   <td>如果启用了动态分配，并且缓存了数据块的执行程序空闲时间超过此持续时间，则将删除执行程序。</td> 
  </tr> 
  <tr> 
   <td style="width:387px;"><code>spark.dynamicAllocation.initialExecutors</code></td> 
   <td style="width:9px;"><code>spark.dynamicAllocation.minExecutors</code></td> 
   <td>启用动态分配时要运行的初始执行器数目。<br><br> 如果 `--num-executors` (or `spark.executor.instances`)设置并大于此值，则它将用作执行器的初始数目。</td> 
  </tr> 
  <tr> 
   <td style="width:387px;"><code>spark.dynamicAllocation.maxExecutors</code></td> 
   <td style="width:9px;">infinity</td> 
   <td>启用动态分配时执行器数目的上限。</td> 
  </tr> 
  <tr> 
   <td style="width:387px;"><code>spark.dynamicAllocation.minExecutors</code></td> 
   <td style="width:9px;">0</td> 
   <td>如果启用动态分配，则执行器数量的下限。</td> 
  </tr> 
  <tr> 
   <td style="width:387px;"><code>spark.dynamicAllocation.schedulerBacklogTimeout</code></td> 
   <td style="width:9px;">1s</td> 
   <td>如果启用了动态分配，并且存在挂起的任务积压时间超过此时间，则将请求新的执行器。</td> 
  </tr> 
  <tr> 
   <td style="width:387px;"><code>spark.dynamicAllocation.sustainedSchedulerBacklogTimeout</code></td> 
   <td style="width:9px;"><code>schedulerBacklogTimeout</code></td> 
   <td>跟&nbsp;<code>spark.dynamicAllocation.schedulerBacklogTimeout 一样，</code>&nbsp;但仅用于后续执行程序请求。 For more detail, see this <a href="http://spark.apache.org/docs/2.1.1/job-scheduling.html#resource-allocation-policy" rel="nofollow">description</a>.</td> 
  </tr> 
 </tbody> 
</table>

### Security ###

<table> 
 <tbody> 
  <tr> 
   <th style="width:215.5px;">Property Name</th> 
   <th style="width:1px;">Default</th> 
   <th>Meaning</th> 
  </tr> 
  <tr> 
   <td style="width:215.5px;"><code>spark.acls.enable</code></td> 
   <td style="width:1px;">false</td> 
   <td>是否应启用 Spark acl。如果启用，则检查用户是否具有查看或修改作业的访问权限。注意，这要求用户是已知的，因此如果用户遇到null，则不执行任何检查。过滤器可与 UI 一起用于验证和设置用户。</td> 
  </tr> 
  <tr> 
   <td style="width:215.5px;"><code>spark.admin.acls</code></td> 
   <td style="width:1px;">Empty</td> 
   <td>具有对所有Spark 作业的查看和修改权限的用户/管理员列表，用逗号分隔。如果您在一个共享集群上运行，并且有一组管理员或开发人员在出现问题时帮助进行调试，那么可以使用这种方法。将“*”放在列表中意味着任何用户都可以拥有admin权限。</td> 
  </tr> 
  <tr> 
   <td style="width:215.5px;"><code>spark.admin.acls.groups</code></td> 
   <td style="width:1px;">Empty</td> 
   <td>具有对所有Spark作业的查看和修改权限的组的逗号分隔列表。如果您有一组管理员或开发人员来帮助维护和调试底层基础设施，则可以使用此功能。将“*”放在列表中意味着任何组中的任何用户都可以拥有admin特权。用户组是从spark.user.groups.mapping指定的组映射提供程序的实例中获得的。</td> 
  </tr> 
  <tr> 
   <td style="width:215.5px;"><code>spark.user.groups.mapping</code></td> 
   <td style="width:1px;"><code>org.apache.spark.security.ShellBasedGroupsMappingProvider</code></td> 
   <td>用户的组列表由trait org.apache.spark.security.GroupMappingServiceProvider&nbsp;定义的组映射服务确定可以通过此属性配置的。提供了一个默认的基于unix shell的实现 <code>org.apache.spark.security.ShellBasedGroupsMappingProvider&nbsp;</code>。可以指定它来为用户解析组列表。注意:这个实现只支持基于Unix/Linux的环境。目前不支持Windows环境。但是，可以通过实现trait org.apache.spark.security.GroupMappingServiceProvider来支持新的平台/协议。</td> 
  </tr> 
  <tr> 
   <td style="width:215.5px;"><code>spark.authenticate</code></td> 
   <td style="width:1px;">false</td> 
   <td>Spark是否验证其内部连接。没有用 yarn 看&nbsp;<code>spark.authenticate.secret</code></td> 
  </tr> 
  <tr> 
   <td style="width:215.5px;"><code>spark.authenticate.secret</code></td> 
   <td style="width:1px;">None</td> 
   <td>设置用于Spark的密钥，以便在组件之间进行身份验证。如果没有在纱线上运行并且启用了身份验证，则需要设置此选项。</td> 
  </tr> 
  <tr> 
   <td style="width:215.5px;"><code>spark.authenticate.enableSaslEncryption</code></td> 
   <td style="width:1px;">false</td> 
   <td>启用身份验证时启用加密通信。块传输服务和RPC端支持这一点。</td> 
  </tr> 
  <tr> 
   <td style="width:215.5px;"><code>spark.network.sasl.serverAlwaysEncrypt</code></td> 
   <td style="width:1px;">false</td> 
   <td>为支持SASL身份验证的服务禁用未加密的连接。这是目前支持的外部 shuffle 服务。</td> 
  </tr> 
  <tr> 
   <td style="width:215.5px;"><code>spark.core.connection.ack.wait.timeout</code></td> 
   <td style="width:1px;"><code>spark.network.timeout</code></td> 
   <td>在超时和放弃连接之前，等待 ack 发生需要多长时间。为了避免GC等长时间暂停导致的不情愿超时，<span style="color:#f33b45;">可以设置更大的值。</span></td> 
  </tr> 
  <tr> 
   <td style="width:215.5px;"><code>spark.core.connection.auth.wait.timeout</code></td> 
   <td style="width:1px;">30s</td> 
   <td>连接在超时和放弃之前等待身份验证的时间。</td> 
  </tr> 
  <tr> 
   <td style="width:215.5px;"><code>spark.modify.acls</code></td> 
   <td style="width:1px;">Empty</td> 
   <td>具有修改权限的 Spark 作业的用户列表，用逗号分隔。默认情况下，只有启动 Spark 作业的用户才有权修改它(例如杀死它)。在列表中放置一个“*”意味着任何用户都可以修改它。</td> 
  </tr> 
  <tr> 
   <td style="width:215.5px;"><code>spark.modify.acls.groups</code></td> 
   <td style="width:1px;">Empty</td> 
   <td>具有对 Spark 作业修改访问权的组的列表，用逗号分隔。如果您有一组来自同一团队的管理员或开发人员可以访问该作业，则可以使用此选项。在列表中放置“*”表示任何组中的任何用户都可以修改 Spark 作业。用户组是从 spark.user.groups.mapping 指定的组映射提供程序的实例中获得的</td> 
  </tr> 
  <tr> 
   <td style="width:215.5px;"><code>spark.ui.filters</code></td> 
   <td style="width:1px;">None</td> 
   <td>要应用于Spark web UI的筛选器类名列表，用逗号分隔。过滤器应该是一个标准的javax servlet过滤器。每个过滤器的参数也可以通过设置一个java系统属性来指定:<br><code>spark.&lt;class name of filter&gt;.params='param1=value1,param2=value2'</code><br> For example:<br><code>-Dspark.ui.filters=com.test.filter1</code><br><code>-Dspark.com.test.filter1.params='param1=foo,param2=testing'</code></td> 
  </tr> 
  <tr> 
   <td style="width:215.5px;"><code>spark.ui.view.acls</code></td> 
   <td style="width:1px;">Empty</td> 
   <td>具有对 Spark web ui 的视图访问权的用户列表，用逗号分隔。默认情况下，只有启动 Spark 作业的用户才有查看权限。在列表中放置“*”表示任何用户都可以查看此 Spark 作业。</td> 
  </tr> 
  <tr> 
   <td style="width:215.5px;"><code>spark.ui.view.acls.groups</code></td> 
   <td style="width:1px;">Empty</td> 
   <td>用户组是从spark.user.groups.mapping指定的组映射提供程序的实例中获得的。检查条目spark.user.groups。映射以获得更多细节。</td> 
  </tr> 
 </tbody> 
</table>

### Encryption ###

<table> 
 <tbody> 
  <tr> 
   <th style="width:217.5px;">Property Name</th> 
   <th style="width:1px;">Default</th> 
   <th>Meaning</th> 
  </tr> 
  <tr> 
   <td style="width:217.5px;"><code>spark.ssl.enabled</code></td> 
   <td style="width:1px;">false</td> 
   <td> <p>是否在所有受支持的协议上启用SSL连接。</p> <p>当&nbsp;<code>spark.ssl.enabled</code>&nbsp;配置了, <code>spark.ssl.protocol</code>&nbsp;也要配.<br> 所有的 ssl 设置像 spark.ssl.xxx 这样，xxx&nbsp;是一个特定的配置属性，表示所支持的所有协议的全局配置。为了覆盖特定协议的全局配置，必须在特定于协议的名称空间中覆盖属性。<br> &nbsp;<code>spark.ssl.YYY.XXX</code> 覆盖由YYY表示的特定协议的全局配置。 Example values for <code>YYY</code> include <code>fs</code>, <code>ui</code>, <code>standalone</code>, and <code>historyServer</code>. See <a href="http://spark.apache.org/docs/2.1.1/security.html#ssl-configuration" rel="nofollow">SSL Configuration</a> for details on hierarchical SSL configuration for services.</p> </td> 
  </tr> 
  <tr> 
   <td style="width:217.5px;"><code>spark.ssl.enabledAlgorithms</code></td> 
   <td style="width:1px;">Empty</td> 
   <td>逗号分隔的密码列表。JVM必须支持指定的密码。你可以在这个页面上找到协议的参考列表。注意:如果没有设置，它将使用JVM的默认密码套件。</td> 
  </tr> 
  <tr> 
   <td style="width:217.5px;"><code>spark.ssl.keyPassword</code></td> 
   <td style="width:1px;">None</td> 
   <td>密钥存储库中私钥的密码。</td> 
  </tr> 
  <tr> 
   <td style="width:217.5px;"><code>spark.ssl.keyStore</code></td> 
   <td style="width:1px;">None</td> 
   <td>密钥存储文件的路径。路径可以是绝对的，也可以是相对于组件所在的目录的。</td> 
  </tr> 
  <tr> 
   <td style="width:217.5px;"><code>spark.ssl.keyStorePassword</code></td> 
   <td style="width:1px;">None</td> 
   <td>密钥存储的密码。</td> 
  </tr> 
  <tr> 
   <td style="width:217.5px;"><code>spark.ssl.keyStoreType</code></td> 
   <td style="width:1px;">JKS</td> 
   <td>密钥存储的类型。</td> 
  </tr> 
  <tr> 
   <td style="width:217.5px;"><code>spark.ssl.protocol</code></td> 
   <td style="width:1px;">None</td> 
   <td>协议名称。协议必须得到JVM的支持。TLS, SSL, and HTTPS</td> 
  </tr> 
  <tr> 
   <td style="width:217.5px;"><code>spark.ssl.needClientAuth</code></td> 
   <td style="width:1px;">false</td> 
   <td>如果SSL需要客户端身份验证，请设置为true。</td> 
  </tr> 
  <tr> 
   <td style="width:217.5px;"><code>spark.ssl.trustStore</code></td> 
   <td style="width:1px;">None</td> 
   <td>到托管库文件的路径。路径可以是绝对的，也可以是相对于组件所在的目录的。</td> 
  </tr> 
  <tr> 
   <td style="width:217.5px;"><code>spark.ssl.trustStorePassword</code></td> 
   <td style="width:1px;">None</td> 
   <td>信托商店的密码</td> 
  </tr> 
  <tr> 
   <td style="width:217.5px;"><code>spark.ssl.trustStoreType</code></td> 
   <td style="width:1px;">JKS</td> 
   <td>信托商店的类型。</td> 
  </tr> 
 </tbody> 
</table>

### Spark SQL ###

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

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

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

# spark is an existing SparkSession
    spark.sql("SET -v").show(n=200, truncate=False)

sparkR.session()
    properties <- sql("SET -v")
    showDF(properties, numRows = 200, truncate = FALSE)

### Spark Streaming ###

<table> 
 <tbody> 
  <tr> 
   <th style="width:341px;">Property Name</th> 
   <th style="width:40px;">Default</th> 
   <th>Meaning</th> 
  </tr> 
  <tr> 
   <td style="width:341px;"><code>spark.streaming.backpressure.enabled</code></td> 
   <td style="width:40px;">false</td> 
   <td>启用或禁用Spark Streaming的内部反压力机制(从1.5开始)。这使得Spark流能够根据当前的批调度延迟和处理时间来控制接收速率，从而使系统接收的速度只取决于系统能够处理的速度。在内部，这动态地设置接收器的最大接收速率。&nbsp;速率的上限取决于&nbsp;<code>spark.streaming.receiver.maxRate</code> and <code>spark.streaming.kafka.maxRatePerPartition</code> if they are set (see below).</td> 
  </tr> 
  <tr> 
   <td style="width:341px;"><code>spark.streaming.backpressure.initialRate</code></td> 
   <td style="width:40px;">not set</td> 
   <td>这是启用背压机制时每个接收器接收第一批数据的初始最大接收速率。</td> 
  </tr> 
  <tr> 
   <td style="width:341px;"><code>spark.streaming.blockInterval</code></td> 
   <td style="width:40px;">200ms</td> 
   <td>在将数据存储到Spark之前，spark streaming 接收到的数据分块的时间间隔。最少建议- 50毫秒。</td> 
  </tr> 
  <tr> 
   <td style="width:341px;"><code>spark.streaming.receiver.maxRate</code></td> 
   <td style="width:40px;">not set</td> 
   <td>每个接收器接收数据的最大速率(每秒记录数)。实际上，每个流每秒最多消耗这个数量的记录。将这个配置设置为0或负数将不会限制速率。</td> 
  </tr> 
  <tr> 
   <td style="width:341px;"><code>spark.streaming.receiver.writeAheadLog.enable</code></td> 
   <td style="width:40px;">false</td> 
   <td>为接收器启用写前日志。通过接收器接收到的所有输入数据都将被保存，以便提前写入日志，以便在驱动程序故障后恢复</td> 
  </tr> 
  <tr> 
   <td style="width:341px;"><code>spark.streaming.unpersist</code></td> 
   <td style="width:40px;">true</td> 
   <td>由Spark流生成并持久的强制 RDDs 将自动从 Spark 的内存中取消持久。spark streaming 的原始输入数据也会自动清除。将其设置为 false 将允许在流应用程序之外访问原始数据和持久的 RDDs，因为它们不会被自动清除。但这是以更高的内存使用量为代价的。</td> 
  </tr> 
  <tr> 
   <td style="width:341px;"><code>spark.streaming.stopGracefullyOnShutdown</code></td> 
   <td style="width:40px;">false</td> 
   <td>If <code>true</code>, Spark会在JVM关闭时优雅地关闭StreamingContext，而不是立即关闭。</td> 
  </tr> 
  <tr> 
   <td style="width:341px;"><code>spark.streaming.kafka.maxRatePerPartition</code></td> 
   <td style="width:40px;">not set</td> 
   <td>新建 kafka stream api 从每个 Kafka 分区读取数据的最大速率(每秒记录数)。有关更多细节，请参阅&nbsp; <p><a href="https://blog.csdn.net/zpf_940810653842/article/details/103144286" rel="nofollow">Structured Streaming + Kafka 构建指南</a></p> </td> 
  </tr> 
  <tr> 
   <td style="width:341px;"><code>spark.streaming.kafka.maxRetries</code></td> 
   <td style="width:40px;">1</td> 
   <td>驱动程序将进行最大次数的连续重试，以找到每个分区的leader上的最新偏移量(默认值为1表示驱动程序最多进行2次尝试)。只适用于 kafka stream api</td> 
  </tr> 
  <tr> 
   <td style="width:341px;"><code>spark.streaming.ui.retainedBatches</code></td> 
   <td style="width:40px;">1000</td> 
   <td>在垃圾收集之前，Spark流UI和状态api记住了多少批次。</td> 
  </tr> 
  <tr> 
   <td style="width:341px;"><code>spark.streaming.driver.writeAheadLog.closeFileAfterWrite</code></td> 
   <td style="width:40px;">false</td> 
   <td>是否在驱动器上写入写前日志记录后关闭文件。当您想要使用&nbsp;<span style="color:#f33b45;">S3&nbsp;</span>(或任何不支持刷新的文件系统)来处理驱动程序上的元数据WAL时，将其设置为“true”。</td> 
  </tr> 
  <tr> 
   <td style="width:341px;"><code>spark.streaming.receiver.writeAheadLog.closeFileAfterWrite</code></td> 
   <td style="width:40px;">false</td> 
   <td>是否在写完文件后，在接收器上提前写好日志记录。当您希望使用&nbsp;<span style="color:#f33b45;">S3&nbsp;</span>(或任何不支持刷新的文件系统)来处理接收器上的数据时，请将此设置为“true”。</td> 
  </tr> 
 </tbody> 
</table>

### SparkR ###

<table> 
 <tbody> 
  <tr> 
   <th style="width:274px;">Property Name</th> 
   <th style="width:73px;">Default</th> 
   <th>Meaning</th> 
  </tr> 
  <tr> 
   <td style="width:274px;"><code>spark.r.numRBackendThreads</code></td> 
   <td style="width:73px;">2</td> 
   <td>rbackend 用来处理来自SparkR包的RPC调用的线程数。</td> 
  </tr> 
  <tr> 
   <td style="width:274px;"><code>spark.r.command</code></td> 
   <td style="width:73px;">Rscript</td> 
   <td>可执行的在集群模式下执行R脚本的 driver 和 worker。</td> 
  </tr> 
  <tr> 
   <td style="width:274px;"><code>spark.r.driver.command</code></td> 
   <td style="width:73px;">spark.r.command</td> 
   <td>可执行的R脚本在客户端模式的驱动程序。在集群模式中忽略。</td> 
  </tr> 
  <tr> 
   <td style="width:274px;"><code>spark.r.shell.command</code></td> 
   <td style="width:73px;">R</td> 
   <td>可执行的执行 sparkR shell 在客户端模式的驱动程序。在集群模式中忽略。它与环境变量 SPARKR_DRIVER_R 相同，但是优先极高。 <code>spark.r.shell.command</code> 用于 sparkR shell，&nbsp;<code>spark.r.driver.command 用于执行</code>&nbsp;R 脚本.</td> 
  </tr> 
  <tr> 
   <td style="width:274px;"><code>spark.r.backendConnectionTimeout</code></td> 
   <td style="width:73px;">6000</td> 
   <td>由R进程在其连接到r后台时设置的连接超时(以秒为单位)。</td> 
  </tr> 
  <tr> 
   <td style="width:274px;"><code>spark.r.heartBeatInterval</code></td> 
   <td style="width:73px;">100</td> 
   <td>从SparkR后端发送到R进程的心跳间隔，以防止连接超时。</td> 
  </tr> 
 </tbody> 
</table>

### Deploy ###

<table> 
 <tbody> 
  <tr> 
   <th style="width:224px;">Property Name</th> 
   <th style="width:23px;">Default</th> 
   <th>Meaning</th> 
  </tr> 
  <tr> 
   <td style="width:224px;"><code>spark.deploy.recoveryMode</code></td> 
   <td style="width:23px;">NONE</td> 
   <td>恢复模式设置，用于在集群模式失败并重新启动时恢复已提交的Spark作业。这只适用于使用 standalone 或 Mesos 运行时的集群模式。</td> 
  </tr> 
  <tr> 
   <td style="width:224px;"><code>spark.deploy.zookeeper.url</code></td> 
   <td style="width:23px;">None</td> 
   <td>当‘spark.deploy.recoveryMode’被设置为ZOOKEEPER时，这个配置用于设置要连接的ZOOKEEPER URL。</td> 
  </tr> 
  <tr> 
   <td style="width:224px;"><code>spark.deploy.zookeeper.dir</code></td> 
   <td style="width:23px;">None</td> 
   <td>当‘spark.deploy.recoveryMode’被设置为ZOOKEEPER时，这个配置用于设置ZOOKEEPER目录来存储恢复状态。</td> 
  </tr> 
 </tbody> 
</table>

### 集群管理 ###

[Running Spark on YARN][]：[https://blog.csdn.net/zpf\_940810653842/article/details/103377694][Running Spark on YARN]

# 环境变量 #

可以通过环境变量来配置 Spark 的某些属性，这些环境变量是从安装目录中的 conf/sparkk-env.sh 中读取的。在独立模式和 Messo 模式中，该文件可提供特定于机器的信息，如主机名。本地运行程序也会被引用。

默认安装之后是没有 conf/spark-env.sh 文件的，需要通过复制 conf/spark-env.sh.templete 来创建。

<table> 
 <tbody> 
  <tr> 
   <th style="width:199px;">Environment Variable</th> 
   <th style="width:650px;">Meaning</th> 
  </tr> 
  <tr> 
   <td style="width:199px;"><code>JAVA_HOME</code></td> 
   <td style="width:650px;">安装Java的位置(如果它不在您的默认路径上)。</td> 
  </tr> 
  <tr> 
   <td style="width:199px;"><code>PYSPARK_PYTHON</code></td> 
   <td style="width:650px;">Python二进制可执行文件，用于驱动程序和工作程序中的PySpark(如果可用，默认为python2.7，否则为Python)。&nbsp;如果设置了&nbsp;<code>spark.pyspark.python，则使用他。</code></td> 
  </tr> 
  <tr> 
   <td style="width:199px;"><code>PYSPARK_DRIVER_PYTHON</code></td> 
   <td style="width:650px;">Python二进制可执行文件，仅用于驱动程序中的PySpark(默认为PYSPARK_PYTHON)。如果设置了&nbsp;<code>spark.pyspark.driver.python</code> 则使用他</td> 
  </tr> 
  <tr> 
   <td style="width:199px;"><code>SPARKR_DRIVER_R</code></td> 
   <td style="width:650px;">用于SparkR shell的二进制可执行文件(默认为R)。 如果设置了&nbsp;<code>spark.r.shell.command</code> 则使用他</td> 
  </tr> 
  <tr> 
   <td style="width:199px;"><code>SPARK_LOCAL_IP</code></td> 
   <td style="width:650px;">要绑定到的机器的IP地址。</td> 
  </tr> 
  <tr> 
   <td style="width:199px;"><code>SPARK_PUBLIC_DNS</code></td> 
   <td style="width:650px;">Hostname your Spark program will advertise to other machines.</td> 
  </tr> 
 </tbody> 
</table>

除了上述变量外，还有设置 Spark 独立集群脚本的选项，比如在每台机器上使用的内核数量和最大内存。

spark-env.sh 是一个 shell 脚本，所以可以通过 SPARK\_LOCAL\_IP 来指定 IP。

注意：在集群模式下使用 YARN 时，需要更改 conf/spark-default.conf 中 spark.yarn.appMasterEnv.\[EnviromentVariableName\]，在集群模式下 spark-env.sh 中的环境变量不会映射到 YARN 的 AM 上。

# 日志配置 #

Spark 使用 log4j 来打印日志。可以通过往 conf 文件中添加 log4j.properties 文件来配置。另一种方式通过复制 log4j.properties.template 来配置。

# 重写配置文件 #

指定一个不同于 SPARK\_HOME/conf 的目录，这个设置 SPARK\_CONF\_DIR，spark 将使用该目录下的配置文件(spark-defaults.conf, spark-env.sh, log4j.properties, 等等)。

# 继承 Hadoop 集群配置 #

如果要在 hadoop 上使用 spark，那么就需要将 hdfs-site.xml,core-site.xml 放入spark 中。

这些配置文件的位置在 CDH 和 HDP 中是不同的，一般在 /etc/hadoop/conf 中。cdh 提供了下载 hadoop 配置文件的功能。

若要使这些文件在 spark 中生效，需要在 spark-env.sh 中的 HADOOP\_CONF\_DIR 设置对应文件的位置。

原文地址：[http://spark.apache.org/docs/2.1.1/configuration.html][http_spark.apache.org_docs_2.1.1_configuration.html]

[Running Spark on YARN]: https://blog.csdn.net/zpf_940810653842/article/details/103377694
[http_spark.apache.org_docs_2.1.1_configuration.html]: http://spark.apache.org/docs/2.1.1/configuration.html