Estoy desarrollando una herramienta de monitorización BS kafka. El programa escuchará un tema de kafka y generará constantemente el nuevo mensaje de ese tema. Entonces, ¿cuál es el mejor enfoque para enviar esos mensajes constantemente al lado del navegador?

El programa usa un matraz, por lo que actualmente estoy usando stream_with_context para enviar un nuevo mensaje al lado del navegador. Esto funciona por ahora, pero me pregunto si este es el escenario correcto para usar stream_with_context, ya que la mayoría de los casos de uso son para descargas y transmisión de video. ¿O tal vez debería usar websocket?

@read_controller.route('/v1/listenkafka/<string:kafkaId>', methods=['GET'])
def start_stream(kafkaId):
    try:
        mykafka_json = eval(my_storage.get(kafkaId))
        mykafka = kafkaserver(ip=mykafka_json['ip'], id=kafkaId, port=mykafka_json['port'])
        return Response(stream_with_context(mykafka.consume_topic(mykafka_json['topic'])))
    except Exception as e:
        print(f"{e}")
        return jsonify(f"{e}"), 400
#The generator listen to kafka and feed to stream

def consume_topic(self, topic, groupid='test-consumer-group'):
    consumer = KafkaConsumer(topic,
                             group_id=groupid,
                             bootstrap_servers=[f"{self.ip}:{self.port}"])
    print(f"Topic: {topic}@{self.ip}:{self.port} starts steaming at {datetime.now()}")
    try:
        for messages in consumer:
            mykafka_json = eval(my_storage.get(self.id))
            print(mykafka_json)
            if mykafka_json['flag']:
                my_storage.delete(self.id)
                return
            else:
                message = {'topic':messages.topic,
                           'partition':messages.partition,
                           'offset':messages.offset,
                           'key':messages.key,
                           'value':messages.value}
                print (message['value'])
                yield message['value']
    except StopIteration as e:
        #TODO:: handle return
        print(e)
    finally:
        print(f"Topic-{topic} finish at {datetime.now()}")

Entonces, ¿debería usar stream_with_context en este escenario o debería cambiar para usar websocket?

Gracias

1
zeruitle 22 oct. 2019 a las 11:40

1 respuesta

La mejor respuesta

Bueno, ahora lo entiendo.

El stream_with_context en realidad devolverá TODO el contenido desde el principio en cada momento de la solicitud frontal.

Por lo tanto, es una herramienta para descargar, no para enviar constantemente nuevos datos del servidor al cliente.

Finalmente, elegí flask-socketIO, es una mejor opción que websocket, pero necesitas estudiar la muestra para entender cómo funciona ... El documento pierde algunos detalles ...

0
zeruitle 19 ene. 2020 a las 01:24