elasticsearch搜索及相关插件

ES选型

  • elasticsearch-2.3.4

相关组件:

  • elasticsearch-jdbc-2.3.4.0-dist
  • kibana-4.5.4-linux-x64.tar
  • elasticsearch-analysis-ik-1.9.4
  • elasticsearch-analysis-pinyin-1.7.4
  • _bigdesk
  • _head

以ES2.3.4为基准,其他组件已为测试后最新可用版本,高于以上版本则不兼容。

ES特性

SuggestionDiscovery

SuggestionDiscovery的职责是发现建议词;
建议词的来源可以是商品的分类名称、品牌名称、商品标签、商品名称的高频词、热搜词,也可以是一些组合词,比如“分类 + 性别”和“分类 + 标签”,还可以是一些自定义添加的词;
建议词维护的时候需要考虑去重,比如“卫衣男”和“卫衣 男”应该是相同的,“Nike”和“nike”也应该是相同的;
由于建议词的来源通常比较稳定,所以执行的周期可以比较长一点,比如每周一次;

SuggestionCounter

SuggestionCounter的职责是获取建议词关联的商品数量,如果需要可以进行一些聚合操作,比如聚合分类和标签;
SuggestionCounter的实现的时候由于要真正地调用搜索接口,应该尽量避免对用户搜索的影响,比如在凌晨执行并且使用单线程调用;
为了提升效率,应该使用Elasticsearch的Multi Search接口批量进行count,同时批量更新数据库里建议词的count值;
由于SuggestionCounter是比较耗资源的,可以考虑延长执行的周期,但是这可能会带来count值与实际搜索时误差较大的问题,这个需要根据实际情况考虑;

SuggestionIndexRebuiler

SuggestionIndexRebuiler的职责是负责重建索引;
考虑到用户的搜索习惯,可以使用Multi-fields来给建议词增加多个分析器。比如对于【卫衣 套头】的建议词使用Multi-fields增加不分词字段、拼音分词字段、拼音首字母分词字段、IK分词字段,这样输入【weiyi】和【套头】都可以匹配到该建议词;
重建索引时通过是通过bulk批量添加到临时索引中,然后通过别名来更新;
重建索引的数据依赖于SuggestionCounter,因此其执行的周期应该与SuggestionCounter保持一致;

SuggestionService

SuggestionService是真正处于用户搜索建议的服务类;
通常的实现是先到缓存中查询是否能匹配到缓存记录,如果能匹配到则直接返回;否则的话调用Elasticsearch的Prefix Query进行搜索,由于我们在重建索引的时候定义了Multi-fields,在搜索的时候应该用boolQuery来处理;如果此时Elasticsearch返回不为空的结果数据,那么加入缓存并返回即可;


ES配置

elasticsearch配置

  • elasticsearch.yml

[elk@M-WEB-098 config]$ cat elasticsearch.yml

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
# ======================== Elasticsearch Configuration =========================
#
# NOTE: Elasticsearch comes with reasonable defaults for most settings.
# Before you set out to tweak and tune the configuration, make sure you
# understand what are you trying to accomplish and the consequences.
#
# The primary way of configuring a node is via this file. This template lists
# the most important settings you may want to configure for a production cluster.
#
# Please see the documentation for further information on configuration options:
# <http://www.elastic.co/guide/en/elasticsearch/reference/current/setup-configuration.html>
#
# ---------------------------------- Cluster -----------------------------------
#
# Use a descriptive name for your cluster:
#
cluster.name: pmh_es
#
# ------------------------------------ Node ------------------------------------
#
# Use a descriptive name for the node:
#
node.name: node-1
#
# Add custom attributes to the node:
#
# node.rack: r1
#
# ----------------------------------- Paths ------------------------------------
#
# Path to directory where to store the data (separate multiple locations by comma):
#
path.data: /data/elasticsearch/data/
#
# Path to log files:
#
path.logs: /data/elasticsearch/logs/
#
# ----------------------------------- Memory -----------------------------------
#
# Lock the memory on startup:
#
bootstrap.memory_lock: true
#
# Make sure that the `ES_HEAP_SIZE` environment variable is set to about half the memory
# available on the system and that the owner of the process is allowed to use this limit.
#
# Elasticsearch performs poorly when the system is swapping the memory.
#
# ---------------------------------- Network -----------------------------------
#
# Set the bind address to a specific IP (IPv4 or IPv6):
#
network.host: 192.168.1.98
#
# Set a custom port for HTTP:
#
http.port: 9200
#
# For more information, see the documentation at:
# <http://www.elastic.co/guide/en/elasticsearch/reference/current/modules-network.html>
#
# --------------------------------- Discovery ----------------------------------
#
# Pass an initial list of hosts to perform discovery when new node is started:
# The default list of hosts is ["127.0.0.1", "[::1]"]
#
# discovery.zen.ping.unicast.hosts: ["host1", "host2"]
#
# Prevent the "split brain" by configuring the majority of nodes (total number of nodes / 2 + 1):
#
discovery.zen.ping.unicast.hosts: ["192.168.1.82", "192.168.1.98"]
discovery.zen.ping_timeout: 10s
# discovery.zen.minimum_master_nodes: 3
#
# For more information, see the documentation at:
# <http://www.elastic.co/guide/en/elasticsearch/reference/current/modules-discovery.html>
#
# ---------------------------------- Gateway -----------------------------------
#
# Block initial recovery after a full cluster restart until N nodes are started:
#
# gateway.recover_after_nodes: 3
#
# For more information, see the documentation at:
# <http://www.elastic.co/guide/en/elasticsearch/reference/current/modules-gateway.html>
#
# ---------------------------------- Various -----------------------------------
#
# Disable starting multiple nodes on a single system:
#
# node.max_local_storage_nodes: 1
#
# Require explicit names when deleting indices:
#
# action.destructive_requires_name: true
#ik
#index.analysis.analyzer.ik.type : "ik"
index:
analysis:
analyzer:
ik_max_word:
type: ik
use_smart: false
ik_smart:
type: ik
use_smart: true
bootstrap.memory_lock: true //锁定到到内存,防止交换到硬盘

端口配置

ES对外提供服务端口默认为:9200
可用于访问ES插件及管理界面,如head.

节点间交互的tcp端口默认为:9300
用于提供ES集群节点间相互通信,或内部提供API给业务接口,如提供给JAVA 接口调用。

安全配置

由于ES原生是不带有任何安全认证相关的配置及措施,因此任何人都能调用我们的ES服务API,以及管理API,拥有所有的ES操作权限,极不安全。为此:
关闭了外网,只将ES服务绑定在内网上
通过host本地解析ES IP地址,配合openresty提供域名API服务
通过openresty隐藏9200端口,同时配置反向代理ES,为ES提供方便的可扩展性和安全性
通过openresty为kibana提供secret http服务,提供安全的数据可视化服务(密码找相关人员索取)

JDBC配置

导入ojdbc6.jar包到/usr/local/elasticsearch-2.3.4/elasticsearch-jdbc-2.3.4.0/lib
配置索引导入脚本

oracle-pmh_es.sh
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
#!/bin/sh
# This example is a template to connect to Oracle
# The JDBC URL and SQL must be replaced by working ones.
DIR=/usr/local/elasticsearch-2.3.4/elasticsearch-jdbc-2.3.4.0
bin=${DIR}/bin
lib=${DIR}/lib
echo '
{
"type" : "jdbc",
"jdbc" : {
"url" : "jdbc:oracle:thin:@//192.168.1.129:1521/pomoho",
"connection_properties" : {
"oracle.jdbc.TcpNoDelay" : false,
"useFetchSizeWithLongColumn" : false,
"oracle.net.CONNECT_TIMEOUT" : 10000,
"oracle.jdbc.ReadTimeout" : 50000
},
"user" : "****",
"password" : "******",
"sql" : "select * from PMH_SOLR",
"index" : "pmh_es_smart-test",
"type" : "myoracle",
"elasticsearch" : {
"cluster" : "pmh_es",
"host" : "192.168.1.98",
"port" : 9300
},
"max_bulk_actions" : 20000,
"max_concurrent_bulk_requests" : 8,
"index_settings" : {
"index" : {
"number_of_shards" : 1,
"number_of_replica" : 1
},
"analysis" : {
"analyzer" : {
"ik" : {
"tokenizer" : "ik_smart"
}
}
}
},
"type_mapping": {
"myoracle":{
"properties" : {
"IMDBID":{
"type" : "integer"
},
"FILMNAME":{
"type" : "string",
"analyzer" : "ik",
"search_analyzer": "ik"
},
"CREATETIME":{
"type":"date"
},
"CREATEUSER":{
"type":"integer"
},
"PLAYCOST":{
"type":"integer"
},
"STATUS":{
"type":"integer"
},
"STATUSTIME":{
"type":"date"
},
"SOLRTIME":{
"type":"date"
},
"DEALSTATUS":{
"type":"integer"
},
"FILETYPE":{
"type":"string"
},
"TAGS":{
"type":"string"
},
"BELONGEDFLAG":{
"type":"integer"
},
"CLASSID":{
"type":"integer"
},
"CLASSIDTWO":{
"type":"integer"
},
"CLASSIDTHREE":{
"type":"string"
},
"CLASSIDFOUR":{
"type":"integer"
},
"CHANNELID":{
"type":"integer"
},
"CHANNELNAME":{
"type":"string"
},
"CHANNELDESC":{
"type":"string"
}
}
}
}
}
}
' | java \
-cp "${lib}/*" \
-Dlog4j.configurationFile=${bin}/log4j2.xml \
org.xbib.tools.Runner \
org.xbib.tools.JDBCImporter
oracle-pmh_mhh_deltaImport.sh
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
#!/bin/sh
# This example is a template to connect to Oracle
# The JDBC URL and SQL must be replaced by working ones.
DIR=/usr/local/elasticsearch-2.3.4/elasticsearch-jdbc-2.3.4.0
bin=${DIR}/bin
lib=${DIR}/lib
echo '
{
"type" : "jdbc",
"jdbc" : {
"url" : "jdbc:oracle:thin:@//IP:PORT/INSTANCE",
"connection_properties" : {
"oracle.jdbc.TcpNoDelay" : false,
"useFetchSizeWithLongColumn" : false,
"oracle.net.CONNECT_TIMEOUT" : 10000,
"oracle.jdbc.ReadTimeout" : 50000
},
"user" : "****",
"password" : "****",
"statefile" : "statefile-PMH_ES_MHH.json",
"schedule" : "0 55 0/1 * * ?",
"sql" : [
{
"statement" : "select * from PMH_MHH_SLORUSER where CREATETIME > ?",
"parameter" : ["$metrics.lastexecutionstart"]
}
],
"index" : "pmh_es_mhh",
"type" : "myoracle",
"elasticsearch" : {
"cluster" : "pmh_es",
"host" : "192.168.1.82",
"port" : 9300
},
"max_bulk_actions" : 20000,
"max_concurrent_bulk_requests" : 8,
"index_settings" : {
"index" : {
"number_of_shards" : 1,
"number_of_replica" : 1
},
"analysis" : {
"analyzer" : {
"ik" : {
"tokenizer" : "ik_smart",
"filter" : ["full_pinyin_no_space","full_pinyin_with_space","first_letter_pinyin"]
}
},
"filter" :{
"full_pinyin_no_space" : {
"type" : "pinyin",
"first_letter" : "none",
"padding_char" : ""
},
"full_pinyin_with_space" : {
"type" : "pinyin",
"first_letter" : "none",
"padding_char" : " "
},
"first_letter_pinyin" : {
"type" : "pinyin",
"first_letter" : "only",
"padding_char" : ""
}
}
}
},
"type_mapping": {
"myoracle":{
"properties" : {
"USERID":{
"type" : "integer"
},
"NICKNAME":{
"type" : "string",
"analyzer" : "ik",
"search_analyzer": "ik"
},
"USERTYPE":{
"type":"integer"
},
"HEADIMAGE":{
"type":"string"
},
"REMARK":{
"type":"string"
},
"CREATETIME":{
"type":"date"
},
"STATUS":{
"type":"integer"
}
}
}
}
}
}
' | java \
-cp "${lib}/*" \
-Dlog4j.configurationFile=${bin}/log4j2.xml \
org.xbib.tools.Runner \
org.xbib.tools.JDBCImporter
oracle-pmh_es_nopinyin_deltaImport.sh
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
#!/bin/sh
# This example is a template to connect to Oracle
# The JDBC URL and SQL must be replaced by working ones.
DIR=/usr/local/elasticsearch-2.3.4/elasticsearch-jdbc-2.3.4.0
bin=${DIR}/bin
lib=${DIR}/lib
echo '
{
"type" : "jdbc",
"jdbc" : {
"url" : "jdbc:oracle:thin:@//IP:PORT/INSTANCE",
"connection_properties" : {
"oracle.jdbc.TcpNoDelay" : false,
"useFetchSizeWithLongColumn" : false,
"oracle.net.CONNECT_TIMEOUT" : 10000,
"oracle.jdbc.ReadTimeout" : 50000
},
"user" : "****",
"password" : "****",
"statefile" : "statefile-PMH_SOLR_NOPY.json",
"schedule" : "0 15 0/1 * * ?",
"sql" : [
{
"statement" : "select * from PMH_SOLR where SOLRTIME > ?",
"parameter" : ["$metrics.lastexecutionstart"]
}
],
"index" : "pmh_es_so_nopy",
"type" : "myoracle",
"elasticsearch" : {
"cluster" : "pmh_es",
"host" : "192.168.1.82",
"port" : 9300
},
"max_bulk_actions" : 20000,
"max_concurrent_bulk_requests" : 8,
"index_settings" : {
"index" : {
"number_of_shards" : 1,
"number_of_replica" : 1
},
"analysis" : {
"analyzer" : {
"ik" : {
"tokenizer" : "ik_smart"
}
}
}
},
"type_mapping": {
"myoracle":{
"properties" : {
"IMDBID":{
"type" : "integer"
},
"FILMNAME":{
"type" : "string",
"analyzer" : "ik",
"search_analyzer": "ik"
},
"CREATETIME":{
"type":"date"
},
"CREATEUSER":{
"type":"integer"
},
"PLAYCOST":{
"type":"integer"
},
"STATUS":{
"type":"integer"
},
"STATUSTIME":{
"type":"date"
},
"SOLRTIME":{
"type":"date"
},
"DEALSTATUS":{
"type":"integer"
},
"FILETYPE":{
"type":"string"
},
"TAGS":{
"type":"string"
},
"BELONGEDFLAG":{
"type":"integer"
},
"CLASSID":{
"type":"integer"
},
"CLASSIDTWO":{
"type":"integer"
},
"CLASSIDTHREE":{
"type":"string"
},
"CLASSIDFOUR":{
"type":"integer"
},
"CHANNELID":{
"type":"integer"
},
"CHANNELNAME":{
"type":"string"
},
"CHANNELDESC":{
"type":"string"
}
}
}
}
}
}
' | java \
-cp "${lib}/*" \
-Dlog4j.configurationFile=${bin}/log4j2.xml \
org.xbib.tools.Runner \
org.xbib.tools.JDBCImporter

索引

分片

当在ElasticSearch集群中配置好你的索引后, 你要明白在集群运行中你无法调整分片设置. 既便以后你发现需要调整分片数量, 你也只能新建创建并对数据进行重新索引(reindex)(虽然reindex会比较耗时, 但至少能保证你不会停机).
主分片的配置与硬盘分区很类似, 在对一块空的硬盘空间进行分区时, 会要求用户先进行数据备份, 然后配置新的分区, 最后把数据写到新的分区上.
分配分片时主要考虑的你的数据集的增长趋势.

我们也经常会看到一些不必要的过度分片场景. 从ES社区用户对这个热门主题(分片配置)的分享数据来看, 用户可能认为过度分配是个绝对安全的策略(这里讲的过度分配是指对特定数据集, 为每个索引分配了超出当前数据量(文档数)所需要的分片数).

Elastic 在早期确实鼓吹过这种做法, 然后很多用户做的更为极端–例如分配1000个分片. 事实上, Elastic目前对此持有 更谨慎的态度 .

稍有富余是好的, 但过度分配分片却是大错特错. 具体定义多少分片很难有定论, 取决于用户的数据量和使用方式. 100个分片, 即便很少使用也可能是好的;而2个分片, 即便使用非常频繁, 也可能是多余的.

要知道, 你分配的每个分片都是有额外的成本的:

每个分片本质上就是一个Lucene索引, 因此会消耗相应的文件句柄, 内存和CPU资源

每个搜索请求会调度到索引的每个分片中. 如果分片分散在不同的节点倒是问题不太. 但当分片开始竞争相同的硬件资源时, 性能便会逐步下降

ES使用 词频统计来计算相关性 . 当然这些统计也会分配到各个分片上. 如果在大量分片上只维护了很少的数据, 则将导致最终的文档相关性较差

我们的客户通常认为随着业务的增长, 他们的数据量也会相应的增加, 所以很有必要为此做长期规划. 很多用户相信他们将会遇到暴发性增长(尽管大多数甚至都没有遇到过峰值), 当然也希望避免重新分片并减少可能的停机时间.

如果你真的担心数据的快速增长, 我们建议你多关心这条限制: ElasticSearch推荐的最大JVM堆空间 是30~32G, 所以把你的分片最大容量限制为30GB, 然后再对分片数量做合理估算. 例如, 你认为你的数据能达到200GB, 我们推荐你最多分配7到8个分片.

总之, 不要现在就为你可能在三年后才能达到的10TB数据做过多分配. 如果真到那一天, 你也会很早感知到性能变化的.
动态副本

1
2
3
4
PUT /my_temp_index/_settings
{
"number_of_replicas": 1
}


analysis

standard 分析器是用于全文字段的默认分析器,对于大部分西方语系来说是一个不错的选择。它考虑了以下几点:
standard 分词器,在词层级上分割输入的文本。
standard 标记过滤器,被设计用来整理分词器触发的所有标记(但是目前什么都没做)。
lowercase 标记过滤器,将所有标记转换为小写。
stop 标记过滤器,删除所有可能会造成搜索歧义的停用词,如 a,the,and,is。
默认情况下,停用词过滤器是被禁用的。如需启用它,你可以通过创建一个基于 standard 分析器的自定义分析器,并且设置 stopwords 参数。可以提供一个停用词列表,或者使用一个特定语言的预定停用词列表。

1
2
3
4
5
6
7
8
9
10
11
12
13
PUT /spanish_docs
{
"settings": {
"analysis": {
"analyzer": {
"es_std": {
"type": "standard",
"stopwords": "_spanish_"
}
}
}
}
}

中文分词

使用https://github.com/medcl/elasticsearch-analysis-ik
配置了ik_max_wordik_smart,当前使用ik_smart更加人性化。

ik_max_word

ik_smart

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
配置:
index:
analysis:
analyzer:
ik_max_word:
type: ik
use_smart: false
ik_smart:
type: ik
use_smart: true
"analysis" : {
"analyzer" : {
"ik" : {
"tokenizer" : "ik_smart"
}
}
}
},

拼音

使用https://github.com/medcl/elasticsearch-analysis-pinyin 对应1.7.4版本执行mvn打包(打包时间较长,期间可能需要去外网下包)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
wget http://mirror.bit.edu.cn/apache/maven/maven-3/3.3.9/binaries/apache-maven-3.3.9-bin.tar.gz //
326 tar zxvf apache-maven-3.3.9-bin.tar.gz //
327 ls
328 cp apache-maven-3.3.9 /usr/local/maven
329 cp -r apache-maven-3.3.9 /usr/local/maven
330 vim /etc/profile //
331 . /etc/profile //
332 cd /usr/local/maven/
333 ls
334 cd bin/
335 ls
336 vim /etc/profile
337 source /etc/profile
338 mvn
339 vim /etc/profile
340 source /etc/profile
341 cd /tmp/software/
342 ls
343 cd product/
344 ls
345 git clone https://github.com/medcl/elasticsearch-analysis-pinyin.git
346 ls
347 cd elasticsearch-analysis-pinyin/
348 ls
349 mvn package
350 ls
351 cd ..
352 ls
353 rm -rf elasticsearch-analysis-pinyin
354 ls
355 wget https://github.com/medcl/elasticsearch-analysis-pinyin/archive/v1.7.4.zip //
356 ls
357 mkdir elasticsearch-analysis-pinyin
358 mv v1.7.4.zip elasticsearch-analysis-pinyin/ //
359 cd elasticsearch-analysis-pinyin/
360 ls
361 unzip v1.7.4.zip //
362 ls
363 cd elasticsearch-analysis-pinyin-1.7.4/ //
364 ls
365 mvn package //
366 ls
367 cd target/ //
368 ls
369 cd releases/ //
370 ls
371 cp elasticsearch-analysis-pinyin-1.7.4.zip ../../../

实现中文分词后再进行pinyin过滤

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
{
"index" : {
"analysis" : {
"analyzer" : {
"custom_pinyin_analyzer" : {
"tokenizer" : "ik_smart",
"filter" : ["full_pinyin_no_space","full_pinyin_with_space","first_letter_pinyin"]
}
},
"filter" :{
"full_pinyin_no_space" : {
"type" : "pinyin",
"first_letter" : "none",
"padding_char" : ""
},
"full_pinyin_with_space" : {
"type" : "pinyin",
"first_letter" : "none",
"padding_char" : " "
},
"first_letter_pinyin" : {
"type" : "pinyin",
"first_letter" : "only",
"padding_char" : ""
}
}
}
}
}

断词

同义词

自定义词库(自定义,第三方)


插件

当前使用插件:

  • elasticsearch-head 集群管理工具
    http://estest.baomihua.com/_plugin/head/
    提供索引分片基本信息查看和相关操作,以及基本的增删改查服务,和索引相关配置信息,集群状态,插件配置信息等。

  • bigdesk 集群监控工具
    http://estest.baomihua.com/_plugin/bigdesk/#nodes
    提供ES集群性能实时监测,包括JVM,Thread Pools,OS,Process,HTTP & Transport,Indices,File system相关信息。

  • kibana 可视化数据工具
    http://estest.baomihua.com:5602
    kibana是个日志可视化工具,在本环境下用来提供索引记录的实时详细查询,已经根据索引数据建立相关图表分析等。

  • Marvel 可视化ES集群状态监测工具
    http://estest.baomihua.com:5602/app/marvel
    提供更加美观的可视化ES集群性能实时监测。

  • elasticsearch-jdbc 数据导入工具


索引更新

全量索引

全量索引类似建立索引,全量导入oracle-pmh_es.sh

增量索引

ES-sql参数:
获取一个表,select from table可以使用查询。 查询从数据库选择数据的简单的变体。 他们转储表成Elasticsearch逐行。 如果没有_id列名,IDs将自动生成。
id as _id 这样的话可以增量同步,_id是es的默认id命名
“interval”:”1800”, 这里是同步数据的频率 1800s,半小时,可以按需要设成 1s或其它
“schedule” : “0 0/60 0-23 ?
*”, 同步数据任务 60分钟一次
“flush_interval” : “5s”, 刷新间隔为5S
sql.parameter——绑定SQL语句参数(按顺序)。 可以使用一些特殊的值具有以下含义:

$now——当前时间戳
$state——国家之一:BEFORE_FETCH,取回,AFTER_FETCH,无所事事,例外
$metrics.counter——一个计数器
$lastrowcount——从最后一条语句的行数
$lastexceptiondate- SQL时间戳的例外
$lastexception——完整的堆栈跟踪的例外
$metrics.lastexecutionstart——最后一次执行SQL时间戳的时候开始
$metrics.lastexecutionend- SQL时间戳的时候最后一次执行结束
$metrics.totalrows——总获取的行数
$metrics.totalbytes——获取的字节总数
$metrics.failed——失败的SQL执行的总数
$metrics.succeeded
1
2
3
4
5
6
7
8
9
10
deltaImportQuery="SELECT * FROM PHM_SOLR WHERER SOLRTIME >TO_date('${metrics.lastexecutionstart}','YYYY-MM-DD hh24:mi:ss')"
"statefile" : "statefile-article.json",
"schedule" : "0 0-59 0-23 ? * *",
"sql" : [
{
"statement" : "select *, id as _id from article where update_time > ?",
"parameter" : [ "$metrics.lastexecutionstart" ]
}
]

ES查询API

简易搜索

http://estest.baomihua.com/pmh_es_smart-test/_search?&pretty
pretty:美化json

http://estest.baomihua.co/pmh_es_smart-test/_search?q=FILMNAME:%E4%B8%AD%E5%9B%BD+CHANNELNAME:%E4%B8%AD%E5%9B%BD&pretty
字段搜索:_search?q=FILMNAME:中国+CHANNELNAME:中国

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
GET /_search?timeout=10ms
定义响应超时时间
/_search
在所有索引的所有类型中搜索
/gb/_search
在索引gb的所有类型中搜索
/gb,us/_search
在索引gb和us的所有类型中搜索
/g*,u*/_search
在以g或u开头的索引的所有类型中搜索
/gb/user/_search
在索引gb的类型user中搜索
/gb,us/user,tweet/_search
在索引gb和us的类型为user和tweet中搜索
/_all/user,tweet/_search
在所有索引的user和tweet中搜索 search types user and tweet in all indices

分页

size: 结果数,默认10
from: 跳过开始的结果数,默认0
每页显示5个结果,页码从1到3
GET /_search?size=5
GET /_search?size=5&from=5
GET /_search?size=5&from=10

高亮

1
2
3
4
5
6
7
8
9
10
11
12
13
"highlight": {
"pre_tags": [
"<tag1>",
"<tag2>"
],
"post_tags": [
"</tag1>",
"</tag2>"
],
"fields": {
"FILMNAME": {}
}
}
1
2
3
4
5
6
7
8
9
10
11
12
{
"query": {
"match": {
"FILMNAME": "中国"
}
},
"highlight": {
"fields": {
"FILMNAME": {}
}
}
}

ES结构化API

请求体查询

1
2
GET /_search
{} <1>

返回索引中所有的文档

1
2
3
4
5
6
7
8
9
10
11
GET /_search
{
"from": 30,
"size": 10
}
POST /_search
{
"from": 30,
"size": 10
}

分页

Query DSL

1
2
3
4
5
6
GET /_search
{
"query": {
"match_all": {}
}
}

匹配所有的文档

合并多子句

查询子句就像是搭积木一样,可以合并简单的子句为一个复杂的查询语句,比如:
叶子子句(leaf clauses)(比如match子句)用以在将查询字符串与一个字段(或多字段)进行比较
复合子句(compound)用以合并其他的子句。例如,bool子句允许你合并其他的合法子句,must,must_not或者should,如果可能的话:

1
2
3
4
5
6
7
8
{
"bool":
{
"must": { "match": { "tweet": "elasticsearch" }},
"must_not": { "match": { "name": "mary" }},
"should": { "match": { "tweet": "full text" }}
}
}


Filter DSL

term 过滤

term主要用于精确匹配哪些值,比如数字,日期,布尔值或 not_analyzed的字符串(未经分析的文本数据类型):

1
2
3
4
{ "term": { "age": 26 }}
{ "term": { "date": "2014-09-01" }}
{ "term": { "public": true }}
{ "term": { "tag": "full_text" }}

terms 过滤

terms 跟 term 有点类似,但 terms 允许指定多个匹配条件。 如果某个字段指定了多个值,那么文档需要一起去做匹配:

1
2
3
4
5
{
"terms": {
"tag": [ "search", "full_text", "nosql" ]
}
}

range过滤

1
2
3
4
5
6
7
8
{
"range": {
"age": {
"gte": 20,
"lt": 30
}
}
}

范围操作符包含:
gt :: 大于
gte:: 大于等于
lt :: 小于
lte:: 小于等于

exists 和 missing 过滤

1
2
3
4
5
{
"exists": {
"field": "title"
}
}

bool 过滤

bool 过滤可以用来合并多个过滤条件查询结果的布尔逻辑,它包含一下操作符:
must :: 多个查询条件的完全匹配,相当于 and。
must_not :: 多个查询条件的相反匹配,相当于 not。
should :: 至少有一个查询条件匹配, 相当于 or。

match 查询

multi_match 查询

multi_match查询允许你做match查询的基础上同时搜索多个字段:

1
2
3
4
5
6
{
"multi_match": {
"query": "full text search",
"fields": [ "title", "body" ]
}
}


排序

字段值排序

1
2
3
4
5
6
7
8
9
GET /_search
{
"query" : {
"filtered" : {
"filter" : { "term" : { "user_id" : 1 }}
}
},
"sort": { "date": { "order": "desc" }}
}

date排序会转换为毫秒进行排序
_score得分排序,最优结果


注意:本文为工作记录,未进行文档化,部分内容可读性较差,如有啥知识性误导或问题,可以留言反馈。以后或许会写些系列性的ES文档。

hyperxu wechat
欢迎您扫一扫上面的二维码,订阅我的公众号!
坚持原创技术分享,您的支持将鼓励我继续创作!