Python脚本(Kafka生产者+消费者)

qyt19885202025-10-02 11:33

以mac为例

1）安装kafka : brew install kafka

2）检查安装路径：

brew --prefix kafka

brew --prefix zookeeper

3）启动服务（目录为本人电脑目录，可能与读者目录不一致）

3.1）启动zookeeper：zookeeper-server-start /usr/local/etc/kafka/zookeeper.properties

3.2）启动kafka: kafka-server-start /usr/local/etc/kafka/server.properties

4）topic

4.1）创建topic：

创建名为 test_topic 的 topic，1个分区，1个副本

kafka-topics --create \

--bootstrap-server localhost:9092 \

--replication-factor 1 \

--partitions 1 \

--topic test_topic

注意：

根据版本选择参数：
Kafka 版本 推荐创建 Topic 的方式 参数使用
​Kafka ≥ 2.2​ 推荐使用 --bootstrap-server（更现代，不依赖 ZK） --bootstrap-server localhost:9092
​Kafka < 2.2（比如 2.1.x、1.x）​​ 必须使用 --zookeeper --zookeeper localhost:2181

4.2）查看topic：kafka-topics --list --bootstrap-server localhost:9092

旧版本：kafka-topics --list --zookeeper localhost:2181

5）python3代码(以kafka-python为例)：

工具 适用场景 特点
​confluent-kafka​ 生产环境，高性能 需安装 librdkafka，API 更底层，速度快
​kafka-python​ 学习、测试、开发 纯 Python，无需额外依赖，简单易用

5.1）安装依赖：pip install kafka-python

5.2）生产者（producer_kafka_python.py）

python 复制代码 
from kafka import KafkaProducer
import time

# Kafka 服务地址，确保 Kafka Broker 正在运行并监听该端口（默认 9092）
bootstrap_servers = 'localhost:9092'

# 要发送消息的 Kafka Topic 名称，确保该 Topic 已存在（或 Kafka 配置了自动创建 Topic）
topic = 'test_topic'

# 创建一个 Kafka 生产者实例
# value_serializer：指定如何将发送的消息（通常是字符串）序列化为字节，这里使用 UTF-8 编码
producer = KafkaProducer(
    bootstrap_servers=bootstrap_servers,
    value_serializer=lambda v: v.encode('utf-8')  # 将字符串编码为 bytes
)

# 发送 5 条测试消息到 Kafka Topic
for i in range(5):
    msg = f'Hello from kafka-python #{i}'  # 构造消息内容
    print(f'发送: {msg}')  # 打印即将发送的消息

    # 异步发送消息到指定的 topic，并返回一个 Future 对象
    future = producer.send(topic, value=msg)

    try:
        # 阻塞等待，获取消息发送的元数据（如 Topic、Partition、Offset）
        # timeout=10 表示最多等待 10 秒，超时则抛出 KafkaTimeoutError
        metadata = future.get(timeout=10)
        print(f"发送到 Topic: {metadata.topic}, Partition: {metadata.partition}, Offset: {metadata.offset}")
    except Exception as e:
        print(f"消息发送失败: {e}")

    time.sleep(1)  # 每隔 1 秒发送一条消息，模拟间隔发送

# 关闭生产者，确保网络连接等资源被正确释放
producer.close()
生产者运行结果如下：
5.3）消费者（consumer_kafka_python.py）
python 复制代码 
from kafka import KafkaConsumer

# Kafka 服务地址
bootstrap_servers = 'localhost:9092'

# 要消费的 Kafka Topic 名称
topic = 'test_topic'

# 消费者组 ID，用于标识一组消费者，Kafka 会为每个组管理消费位移（offset）
group_id = 'my-group-python'

# 创建 Kafka 消费者实例
consumer = KafkaConsumer(
    topic,  # 订阅一个或多个 topic，这里只订阅了一个
    bootstrap_servers=bootstrap_servers,  # Kafka 服务地址
    group_id=group_id,  # 消费者组 ID
    auto_offset_reset='earliest',  # 如果没有已提交的 offset，从最早的消息开始消费；
    # 可选值：'earliest'（最早）、'latest'（最新）
    value_deserializer=lambda x: x.decode('utf-8')  # 将接收的字节数据解码为字符串
)

print(f"开始消费主题 '{topic}' ...")  # 提示消费者已启动并开始监听

# 持续监听并消费消息
for message in consumer:
    # 打印每条消息的详细信息
    print(
        f"收到消息 -> Topic: {message.topic}, Partition: {message.partition}, Offset: {message.offset}, Value: {message.value}")

消费者运行结果如下：

6）运行步骤总结：

  1. 安装 Kafka（通过 Homebrew）​
  2. 启动 Zookeeper
  3. 启动 Kafka Broker
  4. **（可选）创建 Topic：test_topic
  5. 运行 Python 生产者：python`` producer_kafka_python.py
  6. 运行 Python 消费者：python ``consumer_kafka_python.py

7）confluent-kafka版python代码：

7.1）安装librdkafka ： brew install librdkafka

7.2）安装confluent-kafka ： pip3 install confluent-kafka

7.3）生产者

python 复制代码 
from confluent_kafka import Producer
import time

# ===========================
# Kafka 生产者示例（基于 confluent-kafka）
# 功能：向 Kafka 的 test_topic 发送 5 条测试消息，异步发送 + 回调通知发送结果
# 前提条件：
# - Kafka 服务已启动，并监听 localhost:9092
# - Topic 'test_topic' 已存在（或 Kafka 配置允许自动创建）
# ===========================

# Kafka 服务地址（Broker 地址列表，可以是多个，用逗号分隔）
bootstrap_servers = 'localhost:9092'

# 要发送消息的目标 Kafka Topic
topic = 'test_topic'

# 创建一个 Kafka Producer 实例
# 参数是一个字典，常用的配置项如下：
# - 'bootstrap.servers': Kafka Broker 地址，用于建立初始连接，客户端会从中发现集群
producer = Producer({'bootstrap.servers': bootstrap_servers})

# ===========================
# 消息发送回调函数
# 作用：当消息成功发送或发送失败时触发，用于打印发送结果
# 参数：
# - err: 错误对象，如果发送成功则为 None，否则为 Kafka 错误信息
# - msg: 消息对象，包含 topic、partition、offset、value 等元数据
# ===========================
def delivery_report(err, msg):
    if err is not None:
        print(f' 消息发送失败: {err}')
    else:
        print(f' 消息发送成功 -> Topic: {msg.topic()}, Partition: {msg.partition()}, Offset: {msg.offset()}, Value: {msg.value().decode("utf-8")}')

# ===========================
# 发送 5 条测试消息
# 使用异步发送（producer.produce），并通过 producer.poll() 处理事件循环（如触发回调）
# 每隔 1 秒发送一条，模拟间隔消息生产
# ===========================
for i in range(5):
    msg_value = f'Hello from confluent-kafka Producer #{i}'  # 构造消息内容
    print(f' 发送: {msg_value}')  # 打印即将发送的消息内容

    # 异步发送消息到指定 topic
    # value 必须是 bytes 类型，所以需要用 encode('utf-8') 转换
    producer.produce(
        topic=topic,
        value=msg_value.encode('utf-8'),  # 消息内容转为 bytes
        callback=delivery_report  # 指定回调函数，用于异步通知发送结果
    )

    # 处理事件队列（比如触发回调函数）
    # 参数 0 表示不阻塞，立即返回，但会处理当前所有待处理的事件（如回调）
    producer.poll(0)

    # 每隔 1 秒发送一条消息
    time.sleep(1)

# ===========================
# 确保所有异步发送的消息都已完成（比如回调已触发、消息已发送到网络缓冲并 flush 到 Broker）
# 必须在 producer 关闭前调用，否则可能导致部分消息未真正发送出去
# ===========================
producer.flush()
print(" 所有消息发送完毕，生产者关闭")

7.4）消费者

python 复制代码 
from confluent_kafka import Consumer, KafkaException
import sys

# ===========================
# Kafka 消费者示例（基于 confluent-kafka）
# 功能：订阅并持续监听 Kafka 的 test_topic，接收并打印消息
# 前提条件：
# - Kafka 服务已启动，且监听 localhost:9092
# - Topic 'test_topic' 中有消息（可由生产者发送）
# - 消费者组 ID 用于管理消费位移（offset），相同 group.id 的消费者会共同消费
# ===========================

# Kafka 服务地址
bootstrap_servers = 'localhost:9092'

# 要消费的 Kafka Topic 名称
topic = 'test_topic'

# 消费者组 ID，用于标识一个消费者组，Kafka 会为每个组保存消费位移
group_id = 'my_consumer_group_1'

# 创建一个 Kafka Consumer 实例
# 配置项说明：
# - 'bootstrap.servers': Kafka Broker 地址
# - 'group.id': 消费者组 ID
# - 'auto.offset.reset': 当没有初始 offset 时，从何处开始消费
#   - 'earliest': 从最早的消息开始消费
#   - 'latest': 从最新的消息开始消费（默认）
consumer = Consumer({
    'bootstrap.servers': bootstrap_servers,
    'group.id': group_id,
    'auto.offset.reset': 'earliest'  # 如果没有已提交的 offset，从最早的消息开始消费
})

# 订阅一个或多个 topic，这里只订阅了 test_topic
consumer.subscribe([topic])

print(f" 开始监听主题: {topic} ...")

try:
    # 持续监听并消费消息
    while True:
        # 拉取消息，设置超时时间为 1 秒
        # 如果在 1 秒内没有消息，则返回 None
        msg = consumer.poll(timeout=1.0)

        if msg is None:
            continue  # 没有消息，继续下一轮拉取

        if msg.error():
            # 检查消息是否为错误消息
            if msg.error().code() == KafkaException._PARTITION_EOF:
                # 分区末尾（正常情况，表示该分区的消息已经消费完）
                sys.stderr.write(f' {msg.topic()} [{msg.partition()}] 已到达末尾\n')
            else:
                # 其它错误，抛出异常
                raise KafkaException(msg.error())
        else:
            # 成功接收到消息，打印消息详情
            print(f" 收到消息 -> Topic: {msg.topic()}, Partition: {msg.partition()}, Offset: {msg.offset()}, Value: {msg.value().decode('utf-8')}")

except KeyboardInterrupt:
    # 用户按下 Ctrl+C 时，优雅退出
    print(" 消费者已停止")

finally:
    # 确保消费者被正确关闭，释放资源，提交最终的 offset（如果配置了自动提交）
    consumer.close()
相关推荐
RunningShare5 小时前
大数据消息中间件选型终极指南：深度解析Kafka、Pulsar、RocketMQ架构与性能
大数据·kafka·rocketmq·pulsar
caibixyy14 小时前
Spring Boot 整合 Redisson 实现分布式锁：实战指南
spring boot·分布式·后端
caibixyy17 小时前
Spring Boot 集成 Kafka 详解
spring boot·kafka
求你不要出Bug了17 小时前
RokcetMQ事务消息详解
分布式·rocketmq·事务消息
❀͜͡傀儡师18 小时前
Docker部署Kafka Native
docker·容器·kafka
caibixyy19 小时前
Spring Boot整合Kafka：解决消息挤压、丢失与重复消费
kafka
Vahala0623-孔勇20 小时前
Redisson分布式锁源码深度解析：RedLock算法、看门狗机制，以及虚拟线程下的锁重入陷阱与解决
java·开发语言·分布式
疯癫的老码农21 小时前
【小白入门docker】创建Spring Boot Hello World应用制作Docker镜像并运行
java·spring boot·分布式·docker·微服务
没有bug.的程序员1 天前
分布式架构初识：为什么需要分布式
java·分布式·架构·php
热门推荐
01GitHub 镜像站点02OpenSpeedy简介03KGG转MP3工具|非KGM文件|解密音频04UV安装并设置国内源05在国行 macOS 下用 DeepSeek 补齐 Xcode 26 的 AI 能力：问题、原因与 mitmproxy 解决方案（含可用脚本与安装教程）06jdk21下载、安装（Windows、Linux、macOS）07UV 工具安装与国内镜像源配置指南08Linux下V2Ray安装配置指南09阿里最新开源Wan2.2-Animate-14B 本地部署教程：统一双模态框架，MoE架构赋能电影级角色动画与替换10Spec-Kit 使用指南