Apache Spark Streaming (章节四)

最新推荐文章于 2023-04-03 20:35:19 发布

<>=

最新推荐文章于 2023-04-03 20:35:19 发布

阅读量230

点赞数

分类专栏： spark 文章标签： spark

本文链接：https://blog.csdn.net/qq_36752007/article/details/103430400

版权

spark 专栏收录该内容

10 篇文章 0 订阅

订阅专栏

Spark Streaming

Spark Streaming是核心Spark API的扩展，可实现实时数据流的可扩展，高吞吐量，容错流处理。数据可以从许多来源（如Kafka，Flume，Kinesis或TCP套接字）中获取，并且可以使用以高级函数（如map，reduce，join和window）表示的复杂算法进行处理。最后，处理后的数据可以推送到文件系统，数据库和实时dashboards。
在这里插入图片描述
在内部，它的工作原理如下。 Spark Streaming接收实时输入数据流并将数据分成批处理，然后由Spark引擎处理以批量生成最终结果流。

Spark Streaming提供称为离散流或DStream的高级抽象，表示连续的数据流。DStream可以从来自Kafka，Flume和Kinesis等源的输入数据流创建，也可以通过在其他DStream上应用高级操作来创建。在内部DStream表示为一系列RDD。

Quick Start

maven

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

案例入门

val conf = new SparkConf()
	.setMaster("local[5]")
	.setAppName("wordCount")
val ssc = new StreamingContext(conf,Seconds(1))
//关闭其他日志
ssc.sparkContext.setLogLevel("FATAL")

val ssc = new StreamingContext(sc,Seconds(1))
ssc.socketTextStream("192.168.239.131", 9999)
  .flatMap(line => line.split(" "))
  .map((_, 1))
  .reduceByKey((v1, v2) => v1 + v2)
  .print()

ssc.start()
ssc.awaitTermination()

注意：使用SocketTextStream的时候注意安装nc组件，然后启动nc -lk 9999启动netcat服务。

概念介绍

通过上述案例的运行，现在我们来一起探讨一些流处理的概念。在处理流计算的时候，除去spark-core依赖以外我们还需要引入spark-streaming模块。要从Spark Streaming核心API中不存在的Kafka，Flume和Kinesis等源中提取数据，您必须将相应的工件spark-streaming-xyz_2.11添加到依赖项中。

Source	Artifact
Kafka	spark-streaming-kafka-0-10_2.12

初始化 StreamingContext

要初始化Spark Streaming程序，必须创建一个StreamingContext对象，它是所有Spark Streaming功能的主要入口点。

import org.apache.spark._
import org.apache.spark.streaming._

val conf = new SparkConf().setAppName(appName).setMaster(master)
val ssc = new StreamingContext(conf, Seconds(1))

appName参数是应用程序在集群UI上显示的名称。 master是Spark，YARN群集URL，或者是在本地模式下运行的特殊"local [*]"字符串。实际上，在群集上运行时，您不希望在程序中对master进行硬编码，而是使用spark-submit启动指定–master配置。但是，对于本地测试和单元测试，您可以传递“local [*]”以在进程中运行Spark Streaming（系统会自动检测本地系统的核的数目）。

请注意ssc会在内部创建一个SparkContext（所有Spark功能的起点），如果需要获取SparkContext对象用户可以调用ssc.sparkContext访问。例如用户使用SparkContext关闭日志。

val conf = new SparkConf()
	.setMaster("local[5]")
	.setAppName("wordCount")
val ssc = new StreamingContext(conf,Seconds(1))
//关闭其他日志
ssc.sparkContext.setLogLevel("FATAL")

必须根据应用程序的延迟要求和可用的群集资源设置批处理间隔。要使群集上运行的Spark Streaming应用程序保持稳定，系统应该能够以接收数据的速度处理数据。换句话说，批处理数据应该在生成时尽快处理。通过监视流式Web UI中的处理时间可以找到是否适用于应用程序，其中批处理时间应小于批处理间隔。

val conf = new SparkConf()
.setMaster("local[5]")
.setAppName("wordCount")
val sc = new SparkContext(conf)
val ssc = new StreamingContext(sc,Seconds(1))

当用户创建完StreamingContext对象之后，用户需要完成以下步骤

定义数据源，用于创建输入的 DStreams.
定义流计算算子，通过定义这些算子实现对DStream数据转换和输出
调用streamingContext.start()启动数据.
等待计算结束 (人工结束或者是错误) 调用 streamingContext.awaitTermination().
如果是人工结束，泳衣调用 streamingContext.stop()结束流计算.

重要因素需要谨记

一旦流计算启动，无法再往计算流程中添加计算算子
一旦SparkContext对象被stop后，无法重启。
一个JVM系统中只能实例化一个StreamingContext对象。
SparkContext被stop()后，内部创建的SparkContext也会被stop.如果仅仅是想Stop StreamingContext, 可以设置stop() 中的可选参数 stopSparkContext=false即可.

ssc.stop(stopSparkContext = false)

一个SparkContext 可以重复使用并且创建多个StreamingContexts, 前提是上一个启动的StreamingContext 被停止了(但是并没有关闭 SparkContext对象) 。

Discretized Streams (DStreams)

Discretized Stream或DStream是Spark Streaming提供的基本抽象。它表示连续的数据流，可以是从源接收的输入数据流，也可以是通过转换输入流生成的已处理数据流。在内部，DStream由一系列连续的RDD表示，这是Spark对不可变分布式数据集的抽象。DStream中的每个RDD都包含来自特定时间间隔的数据，如下图所示。
在这里插入图片描述
应用于DStream的任何操作都转换为底层RDD上的操作。例如，在先前Quick Start示例中，flatMap操作应用于行DStream中的每个RDD以生成单词DStream的RDD。如下图所示。

这些底层RDD转换由Spark引擎计算。 DStream操作隐藏了大部分细节，并为开发人员提供了更高级别的API以方便使用。

Input DStreams and Receivers

Input DStream是表示从流源接收的输入数据流。在Quick Start示例中，lines是输入DStream，因为它表示从netcat服务器接收的数据流。每个输入DStream（file stream除外，稍后讨论）都与Receiver对象相关联，该对象从源接收数据并将其存储在Spark的内存中进行处理。

Spark Streaming提供两类内置streaming sources。

Basic Source :StreamingContext API中直接提供的源。示例：filesystem和socket连接。
Advanced sources:像Kafka，Flume等来源可通过额外的实用程序类获得。这些需要链接到额外的依赖项.

请注意，如果要在流应用程序中并行接收多个数据流，可以创建多个输入DStream,这将创建多个Receiver，这些Receiver将同时接收多个数据流。但请注意，Spark worker / executor是一个长期运行的任务，因此它占用了分配给Spark Streaming应用程序的其中一个core。因此，重要的是要记住，Spark Streaming应用程序需要分配足够的cores（或线程，如果在本地运行）来处理接收的数据，以及运行Receiver。

在本地运行Spark Streaming程序时，请勿使用“local”或“local [1]”作为主URL。这两种方法都意味着只有一个线程将用于本地运行任务。如果您正在使用基于Receiver的输入DStream（例如Socket，Kafka，Flume等），那么将使用单个线程来运行Receiver，而不留下用于处理接收数据的线程。因此，在本地运行时，始终使用“local [n]”作为主URL，其中n>number receivers。
同样道理在集群上运行时，分配给Spark Streaming应用程序的核心数必须大于Receiver数。否则系统将接收数据，但无法处理数据。

Basic Sources

我们已经在Quickstart中查看了ssc.socketTextStream（…），该示例根据通过TCP Socket连接接收的文本数据创建DStream。除了套接字之外，StreamingContext API还提供了从文件创建DStream作为输入源的方法。

File Streams

对于从与HDFS API兼容的任何文件系统（即HDFS，S3，NFS等）上的文件读取数据，可以通过StreamingContext.fileStream [KeyClass，ValueClass，InputFormatClass]创建DStream。文件流不需要运行Receiver，因此不需要为接收文件数据分配任何core。

对于简单的文本文件，最简单的方法是StreamingContext.textFileStream（dataDirectory）

通用文件

streamingContext.fileStream[KeyClass, ValueClass, InputFormatClass](dataDirectory)

val conf = new SparkConf()
  .setMaster("local[5]")
  .setAppName("wordCount")
val ssc = new StreamingContext(conf,Seconds(5))
ssc.sparkContext.setLogLevel("FATAL")

ssc.textFileStream("hdfs://192.168.239.131:9000//demo/words")
    .flatMap(line=>line.split(" "))
    .map((_,1))
    .reduceByKey(_+_)
    .print()

ssc.start()
ssc.awaitTermination()

文本文件

streamingContext.textFileStream(dataDirectory)

val conf = new SparkConf()
.setMaster("local[5]")
.setAppName("wordCount")
val ssc = new StreamingContext(conf,Seconds(5))
ssc.sparkContext.setLogLevel("FATAL")

ssc.fileStream[LongWritable,Text,TextInputFormat]("hdfs://192.168.239.131:9000//demo/words")
.flatMap(line=>line._2.toString.split(" "))
.map((_,1))
.reduceByKey(_+_)
.print()

ssc.start()
ssc.awaitTermination()

测试：

[root@CentOS ~]# hdfs dfs -put install.log /
[root@CentOS ~]# hdfs dfs -mv /install.log /demo/wrods/

注意在使用采集hdfs系统数据的时候，必须先将需要采集的文件上传到非监测目录，等文件上传结束后将数据mv到采样目录，否则spark采集不到数据，原因如下：

“Full” Filesystems such as HDFS tend to set the modification time on their files as soon as the output stream is created. When a file is opened, even before data has been completely written, it may be included in the DStream - after which updates to the file within the same window will be ignored. That is: changes may be missed, and data omitted from the stream.

因此需要保证：

1.这些文件具有相同的格式

2.这些文件通过原子移动或重命名文件的方式在dataDirectory创建

3.一旦移动这些文件，就不能再进行修改，如果在文件中追加内容，这些追加的新数据也不会被读取。

Queue of RDDs as a Stream

为了使用测试数据测试Spark Streaming应用程序，还可以使用streamingContext.queueStream（queueOfRDDs）基于RDD队列创建DStream。推入队列的每个RDD将被视为DStream中的一批数据，并像流一样处理。

val conf = new SparkConf()
.setMaster("local[5]")
.setAppName("wordCount")
val ssc = new StreamingContext(conf,Seconds(5))
val sc = ssc.sparkContext
sc.setLogLevel("FATAL")

val queue=new mutable.Queue[RDD[String]]();
ssc.queueStream(queue)
.flatMap(line=>line.split("\\W+"))
.map(word=>(word,1))
.reduceByKey(_+_)
.print()

ssc.start()
for(i <- 1 to 30){
  queue += sc.makeRDD(List("this is a demo","hello how are you"))
  Thread.sleep(1000)
}
ssc.stop()

Advanced Sources

此类Source需要与外部非Spark库连接，其中一些库具有复杂的依赖性（例如，Kafka和Flume）。因此，为了最大限度地减少与依赖项版本冲突相关的问题，从这些源创建DStream的功能已移至可在必要时显式链接的单独库。请注意，Spark shell中不提供这些高级源，因此无法在shell中测试基于这些高级源的应用程序。如果您真的想在Spark shell中使用它们，则必须下载相应的Maven工件JAR及其依赖项，并将其添加到类路径中。演示Kafka和Spark流处理集成。

下载依赖

<dependency>
  <groupId>org.apache.spark</groupId>
  <artifactId>spark-streaming-kafka-0-10_2.11</artifactId>
  <version>${spark.version}</version>
</dependency>

val conf = new SparkConf()
.setMaster("local[5]")
.setAppName("wordCount")
val ssc = new StreamingContext(conf,Seconds(5))
ssc.sparkContext.setLogLevel("FATAL")

val kafkaParams = Map[String, Object](
  "bootstrap.servers" -> "CentOS:9092,CentOS:9093,CentOS:9094",
  "key.deserializer" -> classOf[StringDeserializer],
  "value.deserializer" -> classOf[StringDeserializer],
  "group.id" -> "group1",
  "auto.offset.reset" -> "latest",
  "enable.auto.commit" -> (false: java.lang.Boolean)
)

val topics = Array("topic01")
KafkaUtils.createDirectStream(ssc,
                              PreferConsistent,
                              Subscribe[String,String](topics,kafkaParams)
                             ).map(record => record.value())
.flatMap(line=>line.split("\\W+"))
.map((_,1))
.reduceByKey(_+_)
.print()

ssc.start()
ssc.awaitTermination()