20200623SparkStreaming学习笔记

为什么是local[2]
    
(需要资源)socket <- Receiver ->Memory  -> Operation (也需要资源)
所以不设置2的话就无法往下执行


黑名单过滤

访问日志   ==> DStream
20180808,zs
20180808,ls
20180808,ww
   ==>  (zs: 20180808,zs)(ls: 20180808,ls)(ww: 20180808,ww)

黑名单列表  ==> RDD
zs
ls
   ==>(zs: true)(ls: true)

==> 20180808,ww

leftjoin
(zs: [<20180808,zs>, <true>])  x 
(ls: [<20180808,ls>, <true>])  x
(ww: [<20180808,ww>, <false>])  ==> tuple 1


@transient 是 java 的 transient 关键字的作用,是需要实现 Serilizable 接口,@transient
是类型修饰符,只能用来修饰字段。在对象序列化过程中, / 被 transient 标记的变量不会被序列化


运行出现FlumePush代码出现了
java.lang.AbstractMethodError: org.apache.avro.specific.SpecificFixed.getSchema()Lorg/apache/avro/Sc

查了下因为没加依赖

   <dependency>
      <groupId>org.apache.avro</groupId>
      <artifactId>avro</artifactId>
      <version>1.7.6-cdh5.16.2</version>
    </dependency>

问题得到解决


Flume Agent的编写: flume_push_streaming.conf

simple-agent.sources = netcat-source
simple-agent.sinks = avro-sink
simple-agent.channels = memory-channel

simple-agent.sources.netcat-source.type = netcat
simple-agent.sources.netcat-source.bind = hadoop000
simple-agent.sources.netcat-source.port = 44444

simple-agent.sinks.avro-sink.type = avro
simple-agent.sinks.avro-sink.hostname = 192.168.31.77 //我本地的地址
simple-agent.sinks.avro-sink.port = 41414

simple-agent.channels.memory-channel.type = memory

simple-agent.sources.netcat-source.channels = memory-channel
simple-agent.sinks.avro-sink.channel = memory-channel

flume-ng agent  \
--name simple-agent   \
--conf $FLUME_HOME/conf    \
--conf-file $FLUME_HOME/conf/flume_push_streaming.conf  \
-Dflume.root.logger=INFO,console


hadoop000:是服务器的地址
local的模式进行Spark Streaming代码的测试  192.168.199.203

本地测试总结
1)启动sparkstreaming作业
2) 启动flume agent
3) 通过telnet输入数据,观察IDEA控制台的输出

spark-submit \
--class com.imooc.spark.FlumePushWordCount \
--master local[2] \
--packages org.apache.spark:spark-streaming-flume_2.11:2.2.0 \
/home/hadoop/lib/sparktrain-1.0.jar \
hadoop000 41414

======
Pull方式整合

Flume Agent的编写: flume_pull_streaming.conf

simple-agent.sources = netcat-source
simple-agent.sinks = spark-sink
simple-agent.channels = memory-channel

simple-agent.sources.netcat-source.type = netcat
simple-agent.sources.netcat-source.bind = hadoop000
simple-agent.sources.netcat-source.port = 44444

simple-agent.sinks.spark-sink.type = org.apache.spark.streaming.flume.sink.SparkSink
simple-agent.sinks.spark-sink.hostname = hadoop000
simple-agent.sinks.spark-sink.port = 41414

simple-agent.channels.memory-channel.type = memory

simple-agent.sources.netcat-source.channels = memory-channel
simple-agent.sinks.spark-sink.channel = memory-channel

注意点:先启动flume 后启动Spark Streaming应用程序
flume-ng agent  \
--name simple-agent   \
--conf $FLUME_HOME/conf    \
--conf-file $FLUME_HOME/conf/flume_pull_streaming.conf  \
-Dflume.root.logger=INFO,console


spark-submit \
--class com.imooc.spark.FlumePullWordCount \
--master local[2] \
--packages org.apache.spark:spark-streaming-flume_2.11:2.2.0 \
/home/hadoop/lib/sparktrain-1.0.jar \
hadoop000 41414

Receiver整合
1) 启动zk
2) 启动kafka. ./kafka-server-start.sh -daemon /home/hadoop/app/kafka_2.11-0.9.0.0/config/server.properties 
3) 创建topic.  ./kafka-topics.sh --create --zookeeper localhost:2181 --replication-factor 1 --partitions 1 --topic kafka_streaming_topic
//查询./kafka-topics.sh --list --zookeeper localhost:2181
测试一下
./kafka-console-producer.sh --broker-list localhost:9092 --topic kafka_streaming_topic
./kafka-console-consumer.sh --zookeeper localhost:2181 --topic kafka_streaming_topic
在produce那边测试 hello 
world 
spark
4) 通过控制台测试本topic是否能够正常的生产和消费信息


spark-submit \
--class com.imooc.spark.KafkaReceiverWordCount \
--master local[2] \
--name KafkaReceiverWordCount \
--packages org.apache.spark:spark-streaming-kafka-0-8_2.11:2.2.0 \
/home/hadoop/lib/sparktrain-1.0.jar  hadoop000:2181 test kafka_streaming_topic 1


spark-submit \
--class com.imooc.spark.KafkaDirectWordCount \
--master local[2] \
--name KafkaDirectWordCount \
--packages org.apache.spark:spark-streaming-kafka-0-8_2.11:2.2.0 \
/home/hadoop/lib/sparktrain-1.0.jar  hadoop000:9092 kafka_streaming_topic


-----------------------------------------------------------------------------------------------------
streaming.conf

agent1.sources=avro-source
agent1.channels=logger-channel
agent1.sinks=log-sink

#define source
agent1.sources.avro-source.type=avro
agent1.sources.avro-source.bind=0.0.0.0
agent1.sources.avro-source.port=41414

#define channel
agent1.channels.logger-channel.type=memory

#define sink
agent1.sinks.log-sink.type=logger

agent1.sources.avro-source.channels=logger-channel
agent1.sinks.log-sink.channel=logger-channel

flume-ng agent \
--conf $FLUME_HOME/conf \
--conf-file $FLUME_HOME/conf/streaming.conf \
--name agent1 \
-Dflume.root.logger=INFO,console


./kafka-topics.sh --create --zookeeper hadoop000:2181 --replication-factor 1 --partitions 1 --topic streamingtopic

streaming2.conf
agent1.sources=avro-source
agent1.channels=logger-channel
agent1.sinks=kafka-sink

#define source
agent1.sources.avro-source.type=avro
agent1.sources.avro-source.bind=0.0.0.0
agent1.sources.avro-source.port=41414

#define channel
agent1.channels.logger-channel.type=memory

#define sink
agent1.sinks.kafka-sink.type=org.apache.flume.sink.kafka.KafkaSink
agent1.sinks.kafka-sink.topic = streamingtopic
agent1.sinks.kafka-sink.brokerList = hadoop000:9092
agent1.sinks.kafka-sink.requiredAcks = 1
agent1.sinks.kafka-sink.batchSize = 20

agent1.sources.avro-source.channels=logger-channel
agent1.sinks.kafka-sink.channel=logger-channel


flume-ng agent \
--conf $FLUME_HOME/conf \
--conf-file $FLUME_HOME/conf/streaming2.conf \
--name agent1 \
-Dflume.root.logger=INFO,console

./kafka-console-consumer.sh --zookeeper hadoop000:2181 --topic streamingtopic

我们现在是在本地进行测试的,在IDEA中运行LoggerGenerator,
然后使用Flume、Kafka以及Spark Streaming进行处理操作。

在生产上肯定不是这么干的,怎么干呢?
1) 打包jar,执行LoggerGenerator类
2) Flume、Kafka和我们的测试是一样的
3) Spark Streaming的代码也是需要打成jar包,然后使用spark-submit的方式进行提交到环境上执行
    可以根据你们的实际情况选择运行模式:local/yarn/standalone/mesos

在生产上,整个流处理的流程都一样的,区别在于业务逻辑的复杂性


linux crontab
    网站:http://tool.lu/crontab
    每一分钟执行一次的crontab表达式: */1 * * * * 

crontab -e
    */1 * * * * /home/hadoop/data/project/log_generator.sh


对接python日志产生器输出的日志到Flume
streaming_project.conf

选型:access.log  ==>  控制台输出
    exec
    memory
    logger


对接python日志产生器输出的日志到Flume
streaming_project.conf

vi streaming_project.conf

选型:access.log  ==>  控制台输出
    exec
    memory
    logger


exec-memory-logger.sources = exec-source
exec-memory-logger.sinks = logger-sink
exec-memory-logger.channels = memory-channel

exec-memory-logger.sources.exec-source.type = exec
exec-memory-logger.sources.exec-source.command = tail -F /home/hadoop/data/project/logs/access.log
exec-memory-logger.sources.exec-source.shell = /bin/sh -c

exec-memory-logger.channels.memory-channel.type = memory

exec-memory-logger.sinks.logger-sink.type = logger

exec-memory-logger.sources.exec-source.channels = memory-channel
exec-memory-logger.sinks.logger-sink.channel = memory-channel

flume-ng agent \
--name exec-memory-logger \
--conf $FLUME_HOME/conf \
--conf-file /home/hadoop/data/project/streaming_project.conf \
-Dflume.root.logger=INFO,console


日志==>Flume==>Kafka
    启动zk:./zkServer.sh start
    启动Kafka Server:kafka-server-start.sh -daemon /home/hadoop/app/kafka_2.11-0.9.0.0/config/server.properties 
    修改Flume配置文件使得flume sink数据到Kafka

streaming_project2.conf
exec-memory-kafka.sources = exec-source
exec-memory-kafka.sinks = kafka-sink
exec-memory-kafka.channels = memory-channel

exec-memory-kafka.sources.exec-source.type = exec
exec-memory-kafka.sources.exec-source.command = tail -F /home/hadoop/data/project/logs/access.log
exec-memory-kafka.sources.exec-source.shell = /bin/sh -c

exec-memory-kafka.channels.memory-channel.type = memory

exec-memory-kafka.sinks.kafka-sink.type = org.apache.flume.sink.kafka.KafkaSink
exec-memory-kafka.sinks.kafka-sink.brokerList = hadoop000:9092
exec-memory-kafka.sinks.kafka-sink.topic = streamingtopic
exec-memory-kafka.sinks.kafka-sink.batchSize = 5
exec-memory-kafka.sinks.kafka-sink.requiredAcks = 1

exec-memory-kafka.sources.exec-source.channels = memory-channel
exec-memory-kafka.sinks.kafka-sink.channel = memory-channel

flume-ng agent \
--name exec-memory-kafka \
--conf $FLUME_HOME/conf \
--conf-file /home/hadoop/data/project/streaming_project2.conf \
-Dflume.root.logger=INFO,console

kafka-console-consumer.sh --zookeeper hadoop000:2181 --topic streamingtopic


数据清洗操作:从原始日志中取出我们所需要的字段信息就可以了

数据清洗结果类似如下:
ClickLog(46.30.10.167,20171022151701,128,200,-)
ClickLog(143.132.168.72,20171022151701,131,404,-)
ClickLog(10.55.168.87,20171022151701,131,500,-)
ClickLog(10.124.168.29,20171022151701,128,404,-)
ClickLog(98.30.87.143,20171022151701,131,404,-)
ClickLog(55.10.29.132,20171022151701,146,404,http://www.baidu.com/s?wd=Storm实战)
ClickLog(10.87.55.30,20171022151701,130,200,http://www.baidu.com/s?wd=Hadoop基础)
ClickLog(156.98.29.30,20171022151701,146,500,https://www.sogou.com/web?query=大数据面试)
ClickLog(10.72.87.124,20171022151801,146,500,-)
ClickLog(72.124.167.156,20171022151801,112,404,-)

到数据清洗完为止,日志中只包含了实战课程的日志


补充一点:希望你们的机器配置被太低
    Hadoop/ZK/HBase/Spark Streaming/Flume/Kafka
    hadoop000: 8Core  8G

功能1:今天到现在为止 实战课程 的访问量

    yyyyMMdd   courseid

使用数据库来进行存储我们的统计结果
    Spark Streaming把统计结果写入到数据库里面
    可视化前端根据:yyyyMMdd   courseid 把数据库里面的统计结果展示出来


选择什么数据库作为统计结果的存储呢?
    RDBMS: MySQL、Oracle...
        day        course_id  click_count
        20171111     1            10
        20171111     2            10

        下一个批次数据进来以后:
            20171111 + 1   ==> click_count + 下一个批次的统计结果  ==> 写入到数据库中

    NoSQL: HBase、Redis....
        HBase: 一个API就能搞定,非常方便
            20171111 + 1 ==> click_count + 下一个批次的统计结果
        本次课程为什么要选择HBase的一个原因所在

    前提:
        HDFS
        Zookeeper
        HBase ./start-hbase.sh 

全部启动完之后. ./hbase shell


    HBase表设计
        创建表
            create 'imooc_course_clickcount', 'info'
        Rowkey设计
            day_courseid    

如何使用Scala来操作HBase


代码运行卡在那里,我给看晕了,检查了一下8088端口打不开,然后服务器关了重新开,还去把yarn-site.xml重新配了下 

总算开起来然后代码跑起来了

org.apache.flume.ChannelFullException: Space for commit to queue couldn't be acquired. Sinks are likely not keeping up with sources, or the buffer size is too tight
机子不行,顶不住==

功能二:功能一+从搜索引擎引流过来的


HBase表设计
create 'imooc_course_search_clickcount','info'
rowkey设计:也是根据我们的业务需求来的

20171111 +search+ 1


hadoop000:2181 test streamingtopic 1

项目打包:mvn clean package -DskipTests

报错:
[ERROR] /Users/rocky/source/work/sparktrain/src/main/scala/com/imooc/spark/project/dao/CourseClickCountDAO.scala:4: error: object HBaseUtils is not a member 
of package com.imooc.spark.project.utils

spark-submit --master local[5] \
--class com.imooc.spark.project.spark.ImoocStatStreamingApp \
/home/hadoop/lib/sparktrain-1.0.jar \
hadoop000:2181 test streamingtopic 1


报错:
Exception in thread "main" java.lang.NoClassDefFoundError: org/apache/spark/streaming/kafka/KafkaUtils$
    at com.imooc.spark.project.spark.ImoocStatStreamingApp$.main(ImoocStatStreamingApp.scala:31)
    at com.imooc.spark.project.spark.ImoocStatStreamingApp.main(ImoocStatStreamingApp.scala)
    at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
    at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:62)
    at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43)
    at java.lang.reflect.Method.invoke(Method.java:498)
    at org.apache.spark.deploy.SparkSubmit$.org$apache$spark$deploy$SparkSubmit$$runMain(SparkSubmit.scala:755)
    at org.apache.spark.deploy.SparkSubmit$.doRunMain$1(SparkSubmit.scala:180)
    at org.apache.spark.deploy.SparkSubmit$.submit(SparkSubmit.scala:205)
    at org.apache.spark.deploy.SparkSubmit$.main(SparkSubmit.scala:119)
    at org.apache.spark.deploy.SparkSubmit.main(SparkSubmit.scala)
Caused by: java.lang.ClassNotFoundException: org.apache.spark.streaming.kafka.KafkaUtils$
    at java.net.URLClassLoader.findClass(URLClassLoader.java:381)
    at java.lang.ClassLoader.loadClass(ClassLoader.java:424)
    at java.lang.ClassLoader.loadClass(ClassLoader.java:357)
    ... 11 more


spark-submit --master local[5] \
--class com.imooc.spark.project.spark.ImoocStatStreamingApp \
--packages org.apache.spark:spark-streaming-kafka-0-8_2.11:2.2.0 \
/home/hadoop/lib/sparktrain-1.0.jar \
hadoop000:2181 test streamingtopic 1

java.lang.NoClassDefFoundError: org/apache/hadoop/hbase/client/HBaseAdmin
    at com.imooc.spark.project.utils.HBaseUtils.<init>(HBaseUtils.java:30)
    at com.imooc.spark.project.utils.HBaseUtils.getInstance(HBaseUtils.java:40)
    at com.imooc.spark.project.dao.CourseClickCountDAO$.save(CourseClickCountDAO.scala:26)
    at com.imooc.spark.project.spark.ImoocStatStreamingApp$$anonfun$main$4$$anonfun$apply$1.a


spark-submit --master local[5] \
--jars $(echo /home/hadoop/app/hbase-1.2.0-cdh5.7.0/lib/*.jar | tr ' ' ',') \
--class com.imooc.spark.project.spark.ImoocStatStreamingApp \
--packages org.apache.spark:spark-streaming-kafka-0-8_2.11:2.2.0 \
/home/hadoop/lib/sparktrain-1.0.jar \
hadoop000:2181 test streamingtopic 1

提交作业时,注意事项:
1)--packages的使用
2)--jars的使用

  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
### 回答1: Kafka和Spark Streaming大数据领域中非常重要的技术,它们可以协同工作,实现实时数据处理和分析。Kafka是一个分布式的消息队列系统,可以高效地处理海量数据流,而Spark Streaming则是一个基于Spark的流处理框架,可以实现实时数据处理和分析。在学习Kafka和Spark Streaming时,需要掌握它们的基本概念、原理和使用方法,以及如何将它们结合起来实现实时数据处理和分析。同时,还需要了解Kafka和Spark Streaming的优缺点,以及如何优化它们的性能和可靠性。 ### 回答2: Kafka是一个高性能,可扩展的分布式消息系统。它通过将消息划分成一个或多个主题,然后将这些主题划分成一个或多个分区来进行实现。Kafka是由LinkedIn开发的,由Apache基金会进行管理。它的主要设计目标是支持分布式处理,如流处理和批处理等。Kafka通过使用Zookeeper来进行节点管理和故障转移,能够快速处理海量的数据。Kafka采用发布/订阅模式,支持多个消费者订阅同一个主题,每个消费者可以读取主题的所有分区数据,也可以选择读取其中的某个分区。 Spark Streaming是一个流处理框架,它能够利用Spark的分布式处理能力来对实时数据进行处理。Spark Streaming采用微批处理的方式,将实时数据流切片成一段一段的,并通过并行处理的方式进行计算。Spark Streaming的数据源可以是Kafka、Flume或者TCP sockets等。与Kafka相比,Spark Streaming更适合于需要进行实时计算的场景,例如:实时日志分析、实时推荐、实时风控等。同时,Spark Streaming还能够与Spark的批处理进行无缝对接,实现流处理与批处理的统一计算引擎。Spark Streaming支持机器学习、图计算等高级计算库,能够为用户提供更强大的计算能力。 学习Kafka和Spark Streaming的过程中,需要掌握Java、Scala等编程语言基础知识,并具备分布式系统的相关知识。对于Kafka,需要了解其基本概念、架构、API等,理解消息系统、发布/订阅模式、分区等内容。对于Spark Streaming,需要掌握其基本概念、流式计算流程、数据源等,同时也要熟悉Spark的RDD、DataFrame等相关知识。在学习中,需要结合实际项目,进行代码实践和调试,同时不断学习、思考和总结,以加深对Kafka和Spark Streaming的理解和应用。 ### 回答3: Kafka是由Apache SoftWare Foundation开发的一种分布式发布/订阅消息系统。其主要目的是为数据传输提供一种高吞吐量、低延迟的解决方案。Kafka提供了一种可靠的、持久化的、实时的数据传输方式,适用于众多的场景,如:日志收集、数据传输、消息系统等。 Kafka的特点: 1、高吞吐量:Kafka可以支持非常高的数据传输吞吐量,同时保持低延迟和高稳定性。 2、可扩展性:Kafka可以轻松扩展以适应更大的数据需求,并可以在运行时添加新的主题分区。 3、持久化:Kafka保证数据能够可靠地在分布式集群中传输,同时保证数据不会丢失或者被意外删除。 4、多样化的客户端:Kafka提供了多种语言的客户端接口,以满足不同的开发需求。 SparkStreaming 是由Apache Spark社区发展的一个实时数据处理框架。它用于将实时数据流分成小批处理,可以跨越不同的时间窗口进行计算。Spark Streaming提供了与Spark非常相似的编程模型,同时支持不同的输入源,包括社交媒体、传感器、消息队列等。 SparkStreaming的特点: 1、处理速度快:它可以支持毫秒级别的处理速度,并且可以在分布式系统中实现高吞吐量。 2、支持多种数据源:Spark Streaming可以从多种类型的数据源中读取数据,如HDFS、Flume、Kafka等。 3、编程简单:Spark Streaming提供了与Spark相似的编程模式,使得开发人员可以将Spark StreamingSpark整合在一起进行处理。 4、高容错性:Spark Streaming在分布式环境中实现了高可靠性和容错性,使得它可以支持大规模的实时数据处理需求。 总之,Kafka和Spark Streaming这两个工具是在大数据处理领域中非常重要的工具。它们可以很好地相互结合,支持大规模的实时数据处理和分析,进而为企业提供更好更快的数据处理方案。如果你对这两个技术感兴趣,可以从官方文档和教程开始学习,逐步掌握它们的定义、特点、应用场景和基本使用方法。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值