spark安装和使用

local模式

概述

local模式就是在一台计算机上运行spark程序，通常用于在本机上练手和测试，它将线程映射为worker。

1）local: 所有计算都运行在一个线程当中，没有任何并行计算，通常我们在本机执行一些测试代码，或者练手，就用这种模式;

2）local[K]: 指定使用几个线程来运行计算，比如local[4]就是运行4个Worker线程。通常我们的Cpu有几个Core，就指定几个线程，最大化利用Cpu的计算能力;

3）local[*]: 这种模式直接帮你按照Cpu最多Cores来设置线程数了。

安装使用

1）上传并解压spark安装包

tar -zxvf spark-2.1.1-bin-hadoop2.7.tgz -C /opt/module/

2） 官方求PI案例

bin/spark-submit \

--class org.apache.spark.examples.SparkPi \

--executor-memory 1G \

--total-executor-cores 2 \

./examples/jars/spark-examples_2.11-2.1.1.jar \

100

该算法是利用蒙特·卡罗算法求PI，结果如下：

standalone模式

构建一个由Master+Slave构成的Spark集群，采用Spark原生的资源管理器，Spark运行在集群中。

Yarn模式

概述：

Spark客户端直接连接Yarn，不需要额外构建Spark集群。有yarn-client和yarn-cluster两种模式，主要区别在于：Driver程序的运行节点。

yarn-client：主程序逻辑运行在本地，任务运行在Yarn集群中

yarn-cluster：APPMaster；主程序逻辑和任务都运行在Yarn集群中。适用于生产环境。

安装使用：

1）修改hadoop配置文件yarn-site.xml,添加如下内容：

 <!--是否启动一个线程检查每个任务正使用的物理内存量，如果任务超出分配值，则直接将其杀掉，默认是true -->
        <property>
                <name>yarn.nodemanager.pmem-check-enabled</name>
 <value>false</value>
        </property>
        <!--是否启动一个线程检查每个任务正使用的虚内存量，如果任务超出分配值，则直接将其杀掉，默认是true -->
        <property>
                <name>yarn.nodemanager.vmem-check-enabled</name>
                <value>false</value>
        </property>

2）分发配置文件

xsync /opt/module/hadoop-2.7.2/etc/hadoop/yarn-site.xml

3）修改spark-env.sh，添加如下配置：

YARN_CONF_DIR=/opt/module/hadoop-2.7.2/etc/hadoop

4）执行一个程序

$ bin/spark-submit \
--class org.apache.spark.examples.SparkPi \
--master yarn \
--deploy-mode client \
./examples/jars/spark-examples_2.11-2.1.1.jar \
100

注意：

1.运行程序之前要确保hdfs和yarn已经正常启动

2.修改yarn的配置文件之后要重启yarn以让配置文件生效

3.在yarn模式下，是否需要在所有的结点都部属spark程序包？不需要，因为是运行在yarn上，资源管理和调度是由yarn负责的。只需要在其中一个结点提供部署spark的jar包，并通过driver提交作业到yarn集群。

spark-shell

启动spark-shell的正确姿势是：进入到spark的底层目录，输入bin/spark-shell

关闭spark-shell的正确姿势是：:quit,注意冒号

其部分参数如下（非常类似于下文的spark-submit，均可通过--help参数来获取）：

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).

spark-submit

基本语法：
bin/spark-submit \
--class <main-class>
--master <master-url> \
--deploy-mode <deploy-mode> \
--conf <key>=<value> \
... # other options
<application-jar> \
[application-arguments]

\是分隔符；

--表示这个选项是可有可无，而且顺序是可变换的

--master 指定Master的地址，默认为Local。

如果是yarn模式，则是yarn

如果是standalone模式，则是spark://master:port

如果是local模式，则是local,local[n](n表示核数)，local[*](*表示按照cpu核数来设定线程数)

--class: 你的应用的启动类 (如 org.apache.spark.examples.SparkPi)

--deploy-mode: 是否发布你的驱动到worker节点(cluster) 或者作为一个本地客户端 (client) (default: client)*

--conf: 任意的Spark配置属性， 格式key=value. 如果值包含空格，可以加引号“key=value”

application-jar: 打包好的应用jar,包含依赖. 这个URL在集群中全局可见。 比如hdfs:// 共享存储系统， 如果是 file:// path， 那么所有的节点的path都包含同样的jar

application-arguments: 传给main()方法的参数

--executor-memory 1G 指定每个executor可用内存为1G

--total-executor-cores 2 指定每个executor使用的cup核数为2个

利用idea开发spark程序

Spark Shell仅在测试和验证我们的程序时使用的较多，在生产环境中，通常会在IDE中编制程序，然后打成jar包，然后提交到集群，最常用的是创建一个Maven项目，利用Maven来管理jar包的依赖。

1) 创建一个Maven项目WordCount并导入依赖

<dependencies>
    <dependency>
        <groupId>org.apache.spark</groupId>
        <artifactId>spark-core_2.11</artifactId>
<version>2.1.1</version>
    </dependency>
</dependencies>
<build>
        <finalName>WordCount</finalName>
        <plugins>
<plugin>
                <groupId>net.alchim31.maven</groupId>
<artifactId>scala-maven-plugin</artifactId>
                <version>3.2.2</version>
                <executions>
                    <execution>
                       <goals>
                          <goal>compile</goal>
                          <goal>testCompile</goal>
                       </goals>
                    </execution>
                 </executions>
            </plugin>
        </plugins>
</build>

2）编写代码

package com.atguigu

import org.apache.spark.{SparkConf, SparkContext}

object WordCount{

  def main(args: Array[String]): Unit = {

//1.创建SparkConf并设置App名称
    val conf = new SparkConf().setAppName("WC")

//2.创建SparkContext，该对象是提交Spark App的入口
    val sc = new SparkContext(conf)

    //3.使用sc创建RDD并执行相应的transformation和action
    sc.textFile(args(0)).flatMap(_.split(" ")).map((_, 1)).reduceByKey(_+_, 1).sortBy(_._2, false).saveAsTextFile(args(1))

//4.关闭连接
    sc.stop()
  }
}

3）打包插件

              <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-assembly-plugin</artifactId>
                <version>3.0.0</version>
                <configuration>
                    <archive>
                    <manifest>
                            <mainClass>Hello</mainClass>
                        </manifest>
                    </archive>
                    <descriptorRefs>
                        <descriptorRef>jar-with-dependencies</descriptorRef>
                    </descriptorRefs>
                </configuration>
                <executions>
                    <execution>
                        <id>make-assembly</id>
                        <phase>package</phase>
                        <goals>
                            <goal>single</goal>
                        </goals>
                    </execution>
                </executions>
      </plugin>

4）打包到集群测试

bin/spark-submit \
--class WordCount \
--master spark://hadoop102:7077 \
WordCount.jar \
/word.txt \
/out