Come posso inviare messaggi di grandi dimensioni con Kafka (oltre 15 MB)?

Invio di messaggi String a Kafka V. 0.8 con l'API Java Producer. Se la dimensione del messaggio è di circa 15 MB, ottengo un file MessageSizeTooLargeException. Ho provato a impostare message.max.bytessu 40 MB, ma ottengo ancora l'eccezione. I piccoli messaggi funzionavano senza problemi.

(L'eccezione appare nel produttore, non ho un consumatore in questa applicazione.)

Cosa posso fare per sbarazzarmi di questa eccezione?

Il mio esempio di configurazione del produttore

private ProducerConfig kafkaConfig() {
    Properties props = new Properties();
    props.put("metadata.broker.list", BROKERS);
    props.put("serializer.class", "kafka.serializer.StringEncoder");
    props.put("request.required.acks", "1");
    props.put("message.max.bytes", "" + 1024 * 1024 * 40);
    return new ProducerConfig(props);
}

Error-Log:

4709 [main] WARN  kafka.producer.async.DefaultEventHandler  - Produce request with correlation id 214 failed due to [datasift,0]: kafka.common.MessageSizeTooLargeException
4869 [main] WARN  kafka.producer.async.DefaultEventHandler  - Produce request with    correlation id 217 failed due to [datasift,0]: kafka.common.MessageSizeTooLargeException
5035 [main] WARN  kafka.producer.async.DefaultEventHandler  - Produce request with   correlation id 220 failed due to [datasift,0]: kafka.common.MessageSizeTooLargeException
5198 [main] WARN  kafka.producer.async.DefaultEventHandler  - Produce request with correlation id 223 failed due to [datasift,0]: kafka.common.MessageSizeTooLargeException
5305 [main] ERROR kafka.producer.async.DefaultEventHandler  - Failed to send requests for topics datasift with correlation ids in [213,224]

kafka.common.FailedToSendMessageException: Failed to send messages after 3 tries.
at kafka.producer.async.DefaultEventHandler.handle(Unknown Source)
at kafka.producer.Producer.send(Unknown Source)
at kafka.javaapi.producer.Producer.send(Unknown Source)

È necessario regolare tre (o quattro) proprietà:

• Lato consumatore: fetch.message.max.bytesdeterminerà la dimensione massima di un messaggio che può essere recuperata dal consumatore.
• Lato broker: replica.fetch.max.bytesquesto consentirà alle repliche nei broker di inviare messaggi all'interno del cluster e di assicurarsi che i messaggi vengano replicati correttamente. Se è troppo piccolo, il messaggio non verrà mai replicato e, di conseguenza, il consumatore non vedrà mai il messaggio perché il messaggio non verrà mai sottoposto a commit (replicato completamente).
• Lato broker: message.max.bytes- questa è la dimensione massima del messaggio che può essere ricevuto dal broker da un produttore.
• Lato broker (per argomento): max.message.bytesquesta è la dimensione massima del messaggio che il broker consentirà di aggiungere all'argomento. Questa dimensione è convalidata prima della compressione. (L'impostazione predefinita è quella del broker message.max.bytes.)

Ho scoperto a mie spese il numero 2: non ricevi ALCUNA eccezione, messaggio o avviso da Kafka, quindi assicurati di tenerlo in considerazione quando invii messaggi di grandi dimensioni.

Piccole modifiche richieste per Kafka 0.10 e il nuovo consumatore rispetto alla risposta di laughing_man :

• Broker: Nessuna modifica, è comunque necessario aumentare le proprietà message.max.bytese replica.fetch.max.bytes. message.max.bytesdeve essere uguale o minore (*) di replica.fetch.max.bytes.
• Produttore: aumentare max.request.sizeper inviare il messaggio più grande.
• Consumatore: aumentare max.partition.fetch.bytesper ricevere messaggi più grandi.

(*) Leggi i commenti per saperne di più su message.max.bytes<=replica.fetch.max.bytes

È necessario sovrascrivere le seguenti proprietà:

Configurazioni broker ($ KAFKA_HOME / config / server.properties)

• replica.fetch.max.bytes
• message.max.bytes

Consumer Configs ($ KAFKA_HOME / config / consumer.properties)
Questo passaggio non ha funzionato per me. L'ho aggiunto all'app consumer e funzionava bene

• fetch.message.max.bytes

Riavvia il server.

guarda questa documentazione per maggiori informazioni: http://kafka.apache.org/08/configuration.html

L'idea è di avere la stessa dimensione del messaggio inviato da Kafka Producer a Kafka Broker e quindi ricevuto da Kafka Consumer, ovvero

Produttore Kafka -> Broker Kafka -> Consumatore Kafka

Supponiamo che se il requisito è di inviare 15 MB di messaggio, il produttore , il broker e il consumatore , tutti e tre, devono essere sincronizzati.

Kafka Producer invia 15 MB -> Kafka Broker consente / archivia 15 MB -> Kafka Consumer riceve 15 MB

L'impostazione quindi dovrebbe essere:

a) su Broker:

message.max.bytes=15728640 
replica.fetch.max.bytes=15728640

b) sul consumatore:

fetch.message.max.bytes=15728640

Una cosa fondamentale da ricordare che l' message.max.bytesattributo deve essere sincronizzato con la fetch.message.max.bytesproprietà del consumatore . la dimensione del fetch deve essere grande almeno quanto la dimensione massima del messaggio altrimenti potrebbe esserci una situazione in cui i produttori possono inviare messaggi più grandi di quanto il consumatore possa consumare / fetch. Potrebbe valere la pena dargli un'occhiata.
Quale versione di Kafka stai usando? Fornisci anche qualche traccia di dettagli in più che stai ottenendo. c'è qualcosa come ... in payload size of xxxx larger than 1000000arrivo nel registro?

La risposta di @laughing_man è abbastanza accurata. Tuttavia, volevo dare una raccomandazione che ho imparato dall'esperto di Kafka Stephane Maarek di Quora.

Kafka non è pensato per gestire messaggi di grandi dimensioni.

La tua API dovrebbe utilizzare l'archiviazione cloud (Ex AWS S3) e inviare semplicemente a Kafka oa qualsiasi broker di messaggi un riferimento di S3. Devi trovare un posto in cui conservare i tuoi dati, forse è un'unità di rete, forse è qualunque cosa, ma non dovrebbe essere un broker di messaggi.

Ora, se non vuoi andare con la soluzione sopra

La dimensione massima del messaggio è 1 MB (l'impostazione nei broker è chiamata message.max.bytes) Apache Kafka . Se ne avevi davvero bisogno, potresti aumentare quella dimensione e assicurarti di aumentare i buffer di rete per i tuoi produttori e consumatori.

E se ti interessa davvero dividere il tuo messaggio, assicurati che ogni divisione del messaggio abbia la stessa identica chiave in modo che venga inviata alla stessa partizione e il contenuto del tuo messaggio dovrebbe riportare un "ID parte" in modo che il tuo consumatore possa ricostruire completamente il messaggio .

Puoi anche esplorare la compressione, se il tuo messaggio è basato su testo (compressione gzip, snappy, lz4) che può ridurre la dimensione dei dati, ma non magicamente.

Di nuovo, devi usare un sistema esterno per archiviare quei dati e semplicemente inviare un riferimento esterno a Kafka. Questa è un'architettura molto comune e dovresti andare con e ampiamente accettata.

Tieni presente che Kafka funziona meglio solo se i messaggi sono enormi in quantità ma non in dimensioni.

Fonte: https://www.quora.com/How-do-I-send-Large-messages-80-MB-in-Kafka

Per le persone che usano landoop kafka: puoi passare i valori di configurazione nelle variabili d'ambiente come:

docker run -d --rm -p 2181:2181 -p 3030:3030 -p 8081-8083:8081-8083  -p 9581-9585:9581-9585 -p 9092:9092
 -e KAFKA_TOPIC_MAX_MESSAGE_BYTES=15728640 -e KAFKA_REPLICA_FETCH_MAX_BYTES=15728640  landoop/fast-data-dev:latest `

E se stai usando rdkafka, passa il messaggio message.max.bytes nella configurazione del produttore come:

  const producer = new Kafka.Producer({
        'metadata.broker.list': 'localhost:9092',
        'message.max.bytes': '15728640',
        'dr_cb': true
    });

Allo stesso modo, per il consumatore,

  const kafkaConf = {
   "group.id": "librd-test",
   "fetch.message.max.bytes":"15728640",
   ... .. }