Spark 設定

Spark 提供三個位置來組態系統

Spark 屬性

Spark 屬性控制大部分應用程式設定,並且針對每個應用程式個別組態。這些屬性可以直接設定在傳遞給 SparkContextSparkConf 上。 SparkConf 允許您組態一些常見屬性 (例如主控 URL 和應用程式名稱),以及透過 set() 方法設定任意的金鑰值配對。例如,我們可以初始化一個具有兩個執行緒的應用程式,如下所示

請注意,我們使用 local[2] 執行,表示兩個執行緒,這代表「最小」平行性,有助於偵測僅在分散式環境中執行時才會存在的錯誤。

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

請注意,我們可以在本地模式中擁有超過 1 個執行緒,在 Spark Streaming 等情況下,我們實際上可能需要超過 1 個執行緒來防止任何類型的資源不足問題。

指定某段時間持續時間的屬性應設定時間單位。接受下列格式

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/-c 旗標接受任何 Spark 屬性,但會針對在啟動 Spark 應用程式中扮演角色的屬性使用特殊旗標。執行 ./bin/spark-submit --help 將顯示這些選項的完整清單。

bin/spark-submit 也會從 conf/spark-defaults.conf 中讀取組態選項,其中每一行都包含一個金鑰和一個以空白分隔的值。例如

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

以旗標或在屬性檔案中指定的任何值都將傳遞給應用程式,並與透過 SparkConf 指定的值合併。直接在 SparkConf 上設定的屬性具有最高優先順序,然後是傳遞給 spark-submitspark-shell 的旗標,然後是 spark-defaults.conf 檔案中的選項。自 Spark 較早版本以來,一些組態金鑰已被重新命名;在這種情況下,較舊的金鑰名稱仍被接受,但優先順序低於較新金鑰的任何實例。

Spark 屬性主要可以分為兩種:一種與部署相關,例如「spark.driver.memory」、「spark.executor.instances」,這種屬性在執行階段透過 SparkConf 以程式方式設定時可能不受影響,或行為取決於您選擇的叢集管理員和部署模式,因此建議透過組態檔案或 spark-submit 命令列選項進行設定;另一種主要與 Spark 執行階段控制相關,例如「spark.task.maxFailures」,這種屬性可以用任何一種方式設定。

檢視 Spark 屬性

應用程式網頁使用者介面在 http://<driver>:4040 列出「環境」標籤中的 Spark 屬性。這是檢查屬性是否已正確設定的實用位置。請注意,只有透過 spark-defaults.confSparkConf 或命令列明確指定的數值才會顯示。對於所有其他組態屬性,您可以假設使用預設值。

可用屬性

控制內部設定的大部分屬性都有合理的預設值。一些最常見的設定選項為

應用程式屬性

屬性名稱預設值意義版本
spark.app.name (無) 應用程式的名稱。這將顯示在使用者介面和日誌資料中。 0.9.0
spark.driver.cores 1 僅在叢集模式中,供驅動程式程序使用的核心數。 1.3.0
spark.driver.maxResultSize 1g 每個 Spark 動作(例如收集)的所有分區序列化結果總大小限制(以位元組為單位)。應至少為 1M,或 0 表示無限制。如果總大小超過此限制,作業將會中止。設定較高的限制可能會導致驅動程式發生記憶體不足錯誤(取決於 spark.driver.memory 和 JVM 中物件的記憶體開銷)。設定適當的限制可以保護驅動程式免於發生記憶體不足錯誤。 1.2.0
spark.driver.memory 1g 供驅動程式程序使用的記憶體量,亦即 SparkContext 初始化的位置,格式與 JVM 記憶體字串相同,並附有大小單位字尾(「k」、「m」、「g」或「t」)(例如 512m2g)。
注意:在用戶端模式中,此組態不得透過應用程式中的 SparkConf 直接設定,因為驅動程式 JVM 已在該點啟動。請改為透過 --driver-memory 命令列選項或在您的預設屬性檔案中設定。
1.1.1
spark.driver.memoryOverhead driverMemory * spark.driver.memoryOverheadFactor,最小值為 384 在叢集模式中,每個驅動程式程序分配的非堆疊記憶體量,單位為 MiB,除非另有指定。這是用於計算 VM 開銷、內部字串、其他原生開銷等事項的記憶體。這會隨著容器大小而增加(通常為 6-10%)。目前在 YARN、Mesos 和 Kubernetes 上支援此選項。注意:非堆疊記憶體包括非堆外記憶體(當 spark.memory.offHeap.enabled=true)和由其他驅動程式程序(例如與 PySpark 驅動程式搭配的 python 程序)使用的記憶體,以及在同一個容器中執行的其他非驅動程式程序使用的記憶體。執行驅動程式的容器的最大記憶體大小由 spark.driver.memoryOverheadspark.driver.memory 的總和決定。 2.3.0
spark.driver.memoryOverheadFactor 0.10 在叢集模式中,每個驅動程式程序分配為額外非堆疊記憶體的驅動程式記憶體部分。這是用於計算 VM 開銷、內部字串、其他原生開銷等事項的記憶體。這會隨著容器大小而增加。此值預設為 0.10,但 Kubernetes 非 JVM 作業預設為 0.40。這是因為非 JVM 作業需要更多非 JVM 堆疊空間,而此類作業通常會因「記憶體開銷已超過」錯誤而失敗。這會以較高的預設值先發制人地避免此錯誤。如果直接設定 spark.driver.memoryOverhead,則會忽略此值。 3.3.0
spark.driver.resource.{resourceName}.amount 0 在驅動程式上使用的特定資源類型的數量。如果使用此選項,還必須指定 spark.driver.resource.{resourceName}.discoveryScript,以便驅動程式在啟動時尋找資源。 3.0.0
spark.driver.resource.{resourceName}.discoveryScript 驅動程式執行的腳本,用於發現特定資源類型。這應該以 ResourceInformation 類別的格式將 JSON 字串寫入 STDOUT。這有一個名稱和一個地址陣列。對於客戶端提交的驅動程式,發現腳本必須為此驅動程式指定與同一主機上的其他驅動程式不同的資源地址。 3.0.0
spark.driver.resource.{resourceName}.vendor 要為驅動程式使用的資源供應商。此選項目前僅在 Kubernetes 上受支援,並且實際上是供應商和網域,遵循 Kubernetes 裝置外掛程式命名慣例。(例如,對於 Kubernetes 上的 GPU,此設定會設為 nvidia.com 或 amd.com) 3.0.0
spark.resources.discoveryPlugin org.apache.spark.resource.ResourceDiscoveryScriptPlugin 要載入應用程式的實作 org.apache.spark.api.resource.ResourceDiscoveryPlugin 的類別名稱的逗號分隔清單。這是供進階使用者使用自訂實作取代資源發現類別。Spark 會嘗試每個指定的類別,直到其中一個類別傳回該資源的資源資訊。如果沒有任何外掛程式傳回該資源的資訊,它最後會嘗試發現腳本。 3.0.0
spark.executor.memory 1g 每個執行器程序使用的記憶體量,格式與 JVM 記憶體字串相同,並帶有大小單位字尾 ("k"、"m"、"g" 或 "t") (例如 512m2g)。 0.7.0
spark.executor.pyspark.memory 未設定 要分配給每個執行器中的 PySpark 的記憶體量,以 MiB 為單位,除非另有指定。如果設定,執行器的 PySpark 記憶體將限制為此數量。如果未設定,Spark 將不會限制 Python 的記憶體使用,應用程式必須避免超過與其他非 JVM 程序共用的額外記憶體空間。當 PySpark 在 YARN 或 Kubernetes 中執行時,此記憶體會新增到執行器資源要求。
注意:此功能依賴於 Python 的 `resource` 模組;因此,行為和限制會繼承自該模組。例如,Windows 不支援資源限制,而 MacOS 上的實際資源並未受到限制。
2.4.0
spark.executor.memoryOverhead executorMemory * spark.executor.memoryOverheadFactor,最小值為 384 每個執行器程序要分配的額外記憶體量,以 MiB 為單位,除非另有指定。這是考慮到 VM 額外負擔、內部字串、其他原生額外負擔等事物的記憶體。這會隨著執行器大小而增加 (通常為 6-10%)。此選項目前在 YARN 和 Kubernetes 上受支援。
注意:額外記憶體包括 PySpark 執行器記憶體 (當 spark.executor.pyspark.memory 未設定時) 和在同一容器中執行的其他非執行器程序使用的記憶體。執行執行器的容器的最大記憶體大小由 spark.executor.memoryOverheadspark.executor.memoryspark.memory.offHeap.sizespark.executor.pyspark.memory 的總和決定。
2.3.0
spark.executor.memoryOverheadFactor 0.10 每個執行器程序分配為額外非堆疊記憶體的執行器記憶體部分。此記憶體用於記錄 VM 開銷、內部字串、其他原生開銷等事項。此值通常會隨著容器大小而增加。此值預設為 0.10,但 Kubernetes 非 JVM 作業預設為 0.40。這是因為非 JVM 作業需要更多非 JVM 堆疊空間,且此類作業通常會因「記憶體開銷超過」錯誤而失敗。此值會以較高的預設值優先處理此錯誤。如果直接設定 spark.executor.memoryOverhead,則會忽略此值。 3.3.0
spark.executor.resource.{resourceName}.amount 0 每個執行器程序使用的特定資源類型數量。如果使用此設定,您還必須指定 spark.executor.resource.{resourceName}.discoveryScript,讓執行器在啟動時尋找資源。 3.0.0
spark.executor.resource.{resourceName}.discoveryScript 執行器執行的腳本,用於找出特定資源類型。此腳本應以 JSON 字串格式寫入 STDOUT,格式為 ResourceInformation 類別。此格式包含名稱和地址陣列。 3.0.0
spark.executor.resource.{resourceName}.vendor 執行器使用的資源供應商。目前僅在 Kubernetes 上支援此選項,實際上是供應商和網域,遵循 Kubernetes 裝置外掛命名慣例。(例如,對於 Kubernetes 上的 GPU,此設定會設為 nvidia.com 或 amd.com) 3.0.0
spark.extraListeners (無) 實作 SparkListener 的類別清單,以逗號分隔;初始化 SparkContext 時,這些類別的執行個體會建立並向 Spark 的監聽器匯流排註冊。如果類別具有接受 SparkConf 的單一引數建構函式,則會呼叫該建構函式;否則,會呼叫無引數建構函式。如果找不到有效的建構函式,SparkContext 建立會失敗並傳回例外狀況。 1.3.0
spark.local.dir /tmp Spark 中用於「暫存」空間的目錄,包括儲存在磁碟上的對應輸出檔案和 RDD。此目錄應位於系統中的快速本機磁碟上。它也可以是不同磁碟上多個目錄的逗號分隔清單。
注意:此設定會被群集管理員設定的 SPARK_LOCAL_DIRS (獨立式)、MESOS_SANDBOX (Mesos) 或 LOCAL_DIRS (YARN) 環境變數覆寫。
0.5.0
spark.logConf false 在 SparkContext 啟動時,將有效 SparkConf 記錄為 INFO。 0.9.0
spark.master (無) 要連線的叢集管理員。請參閱 允許的 Master URL 清單。 0.9.0
spark.submit.deployMode client Spark 驅動程式程式的部署模式,可以是「client」或「cluster」,意即在叢集內的其中一個節點上,以本機(「client」)或遠端(「cluster」)方式啟動驅動程式。 1.5.0
spark.log.callerContext (無) 在 Yarn/HDFS 上執行時,將寫入 Yarn RM 記錄/HDFS 稽核記錄的應用程式資訊。其長度取決於 Hadoop 設定 hadoop.caller.context.max.size。它應該簡潔,通常最多可以有 50 個字元。 2.2.0
spark.log.level (無) 設定時,會覆寫任何使用者定義的記錄設定,就像在 Spark 啟動時呼叫 SparkContext.setLogLevel() 一樣。有效的記錄層級包括:「ALL」、「DEBUG」、「ERROR」、「FATAL」、「INFO」、「OFF」、「TRACE」、「WARN」。 3.5.0
spark.driver.supervise false 如果為 true,則在驅動程式以非零退出狀態失敗時,自動重新啟動驅動程式。僅在 Spark 獨立模式或 Mesos 叢集部署模式中有效。 1.3.0
spark.driver.log.dfsDir (無) 如果 spark.driver.log.persistToDfs.enabled 為 true,則 Spark 驅動程式記錄同步到的基本目錄。在這個基本目錄內,每個應用程式會將驅動程式記錄記錄到特定應用程式的檔案中。使用者可能希望將其設定為統一的位置,例如 HDFS 目錄,以便可以保留驅動程式記錄檔案以供以後使用。任何 Spark 使用者都應該可以讀取/寫入這個目錄,而 Spark 歷史記錄伺服器使用者則可以刪除檔案。此外,如果 spark.history.fs.driverlog.cleaner.enabled 為 true,而且檔案早於透過設定 spark.history.fs.driverlog.cleaner.maxAge 設定的最大年齡,則 Spark 歷史記錄伺服器 會清除這個目錄中的較舊記錄。 3.0.0
spark.driver.log.persistToDfs.enabled false 如果為 true,則在 client 模式下執行的 Spark 應用程式會將驅動程式記錄寫入 spark.driver.log.dfsDir 中設定的持久性儲存體。如果未設定 spark.driver.log.dfsDir,則不會保留驅動程式記錄。此外,在 Spark 歷史記錄伺服器 中將 spark.history.fs.driverlog.cleaner.enabled 設定為 true 以啟用清除器。 3.0.0
spark.driver.log.layout %d{yy/MM/dd HH:mm:ss.SSS} %t %p %c{1}: %m%n%ex 同步到 spark.driver.log.dfsDir 的驅動程式記錄的版面配置。如果未設定此項,則會使用 log4j2.properties 中定義的第一個附加程式的版面配置。如果這項也未設定,則驅動程式記錄會使用預設版面配置。 3.0.0
spark.driver.log.allowErasureCoding false 是否允許驅動程式記錄使用消除編碼。在 HDFS 上,消除編碼的檔案不會像一般複製的檔案一樣快速更新,因此它們可能需要較長的時間才能反映應用程式寫入的變更。請注意,即使為 true,Spark 仍不會強制檔案使用消除編碼,它只會使用檔案系統預設值。 3.0.0
spark.decommission.enabled false 當 decommission 啟用時,Spark 會盡可能優雅地關閉執行器。當 spark.storage.decommission.enabled 啟用時,Spark 會嘗試將所有 RDD 區塊(由 spark.storage.decommission.rddBlocks.enabled 控制)和洗牌區塊(由 spark.storage.decommission.shuffleBlocks.enabled 控制)從 decommission 執行器移轉到遠端執行器。當 decommission 啟用時,Spark 也會在 spark.dynamicAllocation.enabled 啟用時 decommission 執行器,而不是終止執行器。 3.1.0
spark.executor.decommission.killInterval (無) 經過此時間後,外部(例如非 Spark)服務會強制終止 decommission 的執行器。 3.1.0
spark.executor.decommission.forceKillTimeout (無) 經過此時間後,Spark 會強制 decommission 的執行器退出。在大多數情況下,此設定應設為較高值,因為較低的值會讓區塊移轉沒有足夠的時間完成。 3.2.0
spark.executor.decommission.signal PWR 用於觸發執行器開始 decommission 的訊號。 3.2.0
spark.executor.maxNumFailures numExecutors * 2,最小值為 3 在應用程式失敗前,執行器失敗的最大次數。此設定僅在 YARN 或 Kubernetes 中有效,當 `spark.kubernetes.allocation.pods.allocator` 設為 'direct' 時。 3.5.0
spark.executor.failuresValidityInterval (無) 經過此時間後,執行器失敗將被視為獨立的事件,不會累積到嘗試次數中。此設定僅在 YARN 或 Kubernetes 中有效,當 `spark.kubernetes.allocation.pods.allocator` 設為 'direct' 時。 3.5.0

除了這些,下列屬性也可用,且在某些情況下可能很有用

執行時間環境

屬性名稱預設值意義版本
spark.driver.extraClassPath (無) 要加到驅動程式類別路徑開頭的額外類別路徑項目。
注意:在用戶端模式中,此設定不能透過應用程式中的 SparkConf 直接設定,因為驅動程式 JVM 在那時已經啟動。請改用 --driver-class-path 命令列選項或在預設屬性檔中設定。
1.0.0
spark.driver.defaultJavaOptions (無) 要加到 spark.driver.extraJavaOptions 開頭的預設 JVM 選項字串。此設定預計由管理員設定。例如,GC 設定或其他記錄。請注意,使用此選項設定最大堆積大小 (-Xmx) 設定是非法的。最大堆積大小設定可以在叢集模式中使用 spark.driver.memory 設定,在用戶端模式中使用 --driver-memory 命令列選項設定。
注意:在客戶端模式中,此設定不可透過應用程式中的 SparkConf 直接設定,因為驅動程式 JVM 已在該點啟動。請改用 --driver-java-options 命令列選項或在預設屬性檔案中設定。
3.0.0
spark.driver.extraJavaOptions (無) 傳遞給驅動程式的額外 JVM 選項字串。這應由使用者設定。例如,GC 設定或其他記錄。請注意,使用此選項設定最大堆積大小 (-Xmx) 設定是非法的。最大堆積大小設定可在叢集模式中使用 spark.driver.memory 設定,在客戶端模式中則透過 --driver-memory 命令列選項設定。
注意:在客戶端模式中,此設定不可透過應用程式中的 SparkConf 直接設定,因為驅動程式 JVM 已在該點啟動。請改用 --driver-java-options 命令列選項或在預設屬性檔案中設定。spark.driver.defaultJavaOptions 會加到此設定之前。
1.0.0
spark.driver.extraLibraryPath (無) 設定啟動驅動程式 JVM 時要使用的特殊函式庫路徑。
注意:在客戶端模式中,此設定不可透過應用程式中的 SparkConf 直接設定,因為驅動程式 JVM 已在該點啟動。請改用 --driver-library-path 命令列選項或在預設屬性檔案中設定。
1.0.0
spark.driver.userClassPathFirst false (實驗性質)在驅動程式中載入類別時,是否讓使用者新增的 jar 優先於 Spark 自有的 jar。此功能可用於減輕 Spark 相依項與使用者相依項之間的衝突。目前為實驗性質功能。僅用於叢集模式。 1.3.0
spark.executor.extraClassPath (無) 額外類別路徑,加到執行緒類別路徑之前。這主要是為了與舊版 Spark 的向下相容性。使用者通常不需要設定此選項。 1.0.0
spark.executor.defaultJavaOptions (無) 預設 JVM 選項字串,加到 spark.executor.extraJavaOptions 之前。這應由管理員設定。例如,GC 設定或其他記錄。請注意,使用此選項設定 Spark 屬性或最大堆積大小 (-Xmx) 設定是非法的。Spark 屬性應使用 SparkConf 物件或 spark-submit 腳本使用的 spark-defaults.conf 檔案設定。最大堆積大小設定可用 spark.executor.memory 設定。如果存在,下列符號會進行內插:會替換為應用程式 ID,會替換為執行緒 ID。例如,要在 /tmp 中針對應用程式的執行緒 ID 啟用詳細 gc 記錄到檔案,請傳遞「值」:-verbose:gc -Xloggc:/tmp/-.gc 3.0.0
spark.executor.extraJavaOptions (無) 傳遞給執行器的額外 JVM 選項字串。這是供使用者設定的。例如,GC 設定或其他記錄。請注意,使用此選項設定 Spark 屬性或最大堆積大小 (-Xmx) 設定是非法的。應使用 SparkConf 物件或 spark-submit 腳本使用的 spark-defaults.conf 檔案設定 Spark 屬性。最大堆積大小設定可以使用 spark.executor.memory 設定。如果存在,下列符號將會內插:將會以應用程式 ID 取代,而將會以執行器 ID 取代。例如,若要將詳細的 gc 記錄啟用到 /tmp 中應用程式的執行器 ID 命名之檔案,請傳遞下列的「值」:-verbose:gc -Xloggc:/tmp/-.gc spark.executor.defaultJavaOptions 將會預先加到此組態中。 1.0.0
spark.executor.extraLibraryPath (無) 啟動執行器 JVM 時設定要使用的特殊函式庫路徑。 1.0.0
spark.executor.logs.rolling.maxRetainedFiles -1 設定系統將保留的最新滾動記錄檔數目。較舊的記錄檔將會刪除。預設為停用。 1.1.0
spark.executor.logs.rolling.enableCompression false 啟用執行器記錄壓縮。如果啟用,已滾動的執行器記錄將會壓縮。預設為停用。 2.0.2
spark.executor.logs.rolling.maxSize 1024 * 1024 設定執行器記錄將會滾動的檔案最大大小(以位元組為單位)。預設停用滾動。請參閱 spark.executor.logs.rolling.maxRetainedFiles 以自動清除舊記錄。 1.4.0
spark.executor.logs.rolling.strategy (無) 設定執行器記錄滾動策略。預設為停用。可以設定為「時間」(基於時間的滾動)或「大小」(基於大小的滾動)。對於「時間」,請使用 spark.executor.logs.rolling.time.interval 設定滾動間隔。對於「大小」,請使用 spark.executor.logs.rolling.maxSize 設定滾動的最大檔案大小。 1.1.0
spark.executor.logs.rolling.time.interval daily 設定執行器記錄將會滾動的時間間隔。預設停用滾動。有效值為 dailyhourlyminutely 或任何以秒為單位的間隔。請參閱 spark.executor.logs.rolling.maxRetainedFiles 以自動清除舊記錄。 1.1.0
spark.executor.userClassPathFirst false (實驗性質)與 spark.driver.userClassPathFirst 相同的功能,但套用於執行器執行個體。 1.3.0
spark.executorEnv.[EnvironmentVariableName] (無) EnvironmentVariableName 指定的環境變數新增至執行器程序。使用者可以指定多個來設定多個環境變數。 0.9.0
spark.redaction.regex (?i)secret|password|token|access[.]key 正規表示法用於決定驅動程式和執行器環境中哪些 Spark 組態屬性和環境變數包含機密資訊。當此正規表示法符合屬性金鑰或值時,值會從環境 UI 和各種記錄(例如 YARN 和事件記錄)中移除。 2.1.2
spark.redaction.string.regex (無) 決定 Spark 產生的字串哪一部分包含敏感資訊的正規表示法。當這個正規表示法符合字串的一部分時,該字串的部分會被替換成一個虛擬值。這目前用於編輯 SQL 解釋指令的輸出。 2.2.0
spark.python.profile false 在 Python 工作器中啟用剖析,剖析結果會顯示在 sc.show_profiles() 中,或是在驅動程式結束前顯示。它也可以透過 sc.dump_profiles(path) 轉儲到磁碟。如果某些剖析結果已手動顯示,則在驅動程式結束前不會自動顯示。預設會使用 pyspark.profiler.BasicProfiler,但這可以透過將剖析器類別傳遞為參數給 SparkContext 建構函數來覆寫。 1.2.0
spark.python.profile.dump (無) 在驅動程式結束前用來轉儲剖析結果的目錄。結果會以每個 RDD 分別的檔案轉儲。它們可以用 pstats.Stats() 載入。如果指定這個,剖析結果不會自動顯示。 1.2.0
spark.python.worker.memory 512m 在聚合期間每個 Python 工作器程序使用的記憶體量,格式與 JVM 記憶體字串相同,並帶有大小單位字尾(「k」、「m」、「g」或「t」)(例如 512m2g)。如果在聚合期間使用的記憶體超過這個量,它會將資料溢位到磁碟。 1.1.0
spark.python.worker.reuse true 是否重複使用 Python 工作器。如果是,它會使用固定數量的 Python 工作器,不需要為每個工作分派(fork())一個 Python 程序。如果有一個大型廣播,這會非常有用,那麼廣播不需要為每個工作從 JVM 傳輸到 Python 工作器。 1.2.0
spark.files 要放置在每個執行器工作目錄中的檔案的逗號分隔清單。允許使用萬用字元。 1.0.0
spark.submit.pyFiles 要放置在 Python 應用程式 PYTHONPATH 上的 .zip、.egg 或 .py 檔案的逗號分隔清單。允許使用萬用字元。 1.0.1
spark.jars 要包含在驅動程式和執行器類別路徑中的 jar 檔案的逗號分隔清單。允許使用萬用字元。 0.9.0
spark.jars.packages 包含在驅動程式和執行器類別路徑中的 jar 的 Maven 座標的逗號分隔清單。座標應為 groupId:artifactId:version。如果給定 spark.jars.ivySettings,則會根據檔案中的組態解析人工製品,否則會在本地 maven 儲存庫中搜尋人工製品,然後是 maven central,最後是命令列選項 --repositories 給出的任何其他遠端儲存庫。如需更多詳細資訊,請參閱 進階相依性管理 1.5.0
spark.jars.excludes groupId:artifactId 的逗號分隔清單,在解析 spark.jars.packages 中提供的相依性時排除,以避免相依性衝突。 1.5.0
spark.jars.ivy 用於指定 Ivy 使用者目錄的路徑,用於 spark.jars.packages 的本地 Ivy 快取和套件檔案。這將覆寫 Ivy 屬性 ivy.default.ivy.user.dir,其預設為 ~/.ivy2。 1.3.0
spark.jars.ivySettings Ivy 設定檔的路徑,用於自訂使用 spark.jars.packages 指定的 jar 的解析,而不是內建預設值,例如 maven central。命令列選項 --repositoriesspark.jars.repositories 給出的其他儲存庫也會包含在內。對於允許 Spark 從防火牆後方解析人工製品很有用,例如透過內部人工製品伺服器,例如 Artifactory。設定檔格式的詳細資訊可以在 設定檔 中找到。僅支援具有 file:// 架構的路徑。沒有架構的路徑假設具有 file:// 架構。

在 YARN 集群模式下執行時,此檔案也會在地端化到遠端驅動程式,以便在 SparkContext#addJar 中解析相依性

2.2.0
spark.jars.repositories 逗號分隔的額外遠端儲存庫清單,用於搜尋使用 --packagesspark.jars.packages 給出的 maven 座標。 2.3.0
spark.archives 要解壓縮到每個執行器工作目錄的檔案的逗號分隔清單。支援 .jar、.tar.gz、.tgz 和 .zip。您可以透過在檔案名稱後加上 # 來指定要解壓縮的目錄名稱,例如 file.zip#directory。此組態為實驗性質。 3.1.0
spark.pyspark.driver.python PySpark 在驅動程式中使用的 Python 二進制可執行檔。(預設值為 spark.pyspark.python 2.1.0
spark.pyspark.python PySpark 在驅動程式和執行器中使用的 Python 二進制可執行檔。 2.1.0

洗牌行為

屬性名稱預設值意義版本
spark.reducer.maxSizeInFlight 48m 從每個縮減工作同時擷取的地圖輸出的最大大小,以 MiB 為單位,除非另有指定。由於每個輸出都需要我們建立一個緩衝區來接收它,因此這表示每個縮減工作都有固定的記憶體開銷,所以除非您有大量的記憶體,否則請保持較小。 1.4.0
spark.reducer.maxReqsInFlight Int.MaxValue 此組態會限制在任何特定時間點擷取區塊的遠端要求數量。當叢集中的主機數量增加時,可能會導致與一個或多個節點有大量的入站連線,導致工作人員在負載下發生故障。透過允許它限制擷取要求的數量,可以減輕此情況。 2.0.0
spark.reducer.maxBlocksInFlightPerAddress Int.MaxValue 此組態會限制從特定主機埠擷取的遠端區塊數量,以縮減工作為單位。當從特定地址在單一擷取或同時擷取大量區塊時,可能會使提供服務的執行器或節點管理員崩潰。當啟用外部洗牌時,這對於降低節點管理員的負載特別有用。您可以將其設定為較低的值來減輕此問題。 2.2.1
spark.shuffle.compress true 是否壓縮地圖輸出檔案。通常是個好主意。壓縮將使用 spark.io.compression.codec 0.6.0
spark.shuffle.file.buffer 32k 每個洗牌檔案輸出串流的記憶體中緩衝區大小,以 KiB 為單位,除非另有指定。這些緩衝區會減少在建立中間洗牌檔案時進行的磁碟尋址和系統呼叫次數。 1.4.0
spark.shuffle.unsafe.file.output.buffer 32k 在每個分割寫入不安全的洗牌寫入器後,此緩衝區大小的檔案系統。以 KiB 為單位,除非另有指定。 2.3.0
spark.shuffle.spill.diskWriteBufferSize 1024 * 1024 將排序記錄寫入磁碟檔案時要使用的緩衝區大小(以位元組為單位)。 2.3.0
spark.shuffle.io.maxRetries 3 (僅 Netty)如果此設定值為非零值,則會自動重試因 IO 相關例外狀況而失敗的擷取。此重試邏輯有助於在長時間 GC 暫停或暫時網路連線問題的情況下,穩定大型混排。 1.2.0
spark.shuffle.io.numConnectionsPerPeer 1 (僅 Netty)為了減少大型叢集的連線建立,會重複使用主機之間的連線。對於具有許多硬碟和少數主機的叢集,這可能會導致並行度不足以讓所有硬碟飽和,因此使用者可以考慮增加此值。 1.2.1
spark.shuffle.io.preferDirectBufs true (僅 Netty)非堆積緩衝區用於在混排和快取區塊傳輸期間減少垃圾回收。對於非堆積記憶體受到嚴格限制的環境,使用者可能希望關閉此功能,以強制 Netty 中的所有配置都在堆積上。 1.2.0
spark.shuffle.io.retryWait 5s (僅 Netty)重試擷取之間的等待時間。預設情況下,重試造成的最大延遲為 15 秒,計算方式為 maxRetries * retryWait 1.2.1
spark.shuffle.io.backLog -1 混排服務的接受佇列長度。對於大型應用程式,可能需要增加此值,以便在服務無法在短時間內處理大量連線時,不會中斷傳入的連線。這需要在混排服務本身執行的任何地方進行設定,這可能在應用程式之外(請參閱下方的 spark.shuffle.service.enabled 選項)。如果設定低於 1,將會回退至 Netty 的 io.netty.util.NetUtil#SOMAXCONN 定義的作業系統預設值。 1.1.1
spark.shuffle.io.connectionTimeout spark.network.timeout 的值 在混排伺服器和用戶端之間建立的連線的逾時時間,如果仍有未完成的擷取要求,但頻道至少在 `connectionTimeout` 中沒有流量,則會將其標記為閒置並關閉。 1.2.0
spark.shuffle.io.connectionCreationTimeout spark.shuffle.io.connectionTimeout 的值 在混排伺服器和用戶端之間建立連線的逾時時間。 3.2.0
spark.shuffle.service.enabled false 啟用外部混排服務。此服務會保留執行緒所寫入的混排檔案,例如,以便可以安全地移除執行緒,或是在執行緒發生故障時,混排擷取可以繼續進行。必須設定外部混排服務才能啟用它。請參閱 動態配置和設定文件 以取得更多資訊。 1.2.0
spark.shuffle.service.port 7337 外部混排服務將執行的埠。 1.2.0
spark.shuffle.service.name spark_shuffle 用戶端應與之通訊的 Spark 混排服務的已設定名稱。這必須與用於在 YARN NodeManager 設定(yarn.nodemanager.aux-services)中設定混排的名稱相符。僅在將 spark.shuffle.service.enabled 設定為 true 時才會生效。 3.2.0
spark.shuffle.service.index.cache.size 100 公尺 快取項目限制在指定的記憶體佔用空間,以位元組為單位,除非另有說明。 2.3.0
spark.shuffle.service.removeShuffle false 當不再需要混排時,是否使用 ExternalShuffleService 刪除已解除配置執行器的混排區塊。如果未啟用此功能,已解除配置執行器上的混排資料將保留在磁碟上,直到應用程式結束。 3.3.0
spark.shuffle.maxChunksBeingTransferred Long.MAX_VALUE 在混排服務上同時允許傳輸的區塊最大數量。請注意,當達到最大數量時,新的傳入連線將會關閉。如果達到這些限制,客戶端將根據混排重試設定(請參閱 spark.shuffle.io.maxRetriesspark.shuffle.io.retryWait)重試,如果任務將會因擷取失敗而失敗。 2.3.0
spark.shuffle.sort.bypassMergeThreshold 200 (進階)在基於排序的混排管理員中,如果沒有地圖端聚合,且最多只有這麼多減少區段,則避免合併排序資料。 1.1.1
spark.shuffle.sort.io.plugin.class org.apache.spark.shuffle.sort.io.LocalDiskShuffleDataIO 用於混排 I/O 的類別名稱。 3.0.0
spark.shuffle.spill.compress true 是否在混排期間壓縮溢出的資料。壓縮將使用 spark.io.compression.codec 0.9.0
spark.shuffle.accurateBlockThreshold 100 * 1024 * 1024 HighlyCompressedMapStatus 中混排區塊大小準確記錄的位元組閾值。這有助於避免在擷取混排區塊時低估混排區塊大小,從而防止 OOM。 2.2.1
spark.shuffle.registration.timeout 5000 向外部混排服務註冊的逾時時間(毫秒)。 2.3.0
spark.shuffle.registration.maxAttempts 3 當我們無法向外部混排服務註冊時,我們將重試 maxAttempts 次。 2.3.0
spark.shuffle.reduceLocality.enabled true 是否為減少任務計算區域偏好設定。 1.5.0
spark.shuffle.mapOutput.minSizeForBroadcast 512k 我們使用廣播將地圖輸出狀態傳送給執行器的規模。 2.0.0
spark.shuffle.detectCorrupt true 是否偵測擷取區塊中的任何損毀。 2.2.0
spark.shuffle.detectCorrupt.useExtraMemory false 如果啟用,一部份壓縮/加密串流將透過使用額外記憶體來解壓縮/解密,以偵測早期損毀。任何引發的 IOException 都會導致任務重試一次,如果再次因相同例外狀況而失敗,則會引發 FetchFailedException 以重試前一階段。 3.0.0
spark.shuffle.useOldFetchProtocol false 在執行混排區塊擷取時是否使用舊通訊協定。它只會在我們需要相容性時啟用,在這種情況下,新 Spark 版本工作會從舊版本外部混排服務擷取混排區塊。 3.0.0
spark.shuffle.readHostLocalDisk true 如果啟用(且 spark.shuffle.useOldFetchProtocol 已停用),則會直接從磁碟讀取從在相同主機上執行的那些區塊管理員要求的混排區塊,而不是透過網路作為遠端區塊擷取。 3.0.0
spark.files.io.connectionTimeout spark.network.timeout 的值 在 Spark RPC 環境中,如果仍有未下載完成的檔案,但頻道中至少 `connectionTimeout` 沒有流量,則會將用於擷取檔案的已建立連線逾時,並將其標記為閒置和關閉。 1.6.0
spark.files.io.connectionCreationTimeout spark.files.io.connectionTimeout 的值 在 Spark RPC 環境中,建立連線以擷取檔案的逾時。 3.2.0
spark.shuffle.checksum.enabled true 是否計算混洗資料的檢查總和。如果啟用,Spark 會計算映射輸出檔案中每個分割資料的檢查總和值,並將這些值儲存在磁碟上的檢查總和檔案中。當偵測到混洗資料損毀時,Spark 會嘗試使用檢查總和檔案診斷損毀的原因(例如,網路問題、磁碟問題等)。 3.2.0
spark.shuffle.checksum.algorithm ADLER32 演算法用於計算混洗檢查總和。目前,它僅支援 JDK 的內建演算法,例如 ADLER32、CRC32。 3.2.0
spark.shuffle.service.fetch.rdd.enabled false 是否使用 ExternalShuffleService 擷取磁碟持續性 RDD 區塊。如果啟用此功能,在動態配置的情況下,只有磁碟持續性區塊的執行器會在 spark.dynamicAllocation.executorIdleTimeout 後被視為閒置,並會相應地釋放。 3.0.0
spark.shuffle.service.db.enabled true 是否在 ExternalShuffleService 中使用資料庫。請注意,這只會影響獨立模式。 3.0.0
spark.shuffle.service.db.backend LEVELDB 指定混洗服務本地資料庫中使用的基於磁碟的儲存。設定為 LEVELDB 或 ROCKSDB。 3.4.0

Spark UI

屬性名稱預設值意義版本
spark.eventLog.logBlockUpdates.enabled false 如果 spark.eventLog.enabled 為 true,則記錄每個區塊更新的事件。*警告*:這會大幅增加事件記錄的大小。 2.3.0
spark.eventLog.longForm.enabled false 如果為 true,則在事件記錄中使用呼叫站點的長格式。否則,使用短格式。 2.4.0
spark.eventLog.compress false 如果 spark.eventLog.enabled 為 true,則壓縮記錄的事件。 1.0.0
spark.eventLog.compression.codec zstd 用於壓縮記錄事件的編解碼器。預設情況下,Spark 提供四種編解碼器:lz4lzfsnappyzstd。您也可以使用完全限定的類別名稱來指定編解碼器,例如 org.apache.spark.io.LZ4CompressionCodecorg.apache.spark.io.LZFCompressionCodecorg.apache.spark.io.SnappyCompressionCodecorg.apache.spark.io.ZStdCompressionCodec 3.0.0
spark.eventLog.erasureCoding.enabled false 無論檔案系統預設值為何,是否允許事件記錄使用消除編碼,或關閉消除編碼。在 HDFS 上,消除編碼檔案的更新速度不如一般複製檔案快,因此應用程式更新會花較長時間才會出現在歷史記錄伺服器中。請注意,即使為 true,Spark 仍不會強制檔案使用消除編碼,它只會使用檔案系統預設值。 3.0.0
spark.eventLog.dir file:///tmp/spark-events 如果 spark.eventLog.enabled 為 true,則 Spark 事件記錄在其中的基本目錄。在這個基本目錄中,Spark 會為每個應用程式建立一個子目錄,並將特定於應用程式的事件記錄到這個目錄中。使用者可能希望將其設定為統一的位置,例如 HDFS 目錄,以便歷史伺服器可以讀取歷史檔案。 1.0.0
spark.eventLog.enabled false 是否記錄 Spark 事件,這對於在應用程式完成後重建 Web UI 很有用。 1.0.0
spark.eventLog.overwrite false 是否覆寫任何現有檔案。 1.0.0
spark.eventLog.buffer.kb 100k 寫入輸出串流時要使用的緩衝區大小,除非另有指定,否則以 KiB 為單位。 1.0.0
spark.eventLog.rolling.enabled false 是否啟用事件記錄檔的滾動。如果設定為 true,它會將每個事件記錄檔縮減為設定的大小。 3.0.0
spark.eventLog.rolling.maxFileSize 128m spark.eventLog.rolling.enabled=true 時,指定事件記錄檔在滾動之前的大小上限。 3.0.0
spark.ui.dagGraph.retainedRootRDDs Int.MaxValue 在垃圾收集之前,Spark UI 和狀態 API 記住多少個 DAG 圖形節點。 2.1.0
spark.ui.enabled true 是否為 Spark 應用程式執行 Web UI。 1.1.1
spark.ui.store.path 用於快取即時 UI 應用程式資訊的本地目錄。預設情況下,未設定此項,表示所有應用程式資訊都將保留在記憶體中。 3.4.0
spark.ui.killEnabled true 允許從 Web UI 中終止工作和階段。 1.0.0
spark.ui.liveUpdate.period 100ms 更新即時實體的頻率。-1 表示在重播應用程式時「永不更新」,表示只會執行最後一次寫入。對於即時應用程式,當快速處理傳入的任務事件時,這可以避免一些我們可以忍受的操作。 2.3.0
spark.ui.liveUpdate.minFlushPeriod 1s 過時的 UI 資料沖刷之前的最小經過時間。當傳入的任務事件不頻繁觸發時,這可以避免 UI 過時。 2.4.2
spark.ui.port 4040 應用程式儀表板的埠,其中顯示記憶體和工作負載資料。 0.7.0
spark.ui.retainedJobs 1000 在垃圾收集之前,Spark UI 和狀態 API 記住多少個工作。這是一個目標上限,在某些情況下可能會保留較少的元素。 1.2.0
spark.ui.retainedStages 1000 在垃圾收集之前,Spark UI 和狀態 API 記住多少個階段。這是一個目標上限,在某些情況下可能會保留較少的元素。 0.9.0
spark.ui.retainedTasks 100000 在垃圾收集之前,Spark UI 和狀態 API 記住一個階段中的多少個任務。這是一個目標上限,在某些情況下可能會保留較少的元素。 2.0.1
spark.ui.reverseProxy false 啟用將 Spark Master 作為工作人員和應用程式 UI 的反向代理執行。在此模式中,Spark master 將反向代理工作人員和應用程式 UI,以便在不需要直接存取其主機的情況下啟用存取。請小心使用,因為工作人員和應用程式 UI 將無法直接存取,您只能透過 spark master/proxy 公共 URL 存取它們。此設定會影響群集中執行的所有工作人員和應用程式 UI,並且必須設定在所有工作人員、驅動程式和 master 上。 2.1.0
spark.ui.reverseProxyUrl 如果 Spark UI 應透過另一個前端反向代理伺服,這是透過該反向代理存取 Spark 主控端 UI 的 URL。這在執行代理進行驗證時很有用,例如 OAuth 代理。URL 可能包含路徑前置詞,例如 http://mydomain.com/path/to/spark/,讓您能透過相同的虛擬主機和埠為多個 Spark 群集和其他網路應用程式提供 UI 服務。一般來說,這應該是包含通訊協定 (http/https)、主機和埠的絕對 URL。您可以在這裡指定以「/」開頭的相對 URL。在這種情況下,Spark UI 和 Spark REST API 產生的所有 URL 都會是伺服器相關連結,這仍然有效,因為整個 Spark UI 都是透過相同的主機和埠提供服務。
此設定會影響 Spark UI 中的連結產生,但前端反向代理負責
  • 在轉發要求之前移除路徑前置詞,
  • 改寫直接指向 Spark 主控端的重新導向,
  • 將存取從 http://mydomain.com/path/to/spark 重新導向到 http://mydomain.com/path/to/spark/ (路徑前置詞後的尾斜線);否則主頁上的相對連結無法正常運作。
此設定會影響在群集中執行的所有工作人員和應用程式 UI,且必須在所有工作人員、驅動程式和主控端上設定相同。只有在啟用 spark.ui.reverseProxy 時,此設定才會生效。當 Spark 主控端網路 UI 可直接存取時,不需要此設定。
請注意,此設定的值在以「/」分隔後,不能包含關鍵字「proxy」或「history」。Spark UI 仰賴這兩個關鍵字從 URI 取得 REST API 端點。
2.1.0
spark.ui.proxyRedirectUri 當 Spark 在代理伺服器後方執行時,重新導向應導向何處。這會讓 Spark 修改重新導向回應,使其指向代理伺服器,而非 Spark UI 本身的位址。這應僅為伺服器的位址,不含任何應用程式的路徑前置詞;前置詞應由代理伺服器本身設定 (透過新增 X-Forwarded-Context 要求標頭),或透過在 Spark 應用程式的組態中設定代理基礎。 3.0.0
spark.ui.showConsoleProgress false 在主控台中顯示進度條。進度條會顯示執行時間超過 500 毫秒的階段進度。如果多個階段同時執行,多個進度條會顯示在同一行上。
注意:在 shell 環境中,spark.ui.showConsoleProgress 的預設值為 true。
1.2.1
spark.ui.custom.executor.log.url (無) 指定自訂 Spark 執行器記錄 URL,以支援外部記錄服務,而非在 Spark UI 中使用群集管理員的應用程式記錄 URL。Spark 會透過模式支援一些路徑變數,這些模式可能因群集管理員而異。請查看群集管理員的說明文件,以了解支援哪些模式 (如有)。

請注意,此組態也會取代事件記錄中的原始記錄 URL,這在歷史伺服器上存取應用程式時也會生效。新的記錄 URL 必須是永久的,否則執行器記錄 URL 可能會有失效連結。

目前,只有 YARN 模式支援此組態

3.0.0
spark.worker.ui.retainedExecutors 1000 Spark UI 和狀態 API 在垃圾回收之前記住的已完成執行器數量。 1.5.0
spark.worker.ui.retainedDrivers 1000 Spark UI 和狀態 API 在垃圾回收之前記住的已完成驅動程序數量。 1.5.0
spark.sql.ui.retainedExecutions 1000 Spark UI 和狀態 API 在垃圾回收之前記住的已完成執行數量。 1.5.0
spark.streaming.ui.retainedBatches 1000 Spark UI 和狀態 API 在垃圾回收之前記住的已完成批次數量。 1.0.0
spark.ui.retainedDeadExecutors 100 Spark UI 和狀態 API 在垃圾回收之前記住的已死執行器數量。 2.0.0
spark.ui.filters 要套用至 Spark 網路 UI 的過濾器類別名稱的逗號分隔清單。過濾器應為標準 javax servlet 過濾器
過濾器參數也可以在組態中指定,方法是設定 spark.<過濾器類別名稱>.param.<參數名稱>=<值> 形式的組態項目。
例如
spark.ui.filters=com.test.filter1
spark.com.test.filter1.param.name1=foo
spark.com.test.filter1.param.name2=bar
1.0.0
spark.ui.requestHeaderSize 8k HTTP 要求標頭允許的最大大小,以位元組為單位,除非另有指定。此設定也適用於 Spark 歷史記錄伺服器。 2.2.3
spark.ui.timelineEnabled true 是否在 UI 頁面上顯示事件時間軸資料。 3.4.0
spark.ui.timeline.executors.maximum 250 事件時間軸中顯示的最大執行器數量。 3.2.0
spark.ui.timeline.jobs.maximum 500 事件時間軸中顯示的最大工作數量。 3.2.0
spark.ui.timeline.stages.maximum 500 事件時間軸中顯示的最大階段數量。 3.2.0
spark.ui.timeline.tasks.maximum 1000 事件時間軸中顯示的最大任務數量。 1.4.0
spark.appStatusStore.diskStoreDir 儲存 SQL 執行診斷資訊的本機目錄。此組態僅適用於即時 UI。 3.4.0

壓縮和序列化

屬性名稱預設值意義版本
spark.broadcast.compress true 是否在傳送廣播變數之前將其壓縮。通常是個好主意。壓縮將使用 spark.io.compression.codec 0.6.0
spark.checkpoint.compress false 是否壓縮 RDD 檢查點。通常是個好主意。壓縮將使用 spark.io.compression.codec 2.2.0
spark.io.compression.codec lz4 用於壓縮內部資料(例如 RDD 分割區、事件記錄、廣播變數和洗牌輸出)的編碼器。預設情況下,Spark 提供四種編碼器:lz4lzfsnappyzstd。您也可以使用完全限定的類別名稱來指定編碼器,例如 org.apache.spark.io.LZ4CompressionCodecorg.apache.spark.io.LZFCompressionCodecorg.apache.spark.io.SnappyCompressionCodecorg.apache.spark.io.ZStdCompressionCodec 0.8.0
spark.io.compression.lz4.blockSize 32k 當使用 LZ4 壓縮編解碼器時,LZ4 壓縮中使用的區塊大小。降低此區塊大小也會降低在使用 LZ4 時的洗牌記憶體使用量。除非另有指定,否則預設單位為位元組。此組態僅適用於 `spark.io.compression.codec`。 1.4.0
spark.io.compression.snappy.blockSize 32k 當使用 Snappy 壓縮編解碼器時,Snappy 壓縮中的區塊大小。降低此區塊大小也會降低在使用 Snappy 時的洗牌記憶體使用量。除非另有指定,否則預設單位為位元組。此組態僅適用於 `spark.io.compression.codec`。 1.4.0
spark.io.compression.zstd.level 1 Zstd 壓縮編解碼器的壓縮等級。提高壓縮等級將以更高的 CPU 和記憶體消耗為代價,獲得更好的壓縮效果。此組態僅適用於 `spark.io.compression.codec`。 2.3.0
spark.io.compression.zstd.bufferSize 32k 當使用 Zstd 壓縮編解碼器時,Zstd 壓縮中使用的緩衝區大小(以位元組為單位)。降低此大小將降低在使用 Zstd 時的洗牌記憶體使用量,但由於過多的 JNI 呼叫開銷,這可能會增加壓縮成本。此組態僅適用於 `spark.io.compression.codec`。 2.3.0
spark.io.compression.zstd.bufferPool.enabled true 如果為 true,則啟用 ZSTD JNI 函式庫的緩衝區池。 3.2.0
spark.kryo.classesToRegister (無) 如果您使用 Kryo 序列化,請提供一個自訂類別名稱的逗號分隔清單,以向 Kryo 註冊。請參閱調整指南以取得更多詳細資訊。 1.2.0
spark.kryo.referenceTracking true 使用 Kryo 序列化資料時,是否追蹤對同一個物件的參照,這在您的物件圖形有迴圈時是必要的,而且如果它們包含同一個物件的複本,則對於效率很有幫助。如果您知道這不是這種情況,可以停用它以提升效能。 0.8.0
spark.kryo.registrationRequired false 是否需要向 Kryo 註冊。如果設定為「true」,則在序列化未註冊的類別時,Kryo 會擲回例外。如果設定為 false(預設值),Kryo 會在每個物件中寫入未註冊的類別名稱。寫入類別名稱可能會造成顯著的效能開銷,因此啟用此選項可以嚴格強制使用者不要遺漏類別註冊。 1.1.0
spark.kryo.registrator (無) 如果您使用 Kryo 序列化,請提供一個類別的逗號分隔清單,以向 Kryo 註冊您的自訂類別。如果您需要以自訂方式註冊您的類別,例如指定自訂欄位序列化器,則此屬性很有用。否則,spark.kryo.classesToRegister 會比較簡單。它應該設定為延伸 KryoRegistrator的類別。請參閱調整指南以取得更多詳細資訊。 0.5.0
spark.kryo.unsafe true 是否使用基於 unsafe 的 Kryo 序列化器。使用基於 Unsafe 的 I/O 可以大幅提升速度。 2.1.0
spark.kryoserializer.buffer.max 64m Kryo 序列化緩衝區允許的最大大小(以 MiB 為單位,除非另有說明)。此大小必須大於您嘗試序列化的任何物件,且必須小於 2048m。如果在 Kryo 中收到「緩衝區限制已超過」例外狀況,請增加此大小。 1.4.0
spark.kryoserializer.buffer 64k Kryo 序列化緩衝區的初始大小(以 KiB 為單位,除非另有說明)。請注意,每個工作器上會有一個緩衝區每個核心。如果需要,此緩衝區會增加到 spark.kryoserializer.buffer.max 1.4.0
spark.rdd.compress false 是否壓縮序列化 RDD 分割區(例如 Java 和 Scala 中的 StorageLevel.MEMORY_ONLY_SER 或 Python 中的 StorageLevel.MEMORY_ONLY)。可以節省大量空間,但會消耗一些額外的 CPU 時間。壓縮將使用 spark.io.compression.codec 0.6.0
spark.serializer org.apache.spark.serializer.
JavaSerializer
用於序列化將透過網路傳送或需要以序列化形式快取的物件的類別。Java 序列化的預設值適用於任何可序列化的 Java 物件,但速度相當慢,因此我們建議在需要速度時使用 org.apache.spark.serializer.KryoSerializer 並設定 Kryo 序列化。可以是 org.apache.spark.Serializer 的任何子類別。 0.5.0
spark.serializer.objectStreamReset 100 使用 org.apache.spark.serializer.JavaSerializer 序列化時,序列化器會快取物件以防止寫入重複的資料,但這會停止這些物件的垃圾回收。呼叫「重設」會從序列化器中清除該資訊,並允許收集舊物件。若要關閉此定期重設,請將其設定為 -1。預設情況下,它會每 100 個物件重設一次序列化器。 1.0.0

記憶體管理

屬性名稱預設值意義版本
spark.memory.fraction 0.6 用於執行和儲存的(堆空間 - 300MB)比例。此值越低,溢出和快取資料驅逐發生的頻率越高。此設定的目的是在稀疏、異常大的記錄的情況下,保留記憶體供內部元資料、使用者資料結構和不精確大小估計使用。建議將此值保留為預設值。有關更多詳細資訊,包括在增加此值時正確調整 JVM 垃圾回收的重要資訊,請參閱此說明 1.6.0
spark.memory.storageFraction 0.5 不受驅逐影響的儲存記憶體量,表示為 spark.memory.fraction 所保留區域大小的比例。此值越高,可供執行使用的工作記憶體就越少,而且任務溢出到磁碟的頻率可能會更高。建議將此值保留為預設值。有關更多詳細資訊,請參閱此說明 1.6.0
spark.memory.offHeap.enabled false 如果為 true,Spark 會嘗試對某些操作使用非堆記憶體。如果啟用非堆記憶體使用,則 spark.memory.offHeap.size 必須為正數。 1.6.0
spark.memory.offHeap.size 0 可用於非堆疊配置的絕對記憶體量,以位元組為單位,除非另有說明。此設定不會影響堆疊記憶體使用量,因此如果執行緒的總記憶體消耗量必須符合某些硬性限制,請務必縮減 JVM 堆疊大小。當 spark.memory.offHeap.enabled=true 時,必須將此設定為正值。 1.6.0
spark.storage.unrollMemoryThreshold 1024 * 1024 在展開任何區塊之前請求的初始記憶體。 1.1.0
spark.storage.replication.proactive false 啟用 RDD 區塊的積極區塊複製。如果任何現有的可用複製,則會補充因執行緒失敗而遺失的快取 RDD 區塊複製。這會嘗試將區塊的複製層級調整為初始數字。 2.2.0
spark.storage.localDiskByExecutors.cacheSize 1000 儲存本地目錄的最大執行緒數。此大小同時套用於驅動程式和執行緒側,以避免儲存空間無限擴充。此快取將用於避免在從同一主機擷取磁碟持續 RDD 區塊或洗牌區塊(當設定 spark.shuffle.readHostLocalDisk 時)時發生網路問題。 3.0.0
spark.cleaner.periodicGC.interval 30 分鐘 控制觸發垃圾回收的頻率。

此內容清理器僅在垃圾回收弱連結時觸發清理。在驅動程式 JVM 較大的長期執行應用程式中,驅動程式上的記憶體壓力較小,這可能非常偶爾發生,甚至完全不發生。完全不清理可能會導致執行緒在一段時間後用盡磁碟空間。
1.6.0
spark.cleaner.referenceTracking true 啟用或停用內容清理。 1.0.0
spark.cleaner.referenceTracking.blocking true 控制清理執行緒是否應封鎖在清理任務上(除了洗牌,由 spark.cleaner.referenceTracking.blocking.shuffle Spark 屬性控制)。 1.0.0
spark.cleaner.referenceTracking.blocking.shuffle false 控制清理執行緒是否應封鎖在洗牌清理任務上。 1.1.1
spark.cleaner.referenceTracking.cleanCheckpoints false 控制是否在參考超出範圍時清理檢查點檔案。 1.4.0

執行行為

屬性名稱預設值意義版本
spark.broadcast.blockSize 4m TorrentBroadcastFactory 區塊中每個部分的大小,以 KiB 為單位,除非另有說明。值過大會降低廣播期間的並行度(使其變慢);然而,如果值太小,BlockManager 可能會影響效能。 0.5.0
spark.broadcast.checksum true 是否為廣播啟用檢查碼。如果啟用,廣播將包含檢查碼,這有助於偵測損毀的區塊,但會增加計算和傳送更多資料的成本。如果網路有其他機制來保證資料在廣播期間不會損毀,則可以停用它。 2.1.1
spark.broadcast.UDFCompressionThreshold 1 * 1024 * 1024 以位元組為單位,使用者定義函數 (UDF) 和 Python RDD 命令透過廣播壓縮的臨界值,除非另有說明。 3.0.0
spark.executor.cores 在 YARN 模式中為 1,在獨立和 Mesos 粗粒度模式中為工作器上所有可用核心。 每個執行器上要使用的核心數。在獨立和 Mesos 粗粒度模式中,更多詳細資訊,請參閱 此說明 1.0.0
spark.default.parallelism 對於像 reduceByKeyjoin 之類的分布式混排作業,父 RDD 中分區的最大數目。對於沒有父 RDD 的 parallelize 之類的作業,則取決於叢集管理員
  • 本機模式:本機上的核心數目
  • Mesos 細粒度模式:8
  • 其他:所有執行器節點上的核心總數或 2,以較大者為準
當使用者未設定時,由轉換傳回的 RDD 中分區的預設數目,例如 joinreduceByKeyparallelize 0.5.0
spark.executor.heartbeatInterval 10 秒 每個執行器傳送心跳給驅動程式之間的間隔。心跳讓驅動程式知道執行器仍然運作中,並更新執行器中正在進行任務的指標。spark.executor.heartbeatInterval 應該遠小於 spark.network.timeout 1.1.0
spark.files.fetchTimeout 60 秒 從驅動程式擷取透過 SparkContext.addFile() 新增檔案時要使用的通訊逾時時間。 1.0.0
spark.files.useFetchCache true 如果設為 true (預設值),檔案擷取會使用由屬於同一個應用程式的執行器共用的本機快取,這可以在同一主機上執行許多執行器時改善任務啟動效能。如果設為 false,這些快取最佳化會停用,而且所有執行器都會擷取自己的檔案副本。這個最佳化可能會停用,以便使用位於 NFS 檔案系統上的 Spark 本機目錄 (更多詳細資訊,請參閱 SPARK-6313)。 1.2.2
spark.files.overwrite false 是否覆寫啟動時存在的任何檔案。即使設定此選項為 true,使用者也無法覆寫 SparkContext.addFileSparkContext.addJar 新增的檔案。 1.0.0
spark.files.ignoreCorruptFiles false 是否忽略損毀的檔案。如果為 true,Spark 任務在遇到損毀或不存在的檔案時,仍會繼續執行,且已讀取的內容仍會傳回。 2.1.0
spark.files.ignoreMissingFiles false 是否忽略遺失的檔案。如果為 true,Spark 任務在遇到遺失的檔案時,仍會繼續執行,且已讀取的內容仍會傳回。 2.4.0
spark.files.maxPartitionBytes 134217728 (128 MiB) 讀取檔案時,封裝到單一分割區的位元組最大數量。 2.1.0
spark.files.openCostInBytes 4194304 (4 MiB) 開啟檔案的預估成本,以同時可掃描的位元組數量衡量。這會在將多個檔案放入分割區時使用。最好高估,這樣小檔案的分割區會比大檔案的分割區快。 2.1.0
spark.hadoop.cloneConf false 如果設為 true,會為每個任務複製新的 Hadoop Configuration 物件。應啟用此選項,以解決 Configuration 執行緒安全性問題(有關更多詳細資訊,請參閱 SPARK-2546)。預設會停用此選項,以避免不受這些問題影響的任務效能意外下降。 1.0.3
spark.hadoop.validateOutputSpecs true 如果設為 true,會驗證 saveAsHadoopFile 及其他變體中使用的輸出規格(例如檢查輸出目錄是否已存在)。這可以停用,以避免因預先存在的輸出目錄而產生的例外狀況。我們建議使用者不要停用此選項,除非嘗試與 Spark 的先前版本相容。只要使用 Hadoop 的 FileSystem API 手動刪除輸出目錄即可。此設定會忽略透過 Spark Streaming 的 StreamingContext 產生的任務,因為在檢查點復原期間,資料可能需要重新寫入預先存在的輸出目錄。 1.0.1
spark.storage.memoryMapThreshold 2m Spark 從磁碟讀取區塊時,會記憶體對應的區塊大小。預設單位為位元組,除非另有指定。這可防止 Spark 記憶體對應非常小的區塊。一般來說,記憶體對應對接近或低於作業系統頁面大小的區塊有很高的開銷。 0.9.2
spark.storage.decommission.enabled false 在解除執行緒委派時,是否解除區塊管理員委派。 3.1.0
spark.storage.decommission.shuffleBlocks.enabled true 在區塊管理員解除委派期間,是否傳輸混排區塊。需要可遷移的混排解析器(例如基於排序的混排)。 3.1.0
spark.storage.decommission.shuffleBlocks.maxThreads 8 用於遷移混排檔案的最大執行緒數量。 3.1.0
spark.storage.decommission.rddBlocks.enabled true 區塊管理員解除委派期間是否傳輸 RDD 區塊。 3.1.0
spark.storage.decommission.fallbackStorage.path (無) 區塊管理員解除委派期間的備用儲存空間位置。例如,s3a://spark-storage/。如果為空,備用儲存空間會停用。儲存空間應由 TTL 管理,因為 Spark 不會清除它。 3.1.0
spark.storage.decommission.fallbackStorage.cleanUp false 如果為 true,Spark 會在關閉期間清除其備用儲存空間資料。 3.2.0
spark.storage.decommission.shuffleBlocks.maxDiskSize (無) 拒絕遠端混排區塊前,用於儲存混排區塊的最大磁碟空間。拒絕遠端混排區塊表示執行器不會收到任何混排移轉,如果沒有其他執行器可供移轉,則混排區塊會遺失,除非已設定 spark.storage.decommission.fallbackStorage.path 3.2.0
spark.hadoop.mapreduce.fileoutputcommitter.algorithm.version 1 檔案輸出提交器演算法版本,有效的演算法版本號碼:1 或 2。請注意,2 可能會導致 MAPREDUCE-7282 等正確性問題。 2.2.0

執行器指標

屬性名稱預設值意義版本
spark.eventLog.logStageExecutorMetrics false 是否將每個階段執行器指標的峰值(針對每個執行器)寫入事件記錄檔。
注意: 指標會被輪詢(收集)並在執行器心跳中傳送,這總是會執行;此設定僅用於判斷是否將指標峰值寫入事件記錄檔。
3.0.0
spark.executor.processTreeMetrics.enabled false 收集執行器指標時,是否收集處理程序樹指標(來自 /proc 檔案系統)。
注意: 只有在 /proc 檔案系統存在時,才會收集處理程序樹指標。
3.0.0
spark.executor.metrics.pollingInterval 0 收集執行器指標的頻率(以毫秒為單位)。
如果為 0,輪詢會在執行器心跳中執行(因此在心跳間隔中,由 spark.executor.heartbeatInterval 指定)。如果為正數,輪詢會在此間隔中執行。
3.0.0
spark.eventLog.gcMetrics.youngGenerationGarbageCollectors 複製、PS 清除、ParNew、G1 年輕世代 支援的新世代垃圾收集器的名稱。名稱通常是 GarbageCollectorMXBean.getName 的回傳值。內建的新世代垃圾收集器為 Copy、PS Scavenge、ParNew、G1 Young Generation。 3.0.0
spark.eventLog.gcMetrics.oldGenerationGarbageCollectors MarkSweepCompact、PS MarkSweep、ConcurrentMarkSweep、G1 Old Generation 支援的舊世代垃圾收集器的名稱。名稱通常是 GarbageCollectorMXBean.getName 的回傳值。內建的舊世代垃圾收集器為 MarkSweepCompact、PS MarkSweep、ConcurrentMarkSweep、G1 Old Generation。 3.0.0
spark.executor.metrics.fileSystemSchemes file、hdfs 在執行器指標中回報的檔案系統架構。 3.1.0

網路

屬性名稱預設值意義版本
spark.rpc.message.maxSize 128 允許在「控制平面」通訊中使用的最大訊息大小(以 MiB 為單位);通常只適用於執行器與驅動程式之間傳送的映射輸出大小資訊。如果您執行的工作有數千個映射和縮減工作,並且看到有關 RPC 訊息大小的訊息,請增加此值。 2.0.0
spark.blockManager.port (隨機) 所有區塊管理員要監聽的埠口。這些埠口存在於驅動程式和執行器中。 1.1.0
spark.driver.blockManager.port (spark.blockManager.port 的值) 區塊管理員要監聽的驅動程式特定埠口,適用於無法使用與執行器相同的組態的情況。 2.1.0
spark.driver.bindAddress (spark.driver.host 的值) 用於繫結監聽 socket 的主機名稱或 IP 位址。此組態會覆寫 SPARK_LOCAL_IP 環境變數(請參閱下方)。
它也允許不同的位址從本機位址宣告給執行器或外部系統。例如,當執行具有橋接網路的容器時,這會很有用。為了讓此功能正常運作,驅動程式使用的不同埠口(RPC、區塊管理員和 UI)需要從容器的主機轉送。
2.1.0
spark.driver.host (本機主機名稱) 驅動程式的主機名稱或 IP 位址。這用於與執行器和獨立主控端通訊。 0.7.0
spark.driver.port (隨機) 驅動程式要監聽的埠口。這用於與執行器和獨立主控端通訊。 0.7.0
spark.rpc.io.backLog 64 RPC 伺服器的接受佇列長度。對於大型應用程式,可能需要增加此值,這樣當大量連線在短時間內湧入時,就不會中斷傳入連線。 3.0.0
spark.network.timeout 120s 所有網路互動的預設逾時時間。如果未組態 spark.storage.blockManagerHeartbeatTimeoutMsspark.shuffle.io.connectionTimeoutspark.rpc.askTimeoutspark.rpc.lookupTimeout,此組態將用於取代這些組態。 1.3.0
spark.network.timeoutInterval 60 秒 驅動程式檢查並終止失效執行緒的時間間隔。 1.3.2
spark.network.io.preferDirectBufs true 如果啟用,則共享配置器會優先使用非堆積緩衝區配置。非堆積緩衝區用於在洗牌和快取區塊傳輸期間減少垃圾回收。對於非堆積記憶體受嚴格限制的環境,使用者可能希望關閉此功能,以強制所有配置都在堆積上。 3.0.0
spark.port.maxRetries 16 繫結至連接埠前放棄嘗試的最大次數。當連接埠給定特定值(非 0)時,每次後續嘗試會在重試前將前一次嘗試中使用的連接埠加 1。這基本上允許它嘗試從指定的起始連接埠到連接埠 + maxRetries 的連接埠範圍。 1.1.1
spark.rpc.askTimeout spark.network.timeout RPC 詢問作業在逾時前等待的持續時間。 1.4.0
spark.rpc.lookupTimeout 120s RPC 遠端端點查詢作業在逾時前等待的持續時間。 1.4.0
spark.network.maxRemoteBlockSizeFetchToMem 200m 當區塊大小超過此位元組閾值時,遠端區塊將會擷取至磁碟。這是為了避免大型要求佔用過多記憶體。請注意,此組態會影響洗牌擷取和區塊管理員遠端區塊擷取。對於啟用外部洗牌服務的使用者,此功能僅在外部洗牌服務至少為 2.3.0 時才能運作。 3.0.0
spark.rpc.io.connectionTimeout spark.network.timeout 的值 已建立的 RPC 對等連線在標記為閒置並關閉之前,如果至少 `connectionTimeout` 的時間內頻道上沒有流量,但有未完成的 RPC 要求,則此連線的逾時時間。 1.2.0
spark.rpc.io.connectionCreationTimeout spark.rpc.io.connectionTimeout 的值 建立 RPC 對等連線的逾時時間。 3.2.0

排程

屬性名稱預設值意義版本
spark.cores.max (未設定) 獨立部署叢集「粗粒度」分享模式中的 Mesos 叢集 上執行時,從整個叢集(而非每部機器)要求應用程式使用的最大 CPU 核心數。如果未設定,預設值將會是 Spark 獨立叢集管理員上的 spark.deploy.defaultCores,或 Mesos 上的無限(所有可用的核心)。 0.6.0
spark.locality.wait 3s 放棄並在較不本地的節點上啟動資料本機任務之前,等待啟動的時間。相同的等待時間將用於逐步執行多個本機層級(處理程序本機、節點本機、機架本機,然後是任何)。也可以透過設定 spark.locality.wait.node 等自訂每個層級的等待時間。如果任務很長且本機性不佳,則應增加此設定,但預設值通常運作良好。 0.5.0
spark.locality.wait.node spark.locality.wait 自訂節點本機的本機等待時間。例如,可以將其設定為 0 以略過節點本機,並立即搜尋機架本機(如果叢集有機架資訊)。 0.8.0
spark.locality.wait.process spark.locality.wait 自訂處理程序本機的本機等待時間。這會影響嘗試存取特定執行器處理程序中快取資料的任務。 0.8.0
spark.locality.wait.rack spark.locality.wait 自訂機架本機的本機等待時間。 0.8.0
spark.scheduler.maxRegisteredResourcesWaitingTime 30 秒 在排程開始前,等待資源註冊的最長時間。 1.1.1
spark.scheduler.minRegisteredResourcesRatio KUBERNETES 模式為 0.8;YARN 模式為 0.8;獨立模式和 Mesos 粗粒度模式為 0.0 在排程開始前等待的已註冊資源的最小比率(已註冊資源/總預期資源)(在 yarn 模式和 Kubernetes 模式中,資源是執行器;在獨立模式和 Mesos 粗粒度模式中,資源是 CPU 核心 [Mesos 粗粒度模式的總預期資源是 'spark.cores.max' 值])。指定為 0.0 到 1.0 之間的雙精度浮點數。無論是否已達到資源的最小比率,在排程開始前等待的最長時間都由設定檔 spark.scheduler.maxRegisteredResourcesWaitingTime 控制。 1.1.1
spark.scheduler.mode FIFO 提交至相同 SparkContext 的工作之間的 排程模式。可以設定為 FAIR,以使用公平分享,而不是一個接一個地排隊工作。對於多使用者服務很有用。 0.8.0
spark.scheduler.revive.interval 1s 排程器用於恢復工作資源提供以執行任務的區間長度。 0.8.1
spark.scheduler.listenerbus.eventqueue.capacity 10000 事件佇列的預設容量。Spark 會先嘗試使用 `spark.scheduler.listenerbus.eventqueue.queueName.capacity` 指定的容量初始化事件佇列。如果未設定,Spark 會使用此設定檔指定的預設容量。請注意,容量必須大於 0。如果遺失監聽器事件,請考慮增加值(例如 20000)。增加此值可能會導致驅動程式使用更多記憶體。 2.3.0
spark.scheduler.listenerbus.eventqueue.shared.capacity spark.scheduler.listenerbus.eventqueue.capacity Spark 監聽器匯流排中共享事件佇列的容量,其中包含註冊到監聽器匯流排的外部監聽器的事件。如果遺失與共享佇列對應的監聽器事件,請考慮增加值。增加此值可能會導致驅動程式使用更多記憶體。 3.0.0
spark.scheduler.listenerbus.eventqueue.appStatus.capacity spark.scheduler.listenerbus.eventqueue.capacity appStatus 事件佇列的容量,此佇列保存內部應用程式狀態監聽器的事件。如果與 appStatus 佇列對應的監聽器事件遺失,請考慮增加值。增加此值可能會導致驅動程式使用更多記憶體。 3.0.0
spark.scheduler.listenerbus.eventqueue.executorManagement.capacity spark.scheduler.listenerbus.eventqueue.capacity Spark 監聽器匯流排中 executorManagement 事件佇列的容量,此佇列保存內部執行器管理監聽器的事件。如果與 executorManagement 佇列對應的監聽器事件遺失,請考慮增加值。增加此值可能會導致驅動程式使用更多記憶體。 3.0.0
spark.scheduler.listenerbus.eventqueue.eventLog.capacity spark.scheduler.listenerbus.eventqueue.capacity Spark 監聽器匯流排中 eventLog 佇列的容量,此佇列保存將事件寫入事件記錄檔的事件記錄監聽器的事件。如果與 eventLog 佇列對應的監聽器事件遺失,請考慮增加值。增加此值可能會導致驅動程式使用更多記憶體。 3.0.0
spark.scheduler.listenerbus.eventqueue.streams.capacity spark.scheduler.listenerbus.eventqueue.capacity Spark 監聽器匯流排中 streams 佇列的容量,此佇列保存內部串流監聽器的事件。如果與 streams 佇列對應的監聽器事件遺失,請考慮增加值。增加此值可能會導致驅動程式使用更多記憶體。 3.0.0
spark.scheduler.resource.profileMergeConflicts false 如果設為「true」,Spark 會在不同 RDD 中指定不同設定檔時合併 ResourceProfiles,這些 RDD 會合併成單一階段。合併時,Spark 會選擇每項資源的最大值,並建立新的 ResourceProfile。如果在進入相同階段的 RDD 中找到多個不同的 ResourceProfiles,預設值 false 會導致 Spark 擲回例外狀況。 3.1.0
spark.scheduler.excludeOnFailure.unschedulableTaskSetTimeout 120s 在中止 TaskSet 之前,等待取得新執行器和排程任務的時間,因為所有執行器都因任務失敗而被排除,所以無法排程。 2.4.1
spark.standalone.submit.waitAppCompletion false 如果設為 true,Spark 會在不同 RDD 中指定不同設定檔時合併 ResourceProfiles,這些 RDD 會合併成單一階段。合併時,Spark 會選擇每項資源的最大值,並建立新的 ResourceProfile。如果在進入相同階段的 RDD 中找到多個不同的 ResourceProfiles,預設值 false 會導致 Spark 擲回例外狀況。 3.1.0
spark.excludeOnFailure.enabled false 如果設為「true」,可防止 Spark 在因過多任務失敗而被排除的執行器上排程任務。用於排除執行器和節點的演算法可以進一步由其他「spark.excludeOnFailure」設定選項控制。 2.1.0
spark.excludeOnFailure.timeout 1h (實驗性)在無條件從排除清單中移除節點或執行器以嘗試執行新任務之前,節點或執行器在整個應用程式中被排除的時間長度。 2.1.0
spark.excludeOnFailure.task.maxTaskAttemptsPerExecutor 1 (實驗性) 針對特定工作,在排除執行器執行該工作之前,執行器可以在執行器上重試的次數。 2.1.0
spark.excludeOnFailure.task.maxTaskAttemptsPerNode 2 (實驗性) 針對特定工作,在排除整個節點執行該工作之前,工作可以在節點上重試的次數。 2.1.0
spark.excludeOnFailure.stage.maxFailedTasksPerExecutor 2 (實驗性) 在排除執行器執行特定階段之前,執行器在一個階段內必須失敗多少個不同的工作。 2.1.0
spark.excludeOnFailure.stage.maxFailedExecutorsPerNode 2 (實驗性) 在將整個節點標記為階段失敗之前,有多少個不同的執行器被標記為特定階段的排除對象。 2.1.0
spark.excludeOnFailure.application.maxFailedTasksPerExecutor 2 (實驗性) 在排除執行器執行整個應用程式之前,執行器在成功的任務集中必須失敗多少個不同的任務。排除的執行器會在 spark.excludeOnFailure.timeout 指定的逾時時間後自動新增回可用的資源池。不過,請注意,在動態配置中,執行器可能會被標記為閒置,並由叢集管理員回收。 2.2.0
spark.excludeOnFailure.application.maxFailedExecutorsPerNode 2 (實驗性) 在排除節點執行整個應用程式之前,必須排除多少個不同的執行器執行整個應用程式。排除的節點會在 spark.excludeOnFailure.timeout 指定的逾時時間後自動新增回可用的資源池。不過,請注意,在動態配置中,節點上的執行器可能會被標記為閒置,並由叢集管理員回收。 2.2.0
spark.excludeOnFailure.killExcludedExecutors false (實驗性) 如果設為「true」,允許 Spark 在因擷取失敗或因整個應用程式而排除執行器時自動終止執行器,由 spark.killExcludedExecutors.application.* 控制。請注意,當整個節點被新增為排除對象時,該節點上的所有執行器都會被終止。 2.2.0
spark.excludeOnFailure.application.fetchFailure.enabled false (實驗性) 如果設為「true」,Spark 會在發生擷取失敗時立即排除執行器。如果啟用外部洗牌服務,則整個節點都會被排除。 2.3.0
spark.speculation false 如果設為「true」,執行任務的推測執行。這表示如果一個階段中有一個或多個任務執行緩慢,這些任務將會重新啟動。 0.6.0
spark.speculation.interval 100ms Spark 檢查要推測的任務的頻率。 0.6.0
spark.speculation.multiplier 1.5 任務比中位數慢幾倍,才會被考慮進行推測。 0.6.0
spark.speculation.quantile 0.75 在特定階段啟用推測執行之前,必須完成的任務比例。 0.6.0
spark.speculation.minTaskRuntime 100ms 任務執行時間達到此值後,才會考慮進行推測執行。這可避免啟動非常短暫任務的推測執行副本。 3.2.0
spark.speculation.task.duration.threshold 任務執行時間達到此值後,排程器會嘗試推測執行該任務。如果已提供此值,則在目前階段包含的任務少於或等於單一執行器上的插槽數,且任務執行時間超過此閾值時,就會推測執行任務。此設定有助於推測執行任務數非常少的階段。如果執行器插槽夠大,也可能套用一般推測執行設定。例如,即使尚未達到閾值,只要有足夠的成功執行,任務也可能會重新啟動。插槽數是根據 spark.executor.cores 和 spark.task.cpus 的設定值計算,至少為 1。預設單位為位元組,除非另有指定。 3.0.0
spark.speculation.efficiency.processRateMultiplier 0.75 評估效率不彰的任務時使用的乘數。乘數越高,可能會被視為效率不彰的任務就越多。 3.4.0
spark.speculation.efficiency.longRunTaskFactor 2 只要任務執行時間超過乘數與時間閾值(可能是 spark.speculation.multiplier * successfulTaskDurations.median 或 spark.speculation.minTaskRuntime)的乘積,就會推測執行任務,而不管其資料處理率是否良好。這可避免遺漏任務執行速度變慢與資料處理率無關的效率不彰任務。 3.4.0
spark.speculation.efficiency.enabled true 設為 true 時,Spark 會透過階段任務指標或其執行時間來評估任務處理的效率,而且只需要推測執行效率不彰的任務。任務在以下情況下會被視為效率不彰:1) 其資料處理率低於階段中所有成功任務的平均資料處理率乘以一個乘數,或 2) 其執行時間超過 spark.speculation.efficiency.longRunTaskFactor 與時間閾值(可能是 spark.speculation.multiplier * successfulTaskDurations.median 或 spark.speculation.minTaskRuntime)的乘積。 3.4.0
spark.task.cpus 1 分配給每個任務的核心數。 0.5.0
spark.task.resource.{resourceName}.amount 1 要分配給每個任務的特定資源類型的數量,請注意這可以是雙倍的。如果指定了這個,您還必須提供執行器配置 spark.executor.resource.{resourceName}.amount 和任何對應的發現配置,以便您的執行器使用該資源類型建立。除了整個數量之外,還可以指定小數部分(例如,0.25,表示資源的 1/4)。小數部分必須小於或等於 0.5,換句話說,每個資源的最小共享數量是 2 個任務。此外,小數部分會向下取整以分配資源時段(例如,0.2222 配置,或 1/0.2222 時段將變成 4 個任務/資源,而不是 5 個)。 3.0.0
spark.task.maxFailures 4 在放棄工作之前,任何特定任務連續失敗的次數。跨不同任務傳播的總失敗次數不會導致工作失敗;特定任務必須連續失敗這麼多次嘗試。如果任何嘗試成功,則任務的失敗次數將重設。應大於或等於 1。允許重試的次數 = 此值 - 1。 0.8.0
spark.task.reaper.enabled false 啟用對已終止/中斷任務的監控。當設定為 true 時,任何已終止的任務都將由執行器監控,直到該任務實際完成執行。請參閱其他 spark.task.reaper.* 配置,以了解如何控制此監控的確切行為。當設定為 false(預設值)時,任務終止將使用缺乏此類監控的較舊程式碼路徑。 2.0.3
spark.task.reaper.pollingInterval 10 秒 spark.task.reaper.enabled = true 時,此設定控制執行器輪詢已終止任務狀態的頻率。如果已終止的任務在輪詢時仍在執行,則會記錄警告,並且預設會記錄任務的執行緒傾印(此執行緒傾印可透過 spark.task.reaper.threadDump 設定停用,其說明如下)。 2.0.3
spark.task.reaper.threadDump true spark.task.reaper.enabled = true 時,此設定控制是否在定期輪詢已終止的任務期間記錄任務執行緒傾印。將其設定為 false 以停用執行緒傾印的收集。 2.0.3
spark.task.reaper.killTimeout -1 spark.task.reaper.enabled = true 時,此設定會指定一個逾時時間,若已終止的任務尚未停止執行,執行器 JVM 將會在逾時時間後自行終止。預設值 -1 會停用此機制,並防止執行器自我毀損。此設定的目的是作為安全網,防止無法取消的失控任務讓執行器無法使用。 2.0.3
spark.stage.maxConsecutiveAttempts 4 在中斷階段之前允許連續嘗試階段的次數。 2.2.0
spark.stage.ignoreDecommissionFetchFailure false 計算 spark.stage.maxConsecutiveAttempts 時,是否忽略由執行器停用導致的階段擷取失敗。 3.4.0

屏障執行模式

屬性名稱預設值意義版本
spark.barrier.sync.timeout 365d 來自障礙任務的每個 barrier() 呼叫的逾時時間(以秒為單位)。如果協調器未在設定的時間內從障礙任務收到所有同步訊息,則會擲回 SparkException 以讓所有任務失敗。預設值設定為 31536000(3600 * 24 * 365),因此 barrier() 呼叫將會等待一年。 2.4.0
spark.scheduler.barrier.maxConcurrentTasksCheck.interval 15s 在最大並發任務檢查失敗和下一次檢查之間等待的時間(以秒為單位)。最大並發任務檢查可確保叢集可以啟動比提交工作中障礙階段所需的更多並發任務。如果叢集剛剛啟動且尚未註冊足夠的執行器,則檢查可能會失敗,因此我們會稍等一會兒,然後再嘗試執行檢查。如果檢查失敗次數超過工作設定的最大失敗次數,則會讓目前的提交工作失敗。請注意,此設定只適用於包含一個或多個障礙階段的工作,我們不會對非障礙工作執行檢查。 2.4.0
spark.scheduler.barrier.maxConcurrentTasksCheck.maxFailures 40 在提交工作失敗之前允許的最大並發任務檢查失敗次數。最大並發任務檢查可確保叢集可以啟動比提交工作中障礙階段所需的更多並發任務。如果叢集剛剛啟動且尚未註冊足夠的執行器,則檢查可能會失敗,因此我們會稍等一會兒,然後再嘗試執行檢查。如果檢查失敗次數超過工作設定的最大失敗次數,則會讓目前的提交工作失敗。請注意,此設定只適用於包含一個或多個障礙階段的工作,我們不會對非障礙工作執行檢查。 2.4.0

動態配置

屬性名稱預設值意義版本
spark.dynamicAllocation.enabled false 是否使用動態資源配置,根據工作負載調整向此應用程式註冊的執行器數量。如需更多詳細資訊,請參閱此處的說明。

這需要下列其中一個條件:1) 透過 spark.shuffle.service.enabled 啟用外部混排服務,或 2) 透過 spark.dynamicAllocation.shuffleTracking.enabled 啟用混排追蹤,或 3) 透過 spark.decommission.enabledspark.storage.decommission.shuffleBlocks.enabled 啟用混排區塊停用,或 4)(實驗性質)設定 spark.shuffle.sort.io.plugin.class 以使用自訂 ShuffleDataIO,其 ShuffleDriverComponents 支援可靠儲存。下列設定也相關:spark.dynamicAllocation.minExecutorsspark.dynamicAllocation.maxExecutorsspark.dynamicAllocation.initialExecutorsspark.dynamicAllocation.executorAllocationRatio
1.2.0
spark.dynamicAllocation.executorIdleTimeout 60 秒 如果啟用動態配置,且執行器閒置時間超過此持續時間,則會移除執行器。如需更多詳細資訊,請參閱此 說明 1.2.0
spark.dynamicAllocation.cachedExecutorIdleTimeout infinity 如果啟用動態配置,且執行器已快取資料區塊,且閒置時間超過此持續時間,則會移除執行器。如需更多詳細資訊,請參閱此 說明 1.4.0
spark.dynamicAllocation.initialExecutors spark.dynamicAllocation.minExecutors 如果啟用動態配置,則執行初始執行器數量。

如果設定 `--num-executors` (或 `spark.executor.instances`),且大於此值,則會將其用作初始執行器數量。
1.3.0
spark.dynamicAllocation.maxExecutors infinity 如果啟用動態配置,則執行器數量上限。 1.2.0
spark.dynamicAllocation.minExecutors 0 如果啟用動態配置,則執行器數量下限。 1.2.0
spark.dynamicAllocation.executorAllocationRatio 1 預設情況下,動態配置會根據要處理的任務數量,要求足夠的執行器來最大化平行度。雖然這會將作業延遲降至最低,但對於小型任務,此設定可能會浪費大量資源,因為執行器配置開銷,有些執行器甚至可能不會執行任何工作。此設定允許設定一個比率,用於減少執行器數量,相對於完全平行度。預設為 1.0,以提供最大的平行度。0.5 會將動態配置計算的目標執行器數量除以 2。動態配置計算的目標執行器數量仍可以由 spark.dynamicAllocation.minExecutorsspark.dynamicAllocation.maxExecutors 設定覆寫 2.4.0
spark.dynamicAllocation.schedulerBacklogTimeout 1s 如果啟用動態配置,且待處理任務積壓時間超過此持續時間,則會要求新的執行器。如需更多詳細資訊,請參閱此 說明 1.2.0
spark.dynamicAllocation.sustainedSchedulerBacklogTimeout schedulerBacklogTimeout spark.dynamicAllocation.schedulerBacklogTimeout 相同,但僅用於後續執行器要求。如需更多詳細資訊,請參閱此 說明 1.2.0
spark.dynamicAllocation.shuffleTracking.enabled true 為執行器啟用 Shuffle 檔案追蹤,允許動態配置,而不需要外部 Shuffle 服務。此選項會嘗試讓儲存 Shuffle 資料的執行器保持運作,以供主動作業使用。 3.0.0
spark.dynamicAllocation.shuffleTracking.timeout infinity 當啟用 shuffle 追蹤時,控制持有 shuffle 資料的執行緒逾時。預設值表示 Spark 會依賴於垃圾回收的 shuffle,以釋放執行緒。如果因為某些原因垃圾回收無法快速清理 shuffle,可以使用這個選項控制在何時讓執行緒逾時,即使它們正在儲存 shuffle 資料。 3.0.0

執行緒組態

根據工作和叢集組態,我們可以在 Spark 的多個位置設定執行緒數,以有效利用可用的資源,以獲得更好的效能。在 Spark 3.0 之前,這些執行緒組態套用至 Spark 的所有角色,例如驅動程式、執行緒、工作執行緒和主控程式。從 Spark 3.0 開始,我們可以更細緻地組態執行緒,從驅動程式和執行緒開始。以 RPC 模組為例,如下表所示。對於其他模組,例如 shuffle,只要在屬性名稱中將「rpc」替換為「shuffle」,即可,但 `spark.{driver|executor}.rpc.netty.dispatcher.numThreads` 除外,它僅適用於 RPC 模組。

屬性名稱預設值意義版本
spark.{driver|executor}.rpc.io.serverThreads 回退至 `spark.rpc.io.serverThreads` 伺服器執行緒池中使用的執行緒數 1.6.0
spark.{driver|executor}.rpc.io.clientThreads 回退至 `spark.rpc.io.clientThreads` 用戶端執行緒池中使用的執行緒數 1.6.0
spark.{driver|executor}.rpc.netty.dispatcher.numThreads 回退至 `spark.rpc.netty.dispatcher.numThreads` RPC 訊息調度器執行緒池中使用的執行緒數 3.0.0

與執行緒相關的組態金鑰的預設值為驅動程式或執行緒要求的核心數最小值,或者,如果沒有該值,則為 JVM 可用的核心數(硬編碼上限為 8)。

Spark Connect

伺服器組態

伺服器組態設定在 Spark Connect 伺服器中,例如,當您使用 `./sbin/start-connect-server.sh` 啟動 Spark Connect 伺服器時。它們通常透過組態檔和命令列選項設定,並使用 `--conf/-c`。

屬性名稱預設值意義版本
spark.connect.grpc.binding.port 15002 Spark Connect 伺服器要繫結的埠。 3.4.0
spark.connect.grpc.interceptor.classes (無) 必須實作 `io.grpc.ServerInterceptor` 介面的類別名稱,以逗號分隔。 3.4.0
spark.connect.grpc.arrow.maxBatchSize 4m 使用 Apache Arrow 時,限制伺服器端可以傳送至用戶端端的單一 arrow 批次的最大大小。目前,我們保守地使用 70%,因為大小不準確,而是估計的。 3.4.0
spark.connect.grpc.maxInboundMessageSize 134217728 設定 gRPC 要求的最大入站訊息大小。載荷較大的要求會失敗。 3.4.0
spark.connect.extensions.relation.classes (無) 實作特質 org.apache.spark.sql.connect.plugin.RelationPlugin 的類別清單,以支援 proto 中的客製化 Relation 類型。 3.4.0
spark.connect.extensions.expression.classes (無) 實作特質 org.apache.spark.sql.connect.plugin.ExpressionPlugin 的類別清單,以支援 proto 中的客製化 Expression 類型。 3.4.0
spark.connect.extensions.command.classes (無) 實作特質 org.apache.spark.sql.connect.plugin.CommandPlugin 的類別清單,以支援 proto 中的客製化 Command 類型。 3.4.0

安全性

請參閱 安全性 頁面,以取得有關如何保護不同 Spark 子系統的可用選項。

Spark SQL

執行時期 SQL 組態

執行時期 SQL 設定是每個階段、可變的 Spark SQL 設定。它們可以透過設定檔和帶有 --conf/-c 前綴的命令列選項,或設定用於建立 SparkSessionSparkConf 來設定其初始值。此外,它們可以透過 SET 命令設定和查詢,或透過 RESET 命令或 SparkSession.conf 的設定函式和取得函式方法在執行時期將其重設為初始值。

屬性名稱預設值意義版本
spark.sql.adaptive.advisoryPartitionSizeInBytes (spark.sql.adaptive.shuffle.targetPostShuffleInputSize 的值)

在適應性最佳化期間 (當 spark.sql.adaptive.enabled 為 true 時) 的洗牌區段的建議大小 (以位元組為單位)。當 Spark 合併小型洗牌區段或分割傾斜洗牌區段時,它會生效。

3.0.0
spark.sql.adaptive.autoBroadcastJoinThreshold (無)

設定在執行聯結時將廣播到所有工作者節點的資料表的最大大小 (以位元組為單位)。將此值設定為 -1 可以停用廣播。預設值與 spark.sql.autoBroadcastJoinThreshold 相同。請注意,此設定僅用於適應性架構。

3.2.0
spark.sql.adaptive.coalescePartitions.enabled true

當為 true 且 'spark.sql.adaptive.enabled' 為 true 時,Spark 會根據目標大小 (由 'spark.sql.adaptive.advisoryPartitionSizeInBytes' 指定) 合併連續的洗牌區段,以避免太多小型工作。

3.0.0
spark.sql.adaptive.coalescePartitions.initialPartitionNum (無)

合併前的洗牌區段初始數量。如果未設定,則等於 spark.sql.shuffle.partitions。此設定僅在 'spark.sql.adaptive.enabled' 和 'spark.sql.adaptive.coalescePartitions.enabled' 皆為 true 時才會生效。

3.0.0
spark.sql.adaptive.coalescePartitions.minPartitionSize 1MB

合併後洗牌分區的最小大小。這在合併分區時,適應性計算的目標大小過小時很有用。

3.2.0
spark.sql.adaptive.coalescePartitions.parallelismFirst true

為 true 時,Spark 在合併連續的洗牌分區時,不會遵守「spark.sql.adaptive.advisoryPartitionSizeInBytes」(預設為 64MB)所指定的目標大小,而是根據 Spark 集群的預設並行度,適應性地計算目標大小。計算出的大小通常會小於設定的目標大小。這是為了最大化並行度,並在啟用適應性查詢執行時,避免效能下降。建議將此設定設為 false,並遵守設定的目標大小。

3.2.0
spark.sql.adaptive.customCostEvaluatorClass (無)

要使用的自訂成本評估器類別,用於適應性執行。如果未設定,Spark 預設會使用自己的 SimpleCostEvaluator。

3.2.0
spark.sql.adaptive.enabled true

為 true 時,啟用適應性查詢執行,它會根據準確的執行時間統計資料,在查詢執行過程中重新最佳化查詢計畫。

1.6.0
spark.sql.adaptive.forceOptimizeSkewedJoin false

為 true 時,強制啟用 OptimizeSkewedJoin,即使它會產生額外的洗牌。

3.3.0
spark.sql.adaptive.localShuffleReader.enabled true

為 true 且「spark.sql.adaptive.enabled」為 true 時,Spark 會嘗試使用本機洗牌讀取器,在不需要洗牌分區時讀取洗牌資料,例如在將排序合併聯結轉換為廣播雜湊聯結之後。

3.0.0
spark.sql.adaptive.maxShuffledHashJoinLocalMapThreshold 0b

設定每個分區可以允許建置本機雜湊映射的最大大小(以位元組為單位)。如果這個值不大於 spark.sql.adaptive.advisoryPartitionSizeInBytes,而且所有分區大小都不大於這個設定,聯結選取會偏好使用洗牌雜湊聯結,而不是排序合併聯結,不論 spark.sql.join.preferSortMergeJoin 的值為何。

3.2.0
spark.sql.adaptive.optimizeSkewsInRebalancePartitions.enabled true

為 true 且「spark.sql.adaptive.enabled」為 true 時,Spark 會最佳化 RebalancePartitions 中的傾斜洗牌分區,並根據目標大小(由「spark.sql.adaptive.advisoryPartitionSizeInBytes」指定)將它們分割成較小的分區,以避免資料傾斜。

3.2.0
spark.sql.adaptive.optimizer.excludedRules (無)

設定要在適應性最佳化器中停用的規則清單,其中規則以其規則名稱指定,並以逗號分隔。最佳化器會記錄實際上已排除的規則。

3.1.0
spark.sql.adaptive.rebalancePartitionsSmallPartitionFactor 0.2

如果分區大小小於這個因子乘以 spark.sql.adaptive.advisoryPartitionSizeInBytes,則會在分割期間合併分區。

3.3.0
spark.sql.adaptive.skewJoin.enabled true

為 true 且「spark.sql.adaptive.enabled」為 true 時,Spark 會透過分割(並在需要時複製)傾斜分區,動態處理洗牌聯結(排序合併和洗牌雜湊)中的傾斜。

3.0.0
spark.sql.adaptive.skewJoin.skewedPartitionFactor 5.0

如果分區大小大於這個因子乘以中位數分區大小,且也大於「spark.sql.adaptive.skewJoin.skewedPartitionThresholdInBytes」,則會將分區視為傾斜。

3.0.0
spark.sql.adaptive.skewJoin.skewedPartitionThresholdInBytes 256MB

如果分區大小(以位元組為單位)大於此閾值,且大於「spark.sql.adaptive.skewJoin.skewedPartitionFactor」乘以中位數分區大小,則該分區會被視為傾斜。理想情況下,此設定應大於「spark.sql.adaptive.advisoryPartitionSizeInBytes」。

3.0.0
spark.sql.allowNamedFunctionArguments true

如果為 true,Spark 會為已實作的所有函式啟用命名參數支援。

3.5.0
spark.sql.ansi.doubleQuotedIdentifiers false

如果為 true,且「spark.sql.ansi.enabled」為 true,Spark SQL 會將包含在雙引號 (") 中的文字讀取為識別碼。如果為 false,則會將其讀取為字串文字。

3.4.0
spark.sql.ansi.enabled false

如果為 true,Spark SQL 會使用符合 ANSI 的方言,而不是符合 Hive 的方言。例如,當 SQL 營運子/函式的輸入無效時,Spark 會在執行階段擲回例外,而不是傳回 null 結果。有關此方言的完整詳細資料,您可以在 Spark 文件的「ANSI 相容性」區段中找到。某些 ANSI 方言功能可能並非直接來自 ANSI SQL 標準,但其行為與 ANSI SQL 的風格一致

3.0.0
spark.sql.ansi.enforceReservedKeywords false

如果為 true,且「spark.sql.ansi.enabled」為 true,Spark SQL 剖析器會強制執行 ANSI 保留關鍵字,並禁止使用保留關鍵字作為別名名稱和/或表格、檢視、函式等的識別碼的 SQL 查詢。

3.3.0
spark.sql.ansi.relationPrecedence false

如果為 true,且「spark.sql.ansi.enabled」為 true,在組合關聯時,JOIN 會優先於逗號。例如,t1, t2 JOIN t3 應產生 t1 X (t2 X t3)。如果設定為 false,則結果為 (t1 X t2) X t3

3.4.0
spark.sql.autoBroadcastJoinThreshold 10MB

設定在執行連接時會廣播到所有工作節點的表格最大大小(以位元組為單位)。將此值設定為 -1 可以停用廣播。請注意,目前僅支援已執行 ANALYZE TABLE <tableName> COMPUTE STATISTICS noscan 命令的 Hive Metastore 表格的統計資料,以及直接在資料檔案上計算統計資料的基於檔案的資料來源表格。

1.1.0
spark.sql.avro.compression.codec snappy

用於編寫 AVRO 檔案的壓縮編解碼器。支援的編解碼器:uncompressed、deflate、snappy、bzip2、xz 和 zstandard。預設編解碼器為 snappy。

2.4.0
spark.sql.avro.deflate.level -1

用於編寫 AVRO 檔案的 deflate 編解碼器的壓縮等級。有效值必須在 1 到 9(含)或 -1 的範圍內。預設值為 -1,在目前的實作中對應到等級 6。

2.4.0
spark.sql.avro.filterPushdown.enabled true

如果為 true,則啟用過濾器推送到 Avro 資料來源。

3.1.0
spark.sql.broadcastTimeout 300

廣播聯結中廣播等待時間的逾時時間(秒)。

1.3.0
spark.sql.bucketing.coalesceBucketsInJoin.enabled false

如果為 true,則在聯結兩個具有不同數量的儲存區的儲存區表格時,儲存區數量較多的那一側將合併為與另一側具有相同的儲存區數量。較多的儲存區數量可以被較少的儲存區數量整除。儲存區合併套用於排序合併聯結和隨機雜湊聯結。注意:合併儲存區表格可以避免在聯結中不必要的隨機處理,但它也會減少並行度,並可能導致隨機雜湊聯結的 OOM。

3.1.0
spark.sql.bucketing.coalesceBucketsInJoin.maxBucketRatio 4

要合併的兩個儲存區的數量比率應該小於或等於此值,才能套用儲存區合併。此組態僅在 'spark.sql.bucketing.coalesceBucketsInJoin.enabled' 設為 true 時才有作用。

3.1.0
spark.sql.catalog.spark_catalog (無)

將用作 Spark 內建 v1 目錄的 v2 介面的目錄實作:spark_catalog。此目錄與 spark_catalog 共用其識別名稱空間,並且必須與其一致;例如,如果表格可以由 spark_catalog 載入,則此目錄也必須傳回表格的元資料。若要將作業委派給 spark_catalog,實作可以延伸 'CatalogExtension'。

3.0.0
spark.sql.cbo.enabled false

如果設為 true,則啟用 CBO 來估計計畫統計資料。

2.2.0
spark.sql.cbo.joinReorder.dp.star.filter false

將星形聯結過濾器啟發法套用於基於成本的聯結列舉。

2.2.0
spark.sql.cbo.joinReorder.dp.threshold 12

動態程式設計演算法中允許的最大聯結節點數。

2.2.0
spark.sql.cbo.joinReorder.enabled false

在 CBO 中啟用聯結重新排序。

2.2.0
spark.sql.cbo.planStats.enabled false

如果為 true,則邏輯計畫將從目錄中擷取列數和欄位統計資料。

3.0.0
spark.sql.cbo.starSchemaDetection false

如果為 true,則啟用基於星形架構偵測的聯結重新排序。

2.2.0
spark.sql.charAsVarchar false

如果為 true,則 Spark 會在 CREATE/REPLACE/ALTER TABLE 命令中將 CHAR 類型取代為 VARCHAR 類型,以便新建立/更新的表格不會有 CHAR 類型的欄位。此組態不會影響具有 CHAR 類型欄位的現有表格。

3.3.0
spark.sql.cli.print.header false

如果設為 true,則 spark-sql CLI 會在查詢輸出中列印欄位名稱。

3.2.0
spark.sql.columnNameOfCorruptRecord _corrupt_record

用於儲存無法解析的原始/未解析 JSON 和 CSV 記錄的內部欄位名稱。

1.2.0
spark.sql.csv.filterPushdown.enabled true

如果為 true,則啟用將篩選推送到 CSV 資料源。

3.0.0
spark.sql.datetime.java8API.enabled false

如果將組態屬性設定為 true,則 Java 8 API 的 java.time.Instant 和 java.time.LocalDate 類別將用作 Catalyst 的 TimestampType 和 DateType 的外部類型。如果設定為 false,則 java.sql.Timestamp 和 java.sql.Date 會用於相同目的。

3.0.0
spark.sql.debug.maxToStringFields 25

類似序列的項目欄位最大數目,可以在偵錯輸出中轉換為字串。任何超出限制的元素都將被捨棄,並以「... N 個更多欄位」的佔位符取代。

3.0.0
spark.sql.defaultCatalog spark_catalog

預設目錄名稱。如果使用者尚未明確設定目前的目錄,則這將是目前的目錄。

3.0.0
spark.sql.error.messageFormat PRETTY

如果為 PRETTY,則錯誤訊息包含錯誤類別、訊息和查詢內容的文字表示。MINIMAL 和 STANDARD 格式是漂亮的 JSON 格式,其中 STANDARD 包含額外的 JSON 欄位 message。此組態屬性會影響執行查詢時 Thrift Server 和 SQL CLI 的錯誤訊息。

3.4.0
spark.sql.execution.arrow.enabled false

(已於 Spark 3.0 中棄用,請設定「spark.sql.execution.arrow.pyspark.enabled」)

2.3.0
spark.sql.execution.arrow.fallback.enabled true

(已於 Spark 3.0 中棄用,請設定「spark.sql.execution.arrow.pyspark.fallback.enabled」)

2.4.0
spark.sql.execution.arrow.localRelationThreshold 48MB

將 Arrow 批次轉換為 Spark DataFrame 時,如果 Arrow 批次的位元組大小小於此閾值,則在驅動程式端使用本地集合。否則,Arrow 批次會傳送並反序列化到執行器中的 Spark 內部列。

3.4.0
spark.sql.execution.arrow.maxRecordsPerBatch 10000

使用 Apache Arrow 時,限制可寫入記憶體中單一 ArrowRecordBatch 的最大記錄數目。如果設定為零或負值,則沒有限制。

2.3.0
spark.sql.execution.arrow.pyspark.enabled spark.sql.execution.arrow.enabled 的值)

如果為 true,則在 PySpark 中使用 Apache Arrow 進行資料欄傳輸。此最佳化適用於:1. pyspark.sql.DataFrame.toPandas。2. pyspark.sql.SparkSession.createDataFrame,當其輸入為 Pandas DataFrame 或 NumPy ndarray 時。下列資料類型不受支援:TimestampType 的 ArrayType。

3.0.0
spark.sql.execution.arrow.pyspark.fallback.enabled spark.sql.execution.arrow.fallback.enabled 的值)

如果為 true,則「spark.sql.execution.arrow.pyspark.enabled」啟用的最佳化會在發生錯誤時自動回退到非最佳化的實作。

3.0.0
spark.sql.execution.arrow.pyspark.selfDestruct.enabled false

(實驗性)如果為 true,則在從 Arrow 轉換為 Pandas 時,使用 Apache Arrow 的自毀和分割區塊選項,進行 PySpark 中的資料欄傳輸。這會以一些 CPU 時間為代價來減少記憶體使用量。此最佳化適用於:當「spark.sql.execution.arrow.pyspark.enabled」設定時,pyspark.sql.DataFrame.toPandas。

3.2.0
spark.sql.execution.arrow.sparkr.enabled false

當為 true 時,在 SparkR 中使用 Apache Arrow 進行資料欄位傳輸。此最佳化適用於:1. 當輸入為 R 資料框時建立 createDataFrame 2. 收集 3. dapply 4. gapply 下列資料類型不受支援:FloatType、BinaryType、ArrayType、StructType 和 MapType。

3.0.0
spark.sql.execution.pandas.structHandlingMode 舊版

建立 pandas 資料框時,結構類型轉換模式。當為「舊版」時,1. 當 Arrow 最佳化已停用,轉換為 Row 物件,2. 當 Arrow 最佳化已啟用,轉換為 dict 或在有重複巢狀欄位名稱時引發例外狀況。當為「row」時,不論 Arrow 最佳化為何,都轉換為 Row 物件。當為「dict」時,不論 Arrow 最佳化為何,都轉換為 dict 並使用附檔字尾的鍵名稱(例如 a_0、a_1),如果存在重複的巢狀欄位名稱。

3.5.0
spark.sql.execution.pandas.udf.buffer.size spark.buffer.size 的值)

spark.buffer.size 相同,但只適用於 Pandas UDF 執行。如果未設定,預設值為 spark.buffer.size。請注意,Pandas 執行需要超過 4 個位元組。降低此值可以使小型 Pandas UDF 批次進行反覆運算和串接;但是,它可能會降低效能。請參閱 SPARK-27870。

3.0.0
spark.sql.execution.pyspark.udf.simplifiedTraceback.enabled true

當為 true 時,Python UDF 的追蹤會簡化。它會在追蹤中隱藏 PySpark 中的 Python 工作器、(解)序列化等,只顯示 UDF 的例外狀況訊息。請注意,這只適用於 CPython 3.7+。

3.1.0
spark.sql.execution.pythonUDF.arrow.enabled false

在一般 Python UDF 中啟用 Arrow 最佳化。此最佳化只能在給定函數至少有一個引數時啟用。

3.4.0
spark.sql.execution.pythonUDTF.arrow.enabled false

為 Python UDTF 啟用 Arrow 最佳化。

3.5.0
spark.sql.execution.topKSortFallbackThreshold 2147483632

在 SQL 查詢中,如果 SORT 後面接著 LIMIT,例如「SELECT x FROM t ORDER BY y LIMIT m」,如果 m 低於此臨界值,則在記憶體中進行前 K 筆排序,否則執行可能會溢出到磁碟的整體排序。

2.4.0
spark.sql.files.ignoreCorruptFiles false

是否忽略損毀的檔案。如果為 true,Spark 工作會在遇到損毀的檔案時繼續執行,且已讀取的內容仍會傳回。此組態僅在使用基於檔案的來源(例如 Parquet、JSON 和 ORC)時有效。

2.1.1
spark.sql.files.ignoreMissingFiles false

是否忽略遺失的檔案。如果為 true,Spark 工作會在遇到遺失的檔案時繼續執行,且已讀取的內容仍會傳回。此組態僅在使用基於檔案的來源(例如 Parquet、JSON 和 ORC)時有效。

2.3.0
spark.sql.files.maxPartitionBytes 128MB

讀取檔案時,封裝到單一分割區中的最大位元組數。此組態僅在使用基於檔案的來源(例如 Parquet、JSON 和 ORC)時有效。

2.0.0
spark.sql.files.maxPartitionNum (無)

建議(不保證)的最大分割檔案分割區數。如果設定此值,如果分割區的初始數量超過此值,Spark 會重新調整每個分割區的比例,讓分割區數量接近此值。此組態僅在使用基於檔案的來源(例如 Parquet、JSON 和 ORC)時有效。

3.5.0
spark.sql.files.maxRecordsPerFile 0

寫入單一檔案的最大記錄數。如果此值為零或負值,則沒有限制。

2.2.0
spark.sql.files.minPartitionNum (無)

建議(不保證)的最小分割檔案分割區數。如果未設定,預設值為 spark.sql.leafNodeDefaultParallelism。此組態僅在使用基於檔案的來源(例如 Parquet、JSON 和 ORC)時有效。

3.1.0
spark.sql.function.concatBinaryAsString false

如果將此選項設定為 false,且所有輸入都是二進位,則 functions.concat 會傳回二進位輸出的結果。否則,會傳回字串結果。

2.3.0
spark.sql.function.eltOutputAsString false

如果將此選項設定為 false,且所有輸入都是二進位,則 elt 會傳回二進位輸出的結果。否則,會傳回字串結果。

2.3.0
spark.sql.groupByAliases true

如果為 true,則選取清單中的別名可用於群組依據子句。如果為 false,則會在這種情況下擲回分析例外。

2.2.0
spark.sql.groupByOrdinal true

如果為 true,則群組依據子句中的序號會視為選取清單中的位置。如果為 false,則會忽略序號。

2.0.0
spark.sql.hive.convertInsertingPartitionedTable true

如果設定為 true,且 spark.sql.hive.convertMetastoreParquetspark.sql.hive.convertMetastoreOrc 為 true,則會使用內建的 ORC/Parquet 寫入器處理插入使用 HiveSQL 語法建立的已分割的 ORC/Parquet 資料表。

3.0.0
spark.sql.hive.convertMetastoreCtas true

如果設定為 true,Spark 會嘗試在 CTAS 中使用內建資料來源寫入器,而不是 Hive serde。此旗標僅在 spark.sql.hive.convertMetastoreParquetspark.sql.hive.convertMetastoreOrc 分別針對 Parquet 和 ORC 格式啟用時才有效

3.0.0
spark.sql.hive.convertMetastoreInsertDir true

如果設定為 true,Spark 會嘗試在 INSERT OVERWRITE DIRECTORY 中使用內建資料來源寫入器,而不是 Hive serde。此旗標僅在 spark.sql.hive.convertMetastoreParquetspark.sql.hive.convertMetastoreOrc 分別針對 Parquet 和 ORC 格式啟用時才有效

3.3.0
spark.sql.hive.convertMetastoreOrc true

設為 true 時,內建 ORC 讀取器和寫入器會用於處理使用 HiveQL 語法建立的 ORC 表格,而不是 Hive serde。

2.0.0
spark.sql.hive.convertMetastoreParquet true

設為 true 時,內建 Parquet 讀取器和寫入器會用於處理使用 HiveQL 語法建立的 Parquet 表格,而不是 Hive serde。

1.1.1
spark.sql.hive.convertMetastoreParquet.mergeSchema false

為 true 時,也會嘗試合併不同 Parquet 資料檔中可能不同但相容的 Parquet 架構。此組態僅在「spark.sql.hive.convertMetastoreParquet」為 true 時有效。

1.3.1
spark.sql.hive.dropPartitionByName.enabled false

為 true 時,Spark 會取得分割名稱,而不是分割物件來刪除分割,這可以提升刪除分割的效能。

3.4.0
spark.sql.hive.filesourcePartitionFileCacheSize 262144000

當非零時,啟用分割檔案元資料的記憶體快取。所有表格共用一個快取,最多可以使用指定的位元組數來儲存檔案元資料。此設定僅在啟用 Hive 檔案來源分割管理時有效。

2.1.1
spark.sql.hive.manageFilesourcePartitions true

為 true 時,也為檔案來源表格啟用 Metastore 分割管理。這包括資料來源和轉換的 Hive 表格。啟用分割管理後,資料來源表格會將分割儲存在 Hive Metastore 中,並在 spark.sql.hive.metastorePartitionPruning 設為 true 時,在查詢規劃期間使用 Metastore 來修剪分割。

2.1.1
spark.sql.hive.metastorePartitionPruning true

為 true 時,某些謂詞會下推至 Hive Metastore,以便可以提早消除不匹配的分割。

1.5.0
spark.sql.hive.metastorePartitionPruningFallbackOnException false

從 Metastore 遇到 MetaException 時,是否改用從 Hive Metastore 取得所有分割,並在 Spark 客戶端執行分割修剪。請注意,如果啟用此選項且有許多分割要列出,Spark 查詢效能可能會下降。如果停用此選項,Spark 會改為讓查詢失敗。

3.3.0
spark.sql.hive.metastorePartitionPruningFastFallback false

啟用此設定時,如果謂詞不受 Hive 支援,或 Spark 因從 Metastore 遇到 MetaException 而改用,Spark 會改用先取得分割名稱,然後在客戶端評估篩選式來修剪分割。請注意,不支援具有 TimeZoneAwareExpression 的謂詞。

3.3.0
spark.sql.hive.thriftServer.async true

設為 true 時,Hive Thrift 伺服器會以非同步方式執行 SQL 查詢。

1.5.0
spark.sql.hive.verifyPartitionPath false

為 true 時,在從 HDFS 儲存的資料中讀取資料時,檢查表格根目錄下的所有分割路徑。此組態將在未來版本中棄用,並由 spark.files.ignoreMissingFiles 取代。

1.4.0
spark.sql.inMemoryColumnarStorage.batchSize 10000

控制欄位快取批次的容量。較大的批次容量可以提升記憶體使用率和壓縮,但快取資料時有發生 OOM 的風險。

1.1.1
spark.sql.inMemoryColumnarStorage.compressed true

當設為 true 時,Spark SQL 會根據資料統計資料自動為每一個欄位選擇壓縮編解碼器。

1.0.1
spark.sql.inMemoryColumnarStorage.enableVectorizedReader true

為欄位快取啟用向量化讀取器。

2.3.1
spark.sql.json.filterPushdown.enabled true

當為 true 時,啟用將篩選條件下推至 JSON 資料來源。

3.1.0
spark.sql.jsonGenerator.ignoreNullFields true

在 JSON 資料來源和 JSON 函式(例如 to_json)中產生 JSON 物件時,是否忽略 null 欄位。如果為 false,則會在 JSON 物件中為 null 欄位產生 null。

3.0.0
spark.sql.leafNodeDefaultParallelism (無)

產生資料的 Spark SQL 葉節點的預設並行度,例如檔案掃描節點、本機資料掃描節點、範圍節點等。此設定的預設值為「SparkContext#defaultParallelism」。

3.2.0
spark.sql.mapKeyDedupPolicy EXCEPTION

內建函式中重複的 map 鍵的重複資料刪除政策:CreateMap、MapFromArrays、MapFromEntries、StringToMap、MapConcat 和 TransformKeys。當為 EXCEPTION 時,如果偵測到重複的 map 鍵,查詢會失敗。當為 LAST_WIN 時,最後插入的 map 鍵優先。

3.0.0
spark.sql.maven.additionalRemoteRepositories https://maven-central.storage-download.googleapis.com/maven2/

選用的其他遠端 Maven 鏡像儲存庫的逗號分隔字串設定。這只用於在預設 Maven Central 儲存庫無法連線時,下載 IsolatedClientLoader 中的 Hive jar。

3.0.0
spark.sql.maxMetadataStringLength 100

輸出至中繼資料字串的最大字元數。例如 DataSourceScanExec 中的檔案位置,如果超過長度,每個值都會被縮寫。

3.1.0
spark.sql.maxPlanStringLength 2147483632

輸出至計畫字串的最大字元數。如果計畫較長,後續輸出會被截斷。預設設定總是會產生完整的計畫。如果計畫字串佔用太多記憶體,或導致驅動程式或 UI 程序發生 OutOfMemory 錯誤,請將此設定為較低的值,例如 8k。

3.0.0
spark.sql.maxSinglePartitionBytes 9223372036854775807b

單一分割允許的最大位元組數。否則,規劃器會導入洗牌以改善並行度。

3.4.0
spark.sql.optimizer.collapseProjectAlwaysInline false

是否總是合併兩個相鄰的投影和內聯表達式,即使會造成額外的重複。

3.3.0
spark.sql.optimizer.dynamicPartitionPruning.enabled true

為 true 時,我們會在聯結金鑰中使用分割欄位時產生謂詞

3.0.0
spark.sql.optimizer.enableCsvExpressionOptimization true

是否在 SQL 最佳化器中最佳化 CSV 表達式。它包括從 from_csv 中修剪不必要的欄位。

3.2.0
spark.sql.optimizer.enableJsonExpressionOptimization true

是否在 SQL 最佳化器中最佳化 JSON 表達式。它包括從 from_json 中修剪不必要的欄位,簡化 from_json + to_json、to_json + named_struct(from_json.col1, from_json.col2, ....)。

3.1.0
spark.sql.optimizer.excludedRules (無)

設定在最佳化器中要停用的規則清單,其中規則以其規則名稱指定並以逗號分隔。無法保證此設定中的所有規則最終都會被排除,因為某些規則對於正確性是必要的。最佳化器會記錄實際已排除的規則。

2.4.0
spark.sql.optimizer.runtime.bloomFilter.applicationSideScanSizeThreshold 10GB

Bloom 篩選器應用程式側計畫的彙總掃描大小的位元組大小閾值。Bloom 篩選器應用程式側的彙總掃描位元組大小需要超過此值才能注入 Bloom 篩選器。

3.3.0
spark.sql.optimizer.runtime.bloomFilter.creationSideThreshold 10MB

Bloom 篩選器建立側計畫的大小閾值。估計大小需要低於此值才能嘗試注入 Bloom 篩選器。

3.3.0
spark.sql.optimizer.runtime.bloomFilter.enabled true

為 true 且如果洗牌聯結的一側具有選擇性謂詞時,我們會嘗試在另一側插入 Bloom 篩選器以減少洗牌資料量。

3.3.0
spark.sql.optimizer.runtime.bloomFilter.expectedNumItems 1000000

執行時期 Bloom 篩選器的預期項目預設數量

3.3.0
spark.sql.optimizer.runtime.bloomFilter.maxNumBits 67108864

執行時期 Bloom 篩選器要使用的最大位元數

3.3.0
spark.sql.optimizer.runtime.bloomFilter.maxNumItems 4000000

執行時期 Bloom 篩選器的允許最大預期項目數量

3.3.0
spark.sql.optimizer.runtime.bloomFilter.numBits 8388608

執行時期 Bloom 篩選器要使用的預設位元數

3.3.0
spark.sql.optimizer.runtime.rowLevelOperationGroupFilter.enabled true

針對基於群組的列級操作啟用執行時期群組篩選。取代資料群組的資料來源(例如檔案、分割區)可以在規劃列級操作掃描時,使用提供的資料來源篩選器來修剪整個群組。然而,此類篩選受到限制,因為並非所有表達式都能轉換成資料來源篩選器,而且某些表達式只能由 Spark 評估(例如子查詢)。由於重寫群組很耗費資源,因此 Spark 可以執行查詢以在執行時期找出哪些記錄符合列級操作的條件。關於相符記錄的資訊將傳回列級操作掃描,讓資料來源可以捨棄不必重寫的群組。

3.4.0
spark.sql.optimizer.runtimeFilter.number.threshold 10

單一查詢中注入的執行時期篩選器(非 DPP)總數。這是為了防止驅動程式因過多 Bloom 篩選器而發生 OOM。

3.3.0
spark.sql.optimizer.runtimeFilter.semiJoinReduction.enabled false

如果為 true,且混洗聯結的一方具有選擇性謂詞,我們會嘗試在另一方插入半聯結,以減少混洗資料的數量。

3.3.0
spark.sql.orc.aggregatePushdown false

如果為 true,則會將聚合推送到 ORC 以進行最佳化。支援 MIN、MAX 和 COUNT 作為聚合運算式。對於 MIN/MAX,支援布林值、整數、浮點數和日期類型。對於 COUNT,支援所有資料類型。如果任何 ORC 檔案尾端缺少統計資料,就會擲回例外狀況。

3.3.0
spark.sql.orc.columnarReaderBatchSize 4096

要包含在 orc 向量化讀取批次中的列數。應仔細選擇這個數字,以將開銷減至最低,並避免在讀取資料時發生 OOM。

2.4.0
spark.sql.orc.columnarWriterBatchSize 1024

要包含在 orc 向量化寫入批次中的列數。應仔細選擇這個數字,以將開銷減至最低,並避免在寫入資料時發生 OOM。

3.4.0
spark.sql.orc.compression.codec snappy

設定寫入 ORC 檔案時使用的壓縮編解碼器。如果在特定於資料表的選項/屬性中指定了 compressionorc.compress,優先順序將為 compressionorc.compressspark.sql.orc.compression.codec。可接受的值包括:none、uncompressed、snappy、zlib、lzo、zstd、lz4。

2.3.0
spark.sql.orc.enableNestedColumnVectorizedReader true

為巢狀欄位啟用向量化 orc 解碼。

3.2.0
spark.sql.orc.enableVectorizedReader true

啟用向量化 orc 解碼。

2.3.0
spark.sql.orc.filterPushdown true

如果為 true,則為 ORC 檔案啟用篩選推播。

1.4.0
spark.sql.orc.mergeSchema false

如果為 true,則 Orc 資料來源會合併從所有資料檔案收集的架構,否則會從隨機資料檔案中挑選架構。

3.0.0
spark.sql.orderByOrdinal true

如果為 true,則序號會視為在選取清單中的位置。如果為 false,則會忽略 order/sort by 子句中的序號。

2.0.0
spark.sql.parquet.aggregatePushdown false

如果為 true,則會將聚合推送到 Parquet 以進行最佳化。支援 MIN、MAX 和 COUNT 作為聚合運算式。對於 MIN/MAX,支援布林值、整數、浮點數和日期類型。對於 COUNT,支援所有資料類型。如果任何 Parquet 檔案尾端缺少統計資料,就會擲回例外狀況。

3.3.0
spark.sql.parquet.binaryAsString false

其他一些產生 Parquet 的系統,特別是 Impala 和舊版本的 Spark SQL,在寫出 Parquet 架構時不會區分二進位資料和字串。這個旗標會指示 Spark SQL 將二進位資料解譯為字串,以提供與這些系統的相容性。

1.1.1
spark.sql.parquet.columnarReaderBatchSize 4096

要包含在 parquet 向量化讀取批次中的列數。應仔細選擇這個數字,以將開銷減至最低,並避免在讀取資料時發生 OOM。

2.4.0
spark.sql.parquet.compression.codec snappy

設定寫入 Parquet 檔案時使用的壓縮編解碼器。如果在特定於表格的選項/屬性中指定了 compressionparquet.compression,優先順序將為 compressionparquet.compressionspark.sql.parquet.compression.codec。可接受的值包括:none、uncompressed、snappy、gzip、lzo、brotli、lz4、lz4raw、lz4_raw、zstd。

1.1.1
spark.sql.parquet.enableNestedColumnVectorizedReader true

為巢狀欄位(例如結構、清單、映射)啟用向量化 Parquet 解碼。需要啟用 spark.sql.parquet.enableVectorizedReader。

3.3.0
spark.sql.parquet.enableVectorizedReader true

啟用向量化 Parquet 解碼。

2.0.0
spark.sql.parquet.fieldId.read.enabled false

欄位 ID 是 Parquet 結構規範的原生欄位。啟用後,Parquet 讀取器將使用請求的 Spark 結構規範中的欄位 ID(如果存在)來查詢 Parquet 欄位,而不是使用欄位名稱

3.3.0
spark.sql.parquet.fieldId.read.ignoreMissing false

當 Parquet 檔案沒有任何欄位 ID,但 Spark 讀取結構規範使用欄位 ID 進行讀取時,如果啟用此標記,我們將靜默傳回 Null,否則會傳回錯誤。

3.3.0
spark.sql.parquet.fieldId.write.enabled true

欄位 ID 是 Parquet 結構規範的原生欄位。啟用後,Parquet 寫入器將填入 Spark 結構規範中欄位 ID 的元資料(如果存在)至 Parquet 結構規範。

3.3.0
spark.sql.parquet.filterPushdown true

設定為 true 時,啟用 Parquet 篩選下推最佳化。

1.2.0
spark.sql.parquet.inferTimestampNTZ.enabled true

啟用後,在結構規範推論期間,註解 isAdjustedToUTC = false 的 Parquet 時間戳記欄位會推論為 TIMESTAMP_NTZ 類型。否則,所有 Parquet 時間戳記欄位都會推論為 TIMESTAMP_LTZ 類型。請注意,Spark 會在寫入檔案時將輸出結構規範寫入 Parquet 的頁尾元資料,並在讀取檔案時利用它。因此,此組態只會影響並非由 Spark 寫入的 Parquet 檔案的結構規範推論。

3.4.0
spark.sql.parquet.int96AsTimestamp true

某些產生 Parquet 的系統,特別是 Impala,會將時間戳記儲存在 INT96 中。Spark 也會將時間戳記儲存在 INT96 中,因為我們需要避免奈秒欄位的精度損失。此標記會指示 Spark SQL 將 INT96 資料解譯為時間戳記,以與這些系統相容。

1.3.0
spark.sql.parquet.int96TimestampConversion false

這會控制是否應將時間戳記調整套用到 INT96 資料,以便將 Impala 寫入的資料轉換為時間戳記。這是必要的,因為 Impala 會使用與 Hive 和 Spark 不同的時區偏移量來儲存 INT96 資料。

2.3.0
spark.sql.parquet.mergeSchema false

如果為 true,Parquet 資料來源會合併從所有資料檔案收集的結構規範,否則會從摘要檔案或隨機資料檔案(如果沒有摘要檔案)中選取結構規範。

1.5.0
spark.sql.parquet.outputTimestampType INT96

設定 Spark 將資料寫入 Parquet 檔案時要使用的 Parquet 時間戳記類型。INT96 是 Parquet 中的非標準但常用的時間戳記類型。TIMESTAMP_MICROS 是 Parquet 中的標準時間戳記類型,用於儲存自 Unix 紀元以來的微秒數。TIMESTAMP_MILLIS 也是標準的,但具有毫秒精度,這表示 Spark 必須截斷其時間戳記值的微秒部分。

2.3.0
spark.sql.parquet.recordLevelFilter.enabled false

如果為 true,則使用推入式篩選條件啟用 Parquet 的原生記錄層級篩選。此設定僅在啟用「spark.sql.parquet.filterPushdown」且未使用向量化讀取器時有效。您可以透過將「spark.sql.parquet.enableVectorizedReader」設定為 false 來確保不使用向量化讀取器。

2.3.0
spark.sql.parquet.respectSummaryFiles false

如果為 true,我們假設 Parquet 的所有部分檔案都與摘要檔案一致,而且我們在合併架構時會忽略它們。否則,如果為 false(預設值),我們會合併所有部分檔案。這應視為僅限專家使用的選項,而且不應在確切了解其含義之前啟用。

1.5.0
spark.sql.parquet.writeLegacyFormat false

如果為 true,資料將以 Spark 1.4 及更早版本的方式寫入。例如,十進位數值將以 Apache Parquet 的固定長度位元組陣列格式寫入,這是 Apache Hive 和 Apache Impala 等其他系統所使用的格式。如果為 false,將使用 Parquet 中較新的格式。例如,十進位數將以基於整數的格式寫入。如果 Parquet 輸出預計會與不支援此較新格式的系統搭配使用,請設定為 true。

1.6.0
spark.sql.parser.quotedRegexColumnNames false

如果為 true,SELECT 陳述式中的引號識別碼(使用反引號)將被解釋為正規表示式。

2.3.0
spark.sql.pivotMaxValues 10000

在未為樞紐欄位指定值的情況下執行樞紐時,這是將收集的最大(相異)值數,且不會產生錯誤。

1.6.0
spark.sql.pyspark.inferNestedDictAsStruct.enabled false

PySpark 的 SparkSession.createDataFrame 預設會將巢狀字典推論為映射。當設定為 true 時,它會將巢狀字典推論為結構。

3.3.0
spark.sql.pyspark.jvmStacktrace.enabled false

如果為 true,它會在使用者介面的 PySpark 例外狀況中顯示 JVM 堆疊追蹤,以及 Python 堆疊追蹤。預設情況下,它會停用以隱藏 JVM 堆疊追蹤,並只顯示對 Python 友善的例外狀況。請注意,這與記錄層級設定無關。

3.0.0
spark.sql.pyspark.legacy.inferArrayTypeFromFirstElement.enabled false

PySpark 的 SparkSession.createDataFrame 預設會從陣列中的所有值推論陣列的元素類型。如果將此設定設為 true,它會還原僅從第一個陣列元素推論類型的舊有行為。

3.4.0
spark.sql.readSideCharPadding true

為 true 時,Spark 會在讀取 CHAR 類型的欄位/欄位時套用字串填補,除了寫入端的填補之外。此設定預設為 true,以在外部表格等情況中更好地強制執行 CHAR 類型的語意。

3.4.0
spark.sql.redaction.options.regex (?i)url

正規表示式用於判斷 Spark SQL 命令選項對應中哪些金鑰包含機密資訊。名稱符合此正規表示式的選項值會在 explain 輸出中進行編輯。此編輯套用在 spark.redaction.regex 定義的全球編輯設定之上。

2.2.2
spark.sql.redaction.string.regex (spark.redaction.string.regex 的值)

正規表示式用於判斷 Spark 產生的字串中哪些部分包含機密資訊。當此正規表示式符合字串部分時,該字串部分會被替換為虛擬值。此功能目前用於編輯 SQL explain 命令的輸出。當此設定未設定時,會使用 spark.redaction.string.regex 的值。

2.3.0
spark.sql.repl.eagerEval.enabled false

啟用或停用熱切評估。為 true 時,只有當 REPL 支援熱切評估時,才會顯示 Dataset 的前 K 列。目前,熱切評估在 PySpark 和 SparkR 中受支援。在 PySpark 中,對於像 Jupyter 這樣的筆記本,會傳回 HTML 表格(由 repr_html 產生)。對於純 Python REPL,傳回的輸出會以 dataframe.show() 格式化。在 SparkR 中,傳回的輸出會以類似 R data.frame 的方式顯示。

2.4.0
spark.sql.repl.eagerEval.maxNumRows 20

熱切評估傳回的最大列數。此設定僅在 spark.sql.repl.eagerEval.enabled 設為 true 時才會生效。此設定的有效範圍為 0 到 (Int.MaxValue - 1),因此無效設定(例如負數和超過 (Int.MaxValue - 1))會標準化為 0 和 (Int.MaxValue - 1)。

2.4.0
spark.sql.repl.eagerEval.truncate 20

熱切評估傳回的每個儲存格的最大字元數。此設定僅在 spark.sql.repl.eagerEval.enabled 設為 true 時才會生效。

2.4.0
spark.sql.session.localRelationCacheThreshold 67108864

序列化後,驅動程式端快取的本地關聯大小(以位元組為單位)的臨界值。

3.5.0
spark.sql.session.timeZone (當地時區的值)

以區域為基礎的時區 ID 或時區偏移量格式表示的會話當地時區 ID。區域 ID 必須採用「區域/城市」格式,例如「America/Los_Angeles」。時區偏移量必須採用「(+|-)HH」、「(+|-)HH:mm」或「(+|-)HH:mm:ss」格式,例如「-08」、「+01:00」或「-13:33:33」。此外,也支援「UTC」和「Z」作為「+00:00」的別名。不建議使用其他簡稱,因為它們可能會造成歧義。

2.2.0
spark.sql.shuffle.partitions 200

在為聯結或聚合整理資料時要使用的預設分割區數目。注意:對於結構化串流,無法在從同一個檢查點位置重新啟動查詢之間變更此組態。

1.1.0
spark.sql.shuffledHashJoinFactor 3

如果小型側資料大小乘上此因子後仍然小於大型側,則可以選取整理雜湊聯結。

3.3.0
spark.sql.sources.bucketing.autoBucketedScan.enabled true

如果為 true,則會根據查詢計畫自動決定是否對輸入資料表執行分桶掃描。如果 1. 查詢沒有運算子可以使用分桶(例如聯結、群組依據等),或 2. 這些運算子與資料表掃描之間有一個交換運算子,則不要使用分桶掃描。請注意,當「spark.sql.sources.bucketing.enabled」設為 false 時,此組態不會產生任何效果。

3.1.0
spark.sql.sources.bucketing.enabled true

如果為 false,我們會將分桶資料表視為一般資料表

2.0.0
spark.sql.sources.bucketing.maxBuckets 100000

允許的最大分桶數目。

2.4.0
spark.sql.sources.default parquet

在輸入/輸出中要使用的預設資料來源。

1.3.0
spark.sql.sources.parallelPartitionDiscovery.threshold 32

在驅動程式端列出檔案時允許的最大路徑數目。如果在分割區偵測期間,偵測到的路徑數目超過此值,它會嘗試使用另一個 Spark 分散式工作列出檔案。此組態僅在使用基於檔案的來源(例如 Parquet、JSON 和 ORC)時有效。

1.5.0
spark.sql.sources.partitionColumnTypeInference.enabled true

如果為 true,則會自動推論分割欄的資料類型。

1.5.0
spark.sql.sources.partitionOverwriteMode STATIC

當 INSERT OVERWRITE 分割資料來源表格時,我們目前支援 2 種模式:靜態和動態。在靜態模式中,Spark 會在覆寫前刪除與 INSERT 陳述式中分割規格 (例如 PARTITION(a=1,b)) 相符的所有分割。在動態模式中,Spark 不會預先刪除分割,只會覆寫在執行時期寫入資料的分割。預設情況下,我們使用靜態模式來維持 Spark 在 2.3 之前的相同行為。請注意,此組態不會影響 Hive serde 表格,因為它們總是使用動態模式覆寫。這也可以設定為資料來源的輸出選項,使用 key partitionOverwriteMode (優先於此設定),例如 dataframe.write.option("partitionOverwriteMode", "dynamic").save(path)。

2.3.0
spark.sql.sources.v2.bucketing.enabled false

類似於 spark.sql.sources.bucketing.enabled,此組態用於啟用 V2 資料來源的區塊化。開啟時,Spark 會透過 SupportsReportPartitioning 辨識 V2 資料來源報告的特定分佈,並會在必要時嘗試避免洗牌。

3.3.0
spark.sql.sources.v2.bucketing.partiallyClusteredDistribution.enabled false

在儲存體分割連接期間,當連接的兩側都是 KeyGroupedPartitioning 時,是否允許輸入分割部分群集化。在規劃時間,Spark 會根據表格統計資料選擇資料大小較小的側,將其群組並複製以符合另一側。這是對傾斜連接的最佳化,並有助於減少資料傾斜,當某些分割被指定大量資料時。此組態需要同時啟用 spark.sql.sources.v2.bucketing.enabled 和 spark.sql.sources.v2.bucketing.pushPartValues.enabled

3.4.0
spark.sql.sources.v2.bucketing.pushPartValues.enabled false

當啟用 spark.sql.sources.v2.bucketing.enabled 時,是否推播常見分割值。開啟時,如果連接的兩側都是 KeyGroupedPartitioning,且它們共用相容的分割金鑰,即使它們沒有完全相同的分割值,Spark 會計算分割值的超集,並將該資訊推播至掃描節點,這些節點會使用兩側遺失分割值的空分割。這有助於消除不必要的洗牌

3.4.0
spark.sql.statistics.fallBackToHdfs false

為 true 時,如果無法從表格中取得表格統計資料,它會回退至 HDFS。這有助於判斷表格是否夠小到可以使用廣播連接。此旗標僅對非分割 Hive 表格有效。對於非分割資料來源表格,如果無法取得表格統計資料,它會自動重新計算。對於分割資料來源和分割 Hive 表格,如果無法取得表格統計資料,它會是 'spark.sql.defaultSizeInBytes'。

2.0.0
spark.sql.statistics.histogram.enabled false

如果已啟用,在計算欄位統計資料時會產生直方圖。直方圖可以提供更好的估計準確度。目前,Spark 僅支援等高直方圖。請注意,收集直方圖需要額外的成本。例如,收集欄位統計資料通常只需掃描一次表格,但產生等高直方圖會導致額外掃描一次表格。

2.3.0
spark.sql.statistics.size.autoUpdate.enabled false

當表格資料變更時,啟用表格大小的自動更新。請注意,如果表格的總檔案數目非常大,這可能會很花費成本,並降低資料變更指令的速度。

2.3.0
spark.sql.storeAssignmentPolicy ANSI

在將值插入具有不同資料類型的欄位時,Spark 會執行類型強制轉換。目前,我們支援類型強制轉換規則的 3 種政策:ANSI、舊版和嚴格。透過 ANSI 政策,Spark 會根據 ANSI SQL 執行類型強制轉換。在實務上,行為大多與 PostgreSQL 相同。它不允許某些不合理的類型轉換,例如將 string 轉換為 int 或將 double 轉換為 boolean。透過舊版政策,只要是有效的 Cast,Spark 就允許類型強制轉換,這非常寬鬆。例如,允許將 string 轉換為 int 或將 double 轉換為 boolean。它也是 Spark 2.x 中唯一的行為,且與 Hive 相容。透過嚴格政策,Spark 不允許類型強制轉換中任何可能的精度損失或資料截斷,例如,不允許將 double 轉換為 int 或將 decimal 轉換為 double

3.0.0
spark.sql.streaming.checkpointLocation (無)

用於儲存串流查詢檢查點資料的預設位置。

2.0.0
spark.sql.streaming.continuous.epochBacklogQueueSize 10000

儲存在佇列中以等待較晚時期的最大項目數。如果佇列的大小超過此參數,串流會停止並顯示錯誤訊息。

3.0.0
spark.sql.streaming.disabledV2Writers

已停用 StreamWriteSupport 的完全限定資料來源註冊類別名稱的逗號分隔清單。寫入這些來源會回退到 V1 Sinks。

2.3.1
spark.sql.streaming.fileSource.cleaner.numThreads 1

檔案來源已完成檔案清除程式中使用的執行緒數目。

3.0.0
spark.sql.streaming.forceDeleteTempCheckpointLocation false

如果為 true,則啟用暫時檢查點位置強制刪除。

3.0.0
spark.sql.streaming.metricsEnabled false

是否會針對主動串流查詢報告 Dropwizard/Codahale 指標。

2.0.2
spark.sql.streaming.multipleWatermarkPolicy min

在串流查詢中有多個浮水印運算子時,計算全域浮水印值的政策。預設值為「min」,會選取多個運算子所報告的最小浮水印。其他替代值為「max」,會選取多個運算子所報告的最大浮水印。注意:此組態無法在從相同檢查點位置重新啟動查詢之間變更。

2.4.0
spark.sql.streaming.noDataMicroBatches.enabled true

串流微批次引擎是否會執行沒有資料的批次,以進行有狀態串流查詢的積極狀態管理。

2.4.1
spark.sql.streaming.numRecentProgressUpdates 100

保留串流查詢進度更新的數量

2.1.1
spark.sql.streaming.sessionWindow.merge.sessions.in.local.partition false

如果為 true,串流會話視窗會在洗牌之前,在本地分割區中排序和合併會話。這是為了減少要洗牌的行數,但僅在批次中有許多行被指定到相同會話時才會有幫助。

3.2.0
spark.sql.streaming.stateStore.stateSchemaCheck true

如果為 true,Spark 會根據現有狀態的架構驗證狀態架構,如果不相容,則會讓查詢失敗。

3.1.0
spark.sql.streaming.stopActiveRunOnRestart true

不支援同時執行同一個串流查詢的多次執行。如果我們發現串流查詢的並行主動執行(在同一個叢集中的同一個或不同的 SparkSessions 中),而且這個旗標為 true,我們會停止舊的串流查詢執行,以開始新的執行。

3.0.0
spark.sql.streaming.stopTimeout 0

呼叫串流查詢的 stop() 方法時,以毫秒為單位等待串流執行緒停止的時間長度。0 或負值會無限期等待。

3.0.0
spark.sql.thriftServer.interruptOnCancel true

如果為 true,如果有人取消查詢,所有正在執行的任務都會中斷。如果為 false,所有正在執行的任務都會繼續執行,直到完成。

3.2.0
spark.sql.thriftServer.queryTimeout 0ms

在 Thrift Server 中設定查詢持續時間逾時(以秒為單位)。如果逾時設定為正值,執行中的查詢會在逾時後自動取消,否則查詢會繼續執行,直到完成。如果透過 java.sql.Statement.setQueryTimeout 為每個陳述式設定逾時值,而且這些值小於這個組態值,則這些值會優先。如果您設定這個逾時,而且偏好立即取消查詢,而不等待任務完成,請考慮同時啟用 spark.sql.thriftServer.interruptOnCancel。

3.1.0
spark.sql.thriftserver.scheduler.pool (無)

為 JDBC 用戶端會話設定公平排程器池。

1.1.1
spark.sql.thriftserver.ui.retainedSessions 200

JDBC/ODBC 網路使用者介面歷程記錄中保留的 SQL 用戶端工作階段數目。

1.4.0
spark.sql.thriftserver.ui.retainedStatements 200

JDBC/ODBC 網路使用者介面歷程記錄中保留的 SQL 陳述數目。

1.4.0
spark.sql.timestampType TIMESTAMP_LTZ

設定 Spark SQL 的預設時間戳記類型,包括 SQL DDL、Cast 子句、類型文字和資料來源的架構推論。將設定設為 TIMESTAMP_NTZ 會使用 TIMESTAMP WITHOUT TIME ZONE 作為預設類型,而將其設為 TIMESTAMP_LTZ 則會使用 TIMESTAMP WITH LOCAL TIME ZONE。在 3.4.0 版本之前,Spark 僅支援 TIMESTAMP WITH LOCAL TIME ZONE 類型。

3.4.0
spark.sql.tvf.allowMultipleTableArguments.enabled false

若為 true,則允許表格值函數使用多個表格引數,接收這些表格所有列的笛卡兒積。

3.5.0
spark.sql.ui.explainMode formatted

設定 Spark SQL 使用者介面中使用的查詢說明模式。值可以是「simple」、「extended」、「codegen」、「cost」或「formatted」。預設值為「formatted」。

3.1.0
spark.sql.variable.substitute true

這會啟用使用類似於 ${var}${system:var}${env:var} 的語法進行替換。

2.0.0

靜態 SQL 組態

靜態 SQL 設定是跨工作階段、不可變的 Spark SQL 設定。它們可以使用設定檔和帶有 --conf/-c 前綴的命令列選項,或透過設定用於建立 SparkSessionSparkConf 來設定最終值。外部使用者可以透過 SparkSession.conf 或透過設定指令(例如 SET spark.sql.extensions;)查詢靜態 SQL 設定值,但無法設定或取消設定它們。

屬性名稱預設值意義版本
spark.sql.cache.serializer org.apache.spark.sql.execution.columnar.DefaultCachedBatchSerializer

實作 org.apache.spark.sql.columnar.CachedBatchSerializer 的類別名稱。它將用於將 SQL 資料轉換成可以更有效率快取的格式。基礎 API 可能會變更,因此請小心使用。無法指定多個類別。該類別必須具備無引數建構函式。

3.1.0
spark.sql.catalog.spark_catalog.defaultDatabase default

工作階段目錄的預設資料庫。

3.4.0
spark.sql.event.truncate.length 2147483647

SQL 長度的臨界值,超過此臨界值後,將在加入事件之前將其截斷。預設為不截斷。如果設為 0,則會記錄呼叫位置。

3.0.0
spark.sql.extensions (無)

實作 Function1[SparkSessionExtensions, Unit] 的類別清單,用於設定 Spark 工作階段延伸模組。這些類別必須具備無引數建構函式。如果指定多個延伸模組,則會按指定的順序套用它們。對於規則和規劃策略,它們會按指定的順序套用。對於剖析器,則會使用最後一個剖析器,而每個剖析器都可以委派給其前一個剖析器。對於函數名稱衝突,則會使用最後一個註冊的函數名稱。

2.2.0
spark.sql.hive.metastore.barrierPrefixes

類別前綴的逗號分隔清單,應該針對 Spark SQL 與之通訊的每個 Hive 版本明確重新載入。例如,在通常會共用的前綴中宣告的 Hive UDF(例如 org.apache.spark.*)。

1.4.0
spark.sql.hive.metastore.jars 內建

用於建立 HiveMetastoreClient 的 jar 位置。此屬性可以是四個選項之一:1. 「內建」使用 Hive 2.3.9,當啟用 -Phive 時,會與 Spark 組合打包。當選擇此選項時,spark.sql.hive.metastore.version 必須是 2.3.9 或未定義。2. 「maven」使用從 Maven 儲存庫下載的指定版本 Hive jar。3. 「路徑」使用以逗號分隔格式由 spark.sql.hive.metastore.jars.path 設定的 Hive jar。支援本機或遠端路徑。提供的 jar 應與 spark.sql.hive.metastore.version 相同版本。4. Hive 和 Hadoop 的標準格式類別路徑。提供的 jar 應與 spark.sql.hive.metastore.version 相同版本。

1.4.0
spark.sql.hive.metastore.jars.path

用於建立 HiveMetastoreClient 的 jar 的逗號分隔路徑。此設定僅在 spark.sql.hive.metastore.jars 設定為 path 時才有用。路徑可以是下列任何格式:1. file://path/to/jar/foo.jar 2. hdfs://nameservice/path/to/jar/foo.jar 3. /path/to/jar/(沒有 URI 架構的路徑遵循 conf fs.defaultFS 的 URI 架構)4. [http/https/ftp]://path/to/jar/foo.jar 請注意,1、2 和 3 支援萬用字元。例如:1. file://path/to/jar/,file://path2/to/jar//.jar 2. hdfs://nameservice/path/to/jar/,hdfs://nameservice2/path/to/jar//.jar

3.1.0
spark.sql.hive.metastore.sharedPrefixes com.mysql.jdbc,org.postgresql,com.microsoft.sqlserver,oracle.jdbc

應使用 Spark SQL 和特定版本的 Hive 共用的類別載入程式載入的類別字首的逗號分隔清單。應共用的類別範例是與資料倉儲通訊所需的 JDBC 驅動程式。其他需要共用的類別是與已共用的類別互動的類別。例如,log4j 使用的客製化附加程式。

1.4.0
spark.sql.hive.metastore.version 2.3.9

Hive 資料倉儲版本。可用的選項為 0.12.02.3.9,以及 3.0.03.1.3

1.4.0
spark.sql.hive.thriftServer.singleSession false

設定為 true 時,Hive Thrift 伺服器會以單一工作階段模式執行。所有 JDBC/ODBC 連線會共用暫時檢視、函數註冊、SQL 設定和目前資料庫。

1.6.0
spark.sql.hive.version 2.3.9

與 Spark 散佈套件內建的已編譯 Hive 版本,又稱內建版本。請注意,這是一個唯讀設定,僅用於報告內建的 Hive 版本。如果您要 Spark 呼叫不同的資料倉儲用戶端,請參閱 spark.sql.hive.metastore.version。

1.1.1
spark.sql.metadataCacheTTLSeconds -1000ms

資料倉儲快取的到期時間 (TTL) 值:分割檔案資料倉儲快取和工作階段目錄快取。此設定僅在這個值為正值 (> 0) 時才會生效。它還需要將 'spark.sql.catalogImplementation' 設定為 hive,將 'spark.sql.hive.filesourcePartitionFileCacheSize' 設定為 > 0,並將 'spark.sql.hive.manageFilesourcePartitions' 設定為 true,才能套用於分割檔案資料倉儲快取。

3.1.0
spark.sql.queryExecutionListeners (無)

實作 QueryExecutionListener 的類別名稱清單,將自動新增至新建立的階段。這些類別應具有無引數建構函式,或預期 SparkConf 引數的建構函式。

2.3.0
spark.sql.sources.disabledJdbcConnProviderList

設定已停用的 JDBC 連線提供者清單。清單包含以逗號分隔的 JDBC 連線提供者名稱。

3.1.0
spark.sql.streaming.streamingQueryListeners (無)

實作 StreamingQueryListener 的類別名稱清單,將自動新增至新建立的階段。這些類別應具有無引數建構函式,或預期 SparkConf 引數的建構函式。

2.4.0
spark.sql.streaming.ui.enabled true

當 Spark 網頁 UI 已啟用時,是否為 Spark 應用程式執行結構化串流網頁 UI。

3.0.0
spark.sql.streaming.ui.retainedProgressUpdates 100

為結構化串流 UI 保留串流查詢的進度更新數量。

3.0.0
spark.sql.streaming.ui.retainedQueries 100

為結構化串流 UI 保留非活動查詢的數量。

3.0.0
spark.sql.ui.retainedExecutions 1000

在 Spark UI 中保留的執行次數。

1.5.0
spark.sql.warehouse.dir $PWD/spark-warehouse 的值)

受管理資料庫和資料表的預設位置。

2.0.0

Spark Streaming

屬性名稱預設值意義版本
spark.streaming.backpressure.enabled false 啟用或停用 Spark 串流的內部反壓機制(自 1.5 版起)。這讓 Spark 串流能根據目前的批次排程延遲和處理時間來控制接收速率,讓系統僅以系統能處理的速度接收資料。在內部,這會動態設定接收器的最大接收速率。如果已設定(請見下方),此速率會受到 spark.streaming.receiver.maxRatespark.streaming.kafka.maxRatePerPartition 值的上限限制。 1.5.0
spark.streaming.backpressure.initialRate 未設定 當反壓機制已啟用時,每個接收器在第一個批次接收資料的初始最大接收速率。 2.0.0
spark.streaming.blockInterval 200 毫秒 Spark 串流接收器接收的資料在儲存在 Spark 中之前,會依資料區塊分段的間隔。建議的最小值為 50 毫秒。請參閱 Spark 串流程式設計指南中的效能調整區段,以取得更多詳細資料。 0.8.0
spark.streaming.receiver.maxRate 未設定 每個接收器接收資料的最大速率(每秒記錄數)。實際上,每個串流每秒最多會使用這個數量的記錄。將這個設定設為 0 或負數表示對速率沒有限制。請參閱 Spark 串流程式設計指南中的部署指南以取得模式詳細資料。 1.0.2
spark.streaming.receiver.writeAheadLog.enable false 為接收器啟用寫入前記錄。透過接收器接收的所有輸入資料都將儲存到寫入前記錄,讓資料在驅動程式發生故障後可以復原。請參閱 Spark 串流程式設計指南中的部署指南以取得更多詳細資料。 1.2.1
spark.streaming.unpersist true 強制 Spark 串流產生並持續存在的 RDD 自動從 Spark 的記憶體中取消持續存在。Spark 串流接收到的原始輸入資料也會自動清除。將此設定設為 false 會讓原始資料和持續存在的 RDD 可以從串流應用程式外部存取,因為它們不會自動清除。但這會讓 Spark 使用更多記憶體。 0.9.0
spark.streaming.stopGracefullyOnShutdown false 如果為 true,Spark 會在 JVM 關閉時優雅地關閉 StreamingContext,而不是立即關閉。 1.4.0
spark.streaming.kafka.maxRatePerPartition 未設定 使用新的 Kafka 直接串流 API 時,從每個 Kafka 分割區讀取資料的最大速率(每秒記錄數)。請參閱Kafka 整合指南以取得更多詳細資料。 1.3.0
spark.streaming.kafka.minRatePerPartition 1 使用新的 Kafka 直接串流 API 時,從每個 Kafka 分割區讀取資料的最小速率(每秒記錄數)。 2.4.0
spark.streaming.ui.retainedBatches 1000 Spark 串流 UI 和狀態 API 在進行垃圾回收之前會記住多少批次。 1.0.0
spark.streaming.driver.writeAheadLog.closeFileAfterWrite false 在驅動程式上寫入寫入前記錄後是否要關閉檔案。當您要對驅動程式上的資料 WAL 使用 S3(或任何不支援快取的檔案系統)時,請將此設定設為「true」。 1.6.0
spark.streaming.receiver.writeAheadLog.closeFileAfterWrite false 在接收器上寫入寫入前記錄後是否要關閉檔案。當您要對接收器上的資料 WAL 使用 S3(或任何不支援快取的檔案系統)時,請將此設定設為「true」。 1.6.0

SparkR

屬性名稱預設值意義版本
spark.r.numRBackendThreads 2 RBackend 使用的執行緒數目,用於處理來自 SparkR 套件的 RPC 呼叫。 1.4.0
spark.r.command Rscript 在叢集模式中,驅動程式和工作站執行 R 腳本的可執行檔。 1.5.3
spark.r.driver.command spark.r.command 在用戶端模式中,驅動程式執行 R 腳本的可執行檔。在叢集模式中會忽略。 1.5.3
spark.r.shell.command R 用於在驅動程式的用戶端模式中執行 sparkR shell 的可執行檔。在叢集模式中會被忽略。它與環境變數 SPARKR_DRIVER_R 相同,但優先權高於後者。spark.r.shell.command 用於 sparkR shell,而 spark.r.driver.command 用於執行 R 腳本。 2.1.0
spark.r.backendConnectionTimeout 6000 R 程序在其與 RBackend 的連線中設定的連線逾時時間(以秒為單位)。 2.1.0
spark.r.heartBeatInterval 100 SparkR 後端傳送至 R 程序的心跳間隔,用於防止連線逾時。 2.1.0

GraphX

屬性名稱預設值意義版本
spark.graphx.pregel.checkpointInterval -1 Pregel 中圖形和訊息的檢查點間隔。它用於避免在大量反覆運算後,因長譜系鏈而產生的 stackOverflowError。預設情況下,檢查點已停用。 2.2.0

部署

屬性名稱預設值意義版本
spark.deploy.recoveryMode NONE 當 Spark 提交的工作在叢集模式下失敗並重新啟動時,用於復原的復原模式設定。這僅適用於使用 Standalone 或 Mesos 執行的叢集模式。 0.8.1
spark.deploy.zookeeper.url 當 `spark.deploy.recoveryMode` 設為 ZOOKEEPER 時,此組態用於設定要連線的 zookeeper URL。 0.8.1
spark.deploy.zookeeper.dir 當 `spark.deploy.recoveryMode` 設為 ZOOKEEPER 時,此組態用於設定用於儲存復原狀態的 zookeeper 目錄。 0.8.1

叢集管理員

Spark 中的每個叢集管理員都有額外的組態選項。組態可以在每個模式的頁面上找到

YARN

Mesos

Kubernetes

獨立模式

環境變數

某些 Spark 設定可以透過環境變數來組態,這些變數會從 Spark 安裝目錄中的 conf/spark-env.sh 腳本讀取(或在 Windows 上的 conf/spark-env.cmd)。在 Standalone 和 Mesos 模式中,此檔案可以提供特定於機器資訊,例如主機名稱。在執行本機 Spark 應用程式或提交腳本時,也會引用此檔案。

請注意,在安裝 Spark 時,預設情況下不存在 conf/spark-env.sh。不過,您可以複製 conf/spark-env.sh.template 來建立它。請務必讓複製的檔案具有可執行權限。

以下變數可以在 spark-env.sh 中設定

環境變數意義
JAVA_HOME Java 安裝位置(如果不在預設的 PATH 中)。
PYSPARK_PYTHON 在驅動程式和工作人員中用於 PySpark 的 Python 二進制執行檔(如果可用,預設為 python3,否則為 python)。如果設定了屬性 spark.pyspark.python,則優先使用該屬性。
PYSPARK_DRIVER_PYTHON 僅在驅動程式中用於 PySpark 的 Python 二進制執行檔(預設為 PYSPARK_PYTHON)。如果設定了屬性 spark.pyspark.driver.python,則優先使用該屬性。
SPARKR_DRIVER_R 用於 SparkR shell 的 R 二進制執行檔(預設為 R)。如果設定了屬性 spark.r.shell.command,則優先使用該屬性。
SPARK_LOCAL_IP 要繫結到的機器 IP 位址。
SPARK_PUBLIC_DNS Spark 程式會對其他機器宣告的主機名稱。

除了上述內容之外,還有一些選項可供設定 Spark 獨立叢集腳本,例如每個機器上要使用的核心數和最大記憶體。

由於 spark-env.sh 是 shell 腳本,因此其中一些設定可以在程式中進行,例如,您可以透過查詢特定網路介面的 IP 來計算 SPARK_LOCAL_IP

注意:在 cluster 模式下於 YARN 上執行 Spark 時,環境變數需要使用 conf/spark-defaults.conf 檔案中的 spark.yarn.appMasterEnv.[EnvironmentVariableName] 屬性來設定。在 spark-env.sh 中設定的環境變數不會反映在 cluster 模式下的 YARN 應用程式主控程式處理程序中。請參閱 與 YARN 相關的 Spark 屬性 以取得更多資訊。

組態記錄

Spark 使用 log4j 進行記錄。您可以透過在 conf 目錄中新增 log4j2.properties 檔案來設定它。開始的方法之一是複製位於該處的現有 log4j2.properties.template

預設情況下,Spark 會將 1 筆記錄新增至 MDC(對應式診斷內容):mdc.taskName,它會顯示類似 task 1.0 in stage 0.0 的內容。您可以將 %X{mdc.taskName} 新增至 patternLayout,以便在記錄中列印它。此外,您可以使用 spark.sparkContext.setLocalProperty(s"mdc.$name", "value") 將使用者特定資料新增至 MDC。MDC 中的鍵會是 “mdc.$name” 的字串。

覆寫組態目錄

若要指定預設的 “SPARK_HOME/conf” 以外的不同設定目錄,您可以設定 SPARK_CONF_DIR。Spark 會使用此目錄中的設定檔(spark-defaults.conf、spark-env.sh、log4j2.properties 等)。

繼承 Hadoop 叢集組態

如果您計畫使用 Spark 讀取和寫入 HDFS,則應在 Spark 的 classpath 中包含兩個 Hadoop 設定檔

這些設定檔的位置會隨著 Hadoop 版本而有所不同,但常見的位置是在 /etc/hadoop/conf 內。有些工具會動態建立設定檔,但會提供下載副本的機制。

若要讓 Spark 能看到這些檔案,請在 $SPARK_HOME/conf/spark-env.sh 中將 HADOOP_CONF_DIR 設定為包含設定檔的位置。

自訂 Hadoop/Hive 組態

如果您的 Spark 應用程式與 Hadoop、Hive 或兩者互動,Spark 的類別路徑中可能會有 Hadoop/Hive 設定檔。

多個正在執行的應用程式可能需要不同的 Hadoop/Hive 客户端設定。您可以複製並修改 Spark 類別路徑中的 hdfs-site.xmlcore-site.xmlyarn-site.xmlhive-site.xml 以供每個應用程式使用。在 YARN 上執行的 Spark 集群中,這些設定檔會在整個集群中設定,應用程式無法安全地變更這些設定檔。

更好的選擇是使用 spark.hadoop.* 形式的 Spark Hadoop 屬性,以及使用 spark.hive.* 形式的 Spark Hive 屬性。例如,新增設定「spark.hadoop.abc.def=xyz」表示新增 Hadoop 屬性「abc.def=xyz」,而新增設定「spark.hive.abc=xyz」表示新增 Hive 屬性「hive.abc=xyz」。它們可以視為與可以在 $SPARK_HOME/conf/spark-defaults.conf 中設定的正常 Spark 屬性相同

在某些情況下,您可能想要避免在 SparkConf 中寫入某些設定的硬式編碼。例如,Spark 允許您簡單地建立一個空的 conf 並設定 spark/spark Hadoop/spark Hive 屬性。

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 \
  --conf spark.hive.abc=xyz
  myApp.jar

自訂資源排程和組態概觀

GPU 和其他加速器已廣泛用於加速特殊工作負載,例如深度學習和訊號處理。Spark 現在支援要求和排程一般資源,例如 GPU,但有一些注意事項。目前的實作要求資源具有可由排程器配置的位址。它要求您的集群管理員支援並正確設定資源。

有設定可供要求驅動程式資源:spark.driver.resource.{resourceName}.amount,要求執行器資源:spark.executor.resource.{resourceName}.amount,並指定每個任務的要求:spark.task.resource.{resourceName}.amount。在 YARN、Kubernetes 和 Spark 獨立執行中的客户端驅動程式上需要 spark.driver.resource.{resourceName}.discoveryScript 設定。YARN 和 Kubernetes 需要 spark.executor.resource.{resourceName}.discoveryScript 設定。Kubernetes 也需要 spark.driver.resource.{resourceName}.vendor 和/或 spark.executor.resource.{resourceName}.vendor。請參閱上述設定說明以取得每個設定的更多資訊。

Spark 會使用指定的組態,先從叢集管理員請求具有相應資源的容器。取得容器後,Spark 會在該容器中啟動 Executor,它會找出容器有哪些資源,以及與每個資源相關聯的位址。Executor 會向 Driver 註冊,並回報該 Executor 可用的資源。然後,Spark 排程器可以將工作排程到每個 Executor,並根據使用者指定的資源需求,指派特定的資源位址。使用者可以使用 TaskContext.get().resources api 查看指派給工作的資源。在 Driver 上,使用者可以使用 SparkContext resources 呼叫查看指派資源。然後,使用者可以自行使用指派的位址執行他們想要的處理,或將這些位址傳遞到他們使用的 ML/AI 架構中。

請參閱您的叢集管理員特定頁面,以取得每個頁面的需求和詳細資訊 - YARNKubernetes獨立模式。目前不適用於 Mesos 或本機模式。請注意,具有多個工作節點的本機叢集模式不受支援(請參閱獨立文件)。

階段層級排程概觀

階段層級排程功能允許使用者在階段層級中指定工作和執行器資源需求。這允許不同的階段使用具有不同資源的執行器來執行。一個主要的範例是,一個 ETL 階段使用僅有 CPU 的執行器執行,下一個階段是一個需要 GPU 的 ML 階段。階段層級排程允許使用者在 ML 階段執行時要求具有 GPU 的不同執行器,而不是在應用程式開始時取得具有 GPU 的執行器,然後在 ETL 階段執行時讓它們閒置。這僅適用於 Scala、Java 和 Python 中的 RDD API。當啟用動態分配時,它可用於 YARN、Kubernetes 和 Standalone。當停用動態分配時,它允許使用者在階段層級中指定不同的工作資源需求,並且目前在 YARN、Kubernetes 和 Standalone 集群中支援此功能。請參閱 YARN 頁面或 Kubernetes 頁面或 Standalone 頁面以取得更多實作詳細資料。

請參閱 RDD.withResourcesResourceProfileBuilder API 以使用此功能。當停用動態分配時,具有不同工作資源需求的工作會與 DEFAULT_RESOURCE_PROFILE 共享執行器。當啟用動態分配時,目前的實作會為每個建立的 ResourceProfile 取得新的執行器,而且目前必須完全相符。Spark 不會嘗試將工作放入使用與執行器建立時不同的 ResourceProfile 的執行器中。未使用的執行器會在動態分配邏輯中閒置逾時。此功能的預設設定僅允許每個階段一個 ResourceProfile。如果使用者將超過 1 個 ResourceProfile 關聯到 RDD,Spark 會預設擲回例外。請參閱設定 spark.scheduler.resource.profileMergeConflicts 以控制該行為。當啟用 spark.scheduler.resource.profileMergeConflicts 時,Spark 實作的目前合併策略是衝突 ResourceProfile 中每個資源的簡單最大值。Spark 會建立一個具有每個資源最大值的 ResourceProfile。

推播式洗牌概觀

推播式洗牌有助於提升 Spark 洗牌的可靠性和效能。它採取盡力而為的方式,將映射工作產生的洗牌區塊推送到遠端外部洗牌服務,以每個洗牌分割進行合併。縮減工作會擷取合併洗牌分割和原始洗牌區塊的組合作為其輸入資料,導致將外部洗牌服務的小型隨機磁碟讀取轉換成大型順序讀取。縮減工作資料位置更好的可能性進一步有助於將網路 IO 降至最低。在某些情況下,推播式洗牌會優先於批次擷取,例如當合併輸出可用時進行分割合併。

推播式混洗可改善執行長時間工作/查詢的效能,這些工作/查詢在混洗期間涉及大量的磁碟 I/O。目前它不太適合快速執行且處理較少混洗資料的工作/查詢。這將在未來的版本中進一步改善。

目前推播式混洗僅支援搭配外部混洗服務的 YARN 上的 Spark。

外部洗牌服務 (伺服器) 端組態選項

屬性名稱預設值意義版本
spark.shuffle.push.server.mergedShuffleFileManagerImpl org.apache.spark.network.shuffle.
NoOpMergedShuffleFileManager
管理推播式混洗的 MergedShuffleFileManager 實作類別名稱。這會作為伺服器端設定,以停用或啟用推播式混洗。預設情況下,推播式混洗在伺服器端已停用。

若要在伺服器端啟用推播式混洗,請將此設定設為 org.apache.spark.network.shuffle.RemoteBlockPushResolver

3.2.0
spark.shuffle.push.server.minChunkSizeInMergedShuffleFile 2m

在推播式混洗期間將合併的混洗檔案分割成多個區塊時,區塊的最小大小。合併的混洗檔案包含多個小型混洗區塊。在單一磁碟 I/O 中擷取完整的合併混洗檔案會增加用戶端和外部混洗服務的記憶體需求。相反地,外部混洗服務會以「MB 大小的區塊」提供合併的檔案。
此設定控制區塊可以變多大的程度。將為每個合併的混洗檔案產生一個對應的索引檔案,以指出區塊邊界。

將此設定設得太高會增加用戶端和外部混洗服務的記憶體需求。

將此設定設得太低會不必要地增加對外部混洗服務的 RPC 要求總數。

3.2.0
spark.shuffle.push.server.mergedIndexCacheSize 100 公尺 在推播式混洗中用於儲存合併索引檔案的記憶體中快取的最大大小。此快取是除了透過 spark.shuffle.service.index.cache.size 設定的快取之外的快取。 3.2.0

用戶端組態選項

屬性名稱預設值意義版本
spark.shuffle.push.enabled false 設為 true 以在用戶端啟用推播式混洗,並與伺服器端旗標 spark.shuffle.push.server.mergedShuffleFileManagerImpl 搭配使用。 3.2.0
spark.shuffle.push.finalize.timeout 10 秒 在所有對應器完成特定混洗對應器階段後,驅動程式等待的秒數,然後才將合併完成要求傳送至遠端外部混洗服務。這會給予外部混洗服務額外的時間來合併區塊。將此設定設得太長可能會導致效能下降。 3.2.0
spark.shuffle.push.maxRetainedMergerLocations 500 快取用於基於推播的洗牌的最大合併位置數目。目前,合併位置是負責處理推播區塊、合併區塊和提供合併區塊以供後續洗牌擷取的外部洗牌服務的主機。 3.2.0
spark.shuffle.push.mergersMinThresholdRatio 0.05 用於計算基於縮減階段的分區數目,一個階段所需的最小洗牌合併位置數目的比率。例如,一個具有 100 個分區且使用預設值 0.05 的縮減階段,需要至少 5 個唯一的合併位置才能啟用基於推播的洗牌。 3.2.0
spark.shuffle.push.mergersMinStaticThreshold 5 為了啟用一個階段的基於推播的洗牌,應該有可用的洗牌推播合併位置數目的靜態閾值。請注意,此設定會與 spark.shuffle.push.mergersMinThresholdRatio 搭配運作。spark.shuffle.push.mergersMinStaticThresholdspark.shuffle.push.mergersMinThresholdRatio 的最大值比率,是啟用一個階段的基於推播的洗牌所需的合併數目。例如:對於具有 1000 個分區的子階段,其中 spark.shuffle.push.mergersMinStaticThreshold 為 5,而 spark.shuffle.push.mergersMinThresholdRatio 設定為 0.05,我們需要至少 50 個合併才能為該階段啟用基於推播的洗牌。 3.2.0
spark.shuffle.push.numPushThreads (無) 指定區塊推播器池中的執行緒數目。這些執行緒會協助建立連線,並將區塊推播到遠端的外部洗牌服務。預設情況下,執行緒池大小等於 Spark 執行器核心數目。 3.2.0
spark.shuffle.push.maxBlockSizeToPush 1m

要推播到遠端外部洗牌服務的個別區塊的最大大小。大於此閾值的區塊不會被推播以進行遠端合併。這些洗牌區塊會以原始方式擷取。

將此設定設得太高會導致更多區塊被推播到遠端外部洗牌服務,但這些區塊已經透過現有機制有效地擷取,導致將大型區塊推播到遠端外部洗牌服務的額外負擔。建議將 spark.shuffle.push.maxBlockSizeToPush 設定為小於 spark.shuffle.push.maxBlockBatchSize 設定的值。

將此設定設得太低會導致較少的區塊被合併,並直接從對應程式外部洗牌服務擷取,導致較高的隨機小讀取影響整體磁碟 I/O 效能。

3.2.0
spark.shuffle.push.maxBlockBatchSize 3m 要分組到單一推播要求的洗牌區塊批次的最大大小。預設設定為 3m,以使其略高於預設為 2mspark.storage.memoryMapThreshold,因為每批區塊很可能會被記憶體對應,這會產生較高的負擔。 3.2.0
spark.shuffle.push.merge.finalizeThreads 8 驅動程式用於完成洗牌合併的執行緒數目。由於大型洗牌可能需要數秒才能完成,因此在啟用基於推播的洗牌時,擁有多個執行緒有助於驅動程式處理並行的洗牌合併完成要求。 3.3.0
spark.shuffle.push.minShuffleSizeToWait 500m 只有當總的 shuffle 資料大小超過此閾值時,驅動程式才會等待合併完成。如果總的 shuffle 大小小於此閾值,驅動程式會立即完成 shuffle 輸出。 3.3.0
spark.shuffle.push.minCompletedPushRatio 1.0 在基於 push 的 shuffle 期間,驅動程式開始 shuffle 合併完成之前,應完成的最小映射分區比例。 3.3.0