精华内容
下载资源
问答
  • SparkSQL是spark用来处理结构化... 注:本文所有操作是基于ambari工具,搭建好了 hdfs yarn hive spark mapReduce等大数据常用的组件 一、进入spark命令窗口 输入命令 spark-shell 以上是各种报错的部分...

      SparkSQL是spark用来处理结构化的一个模块,它提供一个抽象的数据集DataFrame,并且是作为分布式SQL查询引擎的应用

       注:本文所有操作是基于ambari工具,搭建好了 hdfs yarn hive spark mapReduce 等大数据常用的组件

    一、进入spark命令窗口

        输入命令   spark-shell 

     

      以上是各种报错的部分截图,原因是spark操文件时,用的是hdfs系统,使用hdfs系统必须hdfs账号来操作,

      为了解决上述问题,切换用户到hdfs用户即可

    退出重新进入

     切换hdfs用户

     su hdfs

    重新进入spark-shell

    spark-shell

     

    现在完全正常了,

    二、创建DataFrames

         2.1、创建了一个数据集,实现了并行化

          val seq= Seq(("1","xiaoming",15),("2","xiaohong",20),("3","xiaobi",10))

          var rdd1 = sc.parallelize(seq)

     

     2.2、将当前的rdd对象转换为DataFrame对象(数据信息和数据结构信息存储到DataFrame)

    val df = rdd1.toDF("id","name","age")

       

    三、查询数据操作

     3.1、DSL 风格语法

    df.select("name").show
    df.select("name","age").show
    //条件过滤
    df.select("name","age").filter("age >10").show
    //参数必须是一个字符串,filter中的表达式也需要时一个字符串

     

     

        3.1.1、参数是类名col (“列名”)

        df.select(“name”,“age”).filter(col(“age”) >10).show

        3.1.2、分组统计个数

        df.groupBy("age").count().show()

       3.1.3、打印DataFrame结构信息

        df.printSchema

     

       3.2、SQL风格语法

       DataFrame的一个强大之处就是我们可以将它看作是一个关系型数据表,然后可以通过在程序中使用spark.sql() 来执行SQL查询,结果将作为一个DataFrame返回。

    如果想使用SQL风格的语法,需要将DataFrame注册成表,注册方式如下

         df.registerTempTable("t_person")

           表示 将DataFrame成t_person表

            3.2.1 、查询年龄最大的前两名

                  spark.sql("select * from t_person order by age desc limit 2").show

       3.2.2、显示表的Schema信息

           spark.sql("desc t_person").show

    3.2.3 、查询年龄大于30的人的信息

     spark.sql("select * from t_person where age > 10 ").show

    3.3、DataSet 风格

        3.3.1. 、 什么是DataSet

        DataSet是分布式的数据集合。DataSet是在Spark1.6中添加的新的接口。它集中了RDD的优点(强类型和可以用强大lambda函数)以及Spark SQL优化的执行引擎。DataSet可以通过JVM的对象进行构建,可以用函数式的转换(map/flatmap/filter)进行多种操作

      3.3.2  、 DataFrame、DataSet、RDD的区别

        同样一组数据,分别形式如下

            RDD中的长像:

        DataFrame中的长像

    Dataset中的长像

    DataSet包含了DataFrame的功能,Spark2.0中两者统一,DataFrame表示为DataSet[Row],即DataSet的子集。

    (1)DataSet可以在编译时检查类型

    (2)并且是面向对象的编程接口

    相比DataFrame,Dataset提供了编译时类型检查,对于分布式程序来讲,提交一次作业太费劲了(要编译、打包、上传、运行),到提交到集群运行时才发现错误,这会浪费大量的时间,这也是引入Dataset的一个重要原因。

       3.3.3  DataFrame与DataSet的互转

    DataFrame和DataSet可以相互转化。

    (1)DataFrame转为 DataSet

    df.as[ElementType]这样可以把DataFrame转化为DataSet。

    (2)DataSet转为DataFrame 

    ds.toDF()这样可以把DataSet转化为DataFrame。


      3.3.4.  创建DataSet

        3.3.4.1 、通过spark.createDataset创建

         val ds = spark.createDataset(1 to 10)

        

      3.3.4.2、通toDS方法生成DataSet

        定义一个类

         case class Person(name:String,age:Long)

         定义一个类的集合

         val data = List(Person("zhangsan",20),Person("lisi",30))

       转成DS

        val ds = data.toDS

      

     查看DS

       ds.show 

      

     

    展开全文
  • Spark常用三种运行模式

    万次阅读 2018-05-23 22:37:11
    Spark 的运行模式有 Local(也称单节点模式),Standalone(集群模式),Spark on Yarn(运行在Yarn上),Mesos以及K8s等常用模式,本文介绍前三种模式。 Spark-shell 参数 Spark-shell 是以一种交互式命令行方式...

    概述

    • Spark 的运行模式有 Local(也称单节点模式),Standalone(集群模式),Spark on Yarn(运行在Yarn上),Mesos以及K8s等常用模式,本文介绍前三种模式。

    Spark-shell 参数

    • Spark-shell 是以一种交互式命令行方式将Spark应用程序跑在指定模式上,也可以通过Spark-submit提交指定运用程序,Spark-shell 底层调用的是Spark-submit,二者的使用参数一致的,通过- -help 查看参数:

      • -master: 指定运行模式,spark://host:port, mesos://host:port, yarn, or local[n].
      • -deploy-mode: 指定将driver端运行在client 还是在cluster.
      • -class: 指定运行程序main方法类名,一般是应用程序的包名+类名
      • -name: 运用程序名称
      • -jars: 需要在driver端和executor端运行的jar,如mysql驱动包
      • -packages: maven管理的项目坐标GAV,多个以逗号分隔
      • -conf: 以key=value的形式传入sparkconf参数,所传入的参数必须是以spark.开头
      • -properties-file: 指定新的conf文件,默认使用spark-default.conf
      • -driver-memory:指定driver端运行内存,默认1G
      • -driver-cores:指定driver端cpu数量,默认1,仅在Standalone和Yarn的cluster模式下
      • -executor-memory:指定executor端的内存,默认1G
      • -total-executor-cores:所有executor使用的cores
      • -executor-cores: 每个executor使用的cores
      • -driver-class-path: driver端的classpath
      • -executor-class-path:executor端的classpath
    • sparkconf的传入有三种方式:

      • 1.通过在spark应用程序开发的时候用set()方法进行指定
      • 2.通过在spark应用程序提交的时候用过以上参数指定,一般使用此种方式,因为使用较为灵活
      • 3.通过配置spark-default.conf,spark-env.sh文件进行指定,此种方式较shell方式级别低

    Local模式

    • Local 模式是最简单的一种Spark运行方式,它采用单节点多线程(cpu)方式运行,local模式是一种OOTB(开箱即用)的方式,只需要在spark-env.sh导出JAVA_HOME,无需其他任何配置即可使用,因而常用于开发和学习
    • 方式:./spark-shell - -master local[n] ,n代表线程数

    Standalone模式

    • Spark可以通过部署与Yarn的架构类似的框架来提供自己的集群模式,该集群模式的架构设计与HDFS和Yarn大相径庭,都是由一个主节点多个从节点组成,在Spark 的Standalone模式中,主,即为master;从,即为worker.
    • Standalone集群模式通过配置spark-env.sh和slaves文件来部署,可以通过以下配置

      1. vi spark-env.sh
      2. SPARK_MASTER_HOST=192.168.137.200 ##配置Master节点
      3. SPARK_WORKER_CORES=2 ##配置应用程序允许使用的核数(默认是所有的core)
      4. SPARK_WORKER_MEMORY=2g  ##配置应用程序允许使用的内存(默认是一个G)
      5. vi slaves
      6. 192.168.137.200
      7. 192.168.137.201
      8. 192.168.137.202
      
    • 启动集群

      1. sbin/start-all.sh
      

      Web UI:192.168.137.200:8080

    Spark on Yarn

    • 简而言之,Spark on Yarn 模式就是将Spark应用程序跑在Yarn集群之上,通过Yarn资源调度将executor启动在container中,从而完成driver端分发给executor的各个任务。将Spark作业跑在Yarn上,首先需要启动Yarn集群,然后通过spark-shell或spark-submit的方式将作业提交到Yarn上运行。
    • 提交作业之前需要将HADOOP_CONF_DIR或YARN_CONF_DIR配置到Spark-env.sh中:

      1. vi spark-env.sh
      2. HADOOP_CONF_DIR=/opt/software/hadoop-2.6.0-cdh5.7.0/etc/hadoop
      

    on Yarn的俩种模式

    • Yarn的俩种模式:一种为 client;一种为 cluster,可以通过- -deploy-mode 进行指定,也可以直接在 - -master 后面使用 yarn-client和yarn-cluster进行指定
    • 俩种模式的区别:在于driver端启动在本地(client),还是在Yarn集群内部的AM中(cluster)

    Client 模式

    这里写图片描述

    • 客户端的Driver将应用提交给Yarn后,Yarn会先后启动ApplicationMaster和excutor,另外ApplicationMaster和executor都装在在container里运行,container默认的内存是1g,ApplicationMaster分配的内存是driver-memory,executor分配的内存是executor-memory.同时,因为Driver在客户端,所以程序的运行结果可以在客户端显示,Driver以进程名为SparkSubmit的形式存在。

    Cluster 模式

    这里写图片描述

    • 1.由client向ResourceManager提交请求,并上传Jar到HDFS上

      这期间包括四个步骤:

      a).连接到RM

      b).从RM ASM(applicationsManager)中获得metric,queue和resource等信息。

      c).upload app jar and spark-assembly jar

      d).设置运行环境和container上下文

    • 2.ResourceManager向NodeManager申请资源,创建Spark ApplicationMaster(每个SparkContext都有一个ApplicationManager)

    • 3.NodeManager启动Spark App Master,并向ResourceManager ASM注册

    • 4.Spark ApplicationMaster从HDFS中找到jar文件,启动DAGScheduler和YARN Cluster Scheduler

    • 5.ResourceManager向ResourceManager ASM注册申请container资源(INFO YarnClientImpl: Submitted application)

    • 6.ResourceManager通知NodeManager分配Container,这是可以收到来自ASM关于container的报告。(每个container的对应一个executor)

    • 7.Spark ApplicationMaster直接和container(executor)进行交互,完成这个分布式任务。

    on Yarn 部分参数调优

    • spark.yarn.jars/spark.yarn.archive
      将本地jar包上传到hdfs,然后通过这个参数指定上传路径:

      1. [hadoop@hadoop001 spark-2.2.0-bin-2.6.0-cdh5.7.0]$ hdfs dfs -mkdir -p /spark/jars
      2. [hadoop@hadoop001 spark-2.2.0-bin-2.6.0-cdh5.7.0]$ hdfs dfs -put jars/ /spark/jars
      
      3. vi spark-defaults.conf
      4. spark.yarn.jars  hdfs:///spark/jars/*
      
    • spark.port.maxRetries 能够启动的最大程序数+1,根据实际业务设置
    • *
    展开全文
  • 常用的命令  1、打包  mvn package --生成压缩文件:java项目#jar包;web项目#war包,放在target目录下     2、清理  mvn clean --删除target目录  3、安装  mvn install --将压缩文件(jar或者war...

    常用的命令

        1、打包

            mvn package  --生成压缩文件:java项目#jar包;web项目#war包,放在target目录下 

            

        2、清理

            mvn clean    --删除target目录

        3、安装

      mvn install   --将压缩文件(jar或者war)上传到本地仓库

    展开全文
  • Spark 常用配置项与优化配置项

    万次阅读 2015-03-12 22:01:38
    Spark 常用配置项与优化配置项 1、配置加载顺序: SparkConf方式 > 命令行参数方式 >文件配置方式。 应用程序SparkConf 优先级高 2.spark 常用配置详解 1 节点说明 IP Role 192.168.1.111...
    Spark 常用配置项与优化配置项

    1、配置加载顺序:
    SparkConf方式 > 命令行参数方式 >文件配置方式。

    应用程序SparkConf 优先级高


    2.spark 常用配置详解
    1 节点说明
    IP

    Role

    192.168.1.111

    ActiveNameNode

    192.168.1.112

    StandbyNameNode,Master,Worker

    192.168.1.113

    DataNode,Master,Worker

    192.168.1.114

    DataNode,Worker

    HDFS集群和Spark集群之间节点共用。
    2 安装HDFS
    见HDFS2.X和Hive的安装部署文档:
    http://www.cnblogs.com/Scott007/p/3614960.html 
    3 Spark部署
    Spark常用的安装部署模式有Spark On Yarn和Standalone,可以同时使用。
    3.1 Spark on Yarn
    这种模式,借助Yarn资源分配的功能,使用Spark客户端来向Yarn提交任务运行。只需将Spark的部署包放置到Yarn集群的某个节点上即可(或者是Yarn的客户端,能读取到Yarn集群的配置文件即可)。Spark本身的Worker节点、Master节点不需要启动。

    但是,Spark的部署包须是基于对应的Yarn版本正确编译后的,否则会出现Spark和Yarn的兼容性问题。

    on Yarn的两种运行方式,其运行结束后的日志不能在Yarn的Application管理界面看到,目前只能在客户端通过:

    yarn logs -applicationId <applicationId>

    命令查看每个Application的日志。
    3.1.1 配置
    部署这种模式,需要修改conf目录下的spark-env.sh文件。在其中新增如下配置选项:

    export HADOOP_HOME= /home/hadoop/hadoop-2.0.0-cdh4.5.0export HADOOP_CONF_DIR= $HADOOP_HOME/etc/hadoopSPARK_EXECUTOR_INSTANCES=2SPARK_EXECUTOR_CORES=1SPARK_EXECUTOR_MEMORY=400MSPARK_DRIVER_MEMORY=400MSPARK_YARN_APP_NAME="Spark 1.0.0"

    其中:

    (1) HADOOP_HOME:当前节点中HDFS的部署路径,因为Spark需要和HDFS中的节点在一起;

    (2) HADOOP_CONF_DIR:HDFS节点中的conf配置文件路径,正常情况下此目录为$HADOOP_HOME/etc/hadoop;

    (3) SPARK_EXECUTOR_INSTANCES:在Yarn集群中启动的Worker的数目,默认为2个;

    (4) SPARK_EXECUTOR_CORES:每个Worker所占用的CPU核的数目;

    (5) SPARK_EXECUTOR_MEMORY:每个Worker所占用的内存大小;

    (6) SPARK_DRIVER_MEMORY:Spark应用程序Application所占的内存大小,这里的Driver对应Yarn中的ApplicationMaster;

    (7) SPARK_YARN_APP_NAME:Spark Application在Yarn中的名字;

    配置完成后,将Spark部署文件放置到Yarn的节点中即可。这里,将spark-1.0.0整个目录放到Yarn集群的一个节点192.168.1.112的/home/hadoop(设为spark的安装路径的父目录)路径下。

    3.1.2 测试
    在Spark的部署路径的bin路径下,执行spark-submit脚本来运行spark-examples包中的例子。执行如下:

    ./bin/spark-submit --master yarn \--class org.apache.spark.examples.JavaWordCount \--executor-memory 400M \--driver-memory 400M \/home/hadoop/spark-1.0.0/examples/target/scala-2.10/spark-examples-1.0.0-hadoop2.0.0-cdh4.5.0.jar ./hdfs-site.xml

    这个例子是计算WordCount的,例子被打包在/home/hadoop/spark-1.0.0/examples/target/scala-2.10/spark-examples-1.0.0-hadoop2.0.0-cdh4.5.0.jar包中,对应的Class为org.apache.spark.examples.JavaWordCount,./hdfs-site.xml是HDFS中指定路径下的一个文件,WordCount就是针对它来做的。而--master yarn就是指定运行在Yarn集群中,以yarn模式运行。

    Spark On Yarn有两种运行模式,一种是Yarn Cluster方式,一种是Yarn Client方式。

    (1) Yarn Cluster: Spark Driver程序将作为一个ApplicationMaster在YARN集群中先启动,然后再由ApplicationMaster向RM申请资源启动executor以运行Task。因为Driver程序在Yarn中运行,所以程序的运行结果不能在客户端显示,所以最好将结果保存在HDFS上,客户端的终端显示的是作为Yarn的job的运行情况。

    (2) Yarn Client: Spark Driver程序在客户端上运行,然后向Yarn申请运行exeutor以运行Task,本地程序负责最后的结果汇总等。客户端的Driver将应用提交给Yarn后,Yarn会先后启动ApplicationMaster和executor,另外ApplicationMaster和executor都是装载在container里运行,container默认的内存是1G,ApplicationMaster分配的内存是driver-memory,executor分配的内存是executor-memory。同时,因为Driver在客户端,所以程序的运行结果可以在客户端显示,Driver以进程名为SparkSubmit的形式存在。

    上面命令中的提交方式“yarn”就是默认按照“Yarn Client”方式运行。用户可自定义运行方式,通过“--master”指定程序以yarn、yarn-cluster或者yarn-client中的一种方式运行。

    需要重点说明的是最后文件的路径,是相当于HDFS中的/user/hadoop而言,hadoop是当前命令的用户。“./hdfs-site.xml”在HDFS中的全路径为“hdfs://namespace/user/hadoop/hdfs-site.xml”,其中hadoop是当前的用户,namespace是HDFS的命名空间;如果写成“/hdfs-site.xml”则在HDFS中指的是“hdfs://namespace/hdfs-site.xml”;当然也可以直接传入“hdfs://namespace/user/hadoop/hdfs-site.xml”用于指定在HDFS中的要进行WordCount计算的文件。

    另外,Spark应用程序需要的CPU Core数目和内存,需要根据当前Yarn的NodeManager的硬件条件相应设置,不能超过NodeManager的硬件条件。

    ./bin/spark-submit --master yarn \--class org.apache.spark.examples.JavaWordCount \--executor-memory 400M \--driver-memory 400M \/home/hadoop/spark-1.0.0/examples/target/scala-2.10/spark-examples-1.0.0-hadoop2.0.0-cdh4.5.0.jar hdfs://namespace/user/hadoop/hdfs-site.xml

    在Yarn的ResourceManager对应的Web界面中查看启动的Application。

    Running:


    Success:


    同时可以在启动脚本的客户端看到WordCount的运行结果:

    3.2 Spark Standalone
    这种模式,就是把Spark单独作为一个集群来进行部署。集群中有两种节点,一种是Master,另一种是Worker节点。Master负责分配任务给Worker节点来执行,并负责最后的结果合并,Worker节点负责具体的任务执行。
    3.2.1 配置
    所需修改的配置文件除了spark-env.sh文件以外,还有slave文件,都位于conf目录中。

    slave文件中保存的是worker节点host或者IP,此处的配置为:

    192.168.1.112

    192.168.1.113

    192.168.1.114

    至于spark-env.sh文件,可以配置如下属性:

    (1) SPARK_MASTER_PORT:Master服务端口,默认为7077;

    (2) SPARK_WORKER_CORES:每个Worker进程所需要的CPU核的数目;

    (3) SPARK_WORKER_MEMORY:每个Worker进程所需要的内存大小;

    (4) SPARK_WORKER_INSTANCES:每个Worker节点上运行Worker进程的数目;

    (5) SPARK_MASTER_WEBUI_PORT:Master节点对应Web服务的端口;

    (6)export SPARK_DAEMON_JAVA_OPTS="-Dspark.deploy.recoveryMode=ZOOKEEPER -Dspark.deploy.zookeeper.url=192.168.1.117:2181,192.168.1.118:2181,192.168.1.119:2181 -Dspark.deploy.zookeeper.dir=/spark":用于指定Master的HA,依赖于zookeeper集群;

    (7) export SPARK_JAVA_OPTS="-Dspark.cores.max=4":用于限定每个提交的Spark Application的使用的CPU核的数目,因为缺省情况下提交的Application会使用所有集群中剩余的CPU Core。

    注意在Worker进程的CPU个数和内存大小的时候,要结合机器的实际硬件条件,如果一个Worker节点上的所有Worker进程需要的CPU总数目或者内存大小超过当前Worker节点的硬件条件,则Worker进程会启动失败。

    将配置好的Spark文件拷贝至每个Spark集群的节点上的相同路径中。为方便使用spark-shell,可以在环境变量中配置上SPARK_HOME。
    3.2.2 启动
    配置结束后,就该启动集群了。这里使用Master的HA方式,选取192.168.1.112、192.168.1.113节点作为Master,192.168.1.112、192.168.1.113、192.168.1.114节点上运行两个Worker进程。

    首先在192.168.1.113节点上做此操作:

    启动之后,可以查看当前节点的进程:

    另外,为了保证Master的HA,在192.168.1.112节点上只启动Master:

    192.168.1.112节点的进程为:

    启动过后,通过Web页面查看集群的情况,这里访问的是:
    http://192.168.1.113:8090/ 
    再看standby节点192.168.1.112的web界面
    http://192.168.1.112:8090/ 
    3.2.3 测试
    Spark的bin子目录中的spark-submit脚本是用于提交程序到集群中运行的工具,我们使用此工具做一个关于pi的计算。命令如下:

    ./bin/spark-submit --master spark://spark113:7077 \--class org.apache.spark.examples.SparkPi \--name Spark-Pi --executor-memory 400M \--driver-memory 512M \/home/hadoop/spark-1.0.0/examples/target/scala-2.10/spark-examples-1.0.0-hadoop2.0.0-cdh4.5.0.jar

    其中--master参数用于指定Master节点的URI,但是这里填的是Host,不是IP!

    任务启动之后,在Spark的Master的Web界面可以看到运行中的Application。


    任务运行结束之后,在Web界面中Completed Applications表格中会看到对应的结果。

    同时,命令行中会打印出来运行的结果,如下所示:


    4 spark-submit工具
    上面测试程序的提交都是使用的spark-submit脚本,其位于$SPARK_HOME/bin目录中,执行时需要传入的参数说明如下:

    Usage: spark-submit [options] <app jar | python file> [app options]

    参数名称

    含义

    --master MASTER_URL

    可以是spark://host:port, mesos://host:port, yarn, yarn-cluster,yarn-client, local

    --deploy-mode DEPLOY_MODE

    Driver程序运行的地方,client或者cluster

    --class CLASS_NAME

    主类名称,含包名

    --name NAME

    Application名称

    --jars JARS

    Driver依赖的第三方jar包

    --py-files PY_FILES

    用逗号隔开的放置在Python应用程序PYTHONPATH上的.zip, .egg, .py文件列表

    --files FILES

    用逗号隔开的要放置在每个executor工作目录的文件列表

    --properties-file FILE

    设置应用程序属性的文件路径,默认是conf/spark-defaults.conf

    --driver-memory MEM

    Driver程序使用内存大小

    --driver-java-options


    --driver-library-path

    Driver程序的库路径

    --driver-class-path

    Driver程序的类路径

    --executor-memory MEM

    executor内存大小,默认1G

    --driver-cores NUM

    Driver程序的使用CPU个数,仅限于Spark Alone模式

    --supervise

    失败后是否重启Driver,仅限于Spark Alone模式

    --total-executor-cores NUM

    executor使用的总核数,仅限于Spark Alone、Spark on Mesos模式

    --executor-cores NUM

    每个executor使用的内核数,默认为1,仅限于Spark on Yarn模式

    --queue QUEUE_NAME

    提交应用程序给哪个YARN的队列,默认是default队列,仅限于Spark on Yarn模式

    --num-executors NUM

    启动的executor数量,默认是2个,仅限于Spark on Yarn模式

    --archives ARCHIVES

    仅限于Spark on Yarn模式

    另外,在执行spark-submit.sh工具进行提交应用之前,可以使用如下方式提前定义好当前Spark Application所使用的CPU Core数目和内存大小:

    SPARK_JAVA_OPTS="-Dspark.cores.max=2 -Dspark.executor.memory=600m" \./bin/spark-submit --master spark://update113:7077 \--class org.apache.spark.examples.SparkPi \……

    5 Spark HistoryServer
    类似于Mapreduce的JobHistoryServer,Spark也有一个服务可以保存历史Application的运行记录。

    修改$SPARK_HOME/conf下的spark-defaults.conf文件(注意,修改后的配置文件在每个节点都要有),其中可修改的配置属性为:

    属性名称

    默认值

    含义

    spark.history.updateInterval

    10

    以秒为单位,更新日志相关信息的时间间隔

    spark.history.retainedApplications

    250

    保存Application历史记录的个数,如果超过这个值,旧的应用程序信息将被删除

    spark.history.ui.port

    18080

    HistoryServer的web端口

    spark.history.kerberos.enabled

    False

    是否使用kerberos方式登录访问HistoryServer,对于持久层位于安全集群的HDFS上是有用的,如果设置为true,就要配置下面的两个属性

    spark.history.kerberos.principal


    用于HistoryServer的kerberos主体名称

    spark.history.kerberos.keytab


    用于HistoryServer的kerberos keytab文件位置

    spark.history.ui.acls.enable

    False

    授权用户查看应用程序信息的时候是否检查acl。如果启用,只有应用程序所有者和spark.ui.view.acls指定的用户可以查看应用程序信息;否则,不做任何检查

    spark.eventLog.enabled

    False

    是否记录Spark事件

    spark.eventLog.dir


    保存日志相关信息的路径,可以是hdfs://开头的HDFS路径,也可以是file://开头的本地路径,都需要提前创建

    spark.yarn.historyServer.address


    Server端的URL:Ip:port 或者host:port

    此处的设置如下:

    spark.eventLog.enabled truespark.eventLog.dir hdfs://yh/user/hadoop/sparklogsspark.yarn.historyServer.address update113:18080

    设置完文件之后,进入sbin目录启动服务:

    运行完成的Application历史记录可以通过访问上面指定的HistoryServer地址查看,这里是
    http://192.168.1.113:18080/ 


    无论运行时是本地模式,还是yarn-client、yarn-cluster,运行记录均可在此页面查看。

    并且程序运行时的环境变量、系统参数、各个阶段的耗时均可在此查看,
    很强大 

    6 Spark可配置参数
    Spark参数的配置可通过三种方式:SparkConf方式 > 命令行参数方式 >文件配置方式。
    6.1 应用属性
    属性名

    默认值

    含义

    spark.app.name


    应用程序名称

    spark.master


    要连接的Spark集群Master的URL

    spark.executor.memory

    512 m

    每个executor使用的内存大小

    spark.serializer

    org.apache.spark

    .serializer.JavaSerializer

    序列化方式,官方建议使用org.apache.spark.serializer.KryoSerializer,当然也可以任意是定义为org.apache.spark.Serializer子类的序化器

    spark.kryo.registrator


    如果要使用 Kryo序化器,需要创建一个继承KryoRegistrator的类并设置系统属性spark.kryo.registrator指向该类

    spark.local.dir

    /tmp

    用于保存map输出文件或者转储RDD。可以多个目录,之间以逗号分隔。在Spark 1.0 及更高版本此属性会被环境变量 SPARK_LOCAL_DIRS (Standalone、Mesos) 或 LOCAL_DIRS (YARN) 代替

    spark.logConf

    False

    SparkContext 启动时是否记录有效 SparkConf信息

    6.2 运行环境变量
    属性名

    默认值

    含义

    spark.executor.extraJavaOptions


    传递给executor的额外JVM 选项,但是不能使用它来设置Spark属性或堆空间大小

    spark.executor.extraClassPath


    追加到executor类路径中的附加类路径

    spark.executor.extraLibraryPath


    启动executor JVM 时要用到的特殊库路径

    spark.files.userClassPathFirst

    False

    executor在加载类的时候是否优先使用用户自定义的JAR包,而不是Spark带有的JAR包,目前,该属性只是一项试验功能

    6.3 Shuffle操作相关属性
    属性名

    默认值

    含义

    spark.shuffle.consolidateFiles

    False

    如果为true,在shuffle时就合并中间文件,对于有大量Reduce任务的shuffle来说,合并文件可以提高文件系统性能,如果使用的是ext4 或 xfs 文件系统,建议设置为true;对于ext3,由于文件系统的限制,设置为true反而会使内核>8的机器降低性能

    spark.shuffle.spill

    True

    如果为true,在shuffle期间通过溢出数据到磁盘来降低了内存使用总量,溢出阈值是由spark.shuffle.memoryFraction指定的

    spark.shuffle.spill.compress

    True

    是否压缩在shuffle期间溢出的数据,如果压缩将使用spark.io.compression.codec。

    spark.shuffle.compress

    True

    是否压缩map输出文件,压缩将使用spark.io.compression.codec。

    spark.shuffle.file.buffer.kb

    100

    每个shuffle的文件输出流内存缓冲区的大小,以KB为单位。这些缓冲区可以减少磁盘寻道的次数,也减少创建shuffle中间文件时的系统调用

    spark.reducer.maxMbInFlight

    48

    每个reduce任务同时获取map输出的最大大小 (以兆字节为单位)。由于每个map输出都需要一个缓冲区来接收它,这代表着每个 reduce 任务有固定的内存开销,所以要设置小点,除非有很大内存

    6.4 SparkUI相关属性
    属性名

    默认值

    含义

    spark.ui.port

    4040

    应用程序webUI的端口

    spark.ui.retainedStages

    1000

    在GC之前保留的stage数量

    spark.ui.killEnabled

    True

    允许在webUI将stage和相应的job杀死

    spark.eventLog.enabled

    False

    是否记录Spark事件,用于应用程序在完成后重构webUI

    spark.eventLog.compress

    False

    是否压缩记录Spark事件,前提spark.eventLog.enabled为true

    spark.eventLog.dir
    file:///tmp/spark-events 
    如果spark.eventLog.enabled为 true,该属性为记录spark事件的根目录。在此根目录中,Spark为每个应用程序创建分目录,并将应用程序的事件记录到在此目录中。可以将此属性设置为HDFS目录,以便history server读取历史记录文件

    6.5 压缩和序列化相关属性
    属性名

    默认值

    含义

    spark.broadcast.compress

    True

    是否在发送之前压缩广播变量

    spark.rdd.compress

    False

    是否压缩RDD分区

    spark.io.compression.codec

    org.apache.spark.io.

    LZFCompressionCodec

    用于压缩内部数据如 RDD分区和shuffle输出的编码解码器, org.apache.spark.io.LZFCompressionCodec和org.apache.spark.io.SnappyCompressionCodec。其中,Snappy提供更快速的压缩和解压缩,而LZF提供了更好的压缩比

    spark.io.compression.snappy

    .block.size

    32768

    使用Snappy编码解码器时,编码解码器使用的块大小 (以字节为单位)

    spark.closure.serializer

    org.apache.spark.serializer.

    JavaSerializer

    用于闭包的序化器,目前只有支持Java序化器

    spark.serializer.
    objectStreamReset
    10000

    org.apache.spark.serializer.JavaSerializer序列化时,会缓存对象以防止写入冗余数据,此时会停止这些对象的垃圾收集。通过调用重置序化器,刷新该信息就可以收集旧对象。若要关闭这重定期重置功能将其设置为< = 0 。默认情况下每10000个对象将重置序化器

    spark.kryo.referenceTracking

    True

    当使用Kryo序化数据时,是否跟踪对同一对象的引用。如果你的对象图有回路或者同一对象有多个副本,有必要设置为true;其他情况下可以禁用以提高性能

    spark.kryoserializer.buffer.mb

    2

    在Kryo 里允许的最大对象大小(Kryo会创建一个缓冲区,至少和序化的最大单个对象一样大)。每个worker的每个core只有一个缓冲区

    6.6 执行时相关属性
    属性名

    默认值

    含义

    spark.default.parallelism

    本地模式:机器核数

    Mesos:8

    其他:max(executor的core,2)

    如果用户不设置,系统使用集群中运行shuffle操作的默认任务数(groupByKey、 reduceByKey等)

    spark.broadcast.factory

    org.apache.spark.broadcast.

    HttpBroadcastFactory

    广播的实现类

    spark.broadcast.blockSize

    4096

    TorrentBroadcastFactory块大小(以kb为单位)。过大会降低广播速度;过小会使印象BlockManager性能

    spark.files.overwrite

    Fale

    通过 SparkContext.addFile() 添加的文件在目标中已经存在并且内容不匹配时,是否覆盖目标文件

    spark.files.fetchTimeout

    False

    在获取由driver通过SparkContext.addFile() 添加的文件时,是否使用通信时间超时

    spark.storage.memoryFraction

    0.6

    Java堆用于cache的比例

    spark.tachyonStore.baseDir

    System.getProperty("java.io.tmpdir")

    用于存储RDD的techyon目录,tachyon文件系统的URL由spark.tachyonStore.url设置,也可以是逗号分隔的多个techyon目录

    spark.storage.

    memoryMapThreshold

    8192

    以字节为单位的块大小,用于磁盘读取一个块大小时进行内存映射。这可以防止Spark在内存映射时使用很小块,一般情况下,对块进行内存映射的开销接近或低于操作系统的页大小

    spark.tachyonStore.url

    tachyon://localhost:19998

    基于techyon文件的URL

    spark.cleaner.ttl


    spark记录任何元数据(stages生成、task生成等)的持续时间。定期清理可以确保将超期的元数据丢弃,这在运行长时间任务是很有用的,如运行7*24的sparkstreaming任务。RDD持久化在内存中的超期数据也会被清理

    6.7 网络相关属性
    属性名

    默认值

    含义

    spark.driver.host


    运行driver的主机名或 IP 地址

    spark.driver.port

    随机

    driver侦听的端口

    spark.akka.frameSize

    10

    以MB为单位的driver和executor之间通信信息的大小,设置值越大,driver可以接受更大的计算结果

    spark.akka.threads

    4

    用于通信的actor线程数,在大型集群中拥有更多CPU内核的driver可以增加actor线程数

    spark.akka.timeout

    100

    以秒为单位的Spark节点之间超时时间

    spark.akka.heartbeat.pauses

    600

    下面3个参数是用于设置Akka自带的故障探测器。启用的话,以秒为单位设置如下这三个参数,有助于对恶意的executor的定位,而对于由于GC暂停或网络滞后引起的情况下,不需要开启故障探测器;另外故障探测器的开启会导致由于心跳信息的频繁交换而引起的网络泛滥。

    本参数是设置可接受的心跳停顿时间

    spark.akka.failure-detector.threshold

    300.0

    对应Akka的akka.remote.transport-failure-detector.threshold

    spark.akka.heartbeat.interval

    1000

    心跳间隔时间

    6.8 调度相关属性
    属性名

    默认值

    含义

    spark.task.cpus

    1

    为每个任务分配的内核数

    spark.task.maxFailures

    4

    Task的最大重试次数

    spark.scheduler.mode

    FIFO

    Spark的任务调度模式,还有一种Fair模式

    spark.cores.max


    当应用程序运行在Standalone集群或者粗粒度共享模式Mesos集群时,应用程序向集群请求的最大CPU内核总数(不是指每台机器,而是整个集群)。如果不设置,对于Standalone集群将使用spark.deploy.defaultCores中数值,而Mesos将使用集群中可用的内核

    spark.mesos.coarse

    False

    如果设置为true,在Mesos集群中运行时使用粗粒度共享模式

    spark.speculation

    False

    以下几个参数是关于Spark推测执行机制的相关参数。此参数设定是否使用推测执行机制,如果设置为true则spark使用推测执行机制,对于Stage中拖后腿的Task在其他节点中重新启动,并将最先完成的Task的计算结果最为最终结果

    spark.speculation.interval

    100

    Spark多长时间进行检查task运行状态用以推测,以毫秒为单位

    spark.speculation.quantile

    0.75

    推测启动前,Stage必须要完成总Task的百分比

    spark.speculation.multiplier

    1.5

    比已完成Task的运行速度中位数慢多少倍才启用推测

    spark.locality.wait

    3000

    以下几个参数是关于Spark数据本地性的。本参数是以毫秒为单位启动本地数据task的等待时间,如果超出就启动下一本地优先级别的task。该设置同样可以应用到各优先级别的本地性之间(本地进程 -> 本地节点 -> 本地机架 -> 任意节点 ),当然,也可以通过spark.locality.wait.node等参数设置不同优先级别的本地性

    spark.locality.wait.process

    spark.locality.wait

    本地进程级别的本地等待时间

    spark.locality.wait.node

    spark.locality.wait

    本地节点级别的本地等待时间

    spark.locality.wait.rack

    spark.locality.wait

    本地机架级别的本地等待时间

    spark.scheduler.revive.interval

    1000

    复活重新获取资源的Task的最长时间间隔(毫秒),发生在Task因为本地资源不足而将资源分配给其他Task运行后进入等待时间,如果这个等待时间内重新获取足够的资源就继续计算

    6.9 安全相关属性
    属性名

    默认值

    含义

    spark.authenticate

    False

    是否启用内部身份验证

    spark.authenticate.secret


    设置组件之间进行身份验证的密钥。如果不是YARN上运行并且spark.authenticate为true时,需要设置密钥

    spark.core.connection. auth.wait.timeout

    30

    进行身份认证的超时时间

    spark.ui.filters
    Spark web UI 要使用的以逗号分隔的筛选器名称列表。筛选器要符合javax servlet Filter标准,每个筛选器的参数可以通过设置java系统属性来指定:

    spark.<class name of filter>.params='param1=value1,param2=value2'

    例如:

    -Dspark.ui.filters=com.test.filter1

    -Dspark.com.test.filter1.params='param1=foo,param2=testing'

    spark.ui.acls.enable

    False

    Spark webUI存取权限是否启用。如果启用,在用户浏览web界面的时候会检查用户是否有访问权限

    spark.ui.view.acls


    以逗号分隔Spark webUI访问用户的列表。默认情况下只有启动Spark job的用户才有访问权限

    6.10 SparkStreaming相关属性
    属性名

    默认值

    含义

    spark.streaming.blockInterval

    200

    Spark Streaming接收器将接收数据合并成数据块并存储在Spark里的时间间隔,毫秒

    spark.streaming.unpersist

    True

    如果设置为true,强迫将SparkStreaming持久化的RDD数据从Spark内存中清理,同样的,SparkStreaming接收的原始输入数据也会自动被清理;如果设置为false,则允许原始输入数据和持久化的RDD数据可被外部的Streaming应用程序访问,因为这些数据不会自动清理
    6.11 Standalone模式特有属性
    可以在文件conf/spark-env.sh中来设置此模式的特有相关属性:

    (1)SPARK_MASTER_OPTS:配置master使用的属性

    (2)SPARK_WORKER_OPTS:配置worker使用的属性

    (3)SPARK_DAEMON_JAVA_OPTS:配置master和work都使用的属性

    配置的时候,使用类似的语句:

    export SPARK_MASTER_OPTS="-Dx1=y1 -Dx2=y2"

    其中x代表属性,y代表属性值。

    SPARK_MASTER_OPTS所支持的属性有:

    属性名

    默认值

    含义

    spark.deploy.spreadOut

    True

    Standalone集群管理器是否自由选择节点还是固定到尽可能少的节点,前者会有更好的数据本地性,后者对于计算密集型工作负载更有效

    spark.worker.timeout

    60

    master因为没有收到心跳信息而认为worker丢失的时间(秒)

    spark.deploy.defaultCores


    如果没有设置spark.cores.max,该参数设置Standalone集群分配给应用程序的最大内核数,如果不设置,应用程序获取所有的有效内核。注意在一个共享的集群中,设置一个低值防止攫取了所有的内核,影响他人的使用

    SPARK_WORKER_OPTS所支持的属性有

    属性名

    默认值

    含义

    spark.worker.cleanup.enabled

    False

    是否定期清理worker的应用程序工作目录,只适用于Standalone模式,清理的时候将无视应用程序是否在运行

    spark.worker.cleanup.interval

    1800

    清理worker本地过期的应用程序工作目录的时间间隔(秒)

    spark.worker.cleanup.appDataTtl

    7*24*3600

    worker保留应用程序工作目录的有效时间。该时间由磁盘空间、应用程序日志、应用程序的jar包以及应用程序的提交频率来设定

    SPARK_DAEMON_JAVA_OPTS所支持的属性有:

    属性名

    含义

    spark.deploy.recoveryMode

    下面3个参数是用于配置zookeeper模式的master HA。设置为ZOOKEEPER表示启用master备用恢复模式,默认为NONE

    spark.deploy.zookeeper.url

    zookeeper集群URL

    spark.deploy.zookeeper.dir

    zooKeeper保存恢复状态的目录,缺省为/spark

    spark.deploy.recoveryMode

    设成FILESYSTEM启用master单节点恢复模式,缺省值为NONE

    spark.deploy.recoveryDirectory

    Spark保存恢复状态的目录

    6.12 Spark on Yarn特有属性
    属性名

    默认值

    含义

    spark.yarn.applicationMaster.waitTries

    10

    RM等待Spark AppMaster启动重试次数,也就是SparkContext初始化次数。超过这个数值,启动失败
    spark.yarn.submit.file.replication

    3

    应用程序上传到HDFS的文件的副本数

    spark.yarn.preserve.staging.files

    False

    若为true,在job结束后,将stage相关的文件保留而不是删除

    spark.yarn.scheduler.heartbeat.interval-ms

    5000

    Spark AppMaster发送心跳信息给YARN RM的时间间隔

    spark.yarn.max.executor.failures

    2倍于executor数

    导致应用程序宣告失败的最大executor失败次数

    spark.yarn.historyServer.address


    Spark history server的地址(不要加http://)。这个地址会在Spark应用程序完成后提交给YARN RM,然后RM将信息从RM UI写到history server UI上。

    7 示例配置
    主要的
    配置文件 
    均位于$SPARK_HOME/conf中,包括slave、spark-env.sh、spark-defaults.conf文件等。
    7.1 slave文件
    192.168.1.112192.168.1.113192.168.1.114

    7.2 spark-env.sh文件

    export JAVA_HOME="/export/servers/jdk1.6.0_25" #yarnexport HADOOP_HOME=/home/hadoop/hadoop-2.0.0-cdh4.5.0export HADOOP_CONF_DIR=$HADOOP_HOME/etc/hadoopSPARK_EXECUTOR_INSTANCES=2SPARK_EXECUTOR_CORES=1SPARK_EXECUTOR_MEMORY=400MSPARK_DRIVER_MEMORY=400MSPARK_YARN_APP_NAME="Spark 1.0.0"#aloneSPARK_MASTER_WEBUI_PORT=8090SPARK_WORKER_MEMORY=400MSPARK_WORKER_CORES=1SPARK_WORKER_INSTANCES=2#Master HAexport SPARK_DAEMON_JAVA_OPTS="-Dspark.deploy.recoveryMode=ZOOKEEPER -Dspark.deploy.zookeeper.url=192.168.1.117:2181,192.168.1.118:2181,192.168.1.119:2181 -Dspark.deploy.zookeeper.dir=/spark"

    7.3 spark-defaults.conf文件

    #history serverspark.eventLog.enabled truespark.eventLog.dir hdfs://namespace/user/hadoop/sparklogsspark.yarn.historyServer.address spark113:18080#shufflespark.shuffle.consolidateFiles true#taskspark.task.cpus 1spark.task.maxFailures 3#scheduler typespark.scheduler.mode FAIR#securitypark.authenticate truespark.authenticate.secret hadoopspark.core.connection.auth.wait.timeout 1500spark.ui.acls.enable truespark.ui.view.acls root,hadoop#each executor used max memoryspark.executor.memory 400m#spark on yarnspark.yarn.applicationMaster.waitTries 5spark.yarn.submit.file.replication 3spark.yarn.preserve.staging.files falsespark.yarn.scheduler.heartbeat.interval-ms 5000#park standalone and on mesosspark.cores.max 4

    8 Spark SQL
    Spark支持Scala、Python等语言写的脚本直接在Spark环境执行,更重要的是支持对Hive语句进行包装后在Spark上运行。这就是Spark SQL。
    8.1 相关配置
    配置的步骤比较简单,把Hive的配置文件hive-site.xml直接放置到$SPARK_HOME的conf路径下即可。如果是想在Spark集群本地执行SQL的话,每个对应的节点都要做同样的配置。
    8.2 运行SQL
    启动bin目录下的spark-shell脚本,依次执行如下语句:

    val sc: SparkContextval hiveContext = new org.apache.spark.sql.hive.HiveContext(sc)import hiveContext._hql("CREATE TABLE IF NOT EXISTS src (key INT, value STRING)")hql("LOAD DATA LOCAL INPATH '/examples /data.txt' INTO TABLE src")hql("FROM src SELECT key, value").collect().foreach(println)

    上面的命令,分别是声明SparkContext对象,利用hql方法执行Hive的SQL语句,在执行SQL语句的过程中,可以通过Hive的Cli客户端进行查看相应操作的结果。
    8.3 on yarn模式
    由于spark-shell脚本是在本地执行的,如果想放到Yarn上去执行的话,可以使用上面第4节中的spark-submit工具,这时候需要对需要输入的sql语句进行包装,将包装类打包成jar文件,再提交。

    包装类的代码如下:

    1 package spark; 2 3 import java.util.List; 4 5 import org.apache.spark.SparkConf; 6 import org.apache.spark.api.java.JavaSparkContext; 7 import org.apache.spark.sql.api.java.Row; 8 import org.apache.spark.sql.hive.api.java.JavaHiveContext; 9 10 /**11 * Description:12 * Author: ITScott@163.com13 * Date: 2014/7/1514 */15 public class SparkSQL {16 17 public static void main(String[] args) {18 if(args.length != 2){19 System.out.println("usage: <applicationName> <sql statments>");20 System.exit(1);21 }22 23 String applicationName = args[0];24 String sql = args[1];25 26 SparkConf conf = new SparkConf().setAppName(applicationName);27 JavaSparkContext sc = new JavaSparkContext(conf);28 JavaHiveContext hiveContext = new JavaHiveContext(sc);29 List<Row> results = hiveContext.hql(sql).collect();30 31 System.out.println("Sql is:" + sql + ", has been executed over.");32 System.out.println("The result size is " + results.size() + ", they are:");33 for(int i=0; i<results.size(); i++){34 System.out.println(results.get(i).toString());35 }36 37 System.out.println("Execute over ...");38 sc.stop();39 System.out.println("Stop over ...");40 }41 42 }

    将其打包成jar文件spark-0.0.1-SNAPSHOT.jar,再使用spark-submit工具进行任务的提交,命令如下:

    ./spark-submit \--class spark.SparkSQL \--master yarn-cluster \--num-executors 3 \--driver-memory 400m --executor-memory 400m --executor-cores 1 \--jars /home/hadoop/spark-1.0.0/examples/libs/spark-core_2.10-1.0.0.jar,/home/hadoop/spark-1.0.0/examples/libs/spark-hive_2.10-1.0.0.jar,/home/hadoop/spark-1.0.0/lib_managed/jars/datanucleus-api-jdo-3.2.1.jar,/home/hadoop/spark-1.0.0/lib_managed/jars/datanucleus-core-3.2.2.jar,/home/hadoop/spark-1.0.0/lib_managed/jars/datanucleus-rdbms-3.2.1.jar,/home/hadoop/hive-0.12.0/lib/mysql-connector-java-5.1.27-bin.jar--files /home/hadoop/spark-1.0.0/conf/hive-site.xml \/home/hadoop/spark-1.0.0/examples/libs/spark-0.0.1-SNAPSHOT.jar "hiveTest" "CREATE TABLE IF NOT EXISTS test4 (key INT, value STRING)"

    其中,--master参数指定的是yarn-cluster模式,当然也可以使用yarn-client模式,至于区别,已经在上文说了;--class指定的是我们包装类的主类,见上文源码;--jars是依赖的四个jar包;--files是指定的hive-site.xml配置文件,提交到Yarn中的Application在执行的时候,需要把此配置文件分发到每个Executor上;最后的两个参数,一个是Application的名称,一个是运行的SQL语句。

    运行结束后,可以到Spark HistoryServer中查看运行结果。
    展开全文
  • spark-submit 命令使用详解

    千次阅读 2019-09-06 20:37:35
    spark-submit 命令使用详解 spark-submit 用户打包 Spark 应用程序并部署到 Spark 支持的集群管理气上,...app arguments 是传递给应用程序的参数,常用命令行参数如下所示: –master: 设置主节点 URL 的参数...
  • Spark程序开发规范

    千次阅读 2018-01-29 15:52:44
    这是通过命令行传入参数的友好性提示和规范编码就体现出来了,下面我将整理【Scala语言开发Spark程序的常用模板】 package spark.sparkSQL object SparkSQLTwitter { def main(args: Array[String]) {
  • 77.SparkSQL中提供的spark-sql命令行的使用 78.SparkSQL中ThriftServer配置使用详解 79.SparkSQL性能优化及DataFrame是什么 80.SparkSQL读取多种数据数据实例 81.DataFrame实现多数据源数据的关联分析 82....
  • 通常我们是在控制台输入命令:spark-sql进入命令行界面:这是大多数人最喜欢用的,也最熟悉的界面。除了这种方式,还可以借助第三方的客户端来接入Spark SQL,常用的windows下图形客户端有:SQuirreL SQL Client、...
  • 大数据 常用框架特点

    2017-12-29 11:46:00
    一、大数据框架: Impala:hadoop的sql平台、支持hbase/hdfs、支持超大数据、支持多并发、sql支持好、对内存依赖比较严重。需要自己优化,并且有的语句超过内存会报错。...提供scala/python代码命令行运行、超大...
  • 进入到/export/server/spark-2.3.0-bin-hadoop2.7/bin目录中 执行以下命令:./beeline 输入:!connect jdbc:hive2://node1:10000,回车 输入用户名:root 直接回车,即可使用命令行连接到Hive,然后就可以执行HQL了...
  • 1. 运行pyspark

    千次阅读 2019-01-07 22:22:55
    3. spark standalone运行spark (集群不常用) 在没有hadoop的情况下实现多台计算机并行计算,需要配置,不介绍   安装好spark后 在终端输入pyspark可以进入shell命令行,(此时就是本地模式) 就可以输入...
  • 3. Spark 搭建 过 1.1 搭建伪分布式2.0.1 ok2016-10-23 耗时 2h ref [0006] Spark 2.0.1 伪分布式搭建练手 后续: 1.2 分布式搭建 notok ... 1.1 常用功能使用 ok 2016-10-23 耗时 0.5...
  • 文章目录第1章 Spark SQL概述1.1 什么是Spark SQL1.2 RDD vs DataFrames vs DataSet1.2.1 RDD1.2.2 Dataframe1.2.3 Dataset1.2.4 三者的共性1.2.5 三者的区别第2章 执行SparkSQL查询2.1 命令行查询流程2.2 IDEA创建...
  • Maven的一些技巧

    2016-04-08 13:56:54
    本文主要收集一些 Maven 的使用技巧,包括 Maven 常见命令、创建多模块项目、上传本地 jar 到插件以及常用的插件等等,本篇文章会保持不停的更新。 命令行创建 maven 项目: $ mvn archetype:generate -DgroupId=...
  • when.py:提供用户友好的函数来帮助用户进行常用的日期和时间操作。 dateutil:Python 标准包 datetime 的扩展。 moment:一个处理日期/时间的库,灵感来自 Moment.js。 pytz:支持跨平台时区计算,并将 tz ...
  • 我阅读《Spark: The Definitive Guide Big Data Processing Made Simple》(Spark权威指南)的笔记和心得: github上 Spark-The-Definitive-Guide-Learning 更好的阅读体验,同步于掘金 推荐一个国外的 Big Data...
  • developerWorks 中国 - Spark 实战系列.epub DevOps的概念与实践(2014年).epub Docker —— 从入门到实践.epub Docker中文指南.epub Docker周报.epub Docker在PHP项目开发环境中的应用.epub Docker源码分析.epub ...
  • developerWorks 中国 - Spark 实战系列.epub DevOps的概念与实践(2014年).epub Docker —— 从入门到实践.epub Docker中文指南.epub Docker周报.epub Docker在PHP项目开发环境中的应用.epub Docker源码分析.epub ...
  • 短小精悍之 Redis 命令行工具有趣的罕见用法 布隆过滤器实战【防止缓存击穿】 布隆过滤器过时了,未来属于布谷鸟过滤器? 什么鬼,面试官竟然让敖丙用Redis实现一个消息队列!!? Redis—分布式锁深入探究 Redis—...
  • technology-talk : 汇总 java 生态圈常用技术框架、开源中间件,系统架构、数据库、大公司架构案例、常用三方类库、项目管理、线上问题排查、个人成长、思考等知识 tutorials:该项目是一系列小而专注的教程 - 每个...

空空如也

空空如也

1 2
收藏数 21
精华内容 8
关键字:

常用spark命令行