extraer - leer json desde url javascript
¿hay alguna forma de importar un archivo json(contiene 100 documentos) en el servidor elásticosearch? (9)
¿Hay alguna manera de importar un archivo JSON (contiene 100 documentos) en el servidor elasticsearch? Quiero importar un gran archivo json en es-server ...
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.
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}}]}
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
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.
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)
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
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
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
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