Spark（一）————Spark介绍以及集群搭建

1、Spark的特点

快如闪电的集群计算。大规模快速通用的计算引擎。
速度比hadoop 100x,磁盘计算快10x。
能使用java / Scala /R /python进行开发，提供80+算子(操作符)，容易构建并行应用。
基于hadoop的mr，扩展MR模型高效使用MR模型，内存型集群计算，提高app处理速度。因为它是在内存中存储中间结果。
通用架构：组合SQL ，流计算 + 复杂分析。
运行模式：yarn, Mesos, standalone, or in the cloud,local.

1.local         //本地模式
2.standalone    //独立模式
3.yarn          //yarn模式
4.mesos         //mesos

Spark模块：

----------------
Spark core      //核心模块,通用执行引擎，提供内存计算和对外部数据集的引用。
Spark SQL       //SQL,构建在core之上，引入新的抽象SchemaRDD，提供了结构化和半结构化支持。
Spark Streaming //流计算,小批量计算，RDD.
Spark MLlib     //机器学习
Spark graph     //图计算

DAG         //direct acycle graph,有向无环图。

2、安装Spark（单机模式）

1.下载spark-2.1.0-bin-hadoop2.7.tgz

2.解压

3.环境变量
[/etc/profile]
SPARK_HOME=/soft/spark
PATH=$PATH:$SPARK_HOME/bin:$SPARK_HOME/sbin

[source]
$>source /etc/profile

4.验证spark
$>cd /soft/spark
$>./spark-shell

5.webui
http://s201:4040/

3、API

[SparkContext]
Spark程序的入口点，封装了整个spark运行环境的信息。代表到Spark集群的连接，可以创建RDD、累加器和广播变量.每个JVM只能激活一个SparkContext对象，在创建sc之前需要stop掉active的sc。
[RDD]
resilient distributed dataset,弹性分布式数据集。等价于集合。
[SparkConf]
spark配置对象，设置Spark应用各种参数，kv形式。

Spark实现word count
编写scala程序，引入spark类库，完成wordcount
1.创建Scala模块,并添加pom.xml

<?xml version="1.0" encoding="UTF-8"?>
        <project xmlns="http://maven.apache.org/POM/4.0.0"
                 xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
                 xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
            <modelVersion>4.0.0</modelVersion>

            <groupId>com.it18zhang</groupId>
            <artifactId>SparkDemo1</artifactId>
            <version>1.0-SNAPSHOT</version>
            <dependencies>
                <dependency>
                    <groupId>org.apache.spark</groupId>
                    <artifactId>spark-core_2.11</artifactId>
                    <version>2.1.0</version>
                </dependency>
            </dependencies>
        </project>

添加针对scala文件的编译插件

<?xml version="1.0" encoding="UTF-8"?>
    <project xmlns="http://maven.apache.org/POM/4.0.0"
             xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
             xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
        <modelVersion>4.0.0</modelVersion>

        <groupId>com.it18zhang</groupId>
        <artifactId>SparkDemo1</artifactId>
        <version>1.0-SNAPSHOT</version>
        <build>
            <plugins>
                <plugin>
                    <groupId>net.alchim31.maven</groupId>
                    <artifactId>scala-maven-plugin</artifactId>
                    <version>3.2.2</version>
                    <configuration>
                        <recompileMode>incremental</recompileMode>
                    </configuration>
                    <executions>
                        <execution>
                            <goals>
                                <goal>compile</goal>
                                <goal>testCompile</goal>
                            </goals>
                        </execution>
                    </executions>
                </plugin>
            </plugins>
        </build>
</project>

2.编写scala文件

package cn.ctgu.WordCountDemo

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

object WordCountDemo{
  def main(args: Array[String]): Unit = {
    //创建Spark配置对象
    val conf = new SparkConf();
    conf.setAppName("WordCountSpark");
    //设置master属性
    conf.setMaster("local") ;

    //通过conf创建sc
    val sc = new SparkContext(conf);

    //加载文本文件
    val rdd1 = sc.textFile("F:\\comp\\test.txt");
    //压扁
    val rdd2 = rdd1.flatMap(line => line.split(" ")) ;
    //映射w => (w,1)
    val rdd3 = rdd2.map((_,1))
    val rdd4 = rdd3.reduceByKey(_ + _)
    val r = rdd4.collect()
    r.foreach(println)

  }
}

3.java版单词统计

package cn.ctgu.WordCountDemo;

import org.apache.spark.SparkConf;
import org.apache.spark.api.java.JavaPairRDD;
import org.apache.spark.api.java.JavaRDD;
import org.apache.spark.api.java.JavaSparkContext;
import org.apache.spark.api.java.function.FlatMapFunction;
import org.apache.spark.api.java.function.Function2;
import org.apache.spark.api.java.function.PairFunction;
import scala.Tuple2;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

public class WordCountJava2 {
    public static void main(String[] args) {
        //创建SparkConf对象
        SparkConf conf=new SparkConf();
       /* conf.setAppName("WordCountJava2");
        conf.setMaster("local");*/

        //创建java sc
        JavaSparkContext sc=new JavaSparkContext(conf);
        //加载文本文件
        JavaRDD<String>rdd1=sc.textFile(args[0]);
        //压扁
        JavaRDD<String>rdd2=rdd1.flatMap(new FlatMapFunction<String, String>() {

            public Iterator<String> call(String s) throws Exception {
                List<String> list=new ArrayList<String>();
                String[]arr=s.split(" ");
                for(String ss:arr){
                    list.add(ss);
                }
                return list.iterator();
            }
        });
        //映射，word->(word,1)
        JavaPairRDD<String,Integer>rdd3=rdd2.mapToPair(new PairFunction<String, String, Integer>() {

            public Tuple2<String, Integer> call(String s) throws Exception {
                return new Tuple2<String, Integer>(s,1);
            }
        });
        //reduce化简
        JavaPairRDD<String,Integer>rdd4=rdd3.reduceByKey(new Function2<Integer, Integer, Integer>() {
            public Integer call(Integer v1, Integer v2) throws Exception {
                return v1+v2;
            }
        });
        //聚合
        List<Tuple2<String,Integer>>list=rdd4.collect();
        for(Tuple2<String,Integer>t:list){
            System.out.println(t._1()+":"+t._2());
        }

    }
}

4.提交作业到spark集群运行

1.导出jar包
    2.spark-submit提交命令运行job
        //Scala版本
        $>spark-submit --master local --name MyWordCount --class cn.ctgu.cn.ctgu.WordCountDemo SparkDemo1-1.0-SNAPSHOT.jar /home/hadoop/test.txt
        //java版
        $>spark-submit --master local --name MyWordCount --class cn.ctgu.WordCountDemo.WordCountJava SparkDemo1-1.0-SNAPSHOT.jar /home/hadoop/test.txt

4、Spark集群模式搭建（standalone）

standalone模式搭建

a)复制spark目录到其他主机

b)配置其他主机的所有环境变量
[/etc/profile]
export SPARK_HOME=/home/hadoop/soft/spark
export PATH=$PATH:$SPARK_HOME/bin:$SPARK_HOME/sbin

c)配置master节点的slaves
[/soft/spark/conf/slaves]
s202
s203
s204

d)启动spark集群
/soft/spark/sbin/start-all.sh

e)查看进程
$>xcall.jps jps
master      //s201
worker      //s202
worker      //s203
worker      //s204

f)webui
http://s201:8080/

提交作业jar到完全分布式spark集群

1.需要启动hadoop集群(只需要hdfs)

$>start-dfs.sh

2.put文件到hdfs

3.运行spark-submit

$>spark-submit 
                    --master spark://s201:7077 
                    --name MyWordCount 
                    --class cn.ctgu.WordCountDemo.WordCountScala 
                    SparkDemo1-1.0-SNAPSHOT.jar 
                    hdfs://s201:8020/home/hadoop/test.txt

脚本分析

[start-all.sh]其实就是执行以下三个脚本
sbin/spark-config.sh
sbin/spark-master.sh        //启动master进程
sbin/spark-slaves.sh        //启动worker进程

[start-master.sh]就是启动主节点
sbin/spark-config.sh
org.apache.spark.deploy.master.Master   //主节点
spark-daemon.sh start org.apache.spark.deploy.master.Master --host --port --webui-port ...

[spark-slaves.sh]启动子节点
sbin/spark-config.sh
slaves.sh               //conf/slaves

$>cd /soft/spark/sbin
$>./stop-all.sh                //停掉整个spark集群.
$>./start-master.sh            //启动master节点,RPC端口 7077
$>./start-slaves.sh            //启动所有worker节点

//webui
独立模式：http://s201:8080
本地模式：http://s201:4040

5、spark集成hadoop ha

1.复制core-site.xml + hdfs-site.xml到spark/conf目录下
2.分发文件到spark所有work节点
3.启动spark集群
4.启动spark-shell,连接spark集群上
$>spark-shell --master spark://s201:7077

Spark（一）————Spark介绍以及集群搭建

猜你喜欢