ERREUR Erreur lors de l'envoi d'un message à un sujet
En produisant un message en kafka, j'obtiens l'erreur suivante:
$ bin/kafka-console-producer.sh --broker-list localhost:9092 --topic nil_PF1_P1
hi
hello
[2016-07-19 17:06:34,542] ERROR Error when sending message to topic nil_PF1_P1 with key: null, value: 2 bytes with error: (org.Apache.kafka.clients.producer.internals.ErrorLoggingCallback)
org.Apache.kafka.common.errors.TimeoutException: Failed to update metadata after 60000 ms.
[2016-07-19 17:07:34,544] ERROR Error when sending message to topic nil_PF1_P1 with key: null, value: 5 bytes with error: (org.Apache.kafka.clients.producer.internals.ErrorLoggingCallback)
org.Apache.kafka.common.errors.TimeoutException: Failed to update metadata after 60000 ms.
$ bin/kafka-topics.sh --describe --zookeeper localhost:2181 --topic nil_PF1_P1
Topic:nil_PF1_P1 PartitionCount:1 ReplicationFactor:1 Configs:
Topic: nil_PF1_P1 Partition: 0 Leader: 2 Replicas: 2 Isr: 2
Toute idée sur ce ??
Au lieu de changer le fichier server.properties, incluez la 0.0.0.0 dans le code même. Cela a résolu le problème pour moi.
Au lieu de
/usr/bin/kafka-console-producer --broker-list Hostname:9092 --topic MyFirstTopic1
Utilisation:
/usr/bin/kafka-console-producer --broker-list 0.0.0.0:9092 --topic MyFirstTopic1
Cela peut être dû à certains paramètres du fichier kafka server.properties. La solution suivante a fonctionné pour moi. Vous pouvez trouver plus d'informations ici
1) arrêtez le serveur kakfka.
$ cd $ KAFKA_HOME/bin
$ ./kafka-server-stop.sh
2) changé
listeners = PLAINTEXT: // nom_hôte: 9092
à
listeners = PLAINTEXT: //0.0.0.0: 9092
de
$ KAFKA_HOME/config/server.properties`
fichier.
3) redémarrer le serveur kafka.
$ KAFKA_HOME/bin/kafka-server-start.sh /kafka/config/server.properties
Si vous exécutez hortonworks cluster, vérifiez le port d'écoute dans ambari.
Dans mon cas 9092 n'était pas mon port . Je suis allé à Ambari et j'ai trouvé que le port d'écoute était réglé sur 6667 :)
Je sais que c'est vieux, mais que cela peut marcher pour quelqu'un d'autre qui s'en occupe: J'ai changé 2 choses:
1. changez le "bootstrap.servers" property ou le --broker-list option en 0.0.0.0:9092
2. changer (décommenter et éditer dans mon cas) le server.properties dans 2 propriétés
- listeners = PLAINTEXT: //votre.hote.name: 9092 à listeners = PLAINTEXT: //: 909 2
- advertised.listeners = PLAINTEXT: //votre.hote.name: 9092 à advertised.listeners = PLAINTEXT: // localhost: 9092
J'ai rencontré un problème similaire, où je pouvais produire et consommer sur localhost mais pas à partir de machines différentes sur le réseau. Sur la base de quelques réponses, j'ai compris qu'il nous fallait essentiellement exposer advertised.listener au producteur et au consommateur, mais donner 0.0.0.0 ne fonctionnait pas non plus. Donc, a donné l'adresse IP exacte par rapport à advertised.listeners
advertised.listeners=PLAINTEXT://Host.IP:9092
Et j'ai laissé le listener=PLAINTEXT://:9092 tel quel.
Donc, avec cela l'étincelle expose l'IP et le port annoncés aux producteurs et aux consommateurs
Je reçois la même erreur aujourd'hui avec confluent_kafka 0.9.2 (0x90200) et librdkafka 0.9.2 (0x90401). Dans mon cas, j'ai spécifié le mauvais port de courtier dans tutorialpoints example:
$ kafka-console-producer.sh --broker-list localhost:9092 --topic tutorialpoint-basic-ops-01
bien que mon courtier ait été démarré sur le port 9094:
$ cat server-02.properties
broker.id=2
port=9094
log.dirs=/tmp/kafka-example-logs-02
zookeeper.connect=localhost:2181
Bien que le port 9092 ne soit pas ouvert (netstat -tunap), il a fallu 60 secondes à kafka-console-producer.sh pour générer une erreur. On dirait que cet outil nécessite un correctif pour:
- échouer plus vite
- avec un message d'erreur plus explicite.
Un autre scénario ici. Aucun indice sur ce qui se passait jusqu'à ce que je trouve un journal kafka avec le message suivant:
Caused by: Java.lang.IllegalArgumentException: Invalid version for API key 3: 2
Apparemment, le producteur utilisait un client kafka (Java) plus récent que le serveur kafka et l’API utilisée n’était pas valide (client utilisant 1.1 et serveur sur 10.0). Sur le client/producteur j'ai eu le:
Error producing to topic Failed to update metadata after 60000 ms.
Pour Apache Kafka v2.11-1.1.0
Démarrer le serveur zookeeper:
$ bin/zookeeper-server-start.sh config/zookeeper.properties
Démarrer le serveur kafka:
$ bin/kafka-server-start.sh config/server.properties
Créez un nom de sujet "my_topic":
$ bin/kafka-topics.sh --create --topic my_topic --zookeeper localhost:2181 --replication-factor 1 --partitions 1
Démarrer le producteur:
$ bin/kafka-console-producer.sh --broker-list localhost:9092 --topic my_topic
Démarrer le consommateur:
$ bin/kafka-console-consumer.sh --bootstrap-server localhost:9092 --topic my_topic --from-beginning
Dans mon cas, j'utilise le docker Kafka avec Openshift. Je commençais à avoir le même problème. Cela a été corrigé lorsque j'ai passé la variable d'environnement KAFKA_LISTENERS avec une valeur de PLAINTEXT://:9092. Cela finira par créer une entrée listeners=PLAINTEXT://:9092 sous server.properties .
Les auditeurs ne doivent pas nécessairement avoir un nom d'hôte.
J'ai fait face à la pile d'exception ci-dessus. J'ai enquêté et trouvé la cause première. J'y ai fait face lorsque j'ai établi le cluster Kafka avec deux nœuds.
paramètres broker1.properties
listeners=PLAINTEXT://A.B.C.D:9092
zookeeper.connect=A.B.C.D:2181,E.F.G.H:2181
paramètres broker2.properties
listeners=PLAINTEXT://E.F.G.H:9092
zookeeper.connect=A.B.C.D:2181,E.F.G.H:2181
J'essayais de démarrer un producteur à partir de node1 ou de node2 à l'aide de la commande suivante: ./bin/kafka-console-producer.sh le stacktrace d'exception de délai d'attente ci-dessus bien que Kafka soit exécuté dans les deux machines.
Bien que le producteur commence soit à partir du nœud Leader, soit d’un suiveur, j’ai toujours eu le même résultat.
En utilisant la commande ci-dessous de n'importe quel courtier, j'ai pu obtenir le message du producteur.
./bin/kafka-console-producer.sh --broker-list A.B.C.D:9092 --topic OUR_TOPIC
or
./bin/kafka-console-producer.sh --broker-list E.F.G.H:9092 --topic OUR_TOPIC
or
./bin/kafka-console-producer.sh --broker-list A.B.C.D:9092,E.F.G.H:9092 --topic OUR_TOPIC
La cause principale est donc que le courtier Kafka utilise en interne listeners = PLAINTEXT: // EFGH: 9092 en regardant un producteur. PLAINTEXT: // localhost: 9092 fonctionnera pour notre toute première commande.
Avait ce problème: Utilisation de Hortonworks HDP 2.5. Kerberisation activé
Corrigé en fournissant le protocole de sécurité et les ports appropriés . Exemples de commandes:
./kafka-console-producer.sh --broker-list sand01.intranet:6667, san02.intranet:6667, san03.intranet:6667--topic test--security-protocol PLAINTEXTSASL
./kafka-console-consumer.sh --zookeeper sand01:2181 --topic test--from-beginning --security-protocol PLAINTEXTSASL
J'utilise Apache Kafka sur une installation de Hortonworks (version HDP 2.X). Le message d'erreur rencontré signifie que le producteur Kafka n'a pas pu envoyer les données dans le fichier journal du segment. À partir d'une console de ligne de commande, cela voudrait dire 2 choses:
- Vous utilisez un port incorrect pour les courtiers
- Votre configuration d'écoute dans server.properties ne fonctionne pas
Si vous rencontrez le message d'erreur lors de l'écriture via scala api, vérifiez également la connexion au cluster kafka à l'aide de telnet <cluster-Host> <broker-port>
REMARQUE: Si vous utilisez scala api pour créer un sujet, les courtiers ont parfois besoin de connaître le sujet nouvellement créé. Donc, immédiatement après la création de la rubrique, les producteurs risquent d’échouer avec l’erreur Failed to update metadata after 60000 ms.
J'ai effectué les vérifications suivantes afin de résoudre ce problème:
La première différence lorsque je vérifie via Ambari est que les courtiers Kafka écoutent sur le port 6667 sur HDP 2.x (Apache kafka utilise 9092).
listeners=PLAINTEXT://localhost:6667
Ensuite, utilisez le ip au lieu de localhost . J'ai exécuté netstat -na | grep 6667
tcp 0 0 192.30.1.5:6667 0.0.0.0:* LISTEN
tcp 1 0 192.30.1.5:52242 192.30.1.5:6667 CLOSE_WAIT
tcp 0 0 192.30.1.5:54454 192.30.1.5:6667 TIME_WAIT
J'ai donc modifié l'appel du producteur pour utiliser l'IP et non pas l'hôte local:
./kafka-console-producer.sh --broker-list 192.30.1.5:6667 --topic rdl_test_2
Pour contrôler si de nouveaux enregistrements sont en cours d'écriture, surveillez le dossier /kafka-logs.
cd /kafka-logs/<topic name>/
ls -lart
-rw-r--r--. 1 kafka hadoop 0 Feb 10 07:24 00000000000000000000.log
-rw-r--r--. 1 kafka hadoop 10485756 Feb 10 07:24 00000000000000000000.timeindex
-rw-r--r--. 1 kafka hadoop 10485760 Feb 10 07:24 00000000000000000000.index
Une fois que le producteur a réussi à écrire, la taille du fichier journal du segment 00000000000000000000.log augmentera.
Voir la taille ci-dessous:
-rw-r--r--. 1 kafka hadoop 10485760 Feb 10 07:24 00000000000000000000.index
-rw-r--r--. 1 kafka hadoop **45** Feb 10 09:16 00000000000000000000.log
-rw-r--r--. 1 kafka hadoop 10485756 Feb 10 07:24 00000000000000000000.timeindex
À ce stade, vous pouvez exécuter le fichier consumer-console.sh:
./kafka-console-consumer.sh --bootstrap-server 192.30.1.5:6667 --topic rdl_test_2 --from-beginning
response is hello world
Après cette étape, si vous souhaitez générer des messages via les API Scala, modifiez la valeur listeners (de localhost à une adresse IP publique) et redémarrez les courtiers Kafka via Ambari:
listeners=PLAINTEXT://192.30.1.5:6667
Un exemple de producteur sera le suivant:
package com.scalakafka.sample
import Java.util.Properties
import Java.util.concurrent.TimeUnit
import org.Apache.kafka.clients.producer.{ProducerRecord, KafkaProducer}
import org.Apache.kafka.common.serialization.{StringSerializer, StringDeserializer}
class SampleKafkaProducer {
case class KafkaProducerConfigs(brokerList: String = "192.30.1.5:6667") {
val properties = new Properties()
val batchsize :Java.lang.Integer = 1
properties.put("bootstrap.servers", brokerList)
properties.put("key.serializer", classOf[StringSerializer])
properties.put("value.serializer", classOf[StringSerializer])
// properties.put("serializer.class", classOf[StringDeserializer])
properties.put("batch.size", batchsize)
// properties.put("linger.ms", 1)
// properties.put("buffer.memory", 33554432)
}
val producer = new KafkaProducer[String, String](KafkaProducerConfigs().properties)
def produce(topic: String, messages: Iterable[String]): Unit = {
messages.foreach { m =>
println(s"Sending $topic and message is $m")
val result = producer.send(new ProducerRecord(topic, m)).get()
println(s"the write status is ${result}")
}
producer.flush()
producer.close(10L, TimeUnit.MILLISECONDS)
}
}
J'espère que ça aide quelqu'un.