python 操作Kafka kafka-python :消费者学习

1.1 安装

> pip install kafka-python

1.2 消费者示例

# coding:utf8
from kafka import KafkaConsumer
#创建一个消费者，指定了topic,group_id,bootstrap_servers
#group_id:多个拥有相同group_id的消费者被判定为一组，一条数据记录只会被同一个组中的一个消费者消费
#bootstrap_servers：kafka的节点，多个节点使用逗号分隔
#这种方式只会获取新产生的数据

consumer = KafkaConsumer(
    bootstrap_servers = "192.168.70.221:19092,192.168.70.222:19092,192.168.70.223:19092", # kafka集群地址
    group_id = "my.group", # 消费组id
    enable_auto_commit = True, # 每过一段时间自动提交所有已消费的消息（在迭代时提交）
    auto_commit_interval_ms = 5000, # 自动提交的周期（毫秒）
)

consumer.subscribe(["my.topic"]) # 消息的主题，可以指定多个

for msg in consumer: # 迭代器，等待下一条消息
    print msg # 打印消息

1.3 KafkaConsumer的构造参数：

*topics ，要订阅的主题

bootstrap_servers ：kafka节点或节点的列表，不一定需要罗列所有的kafka节点。格式为： ‘host[:port]’ 。默认值是：localhost:9092

client_id (str) : 客户端id，默认值: ‘kafka-python-{version}’

group_id (str or None)：分组id

key_deserializer (callable) ：key反序列化函数

value_deserializer (callable)：value反序列化函数

fetch_min_bytes：服务器应每次返回的最小数据量

fetch_max_wait_ms (int)：服务器应每次返回的最大等待时间

fetch_max_bytes (int) ：服务器应每次返回的最大数据量

max_partition_fetch_bytes (int) ：

request_timeout_ms (int) retry_backoff_ms (int)

reconnect_backoff_ms (int)

reconnect_backoff_max_ms (int)

max_in_flight_requests_per_connection (int)

auto_offset_reset (str) enable_auto_commit (bool)

auto_commit_interval_ms (int)

default_offset_commit_callback (callable)

check_crcs (bool)

metadata_max_age_ms (int)

partition_assignment_strategy (list)

max_poll_records (int)

max_poll_interval_ms (int)

session_timeout_ms (int)

heartbeat_interval_ms (int)

receive_buffer_bytes (int)

send_buffer_bytes (int)

socket_options (list)

consumer_timeout_ms (int)

skip_double_compressed_messages (bool)

security_protocol (str)

ssl_context (ssl.SSLContext)

ssl_check_hostname (bool)

ssl_cafile (str) –

ssl_certfile (str)

ssl_keyfile (str)

ssl_password (str)

ssl_crlfile (str)

api_version (tuple)

1.4 KafkaConsumer的函数

assign(partitions)：手动为该消费者分配一个topic分区列表。

assignment()：获取当前分配给该消费者的topic分区。

beginning_offsets(partitions)：获取给定分区的第一个偏移量。

close(autocommit=True)：关闭消费者

commit(offsets=None)：提交偏移量，直到成功或错误为止。

commit_async(offsets=None, callback=None)：异步提交偏移量。

committed(partition)：获取给定分区的最后一个提交的偏移量。

end_offsets(partitions)：获取分区的最大偏移量

highwater(partition)：分区最大的偏移量

metrics(raw=False)：返回消费者性能指标

next（）：返回下一条数据

offsets_for_times(timestamps)：根据时间戳获取分区偏移量

partitions_for_topic(topic)：返回topic的partition列表，返回一个set集合

pause(*partitions)：停止获取数据paused()：返回停止获取的分区poll(timeout_ms=0, max_records=None)：获取数据

position(partition)：获取分区的偏移量

resume(*partitions)：恢复抓取指定的分区

seek(partition, offset)：seek偏移量

seek_to_beginning(*partitions)：搜索最旧的偏移量

seek_to_end(*partitions)：搜索最近可用的偏移量

subscribe(topics=(), pattern=None, listener=None)：订阅topics

subscription()：返回当前消费者消费的所有topic

topics()：返回当前消费者消费的所有topic，返回的是unicode

unsubscribe()：取消订阅所有的topic

1.5 高级用法（消费者）

从指定offset开始读取消息，被消费过的消息也可以被此方法读取

创建消费者
2.使用 assign 方法重置指定分区(partition)的读取偏移(fetch offset)的值

使用 seek 方法从指定的partition和offset开始读取数据

#encoding:utf8
from kafka import KafkaConsumer, TopicPartition

my_topic = "my.topic" # 指定需要消费的主题

consumer = KafkaConsumer(
    bootstrap_servers = "192.168.70.221:19092,192.168.70.222:19092,192.168.70.223:19092", # kafka集群地址
    group_id = "my.group", # 消费组id
    enable_auto_commit = True, # 每过一段时间自动提交所有已消费的消息（在迭代时提交）
    auto_commit_interval_ms = 5000, # 自动提交的周期（毫秒）
)

consumer.assign([
    TopicPartition(topic=my_topic, partition=0),
    TopicPartition(topic=my_topic, partition=1),
    TopicPartition(topic=my_topic, partition=2)
])

consumer.seek(TopicPartition(topic=my_topic, partition=0), 12) # 指定起始offset为12
consumer.seek(TopicPartition(topic=my_topic, partition=1), 0) # 可以注册多个分区，此分区从第一条消息开始接收
# consumer.seek(TopicPartition(topic=my_topic, partition=2), 32) # 没有注册的分区上的消息不会被消费

for msg in consumer: # 迭代器，等待下一条消息
    print msg # 打印消息

## 其他用法

#立刻发送所有数据并等待发送完毕
producer.flush()

#读取下一条消息
next(consumer)

#手动提交所有已消费的消息
consumer.commit()

#手动提交指定的消息
consumer.commit([
    TopicPartition(my_topic, msg.offset)
])

1.6 KafkaProductor的工具类

# -*- coding: utf-8 -*-

"""
Create by Mr.Hao on 2019/7/12.

"""

import sys
import json
import traceback
from utils import get_logger
from kafka.errors import KafkaError
from kafka import KafkaConsumer,TopicPartition
logger = get_logger("ConsumerForKFK")


class ConsumerForKFK(object):


    _MESSAGE_NAME = ''

    def __init__(self, kafkahost, client_id):
        self.kafkaHost = kafkahost
        self.client_id = client_id

    @property
    def consumer_client(self, group_id=None):
        return KafkaConsumer(self._MESSAGE_NAME,
                      bootstrap_servers=self.kafkaHost,
                      client_id = self.client_id,
                      """
                      # earliest
                      当各分区下有已提交的offset时，从提交的offset开始消费；无提交的offset时，从头开始消费
                      # latest
                       当各分区下有已提交的offset时，从提交的offset开始消费；无提交的offset时，消费新产生的该分区下的数据
                      # none
                      topic各分区都存在已提交的offset时，从offset后开始消费；只要有一个分区不存在已提交的offset，则抛出异常
                      """
                      auto_offset_reset='earliest',
                      group_id=group_id,
                      # 若不指定 consumer_timeout_ms，默认一直循环等待接收，若指定，则超时返回，不再等待
                      # consumer_timeout_ms ： 毫秒数
                      consumer_timeout_ms=5000)
    
    @property
    def close(self):
        return self.consumer_client.close()

    def consumer(self):
        """
        :return: 返回正常的kfk 消息
        """
        try:
            consumer = self.consumer_client
            # 迭代器，等待下一条消息
            for msg in consumer:
                # 打印消息
                print msg
        except KafkaError as e:
            t, v, tb = sys.exc_info()
            logger.error("send msg ext has error, please check: %s, %s, %s", t, v, traceback.format_tb(tb))
        finally:
            self.close()

    def consumer_seek(self, partition=1, offset=0):
        """
        :param partition: 
        :param offset: 
        :return: 
        """
        try:
            consumer = self.consumer_client

            consumer.seek(TopicPartition(topic=self._MESSAGE_NAME, partition=partition), offset)
            # 发送到指定的消息主题（异步，不阻塞）
            for msg in consumer:  # 迭代器，等待下一条消息
                print msg  # 打印消息

        except KafkaError as e:
            t, v, tb = sys.exc_info()
            logger.error("send msg ext has error, please check: %s, %s, %s", t, v, traceback.format_tb(tb))
        finally:
            self.close()

    def consumer_assign(self, partition=1):
        """
        :param partition: 
        :return: 
        """
        try:
            consumer = self.consumer_client
            consumer.assign([TopicPartition(topic=self._MESSAGE_NAME, partition=partition)])
            # 发送到指定的消息主题（异步，不阻塞）
            for msg in consumer:  # 迭代器，等待下一条消息
                print msg  # 打印消息
        except KafkaError as e:
            t, v, tb = sys.exc_info()
            logger.error("send msg ext has error, please check: %s, %s, %s", t, v, traceback.format_tb(tb))
        finally:
            self.close()

文档

kafka 文档
 kafka-python
kafka-python 文档

python 操作Kafka kafka-python :消费者学习

1.1 安装

1.2 消费者示例

1.3 KafkaConsumer的构造参数：

1.4 KafkaConsumer的函数

1.5 高级用法（消费者）

从指定offset开始读取消息，被消费过的消息也可以被此方法读取

1.6 KafkaProductor的工具类

文档

文章:用管道解释kafka