Application Properties
| Property Name | Default | Meaning |
|---|---|---|
spark.app.name | (none) | 应用程序名称，会在 UI 和日志中显示。 |
spark.driver.cores | 1 | 驱动程序使用的核心数量，只在集群模式下有效。 |
spark.driver.maxResultSize | 1g | 限制每个 Spark action 所有分区序列化结果的大小。最小设置为 1 M，0 为不限制。如果超出限制，作业会终止。该值设置过大，会导致内存溢出。 |
spark.driver.memory | 1g | SparkContext 初始化时驱动程序使用的内存总和 (e.g.1g, 2g)。注意： 在 client 模式下，该设置不能通过配置 SparkConf 生效，因为启动程序的 JVM 已经启动了。可以通过–driver-memory命令行选项或在默认配置文件中设置。 |
spark.executor.memory | 1g | 每个 executor 使用的内存总和。 (e.g. 2g, 8g) |
spark.extraListeners | (none) | 可以设置多个实现SparkListener接口的类，用逗号分隔。SparkContext 初始化时，这些类的实例会被创建并注册到 Spark 的监听总线。创建时会调用只接收 SparkConf 为参数的构造函数或无参数的构造函数，如果没有合适的构造函数，SparkContext 会创建失败并抛出异常。 |
spark.local.dir | /tmp | Spark 的 “scratch” 空间路径, 用于存放 map 的输出文件和数据集。这个路径应该是一个系统本地路径，也可以是多个磁盘上的路径。 注意：从 Spark 1.0 开始，该参数会被 SPARK_LOCAL_DIRS (Standalone, Mesos) 或 LOCAL_DIRS (YARN) 覆盖。 |
spark.logConf | false | SparkContext 启动时，记录有效的 SparkConf 的 INFO 信息。 |
spark.master | (none) | 集群管理节点地址。allowed master URL’s |
spark.submit.deployMode | (none) | Spark 驱动程序的部署模式。”client” 驱动程序在本地启动，”cluster” 启动程序在集群中的某个节点上启动。 |
Runtime Environment
| Property Name | Default | Meaning |
|---|---|---|
spark.driver.extraClassPath | (none) | 启动程序 classpath 的预加载扩展 classpath 路径。 注意：在 client 模式下，不能通过 SparkConf设置，应使用–driver-class-path命令行选项或默认配置文件设置。 |
spark.driver.extraJavaOptions | (none) | 额外的 JVM 选项，比如 GC 或日志。 注意：最大堆大内存（-Xmx） 不能通过该项设置。集群模式下，最大堆内存使用 spark.driver.memory设置，client 模式下使用–driver-memory命令行选项设置。注意：在 client 模式下，该项不能在 SparkConf设置，应通过–driver-java-options命令行选项或默认配置文件设置。 |
spark.driver.extraLibraryPath | (none) | 启动驱动程序 JVM 时设置一个特殊的库路径。 注意：在 client 模式下，该项不能在 SparkConf设置，应通过–driver-library-path命令行选项或默认配置文件设置。 |
spark.driver.userClassPathFirst | false | （实验）是否设置用户的 jar 优先于 Spark 的 jar 。该特性用于解决 Spark 依赖和用户依赖之间的冲突。这个特性还在实验中，只在集群模式下生效。 |
spark.executor.extraClassPath | (none) | 预设额外的类路径条目，这个属性主要是为了先后兼容老的 Spark 版本，用户通常不需要设置。 |
spark.executor.extraJavaOptions | (none) | 向 executor 传递一个额外的 JVM 选项，比如 GC 或日志。 注意：该项不能设置 Spark Properties 或最大堆大小（-Xmx）。Spark properties 应使用 SparkConf 对象或 spark-defaults.conf 来设置。最大堆内存应通过 spark.executor.memory设置。 |
spark.executor.extraLibraryPath | (none) | executor 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) | 设置日志滚动策略。默认禁用，可以基于“时间”滚动或按照“大小”滚动。基于“时间”，使用spark.executor.logs.rolling.time.interval设置滚动频率。按照“大小”，使用spark.executor.logs.rolling.maxSize设置最大滚动文件大小。 |
spark.executor.logs.rolling.time.interval | daily | 设置日志滚动的时间间隔。默认不滚动。可以设置的值包括daily, hourly, minutely 或任意秒数。参考spark.executor.logs.rolling.maxRetainedFiles自动清除旧的日志。 |
spark.executor.userClassPathFirst | false | （实验）和spark.driver.userClassPathFirst功能相同，但是是作用在 executor 实例。 |
spark.executorEnv.[EnvironmentVariableName] | (none) | 通过指定EnvironmentVariableName添加 executor 的环境变量，可以设置多个值。 |
spark.python.profile | false | 在 python 的 worker 节点上启动 profile 。profile 的结果通过sc.show_profiles()显示或在启动程序退出前显示。通过sc.dump_profiles(path)设置磁盘的路径。如果 profile 结果被手动隐藏，那么在驱动程序退出时不显示。默认pyspark.profiler.BasicProfiler 启用，但是可以给 SparkContext 构造函数传一个 profiler 类参数覆盖该值。 |
spark.files | 每个 executor 的工作目录列表，用逗号分隔。 | |
spark.jars | 设置驱动程序和 executor 类路径包含的本地 jar，用逗号分隔。 | |
spark.jars.packages | 驱动程序和 executor 类路径包含的 jar 包的 maven 坐标。按照本地 maven 仓库，maven 中心库和spark.jars.ivy指定的附加远程仓库顺序查找。格式为：groupId:artifactId:version | |
spark.jars.excludes | 排除spark.jars.packages提供的 jar 以避免冲突。 | |
spark.jars.ivy | 查找附加远程仓库spark.jars.packages指定的坐标，用逗号分隔。 |
Shuffle Behavior
| Property Name | Default | Meaning |
|---|---|---|
spark.reducer.maxSizeInFlight | 48m | 同时从每个 reduce 任务获取的 map 最大值。每个输出都需要创建缓冲区来接收，所以每个 reduce 任务都有固定的内存开销，因此应设置一个较小的值。 |
spark.reducer.maxReqsInFlight | Int.MaxValue | 该选项限制任意给定的点接收远程请求的数量。但集群主机的数量增加，可能会有大量的请求连接到一个或多个节点，导致 worker 节点负载过大而出错。限制请求的数量可以避免出现此种问题。 |
spark.shuffle.compress | true | 是否压缩 map 的输出文件。一般来说使用压缩是的好办法。压缩将使用spark.io.compression.codec属性。 |
spark.shuffle.file.buffer | 32k | 每个 shuffle 文件流的缓冲区大小。缓冲区会降低创建中间 shuffle 文件时的磁盘寻址和系统调用次数。 |
spark.shuffle.io.maxRetries | 3 | （Netty only）抓取到 IO 相关异常错误自动重试。重试使 shuffle 在遇到长时间 GC 暂停或短时间的网络异常更稳定。 |
spark.shuffle.io.numConnectionsPerPeer | 1 | （Netty only）在大规模集群中为了减少连接创建，主机之间的连接被重用。对于集群中有大量的硬盘少量的主机导致并发不足时，用户可以调大该值。 |
spark.shuffle.io.preferDirectBufs | true | （Netty only）在 shuffle 和缓存交换过程中，使用堆缓冲区来减少 GC 。对于堆缓冲区内存有限的环境，用户可能希望关闭这个功能，使所有分配都从 Netty 移到堆中。 |
spark.shuffle.io.retryWait | 5s | （Netty only）每次抓取重试等待时间。默认最大延迟 15 秒maxRetries * retryWait。 |
spark.shuffle.service.enabled | false | 应用额外的 shuffle 服务。该服务保存 executor 生成的 shuffle 文件，以保证 executor 被安全删除。如果spark.dynamicAllocation.enabled为 true，则该值必须设置为 true 。 |
spark.shuffle.service.port | 7337 | 运行额外 shuffle 服务的端口号。 |
spark.shuffle.service.index.cache.entries | 1024 | shuffle 服务的缓存索引中保存的最大条目数量。 |
spark.shuffle.sort.bypassMergeThreshold | 200 | （高级）在基于排序的 shuffle 管理器中，如果没有 map 端的聚合，应避免合并排序数据并减少分区数量。 |
spark.shuffle.spill.compress | true | 是否压缩 shuffle 过程中的溢出数据。压缩使用spark.io.compression.codec属性。 |
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密码体系结构标准算法名称文档的 KeyGenerator 部分。 |
Spark UI
| Property Name | Default | Meaning |
|---|---|---|
spark.eventLog.compress | false | 如果spark.eventLog.enabled为 true ，是否使用压缩。 |
spark.eventLog.dir | file:///tmp/spark-events | 如果spark.eventLog.enabled为 true ，设置路径为 Spark 事件日志的根目录。在这个目录下，Spark 为每个应用程序创建一个子路径，记录特殊的事件。用户可以将其设置为一个统一的路径，如 HDFS 上的路径，以便历史可读。 |
spark.eventLog.enabled | false | 是否记录 Spark 事件日志，程序结束后重现 Web UI 很有用。 |
spark.ui.enabled | true | 是否运行 web UI 程序。 |
spark.ui.killEnabled | true | 允许通过 UI 杀掉任务。 |
spark.ui.port | 4040 | 应用程序面板端口号。 |
spark.ui.retainedJobs | 1000 | GC 之前 Spark UI 和状态 api 能记录多少作业。 |
spark.ui.retainedStages | 1000 | GC 之前 Spark UI 和状态 api 能记录多少阶段。 |
spark.ui.retainedTasks | 100000 | GC 之前 Spark UI 和状态 api 能记录多少任务。 |
spark.ui.reverseProxy | false | Spark 主节点作为 worker 节点和 UI 的反向代理。Spark 主节点不需要访问主机就可以反向代理 worker 节点和 UI 。需要注意的是，worker 节点和 UI 不需要访问路径，只能通过主节点或代理访问。该设置影像所有的 wroker 节点和 UI ，必须在所有的 worker 节点，驱动程序和主节点上设置。 |
spark.ui.reverseProxyUrl | 代理的 URL 。应包括 （http/https）和端口。 | |
spark.worker.ui.retainedExecutors | 1000 | GC 之前 Spark UI 和状态 api 能记录多少完成的 executor 。 |
spark.worker.ui.retainedDrivers | 1000 | GC 之前 Spark UI 和状态 api 能记录多少完成的驱动程序。 |
spark.sql.ui.retainedExecutions | 1000 | GC 之前 Spark UI 和状态 api 能记录多少完成的 execution 。 |
spark.streaming.ui.retainedBatches | 1000 | GC 之前 Spark UI 和状态 api 能记录多少完成的 batch 。 |
spark.ui.retainedDeadExecutors | 100 | GC 之前 Spark UI 和状态 api 能记录多少死亡的 executor 。 |
Compression and Serialization
| Property Name | Default | Meaning |
|---|---|---|
spark.broadcast.compress | true | 是否在发送广播变量之前压缩 |
spark.io.compression.codec | lz4 | 用来压缩 RDD 分区、广播变量、shuffle 输出等内部数据的解码器。Spark 默认提供三种解码器：lz4, lzf, snappy。也可以使用完全类名来指定解码器，比如org.apache.spark.io.LZ4CompressionCodec,org.apache.spark.io.LZFCompressionCodec, org.apache.spark.io.SnappyCompressionCodec。 |
spark.io.compression.lz4.blockSize | 32k | LZ4 压缩的块大小。块大小越小，shuffle 使用的内存越小。 |
spark.io.compression.snappy.blockSize | 32k | Snappy 压缩的块大小。块大小越小，shuffle 使用的内存越小。 |
spark.kryo.classesToRegister | (none) | 通过逗号分隔列表指定在 Kryo 中注册的类的名字。 |
spark.kryo.referenceTracking | true | 在使用 Kryo 序列化数据时，是否跟踪相同对象的引用。如果对象图包含循环的话，这是必要的。如果没有，可以禁用来提高性能。 |
spark.kryo.registrationRequired | false | 是否需要在 Kryo 注册。如果设置为 ‘true’，未注册的类在序列化时，Kryo 会抛出异常。如果设置为 ‘false’ ，Kryo 会将未注册的类名写到每一个对象，这个会造成巨大的性能开销，所以应保证序列化的类在 Kryo 中注册。 |
spark.kryo.registrator | (none) | 通过逗号分隔的列表指定在 Kryo 中注册的类名。这在通过自定义方式注册类时很有用，否则使用spark.kryo.classesToRegister更简单。 |
spark.kryo.unsafe | false | 是否使用不安全的 Kryo 序列化器。使用不安全的 IO 能极大提高性能。 |
spark.kryoserializer.buffer.max | 64m | Kryo 序列化缓冲区允许的最大值。这个大小应大于任何想序列化的对象的大小。如果出现 “buffer limit exceeded” 异常，则调大该值。 |
spark.kryoserializer.buffer | 64k | Kryo 序列化缓冲区的初始大小。注意：每个 worker 节点的每一个 core 都有一个缓冲区。spark.kryoserializer.buffer.max可以修改缓冲区的大小。 |
spark.rdd.compress | false | 是否压缩 RDD 分区。可以节约大量的空间和额外的 CPU 时间。 |
spark.serializer | org.apache.spark.serializer.JavaSerializer | 用来序列化对象的序列化器。默认的 Java 序列化器可以用于任何 Java 序列化对象，但是性能不高。对性能有要求时推荐使用org.apache.spark.serializer.KryoSerializer。 |
spark.serializer.objectStreamReset | 100 | 使用 org.apache.spark.serializer.JavaSerializer时, 序列化器缓存对象会防止多余数据写入会导致这些对象不会被 GC 。通过调用 ‘reset’ 可以刷新序列化器信息，允许旧对象被回收。 默认情况下，每序列化 100 个对象会刷新一次，设置 -1 可以关闭刷新。 |
Memory Management
| Property Name | Default | Meaning |
|---|---|---|
spark.memory.fraction | 0.6 | 执行和存储的内存比例（堆内存-300M）。比例越小，缓存数据回收和泄露越频繁。建议使用默认值。 |
spark.memory.storageFraction | 0.5 | 存储内存的比例。值越高，执行可用的内存越少，数据写到磁盘的频率越高。建议使用默认值。 |
spark.memory.offHeap.enabled | false | 是否使用非堆内存。 |
spark.memory.offHeap.size | 0 | 用于分配非堆内存的内存绝对值。该值对对内存的使用没有影响，如果想将执行的内存消耗限制在一定范围，应减小 JVM 的对内存大小。spark.memory.offHeap.enabled=true时，该值必须设置。 |
spark.memory.useLegacyMode | false | 是否使用 spark 1.5 及以前的 legacy memory management 模式。legacy 模式将对内存分为固定大小的分区，如果没有调优，可能会导致大量的泄露。 |
spark.shuffle.memoryFraction | 0.2 | 废弃的。This is read only if spark.memory.useLegacyMode is enabled. Fraction of Java heap to use for aggregation and cogroups during shuffles. At any given time, the collective size of all in-memory maps used for shuffles is bounded by this limit, beyond which the contents will begin to spill to disk. If spills are often, consider increasing this value at the expense of spark.storage.memoryFraction. |
spark.storage.memoryFraction | 0.6 | 废弃的。This is read only if spark.memory.useLegacyMode is enabled. Fraction of Java heap to use for Spark’s memory cache. This should not be larger than the “old” generation of objects in the JVM,which by default is given 0.6 of the heap, but you can increase it if you configure your own old generation size. |
spark.storage.unrollFraction | 0.2 | (deprecated) This is read only if spark.memory.useLegacyMode is enabled. Fraction of spark.storage.memoryFractionto use for unrolling blocks in memory. This is dynamically allocated by dropping existing blocks when there is not enough free storage space to unroll the new block in its entirety. |
Execution Behavior
| Property Name | Default | Meaning |
|---|---|---|
spark.broadcast.blockSize | 4m | TorrentBroadcastFactory每个块的大小。太大会降低并行度，使程序执行变慢。太小会影响BlockManager的性能。 |
spark.executor.cores | YARN 模式下是 1 ,standalone 和 Mesos 模式下为所有可用核心数量。 | 每个 executor 可以使用的核心数量。如果 worker 节点有充足的核心， 在 standalone 和 Mesos 模式下允许应用在同一个 worker 节点运行多个 executor 。否则一个 worker 节点只能运行一个 executor 。 |
spark.default.parallelism | 父 RDD 最大分区数量，比如 reduceByKey and join 这样的分布式 shuffle 操作。没有父 RDD 的并且操作，依赖于集群管理器：
| 转换操作返回的 RDD 分区数量，比如 join，reduceByKey 和 parallelize。 |
spark.executor.heartbeatInterval | 10s | executor 和驱动程序之间心跳时间间隔。心跳可以让驱动程序知道哪些 executor 活着，更新正在执行的任务信息。spark.executor.heartbeatInterval应小于spark.network.timeout。 |
spark.files.fetchTimeout | 60s | 使用SparkContext.addFile()从驱动程序获取文件的超时时间。 |
spark.files.useFetchCache | true | 如果设置为 true ，获取文件将使用本地缓存。本地缓存和同一个程序的 executor 是共享的，这样可以在相同主机同时运行多个 executor 时，任务启动更快。如果设置为 false，executor 会获取各自的文件副本。为了使用 NFS 文件系统的 Spark 本地目录，可以禁用该项。 |
spark.files.overwrite | false | 通过SparkContext.addFile()获取文件，如果文件存在并且内容不一致时是否覆盖。 |
spark.files.maxPartitionBytes | 134217728 (128 MB) | 读文件时单个分区打包的最大字节数。 |
spark.files.openCostInBytes | 4194304 (4 MB) | 预估打开文件的成本，同时读取文件的字节数量。一个分区放置多个文件时使用。超过 4MB ，小文件的分区会比大文件的快。 |
spark.hadoop.cloneConf | false | 如果设置为 true ，会为每一个任务克隆新的 Hadoop Configuration 对象。 |
spark.hadoop.validateOutputSpecs | true | 如果设置为 true ，校验在使用 saveAsHadoopFile 或其他动作时的输出规范，如校验目录是否存在。除非要兼容 Spark 以前的版本，否则不推荐禁用该项。对于使用 spark streming 的 StreamingContext 创建作业，在检查恢复时，数据需要被重写到已存在的目录，该项会被忽略。 |
spark.storage.memoryMapThreshold | 2m | 从磁盘读取块时映射到 Spark 内存的块的大小。这可以防止映射到很小的块。通常，在操作系统关闭块和降低页大小时内存映射开销很大。 |
Networking
| Property Name | Default | Meaning |
|---|---|---|
spark.rpc.message.maxSize | 128 | executor 和驱动程序之间发送消息的最大大小。如果运行的作业包含几千个 map 和 reduce 任务，可以调大该值。 |
spark.blockManager.port | (random) | executor 和驱动程序上所有块管理器被监听的接口。 |
spark.driver.blockManager.port | (value of spark.blockManager.port) | 块管理器的指定驱动程序监听端口，不能使用和 executor 相同的配置。 |
spark.driver.bindAddress | (value of spark.driver.host) | 主机名或 IP 地址用于绑定 socket 。该配置会覆盖环境变量SPARK_LOCAL_IP。允许设置不同的地址从本地到 executor 或 外部系统。为了能够正常工作，驱动程序使用的不同的接口需要从容器主机转发。 |
spark.driver.host | (local hostname) | 驱动程序的主机名或 IP 地址。用于 executor 和 standalone 主节点之间的通信。 |
spark.driver.port | (random) | 驱动程序的端口。用于 executor 和 standalone 主节点之间的通信。 |
spark.network.timeout | 120s | 网络默认超时时间。如果spark.core.connection.ack.wait.timeout,spark.storage.blockManagerSlaveTimeoutMs, spark.shuffle.io.connectionTimeout,spark.rpc.askTimeout or spark.rpc.lookupTimeout没有配置，可以用该项代替。 |
spark.port.maxRetries | 16 | 放弃端口前最大重试次数。给一个端口指定一个非 0 值，每次重试会将原来的值 +1 。从开始端口到从端口号加最大重试次数范围的端口号都会尝试。 |
spark.rpc.numRetries | 3 | 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) | 在 standalone 模式和 Mesos 粗粒度模式下，程序请求的 CPU 最大核心总数（不是每个机器的核心数量）。不设置该值，standalone 模式默认为spark.deploy.defaultCores的值，Mesos 默认是所有可用核心数。 |
spark.locality.wait | 3s | 放弃启动数据在本地的任务并启动一个非本地节点任务的等待时间。这和跳过多个本地级别（process-local, node-local, rack-local 等）的是相同的。 通过设置 spark.locality.wait.node可以自定义每个级别的等待时间。默认时间通常可以正常工作，如果你的任务很长且不在本地执行，可以增大该值。 |
spark.locality.wait.node | spark.locality.wait | 自定义本地节点的位置。例如，设置 0 以跳过本地节点并立刻搜索机架位置。 |
spark.locality.wait.process | spark.locality.wait | 自定义本地进程的位置。会影响特殊的 executor 进程中试图访问缓存数据的任务。 |
spark.locality.wait.rack | spark.locality.wait | 自定义本地机架的位置。 |
spark.scheduler.maxRegisteredResourcesWaitingTime | 30s | 调度开始前等待资源注册的最大时间。 |
spark.scheduler.minRegisteredResourcesRatio | YARN 模式为 0.8，standalone 模式和 Mesos 粗粒度模式为 0.0 | 调度开始前等待资源注册最小比例（注册的资源/期望注册的所有资源）。指定 0.0 到 1.0 之间的浮点数。不管是否到达设定值，最大等待时间是通过spark.scheduler.maxRegisteredResourcesWaitingTime控制的。 |
spark.scheduler.mode | FIFO | 任务提交到相同的 SparkContext 的模式。多用户使用时可以设置FAIR来公平共享模式来代替 FIFO 。 |
spark.scheduler.revive.interval | 1s | 调度器恢复 worker 节点资源用来运行任务的时间。 |
spark.blacklist.enabled | false | 如果设置为 true ，防止 Spark 从任务失败次数过多被加入黑名单的 executor 上调度任务。黑名单算法通过spark.blacklist配置项决定。 |
spark.blacklist.task.maxTaskAttemptsPerExecutor | 1 | （实验性）对于一个任务，executor 被加入黑名单前 executor 上的重试次数。 |
spark.blacklist.task.maxTaskAttemptsPerNode | 2 | （实验性）对于一个任务，节点被加入黑名单前节点上的重试次数。 |
spark.blacklist.stage.maxFailedTasksPerExecutor | 2 | （实验性）被加入黑名单前有多少个不同的任务在同一个阶段同一个 executor 上失败。 |
spark.blacklist.stage.maxFailedExecutorsPerNode | 2 | （实验性）在整个节点被标记为失败前有多少个不同的 executor 被加入黑名单。 |
spark.speculation | false | 如果设置为 true ，执行任务执行情况推测。意味着如果一个阶段的一个或多个任务运行过慢，被重新启动。 |
spark.speculation.interval | 100ms | 多久检查一次任务执行预估。 |
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 | Enables monitoring of killed / interrupted tasks. When set to true, any task which is killed will be monitored by the executor until that task actually finishes executing. See the other spark.task.reaper.*configurations for details on how to control the exact behavior of this monitoring. When set to false (the default), task killing will use an older code path which lacks such monitoring. |
spark.task.reaper.pollingInterval | 10s | When spark.task.reaper.enabled = true, this setting controls the frequency at which executorswill poll the status of killed tasks. If a killed task is still running when polled then a warning will be logged and, by default, a thread-dump of the task will be logged (this thread dump can be disabled via the spark.task.reaper.threadDump setting, which is documented below). |
spark.task.reaper.threadDump | true | When spark.task.reaper.enabled = true, this setting controls whether task thread dumps arelogged during periodic polling of killed tasks. Set this to false to disable collection of thread dumps. |
spark.task.reaper.killTimeout | -1 | When spark.task.reaper.enabled = true, this setting specifies a timeout after which theexecutor JVM will kill itself if a killed task has not stopped running. The default value, -1, disables this mechanism and prevents the executor from self-destructing. The purpose of this setting is to act as a safety-net to prevent runaway uncancellable tasks from rendering an executor unusable. |
Dynamic Allocation
| Property Name | Default | Meaning |
|---|---|---|
spark.dynamicAllocation.enabled | false | Whether to use dynamic resource allocation, which scales the number of executors registered with this application up and down based on the workload. For more detail, see the description here. This requires spark.shuffle.service.enabledto be set. The following configurations are also relevant: spark.dynamicAllocation.minExecutors,spark.dynamicAllocation.maxExecutors, and spark.dynamicAllocation.initialExecutors |
spark.dynamicAllocation.executorIdleTimeout | 60s | If dynamic allocation is enabled and an executor has been idle for more than this duration, the executor will be removed. For more detail, see this description. |
spark.dynamicAllocation.cachedExecutorIdleTimeout | infinity | If dynamic allocation is enabled and an executor which has cached data blocks has been idle for more than this duration, the executor will be removed. For more details, see this description. |
spark.dynamicAllocation.initialExecutors | spark.dynamicAllocation.minExecutors | Initial number of executors to run if dynamic allocation is enabled. If --num-executors (orspark.executor.instances) is set and larger than this value, it will be used as the initial number ofexecutors. |
spark.dynamicAllocation.maxExecutors | infinity | Upper bound for the number of executors if dynamic allocation is enabled. |
spark.dynamicAllocation.minExecutors | 0 | Lower bound for the number of executors if dynamic allocation is enabled. |
spark.dynamicAllocation.schedulerBacklogTimeout | 1s | If dynamic allocation is enabled and there have been pending tasks backlogged for more than this duration, new executors will be requested. For more detail, see this description. |
spark.dynamicAllocation.sustainedSchedulerBacklogTimeout | schedulerBacklogTimeout | Same as spark.dynamicAllocation.schedulerBacklogTimeout, but used only for subsequent executorrequests. For more detail, see this description. |
Security
| Property Name | Default | Meaning |
|---|---|---|
spark.acls.enable | false | Whether Spark acls should be enabled. If enabled, this checks to see if the user has access permissions to view or modify the job. Note this requires the user to be known, so if the user comes across as null no checks are done. Filters can be used with the UI to authenticate and set the user. |
spark.admin.acls | Empty | Comma separated list of users/administrators that have view and modify access to all Spark jobs. This can be used if you run on a shared cluster and have a set of administrators or devs who help debug when things do not work. Putting a ““ in the list means any user can have the privilege of admin. |
spark.admin.acls.groups | Empty | Comma separated list of groups that have view and modify access to all Spark jobs. This can be used if you have a set of administrators or developers who help maintain and debug the underlying infrastructure. Putting a ““ in the list means any user in any group can have the privilege of admin. The user groups are obtained from the instance of the groups mapping provider specified by spark.user.groups.mapping. Check the entry spark.user.groups.mapping for moredetails. |
spark.user.groups.mapping | org.apache.spark.security.ShellBasedGroupsMappingProvider | The list of groups for a user are determined by a group mapping service defined by the trait org.apache.spark.security.GroupMappingServiceProvider which can configured by this property. A default unix shell based implementation is provided org.apache.spark.security.ShellBasedGroupsMappingProvider which can be specified to resolve alist of groups for a user. Note: This implementation supports only a Unix/Linux based environment. Windows environment is currently not supported. However, a new platform/protocol can be supported by implementing the trait org.apache.spark.security.GroupMappingServiceProvider. |
spark.authenticate | false | Whether Spark authenticates its internal connections. See spark.authenticate.secret if notrunning on YARN. |
spark.authenticate.secret | None | Set the secret key used for Spark to authenticate between components. This needs to be set if not running on YARN and authentication is enabled. |
spark.authenticate.enableSaslEncryption | false | Enable encrypted communication when authentication is enabled. This is supported by the block transfer service and the RPC endpoints. |
spark.network.sasl.serverAlwaysEncrypt | false | Disable unencrypted connections for services that support SASL authentication. This is currently supported by the external shuffle service. |
spark.core.connection.ack.wait.timeout | spark.network.timeout | How long for the connection to wait for ack to occur before timing out and giving up. To avoid unwilling timeout caused by long pause like GC, you can set larger value. |
spark.core.connection.auth.wait.timeout | 30s | How long for the connection to wait for authentication to occur before timing out and giving up. |
spark.modify.acls | Empty | Comma separated list of users that have modify access to the Spark job. By default only the user that started the Spark job has access to modify it (kill it for example). Putting a ““ in the list means any user can have access to modify it. |
spark.modify.acls.groups | Empty | Comma separated list of groups that have modify access to the Spark job. This can be used if you have a set of administrators or developers from the same team to have access to control the job. Putting a ““ in the list means any user in any group has the access to modify the Spark job. The user groups are obtained from the instance of the groups mapping provider specified by spark.user.groups.mapping. Check theentry spark.user.groups.mapping for more details. |
spark.ui.filters | None | Comma separated list of filter class names to apply to the Spark web UI. The filter should be a standard javax servlet Filter. Parameters to each filter can also be specified by setting a java system property of: spark.<classFor example: -Dspark.ui.filters=com.test.filter1-Dspark.com.test.filter1.params=’param1=foo,param2=testing’ |
spark.ui.view.acls | Empty | Comma separated list of users that have view access to the Spark web ui. By default only the user that started the Spark job has view access. Putting a ““ in the list means any user can have view access to this Spark job. |
spark.ui.view.acls.groups | Empty | Comma separated list of groups that have view access to the Spark web ui to view the Spark Job details. This can be used if you have a set of administrators or developers or users who can monitor the Spark job submitted. Putting a ““ in the list means any user in any group can view the Spark job details on the Spark web ui. The user groups are obtained from the instance of the groups mapping provider specified by spark.user.groups.mapping.Check the entry spark.user.groups.mapping for more details. |
Encryption
| Property Name | Default | Meaning |
|---|---|---|
spark.ssl.enabled | false | Whether to enable SSL connections on all supported protocols. When spark.ssl.enabled isconfigured, spark.ssl.protocol is required. All the SSL settings like spark.ssl.xxx where xxx is a particular configuration property, denote the globalconfiguration for all the supported protocols. In order to override the global configuration for the particular protocol, the properties must be overwritten in the protocol-specific namespace. Use spark.ssl.YYY.XXXsettings to overwrite the global configuration for particular protocol denoted by YYY. Examplevalues for YYY include fs, ui, standalone, and historyServer.See SSL Configuration for details on hierarchical SSL configuration for services. |
spark.ssl.enabledAlgorithms | Empty | A comma separated list of ciphers. The specified ciphers must be supported by JVM. The reference list of protocols one can find on this page. Note: If not set, it will use the default cipher suites of JVM. |
spark.ssl.keyPassword | None | A password to the private key in key-store. |
spark.ssl.keyStore | None | A path to a key-store file. The path can be absolute or relative to the directory where the component is started in. |
spark.ssl.keyStorePassword | None | A password to the key-store. |
spark.ssl.keyStoreType | JKS | The type of the key-store. |
spark.ssl.protocol | None | A protocol name. The protocol must be supported by JVM. The reference list of protocols one can find on this page. |
spark.ssl.needClientAuth | false | Set true if SSL needs client authentication. |
spark.ssl.trustStore | None | A path to a trust-store file. The path can be absolute or relative to the directory where the component is started in. |
spark.ssl.trustStorePassword | None | A password to the trust-store. |
spark.ssl.trustStoreType | JKS | The type of the trust-store. |