spark-1.6.0 原文地址html
Spark配置
Spark有如下三種方式修改配置：java
- Spark properties （Spark屬性）能夠控制絕大多數應用程序參數，並且既能夠經過 SparkConf 對象來設置，也能夠經過Java系統屬性來設置。
- Environment variables （環境變量）能夠指定一些各個機器相關的設置，如IP地址，其設置方法是寫在每臺機器上的conf/spark-env.sh中。
- Logging （日誌）能夠經過log4j.properties配置日誌。
Spark屬性
Spark屬性能夠控制大多數的應用程序設置，而且每一個應用的設定都是分開的。這些屬性能夠用SparkConf 對象直接設定。SparkConf爲一些經常使用的屬性定製了專用方法（如，master URL和application name），其餘屬性均可以用鍵值對作參數，調用set()方法來設置。例如，咱們能夠初始化一個包含2個本地線程的Spark應用，代碼以下：node
注意，local[2]表明2個本地線程 – 這是最小的併發方式，能夠幫助咱們發現一些只有在分佈式上下文才能復現的bug。python
val conf = new SparkConf()
.setMaster("local[2]")
.setAppName("CountingSheep")
val sc = new SparkContext(conf)
注意，本地模式下，咱們可使用n個線程（n >= 1）。並且在像Spark Streaming這樣的場景下，咱們可能須要多個線程來防止相似線程餓死這樣的問題。mysql
配置時間段的屬性應該寫明時間單位，以下格式都是可接受的：web
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)
動態加載Spark屬性
在某些場景下，你可能須要避免將屬性值寫死在 SparkConf 中。例如，你可能但願在同一個應用上使用不一樣的master或不一樣的內存總量。Spark容許你簡單地建立一個空的SparkConf對象：sql
val sc = new SparkContext(new SparkConf())
而後在運行時設置這些屬性：shell
./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（設置master URL）。spark-submit能夠在啓動Spark應用時，經過–conf標誌接受任何屬性配置，同時有一些特殊配置參數一樣可用（如，–master）。運行./bin/spark-submit –help能夠展現這些選項的完整列表。apache
同時，bin/spark-submit 也支持從conf/spark-defaults.conf 中讀取配置選項，在該文件中每行是一個鍵值對，並用空格分隔，以下：
spark.master spark://5.6.7.8:7077 spark.executor.memory 4g spark.eventLog.enabled true spark.serializer org.apache.spark.serializer.KryoSerializer
這些經過參數或者屬性配置文件傳遞的屬性，最終都會在SparkConf 中合併。其優先級是：首先是SparkConf代碼中寫的屬性值，其次是spark-submit或spark-shell的標誌參數，最後是spark-defaults.conf文件中的屬性。
有一些配置項被重命名過，這種情形下，老的名字仍然是能夠接受的，只是優先級比新名字優先級低。
查看Spark屬性
每一個SparkContext都有其對應的Spark UI，因此Spark應用程序都能經過Spark UI查看其屬性。默認你能夠在這裏看到：http://<driver>:4040，頁面上的」Environment「 tab頁能夠查看Spark屬性。若是你真的想確認一下屬性設置是否正確的話，這個功能就很是有用了。注意，只有顯式地經過SparkConf對象、在命令行參數、或者spark-defaults.conf設置的參數纔會出如今頁面上。其餘屬性，你能夠認爲都是默認值。
可用的屬性
絕大多數屬性都有合理的默認值。這裏是部分經常使用的選項：
應用屬性
| 屬性名稱 | 默認值 | 含義 |
|---|---|---|
spark.app.name |
(none) | Spark應用的名字。會在SparkUI和日誌中出現。 |
spark.driver.cores |
1 | 在cluster模式下，用幾個core運行驅動器（driver）進程。 |
spark.driver.maxResultSize |
1g | Spark action算子返回的結果最大多大。至少要1M，能夠設爲0表示無限制。若是結果超過這一大小，Spark做業（job）會直接中斷退出。可是，設得太高有可能致使驅動器OOM（out-of-memory）（取決於spark.driver.memory設置，以及驅動器JVM的內存限制）。設一個合理的值，以免驅動器OOM。 |
spark.driver.memory |
1g | 驅動器進程能夠用的內存總量（如：1g，2g）。 注意，在客戶端模式下，這個配置不能在SparkConf中直接設置（由於驅動器JVM都啓動完了呀！）。驅動器客戶端模式下，必需要在命令行裏用 –driver-memory 或者在默認屬性配置文件裏設置。 |
spark.executor.memory |
1g | 單個執行器（executor）使用的內存總量（如，2g，8g） |
spark.extraListeners |
(none) | 逗號分隔的SparkListener子類的類名列表；初始化SparkContext時，這些類的實例會被建立出來，而且註冊到Spark的監聽總線上。若是這些類有一個接受SparkConf做爲惟一參數的構造函數，那麼這個構造函數會被優先調用；不然，就調用無參數的默認構造函數。若是沒有構造函數，SparkContext建立的時候會拋異常。 |
spark.local.dir |
/tmp | Spark的」草稿「目錄，包括map輸出的臨時文件，或者RDD存在磁盤上的數據。這個目錄最好在本地文件系統中，這樣讀寫速度快。這個配置能夠接受一個逗號分隔的列表，一般用這種方式將文件IO分散不一樣的磁盤上去。 注意：Spark-1.0及之後版本中，這個屬性會被集羣管理器所提供的環境變量覆蓋：SPARK_LOCAL_DIRS（獨立部署或Mesos）或者 LOCAL_DIRS（YARN）。 |
spark.logConf |
false | SparkContext啓動時是否把生效的 SparkConf 屬性以INFO日誌打印到日誌裏 |
spark.master |
(none) | 集羣管理器URL。參考allowed master URL’s. |
除了這些之外，如下還有不少可用的參數配置，在某些特定情形下，可能會用到：
運行時環境
| 屬性名 | 默認值 | 含義 |
|---|---|---|
spark.driver.extraClassPath |
(none) | 額外的classpath，將插入到到驅動器的classpath開頭。 注意：驅動器若是運行客戶端模式下，這個配置不能經過SparkConf 在程序裏配置，由於這時候程序已經啓動呀！而是應該用命令行參數（–driver-class-path）或者在 conf/spark-defaults.conf 配置。 |
spark.driver.extraJavaOptions |
(none) | 驅動器額外的JVM選項。如：GC設置或其餘日誌參數。 注意：驅動器若是運行客戶端模式下，這個配置不能經過SparkConf在程序裏配置，由於這時候程序已經啓動呀！而是應該用命令行參數（–driver-java-options）或者conf/spark-defaults.conf 配置。 |
spark.driver.extraLibraryPath |
(none) | 啓動驅動器JVM時候指定的依賴庫路徑。 注意：驅動器若是運行客戶端模式下，這個配置不能經過SparkConf在程序裏配置，由於這時候程序已經啓動呀！而是應該用命令行參數（–driver-library-path）或者conf/spark-defaults.conf 配置。 |
spark.driver.userClassPathFirst |
false | (試驗性的：即將來不必定會支持該配置) 驅動器是否首選使用用戶指定的jars，而不是spark自身的。這個特性能夠用來處理用戶依賴和spark自己依賴項之間的衝突。目前仍是試驗性的，而且只能用在集羣模式下。 |
spark.executor.extraClassPath |
(none) | 添加到執行器（executor）classpath開頭的classpath。主要爲了向後兼容老的spark版本，不推薦使用。 |
spark.executor.extraJavaOptions |
(none) | 傳給執行器的額外JVM參數。如：GC設置或其餘日誌設置等。注意，不能用這個來設置Spark屬性或者堆內存大小。Spark屬性應該用SparkConf對象，或者spark-defaults.conf文件（會在spark-submit腳本中使用）來配置。執行器堆內存大小應該用 spark.executor.memory配置。 |
spark.executor.extraLibraryPath |
(none) | 啓動執行器JVM時使用的額外依賴庫路徑。 |
spark.executor.logs.rolling.maxRetainedFiles |
(none) | Sets the number of latest rolling log files that are going to be retained by the system. Older log files will be deleted. Disabled by default.設置日誌文件最大保留個數。老日誌文件將被幹掉。默認禁用的。 |
spark.executor.logs.rolling.maxSize |
(none) | 設置執行器日誌文件大小上限。默認禁用的。 須要自動刪日誌請參考 spark.executor.logs.rolling.maxRetainedFiles. |
spark.executor.logs.rolling.strategy |
(none) | 執行器日誌滾動策略。默認禁用。 可接受的值有」time」（基於時間滾動） 或者 「size」（基於文件大小滾動）。 time：將使用 spark.executor.logs.rolling.time.interval設置滾動時間間隔 size：將使用 spark.executor.logs.rolling.size.maxBytes設置文件大小上限 |
spark.executor.logs.rolling.time.interval |
daily | 設置執行器日誌滾動時間間隔。日誌滾動默認是禁用的。 可用的值有 「daily」, 「hourly」, 「minutely」，也可設爲數字（則單位爲秒）。 關於日誌自動清理，請參考 spark.executor.logs.rolling.maxRetainedFiles |
spark.executor.userClassPathFirst |
false | （試驗性的）與 spark.driver.userClassPathFirst相似，只不過這個參數將應用於執行器 |
spark.executorEnv.[EnvironmentVariableName] |
(none) | 向執行器進程增長名爲EnvironmentVariableName的環境變量。用戶能夠指定多個來設置不一樣的環境變量。 |
spark.python.profile |
false | 對Python worker啓用性能分析，性能分析結果會在sc.show_profile()中，或者在驅動器退出前展現。也能夠用sc.dump_profiles(path)輸出到磁盤上。若是部分分析結果被手動展現過，那麼驅動器退出前就再也不自動展現了。默認會使用pyspark.profiler.BasicProfiler，也能夠本身傳一個profiler 類參數給SparkContext構造函數。 |
spark.python.profile.dump |
(none) | 這個目錄是用來在驅動器退出前，dump性能分析結果。性能分析結果會按RDD分別dump。同時可使用ptats.Stats()來裝載。若是制定了這個，那麼分析結果就再也不自動展現。 |
spark.python.worker.memory |
512m | 聚合時每一個python worker使用的內存總量，和JVM的內存字符串格式相同（如，512m，2g）。若是聚合時使用的內存超過這個量，就將數據溢出到磁盤上。 |
spark.python.worker.reuse |
true | 是否複用Python worker。若是是，則每一個任務會啓動固定數量的Python worker，而且不須要fork() python進程。若是須要廣播的數據量很大，設爲true能大大減小廣播數據量，由於須要廣播的進程數減小了。 |
混洗行爲
| 屬性名 | 默認值 | 含義 |
|---|---|---|
spark.reducer.maxSizeInFlight |
48m | map任務輸出同時reduce任務獲取的最大內存佔用量。每一個輸出須要建立buffer來接收，對於每一個reduce任務來講，有一個固定的內存開銷上限，因此最好別設太大，除非你內存很是大。 |
spark.shuffle.compress |
true | 是否壓縮map任務的輸出文件。一般來講，壓縮是個好主意。使用的壓縮算法取決於 spark.io.compression.codec |
spark.shuffle.file.buffer |
32k | 每一個混洗輸出流的內存buffer大小。這個buffer能減小混洗文件的建立和磁盤尋址。 |
spark.shuffle.io.maxRetries |
3 | （僅對netty）若是IO相關異常發生，重試次數（若是設爲非0的話）。重試能是大量數據的混洗操做更加穩定，由於重試能夠有效應對長GC暫停或者網絡閃斷。 |
spark.shuffle.io.numConnectionsPerPeer |
1 | （僅netty）主機之間的鏈接是複用的，這樣能夠減小大集羣中重複創建鏈接的次數。然而，有些集羣是機器少，磁盤多，這種集羣能夠考慮增長這個參數值，以便充分利用全部磁盤併發性能。 |
spark.shuffle.io.preferDirectBufs |
true | （僅netty）堆外緩存能夠有效減小垃圾回收和緩存複製。對於堆外內存緊張的用戶來講，能夠考慮禁用這個選項，以迫使netty全部內存都分配在堆上。 |
spark.shuffle.io.retryWait |
5s | （僅netty）混洗重試獲取數據的間隔時間。默認最大重試延遲是15秒，設置這個參數後，將變成maxRetries* retryWait。 |
spark.shuffle.manager |
sort | 混洗數據的實現方式。可用的有」sort」和」hash「。基於排序（sort）的混洗內存利用率更高，而且從1.2開始已是默認值了。 |
spark.shuffle.service.enabled |
false | 啓用外部混洗服務。啓用外部混洗服務後，執行器生成的混洗中間文件就由該服務保留，這樣執行器就能夠安全的退出了。若是 spark.dynamicAllocation.enabled啓用了，那麼這個參數也必須啓用，這樣動態分配纔能有外部混洗服務可用。 更多請參考：dynamic allocation configuration and setup documentation |
spark.shuffle.service.port |
7337 | 外部混洗服務對應端口 |
spark.shuffle.sort.bypassMergeThreshold |
200 | （高級）在基於排序（sort）的混洗管理器中，若是沒有map端聚合的話，就會最多存在這麼多個reduce分區。 |
spark.shuffle.spill.compress |
true | 是否在混洗階段壓縮溢出到磁盤的數據。壓縮算法取決於spark.io.compression.codec |
Spark UI
| 屬性名 | 默認值 | 含義 |
|---|---|---|
spark.eventLog.compress |
false | 是否壓縮事件日誌（固然spark.eventLog.enabled必須開啓） |
spark.eventLog.dir |
file:///tmp/spark-events | Spark events日誌的基礎目錄（固然spark.eventLog.enabled必須開啓）。在這個目錄中，spark會給每一個應用建立一個單獨的子目錄，而後把應用的events log打到子目錄裏。用戶能夠設置一個統一的位置（好比一個HDFS目錄），這樣history server就能夠從這裏讀取歷史文件。 |
spark.eventLog.enabled |
false | 是否啓用Spark事件日誌。若是Spark應用結束後，仍須要在SparkUI上查看其狀態，必須啓用這個。 |
spark.ui.killEnabled |
true | 容許從SparkUI上殺掉stage以及對應的做業（job） |
spark.ui.port |
4040 | SparkUI端口，展現應用程序運行狀態。 |
spark.ui.retainedJobs |
1000 | SparkUI和status API最多保留多少個spark做業的數據（固然是在垃圾回收以前） |
spark.ui.retainedStages |
1000 | SparkUI和status API最多保留多少個spark步驟（stage）的數據（固然是在垃圾回收以前） |
spark.worker.ui.retainedExecutors |
1000 | SparkUI和status API最多保留多少個已結束的執行器（executor）的數據（固然是在垃圾回收以前） |
spark.worker.ui.retainedDrivers |
1000 | SparkUI和status API最多保留多少個已結束的驅動器（driver）的數據（固然是在垃圾回收以前） |
spark.sql.ui.retainedExecutions |
1000 | SparkUI和status API最多保留多少個已結束的執行計劃（execution）的數據（固然是在垃圾回收以前） |
spark.streaming.ui.retainedBatches |
1000 | SparkUI和status API最多保留多少個已結束的批量（batch）的數據（固然是在垃圾回收以前） |
壓縮和序列化
| 屬性名 | 默認值 | 含義 |
|---|---|---|
spark.broadcast.compress |
true | 是否在廣播變量前使用壓縮。一般是個好主意。 |
spark.closure.serializer |
org.apache.spark.serializer. JavaSerializer |
閉包所使用的序列化類。目前只支持Java序列化。 |
spark.io.compression.codec |
snappy | 內部數據使用的壓縮算法，如：RDD分區、廣播變量、混洗輸出。Spark提供了3中算法：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算法使用的塊大小。固然你須要先使用LZ4壓縮。減小塊大小能夠減小混洗時LZ4算法佔用的內存量。 |
spark.io.compression.snappy.blockSize |
32k | Snappy算法使用的塊大小（先得使用Snappy算法）。減小塊大小能夠減小混洗時Snappy算法佔用的內存量。 |
spark.kryo.classesToRegister |
(none) | 若是你使用Kryo序列化，最好指定這個以提升性能（tuning guide）。 本參數接受一個逗號分隔的類名列表，這些類都會註冊爲Kryo可序列化類型。 |
spark.kryo.referenceTracking |
true (false when using Spark SQL Thrift Server) | 是否跟蹤同一對象在Kryo序列化的引用。若是你的對象圖中有循環護着包含統一對象的多份拷貝，那麼最好啓用這個。若是沒有這種狀況，那就禁用以提升性能。 |
spark.kryo.registrationRequired |
false | Kryo序列化時，是否必須事先註冊。若是設爲true，那麼Kryo遇到沒有註冊過的類型，就會拋異常。若是設爲false（默認）Kryo會序列化未註冊類型的對象，但會有比較明顯的性能影響，因此啓用這個選項，能夠強制必須在序列化前，註冊可序列化類型。 |
spark.kryo.registrator |
(none) | 若是你使用Kryo序列化，用這個class來註冊你的自定義類型。若是你須要自定義註冊方式，這個參數頗有用。不然，使用 spark.kryo.classesRegister更簡單。要設置這個參數，須要用KryoRegistrator的子類。詳見：tuning guide 。 |
spark.kryoserializer.buffer.max |
64m | 最大容許的Kryo序列化buffer。必須必你所須要序列化的對象要大。若是你在Kryo中看到」buffer limit exceeded」這個異常，你就得增長這個值了。 |
spark.kryoserializer.buffer |
64k | Kryo序列化的初始buffer大小。注意，每臺worker上對應每一個core會有一個buffer。buffer最大增加到 spark.kryoserializer.buffer.max |
spark.rdd.compress |
false | 是否壓縮序列化後RDD的分區（如：StorageLevel.MEMORY_ONLY_SER）。能節省大量空間，但多消耗一些CPU。 |
spark.serializer |
org.apache.spark.serializer. JavaSerializer (org.apache.spark.serializer. KryoSerializer when using Spark SQL Thrift Server) |
用於序列化對象的類，序列化後的數據將經過網絡傳輸，或從緩存中反序列化回來。默認的Java序列化使用java的Serializable接口，但速度較慢，因此咱們建議使用usingorg.apache.spark.serializer.KryoSerializer and configuring Kryo serialization若是速度須要保證的話。固然你能夠自定義一個序列化器，經過繼承org.apache.spark.Serializer. |
spark.serializer.objectStreamReset |
100 | 若是使用org.apache.spark.serializer.JavaSerializer作序列化器，序列化器緩存這些對象，以免輸出多餘數據，然而，這個會打斷垃圾回收。經過調用reset來flush序列化器，從而使老對象被回收。要禁用這一週期性reset，須要把這個參數設爲-1，。默認狀況下，序列化器會每過100個對象，被reset一次。 |
內存管理
| 屬性名 | 默認值 | 含義 |
|---|---|---|
spark.memory.fraction |
0.75 | 堆內存中用於執行、混洗和存儲（緩存）的比例。這個值越低，則執行中溢出到磁盤越頻繁，同時緩存被逐出內存也更頻繁。這個配置的目的，是爲了留出用戶自定義數據結構、內部元數據使用的內存。推薦使用默認值。請參考this description. |
spark.memory.storageFraction |
0.5 | 不會被逐出內存的總量，表示一個相對於 spark.memory.fraction的比例。這個越高，那麼執行混洗等操做用的內存就越少，從而溢出磁盤就越頻繁。推薦使用默認值。更詳細請參考 this description. |
spark.memory.offHeap.enabled |
true | 若是true，Spark會嘗試使用堆外內存。啓用 後，spark.memory.offHeap.size必須爲正數。 |
spark.memory.offHeap.size |
0 | 堆外內存分配的大小（絕對值）。這個設置不會影響堆內存的使用，因此你的執行器總內存必須適應JVM的堆內存大小。必需要設爲正數。而且前提是 spark.memory.offHeap.enabled=true. |
spark.memory.useLegacyMode |
false | 是否使用老式的內存管理模式（1.5以及以前）。老模式在堆內存管理上更死板，使用固定劃分的區域作不一樣功能，潛在的會致使過多的數據溢出到磁盤（若是不當心調整性能）。必須啓用本參數，如下選項纔可用：spark.shuffle.memoryFractionspark.storage.memoryFractionspark.storage.unrollFraction |
spark.shuffle.memoryFraction |
0.2 | （廢棄）必須先啓用spark.memory.useLegacyMode這個纔有用。 混洗階段用於聚合和協同分組的JVM堆內存比例。在任何指定的時間，全部用於混洗的內存總和不會超過這個上限，超出的部分會溢出到磁盤上。若是溢出臺頻繁，考慮增長spark.storage.memoryFraction的大小。 |
spark.storage.memoryFraction |
0.6 | （廢棄）必須先啓用spark.memory.useLegacyMode這個纔有用。 Spark用於緩存數據的對內存比例。這個值不該該比JVM 老生代（old generation）對象所佔用的內存大，默認是60%的堆內存，固然你能夠增長這個值，同時配置你所用的老生代對象佔用內存大小。 |
spark.storage.unrollFraction |
0.2 | （廢棄）必須先啓用spark.memory.useLegacyMode這個纔有用。 Spark塊展開的內存佔用比例。若是沒有足夠的內存來完整展開新的塊，那麼老的塊將被拋棄。 |
執行行爲
| 屬性名 | 默認值 | 含義 |
|---|---|---|
spark.broadcast.blockSize |
4m | TorrentBroadcastFactory每一個分片大小。太大會減小廣播時候的併發數（更慢了）；若是過小，BlockManager可能會給出性能提示。 |
spark.broadcast.factory |
org.apache.spark.broadcast. TorrentBroadcastFactory |
廣播算法的實現。 |
spark.cleaner.ttl |
(infinite) | Spark記住任意元數據的保留時間（秒）。週期性的清理能保證比這個更老的元數據將被遺忘（刪除）。這對於長期運行的Spark做業很是有用（如，一些7*24運行）。注意，RDD持久化到內存中後，過了這麼長時間之後，也會被清理掉（這。。。是否是有點坑！）。 |
spark.executor.cores |
YARN模式下默認1；若是是獨立部署，則是worker節點上全部可用的core。 | 單個執行器可用的core數。僅針對YARN和獨立部署模式。獨立部署時，單個worker節點上會運行多個執行器（executor），只要worker上有足夠的core。不然，每一個應用在單個worker上只會啓動一個執行器。 |
spark.default.parallelism |
對於reduceByKey和join這樣的分佈式混洗（shuffle）算子，等於父RDD中最大的分區。對於parallelize這樣沒有父RDD的算子，則取決於集羣管理器：
|
若是用戶沒有在參數裏指定，這個屬性是默認的RDD transformation算子分區數，如：join，reduceByKey，parallelize等。 |
spark.executor.heartbeatInterval |
10s | 執行器心跳間隔（報告心跳給驅動器）。心跳機制使驅動器瞭解哪些執行器還活着，而且能夠從心跳數據中得到執行器的度量數據。 |
spark.files.fetchTimeout |
60s | 獲取文件的通信超時，所獲取的文件是經過在驅動器上調用SparkContext.addFile()添加的。 |
spark.files.useFetchCache |
true | 若是設爲true（默認），則同一個spark應用的不一樣執行器之間，會使用一二共享緩存來拉取文件，這樣能夠提高同一主機上運行多個執行器時候，任務啓動的性能。若是設爲false，這個優化就被禁用，各個執行器將使用本身獨有的緩存，他們拉取的文件也是各自有一份拷貝。若是在NFS文件系統上使用本地文件系統，能夠禁用掉這個優化（參考SPARK-6313） |
spark.files.overwrite |
false | SparkContext.addFile()添加的文件已經存在，且內容不匹配的狀況下，是否覆蓋。 |
spark.hadoop.cloneConf |
false | 如設爲true，對每一個任務複製一份Hadoop Configuration對象。啓用這個能夠繞過Configuration線程安全問題（SPARK-2546 ）。默認這個是禁用的，不少job並不會受這個issue的影響。 |
spark.hadoop.validateOutputSpecs |
true | 如設爲true，在saveAsHadoopFile及其變體的時候，將會驗證輸出（例如，檢查輸出目錄是否存在）。對於已經驗證過或確認存在輸出目錄的狀況，能夠禁用這個。咱們建議不要禁用，除非你肯定須要和以前的spark版本兼容。能夠簡單的利用Hadoop 文件系統API手動刪掉已存在的輸出目錄。這個設置會被Spark Streaming StreamingContext生成的job忽略，由於Streaming須要在回覆檢查點的時候，覆蓋已有的輸出目錄。 |
spark.storage.memoryMapThreshold |
2m | spark從磁盤上讀取一個塊後，映射到內存塊的最小大小。這阻止了spark映射太小的內存塊。一般，內存映射塊是有開銷的，應該比接近或小於操做系統的頁大小。 |
spark.externalBlockStore.blockManager |
org.apache.spark.storage.TachyonBlockManager | 用於存儲RDD的外部塊管理器（文件系統）的實現。 文件系統URL由spark.externalBlockStore.url決定。 |
spark.externalBlockStore.baseDir |
System.getProperty(「java.io.tmpdir」) | 外部塊存儲存放RDD的目錄。文件系統URL由spark.externalBlockStore.url決定。也能夠是逗號分隔的目錄列表（Tachyon文件系統） |
spark.externalBlockStore.url |
tachyon://localhost:19998 for Tachyon | 所使用的外部塊存儲文件系統URL。 |
網絡
| 屬性名 | 默認值 | 含義 |
|---|---|---|
spark.akka.frameSize |
128 | 「control plane」 通信中所容許的最大消息大小（MB）。一般，只應用於map輸出數據的大小信息，這些信息會在執行器和驅動器之間傳遞。若是你的job包含幾千個map和reduce任務，你可能須要增大這個設置。 |
spark.akka.heartbeat.interval |
1000s | 設這麼大的值，是爲了禁用Akka傳輸失敗檢測器。也能夠從新啓用，若是你想用這個特性（但不建議）。設成較大的值能夠減小網絡開銷，而較小的值（1秒左右）可能會對Akka的失敗檢測更有用。若有須要，能夠調整這個值和spark.akka.heartbeat.pauses的組合。一種可能須要使用失敗檢測的情形是：用一個敏感的失敗檢測，能夠快速識別並逐出不穩定的執行器。然而，在真實的spark集羣中，這一般不是GC暫停或網絡延遲形成的。除此以外，啓用這個還會致使過多的心跳數據交換，從而形成網絡洪峯。 |
spark.akka.heartbeat.pauses |
6000s | 設這麼大的值，是爲了禁用Akka傳輸失敗檢測器。也能夠從新啓用，若是你想用這個特性（但不建議）。這個是可接受的Akka心跳暫停時間。這個能夠用來控制對GC暫停敏感程度。若有須要，能夠調整這個值和spark.akka.heartbeat.interval的組合。 |
spark.akka.threads |
4 | 用於通信的actor線程數。若是驅動器機器上有不少CPU core，你能夠適當增大這個值。 |
spark.akka.timeout |
100s | Spark節點之間通信超時。 |
spark.blockManager.port |
(random) | 塊管理器（block manager）監聽端口。在驅動器和執行器上都有。 |
spark.broadcast.port |
(random) | 驅動器HTTP廣播server監聽端口。這和torrent廣播沒有關係。 |
spark.driver.host |
(local hostname) | 驅動器主機名。用於和執行器以及獨立部署時集羣master通信。 |
spark.driver.port |
(random) | 驅動器端口。用於和執行器以及獨立部署時集羣master通信。 |
spark.executor.port |
(random) | 執行器端口。用於和驅動器通信。 |
spark.fileserver.port |
(random) | 驅動器HTTP文件server監聽端口。 |
spark.network.timeout |
120s | 全部網絡交互的默認超時。這個配置是如下屬性的默認值：spark.core.connection.ack.wait.timeout,spark.akka.timeout,spark.storage.blockManagerSlaveTimeoutMs,spark.shuffle.io.connectionTimeout,spark.rpc.askTimeout orspark.rpc.lookupTimeout |
spark.port.maxRetries |
16 | 綁定一個端口的最大重試次數。若是指定了一個端口（非0），每一個後續重試會在以前嘗試的端口基礎上加1，而後再重試綁定。本質上，這肯定了一個綁定端口的範圍，就是 [start port, start port + maxRetries] |
spark.replClassServer.port |
(random) | 驅動器HTTP class server的監聽端口。只和spark shell相關。 |
spark.rpc.numRetries |
3 | RPC任務最大重試次數。RPC任務最多重試這麼屢次。 |
spark.rpc.retry.wait |
3s | RPC請求操做重試前等待時間。 |
spark.rpc.askTimeout |
120s | RPC請求操做超時等待時間。 |
spark.rpc.lookupTimeout |
120s | RPC遠程端點查詢超時。 |
調度
| 屬性名 | 默認值 | 含義 |
|---|---|---|
spark.cores.max |
(not set) | 若是運行在獨立部署集羣模式（standalone deploy cluster）或者Mesos集羣粗粒度共享模式（Mesos cluster in 「coarse-grained」 sharing mode），這個值決定了spark應用可使用的最大CPU總數（應用在整個集羣中可用CPU總數，而不是單個機器）。若是不設置，那麼獨立部署時默認爲spark.deploy.defaultCores，Mesos集羣則默認無限制（即全部可用的CPU）。 |
spark.locality.wait |
3s | 爲了數據本地性最長等待時間（spark會根據數據所在位置，儘可能讓任務也啓動於相同的節點，然而可能由於該節點上資源不足等緣由，沒法知足這個任務分配，spark最多等待這麼多時間，而後放棄數據本地性）。數據本地性有多個級別，每一級別都是等待這麼多時間（同一進程、同一節點、同一機架、任意）。你也能夠爲每一個級別定義不一樣的等待時間，須要設置spark.locality.wait.node等。若是你發現任務數據本地性不佳，能夠增長這個值，但一般默認值是ok的。 |
spark.locality.wait.node |
spark.locality.wait | 單獨定義同一節點數據本地性任務等待時間。你能夠設爲0，表示忽略節點本地性，直接跳到下一級別，即機架本地性（若是你的集羣有機架信息）。 |
spark.locality.wait.process |
spark.locality.wait | 單獨定義同一進程數據本地性任務等待時間。這個參數影響試圖訪問特定執行器上的緩存數據的任務。 |
spark.locality.wait.rack |
spark.locality.wait | 單獨定義同一機架數據本地性等待時間。 |
spark.scheduler.maxRegisteredResourcesWaitingTime |
30s | 調度開始前，向集羣管理器註冊使用資源的最大等待時間。 |
spark.scheduler.minRegisteredResourcesRatio |
0.8 for YARN mode； 0.0 for standalone mode and Mesos coarse-grained mode |
調度啓動前，須要註冊獲得資源的最小比例（註冊到的資源數 / 須要資源總數）（YARN模式下，資源是執行器；獨立部署和Mesos粗粒度模式下時資源是CPU core【spark.cores.max是指望獲得的資源總數】）。能夠設爲0.0~1.0的一個浮點數。無論job是否獲得了最小資源比例，最大等待時間都是由spark.scheduler.maxRegisteredResourcesWaitingTime控制的。 |
spark.scheduler.mode |
FIFO | 提交到同一個SparkContext上job的調度模式（scheduling mode）。另外一個可接受的值是FAIR，而FIFO只是簡單的把job按先來後到排隊。對於多用戶服務頗有用。 |
spark.scheduler.revive.interval |
1s | 調度器復活worker的間隔時間。 |
spark.speculation |
false | 若是設爲true，將會啓動推測執行任務。這意味着，若是stage中有任務執行較慢，他們會被從新調度到別的節點上執行。 |
spark.speculation.interval |
100ms | Spark檢查慢任務的時間間隔。 |
spark.speculation.multiplier |
1.5 | 比任務平均執行時間慢多少倍的任務會被認爲是慢任務。 |
spark.speculation.quantile |
0.75 | 對於一個stage來講，完成多少百分比才開始檢查慢任務，並啓動推測執行任務。 |
spark.task.cpus |
1 | 每一個任務分配的CPU core。 |
spark.task.maxFailures |
4 | 單個任務最大失敗次數。應該>=1。最大重試次數 = spark.task.maxFailures – 1 |
動態分配
| 屬性名 | 默認值 | 含義 |
|---|---|---|
spark.dynamicAllocation.enabled |
false | 是否啓用動態資源分配特性，啓用後，執行器的個數會根據工做負載動態的調整（增長或減小）。注意，目前在YARN模式下不用。更詳細信息，請參考：here該特性依賴於 spark.shuffle.service.enabled 的啓用。同時還和如下配置相關：spark.dynamicAllocation.minExecutors, spark.dynamicAllocation.maxExecutors以及 spark.dynamicAllocation.initialExecutors |
spark.dynamicAllocation |
60s | 動態分配特性啓用後，空閒時間超過該配置時間的執行器都會被移除。更詳細請參考這裏：description |
spark.dynamicAllocation.cachedExecutorIdleTimeout |
infinity | 動態分配特性啓用後，包含緩存數據的執行器若是空閒時間超過該配置設置的時間，則被移除。更詳細請參考：description |
spark.dynamicAllocation.initialExecutors |
spark .dynamicAllocation .minExecutors |
動態分配開啓後，執行器的初始個數 |
spark.dynamicAllocation.maxExecutors |
infinity | 動態分配開啓後，執行器個數的上限 |
spark.dynamicAllocation.minExecutors |
0 | 動態分配開啓後，執行器個數的下限 |
spark.dynamicAllocation.schedulerBacklogTimeout |
1s | 動態分配啓用後，若是有任務積壓的持續時間長於該配置設置的時間，則申請新的執行器。更詳細請參考：description |
spark.dynamicAllocation.sustainedSchedulerBacklogTimeout |
schedulerBacklogTimeout |
和spark.dynamicAllocation.schedulerBacklogTimeout相似，只不過該配置對應於隨後持續的執行器申請。更詳細請參考： description |
安全
| 屬性名 | 默認值 | 含義 |
|---|---|---|
spark.acls.enable |
false | 是否啓用Spark acls（訪問控制列表）。若是啓用，那麼將會檢查用戶是否有權限查看或修改某個做業（job）。注意，檢查的前提是須要知道用戶是誰，因此若是用戶是null，則不會作任何檢查。你能夠在Spark UI上設置過濾器（Filters）來作用戶認證，並設置用戶名。 |
spark.admin.acls |
Empty | 逗號分隔的用戶列表，在該列表中的用戶/管理員將可以訪問和修改全部的Spark做業（job）。若是你的集羣是共享的，而且有集羣管理員，還有須要調試的開發人員，那麼這個配置會頗有用。若是想讓全部人都有管理員權限，只需把該配置設置爲」*」 |
spark.authenticate |
false | 設置Spark是否定證集羣內部鏈接。若是不是在YARN上運行，請參考 spark.authenticate.secret |
spark.authenticate.secret |
None | 設置Spark用於內部組件認證的祕鑰。若是不是在YARN上運行，且啓用了 spark.authenticate，那麼該配置必須設置 |
spark.authenticate.enableSaslEncryption |
false | 是否對Spark內部組件認證使用加密通訊。該配置目前只有 block transfer service 使用。 |
spark.network.sasl.serverAlwaysEncrypt |
false | 是否對支持SASL認證的service禁用非加密通訊。該配置目前只有 external shuffle service 支持。 |
spark.core.connection.ack.wait.timeout |
60s | 網絡鏈接等待應答信號的超時時間。爲了不因爲GC等致使的意外超時，你能夠設置一個較大的值。 |
spark.core.connection.auth.wait.timeout |
30s | 網絡鏈接等待認證的超時時間。 |
spark.modify.acls |
Empty | 逗號分隔的用戶列表，在改列表中的用戶能夠修改Spark做業。默認狀況下，只有啓動該Spark做業的用戶能夠修改之（好比殺死該做業）。若是想要任何用戶均可以修改做業，請將該配置設置爲」*」 |
spark.ui.filters |
None | 逗號分隔的過濾器class列表，這些過濾器將用於Spark web UI。這裏的過濾器應該是一個標準的 javax servlet Filter 。每一個過濾器的參數能夠經過java系統屬性來設置，以下：spark.<class name of filer>.params=’param1=value1,param2=value2’例如： -Dspark.ui.filters=com.test.filter1 -Dspark.com.test.filter1.params=’param1=foo,param2=testing’ |
spark.ui.view.acls |
Empty | 逗號分隔的用戶列表，在該列表中的用戶能夠查看Spark web UI。默認，只有啓動該Spark做業的用戶能夠查看之。若是須要讓全部用戶都能查看，只需將該配置設爲」*」 |
加密
| 屬性名 | 默認值 | 含義 |
|---|---|---|
spark.ssl.enabled |
false | 是否啓用SSL鏈接（在全部所支持的協議上）。全部SSL相關配置（spark.ssl.xxx，其中xxx是一個特定的配置屬性），都是全局的。若是須要在某些協議上覆蓋全局設置，那麼須要在該協議命名空間上進行單獨配置。使用 spark.ssl.YYY.XXX 來爲協議YYY覆蓋全局配置XXX。目前YYY的可選值有 akka（用於基於AKKA框架的網絡鏈接） 和 fs（用於應廣播和文件服務器） |
spark.ssl.enabledAlgorithms |
Empty | 逗號分隔的加密算法列表。這些加密算法必須是JVM所支持的。這裏有個可用加密算法參考列表： this |
spark.ssl.keyPassword |
None | 在key-store中私匙對應的密碼。 |
spark.ssl.keyStore |
None | key-store文件路徑。能夠是絕對路徑，或者以本組件啓動的工做目錄爲基礎的相對路徑。 |
spark.ssl.keyStorePassword |
None | key-store的密碼。 |
spark.ssl.protocol |
None | 協議名稱。該協議必須是JVM所支持的。這裏有JVM支持的協議參考列表：this |
spark.ssl.trustStore |
None | trust-store文件路徑。能夠是絕對路徑，或者以本組件啓動的工做目錄爲基礎的相對路徑。 |
spark.ssl.trustStorePassword |
None | trust-store的密碼 |
Spark Streaming [流式]
| 屬性名 | 默認值 | 含義 |
|---|---|---|
spark.streaming.backpressure.enabled |
false | 是否啓用Spark Streaming 的內部反壓機制（spark 1.5以上支持）。啓用後，Spark Streaming會根據當前批次的調度延遲和處理時長來控制接收速率，這樣一來，系統的接收速度會和處理速度相匹配。該特性會在內部動態地設置接收速率。該速率的上限將由 spark.streaming.receiver.maxRate 和 spark.streaming.kafka.maxRatePerPartition 決定（若是它們設置了的話）。 |
spark.streaming.blockInterval |
200ms | 在將數據保存到Spark以前，Spark Streaming接收器組裝數據塊的時間間隔。建議很多於50ms。關於Spark Streaming編程指南細節，請參考 performance tuning 這一節。 |
spark.streaming.receiver.maxRate |
not set | 接收速度的最大速率（每秒記錄條數）。實際上，每一個流每秒將消費這麼多條記錄。設置爲0或者負數表示不限制速率。更多細節請參考： deployment guide |
spark.streaming.receiver.writeAheadLog.enable |
false | 是否啓用接收器預寫日誌。全部的輸入數據都會保存到預寫日誌中，這樣在驅動器失敗後，能夠基於預寫日誌來恢復數據。更詳細請參考：deployment guide |
spark.streaming.unpersist |
true | 是否強制Spark Streaming 自動從內存中清理掉所生成並持久化的RDD。同時，Spark Streaming收到的原始數據也將會被自動清理掉。若是設置爲false，那麼原始數據以及持久化的RDD將不會被自動清理，以便外部程序能夠訪問這些數據。固然，這將致使Spark消耗更多的內存。 |
spark.streaming.stopGracefullyOnShutdown |
false | 若是設爲true，Spark將會在JVM關閉時，優雅地關停StreamingContext，而不是當即關閉之。 |
spark.streaming.kafka.maxRatePerPartition |
not set | 在使用Kafka direct stream API時，從每一個Kafka數據分區讀取數據的最大速率（每秒記錄條數）。更詳細請參考：Kafka Integration guide |
spark.streaming.kafka.maxRetries |
1 | 驅動器連續重試的最大次數，這個配置是爲了讓驅動器找出每一個Kafka分區上的最大offset（默認值爲1，意味着驅動器將最多嘗試2次）。只對新的Kafka direct stream API有效。 |
spark.streaming.ui.retainedBatches |
1000 | Spark Streaming UI 以及 status API 中保留的最大批次個數。 |
SparkR
| 屬性名 | 默認值 | 含義 |
|---|---|---|
spark.r.numRBackendThreads |
2 | SparkR RBackEnd處理RPC調用的後臺線程數 |
spark.r.command |
Rscript | 集羣模式下，驅動器和worker上執行的R腳本可執行文件 |
spark.r.driver.command |
spark.r.command | client模式的驅動器執行的R腳本。集羣模式下會忽略 |
集羣管理器
每一個集羣管理器都有一些額外的配置選項。詳細請參考這裏：
YARN
Mesos
Standalone Mode
環境變量
有些Spark設置須要經過環境變量來設定，這些環境變量能夠在${SPARK_HOME}/conf/spark-env.sh腳本（Windows下是conf/spark-env.cmd）中設置。若是是獨立部署或者Mesos模式，這個文件能夠指定機器相關信息（如hostname）。運行本地Spark應用或者submit腳本時，也會引用這個文件。
注意，conf/spark-env.sh默認是不存在的。你須要複製conf/spark-env.sh.template這個模板來建立，還有注意給這個文件附上可執行權限。
如下變量能夠在spark-env.sh中設置：
| 環境變量 | 含義 |
|---|---|
JAVA_HOME |
Java安裝目錄（若是沒有在PATH變量中指定） |
PYSPARK_PYTHON |
驅動器和worker上使用的Python二進制可執行文件（默認是python） |
PYSPARK_DRIVER_PYTHON |
僅在驅動上使用的Python二進制可執行文件（默認同PYSPARK_PYTHON） |
SPARKR_DRIVER_R |
SparkR shell使用的R二進制可執行文件（默認是R） |
SPARK_LOCAL_IP |
本地綁定的IP |
SPARK_PUBLIC_DNS |
Spark程序公佈給其餘機器的hostname |
另外，還有一些選項須要在Spark standalone cluster scripts裏設置，如：每臺機器上使用的core數量，和最大內存佔用量。
spark-env.sh是一個shell腳本，所以一些參數能夠經過編程方式來設定 – 例如，你能夠獲取本機IP來設置SPARK_LOCAL_IP。
日誌配置
Spark使用log4j 打日誌。你能夠在conf目錄下用log4j.properties來配置。複製該目錄下已有的log4j.properties.template並更名爲log4j.properties便可。
覆蓋配置目錄
默認Spark配置目錄是」${SPARK_HOME}/conf」，你也能夠經過 ${SPARK_CONF_DIR}指定其餘目錄。Spark會從這個目錄下讀取配置文件（spark-defaults.conf，spark-env.sh，log4j.properties等）
繼承Hadoop集羣配置
若是你打算用Spark從HDFS讀取數據，那麼有2個Hadoop配置文件必須放到Spark的classpath下：
- hdfs-site.xml，配置HDFS客戶端的默認行爲
- core-site.xml，默認文件系統名
這些配置文件的路徑在不一樣發佈版本中不太同樣（如CDH和HDP版本），但一般都能在 ${HADOOP_HOME}/etc/hadoop/conf目錄下找到。一些工具，如Cloudera Manager，能夠動態修改配置，並且提供了下載一份拷貝的機制。
要想讓這些配置對Spark可見，請在${SPARK_HOME}/spark-env.sh中設置HADOOP_CONF_DIR變量。