{"id":64095,"date":"2017-02-27T19:00:06","date_gmt":"2017-02-27T17:00:06","guid":{"rendered":"http:\/\/www.javacodegeeks.com\/?p=64095"},"modified":"2023-12-11T10:15:30","modified_gmt":"2023-12-11T08:15:30","slug":"elasticsearch-java-developers-elasticsearch-command-line","status":"publish","type":"post","link":"https:\/\/www.javacodegeeks.com\/2017\/02\/elasticsearch-java-developers-elasticsearch-command-line.html","title":{"rendered":"Elasticsearch for Java Developers: Elasticsearch from the command line"},"content":{"rendered":"

This article is part of our Academy Course titled Elasticsearch Tutorial for Java Developers<\/a>.<\/p>\n

In this course, we provide a series of tutorials so that you can develop your own Elasticsearch based applications. We cover a wide range of topics, from installation and operations, to Java API Integration and reporting. With our straightforward tutorials, you will be able to get your own projects up and running in minimum time. Check it out here<\/a>!<\/em><\/p>\n

<\/a>1. Introduction<\/h2>\n

From the previous part of the tutorial<\/a> we have got a pretty good understanding of what Elasticsearch<\/a> is, its basic concepts and the power of search capabilities it could bring to our applications. In this section we are jumping right into the battle and going to apply our knowledge in practice. Along this section curl<\/a> and\/or http<\/a> would be the only tools we are going to use to make friends with Elasticsearch<\/a>.<\/p>\n

\n

Table Of Contents<\/h3>\n
\n
1. Introduction<\/a><\/dt>\n
2. Is My Cluster Healthy?<\/a><\/dt>\n
3. All About Indices<\/a><\/dt>\n
4. Documents, More Documents, \u2026<\/a><\/dt>\n
5. What if My Mapping Types Are Suboptimal<\/a><\/dt>\n
6. The Search Time<\/a><\/dt>\n
7. Mutations by Query<\/a><\/dt>\n
8. Know Your Queries Better<\/a><\/dt>\n
9. From Search to Insights<\/a><\/dt>\n
10. Watch Your Cluster Breathing<\/a><\/dt>\n
11. Conclusions<\/a><\/dt>\n
12. What\u2019s next<\/a><\/dt>\n<\/dl>\n<\/div>\n

To sum up, we have already finalized our book catalog<\/code> index and mapping types so we are going to pick it up from there. In order to keep things as close to reality as possible, we are going to use Elasticsearch<\/a> cluster with three nodes (all run as Docker<\/a> containers), while catalog<\/code> index is going to be configured with replication factor of two.<\/p>\n

As we are going to see, working with Elasticsearch<\/a> cluster has quite a few subtleties comparing to standalone instance and it is better to be prepared to deal with them. Hopefully, you still remember from the previous part of the tutorial how to start Elasticsearch<\/a> as this is going to be the only prerequisite: having the cluster up and running. With that, let us get started!<\/p>\n

<\/a>2. Is My Cluster Healthy?<\/h2>\n

The first thing you would need to know about your Elasticsearch<\/a> cluster before doing anything with it is its health. There are a couple of ways to gather this information but arguably the easiest and most convenient one is by using Cluster APIs<\/a>, particularly cluster health endpoint<\/a>.<\/p>\n

$ http http:\/\/localhost:9200\/_cluster\/health\n\nHTTP\/1.1 200 OK\ncontent-encoding: gzip\ncontent-type: application\/json; charset=UTF-8\ntransfer-encoding: chunked\n\n{\n    \"active_primary_shards\": 0,\n    \"active_shards\": 0,\n    \"active_shards_percent_as_number\": 100.0,\n    \"cluster_name\": \"es-catalog\",\n    \"delayed_unassigned_shards\": 0,\n    \"initializing_shards\": 0,\n    \"number_of_data_nodes\": 3,\n    \"number_of_in_flight_fetch\": 0,\n    \"number_of_nodes\": 3,\n    \"number_of_pending_tasks\": 0,\n    \"relocating_shards\": 0,\n    \"status\": \"green\",\n    \"task_max_waiting_in_queue_millis\": 0,\n    \"timed_out\": false,\n    \"unassigned_shards\": 0\n}\n<\/pre>\n
Among those details we are looking for status<\/code> indicator which should be set to green<\/code>, meaning that that all shards are allocated and cluster is in a good operational shape.<\/p>\n
<\/a>3. All About Indices<\/h2>\n
Our Elasticsearch<\/a> cluster is all green and ready to rock. The next logical step would be to create a catalog<\/code> index, with the mapping types and settings we have outlined before. But before doing that, let us check if there are any indices already created<\/a> this time using Indices APIs<\/a>.<\/p>\n
$ http http:\/\/localhost:9200\/_stats\n\nHTTP\/1.1 200 OK\ncontent-encoding: gzip\ncontent-type: application\/json; charset=UTF-8\ntransfer-encoding: chunked\n\n{\n    \"_all\": {\n        \"primaries\": {},\n        \"total\": {}\n    },\n    \"_shards\": {\n        \"failed\": 0,\n        \"successful\": 0,\n        \"total\": 0\n    },\n    \"indices\": {}\n}\n<\/pre>\n
As expected, our cluster has nothing in it yet and we are good to go with creating the index for our book catalog. As we know, Elasticsearch<\/a> speaks JSON<\/a> but manipulating ald be said about usag more or less complex JSON<\/a> document from the command line is somewhat cumbersome. Let us better store the catalog<\/code> settings and mappings in the catalog-index.json<\/a> document.<\/p>\n
{ \n  \"settings\": {\n    \"index\" : {\n      \"number_of_shards\" : 5, \n      \"number_of_replicas\" : 2 \n    }\n  },\n  \"mappings\": {\n    \"books\": {\n      \"_source\" : {\n        \"enabled\": true\n      },\n      \"properties\": {\n        \"title\": { \"type\": \"text\" },\n        \"categories\" : {\n          \"type\": \"nested\",\n          \"properties\" : {\n            \"name\": { \"type\": \"text\" }\n          }\n        },\n        \"publisher\": { \"type\": \"keyword\" },\n        \"description\": { \"type\": \"text\" },\n        \"published_date\": { \"type\": \"date\" },\n        \"isbn\": { \"type\": \"keyword\" },\n        \"rating\": { \"type\": \"byte\" }\n       }\n   },\n   \"authors\": {\n     \"properties\": {\n       \"first_name\": { \"type\": \"keyword\" },\n       \"last_name\": { \"type\": \"keyword\" }\n     },\n     \"_parent\": {\n        \"type\": \"books\"\n      }\n    }\n  }\n}<\/pre>\n
And use this document as an input to create an index API<\/a>.<\/p>\n
$ http PUT http:\/\/localhost:9200\/catalog < catalog-index.json\n\nHTTP\/1.1 200 OK\ncontent-encoding: gzip\ncontent-type: application\/json; charset=UTF-8\ntransfer-encoding: chunked\n\n{\n    \"acknowledged\": true,\n    \"shards_acknowledged\": true\n}\n<\/pre>\n
A few words should be said about the usage of acknowledged<\/code> response property across most of the Elasticsearch<\/a> APIs, especially the ones which apply mutations. In general, this value simply indicates whether the operation completed before the timeout (\u201ctrue\u201d<\/code>) or may take an effect sometime soon (\u201cfalse\u201d<\/code>). We are going to see more examples of its usage in a different context later on.<\/p>\n
That is it and we have brought our catalog<\/code> index live. To ensure the truthiness of this fact, we could ask Elasticsearch<\/a> to return catalog<\/code> index settings<\/a>.<\/p>\n
$ http http:\/\/localhost:9200\/catalog\/_settings\n\nHTTP\/1.1 200 OK\ncontent-encoding: gzip\ncontent-type: application\/json; charset=UTF-8\ntransfer-encoding: chunked\n\n{\n    \"catalog\": {\n        \"settings\": {\n            \"index\": {\n                \"creation_date\": \"1487428863824\",\n                \"number_of_replicas\": \"2\",\n                \"number_of_shards\": \"5\",\n                \"provided_name\": \"catalog\",\n                \"uuid\": \"-b63dCesROC5UawbHz8IYw\",\n                \"version\": {\n                    \"created\": \"5020099\"\n                }\n            }\n        }\n    }\n}\n<\/pre>\n
Awesome, exactly what we have ordered. You might wonder how Elasticsearch<\/a> would react if we would have tried to update the index settings<\/a> by increasing the number of shards (as we know, not all index settings could be updated once index has been created).<\/p>\n
$ echo '{\"index\":{\"number_of_shards\":6}}' | http PUT http:\/\/localhost:9200\/catalog\/_settings\n\nHTTP\/1.1 400 Bad Request\ncontent-encoding: gzip\ncontent-type: application\/json; charset=UTF-8\ntransfer-encoding: chunked\n\n{\n    \"error\": {\n        \"reason\": \"can't change the number of shards for an index\",\n        \"root_cause\": [\n            ...\n        ],\n        \"type\": \"illegal_argument_exception\"\n    },\n    \"status\": 400\n}\n<\/pre>\n
The error response comes as no surprise (please notice that the response details have been reduced for illustrative purposes only). Along with settings, it is very easy to get the mapping types<\/a> for a particular index, for example:<\/p>\n
$ http http:\/\/192.168.99.100:9200\/catalog\/_mapping\n\nHTTP\/1.1 200 OK\ncontent-encoding: gzip\ncontent-type: application\/json; charset=UTF-8\ntransfer-encoding: chunked\n\n{\n    \"catalog\": {\n        \"mappings\": {\n            \"authors\": {\n                ...\n            },\n            \"books\": {\n                ...\n            }\n        }\n    }\n}\n<\/pre>\n
By and large, the index mappings for existing fields cannot be updated; however there are some exceptions of the rule<\/a>. One of the greatest features of the indices APIs<\/a> is the ability to perform the analysis process<\/a> against a particular index mapping type and field without actually sending any documents.<\/p>\n
$ http http:\/\/localhost:9200\/catalog\/_analyze field=books.title text=\"Elasticsearch: The Definitive Guide. A Distributed Real-Time Search and Analytics Engine\"\n\nHTTP\/1.1 200 OK\ncontent-encoding: gzip\ncontent-type: application\/json; charset=UTF-8\ntransfer-encoding: chunked\n\n{\n    \"tokens\": [\n        {\n            \"end_offset\": 13,\n            \"position\": 0,\n            \"start_offset\": 0,\n            \"token\": \"elasticsearch\",\n            \"type\": \"\"\n        },\n        {\n            \"end_offset\": 18,\n            \"position\": 1,\n            \"start_offset\": 15,\n            \"token\": \"the\",\n            \"type\": \"\"\n        },\n        \n        ...\n\n        {\n            \"end_offset\": 88,\n            \"position\": 11,\n            \"start_offset\": 82,\n            \"token\": \"engine\",\n            \"type\": \"\"\n        }\n    ]\n}\n<\/pre>\n
It is exceptionally useful in case you would like to validate your mapping types\u2019 parameters before throwing a bunch of data into Elasticsearch<\/a> for indexing.<\/p>\n
And last but not least, there is one important detail about index states. Any particular index could be in opened<\/code> (fully operational) or closed<\/code> (blocked for read\/write operations, archived would be a good analogy) states. As for everything else, Elasticsearch<\/a> provided an APIs for that<\/a>.<\/p>\n
$ http POST http:\/\/localhost:9200\/catalog\/_open\n\nHTTP\/1.1 200 OK\ncontent-encoding: gzip\ncontent-type: application\/json; charset=UTF-8\ntransfer-encoding: chunked\n\n{\n    \"acknowledged\": true\n}\n<\/pre>\n
<\/a>4. Documents, More Documents, \u2026<\/h2>\n
The empty index without documents is not very useful so let us switch gears from indices APIs<\/a> to another great one, document APIs<\/a>. We are going to start exploring it using the simplest single document<\/a> operations, relying on the following book.json<\/a> document:<\/p>\n
{\n  \"title\": \"Elasticsearch: The Definitive Guide. A Distributed Real-Time Search and Analytics Engine\",\n  \"categories\": [\n      { \"name\": \"analytics\" },\n      { \"name\": \"search\" },\n      { \"name\": \"database store\" }\n  ],\n  \"publisher\": \"O'Reilly\",\n  \"description\": \"Whether you need full-text search or real-time analytics of structured data\u2014or both\u2014the Elasticsearch distributed search engine is an ideal way to put your data to work. This practical guide not only shows you how to search, analyze, and explore data with Elasticsearch, but also helps you deal with the complexities of human language, geolocation, and relationships.\", \n  \"published_date\": \"2015-02-07\",\n  \"isbn\": \"978-1449358549\",\n  \"rating\": 4\n}\n<\/pre>\n
Before sending this JSON<\/a> to Elasticsearch<\/a>, it would be great to talk a little bit about documents identification. Each document in Elasticsearch<\/a> has a unique identifier, stored in a special _id<\/code> field. You may provide one while uploading the document to Elasticsearch<\/a> (like we do in the example below using isbn<\/code> as it is a great example of natural identifier), or it will be generated and assigned by Elasticsearch<\/a>.<\/p>\n
$ http PUT http:\/\/localhost:9200\/catalog\/books\/978-1449358549 < book.json\n\nHTTP\/1.1 201 Created\nLocation: \/catalog\/books\/978-1449358549\ncontent-encoding: gzip\ncontent-type: application\/json; charset=UTF-8\ntransfer-encoding: chunked\n\n{\n    \"_id\": \"978-1449358549\",\n    \"_index\": \"catalog\",\n    \"_shards\": {\n        \"failed\": 0,\n        \"successful\": 3,\n        \"total\": 3\n    },\n    \"_type\": \"books\",\n    \"_version\": 1,\n    \"created\": true,\n    \"result\": \"created\"\n}\n<\/pre>\n
Our first document just made its way into a catalog<\/code> index, under books<\/code> type. But we also have authors<\/code> type, which is in a parent \/ child relationship with books<\/code>. Let us complement the book with its authors from authors.json<\/a> document.<\/p>\n
[\n  {\n    \"first_name\": \"Clinton\",\n    \"last_name\": \"Gormley\",\n    \"_parent\": \"978-1449358549\"\n  },\n  {\n    \"first_name\": \"Zachary\",\n    \"last_name\": \"Tong\",\n    \"_parent\": \"978-1449358549\"\n  }\n]\n<\/pre>\n
The book has more than one author so we still can use the single document API<\/a> by indexing each author document one by one. However, let us not do that but switch over to bulk document API<\/a> instead and transform our authors.json<\/a> document a bit to be compatible with bulk document API<\/a> format.<\/p>\n
{ \"index\" : { \"_index\" : \"catalog\", \"_type\" : \"authors\", \"_id\": \"1\", \"_parent\": \"978-1449358549\" } }\n{ \"first_name\": \"Clinton\", \"last_name\": \"Gormley\" }\n{ \"index\" : { \"_index\" : \"catalog\", \"_type\" : \"authors\", \"_id\": \"2\", \"_parent\": \"978-1449358549\" } }\n{ \"first_name\": \"Zachary\", \"last_name\": \"Tong\" }\n<\/pre>\n
Done deal, let us save this document as authors-bulk.json<\/a> and feed it directly into bulk document API<\/a> endpoint.
 
<\/div> <\/div><\/p>\n
$ http POST http:\/\/localhost:9200\/_bulk < authors-bulk.json\n\nHTTP\/1.1 200 OK\ncontent-encoding: gzip\ncontent-type: application\/json; charset=UTF-8\ntransfer-encoding: chunked\n\n{\n    \"errors\": false,\n    \"items\": [\n        {\n            \"index\": {\n                \"_id\": \"1\",\n                \"_index\": \"catalog\",\n                \"_shards\": {\n                    \"failed\": 0,\n                    \"successful\": 3,\n                    \"total\": 3\n                },\n                \"_type\": \"authors\",\n                \"_version\": 5,\n                \"created\": false,\n                \"result\": \"updated\",\n                \"status\": 200\n            }\n        },\n        {\n            \"index\": {\n                \"_id\": \"2\",\n                \"_index\": \"catalog\",\n                \"_shards\": {\n                    \"failed\": 0,\n                    \"successful\": 3,\n                    \"total\": 3\n                },\n                \"_type\": \"authors\",\n                \"_version\": 2,\n                \"created\": true,\n                \"result\": \"created\",\n                \"status\": 201\n            }\n        }\n    ],\n    \"took\": 105\n}\n<\/pre>\n
And we have book and author documents as the first citizens of the catalog<\/code> index! It is time to fetch those documents<\/a> back.<\/p>\n
$ http http:\/\/localhost:9200\/catalog\/books\/978-1449358549\n\nHTTP\/1.1 200 OK\ncontent-encoding: gzip\ncontent-type: application\/json; charset=UTF-8\ntransfer-encoding: chunked\n\n{\n    \"_id\": \"978-1449358549\",\n    \"_index\": \"catalog\",\n    \"_source\": {\n        \"categories\": [\n            { \"name\": \"analytics\" },\n            { \"name\": \"search\"},\n            { \"name\": \"database store\" }\n        ],\n        \"description\": \"...\",\n        \"isbn\": \"978-1449358549\",\n        \"published_date\": \"2015-02-07\",\n        \"publisher\": \"O'Reilly\",\n        \"rating\": 4,\n        \"title\": \"Elasticsearch: The Definitive Guide. A Distributed Real-Time Search and Analytics Engine\"\n    },\n    \"_type\": \"books\",\n    \"_version\": 1,\n    \"found\": true\n}\n<\/pre>\n
Easy! However to fetch the documents from authors<\/code> collection, which are children of their respective documents from books<\/code> collection, we have to supply the parent identifier along with the document own one, for example:<\/p>\n
$ http http:\/\/localhost:9200\/catalog\/authors\/1?parent=978-1449358549\n\nHTTP\/1.1 200 OK\ncontent-encoding: gzip\ncontent-type: application\/json; charset=UTF-8\ntransfer-encoding: chunked\n\n{\n    \"_id\": \"1\",\n    \"_index\": \"catalog\",\n    \"_parent\": \"978-1449358549\",\n    \"_routing\": \"978-1449358549\",\n    \"_source\": {\n        \"first_name\": \"Clinton\",\n        \"last_name\": \"Gormley\"\n    },\n    \"_type\": \"authors\",\n    \"_version\": 1,\n    \"found\": true\n}\n<\/pre>\n
This is one of the specifics working with parent \/ child relations in Elasticsearch<\/a>. As it has been already mentioned, you may model such relationships in a simpler way but our goal is to learn how to deal with it if you choose to go this route in your applications.<\/p>\n
The delete<\/a> and update<\/a> APIs are pretty straightforward so we just leaf them through, please notice that the same rules regarding identifying the child documents apply. You may be surprised, but deleting a parent document does not automatically delete its children, so keep that in mind. We are going to see how to workaround that a bit later.<\/p>\n
To finish up, let us take a look at the term vectors API<\/a> which returns all the details and statistics about terms in the fields of the document, for example (only the small part of the response has been pasted):<\/p>\n
$ http http:\/\/localhost:9200\/catalog\/books\/978-1449358549\/_termvectors?fields=description\n\nHTTP\/1.1 200 OK\ncontent-encoding: gzip\ncontent-type: application\/json; charset=UTF-8\ntransfer-encoding: chunked\n\n{\n    \"_id\": \"978-1449358549\",\n    \"_index\": \"catalog\",\n    \"_type\": \"books\",\n    \"_version\": 1,\n    \"found\": true,\n    \"term_vectors\": {\n        \"description\": {\n            \"field_statistics\": {\n                \"doc_count\": 1,\n                \"sum_doc_freq\": 46,\n                \"sum_ttf\": 60\n            },\n            \"terms\": {\n                \"analyze\": {\n                    \"term_freq\": 1,\n                    \"tokens\": [ ... ]\n                },\n                \"and\": {\n                    \"term_freq\": 2,\n                    \"tokens\": [ ... ]\n\n                },\n                \"complexities\": {\n                    \"term_freq\": 1,\n                    \"tokens\": [ ... ]\n\n                },\n                \"data\": {\n                    \"term_freq\": 3,\n                    \"tokens\": [ ... ]\n\n                },\n                ...\n            }\n        }\n    },\n    \"took\": 5\n}\n<\/pre>\n
You may not find yourself using the term vectors API<\/a> often however it is a terrific tool to troubleshoot why certain documents may not pop up in the search results.<\/p>\n
<\/a>5. What if My Mapping Types Are Suboptimal<\/h2>\n
Very often over time you may discover that your mapping types may not be optimal and could be made better. However, Elasticsearch<\/a> supports only limited modifications over existing mapping types. Luckily, Elasticsearch<\/a> is providing a dedicated reindexing API<\/a>, for example:<\/p>\n
$ echo '{\"source\": {\"index\": \"catalog\"}, \"dest\": {\"index\": \"catalog-v2\"}}' | http POST http:\/\/localhost:9200\/_reindex\n\nHTTP\/1.1 200 OK\ncontent-encoding: gzip\ncontent-type: application\/json; charset=UTF-8\ntransfer-encoding: chunked\n\n{\n    \"batches\": 0,\n    \"created\": 200,\n    \"deleted\": 0,\n    \"failures\": [],\n    \"noops\": 0,\n    \"requests_per_second\": -1.0,\n    \"retries\": {\n        \"bulk\": 0,\n        \"search\": 0\n    },\n    \"throttled_millis\": 0,\n    \"throttled_until_millis\": 0,\n    \"timed_out\": false,\n    \"took\": 265,\n    \"total\": 200,\n    \"updated\": 0,\n    \"version_conflicts\": 0\n}\n<\/pre>\n
The trick here is to create a new index with updated mapping types, catalog-v2<\/code>, and than just ask Elasticsearch<\/a> to fetch all documents from old index (catalog<\/code>) and put them into the new one (catalog-v2<\/code>), and finally swap the indices. Please notice, it also works not only for local but remote indices as well<\/a>.<\/p>\n
Although simple, this API is still considered an experimental and may not be suitable in all cases, for example if your index is really massive or your Elasticsearch<\/a> is experiencing a high load and should prioritize the application requests.
\n[ulp id=’lFK4fMZhpULqeQUl’]
\n <\/p>\n
<\/a>6. The Search Time<\/h2>\n
We have learned how to create indexes, mapping types and index the documents, all important but not really exciting topics. But search is definitely the heart and soul of Elasticsearch<\/a>, so let us get to know it right away.<\/p>\n
In order to demonstrate different search features we would need a couple of more documents, please upload them to your Elasticsearch<\/a> cluster from books-and-authors-bulk.json<\/a> using our friend bulk document API<\/a>.<\/p>\n
$ http POST http:\/\/localhost:9200\/_bulk < books-and-authors-bulk.json\n<\/pre>\n
Having a few documents in our collections we could start off to issue search queries against them using the most accessible form of search API<\/a> which accepts search criteria in URI<\/a> by means of query string. For example, let us search for a term engine<\/code> (keeping in mind search engine<\/code> phrase).<\/p>\n
$ http POST http:\/\/localhost:9200\/catalog\/books\/_search?q=engine\n\nHTTP\/1.1 200 OK\ncontent-encoding: gzip\ncontent-type: application\/json; charset=UTF-8\ntransfer-encoding: chunked\n\n{\n    \"_shards\": {\n        \"failed\": 0,\n        \"successful\": 5,\n        \"total\": 5\n    },\n    \"hits\": {\n        \"hits\": [\n            {\n                \"_id\": \"978-1449358549\",\n                \"_index\": \"catalog\",\n                \"_score\": 0.7503276,\n                \"_source\": {\n                    \"categories\": [\n                        { \"name\": \"analytics },\n                        { \"name\": \"search\" },\n                        { \"name\": \"database store\" }\n                    ],\n                    \"description\": \" Whether you need full-text search or real-time ...\",\n                    \"isbn\": \"978-1449358549\",\n                    \"published_date\": \"2015-02-07\",\n                    \"publisher\": \"O'Reilly\",\n                    \"rating\": 4,\n                    \"title\": \" Elasticsearch: The Definitive Guide. ...\"\n                },\n                \"_type\": \"books\"\n            }\n        ],\n        \"max_score\": 0.7503276,\n        \"total\": 1\n    },\n    \"timed_out\": false,\n    \"took\": 22\n}\n<\/pre>\n
Good starting point indeed, this API is quite useful for doing quick and shallow searches, but its capabilities are very limited. The search using request body API<\/a> is a very different beast and reveals the full power of Elasticsearch<\/a>. It is built on top of JSON<\/a>-based Query DSL<\/a>, the concise and intuitive language to construct arbitrarily complex search queries.<\/p>\n
There are quite a few query types which Query DSL<\/a> allows to describe, each have own syntax and parameters. However, there is a set of common parameters, like sort<\/a>, from<\/a>, size<\/a>, stored_fields<\/a> (the list is really long<\/a> actually) which are agnostic to query type and could be applied for any of those.<\/p>\n
For the next couple of sections we are going to switch over from http<\/a> to curl<\/a> as the latter is a bit more convenient when dealing with JSON<\/a> payloads.<\/p>\n
The first query type we are going to try out using Query DSL<\/a> is the match all query<\/a>. In some extent, it is not really a query because it just matches all documents. As such, it may return a lot of results and as a general rule, please always annotate your queries with reasonable size<\/a> limit, here is an example:<\/p>\n
$ curl \u2013i http:\/\/localhost:9200\/catalog\/books\/_search?pretty -d '                                                                                                                                  \n{\n    \"size\": 10,\n    \"query\": {\n        \"match_all\" : {\n        }\n    }\n}'\n\nHTTP\/1.1 200 OK\ncontent-type: application\/json; charset=UTF-8\ncontent-length: 3112\n{\n  \"took\" : 13,\n  \"timed_out\" : false,\n  \"_shards\" : {\n    \"total\" : 5,\n    \"successful\" : 5,\n    \"failed\" : 0\n  },\n  \"hits\" : {\n    \"total\" : 3,\n    \"max_score\" : 1.0,\n    \"hits\" : [\n      {\n        \"_index\" : \"catalog\",\n        \"_type\" : \"books\",\n        \"_id\" : \"978-1449358549\",\n        \"_score\" : 1.0,\n        \"_source\" : {\n          \"title\" : \"Elasticsearch: The Definitive Guide ...\",\n          \"categories\" : [\n            { \"name\" : \"analytics\" },\n            { \"name\" : \"search\" },\n            { \"name\" : \"database store\" }\n          ],\n          \"publisher\" : \"O'Reilly\",\n          \"description\" : \"Whether you need full-text ...\",\n          \"published_date\" : \"2015-02-07\",\n          \"isbn\" : \"978-1449358549\",\n          \"rating\" : 4\n        }\n      },\n      ...\n    ]\n  }\n}\n<\/pre>\n
The next one is a real query type and is referred as a class of full text queries<\/a> which do a search against full text document fields (probably the most widely used ones). In the basic form it does a match against a single document field, like for example book\u2019s description<\/code>.<\/p>\n
$ curl -i http:\/\/localhost:9200\/catalog\/books\/_search?pretty -d '\n{\n    \"query\": {\n        \"match\" : {\n            \"description\" : \"engine\"\n        }\n    }\n}'\n\nHTTP\/1.1 200 OK\ncontent-type: application\/json; charset=UTF-8\ncontent-length: 1271\n{\n  \"took\" : 17,\n  \"timed_out\" : false,\n  \"_shards\" : {\n    \"total\" : 5,\n    \"successful\" : 5,\n    \"failed\" : 0\n  },\n  \"hits\" : {\n    \"total\" : 1,\n    \"max_score\" : 0.28004453,\n    \"hits\" : [\n      {\n        \"_index\" : \"catalog\",\n        \"_type\" : \"books\",\n        \"_id\" : \"978-1449358549\",\n        \"_score\" : 0.28004453,\n        \"_source\" : {\n          \"title\" : \"Elasticsearch: The Definitive Guide. ...\",\n          \"categories\" : [\n            { \"name\" : \"analytics\" },\n            { \"name\" : \"search\" },\n            { \"name\" : \"database store\" }\n          ],\n          \"publisher\" : \"O'Reilly\",\n          \"description\" : \"Whether you need full-text ...\",\n          \"published_date\" : \"2015-02-07\",\n          \"isbn\" : \"978-1449358549\",\n          \"rating\" : 4\n        }\n      }\n    ]\n  }\n}\n<\/pre>\n
But the full text queries<\/a> are very powerful and have quite a few other variations, including match_phrase<\/a>, match_phrase_prefix<\/a>, \u00a0multi_match<\/a>, \u00a0common_terms<\/a>, \u00a0query_string<\/a> and simple_query_string<\/a>.<\/p>\n
Moving on, we are entering the world of term level queries<\/a> which operate on the exact terms and usually used for field types like numbers, dates, and keywords. The publisher<\/code> book field is a good candidate to try it out.<\/p>\n
$ curl -i http:\/\/localhost:9200\/catalog\/books\/_search?pretty -d '\n{\n   \"size\": 10,\n   \"_source\": [ \"title\" ],\n   \"query\": {\n        \"term\" : {\n            \"publisher\" : \"Manning\"\n        }\n    }\n}'  \n\nHTTP\/1.1 200 OK\ncontent-type: application\/json; charset=UTF-8\ncontent-length: 675\n\n{\n  \"took\" : 21,\n  \"timed_out\" : false,\n  \"_shards\" : {\n    \"total\" : 5,\n    \"successful\" : 5,\n    \"failed\" : 0\n  },\n  \"hits\" : {\n    \"total\" : 2,\n    \"max_score\" : 0.18232156,\n    \"hits\" : [\n      {\n        \"_index\" : \"catalog\",\n        \"_type\" : \"books\",\n        \"_id\" : \"978-1617291623\",\n        \"_score\" : 0.18232156,\n        \"_source\" : {\n          \"title\" : \"Elasticsearch in Action\"\n        }\n      },\n      {\n        \"_index\" : \"catalog\",\n        \"_type\" : \"books\",\n        \"_id\" : \"978-1617292774\",\n        \"_score\" : 0.18232156,\n        \"_source\" : {\n          \"title\" : \"Relevant Search: With applications ...\"\n        }\n      }\n    ]\n  }\n}\n<\/pre>\n
Please notice how we have limited the properties of document\u2019s _source<\/a> to return title<\/code> field only. The other variations of term level queries<\/a> include terms<\/a>, range<\/a>, exists<\/a>, prefix<\/a>, wildcard<\/a>, regexp<\/a>, fuzzy<\/a>, type<\/a> and ids<\/a>.<\/p>\n
Joining queries<\/a> are exceptionally interesting ones in the context of our book catalog<\/code> index. Those queries allow to perform the search against nested objects or documents with parent\/child relationship. For example, let us find out all the books in the analytics<\/code> category.<\/p>\n
$ curl -i http:\/\/localhost:9200\/catalog\/books\/_search?pretty -d '\n{\n   \"size\": 10,\n   \"_source\": [ \"title\", \"categories\" ],\n   \"query\": {\n        \"nested\": {\n            \"path\": \"categories\",\n            \"query\" : {\n                \"match\": {\n                    \"categories.name\" : \"analytics\"\n                }\n            }\n       }\n    }\n}'\n\nHTTP\/1.1 200 OK\ncontent-type: application\/json; charset=UTF-8\ncontent-length: 1177\n\n{\n  \"took\" : 45,\n  \"timed_out\" : false,\n  \"_shards\" : {\n    \"total\" : 5,\n    \"successful\" : 5,\n    \"failed\" : 0\n  },\n  \"hits\" : {\n    \"total\" : 2,\n    \"max_score\" : 1.3112576,\n    \"hits\" : [\n      {\n        \"_index\" : \"catalog\",\n        \"_type\" : \"books\",\n        \"_id\" : \"978-1617291623\",\n        \"_score\" : 1.3112576,\n        \"_source\" : {\n          \"categories\" : [\n            { \"name\" : \"analytics\" },\n            { \"name\" : \"search\" },\n            { \"name\" : \"database store\" }\n          ],\n          \"title\" : \"Elasticsearch in Action\"\n        }\n      },\n      {\n        \"_index\" : \"catalog\",\n        \"_type\" : \"books\",\n        \"_id\" : \"978-1449358549\",\n        \"_score\" : 1.0925692,\n        \"_source\" : {\n          \"categories\" : [\n            { \"name\" : \"analytics\" },\n            { \"name\" : \"search\" },\n            { \"name\" : \"database store\" }\n          ],\n          \"title\" : \"Elasticsearch: The Definitive Guide ...\"\n        }\n      }\n    ]\n  }\n} \n<\/pre>\n
Similarly, we could have searched for all the books authored by Clinton Gormley<\/a>, leveraging parent\/child relationships between books<\/code> and authors<\/code> collections.<\/p>\n
$ curl -i http:\/\/localhost:9200\/catalog\/books\/_search?pretty -d '\n{\n   \"size\": 10,\n   \"_source\": [ \"title\" ],\n   \"query\": {\n       \"has_child\" : {\n            \"type\" : \"authors\",\n            \"inner_hits\" : {\n                \"size\": 5\n            },\n            \"query\" : {\n                \"term\" : {\n                    \"last_name\" : \"Gormley\"\n                }\n            }\n        }\n    }\n}'\n\nHTTP\/1.1 200 OK\ncontent-type: application\/json; charset=UTF-8\ncontent-length: 1084\n\n{\n  \"took\" : 38,\n  \"timed_out\" : false,\n  \"_shards\" : {\n    \"total\" : 5,\n    \"successful\" : 5,\n    \"failed\" : 0\n  },\n  \"hits\" : {\n    \"total\" : 1,\n    \"max_score\" : 1.0,\n    \"hits\" : [\n      {\n        \"_index\" : \"catalog\",\n        \"_type\" : \"books\",\n        \"_id\" : \"978-1449358549\",\n        \"_score\" : 1.0,\n        \"_source\" : {\n          \"title\" : \"Elasticsearch: The Definitive Guide ...\"\n        },\n        \"inner_hits\" : {\n          \"authors\" : {\n            \"hits\" : {\n              \"total\" : 1,\n              \"max_score\" : 0.6931472,\n              \"hits\" : [\n                {\n                  \"_type\" : \"authors\",\n                  \"_id\" : \"1\",\n                  \"_score\" : 0.6931472,\n                  \"_routing\" : \"978-1449358549\",\n                  \"_parent\" : \"978-1449358549\",\n                  \"_source\" : {\n                    \"first_name\" : \"Clinton\",\n                    \"last_name\" : \"Gormley\"\n                  }\n                }\n              ]\n            }\n          }\n        }\n      }\n    ]\n  }\n}\n<\/pre>\n
Please pay attention to the presence of inner_hits<\/a> query parameter which let the search results to include the inner documents that matched the joining criteria.<\/p>\n
The other query types like Geo queries<\/a>, specialized queries<\/a> and span queries<\/a> work in a very similar way so we would just skip over them and finish up by looking into composite queries<\/a>. The examples we have seen so far included the queries with only one search criteria but Query DSL<\/a> has a way to construct the compound queries<\/a> as well. Let us take a look at the example of using bool <\/a>query which is the composition of some of the query types we have seen already.<\/p>\n
$ curl -i http:\/\/localhost:9200\/catalog\/books\/_search?pretty -d '\n{\n   \"size\": 10,\n   \"_source\": [ \"title\", \"publisher\" ],\n   \"query\": {\n       \"bool\" : {\n          \"must\" : [\n              {\n                  \"range\" : {\n                      \"rating\" : { \"gte\" : 4 }\n                  }\n              },\n              {\n                  \"has_child\" : {\n                      \"type\" : \"authors\",\n                      \"query\" : {\n                          \"term\" : {\n                              \"last_name\" : \"Gormley\"\n                          }\n                      }\n                  }\n              },\n              {\n                  \"nested\": {\n                      \"path\": \"categories\",\n                      \"query\" : {\n                          \"match\": {\n                              \"categories.name\" : \"search\"\n                          }\n                      }\n                  }\n              }\n          ]\n       }\n    }\n}'\n\nHTTP\/1.1 200 OK\ncontent-type: application\/json; charset=UTF-8\ncontent-length: 531\n\n{\n  \"took\" : 79,\n  \"timed_out\" : false,\n  \"_shards\" : {\n    \"total\" : 5,\n    \"successful\" : 5,\n    \"failed\" : 0\n  },\n  \"hits\" : {\n    \"total\" : 1,\n    \"max_score\" : 3.0925694,\n    \"hits\" : [\n      {\n        \"_index\" : \"catalog\",\n        \"_type\" : \"books\",\n        \"_id\" : \"978-1449358549\",\n        \"_score\" : 3.0925694,\n        \"_source\" : {\n          \"publisher\" : \"O'Reilly\",\n          \"title\" : \"Elasticsearch: The Definitive Guide.  ...\"\n        }\n      }\n    ]\n  }\n}\n<\/pre>\n
It would be fair to say that the search API<\/a> of Elasticsearch<\/a> powered by Query DSL<\/a> is exceptionally flexible, easy to use and expressive. More to that, it is worth to mention that additionally to queries the search API<\/a> also supports the concept of filters<\/a> which offer yet another option to exclude the document from the search results.<\/p>\n
<\/a>7. Mutations by Query<\/h2>\n
Surprisingly (or not), queries could be used by Elasticsearch<\/a> to perform mutations like updates<\/a> or deletes<\/a> over the documents in the index. For example, the following snippet will remove all the books which have low rating in our catalog, published by Manning<\/code>.<\/p>\n
$ curl -i http:\/\/localhost:9200\/catalog\/books\/_delete_by_query?pretty -d '\n{\n   \"query\": {\n      \"bool\": {\n          \"must\": [\n              { \"range\" : { \"rating\" : { \"lt\" : 3 } } }\n          ],\n          \"filter\": [\n             { \"term\" :  { \"publisher\" : \"Manning\" } }\n          ]\n      }\n   }\n}'\n\nHTTP\/1.1 200 OK\ncontent-type: application\/json; charset=UTF-8\ncontent-length: 296\n\n{\n  \"took\" : 12,\n  \"timed_out\" : false,\n  \"total\" : 0,\n  \"deleted\" : 0,\n  \"batches\" : 0,\n  \"version_conflicts\" : 0,\n  \"noops\" : 0,\n  \"retries\" : {\n    \"bulk\" : 0,\n    \"search\" : 0\n  },\n  \"throttled_millis\" : 0,\n  \"requests_per_second\" : -1.0,\n  \"throttled_until_millis\" : 0,\n  \"failures\" : [ ]\n}\n<\/pre>\n
It uses the same Query DSL<\/a> and, for the purpose of illustration of how filtering could be used, includes filter<\/code> as part of the query. But instead of returning the matched documents, the update or delete modifications are going to be applied.<\/p>\n
The delete by query API<\/a> could be used to overcome the limitations of regular delete API<\/a> and remove the child documents in case their parent is deleted.<\/p>\n
<\/a>8. Know Your Queries Better<\/h2>\n
Sometimes you may find out that your search queries are returning the documents in order you don\u2019t expect, ranking some documents higher than others. To help you out, Elasticsearch<\/a> provides two very helpful APIs. One of these is explain API<\/a>, which computes a score explanation for a query (and a specific document if needed).<\/p>\n
The explanation could be received by specifying the explain<\/code> parameter as part of query:<\/p>\n
$ curl -i http:\/\/localhost:9200\/catalog\/books\/_search?pretty -d '\n{\n   \"size\": 10,\n   \"explain\": true,\n   \"query\": {\n        \"term\" : {\n            \"publisher\" : \"Manning\"\n        }\n    }\n}\n<\/pre>\n
Or using dedicated explain API endpoint<\/a> and specific document, for example:<\/p>\n
$ curl -i http:\/\/localhost:9200\/catalog\/books\/978-1617292774\/_explain?pretty -d '\n{\n   \"query\": {\n        \"term\" : {\n            \"publisher\" : \"Manning\"\n        }\n    }\n}'\n<\/pre>\n
The responses have not been included intentionally as the tons of useful details are being returned. Another very useful feature of Elasticsearch<\/a> is validation API<\/a> which allows to perform a validation of the query without actually executing it, for example:<\/p>\n
$ curl -i http:\/\/localhost:9200\/catalog\/books\/_validate\/query?pretty -d ' {\n   \"query\": {\n        \"term\" : {\n            \"publisher\" : \"Manning\"\n        }\n    }                            \n}'\n\nHTTP\/1.1 200 OK\ncontent-type: application\/json; charset=UTF-8\ncontent-length: 98\n\n{\n  \"valid\" : true,\n  \"_shards\" : {\n    \"total\" : 1,\n    \"successful\" : 1,\n    \"failed\" : 0\n  }\n}\n<\/pre>\n
Both APIs are very useful to troubleshoot the relevance or analyze potentially impactful search query without executing it on a live Elasticsearch<\/a> cluster.<\/p>\n
<\/a>9. From Search to Insights<\/h2>\n
Often you may find yourself in the situation when the search is just not enough, you need some kind of aggregations on top of the matches. The great example would be faceting (or as Elasticsearch<\/a> calls it, terms aggregations<\/a>), where the search results are grouped into buckets.<\/p>\n
$ curl -i http:\/\/localhost:9200\/catalog\/books\/_search?pretty -d '\n{\n   \"query\": {\n        \"match\" : {\n            \"description\" : \"elasticsearch\"\n        }\n    },\n    \"aggs\" : {\n        \"publisher\" : {\n            \"terms\" : { \"field\" : \"publisher\" }\n        }\n    }\n}'\n\nHTTP\/1.1 200 OK\ncontent-type: application\/json; charset=UTF-8\ncontent-length: 3447\n\n{\n  \"took\" : 176,\n  \"timed_out\" : false,\n  \"_shards\" : {\n    \"total\" : 5,\n    \"successful\" : 5,\n    \"failed\" : 0\n  },\n  \"hits\" : {\n    \"total\" : 3,\n    \"max_score\" : 0.38828257,\n    \"hits\" : [\n      {\n          ...\n      }\n    ]\n  },\n  \"aggregations\" : {\n    \"publisher\" : {\n      \"doc_count_error_upper_bound\" : 0,\n      \"sum_other_doc_count\" : 0,\n      \"buckets\" : [\n        {\n          \"key\" : \"Manning\",\n          \"doc_count\" : 2\n        },\n        {\n          \"key\" : \"O'Reilly\",\n          \"doc_count\" : 1\n        }\n      ]\n    }\n  }\n}\n<\/pre>\n
In this example along with the search query, we have asked Elasticsearch<\/a> to count the documents by publishers. By and large, search query could be completely omitted and only aggregations could be sent in request body, for example:<\/p>\n
$ curl -i http:\/\/localhost:9200\/catalog\/books\/_search?pretty -d '\n{\n  \"aggs\" : {\n      \"authors\": {\n        \"children\": {\n          \"type\" : \"authors\"\n        },\n        \"aggs\": {\n          \"top-authors\": {\n            \"terms\": {\n            \"script\" : {\n              \"inline\": \"doc['first_name'].value + ' ' + doc['last_name'].value\",\n              \"lang\": \"painless\"\n            },\n            \"size\": 10\n          }\n        }\n      }\n    }\n  }\n}'\n\nHTTP\/1.1 200 OK\ncontent-type: application\/json; charset=UTF-8\ncontent-length: 1031\n{\n  \"took\": 381,\n  \"timed_out\": false,\n  \"_shards\": {\n    \"total\": 5,\n    \"successful\": 5,\n    \"failed\": 0\n  },\n  \"hits\": {\n    \"total\": 5,\n    \"max_score\": 1,\n    \"hits\": [\n      ...\n    ]\n  },\n  \"aggregations\": {\n    \"authors\": {\n      \"doc_count\": 6,\n      \"top-authors\": {\n        \"doc_count_error_upper_bound\": 0,\n        \"sum_other_doc_count\": 0,\n        \"buckets\": [\n          {\n            \"key\": \"Clinton Gormley\",\n            \"doc_count\": 1\n          },\n          {\n            \"key\": \"Doug Turnbull\",\n            \"doc_count\": 1\n          },\n          {\n            \"key\": \"Matthew Lee Hinman\",\n            \"doc_count\": 1\n          },\n          {\n            \"key\": \"Radu Gheorghe\",\n            \"doc_count\": 1\n          },\n          {\n            \"key\": \"Roy Russo\",\n            \"doc_count\": 1\n          },\n          {\n            \"key\": \"Zachary Tong\",\n            \"doc_count\": 1\n          }\n        ]\n      }\n    }\n  }\n}\n<\/pre>\n
In this slightly more complicated example we have bucketed over top authors using Elasticsearch<\/a> scripting support to compose the terms out of the author\u2019s first and last name:<\/p>\n
\"script\" : {                           \n  \"inline\": \"doc['first_name'].value + ' ' + doc['last_name'].value\",  \n  \"lang\": \"painless\"                 \n}\n<\/pre>\n
The list of supported aggregations<\/a> is really impressive and includes bucket aggregations<\/a> (some of those we have tried out already), metrics aggregations<\/a>, pipeline aggregations<\/a>, and matrix aggregations<\/a>. Covering just one class of those would need its own tutorial, so please check them out to understand the purpose of each one in depth.<\/p>\n
<\/a>10. Watch Your Cluster Breathing<\/h2>\n
Elasticsearch<\/a> clusters are living \u201ccreatures\u201d and should be watched and monitored closely in order to proactively spot any issues and react on them quickly. The cluster health endpoint<\/a> we have seen before is the easiest way to get overall high-level status of the cluster.<\/p>\n
$ http http:\/\/localhost:9200\/_cluster\/health\n\nHTTP\/1.1 200 OK\ncontent-encoding: gzip\ncontent-type: application\/json; charset=UTF-8\ntransfer-encoding: chunked\n\n{\n    \"active_primary_shards\": 5,\n    \"active_shards\": 5,\n    \"active_shards_percent_as_number\": 20.0,\n    \"cluster_name\": \"es-catalog\",\n    \"delayed_unassigned_shards\": 0,\n    \"initializing_shards\": 0,\n    \"number_of_data_nodes\": 1,\n    \"number_of_in_flight_fetch\": 0,\n    \"number_of_nodes\": 1,\n    \"number_of_pending_tasks\": 0,\n    \"relocating_shards\": 0,\n    \"status\": \"red\",\n    \"task_max_waiting_in_queue_millis\": 0,\n    \"timed_out\": false,\n    \"unassigned_shards\": 20\n}\n<\/pre>\n
If you cluster goes red<\/code> (like in the example above), there is certainly a problem to fix. To help you out, Elasticsearch<\/a> has cluster statistics API<\/a>, cluster state API<\/a>, cluster node level statistics API<\/a> and cluster node indices\u00a0 statistics API<\/a>.<\/p>\n
A bit aside stays another exceptionally important group of APIs, the cat APIs<\/a>. They are different in a sense that the representation is not in JSON<\/a> but rather text based, with compact and aligned output, suitable for terminals.<\/p>\n
<\/a>11. Conclusions<\/h2>\n
In this section of the tutorial we went through many features of the Elasticsearch<\/a> by exploring them through RESTful APIs<\/a>, using command line tools only. By and large, it is just a tiny part of what Elasticsearch<\/a> offers through the APIs and the official documentation<\/a> is a great place to learn them all. Hopefully, at this point we are comfortable enough with Elasticsearch<\/a> and know how to work with it.<\/p>\n
<\/a>12. What\u2019s next<\/h2>\n
In the next part of the tutorial<\/a> we are going to learn the several flavors of native APIs which Elasticsearch<\/a> has to offer to Java\/JVM developers. These APIs are the essential building blocks of any Java\/JVM application which leverages Elasticsearch<\/a> capabilities.<\/p>\n","protected":false},"excerpt":{"rendered":"
This article is part of our Academy Course titled Elasticsearch Tutorial for Java Developers. In this course, we provide a series of tutorials so that you can develop your own Elasticsearch based applications. We cover a wide range of topics, from installation and operations, to Java API Integration and reporting. With our straightforward tutorials, you …<\/p>\n","protected":false},"author":141,"featured_media":65382,"comment_status":"open","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[7],"tags":[732],"class_list":["post-64095","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-core-java","tag-elasticsearch"],"yoast_head":"\nElasticsearch for Java Developers: Elasticsearch from the command line - Java Code Geeks<\/title>\n<meta name=\"description\" content=\"This article is part of our Academy Course titled Elasticsearch Tutorial for Java Developers. In this course, we provide a series of tutorials so that you\" \/>\n<meta name=\"robots\" content=\"index, follow, max-snippet:-1, max-image-preview:large, max-video-preview:-1\" \/>\n<link rel=\"canonical\" href=\"https:\/\/www.javacodegeeks.com\/2017\/02\/elasticsearch-java-developers-elasticsearch-command-line.html\" \/>\n<meta property=\"og:locale\" content=\"en_US\" \/>\n<meta property=\"og:type\" content=\"article\" \/>\n<meta property=\"og:title\" content=\"Elasticsearch for Java Developers: Elasticsearch from the command line - Java Code Geeks\" \/>\n<meta property=\"og:description\" content=\"This article is part of our Academy Course titled Elasticsearch Tutorial for Java Developers. In this course, we provide a series of tutorials so that you\" \/>\n<meta property=\"og:url\" content=\"https:\/\/www.javacodegeeks.com\/2017\/02\/elasticsearch-java-developers-elasticsearch-command-line.html\" \/>\n<meta property=\"og:site_name\" content=\"Java Code Geeks\" \/>\n<meta property=\"article:publisher\" content=\"https:\/\/www.facebook.com\/javacodegeeks\" \/>\n<meta property=\"article:published_time\" content=\"2017-02-27T17:00:06+00:00\" \/>\n<meta property=\"article:modified_time\" content=\"2023-12-11T08:15:30+00:00\" \/>\n<meta property=\"og:image\" content=\"https:\/\/www.javacodegeeks.com\/wp-content\/uploads\/2017\/04\/elastic-logo.png\" \/>\n\t<meta property=\"og:image:width\" content=\"150\" \/>\n\t<meta property=\"og:image:height\" content=\"150\" \/>\n\t<meta property=\"og:image:type\" content=\"image\/png\" \/>\n<meta name=\"author\" content=\"Andrey Redko\" \/>\n<meta name=\"twitter:card\" content=\"summary_large_image\" \/>\n<meta name=\"twitter:creator\" content=\"@javacodegeeks\" \/>\n<meta name=\"twitter:site\" content=\"@javacodegeeks\" \/>\n<meta name=\"twitter:label1\" content=\"Written by\" \/>\n\t<meta name=\"twitter:data1\" content=\"Andrey Redko\" \/>\n\t<meta name=\"twitter:label2\" content=\"Est. reading time\" \/>\n\t<meta name=\"twitter:data2\" content=\"13 minutes\" \/>\n<script type=\"application\/ld+json\" class=\"yoast-schema-graph\">{\"@context\":\"https:\\\/\\\/schema.org\",\"@graph\":[{\"@type\":\"Article\",\"@id\":\"https:\\\/\\\/www.javacodegeeks.com\\\/2017\\\/02\\\/elasticsearch-java-developers-elasticsearch-command-line.html#article\",\"isPartOf\":{\"@id\":\"https:\\\/\\\/www.javacodegeeks.com\\\/2017\\\/02\\\/elasticsearch-java-developers-elasticsearch-command-line.html\"},\"author\":{\"name\":\"Andrey Redko\",\"@id\":\"https:\\\/\\\/www.javacodegeeks.com\\\/#\\\/schema\\\/person\\\/771a6504862edc45322776832cbce413\"},\"headline\":\"Elasticsearch for Java Developers: Elasticsearch from the command line\",\"datePublished\":\"2017-02-27T17:00:06+00:00\",\"dateModified\":\"2023-12-11T08:15:30+00:00\",\"mainEntityOfPage\":{\"@id\":\"https:\\\/\\\/www.javacodegeeks.com\\\/2017\\\/02\\\/elasticsearch-java-developers-elasticsearch-command-line.html\"},\"wordCount\":2792,\"commentCount\":2,\"publisher\":{\"@id\":\"https:\\\/\\\/www.javacodegeeks.com\\\/#organization\"},\"image\":{\"@id\":\"https:\\\/\\\/www.javacodegeeks.com\\\/2017\\\/02\\\/elasticsearch-java-developers-elasticsearch-command-line.html#primaryimage\"},\"thumbnailUrl\":\"https:\\\/\\\/www.javacodegeeks.com\\\/wp-content\\\/uploads\\\/2017\\\/04\\\/elastic-logo.png\",\"keywords\":[\"Elasticsearch\"],\"articleSection\":[\"Core Java\"],\"inLanguage\":\"en-US\",\"potentialAction\":[{\"@type\":\"CommentAction\",\"name\":\"Comment\",\"target\":[\"https:\\\/\\\/www.javacodegeeks.com\\\/2017\\\/02\\\/elasticsearch-java-developers-elasticsearch-command-line.html#respond\"]}]},{\"@type\":\"WebPage\",\"@id\":\"https:\\\/\\\/www.javacodegeeks.com\\\/2017\\\/02\\\/elasticsearch-java-developers-elasticsearch-command-line.html\",\"url\":\"https:\\\/\\\/www.javacodegeeks.com\\\/2017\\\/02\\\/elasticsearch-java-developers-elasticsearch-command-line.html\",\"name\":\"Elasticsearch for Java Developers: Elasticsearch from the command line - Java Code Geeks\",\"isPartOf\":{\"@id\":\"https:\\\/\\\/www.javacodegeeks.com\\\/#website\"},\"primaryImageOfPage\":{\"@id\":\"https:\\\/\\\/www.javacodegeeks.com\\\/2017\\\/02\\\/elasticsearch-java-developers-elasticsearch-command-line.html#primaryimage\"},\"image\":{\"@id\":\"https:\\\/\\\/www.javacodegeeks.com\\\/2017\\\/02\\\/elasticsearch-java-developers-elasticsearch-command-line.html#primaryimage\"},\"thumbnailUrl\":\"https:\\\/\\\/www.javacodegeeks.com\\\/wp-content\\\/uploads\\\/2017\\\/04\\\/elastic-logo.png\",\"datePublished\":\"2017-02-27T17:00:06+00:00\",\"dateModified\":\"2023-12-11T08:15:30+00:00\",\"description\":\"This article is part of our Academy Course titled Elasticsearch Tutorial for Java Developers. In this course, we provide a series of tutorials so that you\",\"breadcrumb\":{\"@id\":\"https:\\\/\\\/www.javacodegeeks.com\\\/2017\\\/02\\\/elasticsearch-java-developers-elasticsearch-command-line.html#breadcrumb\"},\"inLanguage\":\"en-US\",\"potentialAction\":[{\"@type\":\"ReadAction\",\"target\":[\"https:\\\/\\\/www.javacodegeeks.com\\\/2017\\\/02\\\/elasticsearch-java-developers-elasticsearch-command-line.html\"]}]},{\"@type\":\"ImageObject\",\"inLanguage\":\"en-US\",\"@id\":\"https:\\\/\\\/www.javacodegeeks.com\\\/2017\\\/02\\\/elasticsearch-java-developers-elasticsearch-command-line.html#primaryimage\",\"url\":\"https:\\\/\\\/www.javacodegeeks.com\\\/wp-content\\\/uploads\\\/2017\\\/04\\\/elastic-logo.png\",\"contentUrl\":\"https:\\\/\\\/www.javacodegeeks.com\\\/wp-content\\\/uploads\\\/2017\\\/04\\\/elastic-logo.png\",\"width\":150,\"height\":150},{\"@type\":\"BreadcrumbList\",\"@id\":\"https:\\\/\\\/www.javacodegeeks.com\\\/2017\\\/02\\\/elasticsearch-java-developers-elasticsearch-command-line.html#breadcrumb\",\"itemListElement\":[{\"@type\":\"ListItem\",\"position\":1,\"name\":\"Home\",\"item\":\"https:\\\/\\\/www.javacodegeeks.com\\\/\"},{\"@type\":\"ListItem\",\"position\":2,\"name\":\"Java\",\"item\":\"https:\\\/\\\/www.javacodegeeks.com\\\/category\\\/java\"},{\"@type\":\"ListItem\",\"position\":3,\"name\":\"Core Java\",\"item\":\"https:\\\/\\\/www.javacodegeeks.com\\\/category\\\/java\\\/core-java\"},{\"@type\":\"ListItem\",\"position\":4,\"name\":\"Elasticsearch for Java Developers: Elasticsearch from the command line\"}]},{\"@type\":\"WebSite\",\"@id\":\"https:\\\/\\\/www.javacodegeeks.com\\\/#website\",\"url\":\"https:\\\/\\\/www.javacodegeeks.com\\\/\",\"name\":\"Java Code Geeks\",\"description\":\"Java Developers Resource Center\",\"publisher\":{\"@id\":\"https:\\\/\\\/www.javacodegeeks.com\\\/#organization\"},\"alternateName\":\"JCG\",\"potentialAction\":[{\"@type\":\"SearchAction\",\"target\":{\"@type\":\"EntryPoint\",\"urlTemplate\":\"https:\\\/\\\/www.javacodegeeks.com\\\/?s={search_term_string}\"},\"query-input\":{\"@type\":\"PropertyValueSpecification\",\"valueRequired\":true,\"valueName\":\"search_term_string\"}}],\"inLanguage\":\"en-US\"},{\"@type\":\"Organization\",\"@id\":\"https:\\\/\\\/www.javacodegeeks.com\\\/#organization\",\"name\":\"Exelixis Media P.C.\",\"url\":\"https:\\\/\\\/www.javacodegeeks.com\\\/\",\"logo\":{\"@type\":\"ImageObject\",\"inLanguage\":\"en-US\",\"@id\":\"https:\\\/\\\/www.javacodegeeks.com\\\/#\\\/schema\\\/logo\\\/image\\\/\",\"url\":\"https:\\\/\\\/www.javacodegeeks.com\\\/wp-content\\\/uploads\\\/2022\\\/06\\\/exelixis-logo.png\",\"contentUrl\":\"https:\\\/\\\/www.javacodegeeks.com\\\/wp-content\\\/uploads\\\/2022\\\/06\\\/exelixis-logo.png\",\"width\":864,\"height\":246,\"caption\":\"Exelixis Media P.C.\"},\"image\":{\"@id\":\"https:\\\/\\\/www.javacodegeeks.com\\\/#\\\/schema\\\/logo\\\/image\\\/\"},\"sameAs\":[\"https:\\\/\\\/www.facebook.com\\\/javacodegeeks\",\"https:\\\/\\\/x.com\\\/javacodegeeks\"]},{\"@type\":\"Person\",\"@id\":\"https:\\\/\\\/www.javacodegeeks.com\\\/#\\\/schema\\\/person\\\/771a6504862edc45322776832cbce413\",\"name\":\"Andrey Redko\",\"image\":{\"@type\":\"ImageObject\",\"inLanguage\":\"en-US\",\"@id\":\"https:\\\/\\\/secure.gravatar.com\\\/avatar\\\/16419ce8394173028eddaeb992859862bab50cfcf74589fa9bb9a3dd8bb27518?s=96&d=mm&r=g\",\"url\":\"https:\\\/\\\/secure.gravatar.com\\\/avatar\\\/16419ce8394173028eddaeb992859862bab50cfcf74589fa9bb9a3dd8bb27518?s=96&d=mm&r=g\",\"contentUrl\":\"https:\\\/\\\/secure.gravatar.com\\\/avatar\\\/16419ce8394173028eddaeb992859862bab50cfcf74589fa9bb9a3dd8bb27518?s=96&d=mm&r=g\",\"caption\":\"Andrey Redko\"},\"description\":\"Andriy is a well-grounded software developer with more then 12 years of practical experience using Java\\\/EE, C#\\\/.NET, C++, Groovy, Ruby, functional programming (Scala), databases (MySQL, PostgreSQL, Oracle) and NoSQL solutions (MongoDB, Redis).\",\"sameAs\":[\"http:\\\/\\\/aredko.blogspot.com\\\/\",\"http:\\\/\\\/ca.linkedin.com\\\/in\\\/aredko\"],\"url\":\"https:\\\/\\\/www.javacodegeeks.com\\\/author\\\/andrey-redko\"}]}<\/script>\n<!-- \/ Yoast SEO plugin. -->","yoast_head_json":{"title":"Elasticsearch for Java Developers: Elasticsearch from the command line - Java Code Geeks","description":"This article is part of our Academy Course titled Elasticsearch Tutorial for Java Developers. In this course, we provide a series of tutorials so that you","robots":{"index":"index","follow":"follow","max-snippet":"max-snippet:-1","max-image-preview":"max-image-preview:large","max-video-preview":"max-video-preview:-1"},"canonical":"https:\/\/www.javacodegeeks.com\/2017\/02\/elasticsearch-java-developers-elasticsearch-command-line.html","og_locale":"en_US","og_type":"article","og_title":"Elasticsearch for Java Developers: Elasticsearch from the command line - Java Code Geeks","og_description":"This article is part of our Academy Course titled Elasticsearch Tutorial for Java Developers. In this course, we provide a series of tutorials so that you","og_url":"https:\/\/www.javacodegeeks.com\/2017\/02\/elasticsearch-java-developers-elasticsearch-command-line.html","og_site_name":"Java Code Geeks","article_publisher":"https:\/\/www.facebook.com\/javacodegeeks","article_published_time":"2017-02-27T17:00:06+00:00","article_modified_time":"2023-12-11T08:15:30+00:00","og_image":[{"width":150,"height":150,"url":"https:\/\/www.javacodegeeks.com\/wp-content\/uploads\/2017\/04\/elastic-logo.png","type":"image\/png"}],"author":"Andrey Redko","twitter_card":"summary_large_image","twitter_creator":"@javacodegeeks","twitter_site":"@javacodegeeks","twitter_misc":{"Written by":"Andrey Redko","Est. reading time":"13 minutes"},"schema":{"@context":"https:\/\/schema.org","@graph":[{"@type":"Article","@id":"https:\/\/www.javacodegeeks.com\/2017\/02\/elasticsearch-java-developers-elasticsearch-command-line.html#article","isPartOf":{"@id":"https:\/\/www.javacodegeeks.com\/2017\/02\/elasticsearch-java-developers-elasticsearch-command-line.html"},"author":{"name":"Andrey Redko","@id":"https:\/\/www.javacodegeeks.com\/#\/schema\/person\/771a6504862edc45322776832cbce413"},"headline":"Elasticsearch for Java Developers: Elasticsearch from the command line","datePublished":"2017-02-27T17:00:06+00:00","dateModified":"2023-12-11T08:15:30+00:00","mainEntityOfPage":{"@id":"https:\/\/www.javacodegeeks.com\/2017\/02\/elasticsearch-java-developers-elasticsearch-command-line.html"},"wordCount":2792,"commentCount":2,"publisher":{"@id":"https:\/\/www.javacodegeeks.com\/#organization"},"image":{"@id":"https:\/\/www.javacodegeeks.com\/2017\/02\/elasticsearch-java-developers-elasticsearch-command-line.html#primaryimage"},"thumbnailUrl":"https:\/\/www.javacodegeeks.com\/wp-content\/uploads\/2017\/04\/elastic-logo.png","keywords":["Elasticsearch"],"articleSection":["Core Java"],"inLanguage":"en-US","potentialAction":[{"@type":"CommentAction","name":"Comment","target":["https:\/\/www.javacodegeeks.com\/2017\/02\/elasticsearch-java-developers-elasticsearch-command-line.html#respond"]}]},{"@type":"WebPage","@id":"https:\/\/www.javacodegeeks.com\/2017\/02\/elasticsearch-java-developers-elasticsearch-command-line.html","url":"https:\/\/www.javacodegeeks.com\/2017\/02\/elasticsearch-java-developers-elasticsearch-command-line.html","name":"Elasticsearch for Java Developers: Elasticsearch from the command line - Java Code Geeks","isPartOf":{"@id":"https:\/\/www.javacodegeeks.com\/#website"},"primaryImageOfPage":{"@id":"https:\/\/www.javacodegeeks.com\/2017\/02\/elasticsearch-java-developers-elasticsearch-command-line.html#primaryimage"},"image":{"@id":"https:\/\/www.javacodegeeks.com\/2017\/02\/elasticsearch-java-developers-elasticsearch-command-line.html#primaryimage"},"thumbnailUrl":"https:\/\/www.javacodegeeks.com\/wp-content\/uploads\/2017\/04\/elastic-logo.png","datePublished":"2017-02-27T17:00:06+00:00","dateModified":"2023-12-11T08:15:30+00:00","description":"This article is part of our Academy Course titled Elasticsearch Tutorial for Java Developers. In this course, we provide a series of tutorials so that you","breadcrumb":{"@id":"https:\/\/www.javacodegeeks.com\/2017\/02\/elasticsearch-java-developers-elasticsearch-command-line.html#breadcrumb"},"inLanguage":"en-US","potentialAction":[{"@type":"ReadAction","target":["https:\/\/www.javacodegeeks.com\/2017\/02\/elasticsearch-java-developers-elasticsearch-command-line.html"]}]},{"@type":"ImageObject","inLanguage":"en-US","@id":"https:\/\/www.javacodegeeks.com\/2017\/02\/elasticsearch-java-developers-elasticsearch-command-line.html#primaryimage","url":"https:\/\/www.javacodegeeks.com\/wp-content\/uploads\/2017\/04\/elastic-logo.png","contentUrl":"https:\/\/www.javacodegeeks.com\/wp-content\/uploads\/2017\/04\/elastic-logo.png","width":150,"height":150},{"@type":"BreadcrumbList","@id":"https:\/\/www.javacodegeeks.com\/2017\/02\/elasticsearch-java-developers-elasticsearch-command-line.html#breadcrumb","itemListElement":[{"@type":"ListItem","position":1,"name":"Home","item":"https:\/\/www.javacodegeeks.com\/"},{"@type":"ListItem","position":2,"name":"Java","item":"https:\/\/www.javacodegeeks.com\/category\/java"},{"@type":"ListItem","position":3,"name":"Core Java","item":"https:\/\/www.javacodegeeks.com\/category\/java\/core-java"},{"@type":"ListItem","position":4,"name":"Elasticsearch for Java Developers: Elasticsearch from the command line"}]},{"@type":"WebSite","@id":"https:\/\/www.javacodegeeks.com\/#website","url":"https:\/\/www.javacodegeeks.com\/","name":"Java Code Geeks","description":"Java Developers Resource Center","publisher":{"@id":"https:\/\/www.javacodegeeks.com\/#organization"},"alternateName":"JCG","potentialAction":[{"@type":"SearchAction","target":{"@type":"EntryPoint","urlTemplate":"https:\/\/www.javacodegeeks.com\/?s={search_term_string}"},"query-input":{"@type":"PropertyValueSpecification","valueRequired":true,"valueName":"search_term_string"}}],"inLanguage":"en-US"},{"@type":"Organization","@id":"https:\/\/www.javacodegeeks.com\/#organization","name":"Exelixis Media P.C.","url":"https:\/\/www.javacodegeeks.com\/","logo":{"@type":"ImageObject","inLanguage":"en-US","@id":"https:\/\/www.javacodegeeks.com\/#\/schema\/logo\/image\/","url":"https:\/\/www.javacodegeeks.com\/wp-content\/uploads\/2022\/06\/exelixis-logo.png","contentUrl":"https:\/\/www.javacodegeeks.com\/wp-content\/uploads\/2022\/06\/exelixis-logo.png","width":864,"height":246,"caption":"Exelixis Media P.C."},"image":{"@id":"https:\/\/www.javacodegeeks.com\/#\/schema\/logo\/image\/"},"sameAs":["https:\/\/www.facebook.com\/javacodegeeks","https:\/\/x.com\/javacodegeeks"]},{"@type":"Person","@id":"https:\/\/www.javacodegeeks.com\/#\/schema\/person\/771a6504862edc45322776832cbce413","name":"Andrey Redko","image":{"@type":"ImageObject","inLanguage":"en-US","@id":"https:\/\/secure.gravatar.com\/avatar\/16419ce8394173028eddaeb992859862bab50cfcf74589fa9bb9a3dd8bb27518?s=96&d=mm&r=g","url":"https:\/\/secure.gravatar.com\/avatar\/16419ce8394173028eddaeb992859862bab50cfcf74589fa9bb9a3dd8bb27518?s=96&d=mm&r=g","contentUrl":"https:\/\/secure.gravatar.com\/avatar\/16419ce8394173028eddaeb992859862bab50cfcf74589fa9bb9a3dd8bb27518?s=96&d=mm&r=g","caption":"Andrey Redko"},"description":"Andriy is a well-grounded software developer with more then 12 years of practical experience using Java\/EE, C#\/.NET, C++, Groovy, Ruby, functional programming (Scala), databases (MySQL, PostgreSQL, Oracle) and NoSQL solutions (MongoDB, Redis).","sameAs":["http:\/\/aredko.blogspot.com\/","http:\/\/ca.linkedin.com\/in\/aredko"],"url":"https:\/\/www.javacodegeeks.com\/author\/andrey-redko"}]}},"_links":{"self":[{"href":"https:\/\/www.javacodegeeks.com\/wp-json\/wp\/v2\/posts\/64095","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/www.javacodegeeks.com\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/www.javacodegeeks.com\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/www.javacodegeeks.com\/wp-json\/wp\/v2\/users\/141"}],"replies":[{"embeddable":true,"href":"https:\/\/www.javacodegeeks.com\/wp-json\/wp\/v2\/comments?post=64095"}],"version-history":[{"count":0,"href":"https:\/\/www.javacodegeeks.com\/wp-json\/wp\/v2\/posts\/64095\/revisions"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/www.javacodegeeks.com\/wp-json\/wp\/v2\/media\/65382"}],"wp:attachment":[{"href":"https:\/\/www.javacodegeeks.com\/wp-json\/wp\/v2\/media?parent=64095"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.javacodegeeks.com\/wp-json\/wp\/v2\/categories?post=64095"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.javacodegeeks.com\/wp-json\/wp\/v2\/tags?post=64095"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}