精华内容
下载资源
问答
  • 在本博客中,总结了如何在前一篇博客在Windows 7利用Vmware Workstation搭建Ubuntu kylin 14.04的hadoop集群成功的基础,安装Scala,部署Spark,配置Spark搭建Spark集群的详细步骤。

            前一篇博客总结了如何在Windows 7上利用Vmware Workstation搭建Ubuntu kylin 14.04的hadoop集群。Hadoop集群搭建成功,距离Spark集群就只有一步之遥了。因为Spark框架本身就可以建立在Hadoop的hdfs基础之上。

            搭建Spark集群,首先要安装Scala,因为Spark本身就是使用Scala语言开发的。不同的Spark 包,使用的Scala语言版本可能有所差异。而同一个Spark版本,可能因为打包时基于的hadoop版本不同,而又有不同的版本,例如在Spark的Apache官网上,当选择Spark 1.6.3版本时,打包的Hadoop版本有2.3,2.4和2.6三个:

                选择最新的Spark2.2版本,使用的Hadoop版本有2.7及以后和2.6两种:

               

                所以前面搭建hadoop集群时,选择的hadoop版本是2.7.4,而不是其它更新的版本,就是为了与这个Spark的package中的hadoop版本相兼容。

                同样,不同Spark版本使用的Scala语言版本有有所差异,可以在Spark package下载后从其jars目录中包含的scala的相关包的版本看出来,也可以根据Spark官网的指示,如上图所说,从Spark 2.0开始,Spark is built with Scala 2.11 by default:

             

             所以,选择安装的Scala版本为2.11.11。

             首先,在SparkMaster完成Scala语言的安装。下载Scala-2.11.11.tgz,解压后部署到/usr/lib/scala目录,并修改~/.bashrc配置文件,添加SCALA_HOME变量,并把${SCALA_HOME}/bin加入到PATH中。安装完成之后,命令终端输入scala -version,应正确显示scala的版本:

           

            接下来安装Spark,下载Spark-2.2.0-bin-hadoop2.7.tgz,解压后部署安装到/usr/local/scala目录,并修改~/.bashrc配置文件,增加SPARK_HOME环境变量,并把

    ${SPARK_HOME}/bin加入到PATH中。然后配置Spark,进入 ${SPARK_HOME}/conf  目录:

          

           修改spark-env.sh.template,加入JAVA_HOME,SPARK_HOME,SPARK_MASTER_IP,SPARK_WORKER_MEMORY和HADOOP_CONF_DIR五个环境变量,另存为spark-env.sh:

          

          然后修改slaves.template,加入SparkMaster,SparkWorker1和SparkWorker2,配置集群总共有三个worker节点,另存为slaves:

         

          SparkMaster配置完成后,可以用scp命令把Scala和Spark的安装部署文件直接传输到SparkWorker1和SparkWorker2:

          scp -r /usr/lib/scala root@SparkWorker1:/usr/lib/scala

          scp -r /usr/local/spark root@SparkWorker2:/usr/local/spark

          传输完成后,登录SparkWorker1检查,Scala和Spark文件夹都已成功复制过去:

         

          同样修改SparkWorker1的配置文件~/.bashrc,增加环境变量及修改PATH,然后命令行输入scala -version,验证Scala 版本,输入Scala,进入scala REPL,输入5*5,检查Scala及Spark复制安装正确:

         

          同样可以用scp命令从SparkMaster复制Scala和Spark的安装部署到SparkWorker2,并修改配置文件,验证Scala及Spark安装配置正确。

          接下来就可以启动Spark集群了。首先要启动Hadoop集群。到${HADOOP_HOME}/sbin目录下,,/start-all.sh即可启动Hadoop集群。

          hadoop集群启动完成后,在SparkMaster上,jps可以查看到启动的进程,有NameNode和DataNode: 

             

             而在SparkWorker1和SparkWorker2上,则只有DataNode的进程:

             

              Hadoop集群成功启动后,转到${SPARK_HOME}/sbin目录,执行./start-all.sh,启动Spark集群。启动成功后,在SparkMaster上,会多了一个Worker进程:

             

              同样,在SparkWorker1和SparkWorker2上,也出现了Spark的Worker进程,表明Spark集群启动成功:

              

              也可以到Spark集群的Web界面去查看相应的Spark集群信息,网址为http://SparkMaster:8080:

             

              可以看到,Spark集群成功启动,共有三个Worker。

              还可以在SparkMaster上启动Spark Shell,转到${SPARK_HOME}/bin,执行spark-shell:

    这时可以从Spark Shell的Web UI中获取更多Spark Job和Spark Environment的信息,访问地址为:http://SparkMaster:4040

            

         

         


    
    
    
    
    展开全文
  • 参考大佬文章 ... 说前面 以下实验过程都是使用docker搭建spark集群的前提条件下进行,如果你的spark集群还没有搭建成功,可以参考我的一篇博客 https://blog.csdn.net/weixin_45548774/article/d

    参考大佬文章

    https://blog.csdn.net/weixin_43622131/article/details/110565692
    https://blog.csdn.net/weixin_43622131/article/details/110621405

    说在前面

    以下实验过程都是在使用docker搭建好spark集群的前提条件下进行,如果你的spark集群还没有搭建成功,可以参考我的上一篇博客

    https://blog.csdn.net/weixin_45548774/article/details/110206515

    下面是正式的实验内容

    启动spark集群

    1本机启动集群do

    直接运行

    spark-shell
    

    或者进入spark安装目录,打开spark-shell
    在这里插入图片描述
    在这里插入图片描述

    2通过yarn启动spark集群

    使用命令

    spark-shell --master yarn
    

    或者

    spark-shell --master yarn-client
    

    这期间可能会遇到如下问题:

    1 Name node is in safe mode.

    这是因为在分布式文件系统启动的时候,开始的时候会有安全模式,当分布式文件系统处于安全模式的情况下,文件系统中的内容不允许修改也不允许删除,直到安全模式结束。安全模式主要是为了系统启动的时候检查各个DataNode上数据块的有效性,同时根据策略必要的复制或者删除部分数据块。运行期通过命令也可以进入安全模式。
    在这里插入图片描述

    通过以下命令来解决:

    hadoop dfsadmin -safemode leave
    

    2

    在这里插入图片描述

    出现这个问题可以

    参考博客

    https://www.cnblogs.com/yy3b2007com/p/9247621.html

    上面说的很清楚

    确保集群可以正常启动后就可以开始进入正题了!!!

    Windows中使用IDEA写程序,手动生成jar包,手动提交到docker搭建的spark集群上运行

    配置IDEA的环境

    1 下载IDEA

    这里给出官网链接https://www.jetbrains.com/idea/download/#section=windows

    下载后安装即可

    2 在IDEA中下载scala

    在这里插入图片描述
    在这里插入图片描述

    3 在IDEA中创建scala工程

    在这里插入图片描述

    填写信息

    在这里插入图片描述

    标红的地方可以自己修改,其他不变即可,点击finish

    新建scala文件夹,并设置为源目录

    在这里插入图片描述

    右键scala

    在这里插入图片描述

    4 导入scala环境

    点击File中的Project Structure,进入到下图页面,添加scala的SDK,可以从下面链接中下载

    链接:https://pan.baidu.com/s/11DYs4lS-wZjtnHRuFC9_DQ
    提取码:u18t

    下载后解压即可

    在这里插入图片描述

    点击Browse

    在这里插入图片描述

    在下载的文件中选择lib,点击ok即可

    在这里插入图片描述
    在这里插入图片描述

    5 编写pom文件

    <?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>org.example</groupId>
        <artifactId>untitled3</artifactId>
        <version>1.0-SNAPSHOT</version>
    
    
        <properties>
            <scala.version>2.11</scala.version>
            <hadoop.version>2.7.4</hadoop.version>
        </properties>
    
        <repositories>
            <repository>
                <id>scala-tools.org</id>
                <name>Scala-Tools Maven2 Repository</name>
                <url>http://scala-tools.org/repo-releases</url>
            </repository>
        </repositories>
    
        <dependencies>
            <dependency>
                <groupId>org.apache.spark</groupId>
                <artifactId>spark-core_2.10</artifactId>
                <version>1.6.0</version>
            </dependency>
            <dependency>
                <groupId>org.apache.spark</groupId>
                <artifactId>spark-sql_2.10</artifactId>
                <version>1.6.0</version>
            </dependency>
            <dependency>
                <groupId>org.apache.spark</groupId>
                <artifactId>spark-streaming_2.10</artifactId>
                <version>1.6.0</version>
            </dependency>
            <dependency>
                <groupId>org.apache.hadoop</groupId>
                <artifactId>hadoop-client</artifactId>
                <version>${hadoop.version}</version>
            </dependency>
            <dependency>
                <groupId>org.apache.hadoop</groupId>
                <artifactId>hadoop-common</artifactId>
                <version>${hadoop.version}</version>
            </dependency>
            <dependency>
                <groupId>org.apache.hadoop</groupId>
                <artifactId>hadoop-hdfs</artifactId>
                <version>${hadoop.version}</version>
            </dependency>
    
        </dependencies>
    
    </project>
    
    

    6 将spark源码里的jars包直接加到library中

    点击Modules然后点击添加

    在这里插入图片描述
    在这里插入图片描述

    将下载jars导入就可以了,jars可以在下面链接中下载

    链接:https://pan.baidu.com/s/1GFiIvteJu2m94GdjcYxViA
    提取码:kx8o

    在这里插入图片描述

    上传之后环境就基本配置完成了

    7 运行一个scala程序

    新建scala的class,

    在这里插入图片描述

    点击Object,输入名字

    在这里插入图片描述

    建成之后,运行第一个scala程序

    object Hello_World {
     def main(args: Array[String]) {
       println("hello")
     }
    }
    

    在这里插入图片描述

    打包scala程序

    进入这个

    在这里插入图片描述

    然后

    在这里插入图片描述

    在这里插入图片描述

    点击build
    在这里插入图片描述

    在这里插入图片描述

    产生对应jar包

    在这里插入图片描述

    至此就完成了通过IDEA手动生成jar包的过程

    手动提交到spark集群上执行

    首先将生成jar复制下来,通过下面这条命令传入到集群中

    docker cp C:\Users\Administrator\Desktop\untitled2.jar master:/opt
    

    之后启动spark集群,进入到/opt目录下

    使用如下命令运行jar包,Hello_World是主类的名称

    spark-submit --class Hello_World --master yarn untitled2.jar
    

    在这里插入图片描述

    至此就完成了整个的流程

    Windows中使用IDEA写程序,自动提交到docker搭建的spark集群上运行

    1 搭建IDEA环境,这里和上面的内容相同,不再赘述

    2 启动本机docker中的spark环境

    start-all.sh
    start-dfs.sh
    start-yarn.sh
    

    3 创建一个scala类,写入下面的示例代码

    
    
    /**
     * Created by zf on 12/3/20.
     */
    import scala.math.random
    
    import org.apache.spark._
    
    /** Computes an approximation to pi */
    object SparkPi2 {
      def main(args: Array[String]) {
        val conf = new SparkConf().setAppName("Spark Pi").set("spark.executor.memory", "512m")
          .set("spark.driver.host","10.0.75.1")//这个ip很重要,我因为这个ip没有设置正确卡了好长时间,我使用的是docker,这个ip就要设置为本机在docker分配的虚拟网卡中的ip地址,如果设置成其他网卡的ip会被主机拒绝访问
          .set("spark.driver.cores","1")
          .setMaster("spark://127.0.0.1:7077") //这里应设为master的ip加上配置spark时设置的端口,一般都为7077,头面的是windows本机的ip或者直接使用127.0.0.1
           .setJars(List("D:\\edge文件下载位置\\Neo4j-KGBuilder-master\\Neo4j-KGBuilder-master\\untitled\\untitled2\\out\\artifacts\\untitled2_jar\\untitled2.jar"))
    //这里是jar包存放的位置
        val spark = new SparkContext(conf)
        val slices = if (args.length > 0) args(0).toInt else 2
        val n = 100000 * slices
        val count = spark.parallelize(1 to n, slices).map { i =>
          val x = random * 2 - 1
          val y = random * 2 - 1
          if (x * x + y * y < 1) 1 else 0
        }.reduce(_ + _)
        println("Pi is roughly " + 4.0 * count / n)
        spark.stop()
      }
    }
    
    
    .set("spark.driver.host","10.0.75.1")
    

    这里的10.0.75.1可以在cmd中使用ipconfig在下面找到,注意必须是这个ip地址

    在这里插入图片描述

    4 极有可能出现的错误:

    1 如果出现spark运行报错:check your cluster UI to ensure that workers are registered and have sufficient resources,那证明你的spark集群上内存不够了,需要添加内存。

    找到spark-env.sh文件,查看配置,看看是不是内存容量设置的过小了,我最设置的是128m,过小导致运行出现了问题,后来改成了4G问题就解决了。

    注意master和slave节点都要检查!!!
    在这里插入图片描述

    2 修改代码之后,最后都rebuild一下

    在这里插入图片描述

    此时一定要rebulid一下
    在这里插入图片描述
    在这里插入图片描述

    都配置完成之后,运行程序就大功告成了

    5自动运行程序结果

    在这里插入图片描述

    RDD编程初级实践

    1 启动spark-shell

    2 据给定的实验数据,在spark-shell中通过编程来计算题目内容

    数据下载:

    链接:https://pan.baidu.com/s/1lDnee9CxLKU31Zu5gFoIzw
    提取码:6vzx

    首先将数据加载到master中,使用

    var rdd=sc.textFile("file:///usr/mydata/Data01.txt")
    

    将数据打印出,使用

    rdd.collect
    

    将数据打印出来查看

    在这里插入图片描述

    (1)该系总共有多少学生;(首先将数据按照“,”进行分割,由于一个学生可能选修多门课,所以还要对数据进行去重)

    在这里插入图片描述
    在这里插入图片描述

    (2)该系共开设来多少门课程;

    同第一问到的思路一样,取出课程进行去重处理之后进行统计即可。

    在这里插入图片描述

    (3)Tom同学的总成绩平均分是多少;

    在这里插入图片描述
    在这里插入图片描述

    (4)求每名同学的选修的课程门数;

    在这里插入图片描述
    在这里插入图片描述

    在这里插入图片描述

    (5)该系DataBase课程共有多少人选修;

    在这里插入图片描述

    (6)各门课程的平均分是多少;

    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述

    (7)使用累加器计算共有多少人选了DataBase这门课。

    在这里插入图片描述
    在这里插入图片描述

    3 应用程序实现数据去重

    对于两个输入文件A和B,编写Spark独立应用程序,对两个文件进行合并,并剔除其中重复的内容,得到一个新文件C。下面是输入文件和输出文件的一个样例,供参考。

    输入文件A的样例如下:

    20170101 x

    20170102 y

    20170103 x

    20170104 y

    20170105 z

    20170106 z

    输入文件B的样例如下:

    20170101 y

    20170102 y

    20170103 x

    20170104 z

    20170105 y

    根据输入的文件A和B合并得到的输出文件C的样例如下:

    20170101 x

    20170101 y

    20170102 y

    20170103 x

    20170104 y

    20170104 z

    20170105 y

    20170105 z

    20170106 z

    首先创建a.txt和b.txt,文件中输入上面对应的内容,最后将结果输入到文件C.txt中

    代码如下(这里使用自动运行的方式)

    import java.io.FileWriter
    import java.net.InetAddress
    
    import org.apache.spark._
    
    
    object first {
      def main(args: Array[String]) {
        val conf = new SparkConf().setAppName("first").set("spark.executor.memory", "512m")
          //      .set("spark.driver.host", "10.0.75.1")
          .set("spark.driver.cores", "2")
          .setMaster("local") //spark://127.0.0.1:7077
          .setJars(List("D:\\edge文件下载位置\\Neo4j-KGBuilder-master\\Neo4j-KGBuilder-master\\untitled\\untitled2\\out\\artifacts\\untitled2_jar\\untitled2.jar")) // maven打的jar包的路径
          .set("spark.driver.allowMultipleContexts", "true")
        //      .set("spark.driver.port","50516")
        val sc = new SparkContext(conf)
    
    
        // 读取文件A
        var A = sc.textFile("C:\\Users\\Administrator\\Desktop\\a.txt")
        // 读取文件B
        var B = sc.textFile("C:\\Users\\Administrator\\Desktop\\b.txt")
        // 对文件A和B进行整合并去重
        var C = (A ++ B).distinct
        var results = C.collect()
        // 将结果输出到C.txt中
        val out = new FileWriter("C:\\Users\\Administrator\\Desktop\\C.txt",true)
        for(item<-results){
          out.write(item+"\n")
          println(item)
        }
        out.close()
      }
    }
    

    运行结果

    在这里插入图片描述

    4 应用程序实现平均值问题

    每个输入文件表示班级学生某个学科的成绩,每行内容由两个字段组成,第一个是学生名字,第二个是学生的成绩;编写Spark独立应用程序求出所有学生的平均成绩,并输出到一个新文件中。下面是输入文件和输出文件的一个样例,供参考。

    Algorithm成绩:

    小明 92

    小红 87

    小新 82

    小丽 90

    Database成绩:

    小明 95

    小红 81

    小新 89

    小丽 85

    Python成绩:

    小明 82

    小红 83

    小新 94

    小丽 91

    平均成绩如下:

    ​ (小红,83.67)

    ​ (小新,88.33)

    ​ (小明,89.67)

    ​ (小丽,88.67)

    新建三个文件

    在这里插入图片描述

    将题目要求的数据输入到对应的文件夹中去(这里注意文件中的编码形式为utf-8)

    代码如下(采用自动运行的方式):

    import java.io.FileWriter
    import java.net.InetAddress
    
    import org.apache.spark._
    
    
    object first  {
      def main(args: Array[String]) {
        val conf = new SparkConf().setAppName("first").set("spark.executor.memory", "512m")
          //      .set("spark.driver.host", "10.0.75.1")
          .set("spark.driver.cores", "2")
          .setMaster("local") //spark://127.0.0.1:7077
          .setJars(List("D:\\edge文件下载位置\\Neo4j-KGBuilder-master\\Neo4j-KGBuilder-master\\untitled\\untitled2\\out\\artifacts\\untitled2_jar\\untitled2.jar")) // maven打的jar包的路径
          .set("spark.driver.allowMultipleContexts", "true")
        //      .set("spark.driver.port","50516")
        val sc = new SparkContext(conf)
    
    
        // 读取文件Algorithm.txt
        var A = sc.textFile("C:\\Users\\Administrator\\Desktop\\Algorithm.txt")
        // 读取文件Database.txt"
        var B = sc.textFile("C:\\Users\\Administrator\\Desktop\\Database.txt")
        // 读取文件Python.txt
        var C = sc.textFile("C:\\Users\\Administrator\\Desktop\\Python.txt")
        // 对三个文件进行整合
        var all = A ++ B ++ C
        print(all.collect)
        // // 将每个名字作为键,值为一个键值对,该键值对的键为成绩,值为1(用于后面计算平均值计数用)
        val student_grade = all.map(row=>(row.split(" ")(0),(row.split(" ")(1).toInt,1)))
        // 对上述RDD做聚合,值的聚合返回一个二元组,第一个元素是该学生所有课的成绩求和,第二个元素是该学生选修课的数目,然后再做一个映射
        // 将人名作为第一个元素,所有课的总成绩除以选修课程的数目得到该学生的平均成绩作为第二个元素
        val student_ave = student_grade.reduceByKey((x,y)=>(x._1+y._1,x._2+y._2)).map(x=>(x._1,x._2._1/x._2._2))
        var results = student_ave.collect
        // 将结果输出到output.txt中
        val out = new FileWriter("C:\\Users\\Administrator\\Desktop\\result.txt",true)
        for(item<-results){
          out.write(item+"\n")
          println(item)
        }
        out.close()
      }
    
    }
    

    运行结果

    在这里插入图片描述

    5 采用手动打包上传集群的方式实现2的内容

    首先建立a.txt和b.txt,将其上传到hdfs上

    hadoop fs -put /opt/spark/b.txt /
    hadoop fs -put /opt/spark/a.txt /
    

    代码如下:

    import org.apache.spark.SparkContext
    import org.apache.spark.SparkContext._
    import org.apache.spark.SparkConf
    import org.apache.spark.HashPartitioner
    import java.io._
    object first {
      def main(args: Array[String]) {
        val conf = new SparkConf().setAppName("first")
        val sc = new SparkContext(conf)
        sc.setLogLevel("ERROR")
        val A = sc.textFile("/a.txt")
        // 读取文件B
        val B = sc.textFile("/b.txt")
    
        //val data = sc.textFile(dataFile,2)
        val c = (A ++ B).distinct
        val da = c.distinct()
        da.coalesce(1,true).saveAsTextFile("/result")
        //da.saveAsTextFile("file:///opt/spark/c.txt")
    
        val res=da.collect()
        for(item<-res) {
          println(item)
        }
      }
    }
    
    

    将代码打成jar包上传到集群中

    docker cp C:\Users\Administrator\Desktop\untitled2.jar master:/opt
    

    之后运行程序

     spark-submit --class first --master yarn-client untitled2.jar
    

    在这里插入图片描述

    查看运行结果

    在这里插入图片描述

    由于写的比较匆忙,内容比较多,其中可能出现以下小问题,欢迎大家批评指正!

    展开全文
  • 篇博客写了下在Windows下安装Spark本地应用的方法,虽然如此,但其实我最想做的是在Linux下的Spark集群环境的搭建,如今实际使用的时候基本都是在Linux运行的,搭建一个Windows下的本地应用实在是不熟悉Linux...
        上篇博客写了下在Windows下安装Spark本地应用的方法,虽然如此,但其实我最想做的是在Linux下的Spark集群环境的搭建,如今实际使用的时候基本上都是在Linux上运行的,搭建一个Windows下的本地应用实在是不熟悉Linux,不熟悉Spark等,因此想先搞明白Spark是什么,搭建出来后是什么样子,为了熟悉这些内容,当然最好的方式就是在熟悉的Windows环境下搭建出来,现在基本情况了解了,可以尝试在Linux下搭建集群了。
        可以回顾一下,根据在Windows下安装的经验,可以知道,安装Spark的关键有几个:JDK的安装,环境变量的配置,如果集群的话应该还有Spark中配置文件的配置。
        现在有几个先验知识需要提前了解或申明吧——
        spark有三种工作模式:本地模式、HA模式和伪分布式模式。
    
    首先,测试虚拟机之间的连接情况:
    ![Spark1的IP情况](https://img-blog.csdn.net/20160721232529461)
    ![主机的IP情况](https://img-blog.csdn.net/20160721234928581)
    然后ping主机,发现能ping通,但是MTPutty连不上虚拟机,遇到这个问题一般是虚拟机没有安装SSHD服务,主机和虚拟机的连接是通过此服务来进行的,后续spark的集群也会用到这个。因此可以安装这个服务:
     sudo apt-get install openssh-server
    如果出现了主机ping不通虚拟机,但是虚拟机可以ping通主机,那么有两种可能:
    

    1、虚拟机的网络连接方式没有使用桥接的方式,设置下就好;
    2、没有关闭虚拟机的防火墙,这个可以在网上找下关闭的方法,有很多。
    安装完SSH服务后,应该在MTPutty上就可以看得到了(此处不详述Putty和MTPutty和WinSCP的使用方法)。
    另外,在此多说一句,虚拟机的IP最好设置成静态的,否则后续每次打开虚拟机,可能都要设置MTPutty和WinSCP的IP,设置静态IP的方法网上说的很复杂(个人觉得哈……需要用命令行设置文件),其实如果是在Ubuntu系统下就非常简单了,直接在下图所示的位置点击编辑就好了:
    设置静态IP的步骤1
    设置静态IP的步骤2

    下面开始谈下环境搭建,这里采用最简单的master-slave模式进行环境搭建。
    未完,待续……
    
    展开全文
  • windows下 eclipse搭建spark java编译环境

    万次阅读 2018-04-20 23:37:32
    之前有虚拟机或者集群上安装spark安装包的,解压到你想要放spark的本地目录下,比如我的目录就是D:\Hadoop\spark-1.6.0-bin-hadoop2.6 /** *注意: 之前linux环境下安装的spark的版本是spark-2.2.0-bin-...

    环境:

    win10

    jdk1.8

    之前有在虚拟机或者集群上安装spark安装包的,解压到你想要放spark的本地目录下,比如我的目录就是D:\Hadoop\spark-1.6.0-bin-hadoop2.6

    /**

    *注意:

    之前在linux环境下安装的spark的版本是spark-2.2.0-bin-hadoop2.6,但后来搭建eclipse的spark开发环境时发现spark-2.2.0-bin-hadoop2.6解压后没有lib文件,也就没有关键的spark-assembly-1.6.0-hadoop2.6.0.jar这个jar包,不知道spark-2.2.0以后怎么支持eclipse的开发,所以我换了spark-1.6.0,如果有知道的大神,谢谢在下边留言指导一下

    **/

    下边就简单了,先配置spark的环境变量,先添加一个SPARK_HOME,如下:

    然后把SPARK_HOME配置到path,如下:

     这样环境就搭好了,然后就是在eclipse上创建一个普通的java项目,然后把spark-assembly-1.6.0-hadoop2.6.0.jar这个包复制进工程并且导入,如下图

    就可以开发spark程序了,下边附上一段小的测试代码:

     

    import java.util.Arrays;
    
    import org.apache.spark.SparkConf;
    import org.apache.spark.SparkContext;
    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 org.apache.spark.api.java.function.VoidFunction;
    
    import scala.Tuple2;
    
    
    public class WorldCount {
    	
    	public static void main(String[] args) {
    		
    		
    		SparkConf sparkConf = new SparkConf().setMaster("local").setAppName("wc");
    		JavaSparkContext sc = new JavaSparkContext(sparkConf);
    		JavaRDD<String> text = sc.textFile("words.txt");
    		
    		//数据切分和合并
    		JavaRDD<String> words = text.flatMap(new FlatMapFunction<String, String>() {
    			private static final long serialVersionUID = 1L;
    			@Override
    			public Iterable<String> call(String line) throws Exception {
    				// TODO Auto-generated method stub				
    				return Arrays.asList(line.split(" "));
    			}
    		});
    		 JavaPairRDD<String, Integer> wordTopair = words.mapToPair(new PairFunction<String, String, Integer>() {
    			private static final long serialVersionUID = 1L;
    			@Override
    			public Tuple2<String, Integer> call(String word) throws Exception {
    				// TODO Auto-generated method stub
    				return new Tuple2<String, Integer>(word, 1);
    			}
    		});
    		 
    		 JavaPairRDD<String, Integer> results = wordTopair.reduceByKey(new Function2<Integer, Integer, Integer>() {			
    			private static final long serialVersionUID = 1L;
    			@Override
    			public Integer call(Integer value1, Integer value2) throws Exception {
    				// TODO Auto-generated method stub
    				return value1+value2;
    			}
    		});
    		 
    		 JavaPairRDD<Integer, String> temp = results.mapToPair(new PairFunction<Tuple2<String,Integer>, Integer, String>() {
    			private static final long serialVersionUID = 1L;
    			@Override
    			public Tuple2<Integer, String> call(Tuple2<String, Integer> tuple)
    					throws Exception {
    				// TODO Auto-generated method stub
    								
    				return new Tuple2<Integer, String>(tuple._2, tuple._1);
    			}
    		});
    		 JavaPairRDD<String, Integer> sorted = temp.sortByKey(false).mapToPair(new PairFunction<Tuple2<Integer,String>, String, Integer>() {
    			private static final long serialVersionUID = 1L;
    			@Override
    			public Tuple2<String, Integer> call(Tuple2<Integer, String> tuple)
    					throws Exception {
    				// TODO Auto-generated method stub
    				return new Tuple2<String, Integer>(tuple._2,tuple._1);
    			}
    		});
    		 
    		 sorted.foreach(new VoidFunction<Tuple2<String,Integer>>() {
    			private static final long serialVersionUID = 1L;
    
    			@Override
    			public void call(Tuple2<String, Integer> tuple) throws Exception {
    				// TODO Auto-generated method stub
    				System.out.println(tuple._1+" ----------------"+tuple._2);
    				
    			}
    		});
    		sc.close();
    	}
    
    
    
     
    Look! at the window there leans an old maid. She plucks the  
      
    withered leaf from the balsam, and looks at the grass-covered rampart,  
      
    on which many children are playing. What is the old maid thinking  
      
    of? A whole life drama is unfolding itself before her inward gaze.  
      
        "The poor little children, how happy they are- how merrily they  
      
    play and romp together! What red cheeks and what angels' eyes! but  
      
    they have no shoes nor stockings. They dance on the green rampart,  
      
    just on the place where, according to the old story, the ground always  
      
    sank in, and where a sportive, frolicsome child had been lured by  
      
    means of flowers, toys and sweetmeats into an open grave ready dug for  
      
    it, and which was afterwards closed over the child; and from that  
      
    moment, the old story says, the ground gave way no longer, the mound  
      
    remained firm and fast, and was quickly covered with the green turf.  
      
    The little people who now play on that spot know nothing of the old  
      
    tale, else would they fancy they heard a child crying deep below the  
      
    earth, and the dewdrops on each blade of grass would be to them  
      
    tears of woe. Nor do they know anything of the Danish King who here,  
      
    in the face of the coming foe, took an oath before all his trembling  
      
    courtiers that he would hold out with the citizens of his capital, and  
      
    die here in his nest; they know nothing of the men who have fought  
      
    here, or of the women who from here have drenched with boiling water  
      
    the enemy, clad in white, and 'biding in the snow to surprise the  
      
    city.  
      

    }

    展开全文
  • 环境:win10jdk1.8之前有虚拟机或者集群上安装spark安装包的,解压到你想要放spark的本地目录下,比如我的目录就是D:\Hadoop\spark-1.6.0-bin-hadoop2.6/***注意:之前linux环境下安装的spark的版本是spark-...
  • 2、在windows上把hadoop的压缩包解压到一个没有空格的目录下,比如是D盘根目录 3、配置环境变量HADOOP_HOME=D:\hadoop-2.7.7Path下添加 %HADOOP_HOME%\bin 4、下载相似版本的文件hadoop.dll #存放在C:\Windo...
  • docker在windows10的专业版和家庭版的安装方法有很大的不同,本文是基于win10家庭版进行的安装。 一、docker的安装 1、查看系统版本 右击“此电脑”→“属性”,确认是家庭版win10。 2、下载Docker...
  • 基于docker的spark-hadoop分布式集群搭建一、docker的安装1.windows10专业版安装2.windows10家庭版安装3.对docker进行测试4.创建需要的镜像与容器二、环境的配置1.更换apt源2.安装必要的网络工具3.将master提交作为...
  • 一、前期准备  前期的环境准备,Linux系统下要有Hadoop系统,spark伪分布式或者... 然后在spark伪分布式的环境下必须出现如下八个节点才算spark环境搭建好。    然后再本地windows系统下有一个简单的词频...
  • Intellij Idea下载地址: 官方下载 选择右下角的Community Edition版本下载安装即可 本文中使用的是windows系统 ...注意:如果之后要将scala文件打包成jar包并在spark集群上运行的话,请确保spark集群和打包操作...
  • 继续篇文章利用Intellij Idea在windows搭建spark 开发环境(含打jar包过程)(一) 以及 Sparksql处理json日志[要求sparksql统计json日志条数存入mysql数据库]  本章将把打好的jar提交到集群运行。[如何打jar 包请...
  • 本文介绍在windows系统上WMware虚拟机软件上搭建基于Ubuntu系统的Hadoop 2.8 集群 ,后期会在此基础上搭建Spark集群。 一、安装VMware-workstation-full-10.0.4-2249910.exe虚拟机软件,一路Next 二、下载Ubuntu ...
  • windows下虚拟机配置spark集群最强攻略! linux安装ssh和开启 ssh服务 vmware虚拟机ubuntu不能连外网解决办法 通过VMware搭建分布式集群基础环境 Ubuntu关于修改resolv.conf重启失效的问题 Ubuntu 16 NFS的...
  • 前面的话~由于工作中的数据挖掘从sklearn转换到集群了,要开始pyspark了,但是发现市面无论是pyspark的书籍还是文章,相对sklearn来说,还是太少了,大部分问题只能求助pyspark中的api,所以想记录下平时学习...
  • Scala-IDE Eclipse(Windows)中开发Spark应用程序,Ubuntu Spark集群上运行Spark-1.4.0集群搭建Spark国内外书籍推荐Spark修炼之道——Spark学习路线、课程大纲Spark修炼之道系列教程预告Spark修炼之道(基础篇)...
  • Windows下用IDEA进行Spark开发

    千次阅读 2016-11-01 22:03:50
    集群搭建好了,接下来就是将自己的代码写好,扔到集群上进行跑了。安装软件1、JDK 2、Intellj IDEA 3、xshell这三部安装过程这里不介绍,下一步下一步即可。4、Intellj IDEA 安装scala插件 首次使用会出现安装...
  • 由于工作中的数据挖掘从sklearn转换到集群了,要开始pyspark了,但是发现市面无论是pyspark的书籍还是文章,相对sklearn来说,还是太少了,大部分问题只能求助pyspark中的api,所以想记录下平时学习与使用pyspark...
  • 周志湖Spark系列

    2016-11-03 14:13:58
    本人本着十分尊重的态度来学习周老师的博文,特此为方便好找,此做一个目录。方便学习。 ... Eclipse(Windows)中开发Spark应用程序,Ubuntu Spark集群上运行 Spark-1.4.0集群搭建
  • Chapter II 用Scala和Spark进行数据分析前言练习的平台是三台主机组成的服务器上搭建Spark集群,同时安装Jupyter Notebook以及加载了spark内核,然后自己电脑的windows浏览器中访问jupyter notebook来进行scala...
  • 自己的机器配置spark的本地开发模式,可以用来测试spark代码是否正确,如果没问题,可以提交到spark集群上去运行,免去每次都要打包放到集群上去测试的麻烦。因为网络没找到合适的资源可以快速构建,所以就...
  • 基于Spark Core之的流式处理和结构化数据查询,已被众多公司青睐,企业中使用最广泛,很多大数据公司都将以往RDBMS和 Hive中的数据处理,迁移使用Spark SQL。 课程目录: 第1章:SCALA编程(一) 1.大数据...
  • 《docker下,极速搭建spark集群(含hdfs集群)》 《docker下的spark集群,调整参数榨干硬件》 《用golang官方Docker镜像运行项目》 《Docker下Prometheus和Grafana三部曲之一:极速体验》 《Docker下Prometheus和...
  • Apache HBase: 是一个高可靠性、高性能、面向列、可伸缩的分布式存储系统,利用HBase技术可廉价PC Server上搭建起大规模结构化存储集群 HBase入门————《HBase不睡觉》 《HBase实战》见下方ebook 一条数据...
  • 基础3 在windows上安装和启动Elasticseach 基础4 ElasticsSearch 集群健康检查,文档CRUD 基础5 ElasticsSearch 多种搜索方式 基础6 ElasticSearch 嵌套聚合,下钻分析,聚合分析 基础7 Elasticsearch的...
  • 在Windows环境下用Yeoman构建AngularJS项目 Zepto.js Zepto.js 中文文档 Sea.js Hello Sea.js React.js React 学习之道 React.js 小书 React.js 中文文档 React webpack-cookbook React 入门教程 React ...

空空如也

空空如也

1 2
收藏数 29
精华内容 11
关键字:

在windows上搭建spark集群