elasticsearch基础及在Python中的简单使用

亦凉 2023-08-17 15:39 134阅读 0赞

*  一. 安装java环境与elasticsearch、kibana
 *  二. elasticsearch、kibana的部分文件说明
 *  三. Kibana的Dev tools中ES的简单命令
 *  四. ES的复杂查询
    
     *  1.排序sort、分页、布尔查询bool
     *  2.高亮查询highlight
     *  3.结果过滤\_source
     *  4.聚合查询
     *  5. ES的mapping映射
     *  6.嵌套属性
     *  7.settings设置主从分片
     *  8.match系列
 *  五. elasticsearch分析数据的过程漫谈
    
     *  5.1 ik安装的问题
     *  5.2 ik分词的测试
 *  六. python操作Elasticsearch
    
     *  6.1 python连接 ES
     *  6.2 python操作ES
     *  **6.3 es.indices**对索引的操作
     *  6.4 Cluster 集群相关
     *  6.5 Node 节点相关
     *  6.6 Cat 一种查询方式
     *  6.7 Snapshot 快照相关
     *  6.8 Task 任务相关
 *  七. python使用ES搜索小例子
    
     *  7.1 settings.py中指定连接数据库
     *  7.2 models.py中建立模型表，并同步至数据库
     *  7.3 新建一个spider.py文件，配置django环境，爬取数据
     *  7.4 urls.py中配置路由
     *  7.5 views.py中视图函数
     *  7.6 templates文件下写的search.html
     *  7.7 启动项目先访问es路由，后面访问index即可

## 一. 安装java环境与elasticsearch、kibana ##

首先要求jdk为1.8及以上，这里elasticsearch（kibana同理，尽量保证elasticsearch版本一致，安装和启动方式也是一样的）版本采用6.5.4。

elasticsearch简介：[https://baike.baidu.com/item/elasticsearch/3411206?fr=aladdin][https_baike.baidu.com_item_elasticsearch_3411206_fr_aladdin]

elasticsearch官网：[https://www.elastic.co/cn/downloads/][https_www.elastic.co_cn_downloads]

![1635189-20190912143342630-349243127.png][]

点击下载，之后下拉选择历史版本past releases

![1635189-20190912143401669-1287259408.png][]

最后点击download即可

![1635189-20190912143409922-92833751.png][]

java环境配置看该博客：[https://www.cnblogs.com/Neeo/articles/10368280.html][https_www.cnblogs.com_Neeo_articles_10368280.html]

安装完毕后如果没有出现错误，解压elasticsearch，然后进入其bin目录，双击打开其中的elasticsearch.bat文件即可，随后访问127.0.0.1:9200，如果能看到返回的json数据，代表配置成功。（其中9200是节点监听的断开，而9300是集群默认监听的端口）。

未能正常启动原因

![1635189-20190912144150333-1247926665.png][]

## 二. elasticsearch、kibana的部分文件说明 ##

1. 解压后的config中的elasticsearch.yml就是ES的配置文件，这用Notepad打开。

![1635189-20190912143536779-413879951.png][]

![1635189-20190912143541884-1802391887.png][]

![1635189-20190912143550324-1995688313.png][]

![1635189-20190912143556795-1662497337.png][]

同目录的jvm.options是虚拟机jrel的配置。

![1635189-20190912143640734-41380868.png][]

同目录的log4j2.properties是日志的配置，可以配置日志的输出、级别等信息，一般不会修改。（log4j是Apache的一个框架，用于控制日志）

1.  Kibana目录下的config中的kibana.yml存放其配置文件。

![1635189-20190912143652883-734656527.png][]

![1635189-20190912143658882-627719868.png][]

![1635189-20190912143704313-830171074.png][]

## 三. Kibana的Dev tools中ES的简单命令 ##

数据准备

PUT s18/doc/2
    {
      "name":"yangtao",
      "age": 18,
      "tags":"浪",
      "b":"19970521",
      "sex": "男"
    }
    
    
    PUT s18/doc/1
    {
      "name":"egon",
      "age": 20,
      "tags":"认真学习",
      "b":"19970781",
      "sex": "男"
    }
    
    
    PUT s18/doc/3
    {
      "name":"sybil",
      "age": 3,
      "tags":"认真学习",
      "b":"19971216",
      "sex": "女"
    }

![1635189-20190912143717291-1838010183.png][]

以 '索引/类型/文档' 的格式
    #增 PUT  如果PUT对的数据已存在，那么会进行更新的操作，但是PUT时传的参数是什么，更新之后的数据就是什么，所以需要填写所有的字段
        PUT s18/doc/1   #新增索引s18/doc/1  s18是_index，1是该数据的文档,doc是Type
        {
            "name":"sybil",
            "skill":"fly",
            "hobby":"sleep",
            "tags":"beautiful"
        }
        
    #删  DELETE
        DELETE s18  #删除索引（数据库）
        DELETE s18/doc/1  #删除索引s18下type是doc，文档是1的数据
        DELETE s18/doc/_search?q=tags:beautiful  #这是错误的删除方式，要使用search的方式删除需要使用POST
            
    #查  GET
        GET s18/doc/1  #查文档为1的数据
        GET s18/doc/_search  #查所有
        GET s18/doc/_search?q=name:sybil  #查名字叫sybil的
    
    #更新指定字段POST，或配合search删除
        POST s18/doc/1/_update
        {
          "doc":{  # 需要指定type，相当于指定表名
            "tags":"美丽冻人"
          }
        }
        
        POST s18/doc/_delete_by_query?q=age:18  #删除年龄为18的数据，不过不推荐使用该方式
     
    #查询的两种方式
        1.查询字符串 query string
            GET s18/doc/_search?q=age:18
                
        2. DSL 结构化查询
            GET s18/doc/_search
            {
                "query":{
                    "match":{
                        "age":18
                    }
                }
            }
            
            GET s18/doc/_search
            {
                "query":{
                    "match_all":{}  #因为是查所有，不需要参数
                }
            }

1.  GET s18/\_mapping

![1635189-20190912143730548-1131027203.png][]

1.  GET s18/\_settings
    
    ![1635189-20190912143745171-1620627583.png][]
2.  GET s18

![1635189-20190912143752188-1854287849.png][]

## 四. ES的复杂查询 ##

### 1.排序sort、分页、布尔查询bool ###

#排序 sort  不是所有的字段都能排序，比如名字
        GET s18/doc/_search
            {
                "query":{
                    "match_all":{}
                },
                "sort": [  #排序
                    {
                        "age":{
                            "order": "asc" #升序，desc降序
                        }
                    }
                ]
            }
            
    #分页 内部会先排好序，保证翻页后不会出现已经返回过的数据
        GET s18/doc/_search
        {
            "query":{
                   "match_all":{}
               },
            "from": 0,  #从0条开始
            "size": 2  #返回2条数据
        }
    
    #布尔查询bool: should(or)  must(and)  must_not(not)，must_not
        GET s18/doc/_search
        {
            "query": {
                "bool": {
                    "should": [  #名字是sybil或者年龄18岁
                        {
                            "match": {
                                "name": "sybil"
                            }
                        },
                        {
                            "match": {
                                "age": "18"
                            }
                        }
                    ]
                }
            }
        }
        
        '查询性别是男的，年龄18'
        GET s18/doc/_search
        {
            "query": {
                "bool":{
                    "must": [
                        {
                            "match": {
                                "age": "18"
                            }
                        },
                        {
                             "match": {
                            "sex": "男"
                            }
                        }
                    ]
                }
            }
        }
        
    #查询年龄大于19岁的男的  filter尽量用must配合，避免脏数据
        GET s18/doc/_search
        {
            "query": {
                "bool": {
                    "must": [
                        {"match": {
                            "sex": "男"
                        }}
                    ],
                    "filter": {
                        "range": {
                            "age": {
                                "gte": 19,
                                "lte": 20
                            }
                        }
                    }
                }
            }
        }

### 2.高亮查询highlight ###

#查询name是sybil的文档
    #高亮查询，查询name是sybil的文档，查询的结果需要在前端才能体现高亮，因为是标签的效果
    GET s18/doc/_search
    {
      "query": {
        "match": {
          "name": "sybil"
        }
      },
      "highlight": {
        "fields": {
          "name": {}  #查询的结果用<em>标签包裹
        }
      }
    }
    
    GET s18/doc/_search
    {
      "query": {
        "match": {
          "name": "sybil"  #会将我们这里定义的字段高亮显示
        }
      },
      "highlight": {  #可以使用pre_tags与post_tags自定义标签
        "pre_tags": "<b style='color:red;font-size:20px'>", 
        "post_tags": "<\b>", 
        "fields": {
          "name": {}  #这里指定字段后空着即可
        }
      }
    }

### 3.结果过滤\_source ###

#过滤出查询结果中想要的字段
    GET s18/doc/_search
    {
      "query": {
        "match": {
          "name": "sybil"
        }
      },
      "_source": "name"  #单个字段
    }
    
    GET s18/doc/_search
    {
      "query": {
        "match": {
          "name": "sybil"
        }
      },
      "_source": ["name", "age"]  #多个字段
    }

### 4.聚合查询 ###

#sum，查询所有男生的年龄
    GET s18/doc/_search
    {
      "query": {
        "match": {
          "sex": "男"
        }
      },
      "aggs": {
        "my_sum": {  #这是查询结果的键，可以自定义
          "sum": {  #这是聚合的方法
            "field": "age"  #指定聚合的依据
          }
        }
      }
    }
    
    #查询最大年龄的男生
    GET s18/doc/_search
    {
      "query": {
        "match": {
          "sex": "男"
        }
      },
      "aggs": {
        "my_max": {
          "max": {
            "field": "age"
          }
        }
      }
    }
    
    #查询最小年龄的男生
    GET s18/doc/_search
    {
      "query": {
        "match": {
          "sex": "男"
        }
      },
      "aggs": {
        "my_min": {
          "min": {
            "field": "age"
          }
        }
      }
    }
    
    #查询男生的平均年龄
    GET s18/doc/_search
    {
      "query": {
        "match": {
          "sex": "男"
        }
      },
      "aggs": {
        "my_avg": {
          "avg": {
            "field": "age"
          }
        }
      }
    }
    
    #分组，根据年龄，0-10，,0-20
    GET s18/doc/_search
    {
      "query": {
        "match": {
          "sex": "男"
        }
      },
      "aggs": {
        "my_group": {  #分组名称
          "range": {
            "field": "age",
            "ranges": [
              {  
                "from": 0,  #[0, 10)
                "to": 10
              },
              {
                "from": 10,
                "to": 20
              },
              {
                "from": 20,
                "to": 30
              }
            ]
          }
        }
      }
    }
    
    #分组，根据年龄，0-10，,0-20, 对每组年龄求和
    GET s18/doc/_search
    {
      "query": {
        "match": {
          "sex": "男"
        }
      },
      "aggs": {
        "my_group": {
          "range": {
            "field": "age",
            "ranges": [
              {
                "from": 0,
                "to": 10
              },
              {
                "from": 10,
                "to": 20
              },
              {
                "from": 20,
                "to": 30
              }
            ]
          },
          "aggs": {
            "my_sum": {
              "sum": {
                "field": "age"
              }
            }
          }
        }
      }
    }

### 5. ES的mapping映射 ###

#自定义索引的映射
    PUT s2
    {
      "mappings": {
        "doc":{  #类型
          "properties":{  #文档的属性
            "name":{
              "type":"text"
            },
            "age":{
              "type":"long"
            },
            "desc":{
              "type":"text"
            }
          }
        }
      }
    }
    
    #如果给该索引加文档时，额外增加了字段，那么mappings会自动增加该字段，使其能够成为查询条件
    GET s2/_mapping
    PUT s2/doc/2
    {
      "name":"catmao",
      "age":30,
      "desc":"beautiful",
      "skill":"sleep"
    }
    GET s2/_mapping  #再次执行会发现字段多了skill
    
    #这是由mappings的dynamic的三种状态，三种状态时，均可以缺省字段
    dynamic为true时特征如上。
    
    dynamic为false时，PUT添加的数据有额外字段时，Mapping不会自动添加，该字段也无法成为查询的条件。
    
    dynamic为strict时，添加的数据不能有额外的字段，会直接报错
        PUT s6
        {
          "mappings": {
            "doc":{
              "dynamic":"strict",
              "properties":{
                "name":{
                  "type":"text"
                }
              }
            }
          }
        }
    #mapping的ignore_above，不会为超过该设定字符长度的字符串设定索引与存储，即无法成为有效的查询条件，仅对type为keyword的字段有效。
    https://www.cnblogs.com/Neeo/articles/10789701.html
        PUT s7
        {
          "mappings": {
            "doc":{
              "properties":{
                "title":{
                  "type":"keyword",
                  "ignore_above":10
                }
              }
            }
          }
        }
    
        PUT s7/doc/2
        {
          "title":"从手机、平板电脑、路由器"
        }
        PUT s7/doc/1
        {
          "title":"1234567"
        }
        GET s7/doc/_search
        {
          "query": {
            "match": {
              "title": "1234567"
            }
          }
        }
        
    #mappings参数之index,设置为false后，ES不会为该字段建立索引，其实是不会做分词
    #mappings的index参数
        PUT s8
        {
          "mappings": {
            "doc":{
              "properties":{
                "t1":{
                  "type":"text",
                  "index":"true"
                },
                "t2":{
                  "type":"text",
                  "index":"false"
                }
              }
            }
          }
        }
    
        PUT s8/doc/1
        {
          "t1":"论母猪的厂前保养",
          "t2":"论母猪的厂后保养"
        }
    
        GET s8/doc/_search
        {
          "query": {
            "match": {
              "t2": "母猪"
            }
          }
        }
        
    #mappings的copy_to，把一个字段的值复制给另一个，可以减少一次查询的次数
        PUT s9
        {
          "mappings": {
            "doc":{
              "properties":{
                "t1":{
                  "type":"text",
                  "copy_to":"full_name"  #复制给多个字段 ["f1", "f2"]
                },
                "t2":{
                  "type":"text",
                  "copy_to":"full_name"
                },
                "full_name":{
                  "type":"text"
                }
              }
            }
          }
        }
    
        PUT s9/doc/1
        {
          "t1":"xxx",
          "t2":"ooo"
        }
    
        GET s9/doc/_search
        {
          "query": {
            "match": {
              "full_name": "xxx"
            }
          }
        }

### 6.嵌套属性 ###

#嵌套类型
        PUT w1
        {
          "mappings": {
            "doc":{
              "properties":{
                "name":{
                  "type":"text"
                },
                "age":{
                  "type":"long"
                },
                 "info":{  #info字段嵌套两个字段
                    "properties":{
                      "addr":{
                        "type":"text"
                      },
                      "tel":{
                        "type":"long"
                      }
                    }
            }
              }
            }
          }
        }
    
        PUT w1/doc/1  #插入一条数据
        {
          "name":"tom",
          "age":18,
          "info":{  
            "addr":"北京",
            "tel":"10010"
          }
        }
    
        GET w1/doc/_search
        {
          "query": {
            "match": {
              "info.tel": "10010"  #以嵌套字段的属性为查询条件时，直接点语法即可
            }
          }
        }

### 7.settings设置主从分片 ###

#主分片一旦设置无法更改，复制分片可以
    PUT w2
    {
      "mappings": {
        "doc":{
          "properties":{
            "title":{
              "type":"text"
            }
          }
        }
      }, 
      "settings": {  #通过settings设置
        "number_of_shards": 3,  #主分片数量，默认为5
        "number_of_replicas": 3  #复制分片数量，默认为1
      }
    }
    
    GET w2

### 8.match系列 ###

![1635189-20190912143821124-70361996.png][]

博客地址[https://www.cnblogs.com/Neeo/articles/10578482.html][https_www.cnblogs.com_Neeo_articles_10578482.html]

#数据准备
    PUT t1/doc/1
    {
      "title":"中国是世界上人口最多的国家"
    }
    PUT t1/doc/2
    {
      "title":"美国是世界上军事实力强大多的国家"
    }
    PUT t1/doc/3
    {
      "title":"北京是中国 的首都"
    }

使用match查询“中国”

#会发现美国也包含在其中，这是因为match内部会散列分词，内部是采用标准的分析器，中国会分为中和国
    GET t1/doc/_search
    {
      "query": {
        "match": {
          "title": "中国"
        }
      }
    }

我们想把中国当成一个短语，需要采用match\_phrase

#这样就不好分词，把中国当成一个短语去查询
    GET t1/doc/_search
    {
      "query": {
        "match_phrase": {
          "title": "中国"
          "slop": 1  #该参数可以指定分词的间隔
        }
      }
    }

最左前缀查询match\_phrase\_prefix

PUT t2/doc/1
    {
      "title":"beautiful girl"
    }
    
    PUT t2/doc/2
    {
      "title":"beautiful so"
    }
    
    GET t2/doc/_search
    {
      "query": {
        "match_phrase_prefix": {
          "title": "bea"  #只要有单词以bea开头
        }
      }
    }

multi\_match多字段查询，可以完成match\_phrase和match\_phrase\_prefix的工作，使用很灵活。

PUT t3/doc/1
    {
      "t1":"beautiful girl",
      "t2":"beautiful so"
    }
    
    #查找字段t1和t2都包含beautiful的文档
    GET t3/doc/_search
    {
      "query": {
        "multi_match": {
          "query": "beautiful",
          "fields": ["t1", "t2"]
        }
      }
    }

## 五. elasticsearch分析数据的过程漫谈 ##

详见博客[https://www.cnblogs.com/Neeo/p/10304892.html][https_www.cnblogs.com_Neeo_p_10304892.html]，附带安装ik分词

### 5.1 ik安装的问题 ###

![1635189-20190912143835624-1342585814.png][]

### 5.2 ik分词的测试 ###

#ik分词的测试
    GET _analyze
    {
      "analyzer": "standard",
      "text":"上海自来水来自海上"
    }
    
    GET _analyze
    {
      "analyzer": "ik_smart",
      "text":"上海自来水来自海上"
    }
    
    #粒度更细，一般存储时建议使用粒度粗的（意义更大），ik_max_word会将文档做最细粒度的拆分
    GET _analyze
    {
      "analyzer": "ik_max_word",
      "text":"上海自来水来自海上"
    }

## 六. python操作Elasticsearch ##

### 6.1 python连接 ES ###

doc\_type默认是doc，所以可以不写，不过建议都写上，以防万一

'1. 安装elasticsearch模块'
    pip install elasticsearch
    # 豆瓣源
    pip install -i https://pypi.doubanio.com/simple/             elasticsearch
            
    '2. 连接的方式'
    from elasticsearch import  Elasticsearch
    # es = Elasticsearch()    # 默认连接本地elasticsearch
    # es = Elasticsearch(['127.0.0.1:9200'])  # 连接本地9200端口
    es = Elasticsearch(
        ["192.168.1.10", "192.168.1.11", "192.168.1.12"], # 连接集群，以列表的形式存放各节点的IP地址
        sniff_on_start=True,    # 连接前测试
        sniff_on_connection_fail=True,  # 节点无响应时刷新节点
        sniff_timeout=60    # 设置超时时间
    )
    
    '3. 配置忽略响应状态码'
    es = Elasticsearch(['127.0.0.1:9200'],ignore=400)  # 忽略返回的400状态码
    es = Elasticsearch(['127.0.0.1:9200'],ignore=[400, 405, 502])  # 以列表的形式忽略多个状态码
    
    '4. 简单的示例'
    from elasticsearch import  Elasticsearch
    es = Elasticsearch()    # 默认连接本地elasticsearch
    # print(es.ping())  #可以用该方法查看是否连接成功，如果群集已启动，则返回True，否则返回False
    print(es.index(index='p1', doc_type='doc', id=1, body={'name': "sybil", "age": 18}))  #index方法，如果索引存在则更新，否则增加新记录
    print(es.get(index='p1', doc_type='doc', id=1))

### 6.2 python操作ES ###

# search方法使用的较多，因为可以跟复杂查询
    '对返回的信息的几种过滤方法（过滤出想要显示的信息）'
    body = {
        "query": {
            "match": {
                "name": "lou22"
            }
        }
    }
    # 返回的是一个大字典
    print(es.search(index='p1', body=body))
    # 可以使用filter_path过滤出其中想要的信息
    print(es.search(index='p1', body=body, filter_path=['hits.hits']))
    # 查询出来的信息主要保存在_source中  {'hits': {'hits': [{'_source': {'name': 'lou22'}}]}}
    print(es.search(index='p1', body=body, filter_path=['hits.hits._source']))
    # 也可以指定多个要显示的信息 {'hits': {'total': 1, 'hits': [{'_source': {'name': 'lou22'}}]}}
    print(es.search(index='p1', body=body, filter_path=['hits.hits._source', 'hits.total']))
    # 可以用*指定返回hits下所有的内容  *是语法，表示所有
    print(es.search(index='p1', body=body, filter_path=['hits.*']))
    # 可以用*指定返回hits下的hits中所有的内容
    print(es.search(index='p1', body=body, filter_path=['hits.hits._*']))
    
    
    '过滤出结果中想要的字段，_source'
    print(es.search(index='py3', doc_type='doc', body={"query": {"match":{"age": 20}}}))  # 一般查询
    print(es.search(index='py3', doc_type='doc', body={"query": {"match":{"age": 19}}},_source=['name', 'age']))  # 结果字段过滤
    print(es.search(index='py3', doc_type='doc', body={"query": {"match":{"age": 19}}},_source_exclude  =[ 'age']))  #除了age字段之外的所有字段都要
    print(es.search(index='py3', doc_type='doc', body={"query": {"match":{"age": 19}}},_source_include =[ 'age']))  #只要age字段，同_source差不多

**get\_source**直接返回数据字典

# 直接返回数据字典  {'name': 'lou22'}
    print(es.get_source(index='p1', doc_type='doc', id=1))

**count**统计查询结果的个数

# 新建几条数据
    for i in range(2, 11):
        print(es.index(index='p1', doc_type='doc', body={"name": "lou%s" % i}))
    
    # 指定用于查询的方式
    body = {
        "query": {
            "match": {
                "name": "lou2"
            }
        }
    }
    #查询回来的结果就是字典，可以采用字典的操作方式
    print(es.count(index='p1', doc_type='doc', body=body))['count']  # 1
    print(es.count(index='w2'))  # {'count': 6, '_shards': {'total': 5, 'successful': 5, 'skipped': 0, 'failed': 0}}
    print(es.count(index='w2', doc_type='doc')) # {'count': 6, '_shards': {'total': 5, 'successful': 5, 'skipped': 0, 'failed': 0}}

**es.create创建索引（索引不存在的话）并新增一条数据，索引存在仅新增（只能新增，重复执行会报错**

#其实内部调用了es.index，一般不使用create方法
    print(es.create(index='py3', doc_type='doc', id='1', body={"name": '王五', "age": 20}))
    print(es.get(index='py3', doc_type='doc', id='1'))

**es.delete**与**es.delete\_by\_query**

#es.delete，删除指定的文档。比如删除文章id为4的文档，但不能删除索引，如果想要删除索引，还需要es.indices.delete来处理
    print(es.delete(index='py3', doc_type='doc', id='4'))
    
    #es.delete_by_query，删除与查询匹配的所有文档
    print(es.delete_by_query(index='py3', doc_type='doc', body={"query": {"match":{"age": 20}}}))

**es.exists**与**es.info**

# es.exists，查询elasticsearch中是否存在指定的文档，返回一个布尔值
    print(es.exists(index='py3', doc_type='doc', id='1'))
    
    #es.info，获取当前集群的基本信息，一般使用kibana查看，因为比较直观
    print(es.info())

### **6.3 es.indices**对索引的操作 ###

**es.indices.create在Elasticsearch中创建索引，用的最多**

body = {
        "mappings": {
            "doc": {
                "dynamic": "strict",  #设置严格模式
                "properties": {
                    "title": {
                        "type": "text",
                        "analyzer": "ik_max_word"
                    },
                    "url": {
                        "type": "text"
                    },
                    "action_type": {
                        "type": "text"
                    },
                    "content": {
                        "type": "text"
                    }
                }
            }
        }
    }
    es.indices.create('py4', body=body)

**es.indices.analyze，返回分词结果**

es.indices.analyze(body={'analyzer': "ik_max_word", "text": "皮特和茱丽当选“年度模范情侣”Brad Pitt and Angelina Jolie"})

**es.indices.delete，在Elasticsearch中删除索引**

print(es.indices.delete(index='py4'))
    print(es.indices.delete(index='w3'))    # {'acknowledged': True}

**es.indices.put\_alias，为一个或多个索引创建别名，查询多个索引的时候，可以使用这个别名**

print(es.indices.put_alias(index='py4', name='py4_alias'))  # 为单个索引创建别名
    print(es.indices.put_alias(index=['py3', 'py2'], name='py23_alias'))  # 为多个索引创建同一个别名，联查用

**es.indices.delete\_alias，删除一个或多个别名**

print(es.indices.delete_alias(index='alias1'))
    print(es.indices.delete_alias(index=['alias1, alias2']))

**es.indices.get\_mapping，检索索引或索引/类型的映射定义**

print(es.indices.get_mapping(index='py4'))

**es.indices.get\_settings，检索一个或多个（或所有）索引的设置**

print(es.indices.get_settings(index='py4'))

**es.indices.get，允许检索有关一个或多个索引的信息**

print(es.indices.get(index='py2'))    # 查询指定索引是否存在
    print(es.indices.get(index=['py2', 'py3']))

**es.indices.get\_alias，检索一个或多个别名**

print(es.indices.get_alias(index='py2'))
    print(es.indices.get_alias(index=['py2', 'py3']))

**es.indices.get\_field\_mapping，检索特定字段的映射信息**

print(es.indices.get_field_mapping(fields='url', index='py4', doc_type='doc'))
    print(es.indices.get_field_mapping(fields=['url', 'title'], index='py4', doc_type='doc'))

**其他**

# es.indices.delete_alias，删除特定别名。
    # es.indices.exists，返回一个布尔值，指示给定的索引是否存在。
    # es.indices.exists_type，检查索引/索引中是否存在类型/类型。
    # es.indices.flus，明确的刷新一个或多个索引。
    # es.indices.get_field_mapping，检索特定字段的映射。
    # es.indices.get_template，按名称检索索引模板。
    # es.indices.open，打开一个封闭的索引以使其可用于搜索。
    # es.indices.close，关闭索引以从群集中删除它的开销。封闭索引被阻  止进行读/写操作。
    # es.indices.clear_cache，清除与一个或多个索引关联的所有缓存或特定缓存。
    # es.indices.put_alias，为特定索引/索引创建别名。
    # es.indices.get_uprade，监控一个或多个索引的升级程度。
    # es.indices.put_mapping，注册特定类型的特定映射定义。
    # es.indices.put_settings，实时更改特定索引级别设置。
    # es.indices.put_template，创建一个索引模板，该模板将自动应用于创建的新索引。
    # es.indices.rollove，当现有索引被认为太大或太旧时，翻转索引API将别名转移到新索引。API接受单个别名和条件列表。别名必须仅指向单个索引。如果索引满足指定条件，则创建新索引并切换别名以指向新别名。
    # es.indices.segments，提供构建Lucene索引（分片级别）的低级别段信息

### 6.4 Cluster 集群相关 ###

**es.cluster.get\_settigns，获取集群设置**

print(es.cluster.get_settings())

**es.cluster.health，获取有关群集运行状况的非常简单的状态**

print(es.cluster.health())

**es.cluster.state，获取整个集群的综合状态信息**

print(es.cluster.state())

**es.cluster.stats，返回群集的当前节点的信息**

print(es.cluster.stats())

### 6.5 Node 节点相关 ###

**es.nodes.info，返回集群中节点的信息**

print(es.nodes.info())  # 返回所节点
    print(es.nodes.info(node_id='node1'))   # 指定一个节点
    print(es.nodes.info(node_id=['node1', 'node2']))   # 指定多个节点列表

**es.nodes.stats，获取集群中节点统计信息**

print(es.nodes.stats())
    print(es.nodes.stats(node_id='node1'))
    print(es.nodes.stats(node_id=['node1', 'node2']))

**es.nodes.hot\_threads，获取指定节点的线程信息**

print(es.nodes.hot_threads(node_id='node1'))
    print(es.nodes.hot_threads(node_id=['node1', 'node2']))

**es.nodes.usage，获取集群中节点的功能使用信息**

print(es.nodes.usage())
    print(es.nodes.usage(node_id='node1'))
    print(es.nodes.usage(node_id=['node1', 'node2']))

### 6.6 Cat 一种查询方式 ###

**es.cat.aliases，返回别名信息**

#name要返回的以逗号分隔的别名列表。
    #formatAccept标头的简短版本，例如json，yaml
    print(es.cat.aliases(name='py23_alias'))
    print(es.cat.aliases(name='py23_alias', format='json'))

**es.cat.allocation，返回分片使用情况**

print(es.cat.allocation())
    print(es.cat.allocation(node_id=['node1']))
    print(es.cat.allocation(node_id=['node1', 'node2'], format='json'))

**es.cat.count，Count提供对整个群集或单个索引的文档计数的快速访问**

print(es.cat.count())  # 集群内的文档总数
    print(es.cat.count(index='py3'))  # 指定索引文档总数
    print(es.cat.count(index=['py3', 'py2'], format='json'))  # 返回两个索引文档和

**es.cat.fielddata，基于每个节点显示有关当前加载的fielddata的信息。有些数据为了查询效率，会放在内存中，fielddata用来控制哪些数据应该被放在内存中，而这个`es.cat.fielddata`则查询现在哪些数据在内存中，数据大小等信息**

print(es.cat.fielddata())
    print(es.cat.fielddata(format='json', bytes='b'))
    #bytes显示字节值的单位，有效选项为：'b'，'k'，'kb'，'m'，'mb'，'g'，'gb'，'t'，'tb' ，'p'，'pb'
    #formatAccept标头的简短版本，例如json，yaml

**es.cat.health，从集群中`health`里面过滤出简洁的集群健康信息**

print(es.cat.health())
    print(es.cat.health(format='json'))

**es.cat.help，返回`es.cat`的帮助信息**

print(es.cat.help())

**es.cat.indices，返回索引的信息**

print(es.cat.indices())
    print(es.cat.indices(index='py3'))
    print(es.cat.indices(index='py3', format='json'))

**es.cat.master，返回集群中主节点的IP，绑定IP和节点名称**

print(es.cat.master())
    print(es.cat.master(format='json'))

**es.cat.nodeattrs，返回节点的自定义属性**

print(es.cat.nodeattrs())
    print(es.cat.nodeattrs(format='json'))

**es.cat.nodes，返回节点的拓扑，这些信息在查看整个集群时通常很有用，特别是大型集群。我有多少符合条件的节点**

print(es.cat.nodes())
    print(es.cat.nodes(format='json'))

**es.cat.plugins，返回节点的插件信息**

print(es.cat.plugins())
    print(es.cat.plugins(format='json'))

**es.cat.segments，返回每个索引的Lucene有关的信息**

print(es.cat.segments())
    print(es.cat.segments(index='py3'))
    print(es.cat.segments(index='py3', format='json'))

**es.cat.shards，返回哪个节点包含哪些分片的信息**

print(es.cat.shards())
    print(es.cat.shards(index='py3'))
    print(es.cat.shards(index='py3', format='json'))

**es.cat.thread\_pool，获取有关线程池的信息**

print(es.cat.thread_pool())

### 6.7 Snapshot 快照相关 ###

# es.snapshot.create，在存储库中创建快照。
        repository 存储库名称。
        snapshot快照名称。
        body快照定义。
    # es.snapshot.delete，从存储库中删除快照。
    # es.snapshot.create_repository。注册共享文件系统存储库。
    # es.snapshot.delete_repository，删除共享文件系统存储库。
    # es.snapshot.get，检索有关快照的信息。
    # es.snapshot.get_repository，返回有关已注册存储库的信息。
    # es.snapshot.restore，恢复快照。
    # es.snapshot.status，返回有关所有当前运行快照的信息。通过指定存储库名称，可以将结果限制为特定存储库。
    # es.snapshot.verify_repository，返回成功验证存储库的节点列表，如果验证过程失败，则返回错误消息

### 6.8 Task 任务相关 ###

# es.tasks.get，检索特定任务的信息。
    # es.tasks.cancel，取消任务。
    # es.tasks.list，任务列表

## 七. python使用ES搜索小例子 ##

### 7.1 settings.py中指定连接数据库 ###

DATABASES = {
        'default': {
            'ENGINE': 'django.db.backends.mysql',
            'NAME': 'test_es',
            'HOST': '127.0.0.1',
            'PORT': 3306,
            'USER': 'root',
            'PASSWORD': 'root'
        }
    }

### 7.2 models.py中建立模型表，并同步至数据库 ###

from django.db import models
    
    
    class Car(models.Model):
        title = models.CharField(max_length=255)
        summary = models.CharField(max_length=255)
        img_url = models.CharField(max_length=255, null=True)
        tags = models.CharField(max_length=255)
        a_url = models.CharField(max_length=255)

随后执行数据库迁移命令

python manage.py makemigrations
    python manage.py migrate

### 7.3 新建一个spider.py文件，配置django环境，爬取数据 ###

#!/usr/bin/env python
    import os
    
    if __name__ == "__main__":
        os.environ.setdefault("DJANGO_SETTINGS_MODULE", "review_django.settings")
        import django
        django.setup()
        import requests
        from bs4 import BeautifulSoup
        from concurrent.futures import ThreadPoolExecutor
        from app01 import models
    
        def work(k):
            response = requests.get(url='https://www.autohome.com.cn/all/{}/#liststart'.format(k))
            response.encoding = 'GBK'
            soup_obj = BeautifulSoup(response.text, 'html.parser')
            div_obj = soup_obj.find(name='div', attrs={"id": "auto-channel-lazyload-article"})
            li_list = div_obj.find_all(name='li')
            for i in li_list:
                no_obj = i.find(name='h3')
                if not no_obj: continue
                title = i.find(name='h3').text
                summary = i.find(name='p').text
                a = 'https:' + i.find(name='a').get('href')
                img = 'https:' + i.find(name='img').get('src')
                tags = a.split('/', 4)[3]
                print(response.url, title, tags)
                print(summary, img)
                models.Car.objects.create(
                    title=title,
                    summary=summary,
                    tags=tags,
                    img_url=img,
                    a_url=a
                )
    
        def spider():
            t = ThreadPoolExecutor(10)
            for k in range(1, 60):
                t.submit(work, k)
            t.shutdown()
    
        spider()

### 7.4 urls.py中配置路由 ###

from django.conf.urls import url
    from app01 import views
    
    urlpatterns = [
        # 用于简单显示一个页面，同时展示用户搜索的内容
        url(r'index', views.index),
        # 将数据库数据写入es
        url(r'es', views.es2)
    ]

### 7.5 views.py中视图函数 ###

from django.shortcuts import render, HttpResponse
    from django.http import JsonResponse
    from elasticsearch import Elasticsearch
    from elasticsearch import helpers
    from app01 import models
    
    
    # 实例化一个ES对象
    es = Elasticsearch()
    
    # Create your views here.
    
    
    def filter(search_msg):
    
        body = {
            "size": 100,  # 返回一百条数据
            "query": {
                "match": {
                    "title": search_msg  # 从标题中查找输入的关键字
                }
            },
            "highlight": {  # 内容高亮显示，使用pre_tags与post_tags定义标签，默认是em标签
                "pre_tags": "<b style='color:red;font-size:24px'>",
                "post_tags": "</b>",
                "fields": {
                    "title": {}  # 将标题高亮显示
                }
            },
        }
        # 存储es搜索的结果
        res = es.search(index='s18', body=body)
        # print(res)
        return res
    
    
    def index(request):
        if request.method == "POST":
            search_msg = request.POST.get('search_msg')
            res = filter(search_msg)
            # 将es搜索的结果返回
            return JsonResponse(res)
        return render(request, 'search.html', locals())
    
    
    def es2(request):
        body = {
            "mappings": {
                "doc": {
                    "properties": {
                        "title": {
                            "type": "text"
                        },
                        "summary": {
                            "type": "text"
                        },
                        "a_url": {
                            "type": "keyword"
                        },
                        "img_url": {
                            "type": "keyword"
                        },
                        "tags": {
                            "type": "text"
                        }
                    }
                }
            }
        }
        # es.indices.create(index='s18', body=body)
        # print(es.indices.get_mapping())
        query_list = models.Car.objects.all()
        # 定义写入es的数据格式，使用生成器，减轻内存压力
        action = ({
            "_index": "s18",  # 索引，相当于指定数据库，不存在则创建
            "_type": "doc",  # 类型，相当于指定表，不存在则创建
            "_source": {  # 指定要写入的内容
                "title": i.title,
                "summary": i.summary,
                "a_url": i.a_url,
                "img_url": i.img_url,
                "tags": i.tags
            }
        }
            for i in query_list
        )
        # helpers会使用java虚拟机帮我们进行该任务
        helpers.bulk(es, action)
        return HttpResponse('ok es')

### 7.6 templates文件下写的search.html ###

<!DOCTYPE html>
    <html lang="en">
    <head>
        <meta charset="UTF-8">
        <title>Title</title>
        <script src="https://cdn.bootcss.com/jquery/3.4.1/jquery.min.js"></script>
        <script src="https://cdn.bootcss.com/twitter-bootstrap/3.4.1/js/bootstrap.min.js"></script>
        <link href="https://cdn.bootcss.com/twitter-bootstrap/3.4.1/css/bootstrap.min.css" rel="stylesheet">
    </head>
    <body>
    <nav class="navbar navbar-default">
      <div class="container-fluid">
        
        <div class="navbar-header">
          <button type="button" class="navbar-toggle collapsed" data-toggle="collapse" data-target="#bs-example-navbar-collapse-1" aria-expanded="false">
            <span class="sr-only">Toggle navigation</span>
            <span class="icon-bar"></span>
            <span class="icon-bar"></span>
            <span class="icon-bar"></span>
          </button>
          <a class="navbar-brand" href="#">Brand</a>
        </div>
    
        
        <div class="collapse navbar-collapse" id="bs-example-navbar-collapse-1">
          <ul class="nav navbar-nav">
            <li class="active"><a href="#">Link <span class="sr-only">(current)</span></a></li>
            <li><a href="#">Link</a></li>
            <li class="dropdown">
              <a href="#" class="dropdown-toggle" data-toggle="dropdown" role="button" aria-haspopup="true" aria-expanded="false">Dropdown <span class="caret"></span></a>
              <ul class="dropdown-menu">
                <li><a href="#">Action</a></li>
                <li><a href="#">Another action</a></li>
                <li><a href="#">Something else here</a></li>
                <li role="separator" class="divider"></li>
                <li><a href="#">Separated link</a></li>
                <li role="separator" class="divider"></li>
                <li><a href="#">One more separated link</a></li>
              </ul>
            </li>
          </ul>
    {#        搜索框                #}
          <form class="navbar-form navbar-left">
            <div class="form-group">
              <input type="text" class="form-control" placeholder="Search" oninput="foo()" id="search">
            </div>
            <button type="submit" class="btn btn-default">Submit</button>
              <span id="totalNum"></span>
          </form>
          <ul class="nav navbar-nav navbar-right">
            <li><a href="#">Link</a></li>
            <li class="dropdown">
              <a href="#" class="dropdown-toggle" data-toggle="dropdown" role="button" aria-haspopup="true" aria-expanded="false">Dropdown <span class="caret"></span></a>
              <ul class="dropdown-menu">
                <li><a href="#">Action</a></li>
                <li><a href="#">Another action</a></li>
                <li><a href="#">Something else here</a></li>
                <li role="separator" class="divider"></li>
                <li><a href="#">Separated link</a></li>
              </ul>
            </li>
          </ul>
        </div>
      </div>
    
        <div class="container">
            <div class="row">
                <div class="col-md-8 col-lg-offset-2">
                    <div id="showData"></div>
                </div>
            </div>
        </div>
    </nav>
    </body>
    
    <script>
        //搜索
        function foo() {
            var searchMsg = $('#search').val();
            console.log(searchMsg);
            $.ajax({
                url:"/app01/index",
                type: "post",
                data: {'search_msg': searchMsg},
                success:function (data) {
                    console.log(data);
                    if (data){
                        //展示结果条数
                        $("#totalNum").html("结果约<b style='color:red'>" + data.hits.total + "<b>")
                        //结果展示
                        var html = '';
                        $.each(data.hits.hits, function (index, item) {
                            //console.log(item._source.title)
                            html += "<a href='+ item.a_url +'>\n" +
                                "                                <div class=\"article-pic\"></div>\n" +
                                "                                <h3>"+item.highlight.title+"</h3>\n" +
                                "                                <div class=\"article-bar\">\n" +
                                "                                    <span class=\"fn-left\"></span>\n" +
                                "                                    <span class=\"fn-right\">\n" +
                                "                                        <em><i class=\"icon12 icon12-eye\"></i></em>\n" +
                                "                                        <em data-class=\"icon12 icon12-infor\" data-articleid=\"945066\"><i class=\"icon12 icon12-infor\"></i>13</em>\n" +
                                "                                    </span>\n" +
                                "                                </div>\n" +
                                "                                <p>"+item._source.summary+"</p>\n" +
                                "                            </a>";
                            $("#showData").html(html)
                        })
                    }
                }
            })
        }
    
    
    </script>
    
    </html>

### 7.7 启动项目先访问es路由，后面访问index即可 ###

转载于:https://www.cnblogs.com/maoruqiang/p/11509873.html

[https_baike.baidu.com_item_elasticsearch_3411206_fr_aladdin]: https://baike.baidu.com/item/elasticsearch/3411206?fr=aladdin
[https_www.elastic.co_cn_downloads]: https://www.elastic.co/cn/downloads/
[1635189-20190912143342630-349243127.png]: /images/20230810/c54e669927174b9dbe396a11ff466c08.png
[1635189-20190912143401669-1287259408.png]: /images/20230810/3c6cbf0c4d7d4b8c9a45c3c2b614c099.png
[1635189-20190912143409922-92833751.png]: /images/20230810/3c8aef224a01490f9551183f5833f0f2.png
[https_www.cnblogs.com_Neeo_articles_10368280.html]: https://www.cnblogs.com/Neeo/articles/10368280.html
[1635189-20190912144150333-1247926665.png]: /images/20230810/81224202f03b4c9f99041673c8a50d4c.png
[1635189-20190912143536779-413879951.png]: /images/20230810/0e1ec84877c94bdbba390b9984030946.png
[1635189-20190912143541884-1802391887.png]: /images/20230810/ed29cc81ef7d449cb74db5b2344516d9.png
[1635189-20190912143550324-1995688313.png]: /images/20230810/5706c39773f94af5953ecd0e0015db4d.png
[1635189-20190912143556795-1662497337.png]: /images/20230810/68426c5a38aa4247af00b1ac1e0209b2.png
[1635189-20190912143640734-41380868.png]: /images/20230810/1a5612af76aa427bb306bc6277f55d60.png
[1635189-20190912143652883-734656527.png]: /images/20230810/484c62155198435b9fc6ad6a0f3722ee.png
[1635189-20190912143658882-627719868.png]: /images/20230810/88853a93a6b24159b3fad5428b800c41.png
[1635189-20190912143704313-830171074.png]: /images/20230810/e1748658d08b46e8b21f10327755bf9e.png
[1635189-20190912143717291-1838010183.png]: /images/20230810/b84812c550c9421e8b3e2138ccc1189b.png
[1635189-20190912143730548-1131027203.png]: /images/20230810/aa4bb886d8434bfebebb4acb9e6579c0.png
[1635189-20190912143745171-1620627583.png]: /images/20230810/4208530b5eac447bb027dd3b57301b2e.png
[1635189-20190912143752188-1854287849.png]: /images/20230810/d0c8caceb6f0451bad892c9194e44e8c.png
[1635189-20190912143821124-70361996.png]: /images/20230810/44e591fe4cea47d8a03961a12eb6ff62.png
[https_www.cnblogs.com_Neeo_articles_10578482.html]: https://www.cnblogs.com/Neeo/articles/10578482.html
[https_www.cnblogs.com_Neeo_p_10304892.html]: https://www.cnblogs.com/Neeo/p/10304892.html
[1635189-20190912143835624-1342585814.png]: /images/20230810/750040ec0af44764a4b9265a90209f5e.png