Kafka快速入门——Python客户端

Posted

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了Kafka快速入门——Python客户端相关的知识,希望对你有一定的参考价值。

Kafka快速入门(十二)——Python客户端

一、confluent-kafka

1、confluent-kafka简介

confluent-kafka是Python模块,是对librdkafka的轻量级封装,支持Kafka 0.8以上版本。本文基于confluent-kafka 1.3.0编写。
GitHub地址:
https://github.com/confluentinc/confluent-kafka-python

2、confluent-kafka特性

(1)可靠。confluent-kafka是对广泛应用于各种生产环境的librdkafka的封装,使用Java客户端相同的测试集进行测试,由Confluent进行支持。
(2)性能。性能是一个关键的设计考虑因素,对于较大的消息,最大吞吐量与Java客户机相当(Python解释器的开销影响较小),延迟与Java客户端相当。
(3)未来支持。Coufluent由Kafka创始人创建,致力于构建以Apache Kafka为核心的流处理平台。确保核心Apache Kafka和Coufluent平台组件保持同步是当务之急。

3、confluent-kafka安装

创建confluent源:
进入/etc/yum.repos.d目录创建confluent.repo文件:

[Confluent.dist]
name=Confluent repository (dist)
baseurl=https://packages.confluent.io/rpm/5.4/7
gpgcheck=1
gpgkey=https://packages.confluent.io/rpm/5.4/archive.key
enabled=1

[Confluent]
name=Confluent repository
baseurl=https://packages.confluent.io/rpm/5.4
gpgcheck=1
gpgkey=https://packages.confluent.io/rpm/5.4/archive.key
enabled=1

安装:

sudo yum clean all &&  sudo yum install confluent-community-2.12
sudo yum install librdkafka-devel python-devel
pip install confluent-kafka

安装AvroProducer、AvroConsumer:
pip install "confluent-kafka[avro]"

二、coufluent-kafka客户端API

1、confluent_kafka.Consumer

Consumer(config)
使用指定的配置dict创建Consumer实例。
Consumer.assign(partitions)
由指定TopicPartition列表设置Consumer的分区分配策略,启动消费。如果对关闭的Consumer调用本函数会抛出RuntimeError。
Consumer.assignment()
返回当前分区分配策略,返回list(TopicPartition)
Consumer.close()
关闭和终止Consumer实例,关闭Consumer实例会执行以下操作:停止消费;提交位移(如果enable.auto.commit设置为False会抛出异常)、离开Consumer Group。
Consumer.commit([message=None][,?offsets=None][,?asynchronous=True])
提交一条消息或位移列表,message和offsets是互斥参数,如果没有指定参数,会使用当前分区分配策略的offsets。
message:提交消息的位移加1
offsets:要提交的TopicPartition列表
asynchronous:是否异步提交。异步提交会立即返回None。如果设置为False,会阻塞直到提交成功或失败,如果提交成功,会返回提交的offsets。注意:提交成功,需要对返回的TopicPartition列表的每个TopicPartition的err字段进行检查,TopicPartition可能会提交失败。
Consumer.committed(partitions[,?timeout=None])
获取已提交的分区的offsets。
partitions:TopicPartition列表
timeout:请求超时,单位秒。
返回TopicPartition列表或错误集
Consumer.consume([num_messages=1][,?timeout=-1])
消费消息,调用回调函数,返回消息列表,如果超时,返回空。
应用程序必须检查返回Message的error方法,正常Message的error返回None。
num_messages:返回的最大消息数量,默认为1
timeout:阻塞等待消息、事件、回调函数的最大时间
Connsumer.get_watermark_offsets(partition[,?timeout=None][,?cached=False])
获取分区的低水位和高水位
partition:TopicPartition对象
Timeout:请求超时,
Cached:是否替换正在查询的Broker使用的缓存信息。
成功返回低水位和高水位的元组,超时返回None。
Consumer.list_topics([topic=None][,?timeout=-1])
请求集群的元数据信息。
topic:字符串类,如果指定,只请求本Topic的信息,否则返回集群的所有Topic。
timeout:超时前的最大响应时间,-1表示永不超时。
返回ClusterMetadata类型
Consumer.offsets_for_times(partitions[,?timeout=None])
对指定的分区列表根据时间戳查询offsets。
返回每个分区的offsets大于等于指定分区列表的时间戳的位移。
partitions:TopicPartition列表
timeout:请求超时时间。
Consumer.pause(partitions)
暂停指定分区列表的分区的消费
Consumer.poll([timeout=None])
消费消息,调用回调函数,返回事件。
应用程序必须检查返回的Message对象的error()方法,如果是正常消息,返回None。
返回Message对象回None。
Consumer.position(partitions)
获取指定分区列表分区的位移
partitions:分区列表
返回带位移的TopicPartition列表,当前位移是最新消费消息的位移加1。
Consumer.resume(partitions)
恢复指定分区列表的分区的消费
partitions:要恢复的TopicPartitio列表
Consumer.seek(partition)
定位分区的消费位移到offset。offset可以是绝对值,也可以是逻辑位移OFFSET_BEGINNING。本函数只用于活跃消费分区更新消费位移,要设置分区的起始位移可以使用assign函数。
Consumer.store_offsets([message=None][,?offsets=None])
存储一条消息的位移或位移列表。
message和offsets是互斥参数。
被存储的位移会根据auto.commit.interval.m参数值被提交,使用本函数时enable.auto.offset.store参数必须被设置为False。
message:存储message的位移加1。
offsets:要存储位移的TopicPartition列表
Consumer.subscribe(topics[,?on_assign=None][,?on_revoke=None])
设置要订阅的Topic列表,会替代此前订阅的Topic。
订阅的Topic名称支持正则表达式,使用”^”作为Topic名称前缀。
topics:Topic名称列表
on_assign:完成分区再分配的回调函数
on_revoke:再平衡操作的

on_assign(consumer,?partitions)
on_revoke(consumer,?partitions)

Consumer.unassign()
删除当前分区分配策略和停止消费
Consumer.unsubscribe()
删除当前订阅Topic

2、confluent_kafka.Producer

confluent_kafka.Producer是异步Kafka生产者。
Producer.Producer(config)
使用config字典创建Producer实例。
config:配置字典对象,至少应该设置bootstrap.servers属性
Producer.len()
返回要传递到Broker的消息数量
Producer.flush([timeout])
等待Producer队列中要传递的所有消息。
timeout:阻塞的最大时间,要求librdkafka版本大于0.9.4。
返回Producer消息队列中仍然存在的消息的数量。
Producer.list_topics([topic=None][,?timeout=-1])
请求集群的元数据。
topic:如果指定Topic,只返回Topic的相应元数据,否则返回所有Topic的元数据。
timeout:超时前的最大响应时间,-1表示永不超时。
返回ClusterMetadata类型。
Producer.poll([timeout])
Poll生产者事件,调用相应回调函数。
timeout:阻塞等待事件的最大时间。
返回处理事件的数量。
Producer.produce(topic[,?value][,?key][,?partition][,?on_delivery][,?timestamp][,?headers])
生产消息到指定Topic,异步操作。
topic:要生产消息到的指定Topic。
value:str或bytes类型,消息数据。
key:str或bytes类型,消息Key。
partition:要生产消息到指定分区,否则使用内置分区分配策略。
on_delivery:投递报告回调函数
timestamp:消息事件戳,要求librdkafka v0.9.4以上版本,api.version.request=true, Kafka 0.10.0.0以上版本。
headers:消息头,字典类型,消息头的key必须是字符串,value必须是二进制数据,unicode或None。要求librdkafka v0.11.4以上版本和Kafka 0.11.0.0以上版本。

3、confluent_kafka.admin.AdminClient

AdminClient提供对Kafka Broker、Topic、Group、Broker支持的其它资源进行管理操作。
AdminClient.alter_configs(resources,?**kwargs)
更新指定resource的配置值。
AdminClient.create_partitions(new_partitions,?**kwargs)
创建指定Topic的分区
AdminClient.create_topics(new_topics,?**kwargs)
创建Topic
AdminClient.delete_topics(topics,?**kwargs)
删除Topic
AdminClient.describe_configs(resources,?**kwargs)
获取指定resource的配置

4、confluent_kafka.admin.BrokerMetadata

BrokerMetadata定义了Kafka Broker的信息,是非实例化类,BrokerMetadata包含的属性如下:
id:整型,Broker ID
host:字符串类型,Broker 主机名
port:整型,Broker端口

5、confluent_kafka.admin.ClusterMetadata

ClusterMetadata定义了Kafka集群、Broker、Topic等信息,是非实例化类,ClusterMetadata包含如下属性:
cluster_id?:字符串,Kafka集群ID字符串。
controller_id:id类型,当前Controller Broker ID
brokers:字典,key为整型Broker ID,值为BrokerMetadata对象。
topics?:字典,key为字符串Topic名称, 值为TopicMetadata对象。
orig_broker_id:整型,数据源于Broker的ID。
orig_broker_name:字符串,数据源于Broker的名称或地址。

6、confluent_kafka.admin.ConfigEntry

ConfigEntry由describe_configs()返回指定资源的配置实体,是非实例化类,ConfigEntry包含如下属性:
name:字符串,配置属性名称。
value:字符串,配置值。
source?:ConfigSource类型,配置源。
is_read_only:bool类型,指明配置属性是否只读。
is_default:bool类型,指明配置属性是否使用默认值。
is_sensitive:bool类型,指明配置属性值是否包含敏感信息,如安全配置。
is_synonym:bool类型,指明配置属性是否是赋配置实体的别名。
synonyms?:list类型,配置属性的备用源的配置实体列表。

7、confluent_kafka.admin.ConfigResource

ConfigResource(restype,?name,?set_config=None,?described_configs=None,?error=None)
restype:resource类型
name:resource名称
set_config:胚珠属性值设置方法
described_configs:
error:错误信息
Kafka资源ConfigResource.Type如下:
ANY= 1,任何资源
BROKER= 4,Broker资源,资源名称是Broker ID
GROUP= 3,Group资源,资源名称是group.id
TOPIC= 2,Topic资源,资源名称是Topic名称。
UNKNOWN= 0,未知类型,未设置类型。
set_config(name,?value,?overwrite=True)
设置、覆写配置实体
name:配置属性名称。
value:配置属性值。
overwrite:是否覆写。

8、confluent_kafka.admin.ConfigSource

ConfigSource是由?describe_configs()返回的配置实体的配置源。
DEFAULT_CONFIG= 5
DYNAMIC_BROKER_CONFIG= 2
DYNAMIC_DEFAULT_BROKER_CONFIG= 3
DYNAMIC_TOPIC_CONFIG= 1
STATIC_BROKER_CONFIG= 4
UNKNOWN_CONFIG= 0

9、confluent_kafka.admin.PartitionMetadata

PartitionsMetadata包含Kafka分区的元数据,是非实例化类,PartitionsMetadata包含的属性如下:
id?:整型,分区编号。
leader?:整型,分区的当前Leader,或是-1。
replicas:?整型列表,分区的副本的Broker ID的列表。
Isrs:?整型列表,分区的ISR Broker ID列表。
error:KafkaError类型,分区错误。

10、confluent_kafka.admin.TopicMetadata

TopicMetadata包含Kafka Topic相关的元数据,是非实例化类,TopicMetadata包含的属性如下:
topic:字符串类型,Topic名称
partitions:字典,key是分区编号,值是PartitionMetadata对象。
error:KafkaError类型,Topic错误。

三、Avro序列化组件

1、confluent_kafka.avro.AvroConsumer

AvroConsumer(config,?schema_registry=None,?reader_key_schema=None,?reader_value_schema=None)
Kafka Consumer客户端,对消息进行avro模式解码,处理消息反序列化。
config:字典,配置参数,包含schema.registry.url和bootstrap.servers参数。
reader_key_schema:schema类型,消息key的读取器。
reader_value_schema:(schema类型,消息值的读取器。
AvroConsumer.poll(timeout=None)
confluent_kafka.Consumer类的poll方法的覆写,使用avro scema处理消息的反序列化。

2、confluent_kafka.avro.AvroProducer

AvroProducer(config,?default_key_schema=None,?default_value_schema=None,?schema_registry=None)
对消息进行avro schema编码的Kafka Producer客户端,处理结构注册、消息序列化。
config:字典,配置参数,包含schema.registry.url和bootstrap.servers参数。
default_key_schema:字符串,可选,key的默认avro schema。
default_value_schema:字符串,可选,value的默认avro schema。
AvroProducer.produce(**kwargs)
异步发送消息到Kafka,使用指定编码,默认使用avro schema。
topic:字符串,Topic名称。
value:?object类型,要序列化的对象。
value_schema:字符串,值的Avro schema。
key:object类型,要序列化的对象。
key_schema:字符串,键Avro schema。

四、coufluent-kafka主要类API

1、confluent_kafka.Message

Message对象表示一条消费或生产的消息,或是一个事件。
应用程序必须使用Message.error()方法检查Message对象是否是一个正常的Message还是一个错误事件。
Message类不是用户可实例化的类,
Message.len()
返回消息数据的长度
Message.error()
Message对象用于传播错误或事件,应用程序必须检查error()方法以确定Message对象是否是一个正常的消息(返回None),错误或是事件(返回KafkaError对象)。
Message.headers()
获取消息的头。消息头是键值对集合,消息头的键是有序的,可以重重复。
返回消息头键值对的列表。
Message.key()
获取消息键。
Message.offset()
消息位移
Message.partition()
分区编号
Message.set_headers(value)
使用新值设置Message.key字段的值。
Message.set_value()
使用新值设置Message.value字段的值
Message.timestamp()
获取消息的时间戳类型和时间戳。时间戳类型如下:
TIMESTAMP_NOT_AVAILABLE:Broker不支持的时间戳
TIMESTAMP_CREATE_TIME:生产者时间戳
TIMESTAMP_LOG_APPEND_TIME:Broker接收时间
返回时间戳类型和时间戳的元组。
如果返回的时间戳类型是TIMESTAMP_NOT_AVAILABLE,返回的时间戳应该被忽略。时间戳要求Kafka 0.10.0.0以上版本,客户端配置的api.version.request属性值为True。
Message.topic()
返回消息的Topic
Message.Value()
返回消息数据。

2、confluent_kafka.TopicPartition

TopicPartition是一种泛类型,用户保存单个分区及其相关的各种信息。通常用于为不同的操作提供TopicPartition列表。
TopicPartition(topic[,?partition][,?offset])
实例化TopicPartition对象。
topic:Topic名称
partition:分区编号
offset:位移
TopicPartition.error:属性值,使用KafkaError表示一个错误。
TopicPartition.offset:属性值,位移
TopicPartition.partition:属性值,分区编号
TopicPartition.topic:属性值,Topic名称

3、confluent_kafka.KafkaError

KafkaError表示Kafka错误和事件对象,不是用户实例化类,用于事件传播、错误传播、异常。
KafkaError.code()
返回错误或事件的代码
KafkaError.name()
返回错误或事件的枚举名称
KafkaError.str()
返回事件或错误的可读字符串描述

4、confluent_kafka.KafkaException

KafkaException是对KafkaError类的封装,使用exception.args[0]可以提取KafkaError对象。

5、Offset

OFFSET_BEGINNING:从分区开始
OFFSET_END:分区结束位置
OFFSET_STORED:使用存储提交位移
OFFSET_INVALID:非法/默认位移。

6、confluent_kafka.ThrottleEvent

ThrottleEvent包含限制请求的相关数据,是非实例化类,包含如下属性:
broker_name:字符串,限制请求的Broker的主机名称。?
broker_id:整型,Broker ID。
throttle_time:float类型,Broker限制请求的时间,单为秒。

7、Configuration

生产者和消费者实例的配置。

conf = {‘bootstrap.servers‘: ‘mybroker.com‘,
        ‘group.id‘: ‘mygroup‘, ‘session.timeout.ms‘: 6000,
        ‘on_commit‘: my_commit_callback,
        ‘default.topic.config‘: {‘auto.offset.reset‘: ‘smallest‘}}
consumer = confluent_kafka.Consumer(conf)

Python绑定提供了其它的配置属性:
default.topic.config:属性值是顶层配置属性字典。

五、coufluent-kafka示例

1、Producer

from confluent_kafka import Producer

class KafkaProducer:
    def __init__(self, brokers):
        self.producer = Producer({‘bootstrap.servers‘: brokers})

    def sendMessage(self, topic, payloads):
        for payload in payloads:
            # Trigger any available delivery report callbacks from previous produce() calls
            self.producer.poll(0)
            # Asynchronously produce a message, the delivery report callback
            # will be triggered from poll() above, or flush() below, when the message has
            # been successfully delivered or failed permanently.
            self.producer.produce(topic, payload.encode(‘utf-8‘), callback=self.delivery_report)

        # Wait for any outstanding messages to be delivered and delivery report
        # callbacks to be triggered.
        self.producer.flush()

    @staticmethod
    def delivery_report(err, msg):
        """ Called once for each message produced to indicate delivery result.
            Triggered by poll() or flush(). """
        if err is not None:
            print(‘Message delivery failed: {}‘.format(err))
        else:
            print(‘Message delivered to {} [{}]‘.format(msg.topic(), msg.partition()))

if __name__ == "__main__":
    producer = KafkaProducer(‘192.168.0.105:9092‘)
    source_data = list()
    for x in range(1000):
        source_data.append("Hello kafka{}".format(x))
    producer.sendMessage(‘test2‘, source_data)

进入kafka容器:
docker exec -it kafka-test /bin/bash
查看Topic的消息:
kafka-console-consumer.sh --bootstrap-server kafka-test:9092 --topic test2 --from-beginning

2、Consumer

from confluent_kafka import Consumer

class KafkaConsumer:
    def __init__(self, brokers, group):
        config = dict()
        config[‘bootstrap.servers‘] = brokers
        config[‘group.id‘] = group
        config[‘auto.offset.reset‘] = ‘earliest‘
        self.consumer = Consumer(config)

    def subscribe(self, topics):
        self.consumer.subscribe(topics=topics)

    def pull(self):
        while True:
            msg = self.consumer.poll(1.0)
            if msg is None:
                continue
            if msg.error():
                print("Consumer error: {}".format(msg.error()))
                continue
            print(‘Received message: {}‘.format(msg.value().decode(‘utf-8‘)))

    def close(self):
        self.consumer.close()

if __name__ == "__main__":
    consumer = KafkaConsumer("192.168.0.105:9092", "test_group")
    consumer.subscribe(["test1", "test2"])
    consumer.pull()
    consumer.close()

3、AvroProducer

from confluent_kafka import avro
from confluent_kafka.avro import AvroProducer

class Message:
    """
    Message struct
    """
    def __init__(self, key, value):
        self.key = {"name": "{}".format(key)}
        self.value = {"name": "{}".format(value)}

class KafkaAvroProducer:
    """
    Kafka Avro Producer Wrapper class
    """
    value_schema = ""
    key_schema = ""

    def __init__(self, brokers, schema_registry_url):
        config = dict()
        config[‘bootstrap.servers‘] = brokers
        config[‘on_delivery‘] = KafkaAvroProducer.delivery_report
        config[‘schema.registry.url‘] = schema_registry_url
        self.avro_producer = AvroProducer(config=config,
                                          default_key_schema=KafkaAvroProducer.key_schema,
                                          default_value_schema=KafkaAvroProducer.value_schema)

    @classmethod
    def register_value_schema(cls, schema):
        cls.key_schema = avro.loads(schema)

    @classmethod
    def register_key_schema(cls, schema):
        cls.value_schema = avro.loads(schema)

    def send_message(self, topic, messages):
        for message in messages:
            self.avro_producer.produce(topic=‘test1‘, value=message.value, key=message.key)

        self.avro_producer.flush()

    @staticmethod
    def delivery_report(err, msg):
        """ Called once for each message produced to indicate delivery result.
            Triggered by poll() or flush(). """
        if err is not None:
            print(‘Message delivery failed: {}‘.format(err))
        else:
            print(‘Message delivered to {} [{}]‘.format(msg.topic(), msg.partition()))

if __name__ == "__main__":
    value_schema_str = """
    {
       "namespace": "kafka.test",
       "name": "value",
       "type": "record",
       "fields" : [
         {
           "name" : "name",
           "type" : "string"
         }
       ]
    }
    """
    key_schema_str = """
    {
       "namespace": "kafka.test",
       "name": "key",
       "type": "record",
       "fields" : [
         {
           "name" : "name",
           "type" : "string"
         }
       ]
    }
    """
    messages = list()
    for i in range(1000):
        messages.append(Message("key{}".format(i), "Hello Confluent Kafka{}".format(i)))
    KafkaAvroProducer.register_key_schema(key_schema_str)
    KafkaAvroProducer.register_value_schema(value_schema_str)
    schema_registry_url = ‘http://127.0.0.1:8081‘
    avroProducer = KafkaAvroProducer("192.168.0.105:9092", schema_registry_url)
    avroProducer.send_message("test1", messages=messages)

4、AvroConsumer

from confluent_kafka.avro import AvroConsumer
from confluent_kafka.avro.serializer import SerializerError

class KafkaAvroConsumer:
    def __init__(self, brokers, group, schema_registry_url):
        self.avro_consumer = AvroConsumer({
            ‘bootstrap.servers‘: brokers,
            ‘group.id‘: group,
            ‘auto.offset.reset‘: ‘earliest‘,
            ‘schema.registry.url‘: schema_registry_url})

    def subscribe(self, topics):
        self.avro_consumer.subscribe(topics=topics)

    def pull_message(self):
        while True:
            try:
                msg = self.avro_consumer.poll(2)
            except SerializerError as e:
                print("Message deserialization failed for {}: {}".format(msg, e))
                break
            if msg is None:
                continue
            if msg.error():
                print("AvroConsumer error: {}".format(msg.error()))
                continue
            print(msg.key(), ": ", msg.value())

    def close(self):
        self.avro_consumer.close()

if __name__ == "__main__":
    schema_registry_url = "http://127.0.0.1:8081"
    avroConsumer = KafkaAvroConsumer("192.168.0.105:9092", "test_group", schema_registry_url)
    avroConsumer.subscribe(["test1", "test2"])
    avroConsumer.pull_message()
    avroConsumer.close()

5、AdminClient

from confluent_kafka.admin import NewTopic, AdminClient

class KafkaManager:
    def __init__(self, broker):
        self.admin_client = AdminClient({‘bootstrap.servers‘: broker})

    def create_topics(self, topics, num_partition):
        new_topics = [NewTopic(topic, num_partitions=num_partition, replication_factor=1) for topic in topics]
        fs = self.admin_client.create_topics(new_topics)
        # Wait for each operation to finish.
        for topic, f in fs.items():
            try:
                f.result()  # The result itself is None
                print("Topic {} created".format(topic))
            except Exception as e:
                print("Failed to create topic {}: {}".format(topic, e))

    def delete_topics(self, topics):
        fs = self.admin_client.delete_topics(topics=topics)
        for topic, f in fs.items():
            try:
                f.result()  # The result itself is None
                print("Topic {} deleted".format(topic))
            except Exception as e:
                print("Failed to delete topic {}: {}".format(topic, e))

if __name__ == "__main__":
    import time
    manager = KafkaManager("192.168.0.105:9092")
    manager.create_topics(["test3", "test4"], 1)
    time.sleep(3)
    manager.delete_topics(["test3", "test4"])

以上是关于Kafka快速入门——Python客户端的主要内容,如果未能解决你的问题,请参考以下文章

Kafka快速入门——Kafka集群部署

Kafka快速入门(Kafka Broker)节点服役和退役手动调整副本

Kafka快速入门

Kafka快速入门

Kafka快速入门

Kafka快速入门——Kafka架构