.NET Core 下使用 Kafka

最新推荐文章于 2023-01-30 08:00:52 发布
最新推荐文章于 2023-01-30 08:00:52 发布
阅读量1.2k 收藏 3
点赞数
分类专栏： NET Core跨平台+CoreCLR+C# 消息队列【kafka】 文章标签： kafka .netcore 大数据
原文链接：https://blog.csdn.net/WuLex
版权

安装

  • CentOS 安装 kafka
  • docker下安装Kafka
    docker pull wurstmeister/kafka
docker run -d --name kafka --publish 9092:9092 --link zookeeper --env KAFKA_ZOOKEEPER_CONNECT=zookeeper:2181 --env KAFKA_ADVERTISED_HOST_NAME=192.168.1.111 --env KAFKA_ADVERTISED_PORT=9092 wurstmeister/kafka

介绍

  • Broker：消息中间件处理节点，一个Kafka节点就是一个broker，多个broker可以组成一个Kafka集群。
  • Topic：一类消息，例如page view日志、click日志等都可以以topic的形式存在，Kafka集群能够同时负责多个topic的分发。
  • Partition：topic物理上的分组，一个topic可以分为多个partition，每个partition是一个有序的队列。
  • Segment：partition物理上由多个segment组成，下面2.2和2.3有详细说明。
  • offset：每个partition都由一系列有序的、不可变的消息组成，这些消息被连续的追加到partition中。partition中的每个消息都有一个连续的序列号叫做offset,用于partition唯一标识一条消息。

在这里插入图片描述
kafka partition 和 consumer 数目关系

  • 如果consumer比partition多是浪费，因为kafka的设计是在一个partition上是不允许并发的，所以consumer数不要大于partition数 。
  • 如果consumer比partition少，一个consumer会对应于多个partitions，这里主要合理分配consumer数和partition数，否则会导致partition里面的数据被取的不均匀 。最好partiton数目是consumer数目的整数倍，所以partition数目很重要，比如取24，就很容易设定consumer数目 。
  • 如果consumer从多个partition读到数据，不保证数据间的顺序性，kafka只保证在一个partition上数据是有序的，但多个partition，根据你读的顺序会有不同
  • 增减consumer，broker，partition会导致rebalance，所以rebalance后consumer对应的partition会发生变化

快速开始

在 .NET Core 项目中安装组件

Install-Package Confluent.Kafka

开源地址：https://github.com/confluentinc/confluent-kafka-dotnet

添加IKafkaService服务接口

public interface IKafkaService
{
    /// <summary>
    /// 发送消息至指定主题
    /// </summary>
    /// <typeparam name="TMessage"></typeparam>
    /// <param name="topicName"></param>
    /// <param name="message"></param>
    /// <returns></returns>
    Task PublishAsync<TMessage>(string topicName, TMessage message) where TMessage : class;
    /// <summary>
    /// 从指定主题订阅消息
    /// </summary>
    /// <typeparam name="TMessage"></typeparam>
    /// <param name="topics"></param>
    /// <param name="messageFunc"></param>
    /// <param name="cancellationToken"></param>
    /// <returns></returns>
    Task SubscribeAsync<TMessage>(IEnumerable<string> topics, Action<TMessage> messageFunc, CancellationToken cancellationToken) where TMessage : class;
}

实现IKafkaService

public class KafkaService : IKafkaService
{
    public async Task PublishAsync<TMessage>(string topicName, TMessage message) where TMessage : class
    {
        var config = new ProducerConfig
        {
            BootstrapServers = "127.0.0.1:9092"
        };
        using var producer = new ProducerBuilder<string, string>(config).Build();
        await producer.ProduceAsync(topicName, new Message<string, string>
        {
            Key = Guid.NewGuid().ToString(),
            Value = message.SerializeToJson()
        });
    }
    public async Task SubscribeAsync<TMessage>(IEnumerable<string> topics, Action<TMessage> messageFunc, CancellationToken cancellationToken) where TMessage : class
    {
        var config = new ConsumerConfig
        {
            BootstrapServers = "127.0.0.1:9092",
            GroupId = "consumer",
            EnableAutoCommit = false,
            StatisticsIntervalMs = 5000,
            SessionTimeoutMs = 6000,
            AutoOffsetReset = AutoOffsetReset.Earliest,
            EnablePartitionEof = true
        };
        //const int commitPeriod = 5;
        using var consumer = new ConsumerBuilder<Ignore, string>(config)
                             .SetErrorHandler((_, e) =>
                             {
                                 Console.WriteLine($"Error: {e.Reason}");
                             })
                             .SetStatisticsHandler((_, json) =>
                             {
                                 Console.WriteLine($" - {DateTime.Now:yyyy-MM-dd HH:mm:ss} > 消息监听中..");
                             })
                             .SetPartitionsAssignedHandler((c, partitions) =>
                             {
                                 string partitionsStr = string.Join(", ", partitions);
                                 Console.WriteLine($" - 分配的 kafka 分区: {partitionsStr}");
                             })
                             .SetPartitionsRevokedHandler((c, partitions) =>
                             {
                                 string partitionsStr = string.Join(", ", partitions);
                                 Console.WriteLine($" - 回收了 kafka 的分区: {partitionsStr}");
                             })
                             .Build();
        consumer.Subscribe(topics);
        try
        {
            while (true)
            {
                try
                {
                    var consumeResult = consumer.Consume(cancellationToken);
                    Console.WriteLine($"Consumed message '{consumeResult.Message?.Value}' at: '{consumeResult?.TopicPartitionOffset}'.");
                    if (consumeResult.IsPartitionEOF)
                    {
                        Console.WriteLine($" - {DateTime.Now:yyyy-MM-dd HH:mm:ss} 已经到底了：{consumeResult.Topic}, partition {consumeResult.Partition}, offset {consumeResult.Offset}.");
                        continue;
                    }
                    TMessage messageResult = null;
                    try
                    {
                        messageResult = JsonConvert.DeserializeObject<TMessage>(consumeResult.Message.Value);
                    }
                    catch (Exception ex)
                    {
                        var errorMessage = $" - {DateTime.Now:yyyy-MM-dd HH:mm:ss}【Exception 消息反序列化失败，Value：{consumeResult.Message.Value}】 ：{ex.StackTrace?.ToString()}";
                        Console.WriteLine(errorMessage);
                        messageResult = null;
                    }
                    if (messageResult != null/* && consumeResult.Offset % commitPeriod == 0*/)
                    {
                        messageFunc(messageResult);
                        try
                        {
                            consumer.Commit(consumeResult);
                        }
                        catch (KafkaException e)
                        {
                            Console.WriteLine(e.Message);
                        }
                    }
                }
                catch (ConsumeException e)
                {
                    Console.WriteLine($"Consume error: {e.Error.Reason}");
                }
            }
        }
        catch (OperationCanceledException)
        {
            Console.WriteLine("Closing consumer.");
            consumer.Close();
        }
        await Task.CompletedTask;
    }
}

注入IKafkaService，在需要使用的地方直接调用即可。

public class MessageService : IMessageService, ITransientDependency
{
    private readonly IKafkaService _kafkaService;
    public MessageService(IKafkaService kafkaService)
    {
        _kafkaService = kafkaService;
    }
    public async Task RequestTraceAdded(XxxEventData eventData)
    {
        await _kafkaService.PublishAsync(eventData.TopicName, eventData);
    }
}

以上相当于一个生产者，当我们消息队列发出后，还需一个消费者进行消费，所以可以使用一个控制台项目接收消息来处理业务。

var cts = new CancellationTokenSource();
Console.CancelKeyPress += (_, e) =>
{
    e.Cancel = true;
    cts.Cancel();
};
await kafkaService.SubscribeAsync<XxxEventData>(topics, async (eventData) =>
{
    // Your logic
    Console.WriteLine($" - {eventData.EventTime:yyyy-MM-dd HH:mm:ss} 【{eventData.TopicName}】- > 已处理");
}, cts.Token);

在IKafkaService中已经写了订阅消息的接口，这里也是注入后直接使用即可。

生产者消费者示例

生产者

static async Task Main(string[] args)
{
    if (args.Length != 2)
    {
        Console.WriteLine("Usage: .. brokerList topicName");
        // 127.0.0.1:9092 helloTopic
        return;
    }
    var brokerList = args.First();
    var topicName = args.Last();
    var config = new ProducerConfig { BootstrapServers = brokerList };
    using var producer = new ProducerBuilder<string, string>(config).Build();
    Console.WriteLine("\n-----------------------------------------------------------------------");
    Console.WriteLine($"Producer {producer.Name} producing on topic {topicName}.");
    Console.WriteLine("-----------------------------------------------------------------------");
    Console.WriteLine("To create a kafka message with UTF-8 encoded key and value:");
    Console.WriteLine("> key value<Enter>");
    Console.WriteLine("To create a kafka message with a null key and UTF-8 encoded value:");
    Console.WriteLine("> value<enter>");
    Console.WriteLine("Ctrl-C to quit.\n");
    var cancelled = false;
    Console.CancelKeyPress += (_, e) =>
    {
        e.Cancel = true;
        cancelled = true;
    };
    while (!cancelled)
    {
        Console.Write("> ");
        var text = string.Empty;
        try
        {
            text = Console.ReadLine();
        }
        catch (IOException)
        {
            break;
        }
        if (string.IsNullOrWhiteSpace(text))
        {
            break;
        }
        var key = string.Empty;
        var val = text;
        var index = text.IndexOf(" ");
        if (index != -1)
        {
            key = text.Substring(0, index);
            val = text.Substring(index + 1);
        }
        try
        {
            var deliveryResult = await producer.ProduceAsync(topicName, new Message<string, string>
            {
                Key = key,
                Value = val
            });
            Console.WriteLine($"delivered to: {deliveryResult.TopicPartitionOffset}");
        }
        catch (ProduceException<string, string> e)
        {
            Console.WriteLine($"failed to deliver message: {e.Message} [{e.Error.Code}]");
        }
    }
}

消费者

static void Main(string[] args)
{
    if (args.Length != 2)
    {
        Console.WriteLine("Usage: .. brokerList topicName");
        // 127.0.0.1:9092 helloTopic
        return;
    }
    var brokerList = args.First();
    var topicName = args.Last();
    Console.WriteLine($"Started consumer, Ctrl-C to stop consuming");
    var cts = new CancellationTokenSource();
    Console.CancelKeyPress += (_, e) =>
    {
        e.Cancel = true;
        cts.Cancel();
    };
    var config = new ConsumerConfig
    {
        BootstrapServers = brokerList,
        GroupId = "consumer",
        EnableAutoCommit = false,
        StatisticsIntervalMs = 5000,
        SessionTimeoutMs = 6000,
        AutoOffsetReset = AutoOffsetReset.Earliest,
        EnablePartitionEof = true
    };
    const int commitPeriod = 5;
    using var consumer = new ConsumerBuilder<Ignore, string>(config)
                         .SetErrorHandler((_, e) =>
                         {
                             Console.WriteLine($"Error: {e.Reason}");
                         })
                         .SetStatisticsHandler((_, json) =>
                         {
                             Console.WriteLine($" - {DateTime.Now:yyyy-MM-dd HH:mm:ss} > monitoring..");
                             //Console.WriteLine($"Statistics: {json}");
                         })
                         .SetPartitionsAssignedHandler((c, partitions) =>
                         {
                             Console.WriteLine($"Assigned partitions: [{string.Join(", ", partitions)}]");
                         })
                         .SetPartitionsRevokedHandler((c, partitions) =>
                         {
                             Console.WriteLine($"Revoking assignment: [{string.Join(", ", partitions)}]");
                         })
                         .Build();
    consumer.Subscribe(topicName);
    try
    {
        while (true)
        {
            try
            {
                var consumeResult = consumer.Consume(cts.Token);
                if (consumeResult.IsPartitionEOF)
                {
                    Console.WriteLine($"Reached end of topic {consumeResult.Topic}, partition {consumeResult.Partition}, offset {consumeResult.Offset}.");
                    continue;
                }
                Console.WriteLine($"Received message at {consumeResult.TopicPartitionOffset}: {consumeResult.Message.Value}");
                if (consumeResult.Offset % commitPeriod == 0)
                {
                    try
                    {
                        consumer.Commit(consumeResult);
                    }
                    catch (KafkaException e)
                    {
                        Console.WriteLine($"Commit error: {e.Error.Reason}");
                    }
                }
            }
            catch (ConsumeException e)
            {
                Console.WriteLine($"Consume error: {e.Error.Reason}");
            }
        }
    }
    catch (OperationCanceledException)
    {
        Console.WriteLine("Closing consumer.");
        consumer.Close();
    }
}

在这里插入图片描述

风神.NET跨平台
关注
  • 0
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Kafka基础之.NetCore中简单使用Kafka(二)
agoling的博客
03-17 2738
.net 中使用Kafka，kafka的简单使用，kafka帮助类，UtilsSharp.Kafka
.NET Core Web API项目简单集成kafka
最新发布
weixin_50384980的博客
05-31 257
这段代码保证我们启动原本的API服务并将kafka集成到里里面，我有通过Jmeter测试过，如果是没有集成过kafka，我通过Jmeter1秒请求2000次大概会出现40-50次请求出错，集成之后2000轻松搞定不会出错，这次也是我初次使用kafka用来做一个类似高并发的实现，如有其他问题欢迎各位指正。在解压后的文件夹中进入/bin/windows/ 在该目录下运行一个命令提示框并输入指令。在解压后的文件夹中进入/bin/windows/在该目录下运行一个命令提示框输入指令。
Kafka学习征途：.NET Core操作Kafka
寒冰屋的专栏
06-29 1761
作为一个.NET Developer，自然想要在.NET项目中集成Kafka实现发布订阅功能。那么，目前可用的Kafka客户端有哪些呢？ 目前.NET圈子主流使用的是 Confluent.Kafka
.Net Core 集成 Kafka
极客神殿
05-18 1098
最近维护的一个系统并发有点高，所以想引入一个消息队列来进行削峰。考察了一些产品，最终决定使用kafka来当做消息队列。以下是关于kafka的一些知识的整理笔记。 kafka kafka 是分布式流式平台。它由linkedin开发，后贡献给了Apache开源组织并成为顶级开源项目。它可以应用在高并发场景下的日志系统，也可以当作消息队列来使用，也可以当作消息服务对系统进行解耦。 流处理平台有以下三种特性: 可以让你发布和订阅流式的记录。这一方面与消息队列或者企业消息系统类似。 可以储存流式的记录，并且有较好
如何在 .NET 中使用 Kafka
dotNET跨平台
03-10 2534
Kafka 是一个开源的，分布式的，可扩展的，高性能的发布订阅模式的消息中间件，如果你要构建一个处理海量数据的系统，那么 Kafka 将会是一个非常好的选择，这篇文章我们将会讨论如何基于 ...
1.5万字长文：从 C# 入门 Kafka（Kafka .NET 基础）
dotNET跨平台
01-30 2101
目录3, Kafka .NET 基础生产者批量生产使用 Tasks.WhenAll如何进行性能测试消费3, Kafka .NET 基础在第一章中，笔者介绍了如何部署 Kafka；在第二章中，笔者介绍了 Kafka 的一些基础知识；在本章中，笔者将介绍如何使用 C# 编写程序连接 kafka，完成生产和消费过程。在第二章的时候，我们已经使用到了confluent-kafka-dotnet，通过...
.NET Core如何通过认证机制访问Kafka？
dotNET跨平台
12-15 260
【.NET Core】|总结/Edison Zhou大家好，我是Edison。最近有一个ASP.NET Core使用认证机制访问Kafka的需求，加之我们又使用了CAP这个开源项目使用的Kafka，于是网上寻找了一番发现对应资料太少，于是调查了一番，做了如下的笔记，希望对你有用。背景在实际场景中，开发环境的Kafka服务器一般没有要求通过认证即可发布和读取消息，并且还可以随意创建Topic和Co...
.NET Core下使用Kafka的方法步骤
10-14
主要介绍了.NET Core下使用Kafka的方法步骤，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
.NET CORE 代码使用kafka推送数据
05-19
.net core 使用kafka推送消息和接收消息，包含生产端和消费端
KafkaNetCore:ASP.NET Core 5.0和KAFKA
03-25
KafkaNetCore ASP.NET Core 5.0和KAFKA 实施的技术： ASP.NET Core 5.0 卡夫卡 实体框架核心5.0 招摇UI
dotnet-kafka-sample:使用垂直切片体系结构的.NET Core Kafka示例应用程序
03-18
标题中的“dotnet-kafka-sample”是一个.NET Core平台上的示例项目，专注于展示如何使用Apache Kafka这一分布式消息系统。Kafka是一种广泛使用的实时数据流处理平台，它允许开发者构建复杂的数据管道和流处理应用。...
在.NET中使用Apache Kafka（一）
nicvscs的博客
02-22 777
​曾经在你的应用程序中使用过异步处理吗?在处理不需要立即执行的任务时，异步代码似乎是不可避免的。Apache Kafka是最常用和最健壮的开源事件流平台之一。许多公司和开发者利用它的强大功能来创建高性能的异步操作，用于微服务的数据集成，以及用于应用程序健康指标的监控工具。这篇文章解释了在.NET应用程序中使用Kafka的细节，还展示了如何在Windows操作系统上安装及使用。 它是如何工作的 当今世界，数据正在以指数形式增长。为了容纳不断增长的数据，Kafka这样的工具应运而生，提供了健壮而令人印象深刻
core net 消费kafka_netcore kafka操作
weixin_35915157的博客
12-31 289
安装使用：1：下载nuget包Confluent.Kafkalibrdkafka.redistSystem.Runtime.CompilerServices.Unsafe基于.net实现kafka的消息队列应用，常用的类库有kafka-net，Confluent.Kafka，官网推荐使用Confluent.Kafka参考：https://blog.csdn.net/qq_34894585/arti...
.net core 使用kafka
07-25
.NET Core可以使用第三方库来集成和使用Kafka。下面是一个简单的示例来演示如何在.NET Core中使用Kafka。 首先，你需要安装NuGet包`Confluent.Kafka`，这是一个Kafka客户端库。你可以通过NuGet包管理器或者使用命令行来安装它： ``` dotnet add package Confluent.Kafka ``` 接下来，你可以使用以下代码来创建一个生产者并发送消息到Kafka： ```csharp using Confluent.Kafka; using System; class Program { static void Main(string[] args) { var config = new ProducerConfig { BootstrapServers = "localhost:9092" }; using (var producer = new ProducerBuilder<Null, string>(config).Build()) { var topic = "my_topic"; var message = "Hello Kafka!"; var deliveryReport = producer.ProduceAsync(topic, new Message<Null, string> { Value = message }).GetAwaiter().GetResult(); Console.WriteLine($"Message delivered to {deliveryReport.TopicPartitionOffset}"); } } } ``` 上述代码创建了一个生产者实例，并将消息发送到名为"my_topic"的主题中。你可以根据自己的需求修改主题名称和消息内容。 如果你想要创建一个消费者并从Kafka接收消息，可以使用以下代码： ```csharp using Confluent.Kafka; using System; class Program { static void Main(string[] args) { var config = new ConsumerConfig { BootstrapServers = "localhost:9092", GroupId = "my_group", AutoOffsetReset = AutoOffsetReset.Earliest }; using (var consumer = new ConsumerBuilder<Ignore, string>(config).Build()) { consumer.Subscribe("my_topic"); while (true) { var consumeResult = consumer.Consume(); Console.WriteLine($"Received message: {consumeResult.Message.Value}"); } } } } ``` 上述代码创建了一个消费者实例，并订阅了"my_topic"主题。消费者将持续监听并接收来自Kafka的消息，并将其打印到控制台。 这只是一个简单的示例，你可以根据自己的需求来配置更多的Kafka生产者和消费者属性。希望能帮助到你！

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值