Répertorier tous les index sur le serveur ElasticSearch?

Je voudrais lister tous les index présents sur un serveur ElasticSearch. J'ai essayé ceci:

curl -XGET localhost:9200/

mais ça me donne juste ceci:

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

Je veux une liste de tous les index ..

Pour obtenir une liste concise de tous les index de votre cluster, appelez

curl http://localhost:9200/_aliases

cela vous donnera une liste des index et de leurs alias.

Si vous le souhaitez joli imprimé, ajoutez pretty=true:

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

Le résultat ressemblera à ceci, si vos indices sont appelés old_deuteronomyet mungojerrie:

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

Essayer

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

Il vous donnera la sortie auto-explicative suivante sous forme de tableau

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

Vous pouvez interroger localhost:9200/_statuset cela vous donnera une liste d'indices et d'informations sur chacun. La réponse ressemblera à ceci:

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

La commande _stats fournit des moyens de personnaliser les résultats en spécifiant les mesures souhaitées. Pour obtenir les indices, la requête est la suivante:

GET /_stats/indices

Le format général de la _statsrequête est:

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

Où les mesures sont:

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

Pour moi-même, j'ai écrit un petit plugin elasticsearch fournissant la fonctionnalité de lister les indices elasticsearch sans aucune autre information. Vous pouvez le trouver à l'url suivante:

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

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

J'utilise ceci pour obtenir tous les indices:

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

Avec cette liste, vous pouvez travailler sur ...

Exemple

$ 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

Pour obtenir la 3ème colonne ci-dessus (noms des indices):

$ 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

REMARQUE: vous pouvez également utiliser awk '{print $3}'au lieu de cut -d\ -f3.

En-têtes de colonne

Vous pouvez également suffixer la requête avec un ?vpour ajouter un en-tête de colonne. Cela interromprait la cut...méthode, je vous recommande donc d'utiliser la awk..sélection à ce stade.

$ 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

Je recommanderais également de faire / _cat / indices qui donne une belle liste lisible par l'homme de vos index.

La façon la plus simple d'obtenir une liste d'index uniquement est d'utiliser la réponse ci-dessus, avec le paramètre 'h = index':

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

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

Cela sortira comme ci-dessous

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

Je vais vous donner la requête que vous pouvez exécuter sur kibana.

GET /_cat/indices?v

et la version CURL sera

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

You may use this command line.

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

Pour en savoir plus (site officiel d'Elasticsearch)

Pour répertorier les index, vous pouvez effectuer: curl 'localhost: 9200 / _cat / indices? V' Elasticsearch Documentation

Accès à la recherche élastique sécurisée via Curl (mise à jour 2020)

Si le Elastic Searchest sécurisé, vous pouvez utiliser cette commande pour répertorier les index

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

_stats/indicesdonne le résultat avec indices.

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

Les gens ici ont répondu comment le faire en boucle et dans le sens, certaines personnes pourraient avoir besoin de le faire en java.

Ça y est

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

Essayez cette API de chat: elle vous donnera la liste de tous les indices avec la santé et d'autres détails.

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

Pour Elasticsearch 6.X, j'ai trouvé ce qui suit le plus utile. Chacun fournit des données différentes dans la réponse.

# 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

Vous pouvez également obtenir un index spécifique en utilisant

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

Pour plus d'informations

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

voici une autre façon de voir les indices dans la base de données:

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

L'un des meilleurs moyens de répertorier les indices + pour afficher son état avec la liste: consiste simplement à exécuter la requête ci-dessous.

Remarque: utilisez de préférence Sense pour obtenir la sortie appropriée.

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

L'échantillon de sortie est comme ci-dessous. Le principal avantage est qu'il affiche essentiellement le nom de l'index et les fragments dans lesquels il a été enregistré, la taille de l'index et l'ip des fragments, 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                                                 
...
...
...

J'utilise le _stats/indexespoint de terminaison pour obtenir un blob json de données, puis filtrer avec jq .

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

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

Si vous ne voulez pas de guillemets, ajoutez un -rindicateur à jq.

Oui, le point de terminaison est indexeset la clé de données estindices , donc ils ne pouvaient pas non plus se décider :)

J'en avais besoin pour nettoyer ces indices d'ordures créés par une analyse de sécurité interne (nessus).

PS. Je recommande fortement de vous familiariser avec jq si vous allez interagir avec ES à partir de la ligne de commande.

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

API 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 vous travaillez dans scala, une façon de le faire et d'utiliser Futureest de créer un RequestExecutor, puis utilisez IndicesStatsRequestBuilder et le client administratif pour soumettre votre demande.

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

L'exécuteur est retiré de ce billet de blog, ce qui est certainement une bonne lecture si vous essayez d'interroger ES par programme et non par curl. Une fois que vous l'avez, vous pouvez créer une liste de tous les index assez facilement comme ceci:

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

clientest une instance de Client qui peut être un nœud ou un client de transport, selon ce qui convient à vos besoins. Vous devrez également avoir une ExecutionContextportée implicite pour cette demande. Si vous essayez de compiler ce code sans lui, vous obtiendrez un avertissement du compilateur scala sur la façon de l'obtenir si vous n'en avez pas déjà importé.

J'avais besoin du nombre de documents, mais si vous n'avez vraiment besoin que des noms des index, vous pouvez les extraire des clés de la carte au lieu de IndexStats:

indicesStatsResponse.getIndices().keySet()

Cette question apparaît lorsque vous cherchez comment faire cela même si vous essayez de le faire par programme, donc j'espère que cela aidera toute personne qui cherche à le faire dans scala / java. Sinon, les utilisateurs de curl peuvent simplement faire ce que dit la première réponse et utiliser

curl http://localhost:9200/_aliases

vous pouvez essayer cette commande

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

J'ai fait installer Kibana et ES sur une machine. Mais je ne connaissais pas les détails (sur quel chemin ou port) était le nœud ES sur cette machine.

Alors, comment pouvez-vous le faire à partir de Kibana (version 5.6)?

• Allez dans Dev Tools
• Voir la section Console et exécutez la requête suivante:

GET _cat/indices

Je voulais trouver la taille d'un indice ES particulier

Si curl est installé sur votre système, essayez cette commande simple: curl -XGET xx.xx.xx.xx: 9200 / _cat / indices? V

La commande mentionnée ci-dessus vous donne le résultat dans ce format: résultat pour récupérer tous les indices