Elencare tutti gli indici sul server ElasticSearch?

Vorrei elencare tutti gli indici presenti su un server ElasticSearch. Ho provato questo:

curl -XGET localhost:9200/

ma mi dà solo questo:

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

Voglio un elenco di tutti gli indici ..

Per un elenco conciso di tutti gli indici nel cluster, chiamare

curl http://localhost:9200/_aliases

questo ti darà un elenco di indici e dei loro alias.

Se vuoi stamparlo graziosamente, aggiungi pretty=true:

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

Il risultato sarà simile a questo, se i tuoi indici vengono chiamati old_deuteronomye mungojerrie:

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

Provare

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

Ti darà il seguente risultato autoesplicativo in modo tabellare

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

Puoi fare una query localhost:9200/_statuse questo ti darà un elenco di indici e informazioni su ciascuno di essi. La risposta sarà simile a questa:

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

Il comando _stats fornisce modi per personalizzare i risultati specificando le metriche desiderate. Per ottenere gli indici la query è la seguente:

GET /_stats/indices

Il formato generale della _statsquery è:

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

Dove sono le metriche:

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

Come esercizio per me stesso, ho scritto un piccolo plug-in elasticsearch che fornisce la funzionalità per elencare gli indici elasticsearch senza altre informazioni. Puoi trovarlo al seguente indirizzo:

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

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

Lo uso per ottenere tutti gli indici:

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

Con questo elenco puoi lavorare su ...

Esempio

$ 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

Per ottenere la terza colonna sopra (nomi degli indici):

$ 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: è inoltre possibile utilizzare awk '{print $3}'invece di cut -d\ -f3.

Intestazioni di colonna

È inoltre possibile ?vaggiungere il suffisso alla query con a per aggiungere un'intestazione di colonna. In questo modo si interromperà il cut...metodo, quindi consiglierei di utilizzare la awk..selezione a questo punto.

$ 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

Vorrei anche raccomandare di fare / _cat / index che fornisce un buon elenco leggibile dall'uomo dei tuoi indici.

Il modo più semplice per ottenere un elenco di soli indici è utilizzare la risposta sopra, con il parametro 'h = index':

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

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

Questo produrrà come di seguito

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

Ti darò la domanda che puoi eseguire su Kibana.

GET /_cat/indices?v

e la versione CURL sarà

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

You may use this command line.

curl -X OTTIENI "localhost: 9200 / _cat / index? v"

Per di più (sito ufficiale Elasticsearch)

Per elencare gli indici che è possibile eseguire: curl 'localhost: 9200 / _cat / index? V' Documentazione Elasticsearch

Accesso alla ricerca elastica protetta tramite Curl (aggiornamento 2020)

Se l' Elastic Searchopzione è protetta, è possibile utilizzare questo comando per elencare gli indici

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

_stats/indicesdà il risultato con indices.

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

Le persone qui hanno risposto a come farlo in termini di arricciatura e senso, alcune persone potrebbero aver bisogno di farlo in Java.

Eccolo

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

Prova questa API gatto: ti fornirà l'elenco di tutti gli indici con salute e altri dettagli.

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

Per Elasticsearch 6.X, ho trovato quanto segue il più utile. Ciascuno fornisce dati diversi nella risposta.

# 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

Puoi anche ottenere un indice specifico 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"
      }
    }
  }
}

Per maggiori informazioni

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

ecco un altro modo solo per vedere gli indici nel 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"}

Uno dei modi migliori per elencare gli indici + per visualizzare il suo stato insieme all'elenco: è semplicemente eseguendo la query di seguito.

Nota: utilizzare preferibilmente Sense per ottenere l'output corretto.

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

L'output del campione è il seguente. Il vantaggio principale è che mostra fondamentalmente il nome dell'indice e i frammenti in cui è stato salvato, la dimensione dell'indice, i frammenti ip ecc

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

Uso l' _stats/indexesendpoint per ottenere un blob di dati json e quindi filtrare con jq .

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

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

Se non vuoi virgolette, aggiungi un -rflag a jq.

Sì, l'endpoint è indexese la chiave dei dati lo è indices, quindi non sono nemmeno riusciti a decidersi :)

Ne avevo bisogno per ripulire questi indici di immondizia creati da una scansione di sicurezza interna (nessus).

PS. Consiglio vivamente di familiarizzare con jq se intendi interagire con ES dalla riga di comando.

<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 + "]");
}

Se lavori in scala, un modo per farlo e utilizzare Futurequello di creare un RequestExecutor, quindi utilizzare IndicesStatsRequestBuilder e il client amministrativo per inviare la richiesta.

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'esecutore è sollevato da questo post del blog che è sicuramente una buona lettura se stai cercando di interrogare ES a livello di codice e non attraverso l'arricciatura. Una volta che hai questo puoi creare un elenco di tutti gli indici abbastanza facilmente in questo modo:

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è un'istanza di Client che può essere un nodo o un client di trasporto, a seconda delle esigenze. Dovrai anche avere un implicitoExecutionContext ambito per questa richiesta. Se provi a compilare questo codice senza di esso, riceverai un avviso dal compilatore scala su come ottenerlo se non ne hai già importato uno.

Avevo bisogno del conteggio dei documenti, ma se hai davvero bisogno solo dei nomi degli indici puoi estrarli dalle chiavi della mappa invece che da IndexStats:

indicesStatsResponse.getIndices().keySet()

Questa domanda viene visualizzata quando stai cercando come farlo anche se stai cercando di farlo a livello di codice, quindi spero che questo aiuti chiunque cerchi di farlo in scala / java. Altrimenti, gli utenti di curl possono semplicemente fare come dice e usare la risposta principale

curl http://localhost:9200/_aliases

puoi provare questo comando

curl -X OTTIENI http: // localhost: 9200 / _cat / index? v

Avevo installato Kibana ed ES su una macchina. Ma non conoscevo i dettagli (in quale percorso o porta) era il nodo ES su quella macchina.

Quindi, come puoi farlo da Kibana (versione 5.6)?

• Vai a Strumenti di sviluppo
• Vedere la sezione Console ed eseguire la query seguente:

GET _cat/indices

Ero interessato a trovare la dimensione di un particolare indice ES

Se hai installato curl sul tuo sistema, prova questo semplice comando: curl -XGET xx.xx.xx.xx: 9200 / _cat / index? V

Il comando sopra menzionato ti dà il risultato in questo formato: risultato per recuperare tutti gli indici