webentwicklung-frage-antwort-db.com.de

gibt es eine Möglichkeit, eine Json-Datei (enthält 100 Dokumente) in Elasticsearch Server zu importieren.

Gibt es eine Möglichkeit, eine JSON-Datei (enthält 100 Dokumente) in den Elasticsearch-Server zu importieren? Ich möchte eine große Json-Datei in den Es-Server importieren.

jsonelasticsearchbigdataartificial-intelligenceelasticsearch-plugin
29
shailendra pathak

Sie sollten Bulk API verwenden. Beachten Sie, dass Sie vor jedem Json-Dokument eine Kopfzeile hinzufügen müssen.

$ cat requests
{ "index" : { "_index" : "test", "_type" : "type1", "_id" : "1" } }
{ "field1" : "value1" }
$ curl -s -XPOST localhost:9200/_bulk --data-binary @requests; echo
{"took":7,"items":[{"create":{"_index":"test","_type":"type1","_id":"1","_version":1,"ok":true}}]}
18
dadoonet

Wie bereits erwähnt, ist die Bulk-API wahrscheinlich der richtige Weg. Um Ihre Datei für das Massenprotokoll umzuwandeln, können Sie jq verwenden.

Angenommen, die Datei enthält nur die Dokumente selbst:

$ echo '{"foo":"bar"}{"baz":"qux"}' | 
jq -c '
{ index: { _index: "myindex", _type: "mytype" } },
. '

{"index":{"_index":"myindex","_type":"mytype"}}
{"foo":"bar"}
{"index":{"_index":"myindex","_type":"mytype"}}
{"baz":"qux"}

Wenn die Datei die Dokumente in einer Liste der obersten Ebene enthält, müssen diese zuerst ausgepackt werden:

$ echo '[{"foo":"bar"},{"baz":"qux"}]' | 
jq -c '
.[] |
{ index: { _index: "myindex", _type: "mytype" } },
. '

{"index":{"_index":"myindex","_type":"mytype"}}
{"foo":"bar"}
{"index":{"_index":"myindex","_type":"mytype"}}
{"baz":"qux"}

das Flag -c von jq stellt sicher, dass sich jedes Dokument in einer eigenen Zeile befindet.

Wenn Sie direkt zum Curl-Pipe übergehen möchten, verwenden Sie --data-binary @- und nicht nur -d. Andernfalls werden die Zeilenumbrüche durch curl wieder entfernt.

39
Peter

Ich bin mir sicher, dass jemand das will, also mache ich es leicht, es zu finden.

FYI - Dies verwendet Node.js (im Wesentlichen als Batch-Skript) auf demselben Server wie die brandneue ES-Instanz. Ich habe es auf 2 Dateien mit jeweils 4000 Elementen verteilt und es dauerte nur etwa 12 Sekunden auf meinem freigegebenen virtuellen Server. YMMV

var elasticsearch = require('elasticsearch'),
    fs = require('fs'),
    pubs = JSON.parse(fs.readFileSync(__dirname + '/pubs.json')), // name of my first file to parse
    forms = JSON.parse(fs.readFileSync(__dirname + '/forms.json')); // and the second set
var client = new elasticsearch.Client({  // default is fine for me, change as you see fit
  Host: 'localhost:9200',
  log: 'trace'
});

for (var i = 0; i < pubs.length; i++ ) {
  client.create({
    index: "epubs", // name your index
    type: "pub", // describe the data thats getting created
    id: i, // increment ID every iteration - I already sorted mine but not a requirement
    body: pubs[i] // *** THIS ASSUMES YOUR DATA FILE IS FORMATTED LIKE SO: [{prop: val, prop2: val2}, {prop:...}, {prop:...}] - I converted mine from a CSV so pubs[i] is the current object {prop:..., prop2:...}
  }, function(error, response) {
    if (error) {
      console.error(error);
      return;
    }
    else {
    console.log(response);  //  I don't recommend this but I like having my console flooded with stuff.  It looks cool.  Like I'm compiling a kernel really fast.
    }
  });
}

for (var a = 0; a < forms.length; a++ ) {  // Same stuff here, just slight changes in type and variables
  client.create({
    index: "epubs",
    type: "form",
    id: a,
    body: forms[a]
  }, function(error, response) {
    if (error) {
      console.error(error);
      return;
    }
    else {
    console.log(response);
    }
  });
}

Ich hoffe, ich kann damit mehr als nur mir helfen. Keine Hexerei, aber jemand kann 10 Minuten sparen.

Prost

11
Deryck

jq ist ein leichter und flexibler JSON-Prozessor für die Befehlszeile.

Verwendungszweck:

cat file.json | jq -c '.[] | {"index": {"_index": "bookmarks", "_type": "bookmark", "_id": .id}}, .' | curl -XPOST localhost:9200/_bulk --data-binary @-

Wir nehmen die Datei file.json und leiten den Inhalt zunächst mit dem Flag -c an jq, um eine kompakte Ausgabe zu erstellen. Hier ist das Nugget: Wir nutzen die Tatsache, dass jq nicht nur ein Objekt, sondern mehrere Objekte pro Eingabezeile erstellen kann. Für jede Zeile erstellen wir das Steuerelement, das JSON Elasticsearch benötigt (mit der ID unseres ursprünglichen Objekts) und eine zweite Zeile, die nur unser ursprüngliches JSON-Objekt (.) Ist.

Zu diesem Zeitpunkt haben wir unser JSON-Format so formatiert, wie es die Bulk-API von Elasticsearch erwartet, also leiten wir es einfach, um die POSTs an Elasticsearch zu locken!

Gutschrift geht an Kevin Marsh

9
max

Importieren Sie Nein, aber Sie können die Dokumente mithilfe der ES-API indizieren. 

Sie können die Index-API verwenden, um jede Zeile zu laden (mit einer Art Code zum Lesen der Datei und zum Aufrufen der Curl-Aufrufe) oder mit der Index-Bulk-API, um sie alle zu laden. Angenommen, Ihre Datendatei kann so formatiert werden, dass sie damit funktioniert. 

Lesen Sie hier mehr: ES API

Ein einfaches Shell-Skript würde den Trick ausführen, wenn Sie sich mit Shell auskennen (etwa nicht getestet):

while read line
do
curl -XPOST 'http://localhost:9200/<indexname>/<typeofdoc>/' -d "$line"
done <myfile.json

Peronal würde ich Python wahrscheinlich entweder pyes oder den elastischen Such-Client verwenden. 

pyes auf github
Python-Client für elastische Suche

Stream2es ist auch für das schnelle Laden von Daten in Es sehr nützlich und hat möglicherweise eine Möglichkeit, eine Datei einfach zu streamen. (Ich habe eine Datei nicht getestet, aber sie verwendet, um Wikipedia-Dokument für das Testen zu laden.)

8
mconlin

Stream2es ist der einfachste Weg, IMO.

z.B. Angenommen, eine Datei "some.json", die eine Liste von JSON-Dokumenten enthält, eines pro Zeile:

curl -O download.elasticsearch.org/stream2es/stream2es; chmod +x stream2es
cat some.json | ./stream2es stdin --target "http://localhost:9200/my_index/my_type
5
Jon Burgess

Sie können esbulk verwenden, einen schnellen und einfachen Bulk-Indexer:

$ esbulk -index myindex file.ldj

Hier ist ein Asciicast , der zeigt, wie die Project Gutenberg-Daten in ca. 11 Sekunden in Elasticsearch geladen werden.

Haftungsausschluss: Ich bin der Autor.

4
miku

sie können das Elasticsearch Gatherer Plugin verwenden

Das Gatherer-Plugin für Elasticsearch ist ein Framework zum skalierbaren Abrufen und Indexieren von Daten. Inhaltsadapter werden in Gatherer Zip-Archiven implementiert, die eine besondere Art von Plugins sind, die über Elasticsearch-Knoten verteilt werden können. Sie können Jobanforderungen empfangen und in lokalen Warteschlangen ausführen. Jobstatus werden in einem speziellen Index verwaltet.

Dieses Plugin befindet sich in der Entwicklung.

Meilenstein 1 - Versammlungs-Reißverschlüsse für Knoten bereitstellen

Meilenstein 2 - Spezifikation und Ausführung von Jobs

Meilenstein 3 - Portierung des JDBC-Flusses auf den JDBC-Sammler

Meilenstein 4 - Collecter-Jobverteilung nach Last/Warteschlangenlänge/Knotenname, Cron-Jobs

Meilenstein 5 - mehr Sammler, mehr Inhaltsadapter

referenz https://github.com/jprante/elasticsearch-gatherer

3
user5722411

Eine Möglichkeit besteht darin, ein Bash-Skript zu erstellen, das eine Masseneinfügung ausführt:

curl -XPOST http://127.0.0.1:9200/myindexname/type/_bulk?pretty=true --data-binary @myjsonfile.json

Nachdem Sie die Einfügung ausgeführt haben, führen Sie diesen Befehl aus, um die Anzahl zu ermitteln:

curl http://127.0.0.1:9200/myindexname/type/_count
0
9digitdev