c++ kafka环境配置

最新推荐文章于 2024-09-12 07:36:16 发布
最新推荐文章于 2024-09-12 07:36:16 发布
阅读量2k 收藏 16
点赞数 1
分类专栏： 环境配置 文章标签： kafka c++ 分布式
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/tu_dresden/article/details/120898877
版权
本文详细介绍了在Ubuntu环境中，如何配置Java环境、安装Kafka以及启动Zookeeper和Kafka服务。接着，讲解了创建和管理Kafka的topic，以及如何创建Producer和Consumer进行消息收发。此外，还展示了如何在C++中使用Qt和librdkafka库实现消息的生产和消费。通过示例代码，读者可以了解到具体的操作步骤和关键函数的用法。
摘要由CSDN通过智能技术生成

本文主要介绍C++ Qt Ubuntu环境下卡夫卡的环境配置和基本收发，整理自@草上爬大神。原贴：https://blog.csdn.net/caoshangpa/article/details/79786100
非常感谢原作者。

kafka依赖安装

卡夫卡需要java才能运行，可安装openjdk11

sudo apt install openjdk-11-jdk

检查版本

java -version

kafka安装和试运行

首先下载kafkahttp://kafka.apache.org/downloads，选择scala那个。
解压即可。
卡夫卡的完整链路需要zookeeper，kafka服务，生产者，消费者四个模块。
进入解压好的目录，打开终端，输入以下指令。
开启zookeeper：

bin/zookeeper-server-start.sh config/zookeeper.properties

开启kafka服务：

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

kafka是订阅发布制的通信系统，所以需要topic来进行管理。创建一个名为test的topic：

bin/kafka-topics.sh --create --zookeeper localhost:2181 --replication-factor 1 --partitions 1 --topic test

查看topic

bin/kafka-topics.sh --list --zookeeper localhost:2181

创建producer:

bin/kafka-console-producer.sh --broker-list localhost:9092 --topic test

创建consumer:

bin/kafka-console-consumer.sh --bootstrap-server localhost:9092 --topic test --from-beginning

接下来，在producer终端输入信息，consumer就可以收到啦。

librdkafka安装

首先克隆librdkafka项目：

git clone https://github.com/edenhill/librdkafka.git

接下来安装：

cd librdkafka/
./configure 
make
sudo make install
-lrdkafka++

librdkafka试运行

新建一个QT工程，在.pro文件引入librdkafka：

INCLUDEPATH += /usr/local/include/librdkafka
LIBS += -L/usr/local/lib -lrdkafka
LIBS += -L/usr/local/lib -lrdkafka++

生产者源文件如下：

#include <iostream>
#include <string>
#include <cstdlib>
#include <cstdio>
#include <csignal>
#include <cstring>
 
#include <getopt.h>
 
#include "rdkafkacpp.h"
 
static bool run = true;
 
static void sigterm (int sig) {
    run = false;
}
 
class ExampleDeliveryReportCb : public RdKafka::DeliveryReportCb {
public:
    void dr_cb (RdKafka::Message &message) {
        std::cout << "Message delivery for (" << message.len() << " bytes): " <<
                     message.errstr() << std::endl;
        if (message.key())
            std::cout << "Key: " << *(message.key()) << ";" << std::endl;
    }
};
 
class ExampleEventCb : public RdKafka::EventCb {
public:
    void event_cb (RdKafka::Event &event) {
        switch (event.type())
        {
        case RdKafka::Event::EVENT_ERROR:
            std::cerr << "ERROR (" << RdKafka::err2str(event.err()) << "): " <<
                         event.str() << std::endl;
            if (event.err() == RdKafka::ERR__ALL_BROKERS_DOWN)
                run = false;
            break;
 
        case RdKafka::Event::EVENT_STATS:
            std::cerr << "\"STATS\": " << event.str() << std::endl;
            break;
 
        case RdKafka::Event::EVENT_LOG:
            fprintf(stderr, "LOG-%i-%s: %s\n",
                    event.severity(), event.fac().c_str(), event.str().c_str());
            break;
 
        default:
            std::cerr << "EVENT " << event.type() <<
                         " (" << RdKafka::err2str(event.err()) << "): " <<
                         event.str() << std::endl;
            break;
        }
    }
};
 
int main ()
{
    std::string brokers = "localhost";
    std::string errstr;
    std::string topic_str="test";
    int32_t partition = RdKafka::Topic::PARTITION_UA;
 
    RdKafka::Conf *conf = RdKafka::Conf::create(RdKafka::Conf::CONF_GLOBAL);
    RdKafka::Conf *tconf = RdKafka::Conf::create(RdKafka::Conf::CONF_TOPIC);
 
    conf->set("bootstrap.servers", brokers, errstr);
 
    ExampleEventCb ex_event_cb;
    conf->set("event_cb", &ex_event_cb, errstr);
 
    signal(SIGINT, sigterm);
    signal(SIGTERM, sigterm);
 
    ExampleDeliveryReportCb ex_dr_cb;
    conf->set("dr_cb", &ex_dr_cb, errstr);
 
    RdKafka::Producer *producer = RdKafka::Producer::create(conf, errstr);
    if (!producer) {
        std::cerr << "Failed to create producer: " << errstr << std::endl;
        exit(1);
    }
    std::cout << "% Created producer " << producer->name() << std::endl;
 
    RdKafka::Topic *topic = RdKafka::Topic::create(producer, topic_str,
                                                   tconf, errstr);
    if (!topic) {
        std::cerr << "Failed to create topic: " << errstr << std::endl;
        exit(1);
    }
 
    for (std::string line; run && std::getline(std::cin, line);) {
        if (line.empty()) {
            producer->poll(0);
            continue;
        }
 
        RdKafka::ErrorCode resp =
                producer->produce(topic, partition,
                                  RdKafka::Producer::RK_MSG_COPY /* Copy payload */,
                                  const_cast<char *>(line.c_str()), line.size(),
                                  NULL, NULL);
        if (resp != RdKafka::ERR_NO_ERROR)
            std::cerr << "% Produce failed: " <<
                         RdKafka::err2str(resp) << std::endl;
        else
            std::cerr << "% Produced message (" << line.size() << " bytes)" <<
                         std::endl;
 
        producer->poll(0);
    }
 
    run = true;
   // 退出前处理完输出队列中的消息
    while (run && producer->outq_len() > 0) {
        std::cerr << "Waiting for " << producer->outq_len() << std::endl;
        producer->poll(1000);
    }
 
    delete conf;
    delete tconf;
    delete topic;
    delete producer;
 
    RdKafka::wait_destroyed(5000);
 
    return 0;
}

消费者工程文件同上，源文件如下：

#include <iostream>
#include <string>
#include <cstdlib>
#include <cstdio>
#include <csignal>
#include <cstring>
 
#include <sys/time.h>
#include <getopt.h>
#include <unistd.h>
 
#include "rdkafkacpp.h"
 
static bool run = true;
static bool exit_eof = true;
static int eof_cnt = 0;
static int partition_cnt = 0;
static int verbosity = 1;
static long msg_cnt = 0;
static int64_t msg_bytes = 0;
 
static void sigterm (int sig) {
    run = false;
}
 
class ExampleEventCb : public RdKafka::EventCb {
public:
    void event_cb (RdKafka::Event &event) {
        switch (event.type())
        {
        case RdKafka::Event::EVENT_ERROR:
            std::cerr << "ERROR (" << RdKafka::err2str(event.err()) << "): " <<
                         event.str() << std::endl;
            if (event.err() == RdKafka::ERR__ALL_BROKERS_DOWN)
                run = false;
            break;
 
        case RdKafka::Event::EVENT_STATS:
            std::cerr << "\"STATS\": " << event.str() << std::endl;
            break;
 
        case RdKafka::Event::EVENT_LOG:
            fprintf(stderr, "LOG-%i-%s: %s\n",
                    event.severity(), event.fac().c_str(), event.str().c_str());
            break;
 
        case RdKafka::Event::EVENT_THROTTLE:
            std::cerr << "THROTTLED: " << event.throttle_time() << "ms by " <<
                         event.broker_name() << " id " << (int)event.broker_id() << std::endl;
            break;
 
        default:
            std::cerr << "EVENT " << event.type() <<
                         " (" << RdKafka::err2str(event.err()) << "): " <<
                         event.str() << std::endl;
            break;
        }
    }
};
 
void msg_consume(RdKafka::Message* message, void* opaque) {
    switch (message->err()) {
    case RdKafka::ERR__TIMED_OUT:
        //std::cerr << "RdKafka::ERR__TIMED_OUT"<<std::endl;
        break;
 
    case RdKafka::ERR_NO_ERROR:
        /* Real message */
        msg_cnt++;
        msg_bytes += message->len();
        if (verbosity >= 3)
            std::cerr << "Read msg at offset " << message->offset() << std::endl;
        RdKafka::MessageTimestamp ts;
        ts = message->timestamp();
        if (verbosity >= 2 &&
                ts.type != RdKafka::MessageTimestamp::MSG_TIMESTAMP_NOT_AVAILABLE) {
            std::string tsname = "?";
            if (ts.type == RdKafka::MessageTimestamp::MSG_TIMESTAMP_CREATE_TIME)
                tsname = "create time";
            else if (ts.type == RdKafka::MessageTimestamp::MSG_TIMESTAMP_LOG_APPEND_TIME)
                tsname = "log append time";
            std::cout << "Timestamp: " << tsname << " " << ts.timestamp << std::endl;
        }
        if (verbosity >= 2 && message->key()) {
            std::cout << "Key: " << *message->key() << std::endl;
        }
        if (verbosity >= 1) {
            printf("%.*s\n",
                   static_cast<int>(message->len()),
                   static_cast<const char *>(message->payload()));
        }
        break;
 
    case RdKafka::ERR__PARTITION_EOF:
        /* Last message */
        if (exit_eof && ++eof_cnt == partition_cnt) {
            std::cerr << "%% EOF reached for all " << partition_cnt <<
                         " partition(s)" << std::endl;
            run = false;
        }
        break;
 
    case RdKafka::ERR__UNKNOWN_TOPIC:
    case RdKafka::ERR__UNKNOWN_PARTITION:
        std::cerr << "Consume failed: " << message->errstr() << std::endl;
        run = false;
        break;
 
    default:
        /* Errors */
        std::cerr << "Consume failed: " << message->errstr() << std::endl;
        run = false;
    }
}
 
class ExampleConsumeCb : public RdKafka::ConsumeCb {
public:
    void consume_cb (RdKafka::Message &msg, void *opaque) {
        msg_consume(&msg, opaque);
    }
};
 
int main () {
    std::string brokers = "localhost";
    std::string errstr;
    std::string topic_str="test";
    std::vector<std::string> topics;
    std::string group_id="101";
 
    RdKafka::Conf *conf = RdKafka::Conf::create(RdKafka::Conf::CONF_GLOBAL);
    RdKafka::Conf *tconf = RdKafka::Conf::create(RdKafka::Conf::CONF_TOPIC);
    //group.id必须设置
    if (conf->set("group.id", group_id, errstr) != RdKafka::Conf::CONF_OK) {
           std::cerr << errstr << std::endl;
           exit(1);
         }
 
    topics.push_back(topic_str);
   //bootstrap.servers可以替换为metadata.broker.list
    conf->set("bootstrap.servers", brokers, errstr);
 
    ExampleConsumeCb ex_consume_cb;
    conf->set("consume_cb", &ex_consume_cb, errstr);
 
    ExampleEventCb ex_event_cb;
    conf->set("event_cb", &ex_event_cb, errstr);
    conf->set("default_topic_conf", tconf, errstr);
 
    signal(SIGINT, sigterm);
    signal(SIGTERM, sigterm);
 
    RdKafka::KafkaConsumer *consumer = RdKafka::KafkaConsumer::create(conf, errstr);
    if (!consumer) {
        std::cerr << "Failed to create consumer: " << errstr << std::endl;
        exit(1);
    }
    std::cout << "% Created consumer " << consumer->name() << std::endl;
 
    RdKafka::ErrorCode err = consumer->subscribe(topics);
    if (err) {
        std::cerr << "Failed to subscribe to " << topics.size() << " topics: "
                  << RdKafka::err2str(err) << std::endl;
        exit(1);
    }
 
    while (run) {
        //5000毫秒未订阅到消息，触发RdKafka::ERR__TIMED_OUT
        RdKafka::Message *msg = consumer->consume(5000);
        msg_consume(msg, NULL);
        delete msg;
    }
 
    consumer->close();
 
    delete conf;
    delete tconf;
    delete consumer;
 
    std::cerr << "% Consumed " << msg_cnt << " messages ("
              << msg_bytes << " bytes)" << std::endl;
 
    //应用退出之前等待rdkafka清理资源
    RdKafka::wait_destroyed(5000);
 
    return 0;
}

运行zookeeper和kafka服务，再编译运行这两个文件，即可实现qq一样的收发功能。

工具人ToolBoy
关注
专栏目录
Windows上搭建Kafka运行环境
weixin_30252155的博客
08-22 215
完整解决方案请参考： Setting Up and Running Apache Kafka on Windows OS 在环境搭建过程中遇到两个问题，在这里先列出来，以方便查询： 1.\Java\jre7\lib\ext\QTJava.zip was unexpected at this time. Process exited 解决方案： 1.1 右键点击“我的电...
mykafka_C++
02-01
Linux qtcreator下kafka之librdkafka库的C++封装，实现生产和消费
CSDN博客爬虫使用手册
最新发布
gitblog_00361的博客
09-12 512
CSDN博客爬虫使用手册 CSDN-spider 爬取csdn文章并转换为md 项目地址: https://gitcode.com/gh_mirrors/csd/CSDN-spider ...
c++ kafka
weixin_43803780的博客
07-13 831
请确保将上述代码中的 `localhost:9092` 替换为你实际的 Kafka 服务器地址。这两个示例展示了如何在 C++ 中使用 Kafka 进行消息的生产和消费。首先，你需要安装 Confluent 的 Kafka C++ 客户端。在 C++ 中使用 Kafka，通常我们会使用 Confluent 的 Kafka C++ 客户端库。下面我将给出一个简单的示例，展示如何使用这个库来创建一个生产者和一个消费者。// 创建一个生产者配置实例。// 等待所有消息发送完成。// 创建一个生产者实例。
C++ 向kafka中发送数据
qq_37845417的博客
11-12 5654
kafka是一个分布式流处理的平台，通过kafka我们可以发布和订阅流式记录。有关kafka的介绍可以参考官网或者这篇文章https://juejin.im/post/6844903495670169607，介绍的非常的详细。 我个人喜欢把kafka当做数据库去理解，因为它也有存放数据的功能，但是还是与数据库是不一样的。 kafka中多个broker称为一个集群，一个broker（独立的kafka服务器）中可以创建不同的topic（主题），topic下可以建立多个partition（分区），数据则存放在分区
Kafka：C++ 实践
you_fathe的博客
12-05 2081
Kafka C++ 实战
快速上手：学习如何使用C++实现kafka消费者客户端
Lion_Long的博客
12-01 3998
一、Kafka 消费者的逻辑。 二、Kafka 的C++ API。 三、Kafka 消费者客户端开发：必要的参数配置、订阅主题和分区、消息消费、完整示例代码。 四、位移提交：自动提交、手动提交、提交API。 五、消费Rebalance机制。
win32 C++ kafka 库
01-22
本资源专注于在Windows 32位环境下，利用C++语言与Kafka进行交互的库。 标题"win32 C++ kafka 库"指的是一个专门为32位Windows操作系统编译的C++库，用于与Apache Kafka进行通信。这个库提供了C++接口，使得开发者...
windows的kafka配置及c++工程.zip
09-11
本资源是windows下kafka的环境配置及c++实现的kafka的producer相关代码，启动后可以测试c++的producer发送消息可以在windows下启动的kafka的customer接收消息。
kafka linux C++ 动态库
06-12
标题 "kafka linux C++ 动态库" 涉及到的是在Linux环境下使用C++与Apache Kafka进行交互，并且使用的是动态链接库。Kafka是一个分布式流处理平台，常用于构建实时数据管道和流应用。在C++中与Kafka交互时，通常会...
Kafka - a simple consumer demo - c++
ShiShc
11-29 2320
Kafka 如果有 kafka 基础的同学可以不用看前面的废话，可以从第五条 [配置] 开始看起～ 代码在第七条 前言：官网比我这标准多了～ 官网跳转，大家可以先完成quickStart部分kafka单机生产消费 一、概念简介 Kafka 是一个分布式流处理平台，常被用作消息队列中间件。具有横向扩展，容错，高速等优点。 Kafka中的概念 record: 由 key , value , timestamp 组成，Kafka 集群会保持所有的消息，直到它们过期，无论消息是否被消费。Kafka 的
Kafka C++客户端库librdkafka笔记
09-09
librdkafka提供的异步的生产接口，异步的消费接口和同步的消息接口，没有同步的生产接口。
librdkafka c++ API 中文版
08-26
自己看了libkafka的源码后翻译的，有些地方翻译不到位还请多多包涵。
kafka,zookeeper,librdkafka(用于c++客户端的库)以及生产者消费者等的示例代码
10-26
kafka,zookeeper,librdkafka(用于c++客户端的库)以及生产者消费者等的示例代码。以上安装包均是目前为止最新的安装包，如果需要别的版本安装包，文件中赋有各安装包下载地址，以供下载，希望能够帮助到你
win32下的kafkac++ api
08-10
包含.dll和.lib和zlibd.dll和rdkafka.h
Windows系统搭建Kafka C++ 客户端实现消息avro序列化发送
risen999的博客
06-25 2185
需求： 在原在水力发电厂在线监测VC++6.0软件中实现kafka C++客户端，将原始波形信号及计算指标点通过消息avro序列化发送给大数据平台侧kafka集群。 C++搭建kafka客户端用了我半个月的时间，avro序列化用了半个月的时间。相信好多人也是苦于没有系统性的参考耽误了好多工夫，我写这篇文档希望能给别人一些辅助。 开发准备工作： 本地装了一套kafka的环境： 序...
c++操作kafka
weixin_30521649的博客
04-09 1504
通过调用librdkafka库实现操作kafka 消费者： 1 #include <vector> 2 #include <string> 3 #include <memory> 4 #include <getopt.h> 5 #include <csignal> 6 #include <iostr...
kafka（四）——生产者流程分析(c++)
www_dong的博客
04-08 1144
1（all）：生产者发送过来的数据，等待所有副本将数据同步后发送下一条数据，性能最慢，安全性最高；消息保序策略：按key分区，可以实现局部有序，但这又可能会导致数据倾斜，可根据实际情况选择。1：生产者发送过来的数据，等待Leader副本确认后发送下一条数据，性能中等；producer的acks参数表示生产者生产消息时，写入到副本的严格程度。
Kafka 简易教程 C++ 实例
Devour_的博客
07-28 4169
Kafka 简易教程 1.初识概念 Apache Kafka是一个分布式消息发布订阅系统。 Topic Kafka将消息种子(Feed)分门别类， 每一类的消息称之为话题(Topic). Producer 发布消息的对象称之为话题生产者(Kafka topic producer) Consumer 订阅消息并处理发布的消息的种子的对象称之为话题消费者(consumers) Broker 已发布的消息保存在一组服务器中，称之为Kafka集群。集群中的每一个服务器都是一个代理(Broker). 消费者可以订阅一
C++ Kafka 动态链接库DLL开箱即用支持VS2010
资源摘要信息:"该压缩包名为 'c_rdkfk.zip'，提供了C++环境下操作Kafka的动态链接库文件（DLL和LIB），这些文件已经预先编译完成，适用于立即使用，特别是支持Visual Studio 2010开发环境的项目。用户可以直接集成...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

工具人ToolBoy

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

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

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

打赏作者

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

抵扣说明：

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

余额充值