Requête Elasticsearch pour renvoyer tous les enregistrements

http://127.0.0.1:9200/foo/_search/?size=1000&pretty=1
                                   ^

Notez le paramètre de taille , qui augmente les hits affichés de la valeur par défaut (10) à 1000 par partition.

Http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/search-request-from-size.html

Elasticsearch (ES) prend en charge à la fois une requête GET ou POST pour obtenir les données de L'index du cluster ES.

Quand nous faisons un GET:

http://localhost:9200/[your index name]/_search?size=[no of records you want]&q=*:*

Quand nous faisons un POST:

http://localhost:9200/[your_index_name]/_search
{
  "size": [your value] //default 10
  "from": [your start index] //default 0
  "query":
   {
    "match_all": {}
   }
}   

Je suggère d'utiliser un plugin UI avec elasticsearch http://mobz.github.io/elasticsearch-head/ Cela vous aidera à avoir une meilleure idée des indices que vous créez et à tester vos indices.

La requête ci-dessous renverrait les NO_OF_RESULTS que vous souhaitez retourner..

curl -XGET 'localhost:9200/foo/_search?size=NO_OF_RESULTS' -d '
{
"query" : {
    "match_all" : {}
  }
}'

Maintenant, la question ici est que vous voulez que tous les les enregistrements soient retournés. Donc, naturellement, avant d'écrire une requête, vous ne connaîtrez pas la valeur de NO_OF_RESULTS .

Comment savons-nous combien d'enregistrements existent dans votre document? Tapez simplement la requête ci-dessous

curl -XGET 'localhost:9200/foo/_search' -d '

Cela vous donnerait un résultat qui ressemble à celui ci-dessous

 {
hits" : {
  "total" :       2357,
  "hits" : [
    {
      ..................

Le résultat total indique le nombre d'enregistrements disponibles dans votre document. Donc, c'est une bonne façon de connaître la valeur des résultats NO_OF

curl -XGET 'localhost:9200/_search' -d ' 

Rechercher tous les types dans tous les indices

curl -XGET 'localhost:9200/foo/_search' -d '

Rechercher tous les types dans l'index foo

curl -XGET 'localhost:9200/foo1,foo2/_search' -d '

Rechercher tous les types dans les indices foo1 et foo2

curl -XGET 'localhost:9200/f*/_search

Recherche tous les types dans tous les indices commençant par f

curl -XGET 'localhost:9200/_all/type1,type2/_search' -d '

Types de recherche Utilisateur et tweet dans tous les indices

C'est la meilleure solution que j'ai trouvée en utilisant le client python

  # Initialize the scroll
  page = es.search(
  index = 'yourIndex',
  doc_type = 'yourType',
  scroll = '2m',
  search_type = 'scan',
  size = 1000,
  body = {
    # Your query's body
    })
  sid = page['_scroll_id']
  scroll_size = page['hits']['total']

  # Start scrolling
  while (scroll_size > 0):
    print "Scrolling..."
    page = es.scroll(scroll_id = sid, scroll = '2m')
    # Update the scroll ID
    sid = page['_scroll_id']
    # Get the number of results that we returned in the last scroll
    scroll_size = len(page['hits']['hits'])
    print "scroll size: " + str(scroll_size)
    # Do something with the obtained page

Https://gist.github.com/drorata/146ce50807d16fd4a6aa

Utilisation du client java

import static org.elasticsearch.index.query.QueryBuilders.*;

QueryBuilder qb = termQuery("multi", "test");

SearchResponse scrollResp = client.prepareSearch(test)
        .addSort(FieldSortBuilder.DOC_FIELD_NAME, SortOrder.ASC)
        .setScroll(new TimeValue(60000))
        .setQuery(qb)
        .setSize(100).execute().actionGet(); //100 hits per shard will be returned for each scroll
//Scroll until no hits are returned
do {
    for (SearchHit hit : scrollResp.getHits().getHits()) {
        //Handle the hit...
    }

    scrollResp = client.prepareSearchScroll(scrollResp.getScrollId()).setScroll(new TimeValue(60000)).execute().actionGet();
} while(scrollResp.getHits().getHits().length != 0); // Zero hits mark the end of the scroll and the while loop.

Https://www.elastic.co/guide/en/elasticsearch/client/java-api/current/java-search-scrolling.html

Utilisez également server:9200/_stats pour obtenir des statistiques sur tous vos alias.. comme la taille et le nombre d'éléments par alias, c'est très utile et fournit des informations utiles

Simple! Vous pouvez utiliser le paramètre size et from!

http://localhost:9200/[your index name]/_search?size=1000&from=0

, Puis vous modifiez le from progressivement jusqu'à ce que vous obtenez toutes les données.

Elasticsearch obtiendra significatif plus lent si vous ajoutez simplement un grand nombre comme taille,une méthode à utiliser pour obtenir tous les documents utilise les identifiants scan et scroll.

Donc votre appel serait:

GET /foo/_search?search_type=scan&scroll=1m
{
    "query": { "match_all": {}},
    "size":  1000
}

Cela renverra un _scroll_id, que vous pouvez maintenant utiliser pour obtenir le premier lot de documents.

Https://www.elastic.co/guide/en/elasticsearch/guide/current/scan-scroll.html

Le meilleur moyen d'ajuster la taille est taille=numéro de, en face de l'URL

Curl -XGET "http://localhost:9200/logstash-*/_search?size=50&pretty"

Note: la valeur maximale qui peut être définie dans cette taille est 10000. Pour toute valeur supérieure à dix mille, il s'attend à ce que vous utilisiez la fonction de défilement qui minimiserait les chances d'impact sur les performances.

Http://localhost:9200/foo/_search/?taille=1000&jolie=1

Vous devrez spécifier le paramètre de requête de taille car la valeur par défaut est 10

Vous pouvez utiliser le _count API pour obtenir la valeur de la size paramètre:

http://localhost:9200/foo/_count?q=<your query>

Renvoie {count:X, ...}. Extraire la valeur 'X', puis faire la requête réelle:

http://localhost:9200/foo/_search?q=<your query>&size=X

Quelques-uns d'entre eux ont donné la bonne réponse d'utiliser scan et scroll, apparemment, Je ne pouvais pas une réponse complète qui fonctionnerait comme par magie. Quand quelqu'un veut tirer des enregistrements, il faut exécuter la commande curl suivante.

curl -XGET 'http://ip1:9200/myindex/_search?scroll=1m' -d '
{
    "query": {
            "match_all" : {}
    }
}
'

Mais nous n'en avons pas fini ici. La sortie de la commande curl ci-dessus serait quelque chose comme ceci

{"_scroll_id":"c2Nhbjs1OzUyNjE6NU4tU3BrWi1UWkNIWVNBZW43bXV3Zzs1Mzc3OkhUQ0g3VGllU2FhemJVNlM5d2t0alE7NTI2Mjo1Ti1TcGtaLVRaQ0hZU0FlbjdtdXdnOzUzNzg6SFRDSDdUaWVTYWF6YlU2Uzl3a3RqUTs1MjYzOjVOLVNwa1otVFpDSFlTQWVuN211d2c7MTt0b3RhbF9oaXRzOjIyNjAxMzU3Ow==","took":109,"timed_out":false,"_shards":{"total":5,"successful":5,"failed":0},"hits":{"total":22601357,"max_score":0.0,"hits":[]}}

Il est important d'avoir _scroll_id à portée de main comme la prochaine fois que vous SHD exécutez la commande suivante

    curl -XGET  'localhost:9200/_search/scroll'  -d'
    {
        "scroll" : "1m", 
        "scroll_id" : "c2Nhbjs2OzM0NDg1ODpzRlBLc0FXNlNyNm5JWUc1" 
    }
    '

Cependant, je ne pense pas que c'est facile à exécuter cette opération manuellement. Votre meilleur pari est d'écrire un code java pour faire la même chose.

    private TransportClient client = null;
    private Settings settings = ImmutableSettings.settingsBuilder()
                  .put(CLUSTER_NAME,"cluster-test").build();
    private SearchResponse scrollResp  = null;

    this.client = new TransportClient(settings);
    this.client.addTransportAddress(new InetSocketTransportAddress("ip", port));

    QueryBuilder queryBuilder = QueryBuilders.matchAllQuery();
    scrollResp = client.prepareSearch(index).setSearchType(SearchType.SCAN)
                 .setScroll(new TimeValue(60000))                            
                 .setQuery(queryBuilder)
                 .setSize(100).execute().actionGet();

    scrollResp = client.prepareSearchScroll(scrollResp.getScrollId())
                .setScroll(new TimeValue(timeVal))
                .execute()
                .actionGet();

Maintenant boucle sur la dernière commande utilisez SearchResponse pour extraire les données.

Pour Elasticsearch 6.x

Demande: GET /foo/_search?pretty=true

Réponse: dans Hits - > total, donnez le nombre de documents

    {
      "took": 1,
      "timed_out": false,
      "_shards": {
        "total": 5,
        "successful": 5,
        "skipped": 0,
        "failed": 0
      },
      "hits": {
        "total": 1001,
        "max_score": 1,
        "hits": [
          {

Size {[4] } param augmente les hits affichés de la valeur par défaut(10) à 500.

http://localhost:9200/[indexName]/_search?pretty=true&size=500&q=*:*

Changez le de étape par étape pour obtenir toutes les données.

http://localhost:9200/[indexName]/_search?size=500&from=0

Par défaut, Elasticsearch renvoie 10 enregistrements, donc la taille doit être fournie explicitement.

Ajoutez la taille avec la demande pour obtenir le nombre désiré d'enregistrements.

Http://{host}:9200/{index_name}/_search?jolie=true&taille=(nombre de dossiers)

Note : La taille maximale de la page ne peut pas être supérieure à l'index.max_result_window paramètre d'index qui par défaut à 10 000.

Pour renvoyer tous les enregistrements de tous les indices, vous pouvez faire:

curl -XGET http://35.195.120.21:9200/_all/_search?size=50&pretty

Sortie:

  "took" : 866,
  "timed_out" : false,
  "_shards" : {
    "total" : 25,
    "successful" : 25,
    "failed" : 0
  },
  "hits" : {
    "total" : 512034694,
    "max_score" : 1.0,
    "hits" : [ {
      "_index" : "grafana-dash",
      "_type" : "dashboard",
      "_id" : "test",
      "_score" : 1.0,
       ...

curl -XGET '{{IP/localhost}}:9200/{{Index name}}/{{type}}/_search?scroll=10m&pretty' -d '{
"query": {
"filtered": {
"query": {
"match_all": {}
}}'

curl -X GET 'localhost:9200/foo/_search?q=*&pretty' 

Le résultat maximum qui retournera par elasticSearch est 10000 en fournissant la taille

curl -XGET 'localhost:9200/index/type/_search?scroll=1m' -d '
{
   "size":10000,
   "query" : {
   "match_all" : {}
    }
}'

Après cela, vous devez utiliser L'API Scroll pour obtenir le résultat et obtenir la valeur _scroll_id et mettre cette valeur dans scroll_id

curl -XGET  'localhost:9200/_search/scroll'  -d'
{
   "scroll" : "1m", 
   "scroll_id" : "" 
}'

Aucun sauf @ Akira Sendoh a répondu comment obtenir réellement tous les documents. Mais même cette solution bloque mon service ES 6.3 sans journaux. La seule chose qui a fonctionné pour moi en utilisant la bibliothèque de bas niveau elasticsearch-py était à travers Scan helper {[8] } qui utilise scroll() api:

from elasticsearch.helpers import scan

doc_generator = scan(
    es_obj,
    query={"query": {"match_all": {}}},
    index="my-index",
)

# use the generator to iterate, dont try to make a list or you will get out of RAM
for doc in doc_generator:
    # use it somehow

Cependant, la manière la plus propre de nos jours semble être à travers la bibliothèque elasticsearch-dsl, qui offre des appels plus abstraits et plus propres, par exemple: http://elasticsearch-dsl.readthedocs.io/en/latest/search_dsl.html#hits

Si quelqu'un cherche encore Toutes les données à récupérer à partir D'Elasticsearch comme moi pour certains cas d'utilisation, voici ce que j'ai fait. De plus, tous les moyens de données, tous les index et tous les types de documents. J'utilise Elasticsearch 6.3

curl -X GET "localhost:9200/_search?pretty=true" -H 'Content-Type: application/json' -d'
{
    "query": {
        "match_all": {}
    }
}
'

Elasticsearch référence

Vous pouvez utiliser size = 0 cela vous retournera tous les documents exemple

curl -XGET 'localhost:9200/index/type/_search' -d '
{
   size:0,
   "query" : {
   "match_all" : {}
    }
}'