Elasticsearch 5.x Cookbook

Elasticsearch 5.x Cookbook - Third Edition

By : Alberto Paro

Buy this Book

Elasticsearch 5.x Cookbook - Third Edition

By: Alberto Paro

Buy this Book

Overview of this book

Elasticsearch is a Lucene-based distributed search server that allows users to index and search unstructured content with petabytes of data. This book is your one-stop guide to master the complete Elasticsearch ecosystem. We’ll guide you through comprehensive recipes on what’s new in Elasticsearch 5.x, showing you how to create complex queries and analytics, and perform index mapping, aggregation, and scripting. Further on, you will explore the modules of Cluster and Node monitoring and see ways to back up and restore a snapshot of an index. You will understand how to install Kibana to monitor a cluster and also to extend Kibana for plugins. Finally, you will also see how you can integrate your Java, Scala, Python, and Big Data applications such as Apache Spark and Pig with Elasticsearch, and add enhanced functionalities with custom plugins. By the end of this book, you will have an in-depth knowledge of the implementation of the Elasticsearch architecture and will be able to manage data efficiently and effectively with Elasticsearch.

Credits

About the Author

About the Reviewer

www.PacktPub.com

Customer Feedback

Dedication

Preface

Free Chapter

Getting Started

Introduction

Understanding node and cluster

Understanding node services

Managing your data

Understanding cluster, replication, and sharding

Communicating with Elasticsearch

Using the HTTP protocol

Using the native protocol

Downloading and Setup

Introduction

Downloading and installing Elasticsearch

Setting up networking

Setting up a node

Setting up for Linux systems

Setting up different node types

Setting up a client node

Setting up an ingestion node

Installing plugins in Elasticsearch

Installing plugins manually

Removing a plugin

Changing logging settings

Setting up a node via Docker

Managing Mappings

Introduction

Using explicit mapping creation

Using dynamic templates in document mapping

Managing nested objects

Managing child document

Adding a field with multiple mapping

Mapping a GeoPoint field

Mapping a GeoShape field

Mapping an IP field

Mapping an attachment field

Adding metadata to a mapping

Specifying a different analyzer

Mapping a completion field

Basic Operations

Introduction

Creating an index

Deleting an index

Opening/closing an index

Putting a mapping in an index

Checking if an index or type exists

Managing index settings

Speeding up atomic operations (bulk operations)

Speeding up GET operations (multi GET)

Executing a scrolling query

Using the search_after functionality

Returning inner hits in results

Suggesting a correct query

Counting matched results

Matching all the documents

Using a boolean query

Text and Numeric Queries

Using a wildcard query

Using a regexp query

Using span queries

Using a match query

Using a query string query

Using a simple query string query

Using the range query

The common terms query

Using IDs query

Using the function score query

Using the exists query

Using the template query

Relationships and Geo Queries

Introduction

Using the has_child query

Using the has_parent query

Using nested queries

Using the geo_bounding_box query

Using the geo_polygon query

Using the geo_distance query

Using the geo_distance_range query

Aggregations

Introduction

Executing an aggregation

Executing stats aggregations

Executing terms aggregation

Executing significant terms aggregation

Executing range aggregations

Executing histogram aggregations

Executing date histogram aggregations

Executing filter aggregations

Executing filters aggregations

Executing global aggregations

Executing geo distance aggregations

Executing children aggregations

Executing nested aggregations

Executing top hit aggregations

Executing a matrix stats aggregation

Executing geo bounds aggregations

Executing geo centroid aggregations

Scripting

Introduction

Painless scripting

Installing additional script plugins

Managing scripts

Sorting data using scripts

Computing return fields with scripting

Filtering a search via scripting

Using scripting in aggregations

Updating a document using scripts

Reindexing with a script

Managing Clusters and Nodes

Introduction

Controlling cluster health via an API

Controlling cluster state via an API

Getting nodes information via API

Getting node statistics via the API

Using the task management API

Hot thread API

Managing the shard allocation

Monitoring segments with the segment API

Cleaning the cache

Backup and Restore

Introduction

Managing repositories

Executing a snapshot

Restoring a snapshot

Setting up a NFS share for backup

Reindexing from a remote cluster

User Interfaces

Introduction

Installing and using Cerebro

Installing Kibana and X-Pack

Managing Kibana dashboards

Monitoring with Kibana

Using Kibana dev-console

Visualizing data with Kibana

Installing Kibana plugins

Generating graph with Kibana

Ingest

Introduction

Pipeline definition

Put an ingest pipeline

Get an ingest pipeline

Delete an ingest pipeline

Simulate an ingest pipeline

Built-in processors

Grok processor

Using the ingest attachment plugin

Using the ingest GeoIP plugin

Java Integration

Introduction

Creating a standard Java HTTP client

Creating an HTTP Elasticsearch client

Creating a native client

Managing indices with the native client

Managing mappings

Managing documents

Managing bulk actions

Building a query

Executing a standard search

Executing a search with aggregations

Executing a scroll search

Scala Integration

Introduction

Creating a client in Scala

Managing indices

Managing mappings

Managing documents

Executing a standard search

Executing a search with aggregations

Python Integration

Introduction

Creating a client

Managing indices

Managing mappings include the mapping

Managing documents

Executing a standard search

Executing a search with aggregations

Plugin Development

Introduction

Creating a plugin

Creating an analyzer plugin

Creating a REST plugin

Creating a cluster action

Creating an ingest plugin

Big Data Integration

Introduction

Installing Apache Spark

Indexing data via Apache Spark

Indexing data with meta via Apache Spark

Reading data with Apache Spark

Reading data using SparkSQL

Indexing data with Apache Pig

Customer Reviews

5 star

4 star

3 star

2 star

1 star

Using the native protocol

Elasticsearch provides a native protocol, used mainly for low-level communication between nodes, but is very useful for fast importing of huge data blocks. This protocol is available only for JVM languages and is commonly used in Java, Groovy, and Scala.

Getting ready

You need a working Elasticsearch cluster--the standard port for native protocol is 9300.

How to do it...

The steps required to use the native protocol in a Java environment are as follows (in Chapter 14, Java Integration we'll discuss it in detail):

Before starting, we must be sure that Maven loads the Elasticsearch JAR adding to the pom.xml lines:

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

Depending on Elasticsearch JAR, creating a Java client, it's quite easy:

        import org.elasticsearch.common.settings.Settings; 
        import org.elasticsearch.client.Client; 
        import org.elasticsearch.client.transport.TransportClient; 
        ... 
        Settings settings = Settings.settingsBuilder() 
        .put("client.transport.sniff", true).build(); 
         // we define a new settings 
         // using sniff transport allows to autodetect other nodes 
        Client client = TransportClient.builder()
        .settings(settings).build().addTransportAddress
        (new InetSocketTransportAddress("127.0.0.1", 9300)); 
        // a client is created with the settings

How it works...

To initialize a native client, some settings are required to properly configure it. The important ones are:

cluster.name: It is the name of the cluster
client.transport.sniff: It allows to sniff the rest of the cluster topology and adds discovered nodes into the client list of machines to use

With these settings, it's possible to initialize a new client giving an IP address and port (default 9300).

There's more...

This is the internal protocol used in Elasticsearch: it's the fastest protocol available to talk with Elasticsearch.

The native protocol is an optimized binary one and works only for JVM languages. To use this protocol, you need to include elasticsearch.jar in your JVM project. Because it depends on Elasticsearch implementation, it must be the same version of the Elasticsearch cluster.

Note

Every time you update Elasticsearch, you need to update the elasticsearch.jar on which it depends, and if there are internal API changes, you need to update your code.

To use this protocol, you also need to study the internals of Elasticsearch, so it's not so easy to use as HTTP protocol.

Native protocol is very useful for massive data import. But as Elasticsearch is mainly thought as a REST HTTP server to communicate with, it lacks support for everything is not standard in Elasticsearch core, such as plugins entry points. Using this protocol, you are unable to call entry points made by external plugins in an easy way.

Note

The native protocol seems easier to integrate in a Java/JVN project, but due to its nature that follows the fast release cycles of Elasticsearch, its API could change often even for minor release upgrades and your code will be broken.

Elasticsearch 5.x Cookbook - Third Edition

By : Alberto Paro

Elasticsearch 5.x Cookbook - Third Edition

By: Alberto Paro

Overview of this book

Related Content you might be interested in

Current Title:

Elasticsearch 5.x Cookbook - Third Edition

Mastering Elasticsearch 5.x

Learning Elasticsearch

Elasticsearch 7 Quick Start Guide

Using the native protocol

Getting ready

How to do it...

How it works...

There's more...

Note

Note

See also