¿Enumerar todos los índices en el servidor ElasticSearch?

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

curl -XGET localhost:9200/

pero solo 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 ...

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

curl http://localhost:9200/_aliases

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

Si quieres que esté bien impreso, agrega pretty=true:

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

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

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

Tratar

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

Te dará el siguiente resultado autoexplicativo de manera tabular

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

Puede consultar localhost:9200/_statusy eso le dará una lista de índices e información sobre cada uno. La respuesta se verá así:

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

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

GET /_stats/indices

El formato general de la _statsconsulta es:

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

Donde están las métricas:

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 de Elasticsearch que proporciona la funcionalidad para enumerar los índices de Elasticsearch 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

Lo uso 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 anterior (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 en awk '{print $3}'lugar de cut -d\ -f3.

Encabezados de columna

También puede ?vagregarle un sufijo a la consulta para agregar un encabezado de columna. Hacerlo interrumpirá el cut...método, por lo que recomendaría usar la awk..selección 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

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

La forma más sencilla de obtener una lista de solo índices es usar la respuesta anterior, con el parámetro 'h = index':

curl -XGET "localhost:9200/_cat/indices?h=index"

curl -XGET 'http://localhost:9200/_cluster/health?level=indices'

Esto saldrá como a continuación

{
  "cluster_name": "XXXXXX:name",
  "status": "green",
  "timed_out": false,
  "number_of_nodes": 3,
  "number_of_data_nodes": 3,
  "active_primary_shards": 199,
  "active_shards": 398,
  "relocating_shards": 0,
  "initializing_shards": 0,
  "unassigned_shards": 0,
  "delayed_unassigned_shards": 0,
  "number_of_pending_tasks": 0,
  "number_of_in_flight_fetch": 0,
  "task_max_waiting_in_queue_millis": 0,
  "active_shards_percent_as_number": 100,
  "indices": {
    "logstash-2017.06.19": {
      "status": "green",
      "number_of_shards": 3,
      "number_of_replicas": 1,
      "active_primary_shards": 3,
      "active_shards": 6,
      "relocating_shards": 0,
      "initializing_shards": 0,
      "unassigned_shards": 0
    },
    "logstash-2017.06.18": {
      "status": "green",
      "number_of_shards": 3,
      "number_of_replicas": 1,
      "active_primary_shards": 3,
      "active_shards": 6,
      "relocating_shards": 0,
      "initializing_shards": 0,
      "unassigned_shards": 0
    }}

Te daré la consulta que puedes ejecutar en kibana.

GET /_cat/indices?v

y la versión CURL será

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

You may use this command line.

curl -X GET "localhost: 9200 / _cat / indices? v"

Para más información (sitio oficial de Elasticsearch)

Para enumerar los índices que puede hacer: curl 'localhost: 9200 / _cat / indices? V' Elasticsearch Documentation

Acceso a la búsqueda elástica segura a través de Curl (Actualización 2020)

Si Elastic Searchestá protegido, puede usar este comando para enumerar índices

curl http://username:password@localhost:9200/_aliases?pretty=true

_stats/indicesda 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" : { }
    }
  }
}

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

Aquí va

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

Pruebe esta API de gato: le dará la lista de todos los índices con detalles de salud y otros.

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

Para Elasticsearch 6.X, encontré lo siguiente más útil. Cada uno proporciona datos diferentes en la respuesta.

# more verbose
curl -sS 'localhost:9200/_stats' | jq -C ".indices" | less

# less verbose, summary
curl -sS 'localhost:9200/_cluster/health?level=indices' | jq -C ".indices" | less

También puede obtener un índice específico usando

curl -X GET "localhost:9200/<INDEX_NAME>"
e.g.   curl -X GET "localhost:9200/twitter"
You may get output like:
{
  "twitter": {
     "aliases": { 

     },
     "mappings": { 

     },
     "settings": {
     "index": {
        "creation_date": "1540797250479",
        "number_of_shards": "3",
        "number_of_replicas": "2",
        "uuid": "CHYecky8Q-ijsoJbpXP95w",
        "version": {
            "created": "6040299"
        },
       "provided_name": "twitter"
      }
    }
  }
}

Para más información

https://www.elastic.co/guide/en/elasticsearch/reference/current/indices-get-index.html

Aquí hay otra forma de ver los índices en la base de datos:

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

Una de la mejor manera de enumerar índices + para mostrar su estado junto con list: es simplemente ejecutando la consulta a continuación.

Nota: preferiblemente use Sense para obtener la salida adecuada.

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 en los que guardó, el tamaño del índice y los fragmentos de IP, 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                                                 
...
...
...

Utilizo el _stats/indexespunto final para obtener un bloc de datos json y luego filtro 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 una -rbandera a jq.

Sí, el punto final es indexesy la clave de datos es indices, por lo que tampoco pudieron decidirse :)

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

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

<dependency>
    <groupId>org.elasticsearch</groupId>
    <artifactId>elasticsearch</artifactId>
    <version>2.4.0</version>
</dependency>

API de Java

Settings settings = Settings.settingsBuilder().put("cluster.name", Consts.ES_CLUSTER_NAME).build();
TransportClient client = TransportClient.builder().settings(settings).build().addTransportAddress(new InetSocketTransportAddress(InetAddress.getByName("52.43.207.11"), 9300));
IndicesAdminClient indicesAdminClient = client.admin().indices();
GetIndexResponse getIndexResponse = indicesAdminClient.getIndex(new GetIndexRequest()).get();
for (String index : getIndexResponse.getIndices()) {
    logger.info("[index:" + index + "]");
}

Si está trabajando en scala, una forma de hacer esto y usarlo Futurees 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 levanta de esta publicación de blog, que definitivamente es una buena lectura si está intentando consultar ES mediante programación y no mediante curl. Una vez que tenga esto, puede crear una lista de todos los índices con bastante facilidad de esta manera:

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

clientes una instancia de Cliente que puede ser un nodo o un cliente de transporte, según sus necesidades. También necesitarás tener un implícitoExecutionContext alcance para esta solicitud. Si intenta compilar este código sin él, recibirá una advertencia del compilador scala sobre cómo obtenerlo si aún 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 IndexStats:

indicesStatsResponse.getIndices().keySet()

Esta pregunta aparece cuando está buscando cómo hacer esto, incluso si está tratando de hacer esto mediante programación, por lo que espero que esto ayude a cualquiera que busque hacer esto en scala / java. De lo contrario, los usuarios de curl pueden hacer lo que dice la respuesta principal y usar

curl http://localhost:9200/_aliases

puedes probar este comando

curl -X GET http: // localhost: 9200 / _cat / indices? v

Tenía Kibana y ES instalados en una máquina. Pero no sabía los detalles (en qué ruta o puerto) era el nodo ES en esa máquina.

Entonces, ¿cómo puedes hacerlo desde Kibana (versión 5.6)?

• Ir a herramientas de desarrollo
• Consulte la sección Consola y ejecute la siguiente consulta:

GET _cat/indices

Estaba interesado en encontrar el tamaño de un índice ES particular

Si tiene curl instalado en su sistema, intente con este comando simple: curl -XGET xx.xx.xx.xx: 9200 / _cat / indices? V

El comando mencionado anteriormente le da el resultado en este formato: resultado para buscar todos los índices