extraer - leer json desde url javascript

¿hay alguna forma de importar un archivo json(contiene 100 documentos) en el servidor elásticosearch?

Question

¿Hay alguna manera de importar un archivo JSON (contiene 100 documentos) en el servidor elasticsearch? Quiero importar un gran archivo json en es-server ...

Answer 1

Como ya mencionamos anteriormente, 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, primero tienen que ser desenvueltos:

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

El indicador -q de jq se asegura de que cada documento esté en línea por sí mismo.

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

Answer 2

Deberías usar Bulk API . Tenga en cuenta que deberá agregar una línea de encabezado antes de cada documento 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}}]}

Answer 3

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

FYI - Esto está usando Node.js (esencialmente como una secuencia de comandos por lotes) en el mismo servidor que la nueva instancia de ES. Lo ejecuté en 2 archivos con 4000 elementos cada uno y solo tardó 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 solo a mí con esto. No es ciencia espacial, pero puede salvar a alguien 10 minutos.

Aclamaciones

Answer 4

Importe no, pero puede indexar los documentos mediante la API de ES.

Puede usar la API de índice para cargar cada línea (usando algún tipo de código para leer el archivo y hacer las llamadas curl) o la API a granel del índice para cargarlas todas. Suponiendo que su archivo de datos puede formatearse 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 el shell algo como esto quizás (no probado):

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

Peronalmente, probablemente usaría Python ya sea pyes o el cliente de búsqueda elástica.

pyes en github
cliente elástico de búsqueda python

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 el documento de wikipedia para pruebas de perf)

Answer 5

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

$ esbulk -index myindex file.ldj

Aquí hay un asciicast muestra que carga los datos del Proyecto Gutenberg en Elasticsearch en aproximadamente 11s.

Descargo de responsabilidad: soy el autor.

Answer 6

Una forma es crear un script bash que realice 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 la inserción, ejecute este comando para obtener el conteo:

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

Answer 7

jq es un procesador JSON liviano y flexible de línea de comandos.

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 conectando su contenido a jq primero con el indicador -c para construir un resultado compacto. Aquí está el nugget: estamos aprovechando el hecho de que jq puede construir no solo uno sino múltiples objetos por línea de entrada. Para cada línea, estamos creando el control de las necesidades de 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 del modo que la API masiva de Elasticsearch lo espera, ¡así que simplemente lo canalizamos para curvar qué POSTS lo envía a Elasticsearch!

El crédito va a Kevin Marsh

Answer 8

puedes usar el complemento Gatherer de Elasticsearch

El plugin de gatherer para Elasticsearch es un marco para la búsqueda e indexación de datos escalables. Los adaptadores de contenido se implementan en los archivos zip de gatherer, que son un tipo especial de complementos distribuibles sobre los nodos Elasticsearch. Pueden recibir solicitudes de trabajo y ejecutarlas en colas locales. Los estados de trabajo se mantienen en un índice especial.

Este complemento está en desarrollo.

Hito 1: desplegar las cremalleras del recolector en los nodos

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

Hito 3: transporte del río JDBC al recolector de JDBC

Hito 4: distribución del trabajo del recopilador por carga / longitud de la cola / nombre del nodo, trabajos de cron

Milestone 5: más recolectores, más adaptadores de contenido

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

Answer 9

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

por ejemplo, asumiendo un archivo "some.json" que 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