Spark命令笔录（3）-参数调优和数据倾斜处理

柔情只为你懂 2023-02-26 06:29 30阅读 0赞

## 1. spark submit参数介绍 ##

你可以通过spark-submit --help或者spark-shell --help来查看这些参数。
    使用格式: 
    
    复制代码
    
    ./bin/spark-submit \
      --class <main-class> \
      --master <master-url> \
      --deploy-mode <deploy-mode> \
      --conf <key>=<value> \
      # other options
      <application-jar> \
      [application-arguments]
      
    参数说明
    
    --master  MASTER_URL 如spark://host:port, mesos://host:port, yarn,  yarn-cluster,yarn-client, local
    --deploy-mode DEPLOY_MODE Client或者cluster，默认是client
    --class CLASS_NAME 应用程序的主类
    --name NAME 应用程序的名称
    --jars JARS  逗号分隔的本地jar包，包含在driver和executor的classpath下
    --packages  包含在driver和executor的classpath下的jar包逗号分隔的”groupId:artifactId：version”列表
    --exclude-packages  用逗号分隔的”groupId:artifactId”列表
    --repositories  逗号分隔的远程仓库
    --py-files  PY_FILES  逗号分隔的”.zip”,”.egg”或者“.py”文件，这些文件放在python app的PYTHONPATH下面
    --files FILES 逗号分隔的文件，这些文件放在每个executor的工作目录下面
    --conf PROP=VALUE 固定的spark配置属性，默认是conf/spark-defaults.conf
    --properties-file  FILE  加载额外属性的文件
    --driver-memory MEM  Driver内存，默认1G
    --driver-java-options  传给driver的额外的Java选项
    --driver-library-path  传给driver的额外的库路径
    --driver-class-path  传给driver的额外的类路径
    --executor-memory MEM  每个executor的内存，默认是1G
    --proxy-user NAME 模拟提交应用程序的用户
    --driver-cores NUM  Driver的核数，默认是1。这个参数仅仅在standalone集群deploy模式下使用
    --supervise  Driver失败时，重启driver。在mesos或者standalone下使用
    --verbose  打印debug信息
    --total-executor-cores NUM  所有executor总共的核数。仅仅在mesos或者standalone下使用
    --executor-core NUM  每个executor的核数。在yarn或者standalone下使用
    --driver-cores NUM  Driver的核数，默认是1。在yarn集群模式下使用
    --queue QUEUE_NAME 队列名称。在yarn下使用
    --num-executors NUM  启动的executor数量。默认为2。在yarn下使用

## 2. Examples ##

复制代码
    
    #EX01  Run application locally on 8 cores(本地模式8核)
    ./bin/spark-submit \
      --class org.apache.spark.examples.SparkPi \
      --master local[8] \
      /path/to/examples.jar \
      100
     
    
    #EX02 Run on a Spark standalone cluster in client deploy mode(standalone client模式)
    ./bin/spark-submit \
      --class org.apache.spark.examples.SparkPi \
      --master spark://207.184.161.138:7077 \
      --executor-memory 20G \
      --total-executor-cores 100 \
      /path/to/examples.jar \
      1000
     
    
    #EX03 Run on a Spark standalone cluster in cluster deploy mode with supervise(standalone cluster模式使用supervise)
    ./bin/spark-submit \
      --class org.apache.spark.examples.SparkPi \
      --master spark://207.184.161.138:7077 \
      --deploy-mode cluster \
      --supervise \
      --executor-memory 20G \
      --total-executor-cores 100 \
      /path/to/examples.jar \
      1000
     
    
    #EX04 Run on a YARN cluster(YARN cluster模式)
    export HADOOP_CONF_DIR=XXX
    ./bin/spark-submit \
      --class org.apache.spark.examples.SparkPi \
      --master yarn \
      --deploy-mode cluster \  # can be client for client mode
      --executor-memory 20G \
      --num-executors 50 \
      /path/to/examples.jar \
      1000
     
    
    #EX05 Run on a Mesos cluster in cluster deploy mode with supervise(Mesos cluster模式使用supervise)
    ./bin/spark-submit \
      --class org.apache.spark.examples.SparkPi \
      --master mesos://207.184.161.138:7077 \
      --deploy-mode cluster \
      --supervise \
      --executor-memory 20G \
      --total-executor-cores 100 \
      http://path/to/examples.jar \
      1000

## 3. spark on yarn ##

所谓的Spark资源参数调优，其实主要就是对Spark运行过程中各个使用资源的地方，通过调节各种参数，来优化资源使用的效率，从而提升Spark作业的执行性能。
    以下参数就是Spark中主要的资源参数，每个参数都对应着作业运行原理中的某个部分，我们同时也给出了一个调优的参考值。
    3.1 num-executors
    参数说明：
    该参数用于设置Spark作业总共要用多少个Executor进程来执行。Driver在向YARN集群管理器申请资源时，YARN集群管理器会尽可能按照你的设置来在
    集群的各个工作节点上，启动相应数量的Executor进程。这个参数非常之重要，如果不设置的话，默认只会给你启动少量的Executor进程，此时你的
    Spark作业的运行速度是非常慢的。
     
    参数调优建议：
    每个Spark作业的运行一般设置50~100个左右的Executor进程比较合适，设置太少或太多的Executor进程都不好。设置的太少，无法充分利用集群资源；
    设置的太多的话，大部分队列可能无法给予充分的资源。
     
    3.2 executor-memory
    参数说明：
    该参数用于设置每个Executor进程的内存。Executor内存的大小，很多时候直接决定了Spark作业的性能，而且跟常见的JVM OOM异常，也有直接的关联。
     
    参数调优建议：
    每个Executor进程的内存设置4G~8G较为合适。但是这只是一个参考值，具体的设置还是得根据不同部门的资源队列来定。可以看看自己团队的资源队列
    的最大内存限制是多少，num-executors乘以executor-memory，是不能超过队列的最大内存量的。此外，如果你是跟团队里其他人共享这个资源队列，
    那么申请的内存量最好不要超过资源队列最大总内存的1/3~1/2，避免你自己的Spark作业占用了队列所有的资源，导致别的同学的作业无法运行。
     
    3.3 executor-cores
    参数说明：
    该参数用于设置每个Executor进程的CPU core数量。这个参数决定了每个Executor进程并行执行task线程的能力。因为每个CPU core同一时间只能执行一个
    task线程，因此每个Executor进程的CPU core数量越多，越能够快速地执行完分配给自己的所有task线程。
     
    参数调优建议：
    Executor的CPU core数量设置为2~4个较为合适。同样得根据不同部门的资源队列来定，可以看看自己的资源队列的最大CPU core限制是多少，再依据设置的
    Executor数量，来决定每个Executor进程可以分配到几个CPU core。同样建议，如果是跟他人共享这个队列，那么num-executors * executor-cores不要超过
    队列总CPU core的1/3~1/2左右比较合适，也是避免影响其他同学的作业运行。
     
    3.4 driver-memory
    参数说明：
    该参数用于设置Driver进程的内存。
     
    参数调优建议：
    Driver的内存通常来说不设置，或者设置1G左右应该就够了。唯一需要注意的一点是，如果需要使用collect算子将RDD的数据全部拉取到Driver上进行处理，
    那么必须确保Driver的内存足够大，否则会出现OOM内存溢出的问题。
     
    3.5 spark.default.parallelism
    参数说明：
    该参数用于设置每个stage的默认task数量。这个参数极为重要，如果不设置可能会直接影响你的Spark作业性能。
    
    参数调优建议：
    Spark作业的默认task数量为500~1000个较为合适。很多同学常犯的一个错误就是不去设置这个参数，那么此时就会导致Spark自己根据底层HDFS的block数量
    来设置task的数量，默认是一个HDFS block对应一个task。通常来说，Spark默认设置的数量是偏少的（比如就几十个task），如果task数量偏少的话，就会
    导致你前面设置好的Executor的参数都前功尽弃。试想一下，无论你的Executor进程有多少个，内存和CPU有多大，但是task只有1个或者10个，那么90%的
    Executor进程可能根本就没有task执行，也就是白白浪费了资源！因此Spark官网建议的设置原则是，设置该参数为num-executors * executor-cores的2~3倍
    较为合适，比如Executor的总CPU core数量为300个，那么设置1000个task是可以的，此时可以充分地利用Spark集群的资源。
     
    3.6 spark.storage.memoryFraction
    参数说明：
    该参数用于设置RDD持久化数据在Executor内存中能占的比例，默认是0.6。也就是说，默认Executor 60%的内存，可以用来保存持久化的RDD数据。根据你选择
    的不同的持久化策略，如果内存不够时，可能数据就不会持久化，或者数据会写入磁盘。
     
    参数调优建议：
    如果Spark作业中，有较多的RDD持久化操作，该参数的值可以适当提高一些，保证持久化的数据能够容纳在内存中。避免内存不够缓存所有的数据，导致数据只
    能写入磁盘中，降低了性能。但是如果Spark作业中的shuffle类操作比较多，而持久化操作比较少，那么这个参数的值适当降低一些比较合适。此外，如果发现
    作业由于频繁的gc导致运行缓慢（通过spark web ui可以观察到作业的gc耗时），意味着task执行用户代码的内存不够用，那么同样建议调低这个参数的值。
     
    3.7 spark.shuffle.memoryFraction
    参数说明：
    该参数用于设置shuffle过程中一个task拉取到上个stage的task的输出后，进行聚合操作时能够使用的Executor内存的比例，默认是0.2。也就是说，Executor
    默认只有20%的内存用来进行该操作。shuffle操作在进行聚合时，如果发现使用的内存超出了这个20%的限制，那么多余的数据就会溢写到磁盘文件中去，此时
    就会极大地降低性能。
     
    参数调优建议：
    如果Spark作业中的RDD持久化操作较少，shuffle操作较多时，建议降低持久化操作的内存占比，提高shuffle操作的内存占比比例，避免shuffle过程中数据过多
    时内存不够用，必须溢写到磁盘上，降低了性能。此外，如果发现作业由于频繁的gc导致运行缓慢，意味着task执行用户代码的内存不够用，那么同样建议调低
    这个参数的值。
     
    资源参数的调优，没有一个固定的值，需要根据自己的实际情况（包括Spark作业中的shuffle操作数量、RDD持久化操作数量以及spark web ui中显示的作业gc情况），
    合理地设置上述参数。
    资源参数参考示例
    以下是一份spark-submit命令的示例，大家可以参考一下，并根据自己的实际情况进行调节：
    复制代码
    
    ./bin/spark-submit \
      --master yarn-cluster \
      --num-executors 100 \
      --executor-memory 6G \
      --executor-cores 4 \
      --driver-memory 1G \
      --conf spark.default.parallelism=1000 \
      --conf spark.storage.memoryFraction=0.5 \
      --conf spark.shuffle.memoryFraction=0.3 \

## spark-submit 命令参数全解 ##

Usage: spark-submit [options] <app jar | python file> [app arguments]
    Usage: spark-submit --kill [submission ID] --master [spark://...]
    Usage: spark-submit --status [submission ID] --master [spark://...]
    Usage: spark-submit run-example [options] example-class [example args]
    
    Options:
    --master MASTER_URL         spark://host:port, mesos://host:port, yarn, or local.
    --deploy-mode DEPLOY_MODE   Whether to launch the driver program locally ("client") or
                              on one of the worker machines inside the cluster ("cluster")
                              (Default: client).
    --class CLASS_NAME          Your application's main class (for Java / Scala apps).
      --name NAME                 A name of your application.
      --jars JARS                 Comma-separated list of local jars to include on the driver
                                  and executor classpaths.
      --packages                  Comma-separated list of maven coordinates of jars to include
                                  on the driver and executor classpaths. Will search the local
                                  maven repo, then maven central and any additional remote
                                  repositories given by --repositories. The format for the
                                  coordinates should be groupId:artifactId:version.
      --exclude-packages          Comma-separated list of groupId:artifactId, to exclude while
                                  resolving the dependencies provided in --packages to avoid
                                  dependency conflicts.
      --repositories              Comma-separated list of additional remote repositories to
                                  search for the maven coordinates given with --packages.
      --py-files PY_FILES         Comma-separated list of .zip, .egg, or .py files to place
                                  on the PYTHONPATH for Python apps.
      --files FILES               Comma-separated list of files to be placed in the working
                                  directory of each executor. File paths of these files
                                  in executors can be accessed via SparkFiles.get(fileName).
    
      --conf PROP=VALUE           Arbitrary Spark configuration property.
      --properties-file FILE      Path to a file from which to load extra properties. If not
                                  specified, this will look for conf/spark-defaults.conf.
    
      --driver-memory MEM         Memory for driver (e.g. 1000M, 2G) (Default: 1024M).
      --driver-java-options       Extra Java options to pass to the driver.
      --driver-library-path       Extra library path entries to pass to the driver.
      --driver-class-path         Extra class path entries to pass to the driver. Note that
                                  jars added with --jars are automatically included in the
                                  classpath.
    
      --executor-memory MEM       Memory per executor (e.g. 1000M, 2G) (Default: 1G).
    
      --proxy-user NAME           User to impersonate when submitting the application.
                                  This argument does not work with --principal / --keytab.
    
      --help, -h                  Show this help message and exit.
      --verbose, -v               Print additional debug output.
      --version,                  Print the version of current Spark.
    
     Spark standalone with cluster deploy mode only:
      --driver-cores NUM          Cores for driver (Default: 1).
    
     Spark standalone or Mesos with cluster deploy mode only:
      --supervise                 If given, restarts the driver on failure.
      --kill SUBMISSION_ID        If given, kills the driver specified.
      --status SUBMISSION_ID      If given, requests the status of the driver specified.
    
     Spark standalone and Mesos only:
      --total-executor-cores NUM  Total cores for all executors.
    
     Spark standalone and YARN only:
      --executor-cores NUM        Number of cores per executor. (Default: 1 in YARN mode,
                                  or all available cores on the worker in standalone mode)
    
     YARN-only:
      --driver-cores NUM          Number of cores used by the driver, only in cluster mode
                                  (Default: 1).
      --queue QUEUE_NAME          The YARN queue to submit to (Default: "default").
      --num-executors NUM         Number of executors to launch (Default: 2).
                                  If dynamic allocation is enabled, the initial number of
                                  executors will be at least NUM.
      --archives ARCHIVES         Comma separated list of archives to be extracted into the
                                  working directory of each executor.
      --principal PRINCIPAL       Principal to be used to login to KDC, while running on
                                  secure HDFS.
      --keytab KEYTAB             The full path to the file that contains the keytab for the
                                  principal specified above. This keytab will be copied to
                                  the node running the Application Master via the Secure
                                  Distributed Cache, for renewing the login tickets and the
                                  delegation tokens periodically.

## 数据倾斜处理 ##

https://www.cnblogs.com/hanhaotian/p/10748476.html