Wyświetla wszystkie indeksy na serwerze ElasticSearch?

Chciałbym wyświetlić listę wszystkich indeksów obecnych na serwerze ElasticSearch. Próbowałem tego:

curl -XGET localhost:9200/

ale to po prostu daje mi to:

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

Chcę listę wszystkich indeksów ..

Aby uzyskać zwięzłą listę wszystkich wskaźników w klastrze, zadzwoń

curl http://localhost:9200/_aliases

da ci to listę indeksów i ich aliasów.

Jeśli chcesz ładnie wydrukować, dodaj pretty=true:

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

Wynik będzie wyglądał mniej więcej tak, jeśli twoje indeksy zostaną wywołane old_deuteronomyi mungojerrie:

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

Próbować

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

Umożliwi to śledzenie danych wyjściowych w sposób tabelaryczny

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

Możesz zapytać, localhost:9200/_statusa to da ci listę indeksów i informacji o każdym z nich. Odpowiedź będzie wyglądać mniej więcej tak:

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

Komenda _stats zapewnia sposoby dostosowywania wyników poprzez określenie żądanych metryk. Aby uzyskać indeksy, zapytanie jest następujące:

GET /_stats/indices

Ogólny format _statszapytania to:

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

Gdzie są dane:

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

Jako ćwiczenie dla siebie napisałem małą wtyczkę elasticsearch, która zapewnia funkcjonalność do wyświetlania indeksów elasticsearch bez żadnych innych informacji. Można go znaleźć pod następującym adresem URL:

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

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

Używam tego, aby uzyskać wszystkie indeksy:

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

Dzięki tej liście możesz pracować nad ...

Przykład

$ 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

Aby uzyskać trzecią kolumnę powyżej (nazwy indeksów):

$ 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

UWAGA: Możesz także użyć awk '{print $3}'zamiast cut -d\ -f3.

Nagłówki kolumn

Możesz również ?vdodać zapytanie do znaku, aby dodać nagłówek kolumny. Spowoduje to złamanie cut...metody, dlatego polecam użycie awk..zaznaczenia w tym miejscu.

$ 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

Poleciłbym także wykonanie / _cat / indices, które dają ładną czytelną dla ludzi listę twoich indeksów.

Najprostszym sposobem uzyskania listy tylko indeksów jest użycie powyższej odpowiedzi z parametrem „h = indeks”:

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

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

To wyjdzie jak poniżej

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

Dam ci zapytanie, które możesz uruchomić na kibana.

GET /_cat/indices?v

a wersja CURL będzie

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

You may use this command line.

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

Więcej informacji (oficjalna strona Elasticsearch)

Aby wyświetlić listę indeksów, możesz: curl 'localhost: 9200 / _cat / indices? V' Dokumentacja elasticsearch

Dostęp do bezpiecznego wyszukiwania elastycznego za pomocą funkcji Curl (aktualizacja 2020)

Jeśli Elastic Searchjest zabezpieczony, możesz użyć tego polecenia, aby wyświetlić listę indeksów

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

_stats/indicesdaje wynik z indices.

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

Ludzie tutaj odpowiedzieli, jak to zrobić w curl i sensie, niektórzy ludzie mogą potrzebować zrobić to w java.

Oto jest

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

Wypróbuj ten cat API: da ci listę wszystkich wskaźników ze zdrowiem i innymi szczegółami.

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

W przypadku Elasticsearch 6.X najbardziej pomocne okazało się następujące. Każdy z nich podaje w odpowiedzi inne dane.

# 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

Możesz także uzyskać określony indeks za pomocą

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

Po więcej informacji

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

oto inny sposób, aby zobaczyć wskaźniki w 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"}

Jednym z najlepszych sposobów wyświetlania list indeksów + w celu wyświetlenia ich statusu wraz z listą: jest po prostu wykonanie poniższego zapytania.

Uwaga: najlepiej użyć Sense, aby uzyskać odpowiednią moc wyjściową.

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

Przykładowy wynik jest następujący. Główną zaletą jest to, że w zasadzie pokazuje nazwę indeksu i fragmenty, w których został zapisany, rozmiar indeksu i fragmenty ip itp

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

Używam _stats/indexespunktu końcowego, aby uzyskać blob danych typu json, a następnie filtrować za pomocą jq .

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

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

Jeśli nie chcesz cytatów, dodaj -rflagę do jq.

Tak, punktem końcowym jest indexesklucz danych indices, dlatego też nie mogli się zdecydować :)

Potrzebowałem tego, aby wyczyścić te wskaźniki śmieci utworzone przez wewnętrzny skan bezpieczeństwa (nessus).

PS. Gorąco polecam zapoznanie się z jq, jeśli zamierzasz wchodzić w interakcję z ES z wiersza poleceń.

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

Jeśli pracujesz w scali, sposobem na to i skorzystanie Futurez tego jest utworzenie RequestExecutor, a następnie skorzystanie z IndicesStatsRequestBuilder i klienta administracyjnego w celu przesłania żądania.

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

Egzekutor jest usuwany z tego postu na blogu, co jest zdecydowanie dobrą lekturą, jeśli próbujesz programowo wysyłać zapytania do ES, a nie przez zwijanie. Po jego utworzeniu możesz łatwo utworzyć listę wszystkich indeksów:

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

clientjest instancją klienta, która może być węzłem lub klientem transportu, w zależności od potrzeb. Będziesz także musiał mieć domyślny ExecutionContextzakres dla tego żądania. Jeśli spróbujesz skompilować ten kod bez niego, otrzymasz od kompilatora scala ostrzeżenie, jak go uzyskać, jeśli jeszcze go nie zaimportowano.

Potrzebowałem liczby dokumentów, ale jeśli naprawdę potrzebujesz tylko nazw indeksów, możesz wyciągnąć je z klawiszy mapy zamiast z IndexStats:

indicesStatsResponse.getIndices().keySet()

To pytanie pojawia się, gdy szukasz sposobu, aby to zrobić, nawet jeśli próbujesz to zrobić programowo, więc mam nadzieję, że pomoże to każdemu, kto chce to zrobić w scala / java. W przeciwnym razie użytkownicy curl mogą zrobić to, co mówi najlepsza odpowiedź i użyć

curl http://localhost:9200/_aliases

możesz wypróbować to polecenie

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

Miałem Kibana i ES zainstalowane na komputerze. Ale nie znałem szczegółów (przy której ścieżce lub porcie) był węzeł ES na tym komputerze.

Jak możesz to zrobić z Kibana (wersja 5.6)?

• Idź do Dev Tools
• Zobacz sekcję Konsola i uruchom następujące zapytanie:

GET _cat/indices

Byłem zainteresowany znalezieniem wielkości konkretnego indeksu ES

Jeśli masz curl zainstalowany w swoim systemie, spróbuj tego prostego polecenia: curl -XGET xx.xx.xx.xx: 9200 / _cat / indices? V

Wyżej wymienione polecenie daje wynik w tym formacie: wynik, aby pobrać wszystkie indeksy