[大数据]连载No7之Spark集群搭建+提交应用到集群

Spark官网地址：http://spark.apache.org/downloads.html

本次总结截图：

Spark集群客户端搭建
环境说明：master节点： 192.168.0.150（master）

                  从节点    ： 192.168.0.151(node1)，192.168.0.152(node2)

1：下载spark安装包 spark-1.6.0-bin-hadoop2.6.tgz
2：tar zxvf spark-1.6.0-bin-hadoop2.6.tgz  并且重命名 mv spark-1.6.0-bin-hadoop2.6 spark-1.6.0
3: 配置slaves
   mv conf/slaves.template slaves 配置从节点 node1,node2
4：配置spark
   mv spark-env.sh.template  spark-env.sh
   export JAVA_HOME=/home/softs/jdk1.7.0_51
   export SPARK_MASTER_IP=master #主节点就是maste
   export SPARK_MASTER_POR=7077  #提交application端口
   export SPARK_WORKER_MEMORY=2g #每个Worker节点管理2G内存，注意：不是每一个worker节点使用2G内存
   export SPARK_WORKER_CORES=3 #每个Worker节点管理3个核，注意：不是每一个worker节点使用3个核
5: 修改 mv /sbin/start-all.sh start-spark-all.sh
       mv /sbin/stop-all.sh stop-spark-all.sh
       source ~/.bash_profile
6：将安装包复制到其他节点  scp -r ./spark-1.6.0 node1[node2]:`pwd`       
7:启动spark集群 start-spark-all.sh  
8:使用浏览器访问8080，查看集群情况
9:上传jar cp 01-spark.jar /home/softs/spark-1.6.0/lib/     
10:提交Application命令 
[root@master lib]# spark-submit --master spark://master:7077 --class com.sxt.FilterCountOperator ./01-spark.jar 

代码如下

/**
  * 代码案例-过滤单词出现次数最多
  */
object FilterCountOperator {

  def main(args: Array[String]): Unit = {
    //创建Spark运行时的配置对象，在配置对象里面可以设置APP name，集群URL以及运行时各种资源需求
    val sparkConf = new SparkConf()
      .setAppName("FilterCountOperator")
    //.setMaster("local")

    //创建SparkContext上下文环境，通过传入配置对象实例化一个SparkContext
    val sc = new SparkContext(sparkConf)

    /**
      * RDD1中的数据：
      * 1  JAVA
      * 2  C++
      * 3  SPARK
      */
    val rdd1 = sc.textFile("hdfs://master:9000/sxt/input/log")

    /**
      * samples算子：Transformation类算子
      * 第一个参数:抽样的方式  true有返回的抽样
      * 第二个参数：抽样比例
      * 第三个参数：抽样算法的初始值
      */
    val sampleRDD = rdd1.sample(true, 0.9)
    val rdd2 = sampleRDD.map {
      _.split("\t")(1)
    }

    /**
      * 将每一个单词   计数为1
      * rdd3就是一个KV格式的RDD
      * K：单词  V：1
      */
    val rdd3 = rdd2.map((_, 1))

    /**
      * 统计每一个单词出现的次数
      * 单词 [1,1,1,1,1,1]
      */
    val rdd4 = rdd3.reduceByKey((v1: Int, v2: Int) => v1 + v2)

    /**
      * sortBy x=>x._2  代表根据value来降序排序
      */
    val rdd6 = rdd4.sortBy((x: (String, Int)) => x._2, false)

    /**
      * 对rdd4中KV的位置颠倒过来
      * (schoolName,count)
      * rdd5
      * (count,schoolName)
      */
    //     val rdd5 = rdd4.map(x=>{
           (x._2,x._1)
    //         x.swap
    //     })
    //
    //     /**
    //      * 对RDD5中的count进行排序
    //      * ascending: Boolean   default：True
    //      * sortByKey：Transformation类算子
    //      *
    //      * rdd6:
    //      *  (count,schoolName)
    //      */
    //     val rdd6 = rdd5.sortByKey(false)

    /**
      * 取出来RDD6中第一个元素，第一个元素就是出现次数最多的那个学校
      * Array[(Int, String)]
      * take:Action类算子
      * arr这个数组中只有1条记录   并且这一条记录是二元组类型的！！！
      */
    val arr = rdd6.take(1)
    val schoolName = arr(0)._1

    println("schoolName:" + schoolName)

    /**
      * 出现次数最多的这个学校名有了，对rdd1进行过滤，在过滤的时候得依据schoolName
      */
    val resultRDD = rdd1.filter { x => {
      !schoolName.equals(x.split("\t")(1))
    }
    }

    /*
     * "result"是一个相对路径
     * saveAsTextFile:transformation类算子
     */
    //resultRDD.saveAsTextFile("result")
    resultRDD.saveAsTextFile("hdfs://master:9000/result")


    sc.stop()
  }

}

访问spark webUI http://master:8080/

输出结果到HDFS