Python消息队列实战:Kafka与Confluent深度解析

python --kafka(二): confluent-kafka 模块生产数据消费数据 文章目录前言一、confluent-kafka 是什么?二、使用步骤1.引入库2.消费数据2.1 初始化consumer对象2.2 消费数据偏移量3. 生产数据总结 前言 kafka是一个开源的流处理平台,一种高吞吐量的分布式发布订阅消息系统,它可以处理消费者在网站中的所有动作流数据。 一、confluent-kafka 是什么? confluent-kafka 模块 confluent-kafka是Python模块,推荐使用,性能优于kafka-python 参考文档:https://docs.c 阅读详情

Python消息队列实战:Kafka与Confluent深度解析

引言

在Python开发中,Kafka是构建大规模消息系统的核心技术。作为一名从Rust转向Python的后端开发者,我深刻体会到Confluent Kafka在消息传递方面的优势。Confluent Kafka是Python生态中最流行的Kafka客户端库,提供了完整的功能和良好的性能。

Confluent Kafka核心概念

什么是Confluent Kafka

Confluent Kafka是Kafka的Python客户端,具有以下特点:

  • 高性能:优化的C扩展实现
  • 完整功能:支持所有Kafka特性
  • 生产者/消费者:支持消息生产和消费
  • 分区支持:支持分区和副本
  • 事务支持:支持事务性消息

架构设计

┌─────────────────────────────────────────────────────────────┐
│                 Confluent Kafka 架构                      │
│  ┌──────────────┐    ┌──────────────┐    ┌──────────────┐ │
│  │   生产者     │───▶│   Kafka      │───▶│   消费者     │ │
│  │ (Producer)  │    │   Broker     │    │ (Consumer)  │ │
│  └──────────────┘    └──────────────┘    └──────────────┘ │
│          │                  │                              │
│          ▼                  ▼                              │
│  ┌──────────────────────────────────────────────────────┐  │
│  │              Topic + Partition + Offset               │  │
│  └──────────────────────────────────────────────────────┘  │
└─────────────────────────────────────────────────────────────┘

环境搭建与基础配置

安装依赖

pip install confluent-kafka

基本生产者

from confluent_kafka import Producer

conf = {
    'bootstrap.servers': 'localhost:9092',
    'client.id': 'python-producer'
}

producer = Producer(conf)

def delivery_report(err, msg):
    if err is not None:
        print(f'Message delivery failed: {err}')
    else:
        print(f'Message delivered to {msg.topic()} [{msg.partition()}]')

producer.produce('my_topic', key='key', value='Hello World!', callback=delivery_report)
producer.flush()

基本消费者

from confluent_kafka import Consumer, KafkaError

conf = {
    'bootstrap.servers': 'localhost:9092',
    'group.id': 'python-consumer',
    'auto.offset.reset': 'earliest'
}

consumer = Consumer(conf)
consumer.subscribe(['my_topic'])

while True:
    msg = consumer.poll(1.0)
    
    if msg is None:
        continue
    
    if msg.error():
        if msg.error().code() == KafkaError._PARTITION_EOF:
            continue
        else:
            print(msg.error())
            break
    
    print(f'Received message: {msg.value().decode("utf-8")}')

consumer.close()

高级特性实战

生产者配置

from confluent_kafka import Producer

conf = {
    'bootstrap.servers': 'localhost:9092',
    'client.id': 'python-producer',
    'acks': 'all',
    'retries': 3,
    'batch.size': 16384,
    'linger.ms': 1,
    'compression.type': 'gzip'
}

producer = Producer(conf)
producer.produce('my_topic', value='Hello World!')
producer.flush()

消费者配置

from confluent_kafka import Consumer

conf = {
    'bootstrap.servers': 'localhost:9092',
    'group.id': 'python-consumer',
    'auto.offset.reset': 'earliest',
    'enable.auto.commit': True,
    'auto.commit.interval.ms': 5000,
    'fetch.min.bytes': 1,
    'fetch.max.wait.ms': 500
}

consumer = Consumer(conf)
consumer.subscribe(['my_topic'])

分区操作

from confluent_kafka import Producer, TopicPartition

producer = Producer({'bootstrap.servers': 'localhost:9092'})

producer.produce('my_topic', value='Partition 0 message', partition=0)
producer.produce('my_topic', value='Partition 1 message', partition=1)
producer.flush()

实际业务场景

场景一:日志收集

from confluent_kafka import Producer
import logging

class LogProducer:
    def __init__(self, bootstrap_servers):
        self.producer = Producer({'bootstrap.servers': bootstrap_servers})
    
    def send_log(self, level, message):
        log_entry = {'level': level, 'message': message}
        self.producer.produce('logs', value=str(log_entry))
        self.producer.poll(0)
    
    def flush(self):
        self.producer.flush()

logger = LogProducer('localhost:9092')
logger.send_log('INFO', 'Application started')
logger.flush()

场景二:事件驱动架构

from confluent_kafka import Consumer
import json

class EventConsumer:
    def __init__(self, bootstrap_servers, group_id):
        self.consumer = Consumer({
            'bootstrap.servers': bootstrap_servers,
            'group.id': group_id,
            'auto.offset.reset': 'earliest'
        })
        self.consumer.subscribe(['events'])
    
    def process_events(self):
        while True:
            msg = self.consumer.poll(1.0)
            if msg is None:
                continue
            
            if msg.error():
                print(msg.error())
                continue
            
            event = json.loads(msg.value().decode('utf-8'))
            self.handle_event(event)
    
    def handle_event(self, event):
        if event['type'] == 'user_created':
            self.handle_user_created(event)
        elif event['type'] == 'order_placed':
            self.handle_order_placed(event)
    
    def handle_user_created(self, event):
        print(f'User created: {event["data"]["user_id"]}')
    
    def handle_order_placed(self, event):
        print(f'Order placed: {event["data"]["order_id"]}')

性能优化

批量消息

from confluent_kafka import Producer

producer = Producer({
    'bootstrap.servers': 'localhost:9092',
    'batch.size': 65536,
    'linger.ms': 100
})

messages = ['msg1', 'msg2', 'msg3', 'msg4', 'msg5']
for msg in messages:
    producer.produce('my_topic', value=msg)

producer.flush()

异步生产

from confluent_kafka import Producer
import asyncio

async def produce_messages(messages):
    producer = Producer({'bootstrap.servers': 'localhost:9092'})
    
    for msg in messages:
        producer.produce('my_topic', value=msg)
        await asyncio.sleep(0.001)
    
    producer.flush()

总结

Confluent Kafka为Python开发者提供了强大的Kafka操作能力。通过高性能的C扩展实现和完整的功能,Confluent Kafka使得消息队列开发变得非常高效。从Rust开发者的角度来看,Confluent Kafka比Rust的rdkafka更加成熟和稳定。

在实际项目中,建议合理使用批量消息和异步生产来优化性能,并注意分区管理和错误处理。

Python3学习(五十四):confluent-kafka模块的使用 coufluent-kafka是Python模块,是对librdkafka的轻量级封装,librdkafka又是基于c/c++的kafka库,性能上不必多说。使用上要优于kafka-python。 confluent-kafka-python是Confluent用于Apache Kafka和Confluent Platform的Python客户端。 特征: 高性能- confluen... 阅读详情

相关推荐

Kafka从消息队列到数据中枢:核心原理、应用场景与实战指南

消息队列作为分布式系统解耦与异步通信的核心组件,其核心原理在于通过发布-订阅或点对点模式实现应用间的可靠数据传递。在技术演进中,传统消息队列逐渐演变为高吞吐、可持久化的流数据平台,这一转变带来了巨大的技术价值——它不仅解决了系统间的通信问题,更成为实时数据管道和流式应用的基础设施。在应用场景上,这类技术广泛应用于日志收集、实时监控、事件驱动架构和大数据流处理等领域。以Apache Kafka为例,它通过分布式日志存储、零拷贝技术和消费者组模型,实现了从简单的消息传递到实时数据中枢的跨越,支撑着电商实时推荐、

weixin_34204722的博客 425

基于docker的confluent-kafka搭建及python接口使用

本文介绍基于docker搭建的confluent-kafka及其python接口的使用。

摇光65535的博客 2194

Kafka在MLOps中的核心作用与生产级调优实战

Kafka本质上是一种分布式、高吞吐、时间有序的不可变日志系统,其分区机制、副本同步(ISR)和日志压缩(Log Compaction)特性,天然契合MLOps对实时特征新鲜度、事件可重放性与状态一致性等关键需求。它不仅支撑毫秒级在线推理与动态Agentic AI工作流,更通过精确的Consumer Lag控制、幂等消费与EOS事务保障模型服务的可靠性。本文结合电商反作弊、工业预测性维护等真实场景,深入解析replication-factor配置陷阱、min.insync.replicas容错公式、comp

471

【python】Kafka介绍及confluent-kafka的使用

kafka介绍 kafka是高效的数据流处理平台。可以理解为数据的写入和读取的“中转站”。 相关概念 Broker 一个broker对应一个kafka实例,可以分别在多台服务器上各启动一个broker, 也可在一个服务器上启动多个broker。 Topic 消息的主题,一个broker可有多个topic。 Partition 每个Topic中的信息可以分配在多个Partition中,有...

weixin_44794704的博客 1万+

实时监听数据库变化:主流方案与Debezium+Kafka实战

在数据驱动的现代应用架构中,实时感知数据变化是实现业务解耦与即时响应的核心需求。其基本原理是通过捕获数据库的变更日志(如MySQL的Binlog、PostgreSQL的WAL),将数据变动事件流式推送,而非低效的轮询查询。这项技术的核心价值在于构建低延迟、高吞吐的数据管道,为微服务通信、实时数仓、缓存与搜索索引同步等场景提供基础支撑。本文聚焦于Change Data Capture(CDC)这一关键技术,深入剖析了基于Debezium与Kafka构建企业级监听方案的工程实践,涵盖了架构设计、配置详解与典型性

weixin_34072637的博客 451

Kafka核心原理与生产实践:高吞吐、可靠性与运维排查全解析

消息队列是分布式系统的核心组件,在应对高并发流量削峰、异步解耦与数据缓冲中扮演关键角色。Kafka作为吞吐量最高的消息中间件,其底层设计融合了分区并行、顺序追加写、页缓存与零拷贝等技术,让百万级TPS成为可能。生产环境中,如何保障消息不丢、避免消息堆积、应对消费组Rebalance带来的抖动,是每个后端工程师的必修课。本文从Kafka架构原理出发,剖析高性能存储机制、可靠性与消费协同细节,并结合集群部署、延迟排查、版本升级等运维经验,帮助读者建立从理论到实战的完整知识体系。无论你是准备面试还是负责线上Kaf

weixin_34302798的博客 511

你还在用旧版kafka-python?最新Confluent Kafka Python客户端迁移全攻略

告别旧版kafka-python性能瓶颈,掌握最新Kafka Python客户端迁移方法。本文详解Confluent Kafka Python客户端在高并发、低延迟场景下的应用,提供平滑升级路径与核心API对比,提升消息处理效率。迁移要点一文掌握,值得收藏。

ByteGlow的博客 1247

Kafka在MLOps中的核心作用:构建高可靠实时特征数据链路

消息队列是支撑现代机器学习工程化落地的关键基础设施,其本质是解决数据在训练与推理之间的时间一致性、格式可演化性及流量弹性问题。Kafka凭借分区有序日志、精确一次语义和Schema Registry治理能力,成为MLOps中事实标准的实时数据中枢。它不仅承载原始事件流,更驱动特征实时计算、模型服务解耦接入与反馈闭环监控,显著提升模型线上稳定性与迭代效率。本文聚焦Kafka在MLOps场景下的分层定位、Topic设计规范、Avro Schema治理及生产调优实践,覆盖从埋点采集到漂移告警的完整链路。

weixin_30251829的博客 621

《Python 架构进阶:Redis、RabbitMQ 与 Kafka 消息队列的深度抉择与实战全景解析》

本文深入探讨 Python 架构设计中 Redis、RabbitMQ 和 Kafka 三大消息队列的选型策略。Redis 作为轻量级高效方案,适合实时性要求高的轻量任务;RabbitMQ 以可靠性著称,适合金融交易等核心业务;Kafka 则专为大数据场景设计。文章通过丰富的 Python 代码示例(如 Redis Streams 消费者组实现、RabbitMQ 异步消费模式),剖析各中间件的核心优势与适用场景,为开发者提供从理论到实践的完整指导。无论是中小型项目还是高并发系统,都能找到最优的消息队列解决方案

铭渊老黄 481

Debezium CDC实战:从原理到生产环境部署与调优

在数据驱动的现代架构中,实时数据同步是构建实时数仓、微服务解耦和缓存更新的核心需求。传统批处理ETL工具存在时间延迟和对源库压力大的问题。CDC(变更数据捕获)技术通过读取数据库事务日志(如MySQL的binlog)来捕获数据变更,实现了毫秒级的低延迟数据流。其技术价值在于将数据变更作为事件流发布,为下游的流处理框架(如Flink、Spark)提供实时数据源。Debezium作为CDC领域的开源明星,基于Kafka Connect框架,通过无状态的Connector实时捕获变更并发布到Kafka,广泛应用于

weixin_34074740的博客 328

Kafka实用指南:Python客户端Confluent-kafka详解

本文详细介绍了Confluent-kafka这一强大的Python客户端的使用方法,并提供了生产者和消费者的示例代码。通过这些示例,你可以了解如何使用Confluent-kafka与Kafka集群进行交互,实现高效的实时数据管道和大数据处理。在Kafka生态系统中,Confluent-kafka是一款强大的Python客户端,提供了与Kafka集群进行交互的功能。接下来,我们来看一个使用Confluent-kafka创建消费者的示例。首先,我们来看一个使用Confluent-kafka创建生产者的示例。

CvhShell的博客 1666

Apache Pulsar Kafka Source Connector 完全指南:配置、Schema 管理与端到端实战

Kafka Source Connector 是 Apache Pulsar 内置的 IO 连接器之一,用于从 Kafka topic 拉取消息并持久化写入 Pulsar topic,从而实现两个消息系统之间的数据桥接。本文以官方文档为核心,结合当前仓库 `pulsar-io/kafka` 模块的源码实现,系统讲解连接器的全部配置项、Schema 自动推导机制、支持的序列化格式映射,并提供一个基于

gitblog_00259的博客 805

confluent-kafka-python:Confluent的Kafka Python客户端

Confluent的适用于Apache Kafka TM的Python客户端 confluent-kafka-python提供了与所有兼容的高级Producer,Consumer和AdminClient 经纪人> = v0.8, 和。 客户是: 可靠-它是 (通过二进制车轮自动提供)的包装,已在各种生产场景中广泛部署。 它使用Java客户端,。 它由支持。 性能-性能是关键的设计考虑因素。 对于较大的消息大小(Python解释器的开销影响较小),最大吞吐量与Java客户端相当。 延迟与Java客户端相当。 面向未来-由Kafka的创建者创建的Confluent,正在构建一个以Apache Kafka为核心的。 对于我们来说,将客户端功能与核心Apache Kafka和组件保持同步是当务之急。 有关更多信息,请参见。 用法 以下是一些典型用法示例。 有关更多示例,请参阅目录或Conf

python使用kafka原理详解真实完整版_kafka 内部原理及实例

kafka介绍Kakfa起初是由LinkedIn公司开发的一个分布式的消息系统,它使用Scala编写,后成为Apache的一部分,支持多种客户端语言(C++,JAVA,python)目前越来越多的开源分布式处理系统如Cloudera、Apache Storm、Spark等都支持与Kafka集成。具有高水平扩展性、高容错性、访问速度快、分布式等特性内部原理深度解析1.producer: 生产者发布消...

weixin_39853968的博客 157

Star CCM+ 202206 (17.04) 详细安装步骤

StarCCM+ 17.04 安装包和详细安装步骤

薛定谔的alpha狗 3万+

全志T113s3主线linux开发(0)--基础准备

嵌入式Linux设备的启动大概是三步:1)启动芯片+内存:常见的是Uboot,不过全志的Uboot主线对SPI NAND 不太友好,用TF卡就方便。对于T113S芯片,推荐使用Awboot,简陋但快速。开发阶段用这个就方便好多,对SPINAND支持也方便。2)启动linux内核:主线内核以下通篇都用6.13以上的内核。对比tina5.0还在用5.4 ,主要是性能、安全上有变化。6.0以上内核在devicetree的编写具体格式上有了变化,网上大量tina5.0和5.4内核的编写方式不适用。

2301_79234138的博客 2251

从MessageId看Pulsar架构:存储计算分离与Kafka的本质差异

在分布式系统中,消息队列是异步解耦与流量削峰的基础设施,其架构设计直接决定了系统的扩展性与可靠性。传统消息队列如Kafka将存储与计算耦合在Broker中,而Apache Pulsar则通过BookKeeper实现存储计算分离,使Broker无状态化,并赋予消息全局唯一的物理坐标——MessageId。这种设计不仅简化了消息回溯与位点管理,还支持多租户、跨地域复制等高级特性,让Pulsar在大规模数据场景下具备独特优势。本文以COSCon'25开源集市的Pulsar展台为线索,深度解析MessageId的三

weixin_34268169的博客 419

基于 Langchain 开发一个完整的支持多轮数据分析(直连 mysql 数据,多表综合分析 SQL 取数,数据分析,报表生成)ChatBI 系统(前后端完整实现源代码)

ChatBI系统开发摘要 本文介绍了基于Langchain的多轮数据分析ChatBI系统开发方案。该系统支持MySQL数据库连接,提供多表分析、SQL查询、数据分析和报表生成功能。系统采用前后端分离架构:前端使用React+Ant Design+ECharts实现交互界面;后端基于FastAPI搭建服务,集成Langchain处理自然语言到SQL的转换;核心技术栈还包括SQLAlchemy、Pandas和Matplotlib。 系统核心模块包括: 数据库连接层:使用SQLAlchemy管理MySQL连接 L

AI天才研究院 819

Kafka在MLOps中的核心作用:构建可靠实时数据管道

消息队列是分布式系统中实现解耦与异步通信的基础组件,其核心原理在于生产者-消费者模型、持久化日志与分区有序性保障。在机器学习工程化(MLOps)场景下,数据管道需同时满足高吞吐、低延迟、强一致性与可重放性等多重严苛要求——这远超传统缓存或数据库的承载能力。Kafka凭借分区级顺序、ISR副本同步、Log Compaction与Exactly-Once语义等机制,成为支撑特征工程、实时训练与在线推理协同演进的事实标准。它不参与模型计算,却决定了MLOps全链路的数据时效性、血缘可追溯性与故障恢复能力,广泛应用

cuiji1279的博客 508

RK3588开发笔记-MIPI-CSI接口视频解码芯片XS9922B调试

Rockchip RK3588 是一款高性能的处理器,支持多种摄像头接口,包括 MIPI(Mobile Industry Processor Interface)接口。MIPI是一种用于移动设备和嵌入式系统中的摄像头、显示器和其他传感器设备的串行接口标准。MIPI是MIPI联盟发起的为移动应用处理器制定的开放标准。CSI-2(Camera Serial Interface 2)是MIPI 联盟定义的另一种高速接口,主要用于摄像模组和处理器之间的连接。

flypig has a dream! 6867

YOLOv8 智能交通违章检测 - 压线/越线行驶检测详解

本文提出了一种基于YOLOv8的智能交通违章检测方案,重点解决车辆压线/越线行驶的识别问题。系统采用多技术融合方案:YOLOv8检测车辆、ByteTrack跟踪轨迹、传统或深度学习方法识别车道线,并通过几何计算判断车辆是否违规跨越实线。文章详细介绍了技术难点(如车道线分类、透视变形处理)、判定流程、系统架构和核心代码实现,包括车道线检测、违章逻辑判断和可视化模块。同时指出了现有方案的局限性,建议通过引入逆透视变换和专用车道线分割模型来提升准确率。该纯视觉方案具有低成本、易部署的特点,适用于智能交通监控场景。

u010117029的博客 179

数据科学从业者必知:大数据生态核心公司与技术栈全景解析

大数据技术生态涵盖从分布式存储、计算引擎到数据分析与可视化的完整链路。Hadoop通过HDFS和MapReduce实现海量数据的分布式存储与批处理,Spark凭借内存计算大幅提升迭代效率,Kafka支撑实时数据流处理,而数据可视化工具则负责将分析结果直观呈现。理解这些核心组件及其背后的技术公司,有助于建立系统性行业认知,在数据仓库建设、实时风控、用户画像、BI报表等场景中做出合理的技术选型。掌握大数据生态的全貌,是数据科学从业者从入门到进阶的关键一步。

weixin_34238633的博客 296

超强干货之---Python-数据爬取(爬虫)

定义: 深度优先搜索是一种遍历或搜索树或图的算法,从起始节点开始,一直沿着一个分支走到底,再回溯到上一个节点继续搜索下一个分支,直到遍历完所有节点。特点递归:通常用递归实现,或者使用栈来模拟递归过程。内存占用低:在有大量分支的情况下,内存占用比广度优先搜索低。适合目标较深的情况:如果目标节点距离起始节点较深,DFS能更快找到目标。适用场景需要遍历所有节点的情况,如生成树、迷宫搜索。目标节点较深,且分支较多时。在大规模数据爬取时,选择合适的存储方式取决于数据的规模、结构和访问需求。

房东的猫的博客 5万+

Kafka Schema Registry兼容性崩了?AI生成代码的5个隐性陷阱,92%工程师踩过第4个——附自动检测CLI工具开源地址

快速定位AI写消息队列代码引发的Schema Registry兼容性问题,总结5大隐性陷阱及自动检测方案。覆盖Kafka生产环境、Schema演进场景,提供开源CLI工具实时校验。92%工程师曾踩中第4个陷阱,值得收藏。

BytePerch的博客 80

WINCC7.3破解文件

WINCC7.3硬件够破解文件,有需要的下载!WINCC7.3硬件够破解文件,有需要的下载!

华为的C语言编程规范.pdf

华为技术有限公司内部技术规范。本规范制定了编写C语言程序的基本原则、规则和建议。从代码的清晰、简洁、可测试、安全、程序效率、可移植各个方面对C语言编程作出了具体指导。

上一篇: Python ORM实战:SQLAlchemy高级用法深度解析
下一篇: Rust数据库实战:Rusqlite SQLite深度解析
第一程序员
博客等级 码龄1年 1万+粉丝 1827原创
评论 3
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明:

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

余额充值