listar todos os índices no servidor ElasticSearch?

Tenta

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

Dar-lhe-ei o resultado auto-explicativo de uma forma tabular

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

Pode consultar localhost:9200/_status e isso dar-lhe-á uma lista de índices e informações sobre cada um. A resposta será algo parecido com isto:

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

O comando _stats fornece formas de personalizar os resultados, especificando as métricas desejadas. Para obter os índices a consulta é a seguinte:

GET /_stats/indices

O formato geral da consulta _stats é:

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

Onde estão as métricas:

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

Como um exercício para mim, eu escrevi um pequeno plugin elasticsearch fornecendo a funcionalidade para listar índices elasticsearch sem qualquer outra informação. Você pode encontrá-lo no seguinte url:

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

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

Uso isto para obter todos os índices:

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

Exemplo

$ 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 obter a terceira coluna acima (nomes dos í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: também pode usar awk '{print $3}' em vez de cut -d\ -f3.

Cabeçalhos Das Colunas

Você também pode sufixar a consulta com um ?v para adicionar um cabeçalho de coluna. Fazê-lo irá quebrar o método cut... para que eu recomendasse usar a selecção awk.. neste 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

Eu também recomendaria fazer/_cat / indices que dá uma lista legível humana de seus índices.

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

Isto irá sair como em baixo

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

GET /_cat/indices?v

E a versão CURL será

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

_stats/indices dá o resultado com indices.

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

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

Tente esta API cat: dar-lhe-á a lista de todos os índices com saúde e outros detalhes.

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

Uso o parâmetro de avaliação final _stats/indexes para obter uma bolha de json dos dados e depois filtrar com jq .

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

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

Se não quiser aspas, adicione uma bandeira -r ao jq.

Sim, O objectivo é indexes e a chave de dados é indices, por isso também não conseguiram decidir-se:)

PS. Eu recomendo que você se familiarize com jq Se você vai interagir com ES de 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 + "]");
}

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

Uma das melhores formas de listar os índices + para mostrar o seu estado em conjunto com a lista : é simplesmente executando a consulta abaixo.

nota: de preferência use Sense para obter a saída adequada.

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

A saída da amostra é a seguinte. A principal vantagem é que, basicamente, mostra o nome do índice e os cacos em que foi gravado, o tamanho do índice e os cacos 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                                                 
...
...
...

Se você está trabalhando em scala, uma maneira de fazer isso e usar Future's é criar um RequestExecutor, em seguida, usar o IndicesStatsRequestBuilder e administrativa de cliente para enviar o seu pedido.

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

O executor é retirado deste postque é definitivamente uma boa leitura se você está tentando consultar ES programaticamente e não através de curl. Um que você tem isso você pode criar uma lista de todos os índices muito facilmente como assim:

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 é um instance of Client which can be a node or a transport client, whatever suaves your needs. Você também precisa ter um implícito ExecutionContext em escopo para este pedido. Se você tentar compilar este código sem ele, então você receberá um aviso do compilador scala sobre como obtê-lo se você não tiver um importado já.

Eu precisava da contagem de documentos, mas se você realmente só precisa dos nomes dos índices você pode puxá-los das chaves do mapa em vez de a partir do IndexStats:

indicesStatsResponse.getIndices().keySet()

Esta pergunta aparece quando você está procurando como fazer isso, mesmo que você esteja tentando fazer isso programaticamente, então eu espero que isso ajude qualquer um que procure fazer isso em scala/java. Caso contrário, os usuários do curl podem apenas fazer o que a resposta superior diz e usar

curl http://localhost:9200/_aliases