hay alguna manera de importar un archivo json(contiene 100 documentos) en elasticsearch server.?

Como ya mencionó dadoonet, la API masiva es probablemente el camino a seguir. Para transformar su archivo para el protocolo masivo, puede usar jq.

Suponiendo que el archivo contiene solo los documentos en 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"}

Y si el archivo contiene los documentos en una lista de nivel superior que tienen que ser desenvueltos primero:

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

La bandera -c de Jq se asegura de que cada documento esté en una línea por sí mismo.

Si desea canalizar directamente a curl, querrá usar --data-binary @-, y no simplemente -d, de lo contrario curl eliminará las nuevas líneas de nuevo.

Estoy seguro de que alguien quiere esto, así que lo haré fácil de encontrar.

FYI - Esto está usando Nodo.js (esencialmente como un script por lotes) en el mismo servidor que la nueva instancia ES. Lo ejecuté en 2 archivos con 4000 elementos cada uno y solo tomó unos 12 segundos en mi servidor virtual compartido. 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);
    }
  });
}

Espero poder ayudar más que a mí mismo con esto. No es ciencia espacial, pero puede ahorrarle a alguien 10 minutos.

Salud

Jq es un procesador JSON de línea de comandos ligero y flexible.

Uso:

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

Estamos tomando el archivo file.json y canalizar su contenido a jq primero con la bandera-c para construir una salida compacta. Aquí está la pepita: Estamos aprovechando el hecho de que jq puede construir no solo uno sino varios objetos por línea de entrada. Para cada línea, estamos creando el control que necesita JSON Elasticsearch (con el ID de nuestro objeto original) y creando una segunda línea que es solo nuestro objeto JSON original (.).

En este punto, tenemos nuestro JSON formateado de la manera que la API masiva de Elasticsearch lo espera, ¡así que simplemente lo canalizamos a curl que lo publica en Elasticsearch!

El crédito va a Kevin Marsh

No importa, pero puede indexar los documentos utilizando la API ES.

Puede usar la api index para cargar cada línea (usando algún tipo de código para leer el archivo y hacer las llamadas curl) o la api index bulk para cargarlas todas. Suponiendo que su archivo de datos se puede formatear para trabajar con él.

Lea más aquí: ES API

Un simple script de shell haría el truco si te sientes cómodo con shell algo como esto tal vez (no probado):

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

Peronalmente, me gustaría probablemente use Python ya sea pyes o el cliente elastic-search.

Pyes en github
elastic search python client

Stream2es también es muy útil para cargar datos rápidamente en es y puede tener una forma de simplemente transmitir un archivo. (No he probado un archivo pero lo he usado para cargar wikipedia doc para es perf testing)

Stream2es es la forma más fácil IMO.

Por ejemplo, asumiendo un archivo " algunos.json " contiene una lista de documentos JSON, uno por línea:

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

Puede usar esbulk , un indexador masivo rápido y simple:

$ esbulk -index myindex file.ldj

Aquí hay unasciicast que lo muestra cargando los datos del Proyecto Gutenberg en Elasticsearch en aproximadamente 11 segundos.

Descargo de responsabilidad: Soy el autor.

Puedes usar el plugin Elasticsearch Gatherer

El complemento gatherer para Elasticsearch es un marco para la obtención e indexación de datos escalables. Los adaptadores de contenido se implementan en archivos zip recolectores que son un tipo especial de complementos distribuibles a través de nodos Elasticsearch. Pueden recibir solicitudes de trabajo y ejecutarlas en colas locales. Los estados de empleo se mantienen en un índice especial.

Este plugin está en desarrollo.

Milestone 1-deploy gatherer zips to nodos

Hito 2-especificación y ejecución del trabajo

Hito 3-portar el río JDBC a JDBC gatherer

Milestone 4-distribución de trabajos de recolector por carga / longitud de cola / nombre de nodo, trabajos cron

Hito 5-más recolectores, más adaptadores de contenido

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

Una forma es crear un script bash que haga una inserción masiva:

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

Después de ejecutar el insert, ejecute este comando para obtener el recuento:

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