curl insert - enumera todos los índices en el servidor ElasticSearch?




data post (14)

Una de las mejores maneras de mostrar índices + para mostrar su estado junto con la lista es simplemente ejecutando la consulta a continuación.

Nota: preferiblemente use Sense para obtener la salida correcta.

curl -XGET 'http://localhost:9200/_cat/shards'

La salida de muestra es la siguiente. La principal ventaja es que básicamente muestra el nombre del índice y los fragmentos guardados, el tamaño del índice y los fragmentos, etc.

index1     0 p STARTED     173650  457.1mb 192.168.0.1 ip-192.168.0.1 
index1     0 r UNASSIGNED                                                 
index2     1 p STARTED     173435  456.6mb 192.168.0.1 ip-192.168.0.1 
index2     1 r UNASSIGNED                                                 
...
...
...

Me gustaría enumerar todos los índices presentes en un servidor ElasticSearch. Intenté esto:

curl -XGET localhost:9200/

pero me da esto:

{
  "ok" : true,
  "status" : 200,
  "name" : "El Aguila",
  "version" : {
    "number" : "0.19.3",
    "snapshot_build" : false
  },
  "tagline" : "You Know, for Search"
}

Quiero una lista de todos los índices ...


También recomendaría hacer / _cat / índices, lo que da una buena lista legible por humanos de sus índices.


Tratar

curl 'localhost:9200/_cat/indices?v'

Le daré la siguiente salida autoexplicativa de forma tabular

health index    pri rep docs.count docs.deleted store.size pri.store.size
yellow customer   5   1          0            0       495b           495b

Le daré la consulta que puede ejecutar en kibana.

GET /_cat/indices?v

y la versión CURL será

CURL -XGET http://localhost:9200/_cat/indices?v

Para obtener una lista concisa de todos los índices en su clúster, llame

curl http://localhost:9200/_aliases

esto le dará una lista de índices y sus alias.

Si lo quiere bastante impreso, agregue pretty=1 :

curl http://localhost:9200/_aliases?pretty=1

El resultado se verá más o menos así, si sus índices se llaman old_deuteronomy y mungojerrie :

{
  "old_deuteronomy" : {
    "aliases" : { }
  },
  "mungojerrie" : {
    "aliases" : {
      "rumpleteazer" : { },
      "that_horrible_cat" : { }
    }
  }
}

El comando _stats proporciona formas de personalizar los resultados especificando las métricas deseadas. Para obtener los índices, la consulta es la siguiente:

GET /_stats/indices

El formato general de la consulta _stats es:

/_stats
/_stats/{metric}
/_stats/{metric}/{indexMetric}
/{index}/_stats
/{index}/_stats/{metric}

Donde las métricas son:

indices, docs, store, indexing, search, get, merge, 
refresh, flush, warmer, filter_cache, id_cache, 
percolate, segments, fielddata, completion

Como ejercicio para mí mismo, he escrito un pequeño complemento elasticsearch que proporciona la funcionalidad para listar índices de búsqueda elástica sin ninguna otra información. Puede encontrarlo en la siguiente url:

http://blog.iterativ.ch/2014/04/11/listindices-writing-your-first-elasticsearch-java-plugin/

https://github.com/iterativ/elasticsearch-listindices


_stats/indices da el resultado con indices .

$ curl -XGET "localhost:9200/_stats/indices?pretty=true"
{
  "_shards" : {
    "total" : 10,
    "successful" : 5,
    "failed" : 0
  },
  "_all" : {
    "primaries" : { },
    "total" : { }
  },
  "indices" : {
    "visitors" : {
      "primaries" : { },
      "total" : { }
    }
  }
}

Puede consultar localhost:9200/_status y eso le dará una lista de índices e información sobre cada uno. La respuesta será algo como esto:

{
  "ok" : true,
  "_shards" : { ... },
  "indices" : {
    "my_index" : { ... },
    "another_index" : { ... }
  }
}

Aquí hay otra forma de ver los índices en el DB:

curl -sG somehost-dev.example.com:9200/_status --user "credentials:password" | sed 's/,/\n/g' | grep index | grep -v "size_in" | uniq


{ "index":"tmpdb"}

{ "index":"devapp"}

Utilizo el punto final _stats/indexes para obtener una json de datos y luego filtrar con jq .

curl 'localhost:9200/_stats/indexes' | jq '.indices | keys | .[]'

"admin"
"blazeds"
"cgi-bin"
"contacts_v1"
"flex2gateway"
"formmail"
"formmail.pl"
"gw"
...

Si no desea cotizaciones, agregue un indicador -r a jq.

Sí, el punto final son los indexes y la clave de datos son los indices , por lo que tampoco pueden decidirse :)

Necesitaba esto para limpiar estos índices de basura creados por un análisis de seguridad interno (nessus).

PD. Recomiendo familiarizarse con jq si vas a interactuar con ES desde la línea de comandos.


Si está trabajando en scala, una forma de hacerlo y usar Future es crear un RequestExecutor, luego use IndicesStatsRequestBuilder y el cliente administrativo para enviar su solicitud.

import org.elasticsearch.action.{ ActionRequestBuilder, ActionListener, ActionResponse }
import scala.concurrent.{ Future, Promise, blocking }

/** Convenice wrapper for creating RequestExecutors */
object RequestExecutor {
    def apply[T <: ActionResponse](): RequestExecutor[T] = {
        new RequestExecutor[T]
    }
}

/** Wrapper to convert an ActionResponse into a scala Future
 *
 *  @see http://chris-zen.github.io/software/2015/05/10/elasticsearch-with-scala-and-akka.html
 */
class RequestExecutor[T <: ActionResponse] extends ActionListener[T] {
    private val promise = Promise[T]()

    def onResponse(response: T) {
        promise.success(response)
    }

    def onFailure(e: Throwable) {
        promise.failure(e)
    }

    def execute[RB <: ActionRequestBuilder[_, T, _, _]](request: RB): Future[T] = {
        blocking {
            request.execute(this)
            promise.future
        }
    }
}

El ejecutor se retira de esta publicación de blog, que definitivamente es una buena lectura si intentas consultar ES programáticamente y no a través de curl. Una vez que tenga esto, puede crear una lista de todos los índices con bastante facilidad:

def totalCountsByIndexName(): Future[List[(String, Long)]] = {
    import scala.collection.JavaConverters._
    val statsRequestBuider = new IndicesStatsRequestBuilder(client.admin().indices())
    val futureStatResponse = RequestExecutor[IndicesStatsResponse].execute(statsRequestBuider)
    futureStatResponse.map { indicesStatsResponse =>
        indicesStatsResponse.getIndices().asScala.map {
            case (k, indexStats) => {
                val indexName = indexStats.getIndex()
                val totalCount = indexStats.getTotal().getDocs().getCount()
                    (indexName, totalCount)
                }
        }.toList
    }
}

client es una instancia de Client que puede ser un nodo o un cliente de transporte, según se ajuste a sus necesidades. También necesitará tener un ExecutionContext implícito en el alcance de esta solicitud. Si intenta compilar este código sin él, recibirá una advertencia del compilador scala sobre cómo obtenerlo si no tiene uno importado.

Necesitaba el recuento de documentos, pero si realmente solo necesita los nombres de los índices, puede extraerlos de las teclas del mapa en lugar de los IndexStats :

indicesStatsResponse.getIndices().keySet()

Esta pregunta aparece cuando estás buscando cómo hacer esto, incluso si estás intentando hacer esto programáticamente, así que espero que esto ayude a cualquiera que busque hacer esto en scala / java. De lo contrario, los usuarios de curl pueden simplemente hacer lo que dice la respuesta superior y usar

curl http://localhost:9200/_aliases

La gente de aquí ha respondido cómo hacerlo en curl y sentido, algunas personas podrían necesitar hacer esto en Java.

Aquí va

client.admin().indices().stats(new IndicesStatsRequest()).actionGet().getIndices().keySet()

Yo uso esto para obtener todos los índices:

$ curl --silent 'http://127.0.0.1:9200/_cat/indices' | cut -d\  -f3

Con esta lista puedes trabajar en ...

Ejemplo

$ curl -s 'http://localhost:9200/_cat/indices' | head -5
green open qa-abcdefq_1458925279526           1 6       0     0   1008b    144b
green open qa-test_learnq_1460483735129    1 6       0     0   1008b    144b
green open qa-testimportd_1458925361399       1 6       0     0   1008b    144b
green open qa-test123p_reports                1 6 3868280 25605   5.9gb 870.5mb
green open qa-dan050216p_1462220967543        1 6       0     0   1008b    144b

Para obtener la tercera columna arriba (nombres de los índices):

$ curl -s 'http://localhost:9200/_cat/indices' | head -5 | cut -d\  -f3
qa-abcdefq_1458925279526
qa-test_learnq_1460483735129
qa-testimportd_1458925361399
qa-test123p_reports
qa-dan050216p_1462220967543

NOTA: También puede usar awk '{print $3}' lugar de cut -d\ -f3 .

Encabezados de columna

También puede sufijar la consulta con un ?v para agregar un encabezado de columna. Si lo hace, se romperá el método de cut... así que recomiendo usar la selección awk.. en este momento.

$ curl -s 'http://localhost:9200/_cat/indices?v' | head -5
health status index                              pri rep docs.count docs.deleted store.size pri.store.size
green  open   qa-abcdefq_1458925279526             1   6          0            0      1008b           144b
green  open   qa-test_learnq_1460483735129      1   6          0            0      1008b           144b
green  open   qa-testimportd_1458925361399         1   6          0            0      1008b           144b
green  open   qa-test123p_reports                  1   6    3868280        25605      5.9gb        870.5mb

Creo que esto se debe a que se usa el tokenizer ...

http://www.elasticsearch.org/guide/reference/index-modules/analysis/lowercase-tokenizer.html

El tokenizador en minúsculas se divide en los límites de las palabras, por lo que 2012.01.13 se indexará como "2012", "01" y "13". La búsqueda de la cadena "2012.01.13" obviamente no coincidirá.

Una opción sería agregar la tokenización en la búsqueda también. Por lo tanto, la búsqueda de "2012.01.13" se convertirá en tokens a los mismos símbolos que en el índice y coincidirá. Esto también es útil, ya que no necesita siempre minúsculas de sus búsquedas en el código.

La segunda opción sería usar un tokenizer n-gram en lugar del filtro. Esto significará que ignorará los límites de las palabras (y obtendrá los "_" también), sin embargo, puede tener problemas con las discrepancias entre mayúsculas y minúsculas, que es, presumiblemente, la razón por la que agregó el tokenizador en minúscula en primer lugar.





curl elasticsearch