est-il possible d'importer un fichier json(contient 100 documents) dans elasticsearch serveur.?

comme dadoonet l'a déjà mentionné, l'API bulk est probablement la solution. Pour transformer votre fichier pour l'essentiel protocole, vous pouvez utiliser jq.

en supposant que le fichier ne contient 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 être déballés en premier:

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

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

Si vous voulez tuyau directement à curl, vous aurez envie d'utiliser --data-binary @-, et pas seulement -d, sinon curl va encore enlever les lignes.

je suis sûr que quelqu'un veut cela donc je vais le rendre facile à trouver.

FYI-ceci utilise noeud.js (essentiellement sous forme de script batch) sur le même serveur que l'instance es toute neuve. Lancé sur 2 fichiers avec 4000 éléments chacun et il n'a pris environ 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. Ce n'est pas de la science, mais ça pourrait sauver quelqu'un de 10 minutes.

Cheers

jq est un processeur JSON léger et flexible.

Utilisation:

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

nous prenons le fichier.json et la tuyauterie de son contenu à jq d'abord avec le drapeau-c pour construire la sortie compacte. Voici le nugget: nous profitons du fait que jq peut construire non seulement un mais plusieurs objets par ligne d'entrée. Pour chaque ligne, nous créons le contrôle JSON Elasticsearch needs (avec L'ID de notre objet original) et créer une deuxième ligne qui est juste notre objet JSON original (.).

à ce stade, nous avons notre JSON formaté la façon dont L'API en vrac D'Elasticsearch s'y attend, donc nous l'avons simplement pipe à curl qui le poste à Elasticsearch!

le crédit va à Kevin Marsh

importer non, mais vous pouvez indexer les documents en utilisant L'API ES.

Vous pouvez utiliser l'api index pour charger chaque ligne (en utilisant une sorte de code pour lire le fichier et faire les appels de boucle) ou l'api index pour les charger toutes. En supposant que votre fichier de données peut être formaté pour fonctionner avec elle.

Lire la suite ici: API ES

un simple script shell ferait l'affaire si vous êtes à l'aise avec shell quelque chose comme ceci peut-être (pas testé):

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

Peronally, je serais probablement utiliser Python soit pyes ou l'élastique à la recherche du client.

pyes sur github

elastic search client python

Stream2es est également très utile pour charger rapidement des données dans es et peut avoir un moyen de simplement streamer un fichier. (Je n'ai pas testé un fichier mais je l'ai utilisé pour charger wikipedia doc pour des tests de performance)

Stream2es est la voie la plus facile IMO.

par exemple, en supposant un fichier "certains.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

Vous pouvez utiliser esbulk, rapide et simple, en vrac indexeur:

$ esbulk -index myindex file.ldj

Voici un asciicast montrant le chargement du Projet Gutenberg données dans Elasticsearch dans environ 11s.

Disclaimer: je suis l'auteur.

vous pouvez utiliser Elasticsearch Gatherer Plugin

le plugin gatherer pour Elasticsearch est un framework pour la collecte et l'indexation de données évolutives. Les adaptateurs de contenu sont implémentés dans les archives zip De gatherer qui sont un type particulier de plugins distribuables sur les noeuds Elasticsearch. Ils peuvent recevoir des demandes d'emploi et les exécuter dans des files d'attente locales. Les États d'emploi sont maintenus dans un indice spécial.

ce plugin est en développement.

Jalon 1-déploiement ramasse zips aux noeuds

Jalon 2-spécification et exécution des tâches

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

Jalon 4-Répartition des tâches de cueillette par charge / longueur de file/nom de noeud, cron jobs

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

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

Une solution est de créer un script bash qui fait un bulk insert:

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

après avoir lancé l'insertion, lancez cette commande pour obtenir le nombre:

curl http://127.0.0.1:9200/myindexname/type/_count