【Storm】【综合案例】【一】Storm集群向Kafka集群写入数据【远程模式】

已于 2023-03-12 10:10:36 修改
阅读量270 收藏 1
点赞数 1
分类专栏： Storm 文章标签： kafka 数据库 storm
于 2023-03-08 02:53:04 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_41405524/article/details/129395315
版权

介绍

今天来实现一个Storm数据流处理综合案例的第一部分，Storm集群向Kafka集群源源不断写入数据，并部署为远程模式

准备工作

搭建三台Kafka集群服务器

参考文档：Linux部署Kafka集群

搭建三台Storm集群服务器

参考文档：Linux部署Storm集群

启动Kafka集群

启动Zookeeper

Zookeeper启动需要一定时间，建议等一分钟再操作其他命令

cd /usr/local/kafka/zookeeper

./bin/zkServer.sh start

在这里插入图片描述

启动Kafka集群

cd /usr/local/kafka/kafka

./bin/kafka-server-start.sh -daemon ./config/server.properties

在这里插入图片描述

查看启动的进程

注：jps命令需要安装JDK环境

jps

在这里插入图片描述

查看Topic

我们使用kafkatopic主题接受消息

cd /usr/local/kafka/kafka

./bin/kafka-topics.sh --list --bootstrap-server 192.168.217.151:9092

在这里插入图片描述

启动Storm集群

启动Zookeeper

zkServer.sh start

Zookeeper启动需要一定时间，建议等一分钟再操作其他命令

zkServer.sh status

在这里插入图片描述

启动Storm

主节点Nimbus

nohup storm nimbus > nohup.out 2>&1 &

nohup storm ui > nohup.out 2>&1 &

从节点Supervisor

nohup storm supervisor > nohup.out 2>&1 &

nohup storm logviewer > nohup.out 2>&1 &

在这里插入图片描述

查看进程

注：jps命令需要安装JDK环境

jps

在这里插入图片描述

代码编写

思路：Storm集群向Kafka集群的kafkatopic发送消息，Kafka集群启动两个消费者查看是否收到消息

项目结构

在这里插入图片描述

项目文件

POM

<?xml version="1.0" encoding="UTF-8"?>
<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/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.heibaiying</groupId>
    <artifactId>storm-kafka-integration</artifactId>
    <version>1.0</version>

    <properties>
        <storm.version>1.2.2</storm.version>
        <kafka.version>2.2.0</kafka.version>
    </properties>

    <dependencies>
        <dependency>
            <groupId>org.apache.storm</groupId>
            <artifactId>storm-core</artifactId>
            <version>${storm.version}</version>
        </dependency>
        <dependency>
            <groupId>org.apache.storm</groupId>
            <artifactId>storm-kafka-client</artifactId>
            <version>${storm.version}</version>
        </dependency>
        <dependency>
            <groupId>org.apache.kafka</groupId>
            <artifactId>kafka-clients</artifactId>
            <version>${kafka.version}</version>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <configuration>
                    <source>8</source>
                    <target>8</target>
                </configuration>
            </plugin>
            <!--使用shade进行打包-->
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-shade-plugin</artifactId>
                <configuration>
                    <createDependencyReducedPom>true</createDependencyReducedPom>
                    <filters>
                        <filter>
                            <artifact>*:*</artifact>
                            <excludes>
                                <exclude>META-INF/*.SF</exclude>
                                <exclude>META-INF/*.sf</exclude>
                                <exclude>META-INF/*.DSA</exclude>
                                <exclude>META-INF/*.dsa</exclude>
                                <exclude>META-INF/*.RSA</exclude>
                                <exclude>META-INF/*.rsa</exclude>
                                <exclude>META-INF/*.EC</exclude>
                                <exclude>META-INF/*.ec</exclude>
                                <exclude>META-INF/MSFTSIG.SF</exclude>
                                <exclude>META-INF/MSFTSIG.RSA</exclude>
                            </excludes>
                        </filter>
                    </filters>
                    <artifactSet>
                        <excludes>
                            <exclude>org.apache.storm:storm-core</exclude>
                        </excludes>
                    </artifactSet>
                </configuration>
                <executions>
                    <execution>
                        <phase>package</phase>
                        <goals>
                            <goal>shade</goal>
                        </goals>
                        <configuration>
                            <transformers>
                                <transformer
                                        implementation="org.apache.maven.plugins.shade.resource.ServicesResourceTransformer"/>
                                <transformer
                                        implementation="org.apache.maven.plugins.shade.resource.ManifestResourceTransformer">
                                </transformer>
                            </transformers>
                        </configuration>
                    </execution>
                </executions>
            </plugin>
        </plugins>
    </build>

</project>

Spout

package write;

import org.apache.storm.shade.org.apache.commons.lang.StringUtils;
import org.apache.storm.spout.SpoutOutputCollector;
import org.apache.storm.task.TopologyContext;
import org.apache.storm.topology.OutputFieldsDeclarer;
import org.apache.storm.topology.base.BaseRichSpout;
import org.apache.storm.tuple.Fields;
import org.apache.storm.tuple.Values;
import org.apache.storm.utils.Utils;

import java.util.*;

/**
 * 产生词频样本的数据源
 */
public class DataSourceSpout extends BaseRichSpout {

    private List<String> list = Arrays.asList("Spark", "Hadoop", "HBase", "Storm", "Flink", "Hive");

    private SpoutOutputCollector spoutOutputCollector;

    @Override
    public void open(Map map, TopologyContext topologyContext, SpoutOutputCollector spoutOutputCollector) {
        this.spoutOutputCollector = spoutOutputCollector;
    }

    @Override
    public void nextTuple() {
        // 模拟产生数据
        String lineData = productData();
        spoutOutputCollector.emit(new Values("key",lineData));
        System.err.println(lineData);
        Utils.sleep(1000);
    }

    @Override
    public void declareOutputFields(OutputFieldsDeclarer outputFieldsDeclarer) {
        outputFieldsDeclarer.declare( new Fields("key", "message"));
    }


    /**
     * 模拟数据
     */
    private String productData() {
        Collections.shuffle(list);
        Random random = new Random();
        int endIndex = random.nextInt(list.size()) % (list.size()) + 1;
        return StringUtils.join(list.toArray(), "\t", 0, endIndex);
    }

}

Topology

package write;

import org.apache.storm.Config;
import org.apache.storm.LocalCluster;
import org.apache.storm.StormSubmitter;
import org.apache.storm.generated.AlreadyAliveException;
import org.apache.storm.generated.AuthorizationException;
import org.apache.storm.generated.InvalidTopologyException;
import org.apache.storm.kafka.bolt.KafkaBolt;
import org.apache.storm.kafka.bolt.mapper.FieldNameBasedTupleToKafkaMapper;
import org.apache.storm.kafka.bolt.selector.DefaultTopicSelector;
import org.apache.storm.topology.TopologyBuilder;

import java.util.Properties;

/**
 * 写入数据到Kafka中
 */
public class WritingToKafkaApp {

    private static final String BOOTSTRAP_SERVERS = "192.168.217.151:9092,192.168.217.152:9092";
    private static final String TOPIC_NAME = "kafkatopic";

    public static void main(String[] args) {


        TopologyBuilder builder = new TopologyBuilder();

        // 定义Kafka生产者属性
        Properties props = new Properties();
        /*
         * 指定broker的地址清单，清单里不需要包含所有的broker地址，生产者会从给定的broker里查找其他broker的信息。
         * 不过建议至少要提供两个broker的信息作为容错。
         */
        props.put("bootstrap.servers", BOOTSTRAP_SERVERS);
        /*
         * acks 参数指定了必须要有多少个分区副本收到消息，生产者才会认为消息写入是成功的。
         * acks=0 : 生产者在成功写入消息之前不会等待任何来自服务器的响应。
         * acks=1 : 只要集群的首领节点收到消息，生产者就会收到一个来自服务器成功响应。
         * acks=all : 只有当所有参与复制的节点全部收到消息时，生产者才会收到一个来自服务器的成功响应。
         */
        props.put("acks", "all");
        props.put("key.serializer", "org.apache.kafka.common.serialization.StringSerializer");
        props.put("value.serializer", "org.apache.kafka.common.serialization.StringSerializer");

        KafkaBolt bolt = new KafkaBolt<String, String>()
                .withProducerProperties(props)
                .withTopicSelector(new DefaultTopicSelector(TOPIC_NAME))
                .withTupleToKafkaMapper(new FieldNameBasedTupleToKafkaMapper<>());

        builder.setSpout("sourceSpout", new DataSourceSpout(), 2).setNumTasks(2);
        builder.setBolt("kafkaBolt", bolt, 2).shuffleGrouping("sourceSpout").setNumTasks(2);

        Config config = new Config();
        config.setNumWorkers(4);
        config.setDebug(true);

        if (args.length > 0 && args[0].equals("cluster")) {
            try {
                StormSubmitter.submitTopology("StormClusterWritingToKafkaClusterApp", config, builder.createTopology());
            } catch (AlreadyAliveException | InvalidTopologyException | AuthorizationException e) {
                e.printStackTrace();
            }
        } else {
            LocalCluster cluster = new LocalCluster();
            cluster.submitTopology("LocalWritingToKafkaApp",
                    config, builder.createTopology());
        }
    }
}

远程部署

打包

使用shade打包

在这里插入图片描述

上传文件

文件只需上传到Nimbus节点即可

使用Nimbus节点启动Topology

storm jar storm-kafka-integration-1.0.jar  write.WritingToKafkaApp cluster

在这里插入图片描述

UI查看

在这里插入图片描述

验证测试

思路：在服务器的Kafka集群创建Kafka消费者，观察消费者能否收到Storm集群发送的消息

分别在两台Supervisor节点创建消费者，等待Storm生产者发送消息

Supervisor 1

cd /usr/local/kafka/kafka

./bin/kafka-console-consumer.sh --bootstrap-server 192.168.217.152:9092 --topic kafkatopic

Supervisor 2

cd /usr/local/kafka/kafka

./bin/kafka-console-consumer.sh --bootstrap-server 192.168.217.153:9092 --topic kafkatopic

在这里插入图片描述

可以看到启动消费者后，两台Kafka消费者都收到了Storm集群发来的消息了，至此，该功能已完成

BirdMan98
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
Storm-Kafka模块之写入kafka-KafkaBolt的使用及实现
Tony_老七
01-26 6913
Storm-Kafka模块之写入kafka-KafkaBolt的使用及实现
Storm综合案例一Storm集群向Kafka集群写入数据远程模式
03-12
今天来实现一个Storm数据流处理综合案例的第一部分，Storm集群向Kafka集群源源不断写入数据，并部署为远程模式 准备工作 搭建三台Kafka集群服务器 参考文档：Linux部署Kafka集群 搭建三台Storm集群服务器 参考...
storm与kafka进行集成写入HDFS
Chain的博客
07-18 367
接上篇storm与kafka进行集成，本篇将storm处理好的数据持久化到hdfs中，主要思路是将最后一个Bolt改为hdfsBolt，将kafka的输出进行分词 统计，将最后的统计结果提交到hdfsBolt中，保存到hdfs中。 （1）HDFSBolt简介 HdfsBolt类的集成层次关系： java.lang.Object继承 org.apache.storm.topology.bas...
2024年最新Go实时读取日志并写入kafka_go 批量写入kakfa，2024年最新神级Golang进阶笔记
最新发布
2401_84905010的博客
05-12 265
启动。
14.5 storm从kafka接收数据然后写入kafka
心雨先生
09-11 1656
package storm.starter.chenbo;   import backtype.storm.Config; import backtype.storm.LocalCluster; import backtype.storm.StormSubmitter; import backtype.storm.task.ShellBolt; import backtype.stor...
【Storm】【综合案例】【二】Storm集群向Kafka集群读取数据并写入MySQL【远程模式】
鸟人的博客
03-12 375
今天接上文，来实现一个Storm数据流处理综合案例的，Storm集群向Kafka集群源源不断，并部署为远程模式。
STORM入门之（集成KafkaBolt）
阿达丶
08-21 951
根据第一篇文章：STORM入门之（Topology简易Demo）进行扩展集成Kafka STORM入门之（集成KAFKA）传送门：http://blog.csdn.net/yl3395017/article/details/77449275 新增Bolt： package com.storm.bolt; import java.util.Map; import org.apache.stor
Storm综合案例二Storm集群向Kafka集群读取数据并写入MySQL远程模式
03-12
今天接上文，来实现一个Storm数据流处理综合案例的第二部分，Storm集群向Kafka集群源源不断读取数据，通过MyBatis写入到MySQL数据库，并部署为远程模式 准备工作 参考上文准备工作 代码编写 思路：Storm集群从...
StormStorm集成Kafka 从Kafka中读取数据
03-12
5. 启动拓扑：提交拓扑到Storm集群，开始从Kafka读取和处理数据。 在处理数据时，Storm会维护一个内部offset（偏移量）来跟踪在Kafka中的位置，保证数据不丢失。`KafkaSpout`会自动处理容错和幂等性，确保在出现...
storm之集成kafka操作示例代码.zip
12-28
Spout会连接到Kafka集群，订阅特定的主题，并持续地将新产生的消息作为数据流发送给Storm的topology。 4. **创建Kafka Spout**：在Java中，我们可以使用`org.apache.storm.kafka.ZkCoordinator`和`org.apache.storm...
使用Storm实时处理交通大数据（数据源：kafka，集群管理：zookeeper）.zip
03-04
4. **集群管理**：ZooKeeper监控Storm集群的运行状态，确保数据处理的稳定性和一致性。 通过这样的架构，可以实现对交通大数据的实时分析，对于优化交通流量、预测拥堵、提高道路安全等方面具有重要意义。同时，...
kafkastorm:kafka整合storm案例
05-17
kafkastorm kafka整合storm案例
storm和kafka结合的一个小问题
anzhuangguai的专栏
05-13 1274
参考文档中说到 打包上传到服务器，运行 Storm jar jarname CountTopology     回车，会看到他在等待数据传入。 这个时候运行kafka消费者程序，将数据输出，则会看到storm 会迅速输出数据和统计数目。 这里测试不写了。 正确的说法是： 是运行kafka生产者程序，将数据输入到storm，这时会看到storm 会迅速输出数据和统计数目。
向Kafka写入数据
weixin_39120411的博客
04-11 5427
不管是把 Kafka 作为消息队列、消息总线还是数据存储平台来使用，总是需要有一个可以 往 Kafka 写入数据的生产者和一个可以从 Kafka 读取数据的消费者，或者一个兼具两种角 色的应用程序。 例如，在一个信用卡事务处理系统里，有一个客户端应用程序，它可能是一个在线商店， 每当有支付行为发生时，它负责把事务发送到 Kafka 上。另一个应用程序根据规则引擎检 查这个事务，决定是批准还是拒绝。...
Kafka生产者发送流程详解
qq_53578500的博客
08-16 2568
实现Partitioner接口，重写方法即可，返回对应的分区值。还需要再主程序关联我们自定义的分区（在Properties中声明），不然它会走默认的分区策略例如：我们想让含有“china”相关的字符串，存到主题为china的分区里。我们可以通过去判断value里是否包含china，如果包含就指明对应的分区号即可。.........
Kafka生产者——向 Kafka写入数据
weixin_33774883的博客
08-10 1869
不管是把 Kafka 作为消息队列、消息、总线还是数据存储平台来使用 ，总是需要有一个可以往 Kafka 写入数据的生产者和一个可以从 Kafka读取数据的消费者，或者一个兼具两种角 色的应用程序。 例如，在一个信用卡事务处理系统里，有一个客户端应用程序，它可能是一个在线商店， 每当有支付行为发生时，它负责把...
2024年Go实时读取日志并写入kafka_go 批量写入kakfa(1)，2024最新网易Golang面经
2401_84910869的博客
05-11 322
启动。
kafka生产者发送消息流程分析
ChinaCR07的博客
03-26 1585
kafka生产者发送消息流程分析
kafka-storm
Beater博客的日常
03-01 962
Kafka和storm集群环境安装 这两者的依赖如下: Storm集群：JDK1.8 , Zookeeper3.4，Storm1.1.1； Kafa集群 : JDK1.8 ，Zookeeper3.4 ，Kafka2.12； 文件准备 环境配置 修改配置文件 启动 Storm 分布式实时大数据处理框架 Storm的核心组件： Nimbus：即Storm的Master，负责资源分配和任务调度。一个...
Flume-Kafka-Storm数据流整合实战
这个整合流程展示了如何构建一个实时数据流处理系统，从数据的生成（telnet）到收集（Flume），再到存储（Kafka）和分析（Storm）。这种架构在大数据实时分析和监控场景中非常常见，例如日志分析、用户行为追踪等。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

BirdMan98

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值