SparkStreaming之读取Kafka数据

最新推荐文章于 2024-02-11 16:22:33 发布
最新推荐文章于 2024-02-11 16:22:33 发布
阅读量6.2k 收藏 2
点赞数 1
分类专栏： spark 文章标签： spark hadoop 大数据 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/secondlieutenant/article/details/79045333
版权

主要内容：

  • 1.本地模式运行SparkStreaming
  • 2.yarn-client模式运行

相关文章：
1.Spark之PI本地
2.Spark之WordCount集群
3.SparkStreaming之读取Kafka数据
4.SparkStreaming之使用redis保存Kafka的Offset
5.SparkStreaming之优雅停止
6.SparkStreaming之写数据到Kafka
7.Spark计算《西虹市首富》短评词云

1.本地模式运行

object ScalaKafkaStreaming {
  def main(args: Array[String]): Unit = {
    // offset保存路径
    val checkpointPath = "D:\\hadoop\\checkpoint\\kafka-direct"

    val conf = new SparkConf()
      .setAppName("ScalaKafkaStream")
      .setMaster("local[2]")

    val sc = new SparkContext(conf)
    sc.setLogLevel("WARN")

    val ssc = new StreamingContext(sc, Seconds(5))
    ssc.checkpoint(checkpointPath)

    val bootstrapServers = "hadoop1:9092,hadoop2:9092,hadoop3:9092"
    val groupId = "kafka-test-group"
    val topicName = "Test"
    val maxPoll = 500

    val kafkaParams = Map(
      ConsumerConfig.BOOTSTRAP_SERVERS_CONFIG -> bootstrapServers,
      ConsumerConfig.GROUP_ID_CONFIG -> groupId,
      ConsumerConfig.MAX_POLL_RECORDS_CONFIG -> maxPoll.toString,
      ConsumerConfig.KEY_DESERIALIZER_CLASS_CONFIG -> classOf[StringDeserializer],
      ConsumerConfig.VALUE_DESERIALIZER_CLASS_CONFIG -> classOf[StringDeserializer]
    )

    val kafkaTopicDS = KafkaUtils.createDirectStream(ssc, LocationStrategies.PreferConsistent,
      ConsumerStrategies.Subscribe[String, String](Set(topicName), kafkaParams))

    kafkaTopicDS.map(_.value)
      .flatMap(_.split(" "))
      .map(x => (x, 1L))
      .reduceByKey(_ + _)
      .transform(data => {
        val sortData = data.sortBy(_._2, false)
        sortData
      })
      .print()

    ssc.start()
    ssc.awaitTermination()
  }
}

本地模式运行SparkStreaming每隔5s从Kafka读取500条数据并计算WorkCount，然后按次数降序排列，并将Offset保存在本地文件夹

创建Topic

kafka-topics.sh --create --zookeeper hadoop1:2181,hadoop2:2181,hadoop3:2181/kafka --topic Test --partitions 3 --replication-factor 3

查看创建的Topic

kafka-topics.sh --describe --zookeeper hadoop1:2181,hadoop2:2181,hadoop3:2181/kafka

 

编写Kafka程序并往Topic里写数据

public class ProducerTest {
    private static final String[] WORDS = {
            "hello", "hadoop", "java", "kafka", "spark"
    };

    public static void main(String[] args) throws Exception {
        Properties props = new Properties();
        props.put("bootstrap.servers", "hadoop1:9092,hadoop2:9092,hadoop3:9092");
        props.put("acks", "all");
        props.put("retries", 0);
        props.put("batch.size", 16384);
        props.put("linger.ms", 1);
        props.put("buffer.memory", 33554432);
        props.put("key.serializer", "org.apache.kafka.common.serialization.StringSerializer");
        props.put("value.serializer", "org.apache.kafka.common.serialization.StringSerializer");
        KafkaProducer<String, String> kafkaProducer = new KafkaProducer(props);
        boolean flag = true;
        while (flag) {
            for (int i = 0; i < 500; i++) {
                //3、发送数据
                kafkaProducer.send(new ProducerRecord("Test", WORDS[new Random().nextInt(5)]));
            }
            kafkaProducer.flush();
            System.out.println("==========Kafka Flush==========");
            Thread.sleep(5000);
        }

        kafkaProducer.close();
    }
}

每5s写500条数据到Topic

运行结果如下：

 

 

可以看到我们的程序可以正确运行了。

2.yarn-client模式运行

修改程序的checkpoint为hdfs上的目录

object ScalaKafkaStreaming {
  def main(args: Array[String]): Unit = {
    // offset保存路径
    val checkpointPath = "/data/output/checkpoint/kafka-direct"

    val conf = new SparkConf()
      .setAppName("ScalaKafkaStream")
      //.setMaster("local[2]")

    val sc = new SparkContext(conf)
    sc.setLogLevel("WARN")

    val ssc = new StreamingContext(sc, Seconds(3))
    ssc.checkpoint(checkpointPath)

    val bootstrapServers = "hadoop1:9092,hadoop2:9092,hadoop3:9092"
    val groupId = "kafka-test-group"
    val topicName = "Test"
    val maxPoll = 20000

    val kafkaParams = Map(
      ConsumerConfig.BOOTSTRAP_SERVERS_CONFIG -> bootstrapServers,
      ConsumerConfig.GROUP_ID_CONFIG -> groupId,
      ConsumerConfig.MAX_POLL_RECORDS_CONFIG -> maxPoll.toString,
      ConsumerConfig.KEY_DESERIALIZER_CLASS_CONFIG -> classOf[StringDeserializer],
      ConsumerConfig.VALUE_DESERIALIZER_CLASS_CONFIG -> classOf[StringDeserializer]
    )

    val kafkaTopicDS = KafkaUtils.createDirectStream(ssc, LocationStrategies.PreferConsistent,
      ConsumerStrategies.Subscribe[String, String](Set(topicName), kafkaParams))

    kafkaTopicDS.map(_.value)
      .flatMap(_.split(" "))
      .map(x => (x, 1L))
      .reduceByKey(_ + _)
      .transform(data => {
        val sortData = data.sortBy(_._2, false)
        sortData
      })
      .print()

    ssc.start()
    ssc.awaitTermination()
  }
}

pom.xml文件

<dependencies>
  <!-- https://mvnrepository.com/artifact/org.apache.spark/spark-core -->
  <dependency>
    <groupId>org.apache.spark</groupId>
    <artifactId>spark-core_2.11</artifactId>
    <version>2.3.0</version>
    <scope>provided</scope>
  </dependency>

  <!-- https://mvnrepository.com/artifact/org.apache.spark/spark-streaming -->
  <dependency>
    <groupId>org.apache.spark</groupId>
    <artifactId>spark-streaming_2.11</artifactId>
    <version>2.3.0</version>
    <scope>provided</scope>
  </dependency>

  <!-- https://mvnrepository.com/artifact/org.apache.spark/spark-streaming-kafka-0-10 -->
  <dependency>
    <groupId>org.apache.spark</groupId>
    <artifactId>spark-streaming-kafka-0-10_2.11</artifactId>
    <version>2.3.0</version>
    <scope>compile</scope>
  </dependency>
</dependencies>
<build>
  <plugins>
    <plugin>
      <artifactId>maven-assembly-plugin</artifactId>
      <configuration>
        <appendAssemblyId>false</appendAssemblyId>
        <descriptorRefs>
          <descriptorRef>jar-with-dependencies</descriptorRef>
        </descriptorRefs>
        <archive>
          <manifest>
            <!-- 此处指定main方法入口的class -->
            <mainClass></mainClass>
          </manifest>
        </archive>
      </configuration>
      <executions>
        <execution>
          <id>make-assembly</id>
          <phase>package</phase>
          <goals>
            <goal>assembly</goal>
          </goals>
        </execution>
      </executions>
    </plugin>
    <plugin>
      <groupId>org.scala-tools</groupId>
      <artifactId>maven-scala-plugin</artifactId>
      <version>2.15.2</version>
      <executions>
        <execution>
          <id>scala-compile-first</id>
          <goals>
            <goal>compile</goal>
          </goals>
          <configuration>
            <includes>
              <include>**/*.scala</include>
            </includes>
          </configuration>
        </execution>
        <execution>
          <id>scala-test-compile</id>
          <goals>
            <goal>testCompile</goal>
          </goals>
        </execution>
      </executions>
    </plugin>
  </plugins>
</build>

这里将spark-streaming-kafka-0-10_2.11打包进jar，不然运行时会报找不到一些类，也可以通过其他方式解决

上传jar，执行

./bin/spark-submit \
--class me.jinkun.scala.kafka.ScalaKafkaStreaming \
--master yarn \
--deploy-mode client \
--driver-memory 512m \
--executor-memory 512m \
--executor-cores 1 \
/opt/soft-install/data/spark-yarn-1.0-SNAPSHOT.jar

运行过程可能会报如下错误：

Current usage: 114.5 MB of 1 GB physical memory used; 2.2 GB of 2.1 GB virtual memory used. Killing container.

解决方式：参考https://blog.csdn.net/kaaosidao/article/details/77950125
我这里修改yarn-site.xml，加入如下配置

<property>
     <name>yarn.nodemanager.vmem-pmem-ratio</name>
     <value>3</value>
</property>

运行如下：

 


说明程序已经正常启动，进入Yarn的管理界面可以看到正在执行任务http://hadoop1:8088

 

 

Yarn管理界面正在运行的作用

通过ID可以查看运行的日志

 

 

 

运行的结果

通过Tracking UI 可以看到Spark的管理界面

 

 

运行如下命令停止SparkStreaming程序

yarn application -kill [appid]

3.checkpoint

 

 

在我们设置的checkpoint文件夹里保存了最近5次的checkpoint，在线上程序一般保存到hdfs里。
作者：阿坤的博客
链接：https://www.jianshu.com/p/30614ff250b5

 

CWS_chen
关注
  • 1
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
sparkStreaming结合kafka取存数据
01-07
目录 一、说明 1、环境介绍 ...3、主程序Kafka2SparkStreaming2Kafka 四、启动程序测试 1、创建相关kafka主题 2、kafka生产数据到程序 3、从写入到的kafka主题中读取数据 一、说明 1、环境介绍 spark:
python准确率 召回率计算_二分类算法的评价指标：准确率、精准率、召回率、混淆矩阵、AUC...
weixin_39757040的博客
12-06 938
评价指标是针对同样的数据，输入不同的算法，或者输入相同的算法但参数不同而给出这个算法或者参数好坏的定量指标。以下为了方便讲解，都以二分类问题为前提进行介绍，其实多分类问题下这些概念都可以得到推广。准确率准确率是最好理解的评价指标，它是一个比值：\[准确率 = \cfrac{算法分类正确的数据个数}{输入算法的数据的个数}\]但是使用准确率评价算法有一个问题，就是在数据的类别不均衡，特别是有极偏的数...
深度学习auc_机器学习入门之AUC理解和Python实现
weixin_30828697的博客
01-04 1443
稍微了解机器学习或深度学习的同学，应该对AUC不陌生，它算是二分类问题中最为常用的评价指标之一。之所以专门写文章来解释其含义，是因为上次面试时被问到如何自己用代码实现AUC时没有答上来，才发现自己一直是似懂非懂的状态。痛定思痛，决定写一篇文章来解释AUC的含义以及给出详细的Python代码实现除了AUC之外，二分类场景里用得更多的一个评价指标是accuracy，也就是准确率。比方说经典的用朴素贝叶...
python数据分析numpy基础之abs()用法和示例
sinat_34735632的博客
02-11 703
python的通用函数ufunc (Universal functions)是一种对ndarray多维数组中的数据执行元素级运算的函数，即对数组的每个元素都调用通用函数。numpy的通用函数分为一元ufunc和二元ufunc。一元ufunc接收一个ndarray入参进行运算，二元ufunc接收二个ndarray进行运算。numpy.abs()是numpy.absolute()函数的缩写。用于计算数组各元素的绝对值。x：必选，array-like。
关于模型评价指标： 精确率，召回率，AUC等，计算AUC的python程序实现
weixin_43832437的博客
08-02 2854
精确率：
python计算AUC、Accuracy、Recall、Precision和PPV
斯人若彩虹，遇上方知有！
02-09 4482
python计算AUC、Accuracy、Recall、Precision和PPV
模型泛化能力的评估（准确率、精确率、召回率、F1、ROC、AUC）与代码实现
AAAAAAABBgg的博客
06-05 4217
模型泛化能力评估（准确率、精确率、召回）
Spark Streaming与OpenCV传感器数据实时获取.zip
01-24
#introduction Spark Streaming与OpenCV传感器数据实时获取:熟悉OpenCV的使用，获取本机的摄像头的图像数据，并通过SparkStreaming做实时分析 #Client client使用OpenCV抓取摄像头数据，按照一定的时间，捕捉每帧...
Spark Streaming与OpenCV传感器数据实时获取
最新发布
03-16
Spark Streaming与OpenCV传感器数据实时获取:熟悉OpenCV的使用，获取本机的摄像头的图像数据，并通过SparkStreaming做实时分析 #Client client使用OpenCV抓取摄像头数据，按照一定的时间，捕捉每帧图像，将图像数据...
spark流数据处理：SparkStreaming的使用
02-26
SparkStreaming可以从很多数据源获取数据，比如：Kafka、Flume、Twitter、ZeroMQ、Kinesis或TCP连接等，并可以用很多高层算子(map/reduce/join/window等)来方便地处理这些数据。最后处理过的数据还可以推送到文件...
sparkstreaming:封装sparkstreaming动态调节batch time(有数据就执行计算)； 支持运行过程中增删topic； 封装sparkstreaming 1.6 - kafka 010 用以支持 SSL
04-29
用来控制读取速率，由于不是用的sparkstreaming，所有速率控制的一些参数拿不到，得自己去计算。 提供spark-streaming-kafka-0-10_2.10 spark 1.6 来支持 kafka的ssl 支持rdd.updateOffset 来管理偏移量。 :party_...
机器学习分类的几种评价指标：准确率Accuracy, AUC, Precision, Recall, F1，MAPE，SMAPE
rosefun96的博客
12-18 8716
分类评价指标有准确率（accuracy）、精确率（precision）、召回率（recall）、F值等 1、AUC 精确率precision = TP/(TP +FP）,即正类预测对的个数和所有预测成正类样本数比值。 召回率recall = TP/(TP +FN),即预测正类样本和原来一共正类样本数的比值。 将真正类率作为Y轴，假正类率作为X轴，然后就可以画出ROC曲线。ROC曲线与X坐标轴所围...
机器学习分类问题指标评估内容详解（准确率、精准率、召回率、F1、ROC、AUC等）
Emins的博客
07-04 9072
看懂机器学习指标：准确率、精准率、召回率、F1、ROC曲线、AUC曲线
准确率、精确率、召回率、F1值、ROC/AUC整理笔记
weixin_42483745的博客
05-03 1万+
文章目录前言一、TP、TN、FP、FN概念二、准确率、精确率（精准率）、召回率、F1值1.准确率（Accuracy）2.精确率（Precision）查准率3.召回率（Recall）查全率4.F1值（H-mean值）三、ROC曲线、AUC值1.ROC曲线2.AUC值总结 前言 案例代码https://github.com/2012Netsky/pytorch_cnn/blob/main/4_time_series_bikes.ipynb 对于分类问题，机器预测的和实际的还是会有所偏差，所以我们引入以下几个概
分类指标评价定义及代码（准确率，精确率，召回率，F1，AUC）
holal的博客
06-03 6170
对于分类问题进行了一个小的总结，并给出python代码方便各位直观的了解其含义。 目录 准确率 精确率 召回率 F1 AUC 准确率 定义：对于给定的测试数据集，分类器正确分类的样本数与总样本数之比。 公式： 缺点：在正负样本不平衡的情况下，这个指标有很大的缺陷。 代码： ## accuracy from sklearn.metrics import accuracy_score y_pred = [0, 1, 0, 1] y_true = [0, 1.
分类指标：准确率、精确率、召回率、F1 score以及ROC、AUC、宏平均、加权平均
TFATS的博客
06-29 8508
本文将介绍： 混淆矩阵（Confusion Matrix） 准确率（accuracy） 召回率（recall） 精确率（precision） F1score ROC和AUC 宏平均(macro avg) 微平均(micro avg) 加权平均(weighted avg) 一，混淆矩阵（Confusion Matrix） 在n分类模型中，使用n行n列的矩阵形式来表示精度，纵列代表n个分类，在每行中的n个数据代表分别预测在每个类别的个数，完美的预测应该是一个列序数=行中有数据的索引数的一条斜线。 TP：
【机器学习】精确率(precision)、召回率(recall)以及F1分数的概念讲解加python代码实现
京斗码农的博客
05-12 1万+
概念理解： 一、理解查准率（precision）& 查全率（recall） 我们在平时常用到的模型评估指标是精度（accuracy）和错误率（error rate），错误率是：分类错误的样本数站样本总数的比例，即E=n/m（如果在m个样本中有n个样本分类错误），那么1-a/m就是精度。除此之外，还会有查准率和查全率，下面举例解释。 按照周志华《机器学习》中的例子，以西瓜问题为例。 错误率：有多少比例的西瓜被判断错误； 查准率（precision）：算法挑出来的西瓜中有多少比例是好西瓜； .
pytorch预测结果的精度、召回率、F1值、准确率计算（简单实现）
计算机视觉的学习日常
11-22 1万+
1. 导入必要的库函数 import os import json import torch from PIL import Image from torchvision import transforms # 导入自己的模型 from model_v3 import mobilenet_v3_small 2. 文件存储格式 imgs文件下下是需要预测的图像 label.txt为每幅图对应的标签 ### 这个无所谓，能正常读取就行 3. 标签读取辅助函数 targets_path =.
【模型评估】Python混淆矩阵、FP、FN、TP、TN、ROC、FROC、mAP、Precision、Recall、Accuracy、F1 score详述与实现
热门推荐
钱多多先森
08-14 3万+
深度学习中，模型评估常用的指标、实现算法汇总。后续还会有几个章节，对其中的各个小点进行详述
spark streaming读取kafka数据
04-14
很高兴回答这个问题。Spark Streaming可以通过Kafka的Direct API或Receiver API来读取数据。使用Direct API时，Spark Streaming直接从Kafka的broker读取数据，并利用Kafka的高可用性和容错性来实现数据的可靠性处理。使用Receiver API时，Spark Streaming通过启动Kafka消费者来读取数据，并将数据存储在Spark内存中。在这两种情况下，Spark Streaming都能够实现高效的数据处理和实时计算。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值