
# 快速配置参数
#### 概述
本节介绍Spark2x使用过程中快速配置常用参数和不建议修改的配置参数。
#### 快速配置常用参数
其他参数在安装集群时已进行了适配，以下参数需要根据使用场景进行调整。以下参数除特别指出外，一般在Spark2x客户端的"spark-defaults.conf"文件中配置。
表1快速配置常用参数 
| 配置项                                           | 说明                                                                                                                                                                                                                                                                                                                                                                              | 默认值                                        |
|:---|:---|:---|
| spark.sql.parquet.compression.codec           | 对于非分区parquet表，设置其存储文件的压缩格式。 在JDBCServer服务端的"spark-defaults.conf"配置文件中进行设置。                                                                                                                                                                                                                                                     | snappy                                     |
| spark.dynamicAllocation.enabled               | 是否使用动态资源调度，用于根据规模调整注册于该应用的executor的数量。目前仅在YARN模式下有效。 JDBCServer默认值为true，client默认值为false。                                                                                                                                                                                                                                       | false                                      |
| spark.executor.memory                         | 每个Executor进程使用的内存数量，与JVM内存设置字符串的格式相同（例如：512m，2g）。                                                                                                                                                                                                                                                                                                                               | 4G                                         |
| spark.sql.autoBroadcastJoinThreshold          | 当进行join操作时，配置广播的最大值。 - 当SQL语句中涉及的表中相应字段的大小小于该值时，进行广播。  - 配置为-1时，将不进行广播。   | 10485760                                   |
| spark.yarn.queue                              | JDBCServer服务所在的Yarn队列。 在JDBCServer服务端的"spark-defaults.conf"配置文件中进行设置。                                                                                                                                                                                                                                                          | default                                    |
| spark.driver.memory                           | 大集群下推荐配置32\~64g驱动程序进程使用的内存数量，即SparkContext初始化的进程（例如：512m, 2g）。                                                                                                                                                                                                                                                                                                                  | 4G                                         |
| spark.yarn.security.credentials.hbase.enabled | 是否打开获取HBase token的功能。如果需要Spark-on-HBase功能，并且配置了安全集群，参数值设置为"true"。否则设置为"false"。                                                                                                                                                                                                                                                                                                  | false                                      |
| spark.serializer                              | 用于串行化将通过网络发送或需要缓存的对象的类以序列化形式展现。 Java序列化的默认值适用于任何Serializable Java对象，但运行速度相当慢，所以建议使用org.apache.spark.serializer.KryoSerializer并配置Kryo序列化。可以是org.apache.spark.serializer.Serializer的任何子类。                                                                                                                                        | org.apache.spark.serializer.JavaSerializer |
| spark.executor.cores                          | 每个执行者使用的内核个数。 在独立模式和Mesos粗粒度模式下设置此参数。当有足够多的内核时，允许应用程序在同样的worker上执行多个执行程序；否则，在每个worker上，每个应用程序只能运行一个执行程序。                                                                                                                                                                                                                       | 1                                          |
| spark.shuffle.service.enabled                 | NodeManager中一个长期运行的辅助服务，用于提升Shuffle计算性能。                                                                                                                                                                                                                                                                                                                                        | false                                      |
| spark.sql.adaptive.enabled                    | 是否开启自适应执行框架。                                                                                                                                                                                                                                                                                                                                                                    | false                                      |
| spark.executor.memoryOverhead                 | 每个执行器要分配的堆内存量（单位为兆字节）。 这是占用虚拟机开销的内存，类似于内部字符串，其他内置开销等等。会随着执行器大小（通常为6-10％）而增长。                                                                                                                                                                                                                                                   | 1GB                                        |
| spark.streaming.kafka.direct.lifo             | 配置是否开启Kafka后进先出功能。                                                                                                                                                                                                                                                                                                                                                              | false                                      |
   
#### 不建议修改的参数
以下参数在安装集群时已进行了适配，不建议用户进行修改。
表2不建议修改的参数说明 
| 配置项                                        | 说明                                                                                                                                                                    | 默认值或配置示例                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
|:---|:---|:---|
| spark.password.factory                     | 用于选择密钥解析方式。                                                                                                                                                           | org.apache.spark.om.util.FIPasswordFactory                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
| spark.ssl.ui.protocol                      | 配置ui的ssl协议。                                                                                                                                                           | TLSv1.2                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
| spark.yarn.archive                         | Spark jars的存档，用于分发到YARN缓存。如果设置，此配置值将替换\<code\> spark.yarn.jars \</ code\>，并存档在所有应用程序的容器中使用。存档应包含其根目录中的jar文件。与以前的选项一样，存档也可以在HDFS上托管，用来加快文件分发速度。                        | hdfs://hacluster/user/spark2x/jars/8.1.0.1/spark-archive-2x.zip 说明： 此处版本号8.1.0.1为示例，具体以实际环境的版本号为准。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
| spark.yarn.am.extraJavaOptions             | 在Client模式下传递至YARN Application Master的一系列额外JVM选项。在Cluster模式下使用"spark.driver.extraJavaOptions"。                                                                         | -Dlog4j.configuration=./__spark_conf__/__hadoop_conf__/log4j-executor.properties -Djava.security.auth.login.config=./__spark_conf__/__hadoop_conf__/jaas-zk.conf -Dzookeeper.server.principal=zookeeper/hadoop.*\<系统域名\>* -Djava.security.krb5.conf=./__spark_conf__/__hadoop_conf__/kdc.conf -Djdk.tls.ephemeralDHKeySize=2048                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
| spark.shuffle.servicev2.port               | Shuffle服务监测数据获取请求的端口。                                                                                                                                                 | 27338                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| spark.ssl.historyServer.enabled            | 配置history server是否使用SSL。                                                                                                                                              | true                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
| spark.files.overwrite                      | 当目标文件存在时，且其内容与源的文件不匹配。是否覆盖通过SparkContext.addFile()添加的文件。                                                                                                              | false                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| spark.yarn.cluster.driver.extraClassPath   | YARN-Cluster模式下，Driver使用的extraClassPath，配置为服务端的路径和参数。                                                                                                                 | ${BIGDATA_HOME}/common/runtime/security                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
| spark.driver.extraClassPath                | 附加至driver的classpath的额外classpath条目。                                                                                                                                    | ${BIGDATA_HOME}/common/runtime/security                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
| spark.yarn.dist.innerfiles                 | 配置YARN模式下Spark内部需要上传到HDFS的文件。                                                                                                                                         | /Spark_path/spark/conf/s3p.file,/Spark_path/spark/conf/locals3.jceks *Spark_path*为Spark客户端的安装路径。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |
| spark.sql.bigdata.register.dialect         | 用于注册sql解析器。                                                                                                                                                           | org.apache.spark.sql.hbase.HBaseSQLParser                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
| spark.shuffle.manager                      | 处理数据的方式。有两种实现方式可用：sort和hash。sort shuffle对内存的使用率更高，是Spark 1.2及后续版本的默认选项。                                                                                               | SORT                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
| spark.deploy.zookeeper.url                 | Zookeeper的地址，多个地址以逗号隔开。                                                                                                                                               | For example: host1:2181,host2:2181,host3:2181                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
| spark.broadcast.factory                    | 使用的广播方式。                                                                                                                                                              | org.apache.spark.broadcast.TorrentBroadcastFactory                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
| spark.sql.session.state.builder            | 指定会话状态构造器。                                                                                                                                                            | org.apache.spark.sql.hive.FIHiveACLSessionStateBuilder                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| spark.executor.extraLibraryPath            | 设置启动executor JVM时所使用的特殊的library path。                                                                                                                                 | ${BIGDATA_HOME}/FusionInsight_HD_8.1.0.1/install/FusionInsight-Hadoop-\*/hadoop/lib/native                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
| spark.ui.customErrorPage                   | 配置网页有错误时是否允许显示自定义的错误信息页面。                                                                                                                                             | true                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
| spark.httpdProxy.enable                    | 配置是否使用httpd代理。                                                                                                                                                        | true                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
| spark.ssl.ui.enabledAlgorithms             | 配置ui ssl算法。                                                                                                                                                           | TLS_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384,TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384,TLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256,TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256,TLS_DHE_RSA_WITH_AES_256_GCM_SHA384,TLS_DHE_DSS_WITH_AES_256_GCM_SHA384,TLS_DHE_RSA_WITH_AES_128_GCM_SHA256,TLS_DHE_DSS_WITH_AES_128_GCM_SHA256                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
| spark.ui.logout.enabled                    | 针对Spark组件的WebUI，设置logout按钮。                                                                                                                                           | true                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
| spark.security.hideInfo.enabled            | 配置UI界面是否隐藏敏感信息。                                                                                                                                                       | true                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
| spark.yarn.cluster.driver.extraLibraryPath | YARN-Cluster模式下driver的extraLibraryPath，配置成服务端的路径和参数。                                                                                                                  | ${BIGDATA_HOME}/FusionInsight_HD_8.1.0.1/install/FusionInsight-Hadoop-\*/hadoop/lib/native                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
| spark.driver.extraLibraryPath              | 设置一个特殊的library path在启动驱动程序JVM时使用。                                                                                                                                     | ${DATA_NODE_INSTALL_HOME}/hadoop/lib/native                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
| spark.ui.killEnabled                       | 允许停止Web UI中的stage和相应的job。                                                                                                                                             | true                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
| spark.yarn.access.hadoopFileSystems        | Spark可以访问多个NameService。有多个NameService时，需要把所使用的NameService都配置进该配置项，之间以逗号分隔。                                                                                            | hdfs://hacluster,hdfs://hacluster                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
| spark.yarn.cluster.driver.extraJavaOptions | 传递至Executor的额外JVM选项。例如，GC设置或其他日志记录。请注意不能通过此选项设置Spark属性或heap大小。Spark属性应该使用SparkConf对象或调用spark-submit脚本时指定的spark-defaults.conf文件来设置。Heap大小可以通过spark.executor.memory来设置。 | -Xloggc:\<LOG_DIR\>/gc.log -XX:+PrintGCDetails -XX:-OmitStackTraceInFastThrow -XX:+PrintGCTimeStamps -XX:+PrintGCDateStamps -XX:+UseGCLogFileRotation -XX:NumberOfGCLogFiles=20 -XX:GCLogFileSize=10M -Dlog4j.configuration=./__spark_conf__/__hadoop_conf__/log4j-executor.properties -Djava.security.auth.login.config=./__spark_conf__/__hadoop_conf__/jaas-zk.conf -Dzookeeper.server.principal=zookeeper/hadoop.*\<系统域名\>* -Djava.security.krb5.conf=./__spark_conf__/__hadoop_conf__/kdc.conf -Djetty.version=x.y.z -Dorg.xerial.snappy.tempdir=${BIGDATA_HOME}/tmp/spark2x_app -Dcarbon.properties.filepath=./__spark_conf__/__hadoop_conf__/carbon.properties -Djdk.tls.ephemeralDHKeySize=2048                                                                                                                                                                                                                                                                                                                                                                                                    |
| spark.driver.extraJavaOptions              | 传递至driver（驱动程序）的一系列额外JVM选项。                                                                                                                                           | -Xloggc:${SPARK_LOG_DIR}/indexserver-omm-%p-gc.log -XX:+PrintGCDetails -XX:-OmitStackTraceInFastThrow -XX:+PrintGCTimeStamps -XX:+PrintGCDateStamps -XX:MaxDirectMemorySize=512M -XX:MaxMetaspaceSize=512M -XX:+UseGCLogFileRotation -XX:NumberOfGCLogFiles=20 -XX:GCLogFileSize=10M -XX:OnOutOfMemoryError='kill -9 %p' -Djetty.version=x.y.z -Dorg.xerial.snappy.tempdir=${BIGDATA_HOME}/tmp/spark2x/JDBCServer/snappy_tmp -Djava.io.tmpdir=${BIGDATA_HOME}/tmp/spark2x/JDBCServer/io_tmp -Dcarbon.properties.filepath=${SPARK_CONF_DIR}/carbon.properties -Djdk.tls.ephemeralDHKeySize=2048 -Dspark.ssl.keyStore=${SPARK_CONF_DIR}/child.keystore #{java_stack_prefer}                                                                                                                                                                                                                                                                                                                                                                                                                                  |
| spark.eventLog.overwrite                   | 是否覆盖任何现有的文件。                                                                                                                                                          | false                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| spark.eventLog.dir                         | 如果**spark.eventLog.enabled** 为**true**，记录Spark事件的目录。在此目录下，Spark为每个应用程序创建文件，并将应用程序的事件记录到文件中。用户也可设置为统一的与HDFS目录相似的地址，这样History server就可以读取历史文件。                          | hdfs://hacluster/spark2xJobHistory2x                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
| spark.random.port.min                      | 设置随机端口的最小值。                                                                                                                                                           | 22600                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| spark.authenticate                         | 是否Spark认证其内部连接。如果不是运行在YARN上，请参见spark.authenticate.secret的相关内容。                                                                                                        | true                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
| spark.random.port.max                      | 设置随机端口的最大值。                                                                                                                                                           | 22899                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| spark.eventLog.enabled                     | 是否记录Spark事件，用于应用程序在完成后重构webUI。                                                                                                                                        | true                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
| spark.executor.extraJavaOptions            | 传递至Executor的额外JVM选项。例如，GC设置或其他日志记录。请注意不能通过此选项设置Spark属性或heap大小。                                                                                                        | -Xloggc:\<LOG_DIR\>/gc.log -XX:+PrintGCDetails -XX:-OmitStackTraceInFastThrow -XX:+PrintGCTimeStamps -XX:+PrintGCDateStamps -XX:+UseGCLogFileRotation -XX:NumberOfGCLogFiles=20 -XX:GCLogFileSize=10M -Dlog4j.configuration=./log4j-executor.properties -Djava.security.auth.login.config=./jaas-zk.conf -Dzookeeper.server.principal=zookeeper/hadoop.*\<系统域名\>* -Djava.security.krb5.conf=./kdc.conf -Dcarbon.properties.filepath=./carbon.properties -Xloggc:\<LOG_DIR\>/gc.log -XX:+PrintGCDetails -XX:-OmitStackTraceInFastThrow -XX:+PrintGCTimeStamps -XX:+PrintGCDateStamps -XX:+UseGCLogFileRotation -XX:NumberOfGCLogFiles=20 -XX:GCLogFileSize=10M -Dlog4j.configuration=./__spark_conf__/__hadoop_conf__/log4j-executor.properties -Djava.security.auth.login.config=./__spark_conf__/__hadoop_conf__/jaas-zk.conf -Dzookeeper.server.principal=zookeeper/hadoop.*\<系统域名\>* -Djava.security.krb5.conf=./__spark_conf__/__hadoop_conf__/kdc.conf -Dcarbon.properties.filepath=./__spark_conf__/__hadoop_conf__/carbon.properties -Djdk.tls.ephemeralDHKeySize=2048 |
| spark.sql.authorization.enabled            | 配置Hive client是否开启认证。                                                                                                                                                  | true                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
   
