5. Script

Elasticsearch支持3种脚本语言：Groovy(1.4.x - 5.0 )、painless、experssion。
Groovy：
安全性问题Elasticsearch5.0以后已经放弃。
painless：
painless是一种专门用于Elasticsearch的简单,用于内联和存储脚本，类似于Java,也有注释、关键字、类型、变量、函数等，安全的脚本语言。它是Elasticsearch的默认脚本语言，可以安全地用于内联和存储脚本。
expression:
每个文档的开销较低：表达式的作用更多，可以非常快速地执行，甚至比编写native脚本还要快，支持javascript语法的子集：单个表达式。缺点：只能访问数字，布尔值，日期和geo_point字段，存储的字段不可用.

脚本模板：

  1. {METHOD} {_index}/{action}/{_id}
  2. {
  3.   "script":{
  4.     "lang": "painless/expression",
  5.     "source": "ctx._source.{field} {option} {值} "
  6.   }
  7. }

使用 painless 脚本将 _index 为“order”_id 为 “1”的premium 字段减1

  1. POST order/_update/1
  2. {
  3.   "script":{
  4.     "lang": "painless",
  5.     "source": "ctx._source.premium -= 1"
  6.   }
  7. }

使用 painless 脚本将 _index 为“order”_id 为 “1”的tenderAddress字段后面拼接一个字符串”666”

  1. POST order/_update/1
  2. {
  3.   "script":{
  4.     "lang": "painless",
  5.     "source": "ctx._source.tenderAddress +='66666' "
  6.   }
  7. }

使用 painless 脚本删除 _index 为“order”_id 为 “1”的doc

  1. POST order/_update/1
  2. {
  3.   "script":{
  4.     "lang": "painless",
  5.     "source": "ctx.op='delete'"
  6.   }
  7. }

upsert是update+insert的简写。所以使用upsert后，如果doc存在的话则是更新操作， 如果doc不存在则是插入操作。
_index 为“order”_id 为 “1”的doc下的tags字段是一个数组。

  1. POST order/_update/1
  2. {
  3.   "script": {
  4.     "lang": "painless",
  5.     "source": "ctx._source.tags.add(params.zhangdeshi)",
  6.     "params": {
  7.       "zhangdeshi":"真TM帅",
  8.       "xiangeshi":"真JB差"
  9.     }
  10.   },
  11.   "upsert": {
  12.     "age":"30",
  13.     "name":"李明",
  14.     "tags":[]
  15.   }
  16. }

使用expression表达式查询一个premium字段

  1. GET {_index}/_search
  2. {
  3.   "script_fields": {
  4.     "{给查询结果起个名字}": {
  5.       "script": {
  6.         "lang": "expression",
  7.         "source":"doc['premium']"
  8.       }
  9.     }
  10.   }
  11. }

使用expression表达式对premium字段打9折

  1. GET {_index}/_search
  2. {
  3.   "script_fields": {
  4.     "{给查询结果起个名字}": {
  5.       "script": {
  6.         "lang": "expression",
  7.         "source":"doc['premium'].value*0.9"
  8.       }    
  9.     }
  10.   }
  11. }

使用painless 查询一个premium字段打9折、打8折，使用参数

  1. GET order/_search
  2. {
  3.   "script_fields": {
  4.     "{给查询结果起个名字}": {
  5.       "script": {
  6.         "lang": "painless",
  7.         "source":"[doc['premium'].value*params.da9zhe,doc['premium'].value*params.da8zhe]",
  8.         "params": {
  9.           "da9zhe":0.9,
  10.           "da8zhe":0.8  
  11.         }
  12.       }
  13.     }
  14.   }
  15. }

Stored script

  1. 先保存一个script模板

    1. POST _scripts/{script-id}
    2. {
    3. "script": {
    4.      "lang": "painless",
    5.      "source":"[doc['premium'].value*params.da9zhe,doc['premium'].value*params.da8zhe]",
    6.      "params": {
    7.        "da9zhe":0.9,
    8.        "da8zhe":0.8  
    9.      }
    10.  }
    11. }

  2. 使用模板

    1. POST order/_search
    2. {
    3. "script_fields": {
    4.  "{给查询结果起个名字}": {
    5.    "script": {
    6.      "id":"{script-id}",
    7.      "params": {
    8.        "da9zhe":0.009,
    9.        "da8zhe":0.008  
    10.      }
    11.    }
    12.  }
    13. }
    14. }

使用自定义脚本，类似于存储过程，可以在里面写一些逻辑， if for 或者一些自定义运算。

  1. POST order/_update/2
  2. {
  3.   "script": {
  4.     "lang": "painless",
  5.     "source": """
  6.       ctx._source.premium *= ctx._source.rate;
  7.       ctx._source.amount += params.danwei
  8.     """,
  9.     "params": {
  10.       "danwei":"万元"
  11.     }
  12.   }
  13. }

查找premium大于等于10小于等于205的数据，并统计查找到的数据的insuranceCompany字段字符的总数。

  1. GET order/_search
  2. {
  3.   "query": {
  4.     "bool": {
  5.       "filter": [
  6.         {
  7.           "range": {
  8.             "premium": {
  9.               "gte": 10,
  10.               "lte": 205
  11.             }
  12.           }
  13.         }
  14.       ]
  15.     }
  16.   },
  17.   "aggs": {
  18.     "{给聚合查村结果起个名字}": {
  19.       "sum": {
  20.         "script": {
  21.           "lang": "painless",
  22.           "source": """
  23.             int total = 0;
  24.             for(int i = 0; i < doc['insuranceCompany.keyword'].length; i++){
  25.               total++;
  26.             }
  27.             return total;
  28.           """
  29.         }
  30.       }
  31.     }
  32.   },
  33.   "size": 0
  34. }

写入原理
image.png

6. 分词器

分词器里面有3个最重要的属性：

  1. char_filter

    分词之前字符预处理，过滤无用字符、无用标签等。 比如： 《Elasticsearch》=> Elasticsearch 新年好 =>“新年好”。

  2. tokenizer

    真正分词用的

  3. token_filter

    停用词、时态转换、大小写转换、同义词转换、语气词处理等。 比如： has=>have
    him=>he
    apples=>apple
    the/oh/a => 去掉

6.1 设置char_filter

  1. 新增索引名称为“my-index”，并指定分词器内的字符过滤器 ```json

    新增索引名称为“my-index”，并指定分词器内的字符过滤器

    PUT my-index { “settings”: { “analysis”: { //指定字符过滤器，名字为“my-charfilter”，指定的字符会被转换为其他内容 “char_filter”: {
    1.  "my-charfilter":{            //指定字符过滤器名字
    2.    "type":"mapping",        //指定过滤器类型
    3.    "mappings":["&=>and","&&=>and","|=>or","||=>or"]    //指定需要映射的字符
    4.  }
    }, //指定分词器内的字符过滤器为我们上面定义好的字符过滤器“my-charfilter” “analyzer”: {
    1.  "my-analyzer":{                //指定分词器的名字
    2.    "tokenizer":"keyword",
    3.    "char_filter":["my-charfilter"]    //指定要使用的字符过滤器
    4.  }
    } } } }

测试 my-index的字符过滤器my-charfilter

GET my-index/_analyze { “analyzer”: “my-analyzer”, “text”: [“666&77&&8||”] }

结果：

{ “tokens” : [ { “token” : “666and77and8or”, “start_offset” : 0, “end_offset” : 11, “type” : “word”, “position” : 0 } ] }

  2. 2. 新增索引名称为“my-index”，并指定分词器内的字符过滤器为“html_strip”，并指定逃逸标签
  3. ```json
  4. # 新增一个索引名字为my-index2 并指定字符过滤器
  5. PUT my-index2
  6. {
  7.   "settings": {
  8.     "analysis": {
  9.       //指定字符过滤器的名字为“my-charfilter”，类型为“html_strip”，逃逸标签为["a","p"]
  10.       "char_filter": {
  11.         "my-charfilter":{                        //指定字符过滤器名字
  12.           "type":"html_strip",            //指定过滤器类型
  13.           "escaped_tags":["a","p"]    //指定字符过滤器逃逸标签
  14.         }
  15.       },
  16.       //指定词法分分词器的名字为my-analyzer，字符过滤器为我们上面定义好的my-charfilter
  17.       "analyzer": {
  18.         "my-analyzer":{                            //指定分词器的名字
  19.           "tokenizer":"keyword",
  20.           "char_filter":["my-charfilter"]    //指定要使用的字符过滤器
  21.         }
  22.       }
  23.     }
  24.   }
  25. }
  27. # 测试
  28. GET my-index2/_analyze
  29. {
  30.   "analyzer": "my-analyzer",
  31.   "text": ["<a><b>hello word</b></a>", "<p>hello word</p>"]
  32. }
  34. # 结果：
  35. {
  36.   "tokens" : [
  37.     {
  38.       "token" : "666and77and8or",
  39.       "start_offset" : 0,
  40.       "end_offset" : 11,
  41.       "type" : "word",
  42.       "position" : 0
  43.     }
  44.   ]
  45. }
  1. 用正则匹配，并替换指定的字符 ```json

    用正则匹配，并替换指定的字符

    PUT my-index3 { “settings”: { “analysis”: { //设置字符过滤器 “char_filter”: { 
    1.  "my-charfilter":{             //指定字符过滤器名字
    2.    "type":"pattern_replace",   //指定过滤器类型
    3.    "pattern":"(\\d+)-(?=\\d)", //指定正则
    4.    "replacement":"$1_"         //指定匹配后的替换字符
    5.  }
    }, //指定词法分分词器的名字为my-analyzer，字符过滤器为我们上面定义好的my-charfilter “analyzer”: {
    1.  "my-analyzer":{             //指定分词器的名字
    2.    "tokenizer":"standard",
    3.    "char_filter":["my-charfilter"] //指定要使用的字符过滤器
    4.  }
    } } } }

测试

GET my-index3/_analyze { “analyzer”: “my-analyzer”, “text”: “My credit card is 123-456-789” }

结果： { “tokens” : [ { “token” : “My”, “start_offset” : 0, “end_offset” : 2, “type” : ““, “position” : 0 }, { “token” : “credit”, “start_offset” : 3, “end_offset” : 9, “type” : ““, “position” : 1 }, { “token” : “card”, “start_offset” : 10, “end_offset” : 14, “type” : ““, “position” : 2 }, { “token” : “is”, “start_offset” : 15, “end_offset” : 17, “type” : ““, “position” : 3 }, { “token” : “123_456_789”, “start_offset” : 18, “end_offset” : 29, “type” : ““, “position” : 4 } ] }

  1. <a name="sO5KC"></a>
  2. ## 6.2 设置token filter
  3. 什么都不带的
  4. ```json
  5. #测试：
  6. GET _analyze
  7. {
  8.   "tokenizer" : "standard",                //标准tokenizer
  9.   "filter" : ["lowercase"],                //小写过滤
  10.   "text" : "THE Quick FoX JUMPs"    //测试内容
  11. }
  12. # 结果：
  13. {
  14.   "tokens" : [
  15.     {
  16.       "token" : "the",
  17.       "start_offset" : 0,
  18.       "end_offset" : 3,
  19.       "type" : "<ALPHANUM>",
  20.       "position" : 0
  21.     },
  22.     {
  23.       "token" : "quick",
  24.       "start_offset" : 4,
  25.       "end_offset" : 9,
  26.       "type" : "<ALPHANUM>",
  27.       "position" : 1
  28.     },
  29.     {
  30.       "token" : "fox",
  31.       "start_offset" : 10,
  32.       "end_offset" : 13,
  33.       "type" : "<ALPHANUM>",
  34.       "position" : 2
  35.     },
  36.     {
  37.       "token" : "jumps",
  38.       "start_offset" : 14,
  39.       "end_offset" : 19,
  40.       "type" : "<ALPHANUM>",
  41.       "position" : 3
  42.     }
  43.   ]
  44. }

带脚本的

  1. #测试
  2. GET /_analyze
  3. {
  4.   "tokenizer" : "standard",                //标准tokenizer
  5.   "filter": [
  6.     {
  7.       "type": "condition",                //条件过滤器
  8.       "filter": [ "lowercase" ],    //转换为小写
  9.       "script": {                                    //条件脚本，满足脚本内的条件即会进行转换
  10.         "source": "token.getTerm().length() < 5"
  11.       }
  12.     }
  13.   ],
  14.   "text": "THE QUICK BROWN FOX"        //测试内容
  15. }
  17. 结果：
  18. {
  19.   "tokens" : [
  20.     {
  21.       "token" : "the",
  22.       "start_offset" : 0,
  23.       "end_offset" : 3,
  24.       "type" : "<ALPHANUM>",
  25.       "position" : 0
  26.     },
  27.     {
  28.       "token" : "QUICK",
  29.       "start_offset" : 4,
  30.       "end_offset" : 9,
  31.       "type" : "<ALPHANUM>",
  32.       "position" : 1
  33.     },
  34.     {
  35.       "token" : "BROWN",
  36.       "start_offset" : 10,
  37.       "end_offset" : 15,
  38.       "type" : "<ALPHANUM>",
  39.       "position" : 2
  40.     },
  41.     {
  42.       "token" : "fox",
  43.       "start_offset" : 16,
  44.       "end_offset" : 19,
  45.       "type" : "<ALPHANUM>",
  46.       "position" : 3
  47.     }
  48.   ]
  49. }

6.3 设置analyzer

停用词

  1. PUT /my_index8
  2. {
  3.   "settings": {
  4.     "analysis": {
  5.       //设置分词器
  6.       "analyzer": {
  7.         "my_analyzer":{           //名字为“my_analyzer”
  8.           "type":"standard",      //类型为标准类型
  9.           "stopwords":"_english_" //停用词为英语语法里面的标准停用词
  10.         }
  11.       }
  12.     }
  13.   }
  14. }
  16. #测试
  17. GET my_index8/_analyze
  18. {
  19.   "analyzer": "my_analyzer",
  20.   "text": "Teacher Ma is in the restroom"
  21. }
  23. #结果：
  24. {
  25.   "tokens" : [
  26.     {
  27.       "token" : "teacher",
  28.       "start_offset" : 0,
  29.       "end_offset" : 7,
  30.       "type" : "<ALPHANUM>",
  31.       "position" : 0
  32.     },
  33.     {
  34.       "token" : "ma",
  35.       "start_offset" : 8,
  36.       "end_offset" : 10,
  37.       "type" : "<ALPHANUM>",
  38.       "position" : 1
  39.     },
  40.     {
  41.       "token" : "restroom",
  42.       "start_offset" : 21,
  43.       "end_offset" : 29,
  44.       "type" : "<ALPHANUM>",
  45.       "position" : 5
  46.     }
  47.   ]
  48. }

6.4 设置analysis

  1. PUT my-index9
  2. {
  3.   "settings": {
  4.     "analysis": {
  5.       //设置字符过滤器
  6.       "char_filter": {
  7.         "test_char_filter": {       //字符过滤器名字为“test_char_filter”
  8.           "type": "mapping",        //类型为mapping
  9.           "mappings": [  "& => and", "| => or" ]
  10.         }
  11.       },
  12.       //设置过滤器
  13.       "filter": {
  14.         "test_stopwords": {         //过滤器名字为test_stopwords
  15.           "type": "stop",           //类型为stop
  16.           "stopwords": ["is","in","at","the","a","for"]
  17.         }
  18.       },
  19.       //设置分词器
  20.       "tokenizer": {
  21.         "punctuation": { 
  22.           "type": "pattern",       //类型为正则匹配型
  23.           "pattern": "[ .,!?]"      //正则
  24.         }
  25.       },
  26.       "analyzer": {
  27.         "my_analyzer": {           //分析器名字为my_analyzer
  28.           "type": "custom",        //设置type为custom告诉Elasticsearch我们正在定义一个定制分析器
  29.           "char_filter": [         //设置字符过滤器一个是我们自定义的test_char_filter，一个是内置的html_strip
  30.             "test_char_filter",
  31.             "html_strip"
  32.           ],
  33.           "tokenizer": "standard", //设置tokenizer为standard                            
  34.           "filter": ["lowercase","test_stopwords"]//设置过滤器为内置的lowercase和我们自定义的test_stopwords
  35.         }
  36.       }
  37.     }
  38.   }
  39. }
  41. # 测试
  42. GET my-index9/_analyze
  43. {
  44.   "text": "Teacher ma & zhang also thinks [mother's friends] is good | nice!!!",
  45.   "analyzer": "my_analyzer"
  46. }
  48. #结果
  49. {
  50.   "tokens" : [
  51.     {
  52.       "token" : "teacher",
  53.       "start_offset" : 0,
  54.       "end_offset" : 7,
  55.       "type" : "<ALPHANUM>",
  56.       "position" : 0
  57.     },
  58.     {
  59.       "token" : "ma",
  60.       "start_offset" : 8,
  61.       "end_offset" : 10,
  62.       "type" : "<ALPHANUM>",
  63.       "position" : 1
  64.     },
  65.     {
  66.       "token" : "and",
  67.       "start_offset" : 11,
  68.       "end_offset" : 12,
  69.       "type" : "<ALPHANUM>",
  70.       "position" : 2
  71.     },
  72.     {
  73.       "token" : "zhang",
  74.       "start_offset" : 13,
  75.       "end_offset" : 18,
  76.       "type" : "<ALPHANUM>",
  77.       "position" : 3
  78.     },
  79.     {
  80.       "token" : "also",
  81.       "start_offset" : 19,
  82.       "end_offset" : 23,
  83.       "type" : "<ALPHANUM>",
  84.       "position" : 4
  85.     },
  86.     {
  87.       "token" : "thinks",
  88.       "start_offset" : 24,
  89.       "end_offset" : 30,
  90.       "type" : "<ALPHANUM>",
  91.       "position" : 5
  92.     },
  93.     {
  94.       "token" : "mother's",
  95.       "start_offset" : 32,
  96.       "end_offset" : 40,
  97.       "type" : "<ALPHANUM>",
  98.       "position" : 6
  99.     },
  100.     {
  101.       "token" : "friends",
  102.       "start_offset" : 41,
  103.       "end_offset" : 48,
  104.       "type" : "<ALPHANUM>",
  105.       "position" : 7
  106.     },
  107.     {
  108.       "token" : "good",
  109.       "start_offset" : 53,
  110.       "end_offset" : 57,
  111.       "type" : "<ALPHANUM>",
  112.       "position" : 9
  113.     },
  114.     {
  115.       "token" : "or",
  116.       "start_offset" : 58,
  117.       "end_offset" : 59,
  118.       "type" : "<ALPHANUM>",
  119.       "position" : 10
  120.     },
  121.     {
  122.       "token" : "nice",
  123.       "start_offset" : 60,
  124.       "end_offset" : 64,
  125.       "type" : "<ALPHANUM>",
  126.       "position" : 11
  127.     }
  128.   ]
  129. }

6.5 完整的mapping+analysis

  1. PUT my_index12
  2. {
  3.   "settings": {
  4.     "analysis": {
  5.       //设置字符过滤器
  6.       "char_filter": {
  7.         "test_char_filter": {       //字符过滤器名字为“test_char_filter”
  8.           "type": "mapping",        //类型为mapping
  9.           "mappings": [  "& => and", "| => or" ]
  10.         }
  11.       },
  12.       //设置过滤器
  13.       "filter": {
  14.         "test_stopwords": {         //过滤器名字为test_stopwords
  15.           "type": "stop",           //类型为stop
  16.           "stopwords": ["is","in","at","the","a","for"]
  17.         }
  18.       },
  19.       //设置分词器
  20.       "tokenizer": {
  21.         "punctuation": { 
  22.           "type": "pattern",       //类型为正则匹配型
  23.           "pattern": "[ .,!?]"      //正则
  24.         }
  25.       },
  26.       "analyzer": {
  27.         "my_analyzer": {           //分析器名字为my_analyzer
  28.           "type": "custom",        //设置type为custom告诉Elasticsearch我们正在定义一个定制分析器
  29.           "char_filter": [         //设置字符过滤器一个是我们自定义的test_char_filter，一个是内置的html_strip
  30.             "test_char_filter",
  31.             "html_strip"
  32.           ],
  33.           "tokenizer": "standard", //设置tokenizer为standard                            
  34.           "filter": ["lowercase","test_stopwords"]//设置过滤器为内置的lowercase和我们自定义的test_stopwords
  35.         }
  36.       }
  37.     }
  38.   },
  39.   "mappings": {
  40.     "properties": {
  41.       //设置字段“name”
  42.       "name": {   
  43.         "type": "text",               //设置类型为文本类型
  44.         "analyzer": "my_analyzer",    //指定分词器
  45.         "search_analyzer": "standard" //设置搜索时分词器
  46.       },
  47.       //设置字段“said”
  48.       "said": {
  49.         "type": "text",               //设置类型为文本类型
  50.         "analyzer": "my_analyzer",    //指定分词器
  51.         "search_analyzer": "standard" //设置搜索时分词器
  52.       }
  53.     }
  54.   }
  55. }

6.6 中文分词器 ik

1. ik安装并使用

ik是一个java项目，使用maven构建，我们把它clone下来，使用maven命令package。在target/release/下面有个zip文件。elasticsearch-analysis-ik-7.4.0.zip
图片.png
把 elasticsearch-analysis-ik-7.4.0.zip解压后是这个样子
图片.png
将这些文件全部copy至{``ES_source_path``}``/plugins/ik文件夹下面（需要在plugins下面创建ik文件夹）。
图片.png
然后重启Elasticsearch。

测试 ik中文分词器 ：

  1. # 测试 ik中文分词器 
  2. GET _analyze
  3. {
  4.   "analyzer": "ik_max_word", //指定分词器为ik内置的两大分词器之一“ik_max_word”
  5.   "text": [ "美国留给伊拉克的是个烂摊子吗"  ] //测试数据
  6. }
  8. # 结果
  9. {
  10.   "tokens" : [
  11.     {
  12.       "token" : "美国",
  13.       "start_offset" : 0,
  14.       "end_offset" : 2,
  15.       "type" : "CN_WORD",
  16.       "position" : 0
  17.     },
  18.     {
  19.       "token" : "留给",
  20.       "start_offset" : 2,
  21.       "end_offset" : 4,
  22.       "type" : "CN_WORD",
  23.       "position" : 1
  24.     },
  25.     {
  26.       "token" : "伊拉克",
  27.       "start_offset" : 4,
  28.       "end_offset" : 7,
  29.       "type" : "CN_WORD",
  30.       "position" : 2
  31.     },
  32.     {
  33.       "token" : "的",
  34.       "start_offset" : 7,
  35.       "end_offset" : 8,
  36.       "type" : "CN_CHAR",
  37.       "position" : 3
  38.     },
  39.     {
  40.       "token" : "是",
  41.       "start_offset" : 8,
  42.       "end_offset" : 9,
  43.       "type" : "CN_CHAR",
  44.       "position" : 4
  45.     },
  46.     {
  47.       "token" : "个",
  48.       "start_offset" : 9,
  49.       "end_offset" : 10,
  50.       "type" : "CN_CHAR",
  51.       "position" : 5
  52.     },
  53.     {
  54.       "token" : "烂摊子",
  55.       "start_offset" : 10,
  56.       "end_offset" : 13,
  57.       "type" : "CN_WORD",
  58.       "position" : 6
  59.     },
  60.     {
  61.       "token" : "摊子",
  62.       "start_offset" : 11,
  63.       "end_offset" : 13,
  64.       "type" : "CN_WORD",
  65.       "position" : 7
  66.     },
  67.     {
  68.       "token" : "吗",
  69.       "start_offset" : 13,
  70.       "end_offset" : 14,
  71.       "type" : "CN_CHAR",
  72.       "position" : 8
  73.     }
  74.   ]
  75. }

安装过程中可能遇到的问题：

java.lang.IllegalArgumentException: Plugin [analysis-ik] was built for Elasticsearch version 7.10.0 but version 7.10.1 is running

一看就是ik和Elasticsearch版本不匹配，我们需要把ik分词器内的Elasticsearch版本改为ik对应的版本。
编辑plugin-descriptor.properties文件：里面有个“elasticsearch.version” 将它改为Elasticsearch版本即可。
图片.png

2. ik两种analyzer

ik_max_word：细粒度，一般都使用这个。
ik_smart：粗粒度

3. config下的文件描述

  • IKAnalyzer.cfg.xml ： IK分词配置文件
  • main.dic ：主词库
  • stopword.dic ：英文停用词,不会建立在倒排索引中
  • quantifier.dic ：特殊词库：计量单位等
  • suffix.dic ：特殊词库：后缀名
  • a. surname.dic ：特殊词库：百家姓
  • preposition ：特殊词库：语气词

4. 如何热更新ik词库

方案一：修改IK源码，定时链接数据库，查询主词和停用词，更新到本机IK中。

方案二：定时调接口
目前该插件支持热更新 IK 分词，通过在 IKAnalyzer.cfg.xml 配置文件中提到的如下配置
图片.png

其中 words_location 是指一个 URL接口地址，该请求只需满足以下两点即可完成分词热更新。

  1. 该 http 请求需要返回两个头部(header)，一个是 **Last-Modified**，一个是 **ETag**，这两者都是字符串类型，只要有一个发生变化，该插件就会去抓取新的分词进而更新词库。
  2. 该 http 请求返回的内容格式是**一行一个分词**，换行符用** \n** 即可。

满足上面两点要求就可以实现热更新分词了，不需要重启 ES 实例。

下面是用spring boot模拟的一个接口：

  1. /**
  2. * 获取ik自定义词典
  3. * @param response
  4. */
  5. @RequestMapping(value="/getCustomDict")
  6. public void getCustomDict(HttpServletResponse response){
  7.     try {
  8.         //具体数据可以连接数据库或者缓存类获取
  9.         String[] dicWords = new String[]{"雷猴啊","割韭菜","996","实力装X","颜值担当"};
  10.         //响应数据
  11.         StringJoiner content = new StringJoiner(System.lineSeparator());
  12.         for (String dicWord : dicWords) {
  13.             content.add(dicWord);
  14.         }
  15.         response.setHeader("Last-Modified", String.valueOf(content.length()));
  16.         response.setHeader("ETag",String.valueOf(content.length()));
  17.         response.setContentType("text/plain; charset=utf-8");
  18.         OutputStream out= response.getOutputStream();
  19.         out.write(content.toString().getBytes("UTF-8"));
  20.         out.flush();
  21.     } catch (Exception e) {
  22.         e.printStackTrace();
  23.     }
  24. }

7. 前缀、通配符、正则、模糊查询

  1. # 设置前缀索引
  2. PUT my_index
  3. {
  4.   "mappings": {
  5.     "properties": {
  6.       "title":{             //字段名字
  7.         "type": "text",     //类型为文本类型
  8.         "index_prefixes":{  //索引前缀设置
  9.           "min_chars":2,      //字段前缀最少2个字符生成索引
  10.           "max_chars":4       //字段前缀最多4个字符生成索引
  11.         }
  12.       }
  13.     }
  14.   }
  15. }
  17. # 批量插入中文测试数据
  18. POST /my_index/_bulk
  19. { "index": { "_id": "1"} }
  20. { "title": "城管打电话喊商贩去摆摊摊" }
  21. { "index": { "_id": "2"} }
  22. { "title": "笑果文化回应商贩老农去摆摊" }
  23. { "index": { "_id": "3"} }
  24. { "title": "老农耗时17年种出椅子树" }
  25. { "index": { "_id": "4"} }
  26. { "title": "夫妻结婚30多年AA制,被城管抓" }
  27. { "index": { "_id": "5"} }
  28. { "title": "黑人见义勇为阻止抢劫反被铐住" }
  30. # 批量插入英文测试数据
  31. POST /my_index/_bulk
  32. { "index": { "_id": "6"} }
  33. { "title": "my english" }
  34. { "index": { "_id": "7"} }
  35. { "title": "my english is good" }
  36. { "index": { "_id": "8"} }
  37. { "title": "my chinese is good" }
  38. { "index": { "_id": "9"} }
  39. { "title": "my japanese is nice" }
  40. { "index": { "_id": "10"} }
  41. { "title": "my disk is full" }
  44. #前缀搜索
  45. GET my_index/_search
  46. {
  47.   "query": {
  48.     "prefix": {    //prefix为前缀搜索      
  49.       "title": {   //指定需要前缀搜索的字段名称
  50.         "value": "城管" //指定字段值
  51.       }
  52.     }
  53.   }
  54. }
  56. # 测试ik分词器
  57. GET /_analyze
  58. {
  59.   "text": "城管打电话喊商贩去摆摊摊",
  60.   "analyzer": "ik_smart"
  61. }
  63. #通配符
  64. GET my_index/_search
  65. {
  66.   "query": {
  67.     "wildcard": {
  68.       "title": {
  69.         "value": "eng?ish"
  70.       }
  71.     }
  72.   }
  73. }
  75. #通配符
  76. GET order/_search
  77. {
  78.   "query": {
  79.     "wildcard": {
  80.       "insuranceCompany.keyword": {
  81.         "value": "中?联合"
  82.       }
  83.     }
  84.   }
  85. }
  87. #通配符
  88. GET product/_search
  89. {
  90.   "query": {
  91.     "wildcard": {
  92.       "name.keyword": {
  93.         "value": "xiaomi*nfc*",
  94.         "boost": 1.0
  95.       }
  96.     }
  97.   }
  98. }
  100. #正则
  101. GET product/_search
  102. {
  103.   "query": {
  104.     "regexp": {
  105.       "name": {
  106.         "value": "[\\s\\S]*nfc[\\s\\S]*",
  107.         "flags": "ALL",
  108.         "max_determinized_states": 10000,
  109.         "rewrite": "constant_score"
  110.       }
  111.     }
  112.   }
  113. }
  116. # 模糊搜索fuzzy
  117. GET order/_search
  118. {
  119.   "query": {
  120.     "match": {
  121.       "tenderAddress": {      //指定需要搜索的字段的名字
  122.         "query": "乔呗",      //指定需要搜索的模糊值
  123.         "fuzziness": "AUTO",  //指定模糊模式，默认“AUTO”
  124.         "operator": "or"      //指定操作类型，默认“or”
  125.       }
  126.     }
  127.   }
  128. }
  131. # 前缀短语搜索match_phrase_prefix
  132. GET /order/_search
  133. {
  134.   "query": {
  135.     //前缀短语搜索
  136.     "match_phrase_prefix": {
  137.       "bidInvationCenter": {    //指定字段
  138.         "query": "中国",        //前缀短语值
  139.         "analyzer": "ik_smart", //设置分词器
  140.         "max_expansions": 1,    //限制匹配的最大词项,参数告诉 match_phrase 查询词条相隔多远时仍然能将文档视为匹配 什么是相隔多远？ 意思是说为了让查询和文档匹配你需要移动词条多少次？
  141.         "slop": 2,              //允许短语间的词项(term)间隔
  142.         "boost": 1              //用于设置该查询的权重
  143.       }
  144.     }
  145.   }
  146. }
  148. GET _search
  149. {
  150.   "query": {
  151.     "match_phrase_prefix": {
  152.       "message": {
  153.         "query": "quick brown f"
  154.       }
  155.     }
  156.   }
  157. }

8. TF-IDF算法、Java API序幕

官网的资料才是最新的，最全的：https://www.elastic.co/guide/en/elasticsearch/client/java-rest/current/java-rest-overview.html

引入maven

  1. <dependency>
  2.     <groupId>org.elasticsearch.client</groupId>
  3.     <artifactId>elasticsearch-rest-high-level-client</artifactId>
  4.     <version>7.11.1</version>
  5. </dependency>
  7. <repositories>
  8.     <repository>
  9.         <id>es-snapshots</id>
  10.         <name>elasticsearch snapshot repo</name>
  11.         <url>https://snapshots.elastic.co/maven/</url>
  12.     </repository>
  13. </repositories>
  15. <repository>
  16.     <id>elastic-lucene-snapshots</id>
  17.     <name>Elastic Lucene Snapshots</name>
  18.     <url>https://s3.amazonaws.com/download.elasticsearch.org/lucenesnapshots/83f9835</url>
  19.     <releases><enabled>true</enabled></releases>
  20.     <snapshots><enabled>false</enabled></snapshots>
  21. </repository>

8.1 基本增删改查

  1. import org.apache.http.HttpHost;
  2. import org.elasticsearch.action.admin.indices.create.CreateIndexRequest;
  3. import org.elasticsearch.action.admin.indices.create.CreateIndexResponse;
  4. import org.elasticsearch.action.admin.indices.delete.DeleteIndexRequest;
  5. import org.elasticsearch.action.admin.indices.delete.DeleteIndexResponse;
  6. import org.elasticsearch.action.bulk.BulkRequest;
  7. import org.elasticsearch.action.bulk.BulkResponse;
  8. import org.elasticsearch.action.delete.DeleteRequest;
  9. import org.elasticsearch.action.delete.DeleteResponse;
  10. import org.elasticsearch.action.get.GetRequest;
  11. import org.elasticsearch.action.get.GetResponse;
  12. import org.elasticsearch.action.index.IndexRequest;
  13. import org.elasticsearch.action.index.IndexResponse;
  14. import org.elasticsearch.action.update.UpdateRequest;
  15. import org.elasticsearch.action.update.UpdateResponse;
  16. import org.elasticsearch.client.RequestOptions;
  17. import org.elasticsearch.client.RestClient;
  18. import org.elasticsearch.client.RestHighLevelClient;
  19. import org.elasticsearch.common.settings.Settings;
  20. import org.elasticsearch.common.xcontent.XContentType;
  22. import java.io.IOException;
  23. import java.util.HashMap;
  24. import java.util.Map;
  26. public class TestElasticsearch {
  28.     public static void main(String[] args) throws IOException {
  29.         RestHighLevelClient client = createClient();//创建链接，创建客户端
  30.         try {
  31. //        createIndex(client); //创建索引
  32. //        addData(client);     //添加数据
  33. //        queryData(client);   //查询数据
  34. //        updateData(client);  //修改数据
  35. //        queryData(client);   //查询数据
  36. //        deleteData(client);  //删除数据
  37. //        deleteIndex(client); //删除索引
  38.         bulk(client);        //批量操作
  39.         }catch (Exception e){
  40.             e.printStackTrace();
  41.         }finally {
  42.             if (client != null){
  43.                 closeClient(client); //关闭客户端
  44.             }
  45.         }
  46.     }
  49.     /**
  50.      * 创建链接，创建客户端
  51.      * @return
  52.      */
  53.     public static RestHighLevelClient createClient(){
  54.         //创建链接，创建客户端
  55.         HttpHost http9200 = new HttpHost("8.140.122.156", 9200, "http");
  56. //        HttpHost http9201 = new HttpHost("8.140.122.156", 9201, "http");
  57.         RestHighLevelClient client = new RestHighLevelClient(RestClient.builder(http9200));
  58.         return client;
  59.     }
  62.     /**
  63.      * 关闭客户端
  64.      * @param client
  65.      * @throws IOException
  66.      */
  67.     public static void closeClient(RestHighLevelClient client) throws IOException {
  68.         client.close();
  69.     }
  72.     /**
  73.      * 创建索引
  74.      * PUT order1
  75.      * {
  76.      *   "settings": {
  77.      *     "number_of_shards": 3,
  78.      *     "number_of_replicas": 2
  79.      *   },
  80.      *   "mappings": {
  81.      *     "properties": {
  82.      *       "id":{
  83.      *         "type": "long"
  84.      *       },
  85.      *       "age":{
  86.      *         "type": "short"
  87.      *       },
  88.      *       "mail":{
  89.      *         "type": "text",
  90.      *         "fields": {
  91.      *           "keyword" : {
  92.      *             "type" : "keyword",
  93.      *             "ignore_above" : 64
  94.      *           }
  95.      *         }
  96.      *       },
  97.      *       "name":{
  98.      *         "type": "text",
  99.      *         "fields": {
  100.      *           "keyword" : {
  101.      *             "type" : "keyword",
  102.      *             "ignore_above" : 64
  103.      *           }
  104.      *         }
  105.      *       },
  106.      *       "createTime":{
  107.      *         "type": "date",
  108.      *         "format": ["yyyy-MM-dd HH:mm:ss"]
  109.      *       }
  110.      *     }
  111.      *   }
  112.      * }
  113.      * @param client
  114.      * @throws IOException
  115.      */
  116.     public static void createIndex(RestHighLevelClient client) throws IOException {
  117.         //设置3个分片，每个分片2副本
  118.         Settings settings = Settings.builder()
  119.                 .put("number_of_shards",3)
  120.                 .put("number_of_replicas",2)
  121.                 .build();
  123.         //新增索引
  124.         CreateIndexRequest createIndexRequest = new CreateIndexRequest("order1");
  125.         createIndexRequest.mapping("properties","{\"id\":{\"type\":\"long\"},\"age\":{\"type\":\"short\"},\"mail\":{\"type\":\"text\",\"fields\":{\"keyword\":{\"type\":\"keyword\",\"ignore_above\":64}}},\"name\":{\"type\":\"text\",\"fields\":{\"keyword\":{\"type\":\"keyword\",\"ignore_above\":64}}},\"createTime\":{\"type\":\"date\",\"format\":[\"yyyy-MM-dd HH:mm:ss\"]}}",XContentType.JSON);
  126.         createIndexRequest.settings(settings);
  127.         //执行
  128.         CreateIndexResponse createIndexResponse = client.indices().create(createIndexRequest, RequestOptions.DEFAULT);
  129.         System.out.println("创建索引结果: "+createIndexResponse.isAcknowledged());
  130.     }
  133.     /**
  134.      * 插入数据
  135.      *
  136.      * @param client
  137.      * @throws IOException
  138.      */
  139.     public static void addData(RestHighLevelClient client) throws IOException {
  140.         //数据
  141.         Map personMap = new HashMap();
  142.         personMap.put("id",1);
  143.         personMap.put("age",28);
  144.         personMap.put("name","王帆");
  145.         personMap.put("email","wangfan@yxinsur.com");
  146.         personMap.put("createTime","2020-02-02 12:00:00");
  148.         //新增索引
  149.         IndexRequest indexRequest = new IndexRequest("order1","_doc","1");
  150.         indexRequest.source(personMap);
  151.         //执行
  152.         IndexResponse indexResponse = client.index(indexRequest, RequestOptions.DEFAULT);
  153.         System.out.println("插入数据结果: "+indexResponse.toString());
  154.     }
  157.     /**
  158.      * 查询数据
  159.      * GET order1/_doc/1
  160.      * @param client
  161.      * @throws IOException
  162.      */
  163.     public static void queryData(RestHighLevelClient client) throws IOException {
  164.         //查询索引
  165.         GetRequest getRequest = new GetRequest("order1","_doc","1");
  167.         //执行
  168.         GetResponse getResponse = client.get(getRequest, RequestOptions.DEFAULT);
  169.         System.out.println("查询数据结果: "+getResponse.toString());
  170.     }
  173.     /**
  174.      * 修改数据
  175.      * PUT order1/_doc/1
  176.      * {
  177.      *   "name": "王帆",
  178.      *   "age": 29,
  179.      *   "email": "wangfan@yxinsur.com"
  180.      * }
  181.      * @param client
  182.      * @throws IOException
  183.      */
  184.     public static void updateData(RestHighLevelClient client) throws IOException {
  186.         //实际数据
  187.         Map<String,Object> personMap = new HashMap<>();
  188.         personMap.put("id",1);
  189.         personMap.put("age",29);
  190.         personMap.put("name","王帆");
  191.         personMap.put("email","wangfan@yxinsur.com");
  192.         personMap.put("createTime","2020-02-02 12:00:00");
  194.         //修改索引
  195.         UpdateRequest updateRequest = new UpdateRequest("order1","_doc","1");
  196.         updateRequest.doc(personMap);
  198.         //或者是upsert
  199.         //updateRequest.upsert(person);
  201.         //执行
  202.         UpdateResponse updateResponse = client.update(updateRequest, RequestOptions.DEFAULT);
  203.         System.out.println("修改数据结果: "+updateResponse.toString());
  204.     }
  207.     /**
  208.      * 删除数据
  209.      * DELETE order1/_doc/1
  210.      * @param client
  211.      * @throws IOException
  212.      */
  213.     public static void deleteData(RestHighLevelClient client) throws IOException {
  214.         //删除数据
  215.         DeleteRequest deleteRequest = new DeleteRequest("order1","_doc","1");
  216.         //执行
  217.         DeleteResponse deleteResponse = client.delete(deleteRequest, RequestOptions.DEFAULT);
  218.         System.out.println("删除数据结果: "+deleteResponse.toString());
  219.     }
  222.     /**
  223.      * 删除索引
  224.      * DELETE order1/_doc/1
  225.      * @param client
  226.      * @throws IOException
  227.      */
  228.     public static void deleteIndex(RestHighLevelClient client) throws IOException {
  229.         //删除索引
  230.         DeleteIndexRequest deleteIndexRequest = new DeleteIndexRequest("order1");
  231.         //执行
  232.         DeleteIndexResponse deleteIndexResponse = client.indices().delete(deleteIndexRequest, RequestOptions.DEFAULT);
  233.         System.out.println("删除索引结果: "+deleteIndexResponse.isAcknowledged());
  234.     }
  237.     /**
  238.      * 批量操作
  239.      * @param client
  240.      */
  241.     public static void bulk(RestHighLevelClient client) throws IOException {
  242.         //准备数据
  243.         Map<String,Object> personMap = new HashMap<>();
  244.         personMap.put("id",2);
  245.         personMap.put("age",29);
  246.         personMap.put("name","王帆");
  247.         personMap.put("email","wangfan@yxinsur.com");
  248.         personMap.put("createTime","2020-02-02 12:00:00");
  250.         //插入数据操作
  251.         IndexRequest indexRequest2 = new IndexRequest("order1","_doc","2");
  252.         indexRequest2.source(personMap,XContentType.JSON);
  253.         IndexRequest indexRequest3 = new IndexRequest("order1","_doc","3");
  254.         indexRequest3.source(personMap,XContentType.JSON);
  256.         //修改数据操作
  257.         personMap.put("age",30);
  258.         UpdateRequest updateRequest = new UpdateRequest("order1","_doc","2");
  259.         updateRequest.doc(personMap,XContentType.JSON);
  261.         //删除数据操作
  262.         DeleteRequest deleteRequest = new DeleteRequest("order1","_doc","2");
  264.         //将操作都放入bulk里面
  265.         BulkRequest bulkRequest = new BulkRequest();
  266.         bulkRequest.add(indexRequest2);
  267.         bulkRequest.add(indexRequest3);
  268.         bulkRequest.add(updateRequest);
  269.         bulkRequest.add(deleteRequest);
  271.         //执行
  272.         BulkResponse bulkResponse = client.bulk(bulkRequest, RequestOptions.DEFAULT);
  273.         System.out.println("批量操作结果: "+bulkResponse.toString());
  274.     }
  276. }

创建索引结果: true插入数据结果: IndexResponse[index=order1,type=_doc,id=1,version=1,result=created,seqNo=0,primaryTerm=1,shards={“total”:3,”successful”:1,”failed”:0}] 查询数据结果: {“_index”:”order1”,”_type”:”_doc”,”_id”:”1”,”_version”:1,”found”:true,”_source”:{“createTime”:”2020-02-02 12:00:00”,”name”:”王帆”,”id”:1,”age”:28,”email”:”wangfan@yxinsur.com”},”fields”:{“_seq_no”:[0],”_primary_term”:[1]}}修改数据结果: UpdateResponse[index=order1,type=_doc,id=1,version=2,seqNo=1,primaryTerm=1,result=updated,shards=ShardInfo{total=3, successful=1, failures=[]}]查询数据结果: {“_index”:”order1”,”_type”:”_doc”,”_id”:”1”,”_version”:2,”found”:true,”_source”:{“createTime”:”2020-02-02 12:00:00”,”name”:”王帆”,”id”:1,”age”:29,”email”:”wangfan@yxinsur.com”},”fields”:{“_seq_no”:[1],”_primary_term”:[1]}}删除数据结果: DeleteResponse[index=order1,type=_doc,id=1,version=3,result=deleted,shards=ShardInfo{total=3, successful=1, failures=[]}]删除索引结果: true批量操作结果: org.elasticsearch.action.bulk.BulkResponse@793be5ca

9. ES集群部署

配置文件说明：

  • cluster.name:

整个集群的名称，整个集群使用一个名字，其他节点通过cluster.name发现集群。

  • node.name：

集群内某个节点的名称，其他节点可通过node.name发现节点，默认是机器名。

  • path.data：

数据存放地址，生产环境必须不能设置为es内部，否则es更新时会直接抹除数据

  • path.logs：

日志存在地址，生产环境必须不能设置为es内部，否则es更新时会直接抹除数据

  • bootstrap.memory_lock：

是否禁用swap交换区(swap交换区为系统内存不够时使用磁盘作为临时空间)， 生产环境必须禁用

  • network.host：

当前节点绑定的Ip地址，切记一旦指定，则必须是这个地址才能访问，比如：如果配置为，127.0.0.1， 则必须只能是127.0.0.1才能访问， localhost 也不行。

  • http.port：

当前节点的服务端口号

  • transport.port：

当前节点的通讯端口号，集群内节点之间通讯使用此端口号， 比如选举master节点时。

  • discovery.seed_hosts：

必须把所有master节点的地址+端口都写进去。

  • cluster.initial_master_nodes:

集群初始化时会从这个列表中取出一个node.name选为master节点。

整个集群搭建模型：

节点名称 node.master node.data 描述
node01 true false master节点
node02 true false master节点
node03 true false master节点
node04 false true 纯数据节点
node05 false true 纯数据节点
node06 false false 仅投票节点,路由节点

机器内网ip：172.27.229.9
集器外网ip：8.140.122.156

node01 配置：

  1. cluster.name: my-application
  2. node.name: node01
  3. path.data: /root/soft/elasticsearch/data/node01
  4. path.logs: /root/soft/elasticsearch/log/node01
  5. bootstrap.memory_lock: false
  6. network.host: 172.27.229.9
  7. http.port: 9200
  8. transport.port: 9300
  9. discovery.seed_hosts: ["172.27.229.9:9300", "172.27.229.9:9301","172.27.229.9:9302",]
  10. cluster.initial_master_nodes: ["node01","node02","node03"]
  11. http.cors.enabled: true
  12. http.cors.allow-origin: "*"
  13. node.master: true
  14. node.data: false
  15. node.max_local_storage_nodes: 6

node02 配置：

  1. cluster.name: my-application
  2. node.name: node02
  3. path.data: /root/soft/elasticsearch/data/node02
  4. path.logs: /root/soft/elasticsearch/log/node02
  5. bootstrap.memory_lock: false
  6. network.host: 172.27.229.9
  7. http.port: 9201
  8. transport.port: 9301
  9. discovery.seed_hosts: ["172.27.229.9:9300", "172.27.229.9:9301","172.27.229.9:9302",]
  10. cluster.initial_master_nodes: ["node01","node02","node03"]
  11. http.cors.enabled: true
  12. http.cors.allow-origin: "*"
  13. node.master: true
  14. node.data: false
  15. node.max_local_storage_nodes: 6

node03 配置：

  1. cluster.name: my-application
  2. node.name: node03
  3. path.data: /root/soft/elasticsearch/data/node03
  4. path.logs: /root/soft/elasticsearch/log/node03
  5. bootstrap.memory_lock: false
  6. network.host: 172.27.229.9
  7. http.port: 9202
  8. transport.port: 9302
  9. discovery.seed_hosts: ["172.27.229.9:9300", "172.27.229.9:9301","172.27.229.9:9302",]
  10. cluster.initial_master_nodes: ["node01","node02","node03"]
  11. http.cors.enabled: true
  12. http.cors.allow-origin: "*"
  13. node.master: true
  14. node.data: false
  15. node.max_local_storage_nodes: 6

node04 配置：

  1. cluster.name: my-application
  2. node.name: node04
  3. path.data: /root/soft/elasticsearch/data/node04
  4. path.logs: /root/soft/elasticsearch/log/node04
  5. bootstrap.memory_lock: false
  6. network.host: 172.27.229.9
  7. http.port: 9203
  8. transport.port: 9303
  9. discovery.seed_hosts: ["172.27.229.9:9300", "172.27.229.9:9301","172.27.229.9:9302",]
  10. cluster.initial_master_nodes: ["node01","node02","node03"]
  11. http.cors.enabled: true
  12. http.cors.allow-origin: "*"
  13. node.master: false
  14. node.data: true
  15. node.max_local_storage_nodes: 6

node05 配置：

  1. cluster.name: my-application
  2. node.name: node05
  3. path.data: /root/soft/elasticsearch/data/node05
  4. path.logs: /root/soft/elasticsearch/log/node05
  5. bootstrap.memory_lock: false
  6. network.host: 172.27.229.9
  7. http.port: 9204
  8. transport.port: 9304
  9. discovery.seed_hosts: ["172.27.229.9:9300", "172.27.229.9:9301","172.27.229.9:9302",]
  10. cluster.initial_master_nodes: ["node01","node02","node03"]
  11. http.cors.enabled: true
  12. http.cors.allow-origin: "*"
  13. node.master: false
  14. node.data: true
  15. node.max_local_storage_nodes: 6

node05 配置：

  1. cluster.name: my-application
  2. node.name: node06
  3. path.data: /root/soft/elasticsearch/data/node06
  4. path.logs: /root/soft/elasticsearch/log/node06
  5. bootstrap.memory_lock: false
  6. network.host: 172.27.229.9
  7. http.port: 9205
  8. transport.port: 9305
  9. discovery.seed_hosts: ["172.27.229.9:9300", "172.27.229.9:9301","172.27.229.9:9302",]
  10. cluster.initial_master_nodes: ["node01","node02","node03"]
  11. http.cors.enabled: true
  12. http.cors.allow-origin: "*"
  13. node.master: false
  14. node.data: false
  15. node.max_local_storage_nodes: 6