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()
相关推荐
武子康6 小时前
大数据-134 ClickHouse 单机+集群节点落地手册 | 安装配置 | systemd 管理 / config.d
大数据·分布式·后端
王嘉俊9258 小时前
HarmonyOS 分布式与 AI 集成：构建智能协同应用的进阶实践
人工智能·分布式·harmonyos
The 旺9 小时前
【案例实战】HarmonyOS分布式购物车：多设备无缝协同的电商体验
分布式·wpf·harmonyos
西***63471 天前
从信号处理到智能协同：高清混合矩阵全链路技术拆解，分布式系统十大趋势抢先看
网络·分布式·矩阵
阿维的博客日记1 天前
从夯到拉的Redis和MySQL双写一致性解决方案排名
redis·分布式·mysql
好玩的Matlab（NCEPU）1 天前
消息队列RabbitMQ、Kafka、ActiveMQ 、Redis、 ZeroMQ、Apache Pulsar对比和如何使用
kafka·rabbitmq·activemq
笨蛋少年派1 天前
zookeeper简介
分布式·zookeeper·云原生
鸽鸽程序猿1 天前
【RabbitMQ】简介
分布式·rabbitmq
在未来等你1 天前
Kafka面试精讲 Day 29：版本升级与平滑迁移
大数据·分布式·面试·kafka·消息队列
在未来等你1 天前
Kafka面试精讲 Day 30：Kafka面试真题解析与答题技巧
大数据·分布式·面试·kafka·消息队列
热门推荐
01BongoCat - 跨平台键盘猫动画工具02GitHub 镜像站点03UV安装并设置国内源04GitLab 零基础入门指南：从安装到项目管理全流程05Linux下V2Ray安装配置指南06Labelme从安装到标注：零基础完整指南07NVIDIA显卡驱动、CUDA、cuDNN 和 TensorRT 版本匹配指南082025软件测试面试八股文（含答案+文档）09在VSCode配置Java开发环境的保姆级教程（适配各类AI编程IDE）10【vue篇】Vue 项目中的静态资源管理：assets vs static 终极指南