【ElasticSearch】es基本了解

深藏阁楼爱情的钟 2024-04-17 06:25 90阅读 0赞

es可做搜索引擎，也常用语搭建ELK系统做日志分析。

**搜索引擎：**  
es最基本的有三个名词我们要知道：索引，类型，文档。索引相当于数据库，类型相当于数据表，映射相当于表结构，文档相当于行数据。  
**索引：**  
倒排索引：又叫反向索引。根据文档内容中的关键字建立索引，叫倒排索引。  
倒排索引结构：  
1）包含关键词的document list  
2）document的数量：IDF inverse document frequency  
3）关键词在document出现的次数：TF term frequency  
4）关键词在document中的次序  
5）每个document的长度：length norm  
6）包含关键词的所有document的平均长度

倒排索引不可变的好处：  
1）不需要锁，提升并发能力，避免锁的问题  
2）数据不变，一直保存在os cache中，只要cache内存足够  
3）filter cache一直驻留在内存，因为数据不变  
4）可以压缩，节省cpu和io开销

不可变的坏处：  
每次都要重新构建整个索引

\_index元数据：  
1）代表一个document存放在哪个index中  
2）类似的数据放在一个索引，非类似的（字段大部分不同）放在一个索引，或者各种数据都放一个大的索引里都是不合理的  
3）索引名称必须小写，不能下划线开头，不能包含逗号

按照什么来建立索引呢？  
比如很大的一个index，比如包含各种不同数据，product，sales，employee等等，后台数据分析系统负责分析最近一年销售相关的趋势变化，并且计算出各种复杂的数据指标，aggs，跑一条超复杂的聚合分析查询，涉及的数据了很大。  
前台主要搜索product数据，需要耗费30s才能完成这次大数据量的批量分析，所有shard都会耗费大量的资源，IO、CPU、内存，去执行这一次大的聚合分析。查product的请求，大量过来，跟正在聚合分析的请求落到同一个shard执行，此时该shard正在执行非常耗时，耗费资源的大型聚合分析操作，可能导致document get请求，大量的性能不好，超时，影响用户体验。  
建索引语法：

创建索引
    PUT /my_index
    { 
      "settings": { 
        "number_of_shards": 1,
        "number_of_replicas": 0
      },
      "mappings": { 
        "my_type": { 
          "properties": { 
            "my_field": { 
              "type": "text"
            }
          }
        }
      }
    }
    
    修改索引
    PUT /my_index/_settings
    { 
        "number_of_replicas": 1
    }
    
    删除索引
    DELETE /my_index
    DELETE /index_one,index_two
    DELETE /index_*
    DELETE /_all

分词器：

1、默认的分词器
    
    standard
    
    standard tokenizer：以单词边界进行切分
    standard token filter：什么都不做
    lowercase token filter：将所有字母转换为小写
    stop token filer（默认被禁用）：移除停用词，比如a the it等等
    
    2、修改分词器的设置
    
    启用english停用词token filter
    
    PUT /my_index
    { 
      "settings": { 
        "analysis": { 
          "analyzer": { 
            "es_std": { 
              "type": "standard",
              "stopwords": "_english_"
            }
          }
        }
      }
    }
    
    GET /my_index/_analyze
    { 
      "analyzer": "standard", 
      "text": "a dog is in the house"
    }
    
    GET /my_index/_analyze
    { 
      "analyzer": "es_std",
      "text":"a dog is in the house"
    }
    3、定制化自己的分词器
    
    PUT /my_index
    { 
      "settings": { 
        "analysis": { 
          "char_filter": { 
            "&_to_and": { 
              "type": "mapping",
              "mappings": ["&=> and"]
            }
          },
          "filter": { 
            "my_stopwords": { 
              "type": "stop",
              "stopwords": ["the", "a"]
            }
          },
          "analyzer": { 
            "my_analyzer": { 
              "type": "custom",
              "char_filter": ["html_strip", "&_to_and"],
              "tokenizer": "standard",
              "filter": ["lowercase", "my_stopwords"]
            }
          }
        }
      }
    }
    
    GET /my_index/_analyze
    { 
      "text": "tom&jerry are a friend in the house, <a>, HAHA!!",
      "analyzer": "my_analyzer"
    }
    
    PUT /my_index/_mapping/my_type
    { 
      "properties": { 
        "content": { 
          "type": "text",
          "analyzer": "my_analyzer"
        }
      }
    }

**类型：**  
字符串string，表示字符串的有keyword、text；  
keyword：直接建立反向索引  
text：先分词，后建反向索引  
数指型：long、integer、short、byte、double、float  
日期型：date  
布尔型：boolean  
二进制型：binary  
数组类型（Array datatype）

\_type元数据：  
1）代表document属于index中哪个类别  
2）一个索引可划分为多个type，比如商品分为电子商品，生鲜，日化等  
3）名称可以大写或小写，但不能下划线开头，不能包含逗号

\_id元数据：  
1）代表document的唯一标识，与index和type一起，可唯一标识一个document  
2）可手动指定document的id(put /index/type/id)，也可es自动为我们创建一个id  
自动生成的id长度20个字符，url安全，base64编码，GUID， 分布式并行生成id不冲突（es内部处理，put请求不可能在不同shard生成相同的id）

\_source元数据：  
指定返回几个字段：  
put /index/type/1  
\{  
“field1”:“field1”,  
“field2”:“field2”  
\}

或者：定制返回的结果，指定返回哪些field  
get /index/type/1?\_source=field1,field2

**mapping映射：**  
映射用来建立文档，用来定义字段的类型、分词器、属性等。分为动态映射和静态映射。  
**动态：**  
关系型数据库中，我们需要事先创建数据库，然后在该数据库建表，插入数据；而es不需要事先设计映射，在文档写入es时，会根据文档字段自动识别类型，称为动态映射。  
true or false --> boolean  
123 --> long  
123.45 --> double  
2017-01-01 --> date  
“hello world” --> string/text

**dynamic策略：**  
三种：  
true：遇到陌生字段，执行dynamic mapping  
false：遇到陌生字段，忽略  
strict：遇到陌生字段，报错

PUT /my_index
    { 
      "mappings": { 
        "my_type": { 
          "dynamic": "strict",
          "properties": { 
            "title": { 
              "type": "text"
            },
            "address": { 
              "type": "object",
              "dynamic": "true"
            }
          }
        }
      }
    }

此时往my\_type加个陌生字段content：

PUT /my_index/my_type/1
    { 
      "title": "my article",
      "content": "this is my article",
      "address": { 
        "province": "guangdong",
        "city": "guangzhou"
      }
    }
    
    报错：（插入陌生字段是不允许的）
    { 
      "error": { 
        "root_cause": [
          { 
            "type": "strict_dynamic_mapping_exception",
            "reason": "mapping set to strict, dynamic introduction of [content] within [my_type] is not allowed"
          }
        ],
        "type": "strict_dynamic_mapping_exception",
        "reason": "mapping set to strict, dynamic introduction of [content] within [my_type] is not allowed"
      },
      "status": 400
    }

插入一条数据：如下：

PUT /my_index/my_type/1
    { 
      "title": "my article",
      "address": { 
        "province": "guangdong",
        "city": "guangzhou"
      }
    }
    es自动建立的mapping如下：
    GET /my_index/_mapping/my_type
    { 
      "my_index": { 
        "mappings": { 
          "my_type": { 
            "dynamic": "strict",
            "properties": { 
              "address": { 
                "dynamic": "true",
                "properties": { 
                  "city": { 
                    "type": "text",
                    "fields": { 
                      "keyword": { 
                        "type": "keyword",
                        "ignore_above": 256
                      }
                    }
                  },
                  "province": { 
                    "type": "text",
                    "fields": { 
                      "keyword": { 
                        "type": "keyword",
                        "ignore_above": 256
                      }
                    }
                  }
                }
              },
              "title": { 
                "type": "text"
              }
            }
          }
        }
      }
    }

**定制dynamic mapping策略：**  
1）date\_detection：默认按照date格式识别，如果输入2020-01-01格式，自动dynamic mapping处理，如果是“hello”字符串，则报错，可以手动关闭date\_detection：

PUT /my_index/_mapping/my_type
    { 
        "date_detection": false
    }

2）定制自己dynamic mapping template

PUT /my_index
    { 
        "mappings": { 
            "my_type": { 
                "dynamic_templates": [
                    {  "en": { 
                          "match":              "*_en", 
                          "match_mapping_type": "string",
                          "mapping": { 
                              "type":           "string",
                              "analyzer":       "english"
                          }
                    }}
                ]
    }}}
    
    PUT /my_index/my_type/1
    { 
      "title": "this is my first article"
    }
    
    PUT /my_index/my_type/2
    { 
      "title_en": "this is my first article"
    }
    title：没有匹配到dynamic模板，默认就是standard分词器，不会过滤停用词，is会进倒排索引，用is搜索是可以搜到的；
    title_en：匹配到了dynamic模板，english分词器，会过滤掉停用词is，用is搜索不到

**静态：**  
在es中可以事先定义好映射，包含文档的各个字段及其类型等，这种方式叫静态映射。

es在lucene的基础上封装，实现了分布式搜索引擎。

mapping,就是index的type的元数据，每个type都有一个自己的mapping，决定了数据类型，建立倒排索引的行为，还有搜索的行为。

**es分布式原理：**  
Cluster集群：  
集群中有多个节点，其中有一个为主节点，这个主节点是通过选举产生，这是从集群内部来说的。es的一个概念是去中心化，是对集群外部来说的，在逻辑上是个整体，你与任何一个节点的通信与整个es集群通信等价的。

Shards分片：  
es可以把一个完整的索引分成多个分片，当索引很大时，拆分成多个，分布到不同的节点上，可以分担压力，提高搜索及其他效率，提高es可用性。默认创建五个分片，分片的数量在建立索引后不可更改，但是备份的可以更改。

replicas：  
索引副本，es可设置多个索引的副本，副本作用：一是提高系统的容错性，当某个节点某个分片损坏或丢失时可以从副本中恢复；二是提高es的查询效率，es会自动对搜索请求进行负载均衡。

Recovery：  
数据恢复或叫数据重新分布。es在有节点加入或退出时会根据机器的负载对索引分片重新分配，挂掉的节点重新启动时也会进行数据恢复。

**es的master-slave架构，实现了分片和备份：**  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2hvbmd3ZWkxNTczMjYyMzM2NA_size_16_color_FFFFFF_t_70]  
建立索引时，首先在master建立，然后再同步到从机。  
但是这样会不会导致写性能很低？  
不会的，只有建立索引或类型需要经过master，数据写入有个简单的routing规则，可以route到集群中任意节点，压力是分布在集群中的。

**ES为什么要实现集群？**  
我们可以处理不能在一个单一的服务器运行的大型索引，索引过大会导致效率问题，不能运行的原因可能是内存也可能是存储，每个分片都可以有多个副本，通过将副本分配到多个服务器，可以提高查询的负载能力。

集群核心原理分析：  
1、每个索引分成多个shards进行存储，默认创建索引是分配5个分片进行存储。每个分片都会分布式部署多个不同的节点上进行部署，该分片称为primary shards。  
2、为了实现高可用，主分片可以有对应的备份分片replicas shards，replica shards分片承载了负责容错、及请求的负载均衡。（每个主分片都有自己的备份分片，主对应的备份不能在同一台服务器上，主primary shards和replicas shards放在同一个node节点）

**ELK系统做日志分析：**  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2hvbmd3ZWkxNTczMjYyMzM2NA_size_16_color_FFFFFF_t_70 1]  
分析日志有什么用？  
假如一个分布式系统有1000台机器，系统出现故障时，我要看日志，还要一台一台登录上去看，但是如果日志接入了ELK，系统运行过程中，突然出现异常，在日志中就可以及时反馈，我们可直接在Kibana中看到日志情况，如果再接入实时计算模块，还可以做实时报警功能。

**总结：**  
本文参考：[http://developer.51cto.com/art/201904/594615.htm?pc][http_developer.51cto.com_art_201904_594615.htm_pc]  
博主写的通俗易懂，小编非常推荐。

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2hvbmd3ZWkxNTczMjYyMzM2NA_size_16_color_FFFFFF_t_70]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/16/877845c0965344729ec1ec2e80b245a4.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2hvbmd3ZWkxNTczMjYyMzM2NA_size_16_color_FFFFFF_t_70 1]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/16/f4023a6bd051430398baeedb87ecbe3a.png
[http_developer.51cto.com_art_201904_594615.htm_pc]: http://developer.51cto.com/art/201904/594615.htm?pc