基于Spark和SparkSQL的NetFlow流量的初步分析——scala语言

最新推荐文章于 2021-06-23 18:59:11 发布

蛮力之精灵

最新推荐文章于 2021-06-23 18:59:11 发布

阅读量882

点赞数

分类专栏： spark 文章标签： scala spark idea intellij idea sparksql

本文链接：https://blog.csdn.net/u012462093/article/details/78287230

版权

spark 专栏收录该内容

2 篇文章 0 订阅

订阅专栏

基于Spark和SparkSQL的NetFlow流量的初步分析——scala语言

标签： NetFlow Spark SparkSQL

本文主要是介绍如何使用Spark做一些简单的NetFlow数据的处理，是基于 IntelliJ IDEA开发Spark 的Maven项目，本文会介绍一些简单的NetFlow基础知识，以及如何在 IntelliJ IDEA 上开发Maven项目，用Scala 写的一些简单的NetFlow字段分析统计的代码，包括 SparkCore和SparkSQL两个版本的。

初步认识NetFlow

在开始写具体的分析代码之前，先要了解NetFlow的基本知识，和它的具体字段都代表什么意思。
我之前的一篇文章里有对于NetFlow的一些简单介绍。
http://blog.csdn.net/u012462093/article/details/78251470#0-qzone-1-66165-d020d2d2a4e8d1a374a433f596ad1440

下面是NetFlow数据和相对应的字段含义（每一行代表一条NetFlow数据）
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-u8lzVkxQ-1592204881867)(https://i.imgur.com/Wfj5s4M.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-7y7fDBkm-1592204881869)(https://i.imgur.com/MqeATZb.png)]

可以看出NetFlow能很清晰的表现出我们需要的信息，方便我们做字段提取和处理。

使用IDEA开发Spark的Maven项目

这也有一篇详细介绍怎么安装IDEA和搭建Maven项目博客
http://blog.csdn.net/kwu_ganymede/article/details/51832427

Maven管理项目在JavaEE普遍使用，开发Spark项目也不例外，因此需要构建Maven-Scala项目来开发Spark项目。本文采用的工具是IntelliJ IDEA 2017，IDEA工具越来越被大家认可，开发java, python ,scala 支持都非常好，而Scala语言是开发Spark项目的首选。

上面那篇博客对如何安装搭建Spark的Maven项目包括安装Scala插件都有非常详细的介绍，这里我就不再过多阐述了。因为我们不光有Spark项目还要用到SparkSql，所以不能用那篇博客中的pom文件，我把我的pom文件粘到这。

<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/maven-v4_0_0.xsd">
<modelVersion>4.0.0</modelVersion>
<groupId>MDemo4</groupId>
<artifactId>scm4</artifactId>
<version>1.0-SNAPSHOT</version>
<inceptionYear>2008</inceptionYear>
<properties>
<jackson.version>2.4.2</jackson.version>
<scala.version>2.10.5</scala.version>
<org.slft4j.version>1.6.1</org.slft4j.version>
<spark.version>1.5.2</spark.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>

<pluginRepositories>
<pluginRepository>
  <id>scala-tools.org</id>
  <name>Scala-Tools Maven2 Repository</name>
  <url>http://scala-tools.org/repo-releases</url>
</pluginRepository>
</pluginRepositories>

<dependencies>
<dependency>
  <groupId>org.scala-lang</groupId>
  <artifactId>scala-library</artifactId>
  <version>${scala.version}</version>
</dependency>


<dependency>
  <groupId>junit</groupId>
  <artifactId>junit</artifactId>
  <version>4.4</version>
  <scope>test</scope>
</dependency>
<dependency>
  <groupId>org.specs</groupId>
  <artifactId>specs</artifactId>
  <version>1.2.5</version>
  <scope>test</scope>
</dependency>
<dependency>
  <groupId>org.scala-lang</groupId>
  <artifactId>scala-compiler</artifactId>
  <version>${scala.version}</version>
  <scope>compile</scope>
</dependency>

<dependency>
  <groupId>org.apache.spark</groupId>
  <artifactId>spark-core_2.10</artifactId>
  <version>${spark.version}</version>
</dependency>

<dependency>
  <groupId>org.apache.spark</groupId>
  <artifactId>spark-streaming_2.10</artifactId>
  <version>${spark.version}</version>
</dependency>

<dependency>
  <groupId>org.apache.spark</groupId>
  <artifactId>spark-streaming-kafka_2.10</artifactId>
  <version>${spark.version}</version>
</dependency>

<dependency>
  <groupId>org.apache.spark</groupId>
  <artifactId>spark-mllib_2.10</artifactId>
  <version>${spark.version}</version>
</dependency>

<dependency>
  <groupId>org.apache.spark</groupId>
  <artifactId>spark-sql_2.10</artifactId>
  <version>${spark.version}</version>
</dependency>

<dependency>
  <groupId>com.databricks</groupId>
  <artifactId>spark-csv_2.10</artifactId>
  <version>1.4.0</version>
</dependency>

<dependency>
  <groupId>org.slf4j</groupId>
  <artifactId>slf4j-api</artifactId>
  <version>${org.slft4j.version}</version>
</dependency>


<dependency>
  <groupId>org.slf4j</groupId>
  <artifactId>jcl-over-slf4j</artifactId>
  <version>${org.slft4j.version}</version>
</dependency>

<dependency>
  <groupId>org.slf4j</groupId>
  <artifactId>slf4j-log4j12</artifactId>
  <version>${org.slft4j.version}</version>
</dependency>

<dependency>
  <groupId>com.alibaba</groupId>
  <artifactId>fastjson</artifactId>
  <version>1.2.15</version>
</dependency>
</dependencies>

<build>
<sourceDirectory>src/main/scala</sourceDirectory>
<testSourceDirectory>src/test</testSourceDirectory>
<plugins>

  <plugin>
    <groupId>org.scala-tools</groupId>
    <artifactId>maven-scala-plugin</artifactId>
    <executions>
      <execution>
        <goals>
          <goal>compile</goal>
          <goal>testCompile</goal>
        </goals>
      </execution>
    </executions>
    <configuration>
      <scalaVersion>${scala.version}</scalaVersion>
      <args>
        <arg>-target:jvm-1.5</arg>
      </args>
    </configuration>
  </plugin>

</plugins>
</build>

<reporting>
<plugins>
  <plugin>
    <groupId>org.scala-tools</groupId>
    <artifactId>maven-scala-plugin</artifactId>
    <configuration>
      <scalaVersion>${scala.version}</scalaVersion>
    </configuration>
  </plugin>
</plugins>
</reporting>
</project>

这个pom文件里详细包含了Spark、SparkSQL、SparkStreaming的相关依赖，所以如果要开发其他的Spark项目也基本够用了。

下面就进入正题，怎么用Spark分析NetFlow数据

用Spark根据目的IP统计字节数

测试数据来源：

首先要解决的是数据来源问题，有两个方法，由flowd程序捕获或由flowfake伪造数据，落地形成文件。
本文用的是第二种方式伪造的数据，或者自己写脚本生成数据，但是无论哪种方式最后都要落地形成文件。我们读取数据的方式是从文件中读取。

数据生成之后可以直接只用也可以上传到HDFS中使用，两种方法区别不大。

直接上代码

import org.apache.spark.{SparkConf, SparkContext}    
object SparkDemo1 {
  def main(args: Array[String]): Unit = {
    val conf = new SparkConf().setAppName("SparkDemo").setMaster("local")
    val sc = new SparkContext(conf)
    val rdd1 = sc.textFile("hdfs:///home/fake/*")
    //按照目的ip统计接受到的包数量
    val rdd2 = rdd1
      .map(m=>{(m.split("\\\t")(2),m.split("\\\t")(6).toInt)})
      .reduceByKey(_+_)
      .sortBy(_._2,false)
      .repartition(1)
    rdd2.saveAsTextFile("hdfs:///home/results")
  }
}

因为是测试，所以用的运行方式是单机运行，也可以换成集群运行。

textFile表示从hdfs上获取数据，如果想读本地文件只需要把hdfs换成file即可
/*表示的是可以读取该目录下的所有文件
netflow数据字段之间是用制表符分割的
在数据量大的情况下回进行默认分区，用repartition(1)可以将结果文件合并成一个，方便查看

提交到Spark系统上运行

首先先用Maven命令将代码打成jar包，IDEA提供了对Maven很好的支持，只用在右侧的Maven Projects栏中即可点击package命令进行打包。
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-u8eroIO0-1592204881872)(https://i.imgur.com/btXt4jy.png)]

也可以在Terminal窗口中输入命令mvn clean package命令进行打包，打好的jar包会存放在target文件夹下。

将jar包上传到Spark所在的系统中使用Spark的submit方式进行运行。

spark-submit --queue flow \
	--class fake.SparkDemo1 \
/home/scm4-1.0-SNAPSHOT.jar

第二行指定的是main函数所在的路径，最后一行指定的是jar包所在的目录

最后运行得到的结果文件如下：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-zl2Gy2Fi-1592204881875)(https://i.imgur.com/58fn8se.png)]

用SparkSQL进行多字段分组聚合查询

老规矩，先上代码

import org.apache.spark.{SparkConf, SparkContext}
import org.apache.spark.sql._    
object SparkDemo3 {
  def main(args: Array[String]): Unit = {
    val conf=new SparkConf().setAppName("SparkDemo").setMaster("local")
    val sc=new SparkContext(conf)
    val sqlc=new SQLContext(sc)
    import sqlc.implicits._
    //选择日期，源ip，目的ip，字节4个字段，并做分组流量查询
    sc.textFile("hdfs:///home/fake/*")
      .map(x=>{(x.split("\\\t")(8),x.split("\\\t")(0),x.split("\\\t")(1),x.split("\\\t")(7))})
      .repartition(1)
      .toDF("time","rip","sip","bytes").registerTempTable("temp")
    sqlc.sql("select max(time), rip, sip, sum(bytes) as bytes from temp group by rip, sip order by bytes desc limit 10")
      .toJavaRDD
      .saveAsTextFile("hdfs:///home/results")

  }

}

因为是直接从文件中读取数据，所以需要先读成RDD再转换成DataFream，最后写出文件之前还要再转回RDD。在本文中仅做测试，真实环境中一般是从hive中读取数据。

运行结果如下：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-PXbXqEoF-1592204881877)(https://i.imgur.com/gIaFemK.png)]

总结

本文介绍的都是一些最基本的Spark使用方式，仅适用于入门，欢迎大家一起探讨学习。
其他相关资料已经同步到我的博客网站，欢迎访问我的个人博客了解更多内容。

蛮力之精灵

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
基于Spark和SparkSQL的NetFlow流量的初步分析——scala语言

基于Spark和SparkSQL的NetFlow流量的初步分析——scala语言标签： NetFlow Spark SparkSQL本文主要是介绍如何使用Spark做一些简单的NetFlow数据的处理，是基于 IntelliJ IDEA开发Spark 的Maven项目，本文会介绍一些简单的NetFlow基础知识，以及如何在 IntelliJ IDEA 上开发Maven项目，用Scala 写的一些简单
复制链接

扫一扫

专栏目录