- concepts
- documents
- indexes
- mappings
- features
- administration
- scaling
- optimizing
- caveats
docker pull docker.elastic.co/elasticsearch/elasticsearch:5.5.0
docker run -p 9200:9200 -e "http.host=0.0.0.0" -e "transport.host=127.0.0.1" docker.elastic.co/elasticsearch/elasticsearch:5.5.0
curl -u elastic http://127.0.0.1:9200/_cat/health
Enter host password for user 'elastic': changeme
curl -XPUT -u elastic 'localhost:9200/_xpack/security/user/elastic/_password' -H "Content-Type: application/json" -d '{"password" : "elasticpassword"}'
- 1 Getting started with the elasticsearch cluster
- Full-text searching
- The basic of elasticsearch
- Installing and configuring your cluster
- Manipulating your data with the REST API
- 2 Indexing your data
- Elasticsearch indexing
- Mappings configuration
- Batch indexing to speed up your indexing process
- Extending your index structure with additional internal information
- 3 Searching your data
- Querying elasticsearch
- Understanding the query process
- Basic queries
- Compound queries
- Filtering your results
- Highlighting
- Validating your queries
- Sorting data
- Query retwrite
- 4 Extending your index structure
- Indexing tree-like structures
- Indexing data that is not flat
- Using nested objects
- Using the parent-child relationship
- Modifying your index structure with the update api
- 5 Make your search better
- An introduction to Apache Lucene scoring
- Scripting capabilities of Elasticsearch
- Searching content in different languages
- Influencing scores qith query boosts
- When does index-time boosting make sense?
- Words with the same meaning
- Understanding the explain information
- 6 Beyond full text searching
- Aggregations
- Faceting
- Using suggesters
- Percolator
- Handling files
- Geo
- The scroll API
- The terms filter
- 7 Elasticsearch cluster in detail
- Node discovery
- The gateway and recovery modules
- Preparing elasticsearch cluster for high query and indexing throughput
- Templates and dynamic types
- 8 Administrating your cluster
- The elasticsearch time machine
- Monitoring your cluster's state and health
- Controlling cluster rebalancing
- Controlling the shard and replica allocation
- Warming up
- Index aliasing and using it to simplify your everyday work
- Elasticsearch plugins
- The update setting API
- 1 Introducing Elasticsearch
- Solving search problesm
- Exploring typical Elasticsearch use cases
- 2 Diving into functionality
- Understanding the logical layout: documents, types and indices
- Understanding the physical layoutL: nodes and shards
- Indexing new data
- Searching and retrieving data
- Configuring elasticsearch
- Adding nodes to the cluster
- 3 Indexing, updating and deleting data
- Using mappings to define kinds of documents
- Core types for defining your own fields in documents
- Arrays and multi-fields
- Using predefined fields
- Updating predefined fields
- Updating existing documents
- Deleting data
- 4 Searching your data
- Structure of a search request
- Introducing the query and filter DSL
- Combining queries or compound queries
- Beyond match and queries
- Querying for field existence with filters
- 5 Analyzing your data
- What is analysis
- Using analyzers for your documents
- Analyzing text with the analyze API
- Analyzers, tokenizers, and token filters, oh my!
- Ngrams, edge ngrams, and shingles
- Stemming
- 6 Searching with relevancy
- How scoring works in Elasticsearch
- Other scoring methods
- Boosting
- Understanding how a document was scored with explain
- Reducing scoring impact with query rescoring
- Custom scoring with function_score
- Tying it back together
- Sorting with scripts
- Field data detour
- 7 Exploring your data with aggregations
- Understanding the anatomy of an aggregation
- Metrics aggregations
- Multi-bucket aggregations
- Nesting aggregrations
- 8 Relations among documents
- Overview of options for defining relationships among documents
- Having objects as field values
- Nested type: connecting nested documents
- Parent-child relationships: connecting separate documents
- Denormalizing: using redundant data connections
- Application-side joins
- 9 Scaling out
- Addind nodes to your elasticsearch cluster
- Discovering other Elasticsearch nodes
- Removing nodes from a cluster
- Upgrading Elasticsearch nodes
- Using the _cat API
- Scaling strategies
- Aliases
- Routing
- 10 Improving performance
- Grouping requests
- Optimizing the handling of Lucene segments
- Making the best use of caches
- Other performance tradeoffs
- 11 Administrating your cluster
- Improving defaults
- Allocation awareness
- Monitoring for bottlenecks
- Backing up your date
- 1 Getting started
- Introduction
- Understanding nodes and clusters
- Understanding node services
- Managing your data
- Understanding clusters, replication, sharding
- Communication with Elasticsearch
- Using the HTTP protocol
- Using the native protocol
- Using the thrift protocol
- 2 Downloading and Setting Up
- Introduction
- Downloading and installing Elasticsearch
- Setting up networking
- Setting up a node
- Setting up for linux systems
- Setting up different node types
- Installing plugins in Elasticsearch
- Installing a plugin manually
- Removing a plugin
- Changing logging settings
- 3 Managing mapping
- Introduction
- Using explicit mapping creation
- Mapping base types
- Mapping arrays
- Mapping an object
- Mapping a document
- Using dynamic templates in document mapping
- Managing nested objects
- Managing a child document
- Adding a field with multiple mappings
- Mapping a geo point field
- Mapping a geo shape field
- Mapping an IP field
- Mapping an attachment field
- Adding metadata to a mapping
- Specifying a different analyzer
- Mapping a completion suggester
- 4 Basic operations
- Introduction
- Creating an index
- Deleting an index
- Opening/closing an index
- Putting a mapping in an index
- Getting a mapping
- Deleting a mapping
- Refreshing an index
- Flushing an index
- Optimizing an index
- Checking if an index or type exists
- Managing index settings
- Using index aliases
- Indexing a document
- Updating a document
- Speeding up atomic operations
- Speeding up GET operations
- 5 Search, Queries, and Filters
- Introduction
- Executing a search
- Sorting results
- Highlighting results
- Executing a scan query
- Suggesting a correct query
- Counting matched results
- Deleting by query
- Matching all the documents
- Querying/filtering for a single term
- Querying/filtering for multiple terms
- Using a prefix query/filter
- Using a boolean query/filter
- Using a range query/filter
- Using span queries
- Using a match query
- Using an ID query/filter
- Using a has_child query/filter
- Using a top_children query
- Using a has_parent query/filter
- Using a regexp query/filter
- Using a function score query
- Using exists and missing filters
- Using and/or/not filters
- Using a geo bounding box filter
- Using a geo polygon filter
- Using a geo distance filter
- Using a querystring filter
- Using a template query
- 6 Aggregations
- Introduction
- Executing an aggregation
- Executing a stats aggregation
- Executing the terms aggregation
- Executing the range aggregation
- Executing the histogram aggregation
- Execution the date histogram aggregation
- Execution the filter aggregation
- 1 Introduction to Elasticsearch
- Introducing Apache Lucene
- Introducing Elasticsearch
- 2 Power User Query DSL
- Default Apache Lucene scorings explained
- Query rewrite explained
- Rescore
- Bulk operations
- Sorting data
- Update API
- Using filters to optimize your queries
- Filters and scopes in Elasticsearch faceting mechanism
- 3 Low-level index control
- Altering apache lucene scoring
- Similarity model configuration
- Using codecs
- NRT, flush, refresh, and transaction log
- Looking deeper into data handling
- Segment merging under control
- 4 Index Distribution Architecture
- Choosing the right amount of shards and replicas
- Routing explained
- Altering the default shard allocation behaviour
- Adjusting shard allocation
- Query execution performance
- Using our knowledge
- 5 Elasticsearch Administration
- Choosing the right directory implementation - the store module
- Discovery configuration
- Segments statistics
- Understaning Elasticsearch caching
- 6 Fighting with fire
- Knowing the garbage collector
- When it is too much for I/O - throttling explained
- Speeding up queries using warmers
- Very hot threads
- Real-life scenarios
- 7 Improving the user search experience
- Correcting user spelling mistakes
- Improving search relevance
- 8 Elasticsearch Java APIs
- Introducing the Elasticsearch Java API
- The code
- Connecting to your cluster
- Anatomy of the API
- CRUD operations
- Querying Elasticsearch
- Performance multiple actions
- Percolator
- The explain API
- Building JSON queries and documents
- The administration API
- 9 Developing Elasticsearch Plugins
- Creating the Apache Maven project structure
- Creating a custom river plugin
- Creating custom analysis plugin
- 1 Getting started
- You know, for search
- Life inside a cluster
- Data in, data out
- Distributed document store
- Searching - the basic tools
- Mapping and analysis
- Full-body search
- Sorting and relevance
- Distributed search execution
- Index management
- Inside a shard
- 2 Search in depth
- Structured search
- Full-text search
- Multifield search
- Proximity matching
- Partial matching
- Controlling relevance
- 3 Dealing with human language
- Getting started with languages
- Identifying words
- Normalizing tokens
- Reducing words to their root form
- Stopwords: performance vs precision
- Synonyms
- Typoes and mispelings
- 4 Aggregations
- High-level concepts
- Aggregation test drive
- Building bar charts
- Looking at time
- Scoping aggregations
- Filtering queries and aggregations
- Sorting multivalue buckets
- Approximate aggregations
- Significant terms
- Controlling memory use and latency
- 5 Geolocation
- Geo-points
- Geohashes
- Geo-aggregations
- Geo-shapes
- 6 Modeling your data
- Handling relationships
- Nested objects
- Parent-child relationships
- Designing for scale
- 7 Administration, monitoring, deployment
- Monitoring
- Production deployment
- Post-deployment
- 1 Introduction to efficient searching
- Getting started
- Understanding the document storage strategy
- Analysis
- 2 What is an elasticsearch index
- Nature of elasticsearch index
- Document
- 3 Basic concepts of mapping
- Basic concepts and definitions
- Types
- The relationship between mapping and relevant results
- Understanding the schema-less
- 4 Analysis and analyzers
- Introducing analysis
- Process of analysis
- Built-in analyzers
- What's text normalization?
- ICU analysis plugin
- An analyzer plugin
- Specifying the analyzer for a field in the mapping
- 5 Anatomy of an elasticsearch cluster
- Basic concepts
- Node
- Shards
- Replicas
- Explaining the architecture of distribution
- Correctly configuring the cluster
- Choosing the right amount of shards and replicas
- 6 Improving indexing performance
- Configuration
- Optimization of mapping definition
- Segments and merging policies
- Store modules
- Bulk API
- Notes
- 7 Snapshot and restore
- Snapshot repository
- Snapshot
- Restore
- How does the snapshot process work?
- 8 Improving the user search experience
- 1 Google-like web search
- 2 Building your own e-commerce solutions
- 3 Relevancy and scoring
- 4 Managing relational content
- 5 Analytics using elasticsearch
- 6 Improving the search experience
- 7 Spicing up a search using geo
- 8 Handling time-based data