web-dev-qa-db-fra.com

est-il possible d'importer un fichier JSON (contenant 100 documents) dans le serveur elasticsearch?

Est-il possible d'importer un fichier JSON (contenant 100 documents) dans le serveur elasticsearch? Je veux importer un gros fichier json dans es-server ..

jsonelasticsearchbigdataartificial-intelligenceelasticsearch-plugin
29
shailendra pathak

Vous devez utiliser Bulk API . Notez que vous devrez ajouter une ligne d’en-tête avant chaque document json.

$ 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

Comme déjà mentionné dans dadoonet, l’API en vrac est probablement la voie à suivre. Pour transformer votre fichier pour le protocole en bloc, vous pouvez utiliser jq .

En supposant que le fichier ne contienne que les documents eux-mêmes:

$ 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"}

Et si le fichier contient les documents dans une liste de premier niveau, ils doivent d'abord être décompressés:

$ 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"}

l’indicateur -c de jq permet de s’assurer que chaque document est sur une ligne distincte.

Si vous voulez diriger directement vers curl, vous voudrez utiliser --data-binary @- et pas seulement -d, sinon curl supprimera à nouveau les nouvelles lignes.

39
Peter

Je suis sûr que quelqu'un le veut, alors je vais le trouver facilement.

FYI - Ceci utilise Node.js (essentiellement comme un script batch) sur le même serveur que la toute nouvelle instance ES. A couru sur 2 fichiers avec 4000 éléments chacun et cela n'a pris que 12 secondes sur mon serveur virtuel partagé. 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);
    }
  });
}

J'espère que je peux aider plus que moi-même avec ça. Pas sorcier mais peut sauver quelqu'un 10 minutes.

À votre santé

11
Deryck

jq est un processeur JSON de ligne de commande léger et flexible.

Usage:

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

Nous prenons le fichier fichier.json et en pipissonsons le contenu dans jq d’abord avec l’option -c pour créer une sortie compacte. Voici le nugget: Nous profitons du fait que jq peut construire non pas un mais plusieurs objets par ligne d’entrée. Pour chaque ligne, nous créons le contrôle dont JSON Elasticsearch a besoin (avec l'ID de notre objet d'origine) et nous créons une deuxième ligne qui est simplement notre objet JSON d'origine (.).

À ce stade, notre fichier JSON est formaté comme l’API en bloc d’Elasticsearch l’attend. Par conséquent, nous le poussons simplement à boucler, ce qui le poste à Elasticsearch!

Le crédit va à Kevin Marsh

9
max

Importez non, mais vous pouvez indexer les documents à l'aide de l'API ES. 

Vous pouvez utiliser l’API d’index pour charger chaque ligne (en utilisant une sorte de code pour lire le fichier et effectuer les appels curl) ou l’API en bloc d’index pour tout charger. En supposant que votre fichier de données puisse être formaté pour fonctionner avec. 

Lisez plus ici: ES API

Un simple script Shell ferait l'affaire si vous maîtrisez quelque chose comme ceci avec Shell (peut-être non testé):

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

Peronally, j'utiliserais probablement Python, soit pyes, soit le client de recherche élastique. 

pyes on github
client de recherche python élastique

Stream2es est également très utile pour le chargement rapide de données dans es et peut avoir un moyen de simplement diffuser un fichier.

8
mconlin

Stream2es est le moyen le plus simple IMO.

par exemple. en supposant un fichier "some.json" contenant une liste de documents JSON, un par ligne:

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

Vous pouvez utiliser esbulk , un indexeur de masse rapide et simple:

$ esbulk -index myindex file.ldj

Voici un asciicast le montrant chargeant les données du projet Gutenberg dans Elasticsearch en environ 11 secondes.

Disclaimer: je suis l'auteur.

4
miku

vous pouvez utiliser le plugin Elasticsearch Gatherer

Le plug-in de collecte pour Elasticsearch est un cadre pour la récupération et l'indexation de données évolutives. Les adaptateurs de contenu sont implémentés dans les archives Zip du rassembleur, qui sont un type particulier de plugins distribuables sur les nœuds Elasticsearch. Ils peuvent recevoir des demandes de travail et les exécuter dans des files d'attente locales. Les états de travail sont conservés dans un index spécial.

Ce plugin est en développement.

Jalon 1 - déployer des zips de collecte vers des nœuds

Jalon 2 - spécification et exécution du travail

Jalon 3 - Portage de la rivière JDBC au collecteur JDBC

Milestone 4 - répartition des tâches du rassembleur par charge/longueur de la file d'attente/nom du noeud, tâches cron

Jalon 5 - plus de collecteurs, plus d'adaptateurs de contenu

référence https://github.com/jprante/elasticsearch-gatherer

3
user5722411

Une solution consiste à créer un script bash qui effectue une insertion en bloc:

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

Après avoir exécuté l'insertion, exécutez cette commande pour obtenir le nombre:

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