Alle Indizes auf dem ElasticSearch-Server auflisten?

Ich möchte alle auf einem ElasticSearch-Server vorhandenen Indizes auflisten. Ich habe es versucht:

curl -XGET localhost:9200/

aber es gibt mir nur folgendes:

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

Ich möchte eine Liste aller Indizes.

Rufen Sie an, um eine übersichtliche Liste aller Indizes in Ihrem Cluster zu erhalten

curl http://localhost:9200/_aliases

Dadurch erhalten Sie eine Liste der Indizes und ihrer Aliase.

Wenn Sie möchten, dass es hübsch gedruckt wird, fügen Sie hinzu pretty=true:

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

Das Ergebnis sieht ungefähr so ​​aus, wenn Ihre Indizes aufgerufen werden old_deuteronomyund mungojerrie:

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

Versuchen

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

Sie erhalten die folgenden selbsterklärenden Ausgaben in tabellarischer Form

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

Sie können abfragen localhost:9200/_statusund erhalten eine Liste mit Indizes und Informationen zu den einzelnen Indizes. Die Antwort sieht ungefähr so ​​aus:

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

Der Befehl _stats bietet Möglichkeiten zum Anpassen der Ergebnisse durch Angabe der gewünschten Metriken. Um die Indizes zu erhalten, lautet die Abfrage wie folgt:

GET /_stats/indices

Das allgemeine Format der _statsAbfrage lautet:

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

Wo die Metriken sind:

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

Als Übung für mich selbst habe ich ein kleines Elasticsearch-Plugin geschrieben, das die Funktionalität bietet, Elasticsearch-Indizes ohne weitere Informationen aufzulisten. Sie finden es unter folgender URL:

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

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

Ich benutze dies, um alle Indizes zu erhalten:

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

Mit dieser Liste können Sie arbeiten an ...

Beispiel

$ 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

So erhalten Sie die 3. Spalte oben (Namen der Indizes):

$ 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

HINWEIS: Sie können auch awk '{print $3}'anstelle von verwenden cut -d\ -f3.

Spaltenüberschriften

Sie können der Abfrage auch ein Suffix ?vhinzufügen, um eine Spaltenüberschrift hinzuzufügen. Wenn Sie dies tun, wird die cut...Methode unterbrochen, daher würde ich empfehlen, die awk..Auswahl an dieser Stelle zu verwenden.

$ 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

Ich würde auch empfehlen, / _cat / indizes zu erstellen, was eine schöne, von Menschen lesbare Liste Ihrer Indizes ergibt.

Der einfachste Weg, eine Liste nur von Indizes zu erhalten, besteht darin, die obige Antwort mit dem Parameter 'h = index' zu verwenden:

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

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

Dies wird wie unten ausgegeben

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

Ich gebe Ihnen die Abfrage, die Sie auf Kibana ausführen können.

GET /_cat/indices?v

und die CURL-Version wird sein

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

You may use this command line.

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

Für mehr (Elasticsearch Offizielle Seite)

So listen Sie die Indizes auf: curl 'localhost: 9200 / _cat / indices? V' Elasticsearch Documentation

Zugriff auf die gesicherte elastische Suche über Curl (Update 2020)

Wenn das Elastic Searchgesichert ist, können Sie mit diesem Befehl Indizes auflisten

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

_stats/indicesgibt das Ergebnis mit indices.

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

Die Leute hier haben geantwortet, wie man es in Locken und Sinn macht, einige Leute müssen dies möglicherweise in Java tun.

Hier kommt's

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

Probieren Sie diese Katzen-API aus: Sie erhalten eine Liste aller Indizes mit Gesundheitszustand und anderen Details.

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

Für Elasticsearch 6.X fand ich Folgendes am hilfreichsten. Jeder liefert unterschiedliche Daten in der Antwort.

# 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

Sie können auch einen bestimmten Index mit abrufen

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

Für mehr Information

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

Hier ist eine andere Möglichkeit, nur die Indizes in der Datenbank zu sehen:

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

Eine der besten Möglichkeiten, Indizes + aufzulisten, um ihren Status zusammen mit list anzuzeigen, besteht darin, einfach die folgende Abfrage auszuführen.

Hinweis: Verwenden Sie vorzugsweise Sense, um die richtige Ausgabe zu erhalten.

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

Die Beispielausgabe ist wie folgt. Der Hauptvorteil ist, dass im Wesentlichen der Indexname und die darin gespeicherten Shards, die Indexgröße und die Shards-IP usw. Angezeigt werden

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

Ich benutze den _stats/indexesEndpunkt, um einen json-Blob von Daten zu erhalten und dann mit jq zu filtern .

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

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

Wenn Sie keine Anführungszeichen möchten, fügen Sie a hinzu -r jq Flag hinzu.

Ja, der Endpunkt ist indexesund der Datenschlüssel istindices , also konnten sie sich auch nicht entscheiden :)

Ich brauchte dies, um diese Müllindizes zu bereinigen, die durch einen internen Sicherheitsscan (Nessus) erstellt wurden.

PS. Ich empfehle dringend, sich mit jq vertraut zu machen, wenn Sie über die Befehlszeile mit ES interagieren möchten .

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

Java API

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

Wenn Sie in Scala arbeiten, können Sie dies tun und verwenden Future, indem Sie einen RequestExecutor erstellen. Verwenden Sie dann den IndicesStatsRequestBuilder und den Verwaltungsclient, um Ihre Anfrage zu senden.

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

Der Executor wird aus diesem Blog-Beitrag entfernt, was definitiv eine gute Lektüre ist, wenn Sie versuchen, ES programmgesteuert und nicht durch Curl abzufragen. Wenn Sie dies haben, können Sie ganz einfach eine Liste aller Indizes erstellen:

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

clientist eine Instanz von Client, die ein Knoten oder ein Transportclient sein kann, je nachdem, was Ihren Anforderungen entspricht. Sie müssen auch einen impliziten ExecutionContextGültigkeitsbereich für diese Anforderung haben. Wenn Sie versuchen, diesen Code ohne ihn zu kompilieren, erhalten Sie vom Scala-Compiler eine Warnung, wie Sie diesen Code erhalten, wenn Sie noch keinen importiert haben.

Ich brauchte die Anzahl der Dokumente, aber wenn Sie wirklich nur die Namen der Indizes benötigen, können Sie sie aus den Schlüsseln der Karte ziehen, anstatt aus IndexStats:

indicesStatsResponse.getIndices().keySet()

Diese Frage wird angezeigt, wenn Sie nach einer Vorgehensweise suchen, auch wenn Sie dies programmgesteuert versuchen. Ich hoffe, dies hilft jedem, der dies in Scala / Java tun möchte. Andernfalls können Curl-Benutzer einfach das tun, was in der Top-Antwort steht, und verwenden

curl http://localhost:9200/_aliases

Sie können diesen Befehl versuchen

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

Ich hatte Kibana und ES auf einer Maschine installiert. Aber ich wusste nicht, welche Details (an welchem ​​Pfad oder an welchem ​​Port) der ES-Knoten auf diesem Computer war.

Wie können Sie dies von Kibana (Version 5.6) aus tun?

• Gehen Sie zu Dev Tools
• Siehe Abschnitt Konsole , und führen Sie die folgende Abfrage aus:

GET _cat/indices

Ich war daran interessiert, die Größe eines bestimmten ES-Index zu ermitteln

Wenn Sie Curl auf Ihrem System installiert haben, versuchen Sie diesen einfachen Befehl: curl -XGET xx.xx.xx.xx: 9200 / _cat / indices? V.

Mit dem oben genannten Befehl erhalten Sie ein Ergebnis in diesem Format: result, um alle Indizes abzurufen