2004年 Shay Banon 基于Lucene开发了 Compass
2010年 Shay Banon 重写了 Compass，取名 Elasticsearch
查询性能好（Near Real Time）
支持分布式，可水平扩展
支持多语言的集成：降低全文检索的学习曲线，可以被任何编程语言调用
海量数据的用户式存储以及集群管理
近实时搜索，性能卓越
海量数据的近实时分析
0.4：2010年2月第一次发布
1.0：2014年1月
2.0：2015年10月
5.0：2016年10月
6.0：2017年10月
7.0：2019年10月
搜索类：继承数据库同步数据 / 独立作为数据存储使用（不推荐）
日志型：Logstash 和 Beats 满足不同的数据源，Kafka作为消息队列
数据处理通道
特性：
可视化分析利器，web
清理的数据采集器
商业化套件
下载地址：https://www.elastic.co/cn/downloads/elasticsearch
jdk11下载：https://download.java.net/java/GA/jdk11/13/GPL/openjdk-11.0.1_linux-x64_bin.tar.gz
can not run elasticsearch as root
# 创建用户 adduser elasticsearch01 # 创建密码 passwd elasticsearch01 # 给文件赋予权限 chown -R elasticsearch01 elasticsearch-6.0.0 # 切换用户 su elasticsearch01 # 后台启动 ./elasticsearch -d其他异常处理：https://blog.csdn.net/happyzxs/article/details/89156068
集群搭建：https://www.cnblogs.com/sanduzxcvbnm/p/12016216.html
- 注意配置的的data和log 会有权限问题，需要自己处理一下
| 目录 | 配置文件 | 描述 |
|---|---|---|
| bin | 脚本文件，包括启动elasticsearch，安装插件。运行统计数据等 | |
| config | elasticsearch.yml | 集群配置文件，user，role based 相关配置 |
| JDK | Java 运行环境 | |
| data | path.data | 数据文件 |
| lib | Java类库 | |
| logs | path.log | 日志文件 |
| modules | 包含所有 ES 模块 | |
| plugins | 包含所有已安装插件 |
elasticsearch-plugin list
./elasticsearch-plugin install analysis-icu
多节点启动
./elasticsearch -E node.name=node1 -E cluster.name=elktest -E path.data=/tmp/es/node1_data -E http.port=9200 -d
./elasticsearch -E node.name=node2 -E cluster.name=elktest -E path.data=/tmp/es/node2_data -E http.port=9201 -d
./elasticsearch -E node.name=node3 -E cluster.name=elktest -E path.data=/tmp/es/node3_data -E http.port=9202 -d
查看节点：http://localhost:9200/_cat/nodes
其他操作类似elastic，例如插件安装等等
i18n.locale: "zh-CN"
nohup ./kibana &
elasticsearch.hosts
elastic集群监控
相关安装和操作教程：https://www.jianshu.com/p/433d821f9667
JRuby开发的（一个采用纯Java实现的Ruby解释器，由JRuby团队开发）
movielens测试数据集
例：Small: 100,000 ratings and 3,600 tag applications applied to 9,000 movies by 600 users. Last updated 9/2018.
#修改movielens目录下的logstash.conf文件
#path修改为,你实际的movies.csv路径
input {
file {
path => "YOUR_FULL_PATH_OF_movies.csv"
start_position => "beginning"
sincedb_path => "/dev/null"
}
}
#启动Elasticsearch实例，然后启动 logstash，并制定配置文件导入数据
bin/logstash -f /YOUR_PATH_of_logstash.conf
logstash.conf文件内容
input {
file {
path => "/usr/local/soft/logstash-7.3.2/bin/movies.csv"
start_position => "beginning"
sincedb_path => "/dev/null"
}
}
filter {
csv {
separator => ","
columns => ["id","content","genre"]
}
mutate {
split => { "genre" => "|" }
remove_field => ["path", "host","@timestamp","message"]
}
mutate {
split => ["content", "("]
add_field => { "title" => "%{[content][0]}"}
add_field => { "year" => "%{[content][1]}"}
}
mutate {
convert => {
"year" => "integer"
}
strip => ["title"]
remove_field => ["path", "host","@timestamp","message","content"]
}
}
output {
elasticsearch {
hosts => ["http://192.168.165.14:9200", "http://192.168.165.15:9200", "http://192.168.165.16:9200"]
index => "movies"
document_id => "%{id}"
}
stdout {}
}
指定elasticsearch地址和端口
启动：./logstash -f logstash.conf
Document
元数据，用于标注文档的相关信息
{
"_index" : "movies",
"_type" : "_doc",
"_id" : "1",
"_version" : 1,
"_seq_no" : 19,
"_primary_term" : 1,
"found" : true,
"_source" : {
"year" : 1995,
"title" : "Toy Story",
"id" : "1",
"genre" : [
"Adventure",
"Animation",
"Children",
"Comedy",
"Fantasy"
],
"@version" : "1"
}
}
| key | 描述 |
|---|---|
| _index | 文档所属的索引名 |
| _type | 文档所属的类型名 |
| _id | 文档唯一id |
| _source | 文档的原始json数据 |
| _version | 文档的版本信息 |
| _score | 相关性打分 |
{
"movies" : {
"aliases" : { },
"mappings" : {
"properties" : {
"@version" : {...},
"genre" : {...},
"id" : {...},
"title" : {
"type" : "text",
"fields" : {
"keyword" : {
"type" : "keyword",
"ignore_above" : 256
}
}
},
"year" : {...}
}
},
"settings" : {
"index" : {
"creation_date" : "1588399246401",
"number_of_shards" : "1",
"number_of_replicas" : "1",
"uuid" : "ZC8ASqi2Rr-MBgjXRXTIxw",
"version" : {
"created" : "7030299"
},
"provided_name" : "movies"
}
}
}
}
| RDBMS | Elasticsearch |
|---|---|
| Table表 | index（type）7.0开始，一个索引只能创建一个Type=_doc |
| Row行数据 | Doucment（具体的数据） |
| Column字段 | Field字段 |
| Schema(表定义,Schema是数据库，瞎说) | Mapping 索引信息 |
| SQL | DSL |
# 查看索引相关信息(setting\mapping)
GET movies
GET .kibana_task_manager
# 查看索引的文档总数
GET movies/_count
# 查看前10条文档，了解文档格式
POST kibana_sample_data_ecommerce/_search
{}
POST movies/_search
{}
// _cat 相关api
# 查看 indeces
GET /_cat/indices/kibana*?v
GET /_cat/indices/kibana*?v&s=index
GET /_cat/indices?bytes=b&v
GET /_cat/indices?format=json&pretty
# 查看状态为绿的索引
GET /_cat/indices?v&health=green
# 按照文档的某个字段排序
GET /_cat/indices?v&s=docs.count:desc
GET /_cat/indices?v&s=store.size:asc
# 查看具体的字段
GET /_cat/indices/kibana*?pri&v&h=health,index,pri,rep,docs,count,mt
一个节点代表一个实例，多个节点组成一个集群
-E node.name=node1指定Data Node
Coordinating Node
开发环境一个节点承担多种校角色，生产环境中，应该设置单一的角色的节点。（瞎说，看实际情况）
| 节点类型 | 配置参数 | 默认值 |
|---|---|---|
| master eligible | node.master | ture |
| data | node.data | ture |
| ingest | node.ingest | ture |
| coordinating only | 无 | 每个节点默认都是 coordinating 节点。设置其他类型全部为false |
| machine learning | node.ml | true (需 enable x-parck) |
Primary Shard & Replica Shard
主分片
用以解决数据水平扩展的问题。通过分片，可以将数据分布到集群内的所有节点上
副本
用以解决数据高可用的问题。分片是主分片的拷贝
对于生产环境中分片的设定，需要提前做好容量规划
GET _cluster/health
GET _cat/nodes
| index | PUT users/_doc/1 {“user”:“Mike”,“post_data”:“2020-05-03T14:29:12”,“message”:“trying out Kibana”} |
指定id，如果id已经存在，删除原来的 再创建新的,版本信息+1 |
| create | POST users/_doc {“user”:“Jack”,“post_data”:“2020-05-03T14:29:12”,“message”:“trying out Kibana”} PUT users/_doc/1?op_type=create {“user”:“Jack”,“post_data”:“2020-05-03T14:32:12”,“message”:“trying out Kibana”} |
自动生成_id 如果_id已经存在，会失败 |
| get | GET users/_search GET users/_doc/1 |
查看索引前十条记录 根据id查询文档 |
| update | POST users/_update/1/ {“doc”:{“post_data”:“2020-05-03T14:44:12”,“message”:“trying out Elasticsearch”,“test”:652}} |
文档增加/修改字段 doc 是关键语法，payload需要包含再doc中 指定id不存在报错 |
| delete | DELETE users/_doc/1 | 删除指定_id |
- 支持再一次API调用中，对不同的索引进行操作
- 支持四种类型操作
- index
- create
- update
- delete
- 可以再URL中指定 index，也可以再请求的 Payload 中进行
- 操作中单条失败，并不会影响其它结果
- 返回结果包括了每一条操作执行的结果
例：
POST _bulk {"index":{"_index":"users","_id":"1"}} {"user":"qilou","test":520} {"delete":{"_index":"users2","_id":3}} {"create":{"_index":"users2","_id":4}} {"field1":"qilou","field2":"520"} {"update":{"_id":"4","_index":"users"}} {"doc":{"field1":"qilou","field2":"520"}} # 上面有index delete create update
批量操作，可以减少网络连接所产生的开源，提高性能
GET _mget {"docs":[{"_index":"users","_id":11},{"_index":"movies","_id":4}]}
- 都是关键字，例如 from 代表开始索引，size 代表从from开始查询多少条
- index 是查询条件，作用于下一条query查询语句的
POST kibana_sample_data_ecommerce/_msearch {} {"query":{"match_all":{}},"from":0,"size":10} {} {"query":{"match_all":{}},"size":10} {"index":"twitter2"} {"query":{"match_all":{}}}
| 问题 | 原因 |
|---|---|
| 无法连接 | 网络故障或集群挂了 |
| 连接无法关闭 | 网络故障或节点出错 |
| 429 | 集群过于繁忙 |
| 4XX | 请求体格式有错 |
| 500 | 集群内部错误 |
。。。
文本分析是把全文本转换一系列单词（term / token）的过程，也叫分词
Analysis 是通过Analyzer 来实现的
数据写入和查询时采用的分析器需要相同
===========================================================
elasticsearch内置的分词器
===========================================================
standard Analyzer 默认分词器，按词切分，小写处理
simple Analyzer 按照非字母切分（符号被过滤，非字符的都被去除），小写处理
stop Analyzer 按照非字母切分（符号被过滤，非字符的都被去除），小写处理，停用词过滤（the，a，is）
whitespace Analyzer 按照空格切分，不转小写
keyword Analyzer 不分词，直接将输入做输出
pattern Analyzer 正则表达式，默认 \W+ (非字符分隔)
language 提供了30 多种常见语言的分词器
customer Analyzer 自定义分词器
===========================================================
===========================================================
相关的中文分词器
===========================================================
icu_analyzer 中文分词器
IK 中文分词器
THULAC 中文分词器
# 使用分词器测试
GET /_analyze
{
"analyzer": "stop",
"text": "Mastering Elasticsearch,elasticsearch in Action"
}
URI Search
- 在URL 中使用查询参数
Request Body Search
- 使用Elasticsearch 提供的，基于 JSON 格式的更加完备的 Query Domain Specific Language （DSL）
查询指定的索引
| 语法 | 范围 |
|---|---|
| /_search | 在集群上的所有索引查询，默认前10个文档 |
| /index1/_search | 同上，只是在指定的索引index1中查询 |
| /index1,index2/_search | 同上，只是在指定的索引index1和index2中查询 |
| /index*/_search | 同上，只是在以index开头的索引中查询,通配符 |
URL查询
使用 “q” ，指定查询字符串
query string syntax，KV键值对
curl -XGET "http://192.168.165.14:9200/kibana_sample_data_ecommerce/_search?q=customer_first_name:Eddie"
Request Body
支持POST和GET
curl -XGET "http://192.168.165.14:9200/kibana_sample_data_ecommerce/_search" -H'Content-Type:application/json' -d'{"query":{"match_all":{}}}'
GET /movies/_search?q=2012&df=title,year&sort=year:desc&from=0&size=10&timeout=1s { "profile": true }
区间表示：[] 闭区间，{}开区间，{}一定要用分组() 不然报错。
[] 闭区间，包含它
{}开区间，不包含
将查询语句通过 HTTP Request Body 发送给 Elasticsearch
Query DSL
POST /movies,404_idx/_search?ignore_unavailable=true { "profile": true, "query": { "match_all": {} } }
POST /movies/_search
{
"from": 100,
"size": 20,
"query": {
"match_all": {}
}
}
最好在数字型和日期型字段上排序
POST /movies/_search
{
"sort": [{"year": {"order": "desc"}}],
"from": 100,
"size": 20,
"query": {
"match_all": {}
}
}
##################或者，这种更精简,推荐用下面这种#######
POST /movies/_search
{
"sort": [{"year":"desc"},{"_id":"desc"}],
"from": 100,
"size": 20,
"query": {
"match_all": {}
}
}
year和_i开头字段的数据，支持通配符POST /movies/_search
{
"_source": ["year","title"],
"sort": [{"year":"desc"},{"_i*":"desc"}],
"from": 100,
"size": 20,
"query": {
"match_all": {}
}
}
fields里面{
"script_fields": {
"new_field": {
"script": {
"lang": "painless",
"source": "doc['order_date'].value+'hello'"
}
}
},
"_source": [
"order_date",
"order_id"
],
"from": 10,
"size": 1,
"query": {
"match_all": {}
}
}
{
"took" : 0,
"timed_out" : false,
"_shards" : {
"total" : 1,
"successful" : 1,
"skipped" : 0,
"failed" : 0
},
"hits" : {
"total" : {
"value" : 4675,
"relation" : "eq"
},
"max_score" : 1.0,
"hits" : [
{
"_index" : "kibana_sample_data_ecommerce",
"_type" : "_doc",
"_id" : "INnh2HEBko7oswXuqL26",
"_score" : 1.0,
"_source" : {
"order_date" : "2020-05-11T10:46:34+00:00",
"order_id" : 727381
},
"fields" : {
"new_field" : [
"2020-05-11T10:46:34.000Zhello"
]
}
}
]
}
}
POST /movies/_search
{
"query": {
"match": {
"title": "hello word"
}
}
}
POST /movies/_search
{
"query": {
"match": {
"title": {
"query": "hello world",
"operator": "and"
}
}
}
}
POST /movies/_search
{
"query": {
"match_phrase": {
"title": {
"query": "one love"
}
}
}
}
POST /movies/_search
{
"query": {
"match_phrase": {
"title": {
"query": "one love",
"slop": 1
}
}
}
}
主要是
query里面支持的查询方式之前已经讲了
match和match_phrase以及match_all
POST movies/_search
{
"query": {
"query_string": {
"default_field": "title",
"query": "hello NOT word"
}
}
}
POST movies/_search
{
"query": {
"query_string": {
"fields": ["title","genre"],
"query": "(hello AND word) OR (beautiful && +Girls)"
}
}
}
类似query_string，但是会忽略语法错误，只支持部分查询语句
- 不支持AND OR NOT，会当作字符串处理
- 不支持&&等，会当作特殊符号给排除了
- 单词之间默认关系是OR，指定default_operator
- 支持用 ±| 代替 AND OR NOT
POST movies/_search
{
"query": {
"simple_query_string": {
"query": "(+hello -word)",
"fields": ["title"],
"default_operator": "AND"
}
}
}
Mapping 类似数据库中的 表的定义，作用如下：
- 定义索引中的字段的名称
- 定义字段的数据类型，例如字符串，数字，布尔……
- 字段，倒排索引的相关配置（Analyzed or Not Analyzed，Analyzer）
Mapping 会把 JSON 文档映射成 Lucene 所需要的扁平格式。
7.0之前每个mapping都有一个type，7.0之后不需要在mapping中定义指定type信息
在写入文档的瘦，如果索引不存在，会自动创建索引
Dynamic Mapping 的机制，使得我们不用手动定义Mapping，Elasticsearch可以自动推算出字段的类型
但是有的时候也会推算不对，例如地址位置信息
当类型设置不对的时候会导致一些功能无法正常运行，例如 Range 查询
# 查看mapping GET movies/_mapping
| JSON类型 | Elasticsearch类型 |
|---|---|
| 字符串 | 匹配日期格式，设置成Date 匹配数字设置为 float 或者 long ，该选项默认关闭 设置为text，并且增加keyword字段 |
| 布尔值 | boolean |
| 浮点数 | float |
| 整数 | long |
| 对象 | properties 也就是object |
| 数组 | 由第一个非空数值的类型所决定，如果是string 那么就是字符串类型 |
| 空值 | 忽略 |
PUT mapping_test/_doc/1
{
"uid": "123",
"name": "lilei",
"create_date": "2019-10-10T22:11:22+00:00",
"isVip": false,
"isAdmin": "true",
"age": 22,
"heigh": "180",
"money": 12.3,
"ip":"192.168.1.11",
"language": [
"java",
"python"
],
"children": {
"number": 3
},
"geoip": {
"lon": 31.3,
"lat": 30.1
}
}
# uid 是text类型
# name 是text类型
# create_date 是date类型
# isVip 是boolean类型
# isAdmin 是text类型
# age 是long类型
# height 是text类型
# money 是float类型
# ip 是 text类型
# language 是text类型，根据第一个值推断的类型
# children 是properties 也就是object类型
# geoip 是properties 也就是object类型，这也就是地理位置推算有问题的地方
不支持对已有字段类型进行改变，如果必须改变，就只能Reindex API来重建索引了
- 设置Mapping，默认是true
PUT dynamic_mapping_test/_mapping { "dynamic": false }
| 设置 | 文档索引 | 字段索引 | Mapping更新 | 描述 |
|---|---|---|---|---|
| “true” | YES | YES | YES | 一旦有新增字段的文档写入，Mapping也同时被更新 |
| “false” | YES | NO | NO | 一旦有新增字段的文档写入，Mapping不会更新 新增的字段数据，也无法被索引，新增字段被丢弃 |
| “strict” | NO | NO | NO | 新增字段时，数据写入直接出错 |
PUT dynamic_mapping_test/_doc/1
{
"newField":"someValue"
}
创建一个Index
PUT test_users { "mappings": { "properties": { "name": { "type": "text" }, "age": { "type": "integer" }, "mobile": { "type": "long" } } } }
index参数
PUT test_users
{
"mappings": {
"properties": {
"name": {
"type": "text"
},
"age": {
"type": "integer"
},
"mobile": {
"type": "long",
"index": false
}
}
}
}
index_options 参数
PUT test_users { "mappings": { "properties": { "name": { "type": "text" }, "age": { "type": "integer" }, "mobile": { "type": "long", "index": false }, "bio": { "type": "text", "index_options": "docs" } } } }
text类型默认记录 positions，其他默认为docs
记录内容越多，占用存储空间越大
null_value参数
只有keyword 类型支持设定 null_value，只有设置了才能支持"NULL"的搜索
设置
PUT test_users { "mappings": { "properties": { "name": { "type": "text" }, "age": { "type": "integer" }, "mobile": { "type": "long", "index": false }, "bio": { "type": "text", "index_options": "docs" }, "nullvalue":{ "type": "keyword", "null_value": "NULL" } } } }
POST test_users/_doc/1
{
"name":"li,.ei",
"age":123,
"mobile":1234412313,
"bio":123123,
"nullvalue": null
}
GET test_users/_search
{
"query": {"query_string": {
"default_field": "nullvalue",
"query":"NULL"
}}
}
_all 在 7 中被 copy_to所代替
- 用于满足一些特定的搜索
- 通过配置。可以让搜索的时候聚合到多个字段
- copy_to的字段不会出现在查询结果的_source中
PUT test_users
{
"mappings": {
"properties": {
"firstName": {
"type": "text",
"copy_to": "fullName"
},
"lastName": {
"type": "text",
"copy_to": "fullName"
}
}
}
}
POST test_users/_doc/1
{
"firstName":"李",
"lastName":"雷"
}
# 测试上面的查询，注意注意，中文是一个字一个词。。。
GET test_users/_search?q=fullName:(李 AND 雷)
POST test_users/_search
{
"query": {
"query_string": {
"default_field": "fullName",
"query": "李 AND 雷"
}
}
}
后面自己去查询。这人的视频。。真无语。 看着头大。乱七八糟的。
好像就是子字段。。
exact_value
- 包括数字 / 日志 / 具体的一个字符串（例如 App Store一个整体）
- elasticsearch中的 keyword
- 精确值不会分词。就是一个整体
full text
- 全文本，非结构化的文本数据
- elasticsearch中的 text，会根据分词器进行分词
当 Elasticsearch 自带的分词器无法满足时，可以自定义分词器。通过自组合不同的组件来实现：
- Character Filter（针对原始文本处理，例：去除html）
- Tokenizer（按照规则切分为单词）
- TokenFilter（将切分的单词进行加工，小写，删除stopwords，增加同义词）
在 Tokenizer 之前对文本进行处理，例如增加删除及替换字符。可以配置多个Character Filters。会影响 Tokenizer 的 position 和 offset 信息
一些自带的 Character Filters
POST _analyze
{
"tokenizer": "keyword",
"char_filter": ["html_strip"],
"text": ["<b>hello world</b>"]
}
# 中划线替换成下划线
POST _analyze
{
"tokenizer": "standard",
"char_filter": [
{
"type": "mapping",
"mappings": ["- => _"]
}
],
"text": "test-id,123-456! test-900 650-423-1234"
}
# 表情符号替换成英文
POST _analyze
{
"tokenizer": "standard",
"char_filter": [
{
"type": "mapping",
"mappings": [":) => happy",":( => sad"]
}
],
"text": ["I am felling :)","Feeling : :( today"]
}
# 正则匹配，留下$1。。。
POST _analyze
{
"tokenizer": "standard",
"char_filter": [
{
"type": "pattern_replace",
"pattern": "http://(.*)",
"replacement": "$1"
}
],
"text": "http://www.elastic.co"
}
将原始的文本按照一定的规则，切分为词（term or token）
whitespace / standard / uax_url_email / pattern / keyword / path hierarchy
POST _analyze
{
"tokenizer": "path_hierarchy",
"text": "/usr/local/soft/elasticsearch"
}
# /usr
# /usr/local
# /usr/local/soft
# /usr/local/soft/elasticsearch
# 按照空格拆分
POST _analyze
{
"tokenizer": "whitespace",
"text": ["The rain in Spain falls mainly on the plain."]
}
注意传递多个，一定要注意先后顺序
将 Tokenizer 输出的单词（term），进行增加、修改、删除
lowercase / stop / synonym（添加近义词）
# The 虽然也是停用词，但是会保留。因为是大写，因为只会去掉是小写的停用词
POST _analyze
{
"tokenizer": "whitespace",
"filter": [
"stop"
],
"text": [
"The rain in Spain falls mainly on the plain."
]
}
# 这个就是把不管大写小写的停用词都去掉，先小写，再去停用词
POST _analyze
{
"tokenizer": "whitespace",
"filter": [
"lowercase","stop"
],
"text": [
"The rain in Spain falls mainly on the plain."
]
}
可以在创建索引的时候设置一个自定义的分词器
只需要再settings里面设置好
PUT my_index
{
"mappings": {},
"settings": {
"analysis": {
"analyzer": {
"my_custom_analyzer_自定义名": {
"type": "custom",
"char_filter": [
"emoticons_自定义名"
],
"tokenizer": "punctuation_自定义名",
"filter": [
"lowercase",
"english_stop_自定义名"
]
}
},
"tokenizer": {
"punctuation_自定义名": {
"type": "pattern",
"pattern": "[ .,!?]"
}
},
"char_filter": {
"emoticons_自定义名": {
"type": "mapping",
"mappings": [
":) => _happy_",
":( => _sad_"
]
}
},
"filter": {
"english_stop_自定义名": {
"type": "stop",
"stopwords": "_english_"
}
}
}
}
}
POST my_index/_analyze
{
"analyzer": "my_custom_analyzer_自定义名",
"text": ["I'm a :) person, and you?"]
}
集群上的索引会越来越多，例如，我们会对日志每天创建一个索引
- 使用多个索引可以让我们更好的管理数据，提高性能
- logs-2020-05-01
- logs-2020-05-02
- logs-2020-06-03
PUT _template/template_default
{
"index_patterns": ["*"],
"order": 0,
"version": 1,
"settings": {
"number_of_shards": 1,
"number_of_replicas": 1
}
}
# 测试模板
POST romdon_test/_doc/1
{
"name":"李磊",
"create_date":"2019-10-10T22:11:22+00:00",
"age":"123"
}
# name 是text类型
# create_date 是date类型
# age 是text类型
PUT _template/template_test
{
"index_patterns": ["test*"],
"order": 1,
"settings": {
"number_of_shards": 1,
"number_of_replicas": 2
},
"mappings": {
"date_detection": false,
"numeric_detection": true
}
}
# 测试模板
POST test_heihei/_doc/1
{
"name":"李磊",
"create_date":"2020-05-06T22:11:22+00:00",
"age":"123"
}
# name 是text类型
# create_date 是text类型
# age 是long类型
根据 Elasticsearch 识别的数据类型，结合字段名称，来动态设定字段类型
- 所有的字符类型都设定成 keyword，或者关闭keyword字段
- is 开头的字段都设置成 boolean 类型
- long_开头的都设置成long 类型
PUT my_test_index3
{
"mappings": {
"dynamic_templates": [
{
"strings_as_boolean_自定义": {
"match_mapping_type": "string",
"match": "is*",
"mapping": {
"type": "boolean"
}
}
},
{
"strings_as_keyword_自定义": {
"match_mapping_type": "string",
"mapping": {
"type": "keyword"
}
}
}
]
}
}
# 测试
POST my_test_index3/_doc/1
{
"isVIP":"true",
"name":"lilei"
}
PUT my_test_index1
{
"mappings": {
"dynamic_templates": [
{
"full_name": {
"path_match": "name.*",
"path_unmatch": "*.middle",
"mapping": {
"type": "text",
"copy_to": "full_name"
}
}
}
]
}
}
# 测试 ，注意正则里面是name这个对象。
PUT my_test_index1/_doc/1
{
"name": {
"first": "John",
"middle": "Winston",
"last": "Lennon"
}
}
GET my_test_index1
GET my_test_index/_search?q=full_name:John
GET my_test_index/_search?q=full_name:Winston # 这个就没有被copy_to
就是语句支持统计分析。。。I fuck you
Bucket Aggregation 一些列满足特定条件的文档的集合
Metric Aggregation 一些数学运算，可以对文档字段进行统计分析
基于数据集计算结果，除了支持在字段上进行计算，同样也支持在脚本（painless script）产生的结果上进行计算
GET kibana_sample_data_flights/_search
{
"size": 0,
"aggs": {
"fligth_dest_自定义名字": {
"terms": {
"field": "DestCountry"
},
"aggs": {
"average_proce_自定义": {
"avg": {
"field": "AvgTicketPrice"
}
},
"max_price_自定义": {
"max": {
"field": "AvgTicketPrice"
}
},
"min_price_自定义": {
"min": {
"field": "AvgTicketPrice"
}
}
}
}
}
}
GET kibana_sample_data_flights/_search
{
"size": 0,
"aggs": {
"flight_dest_自定义": {
"terms": {
"field": "DestCountry"
},
"aggs": {
"average_price_自定义": {
"avg": {
"field": "AvgTicketPrice"
}
},
"weather_自定义": {
"terms": {
"field": "DestWeather"
}
}
}
}
}
}
Pipeline Aggregation 对其他的聚合结果进行二次聚合
Matrix Aggregation 支持对多个字段的操作并提供一个结果矩阵
Elasticsearch数据建模
Elasticsearch保护你的数据
Elasticsearch水平扩展Elasticsearch集群
Elasticsearch生产环境的集群运维
Elasticsearch索引生命周期的管理
用Logstash 和 Beats 构建数据管道
用Kibana 进行数据可视化分析
探索 X-park 套件
实战1：电影搜索服务
实战2：stackoverflow用户调查问卷分析
Elastic认证