Spark在Yarn上运行Wordcount程序

Spark w397090770 2014-05-04 16:26:58 刚刚 4480℃ 0评论

作者:过往记忆 | 新浪微博：左手牵右手TEL |
可以转载, 但必须以超链接形式标明文章原始出处和作者信息及版权声明
推酷网禁止转载本博客文章
博客地址：http://www.iteblog.com/
文章标题：《Spark在Yarn上运行Wordcount程序》
本文链接：http://www.iteblog.com/archives/1028
Hadoop、Hive、Hbase、Flume等QQ交流群：138615359（已满），请加入新群：149892483

本博客的微信公共帐号为：iteblog_hadoop，欢迎大家关注。
如果你觉得本文对你有帮助，不妨分享一次，你的每次支持，都是对我最大的鼓励

如果本文的内容对您的学习和工作有所帮助，不妨支付宝赞助([email protected])一下

本博客最近经常出现无法访问情况说明

　　我们在接触Hadoop的时候，第一个列子一般是运行Wordcount程序，在Spark我们可以用Java代码写一个Wordcount程序并部署在Yarn上运行。我们知道，在Spark源码中就存在一个用Java编写好的JavaWordCount程序，源码如下：

 
          01 
          package  org.apache.spark.examples; 
         
          02 
            
          03 
          import  org.apache.spark.api.java.JavaPairRDD; 
         
          04 
          import  org.apache.spark.api.java.JavaRDD; 
         
          05 
          import  org.apache.spark.api.java.Javaclass="wp_keywordlink_affiliate">"" href="http://www.iteblog.com/archives/tag/spark" target="_blank"  data-original-title="View all posts in Spark">SparkContext; 
         
          06 
          import  org.apache.spark.api.java.function.FlatMapFunction; 
         
          07 
          import  org.apache.spark.api.java.function.Function2; 
         
          08 
          import  org.apache.spark.api.java.function.PairFunction; 
         
          09 
          import  scala.Tuple2; 
         
          10 
            
          11 
          import  java.util.Arrays; 
         
          12 
          import  java.util.List; 
         
          13 
          import  java.util.regex.Pattern; 
         
          14 
            
          15 
          public  final class JavaWordCount { 
         
          16 
              private static final  Pattern SPACE = Pattern.compile(" "); 
         
          17 
            
          18 
              public static void  main(String[] args) throws  Exception { 
         
          19 
                  if (args.length < 2) { 
         
          20 
                      System.err.println("Usage: JavaWordCount  "); 
         
          21 
                      System.exit(1); 
         
          22 
                  } 
         
          23 
            
          24 
                  JavaSparkContext ctx = new JavaSparkContext(args[0], 
         
          25 
                          "JavaWordCount", 
         
          26 
                          System.getenv("SPARK_HOME"), 
         
          27 
                          JavaSparkContext.jarOfClass(JavaWordCount.class)); 
         
          28 
                  JavaRDD lines = ctx.textFile(args[1], 1); 
         
          29 
            
          30 
                  JavaRDD words = lines.flatMap( 
         
          31 
                          new FlatMapFunction() { 
         
          32 
                              @Override 
         
          33 
                              public Iterable call(String s) { 
         
          34 
                                  return Arrays.asList(SPACE.split(s)); 
         
          35 
                              } 
         
          36 
                          }); 
         
          37 
            
          38 
                  JavaPairRDD ones = words.map( 
         
          39 
                          new PairFunction() { 
         
          40 
                              @Override 
         
          41 
                              public Tuple2 call(String s) { 
         
          42 
                                  return new Tuple2(s, 1); 
         
          43 
                              } 
         
          44 
                          }); 
         
          45 
            
          46 
                  JavaPairRDD counts = ones.reduceByKey( 
         
          47 
                          new Function2() { 
         
          48 
                              @Override 
         
          49 
                              public Integer call(Integer i1, Integer i2) { 
         
          50 
                                  return i1 + i2; 
         
          51 
                              } 
         
          52 
                          }); 
         
          53 
            
          54 
                  List> output = counts.collect(); 
         
          55 
                  for (Tuple2 tuple : output) { 
         
          56 
                      System.out.println(tuple._1() + ": " + tuple._2()); 
         
          57 
                  } 
         
          58 
                  System.exit(0); 
         
          59 
              } 
         
          60 
          }

　　这里有必要介绍一下这里用到的几个函数。首先是map函数，它根据现有的数据集返回一个新的分布式数据集，由每个原元素经过func函数转换后组成，这个过程一般叫做转换（transformation）；flatMap函数类似于map函数，但是每一个输入元素，会被映射为0到多个输出元素，因此，func函数的返回值是一个Seq，而不是单一元素，可以从上面的代码中看出；reduceByKey函数在一个（K，V)对的数据集上使用，返回一个（K，V）对的数据集，key相同的值，都被使用指定的reduce函数聚合到一起。
　　运行上面的代码之前你得先编译好（话说我好几次用Maven编译老是不成功啊，不过大家可以用./sbt/sbt assembly进行编译）。编译好之后可以用下面的命令进行运行：

        查看源代码 
       
 打印 帮助 
      
          1 
          ./bin/spark-class                                 \ 
         
          2 
          org.apache.spark.deploy.yarn.Client               \ 
         
          3 
          --jar ./jars/spark-examples-assembly-0.9.1.jar    \ 
         
          4 
          --class org.apache.spark.examples.JavaWordCount   \ 
         
          5 
          --args yarn-standalone                            \ 
         
          6 
          --args /home/wyp/cite75_99.txt                    \

org.apache.spark.examples.JavaWordCount类接收两个参数，第一个参数指定你程序运行的master；第二个参数指定你需要计算Wordcount文件的绝对路径，这个文件需要在HDFS上。程序运行的过程中我们可以在Hadoop的WEB UI上进行查看，程序运行完的时候，可以在logs里面看到运行的结果，类似下面：

        查看源代码 
       
 打印 帮助 
      
          01 
          submitting: 1 
         
          02 
          find: 1 
         
          03 
          versions: 4 
         
          04 
          Regression: 1 
         
          05 
          via: 2 
         
          06 
          tests: 2 
         
          07 
          open: 2 
         
          08 
          ./bin/spark-shell: 1 
         
          09 
          When: 1 
         
          10 
          All: 1 
         
          11 
          download: 1 
         
          12 
          requires: 2 
         
          13 
          SPARK_YARN=true: 3 
         
          14 
          Testing: 1 
         
          15 
          take: 1 
         
          16 
          project: 4 
         
          17 
          no: 1 
         
          18 
          systems.: 1 
         
          19 
          file: 1 
         
          20 
          Or,: 1 
         
          21 
          About: 1 
         
          22 
          project's: 3 
         
          23 
          programs: 2 
         
          24 
          given.: 1 
         
          25 
          obtained: 1 
         
          26 
          sbt/sbt: 5 
         
          27 
          artifact: 1 
         
          28 
          SBT: 1 
         
          29 
          local[2]: 1 
         
          30 
          not: 1 
         
          31 
          runs.: 1 
         
          32 
          you: 5 
         
          33 
          building: 1

当然，程序默认的输出直接输到logs里面去了，我们可以将结果输出到文本里面，修改如下：

        查看源代码 
       
 打印 帮助 
      
          1 
          counts.saveAsTextFile("/home/wyp/result"); 
         
          2 
            
          3 
          或者： 
         
          4 
            
          5 
          counts.saveAsHadoopFile("/home/wyp/result",  
         
          6 
                                          Text.class,  
         
          7 
                                   IntWritable.class,  
         
          8 
                             TextOutputFormat.class);

上面的两行代码都可以将计算的结果存储到HDFS上的/home/wyp/result文件夹里面，但是两者输出来的结果内容格式是有区别的，第一种输出内容格式如下：

格式是(key, value)的；第二种输出内容格式如下：

格式是key value。我们可以根据自己的需要定义一个自己的输出格式，而且我们在输出的时候如果文件比较大，还可以指定输出文件的压缩方式。

Spark在Yarn上运行Wordcount程序

过往记忆专注于Hadoop、Spark、Hive、Flume、Hbase，QQ交流群：138615359

Spark在Yarn上运行Wordcount程序

你可能感兴趣的:(cloud)