web-dev-qa-db-fra.com

Comment obtenir le dernier décalage d'une partition pour une rubrique kafka?

J'utilise le Python consommateur de haut niveau pour Kafka et je veux connaître les derniers décalages pour chaque partition d'un sujet. Cependant, je ne peux pas le faire fonctionner.

from kafka import TopicPartition
from kafka.consumer import KafkaConsumer

con = KafkaConsumer(bootstrap_servers = brokers)
ps = [TopicPartition(topic, p) for p in con.partitions_for_topic(topic)]

con.assign(ps)
for p in ps:
    print "For partition %s highwater is %s"%(p.partition,con.highwater(p))

print "Subscription = %s"%con.subscription()
print "con.seek_to_beginning() = %s"%con.seek_to_beginning()

Mais la sortie que j'obtiens est

For partition 0 highwater is None
For partition 1 highwater is None
For partition 2 highwater is None
For partition 3 highwater is None
For partition 4 highwater is None
For partition 5 highwater is None
....
For partition 96 highwater is None
For partition 97 highwater is None
For partition 98 highwater is None
For partition 99 highwater is None
Subscription = None
con.seek_to_beginning() = None
con.seek_to_end() = None

J'ai une autre approche en utilisant assign mais le résultat est le même

con = KafkaConsumer(bootstrap_servers = brokers)
ps = [TopicPartition(topic, p) for p in con.partitions_for_topic(topic)]

con.assign(ps)
for p in ps:
    print "For partition %s highwater is %s"%(p.partition,con.highwater(p))

print "Subscription = %s"%con.subscription()
print "con.seek_to_beginning() = %s"%con.seek_to_beginning()
print "con.seek_to_end() = %s"%con.seek_to_end()

Il semble à partir d'une partie de la documentation que je pourrais obtenir ce comportement si un fetch n'a pas été émis. Mais je ne peux pas trouver un moyen de forcer cela. Qu'est-ce que je fais mal?

Ou existe-t-il un moyen différent/plus simple d'obtenir les derniers décalages pour un sujet?

pythonapache-kafkakafka-consumer-apikafka-python
20
Saket

Finalement, après avoir passé une journée là-dessus et plusieurs faux départs, j'ai pu trouver une solution et la faire fonctionner. L'afficher pour que d'autres puissent s'y référer.

from kafka import SimpleClient
from kafka.protocol.offset import OffsetRequest, OffsetResetStrategy
from kafka.common import OffsetRequestPayload

client = SimpleClient(brokers)

partitions = client.topic_partitions[topic]
offset_requests = [OffsetRequestPayload(topic, p, -1, 1) for p in partitions.keys()]

offsets_responses = client.send_offset_request(offset_requests)

for r in offsets_responses:
    print "partition = %s, offset = %s"%(r.partition, r.offsets[0])
31
Saket

Si vous souhaitez utiliser Kafka Scripts shell présents dans kafka/bin, vous pouvez obtenir les derniers et les plus petits décalages en utilisant kafka-run-class.sh.

Pour obtenir la dernière commande de décalage, cela ressemblera à ceci

bin/kafka-run-class.sh kafka.tools.GetOffsetShell --broker-list localhost:9092 --time -1 --topic topiname

Pour obtenir la plus petite commande de décalage, cela ressemblera à ceci

bin/kafka-run-class.sh kafka.tools.GetOffsetShell --broker-list localhost:9092 --time -2 --topic topiname

Vous pouvez trouver plus d'informations sur Get Offsets Shell en suivant link

J'espère que cela t'aides!

17
avr
from kafka import KafkaConsumer, TopicPartition

TOPIC = 'MYTOPIC'
GROUP = 'MYGROUP'
BOOTSTRAP_SERVERS = ['kafka01:9092', 'kafka02:9092']

consumer = KafkaConsumer(
        bootstrap_servers=BOOTSTRAP_SERVERS,
        group_id=GROUP,
        enable_auto_commit=False
    )


for p in consumer.partitions_for_topic(TOPIC):
    tp = TopicPartition(TOPIC, p)
    consumer.assign([tp])
    committed = consumer.committed(tp)
    consumer.seek_to_end(tp)
    last_offset = consumer.position(tp)
    print("topic: %s partition: %s committed: %s last: %s lag: %s" % (TOPIC, p, committed, last_offset, (last_offset - committed)))

consumer.close(autocommit=False)
12
Itamar Lavender

Avec kafka-python>=1.3.4 vous pouvez utiliser:

kafka.KafkaConsumer.end_offsets (partitions)

Obtenez le dernier décalage pour les partitions données. Le dernier décalage d'une partition est le décalage du message à venir, c'est-à-dire le décalage du dernier message disponible + 1.

from kafka import TopicPartition
from kafka.consumer import KafkaConsumer

con = KafkaConsumer(bootstrap_servers = brokers)
ps = [TopicPartition(topic, p) for p in con.partitions_for_topic(topic)]

con.end_offsets(ps)
7
a.costa

Une autre façon d'y parvenir est d'interroger le consommateur pour obtenir le dernier décalage consommé, puis d'utiliser la méthode seek_to_end pour obtenir la partition de décalage disponible la plus récente.

from kafka import KafkaConsumer
consumer = KafkaConsumer('my-topic',
                     group_id='my-group',
                     bootstrap_servers=['localhost:9092'])
consumer.poll()
consumer.seek_to_end()

Cette méthode est particulièrement utile lors de l'utilisation de groupes de consommateurs.

SOURCES:

  1. https://kafka-python.readthedocs.io/en/master/apidoc/kafka.consumer.html#kafka.consumer.KafkaConsumer.poll
  2. https://kafka-python.readthedocs.io/en/master/apidoc/kafka.consumer.html#kafka.consumer.KafkaConsumer.seek_to_end
2
olujedai