Elasticsearch

关于elasticsearch:elasticsearch-学习系列目录更新ing

一、根底（文档学习）elasticsearch根底(1)——概念 elasticsearch根底(3)—— 聚合初识二、云服务elasticsearch云服务(1)——elasticsearch cloud 初试三、插件工具elasticsearch插件(1)—— esm 四、源码浏览elasticsearch2.0源码浏览(1) ——环境装置 elasticsearch 7.X 源码学习(1)——本地debug 五、理论总结elasticsearch理论总结(1)——常见谬误 elasticsearch理论总结(2)——集群状态监控

关于docker:使用-Docker-运行-elasticsearch-容器

# 搜寻elasticsearch镜像docker search elasticsearch# 拉取elasticsearch镜像docker pull elasticsearch# 查看所有镜像docker images# 运行elasticsearch容器，-d 后盾运行容器并打印出容器ID，-p 将容器的9200端口映射到主机的9200端口docker run -d --name es \-p 9200:9200 -p 9300:9300 \-e "discovery.type=single-node" \-e ES_JAVA_OPTS="-Xms64m -Xmx512m" \elasticsearch:7.6.2curl localhost:9200在浏览器中拜访并显示elasticsearch信息： http://localhost:9200查看所有运行中的容器： docker ps通过容器名称进行容器： docker container stop es通过容器名称移除容器： docker container rm es

关于elasticsearch:elasticsearch-cloud-初试

一、参考Enable logging and monitoring二、kibana开启monitor

关于elasticsearch:elasticsearch-的常见错误

一、参考二、命名标准2.1 索引名称必须是小写 2.2 字段名称不能蕴含点号.（1）创立索引 PUT testfieldname/{ "mappings": { "properties": { "f1.f2": { "type": "keyword" } } }}(2) 查看mapping GET testfieldname/_mapping{ "testfieldname" : { "mappings" : { "properties" : { "f1" : { "properties" : { "f2" : { "type" : "keyword" } } } } } }}字段名称中蕴含有., 会主动解析为json构造

关于elasticsearch:elasticsearch中的概念

一、参考权威指南: doc values二、doc Values2.1 简略介绍聚合时候，应用一个 doc values数据结构，应用 doc values能够让聚合: (1) 速度更快 (2) 更高效 (3) 内存敌对 2.2 倒排索引倒排索引的劣势：查找蕴含某个项的文档例如：如果须要查问蕴含 brown字段的所有的文档，

关于elasticsearch:elasticsearch-迁移工具-esm试用

一、参考github 源码 esm二、下载安装2.1 下载源码esm-0.5 2.2 装置(1) 通过源码装置 tar -xvzf esm-0.5.0.tar.gzcd esm-0.5.0/make(2) 通过安装包装置 tar -xzvf darwin64.tar.gzls -ll bin/darwin64esm三、数据导出到本地esm ./bin/darwin64/esm --helpUsage: esm [OPTIONS]Application Options: -s, --source= source elasticsearch instance, ie: http://localhost:9200 -q, --query= query against source elasticsearch instance, filter data before migrate, ie: name:medcl -d, --dest= destination elasticsearch instance, ie: http://localhost:9201 -m, --source_auth= basic auth of source elasticsearch instance, ie: user:pass -n, --dest_auth= basic auth of target elasticsearch instance, ie: user:pass -c, --count= number of documents at a time: ie "size" in the scroll request (10000) --buffer_count= number of buffered documents in memory (1000000) -w, --workers= concurrency number for bulk workers (1) -b, --bulk_size= bulk size in MB (5) -t, --time= scroll time (10m) --sliced_scroll_size= size of sliced scroll, to make it work, the size should be > 1 (1) -f, --force delete destination index before copying -a, --all copy indexes starting with . and _ --copy_settings copy index settings from source --copy_mappings copy index mappings from source --shards= set a number of shards on newly created indexes -x, --src_indexes= indexes name to copy,support regex and comma separated list (_all) -y, --dest_index= indexes name to save, allow only one indexname, original indexname will be used if not specified -u, --type_override= override type name --green wait for both hosts cluster status to be green before dump. otherwise yellow is okay -v, --log= setting log level,options:trace,debug,info,warn,error (INFO) -o, --output_file= output documents of source index into local file -i, --input_file= indexing from local dump file --input_file_type= the data type of input file, options: dump, json_line, json_array, log_line (dump) --source_proxy= set proxy to source http connections, ie: http://127.0.0.1:8080 --dest_proxy= set proxy to target http connections, ie: http://127.0.0.1:8080 --refresh refresh after migration finished --fields= filter source fields, comma separated, ie: col1,col2,col3,... --rename= rename source fields, comma separated, ie: _type:type, name:myname -l, --logstash_endpoint= target logstash tcp endpoint, ie: 127.0.0.1:5055 --secured_logstash_endpoint target logstash tcp endpoint was secured by TLS --repeat_times= repeat the data from source N times to dest output, use align with parameter regenerate_id to amplify the data size -r, --regenerate_id regenerate id for documents, this will override the exist document id in data source --compress use gzip to compress traffic -p, --sleep= sleep N seconds after each bulk request (-1)Help Options: -h, --help Show this help message3.1 先创立测试数据PUT yz_tracing-000001POST _reindex{ "source": { "index": "test_tracing-000001" }, "dest": { "index": "yz_tracing-000001" }}GET _tasks?actions=*reindex./bin/darwin64/esm -s https://testhost:9243 -m "elastic:testpasswd" -x "yztest" -o "yz_oss_test-000001" ...

关于elasticsearch:ESKibana的Docker部署

version: '2.2'services: es01: image: docker.elastic.co/elasticsearch/elasticsearch:7.8.1 container_name: es01 environment: - node.name=es01 - cluster.name=es-docker-cluster - cluster.initial_master_nodes=es01 - bootstrap.memory_lock=true - "ES_JAVA_OPTS=-Xms512m -Xmx512m" ulimits: memlock: soft: -1 hard: -1 volumes: - data01:/usr/share/elasticsearch/data ports: - 9200:9200 networks: - elastic kib01: image: docker.elastic.co/kibana/kibana:7.8.1 container_name: kib01 ports: - 5601:5601 environment: ELASTICSEARCH_URL: http://es01:9200 ELASTICSEARCH_HOSTS: http://es01:9200 networks: - elasticvolumes: data01: driver: local data02: driver: local data03: driver: localnetworks: elastic: driver: bridge

关于聚合:elasticsearch-聚合初识一

一、参考elasticsearch 权威指南二、基本概念2.1 两个次要概念bucket 桶满足特定条件的文档的汇合 metric 指标对桶内的文档进行统计计算每一个聚合都是（1）一个或者多个桶（2）0个或者多个指标的组合 2.2 桶简略说来，桶就是满足了特定条件的文档的汇合当聚合开始被执行，（1）每个文档外面的值通过计算来决定合乎哪个桶的条件，（2）如果匹配到，文档将放入对应的桶，并且接着进行聚合操作（3）桶能够被嵌套到其余的桶中，提供层次化或者有条件的划分计划 2.3 指标分桶是一种达到目标的伎俩，最终的指标是：对于桶内的文档进行一些指标的计算大多数的指标都是简略的数学计算三、桶排序3.1 默认排序默认，多值桶会依据 doc_count 降序排列 3.2 order引入了一个 order 对象，扩大了桶排序：类型阐明termshistogramdate_histogram_count依照文档数量排序✅✅✅_term依照词项的字符串的字典顺序排列✅❌❌_key按每个桶的键值数值排序❌✅✅3.3 度量排序能够增加一个度量聚合，而后在外层 order中指定具体的度量度量只有1个输入值GET /cars/_search{ "size": 0, "aggs": { "colors": { "terms": { "field": "color", "order": { "avg_price": "asc" } }, "aggs": { "avg_price": { "avg": { "field": "price" } } } } }}度量如果有多个值，须要指定具体的参数GET /cars/_search{ "size": 0, "aggs": { "colors": { "terms": { "field": "color", "order": { "stats.variance": "asc" } }, "aggs": { "stats": { "extended_stats": { "field": "price" } } } } }}3.4 深度度量能够定义更深的门路，将度量用尖括号（ > ）嵌套起来，像这样： ...

关于elasticsearch:Elasticsearch入门二

一、ES根底概念1.简单的分布式机制，比方分片、正本、负载平衡等等，全副都暗藏起来2.扩容计划(垂直扩容、程度扩容)3.减少或者缩小节点时的数据rebalance：总有某些服务器的负载会重一些，承载的数量和申请量会大一些4.mater节点: (1)治理es集群的元数据,比如说索引的创立和删除,保护索引元数据;节点的减少和移除，保护集群的元数据(2)默认状况下，会主动抉择出一台节点，作为mater节点(3)mater节点不承载所有的申请，所以不会是单点瓶颈5.节点对等的分布式架构 (1)节点对等，每个节点都能接管所有的申请(2)节点的主动路由二、shard和replica机制详解index蕴含多个shard每个shard都是一个最小工作单元，承载局部数据增减节点时，shard会主动的nodes中负载平衡每个document只能存在于一个primary shard中。replica shrad是primary shard的正本，负责容错以及承当读申请负载primary shard的数量再创立索引的时候就固定了，replica shard的数据能够随时更改replica shard 不能和primary shard放在同一个节点上，然而能够和别的primary shard的replica shard 放在同一个节点三、指定index的primary shard的数量 PUT /test_index { "settings":{ "number_of_shards":3, "number_of_replicas":1 } }四、容错的过程当有一个node宕机，这个机器上的某个primary shard 就没了，此时status就不是active，状态也会批改成red。(1) 容错第一步：mater 选举，主动抉择另一个node成为新的mater，承当起master的责任(2) 容错第二步：新的master，将失落掉的primary shard的某个replica shard晋升为primary shard，此时cluster status会变为yellow，因为primary shard 全副都变成了active。然而少了一个replica shard,所以不是所有的replica shard 都是active(3)容错第三步：重启故障的node，新的mater会将缺失的正本都时copy一份到该node上，而且该node会应用之前已有的shard数据，只是同步一下宕机之后产生过的批改。cluster status 变为green。

关于kibana:kibana-查看日志具体流程

一、前提前提是曾经实现了下面的步骤。咳咳二、具体操作 1、创立索引模式 2、 3、以上三步就over了三、查看

关于elasticsearch:elasticsearch7X-创建索引文档fields

一、索引的增删改查rest 肯定要大写哦哈哈减少索引： customer 索引名，_doc type类型 ,1 文档id 大括号中的为申请体（及数据）1、创立索引PUT /索引名/类型名（会删除）/文档id { 申请体}阐明：PUT手动指定索引例：创立索引PUT /customer/_doc/1{ "name": "John Doe"}2、查问索引GET /customer/_doc/13、删除索引DELETE /customer4、批改PUT /customer/_doc/1 { "name": "大帅逼"}阐明：这种形式会将version版本号减少，然而增加时须要与后面文档中数据数目统一不然会失落数据POST /test20210304/_doc/1/_update{ "doc":{ "name": "大帅逼" }}二、索引的属性批改创立索引规定，就像设置数据库的一些参数一样，PUT /test1{ "mappings": { "properties": { "name": { "type":"text" } } }}阐明：设置文档中对应词组的类型GET /test1 查看索引的信息三、查看elasticsearch状态GET _cat/ 获取es的信息状态四、文档的操作 1、基本操作1）增加数据 PUT /testbasedoc/_doc/1{ "name":"大帅比大水笔", "age":"23", "desc":"喜之郎果冻，盼盼我爱你", "likes":["java 爪哇","可恶","刘月半"] }PUT /testbasedoc/_doc/2{ "name":"鸡蛋", "age":"23", "desc":"喜之冻，牙医媒体", "likes":["电影ae,ar","胖胖","倩妹子"]}PUT /testbasedoc/_doc/3{ "name":"鸭蛋", "age":"23", "desc":"趣味使然的理发师", "likes":["打游戏","剪头发","妹子"]} 2)查问GET testbasedoc/_doc/1 3）更新 POST /test20210304/_doc/1/_update{ "doc":{ "name": "大帅比2" }}4）删除文档DELETE /tehero_index/_doc/1 ...

关于elasticsearch:Elasticsearch生态技术峰会-Elasticsearch在企查查的应用实践

简介：开源最大的特色就是开放性，云生态则让开源技术更具开放性与创造性，Elastic 与阿里云的单干正是开源与云生态共生共荣的榜样。值此单干三周年之际，咱们邀请业界资深人士相聚云端，共话云上Elasticsearch生态与技术的将来。开源最大的特色就是开放性，云生态则让开源技术更具开放性与创造性，Elastic 与阿里云的单干正是开源与云生态共生共荣的榜样。值此单干三周年之际，咱们邀请业界资深人士相聚云端，共话云上Elasticsearch生态与技术的将来。本篇内容是企查查搜寻部门经理范兆明分享的Elasticsearch在企查查的利用实际。分享人：企查查搜寻部门经理范兆明视频地址：http://cloud.video.taobao.com/play/u/3177173649/p/1/e/6/t/1/297441406466.mp4 家喻户晓，企查查是一家业余做工商查问的公司，所有的业务入口都是基于查问实现的，能够说查问是实现企查查价值的次要入口。所以，本篇内容将介绍Elasticsearch在企查查的利用实际。企查查遇到阿里云ES时的情况是，海量的数据无奈存储，存储后的数据无奈做大规模的剖析，实时的用户行为得不到到监控。基于这些痛点，让企查查在寻找解决办法的过程中遇到并意识了阿里云ES。通过搭建ELK日志剖析平台、日志剖析、全文检索等性能，充沛的理解和相熟了ES。 ES次要的技术革新和特点，总结而言有三个：架构天生分布式、检索全文和构造、剖析实时聚合。架构天生分布式ES天生的分布式架构能够通过硬件扩容的形式实现海量数据的收缩，并且它的正本模式可能解决数据安全问题。检索全文和构造通过Lucene的倒排索引、Bm25的全文检索和高效的结构化检索，可能满足大部分搜寻场景。剖析实时聚合实时的海量聚合能力和多聚合模式可能实现大部分剖析场景。基于以上ES的能力，最终企查查抉择了阿里云ES。那么阿里云在ES的根底上又带来了哪些方面的便捷呢？优良的NLP分词器阿里云ES具备优良的NLP分词器能力。目前支流的ES中文分词器有IK和ANSJ等次要的几种，企查查抉择了IK和ANSJ后，荡涤了大概百万级的根底数据，而后导入到IK和ANSJ。通过阿里云分词器比照了IK和ANSJ分词器发现，基于NLP的阿里云分词器更优良。区别就在于，基于NLP的阿里云分词器能够在不同场景解析出不同的语义，实现不同分词，所以企查查最终的解决方案是，以阿里云分词器为主，以ANSJ分词器为辅做了两套分词模式，同时利用于文档搜寻。一站式治理和高效扩大这两个特点本来就是云平台的人造劣势，这也是为什么中小企业和高速倒退企业会抉择云平台的根本原因。企查查基于阿里云Elasticsearch设计的利用实际，这里给大家介绍几个外围的数据。 5000+QPS5000+QPS是指实时峰值QPS达到每秒5000； 200+利用200+是指目前有200个数据维度参加了实时搜寻； 8TB数据8TB是指所有实时搜寻数据加起来超过8TB。从下图企查查的倒退历程能够发现，2014年企查查只有繁多的工伤搜寻维度；倒退到2020年底，企查查曾经超过了200多个搜寻维度。疾速的版本迭代、数据爆炸式的增长、爆炸式的用户申请等等都在阿里云ES上都失去了很好的体现。因为阿里云具备足够稳固、疾速扩容、大大减少经营老本和搜寻故障等特点，在这些年的倒退中一直的晋升企查查的搜寻体验。企查查的技术特点企查查波及到的其余技术特点跟全文检索特点是一样的，包含高并发、海量数据、实时聚合和分词等特点。高并发和实时聚合也是ES所善于的，再加上阿里云优良的NLP分词器，两两作用后让企查查搜寻体验更优良。搜寻的目标咱们越来越器重搜寻并一直进步搜寻体验，那么搜寻须要出现的后果是怎么的呢？第一个是精准搜寻。顾名思义，就是把搜索词和文本词齐全匹配的后果返回给用户；第二个是分词匹配。分词匹配是目前搜寻技术的支流，也是最难实现的。难度在于，尽管有基于语义的分词器，如基于NLP的阿里云，但依然会有分词异样和分词歧义的时候。根底数据的权重配比、荡涤排序是否达到用户预期和搜寻用意，都是长期迭代的工作。第三个是意义搜寻。意思是当用户搜寻的词，在精准搜寻和分词搜寻都没有匹配，但实际上意义是一样时提供的服务，比方番茄和西红柿，或是同音字和形近字，这个时候就会须要意义搜寻。意义搜寻就是把同义字、同音字和形近字都反馈给搜寻用户。第四个是用意搜寻。当用户搜了一大段内容，然而在分词、精准和意义搜寻里都没有方法找到搜寻后果时，就须要提取用户搜寻的外围词，而后用外围词再去搜寻并反馈给用户后果。第五个是局部匹配搜寻。意思是当上述四个搜寻都没有后果的时候，须要将局部匹配出的后果反馈给用户。 Elasticsearch还能带来什么？目前ES在机器学习方面做了继续迭代，能够主动发现实时数据异样，主动实现业务的实时监控。 ES能够做更深层次的数据分析，还能够将发现数据的外围词和数据的特点举荐给搜寻的用户。原文链接本文为阿里云原创内容，未经容许不得转载。

关于elasticsearch:Elasticsearch生态技术峰会-Elasticsearch在清博大数据的应用与实践

简介：开源最大的特色就是开放性，云生态则让开源技术更具开放性与创造性，Elastic 与阿里云的单干正是开源与云生态共生共荣的榜样。值此单干三周年之际，咱们邀请业界资深人士相聚云端，共话云上Elasticsearch生态与技术的将来。开源最大的特色就是开放性，云生态则让开源技术更具开放性与创造性，Elastic 与阿里云的单干正是开源与云生态共生共荣的榜样。值此单干三周年之际，咱们邀请业界资深人士相聚云端，共话云上Elasticsearch生态与技术的将来。本篇内容是清博大数据技术副总裁王欢带来的基于Elasticsearch技术的利用与实际分享。分享人：清博大数据技术副总裁王欢对于Elasticsearch在清博的利用和实际，本文将通过四个局部开展介绍：对于清博典型业务场景痛点与诉求阿里云Elasticsearch实际与收益一、对于清博大数据清博数据成立于2014年，是一家专一于内容数据畛域，是基于网络公开数据，依靠自然语言解决、常识图谱、事理图谱等AI技术，开掘有价值的数据以及关系，为政务部门、企业、媒体和高校的网络空间数据治理，提供一站式解决方案的公司。清博大数据的次要业务布局有：清博指数，曾经成为业内出名的新媒体账号评估服务体系；清博舆情，是业内支流舆情SaaS服务平台，为数十万B端网络品牌跟踪治理提供一站式服务；清博融媒，助力政企、校园的融媒体建设；产业数据，基于数据和技术的积攒，在汽车大数据和环保大数据等产业数据畛域也有布局。二、典型业务场景上文所提到的业务方向中都有Elasticsearch的参加和反对。上面介绍几个典型的利用场景。清博舆情下图展现的是清博舆情中常见的剖析模块。清博舆情利用NLP技术给常见的每条新闻及评论打上7个情绪标签，而后基于标签剖析每天的情绪走势和情绪散布状况。这个利用能够了解为，针对某个事件，公众在不同情感表白下的声量大小。另外，咱们也对事件的公布和媒体敏感信息报道进行渠道统计，统计后就能够直观的看到一个事件的重要或敏感的流传节点，这就为业务的决策者提供了十分直观的决策参考。除此之外，零碎还为用户提供发文类型、提及地区、热词剖析等十多个罕用的统计分析模块。以上所形容的统计分析，都是基于Elasticsearch弱小的聚合统计能力，包含嵌套的统计能力实现的。因为清博大数据提供的是线上的SaaS服务，在同个页面会爆发申请查问或聚合多个接口等需要，这就对Elasticsearch的聚合统计性能和内存使用率，都提出了更高的要求。多维度的检索多维度检索在清博大数据也是比拟常见的业务场景。在舆情高级检索模块，清博检索提供了基于工夫、公布平台、情感、媒体类别、公布地区等十多个维度的复合检索。同时还提供了基于term和match price的准确或含糊检索的简单查问形式。不同于日志检索场景，清博的多维度检索业务，须要衡量召回率和准确率，须要对题目跟注释设置不同的打分策略。比方给题目设置更高的权重，给注释设置绝对较低的权重。另外，产品还能对包含阿拉伯语、日语、韩语、德语、法语等多国语言进行文本检索，这就波及到了多语种的分词与检索召回。账号画像下图是清博指数平台一个微信公众号的画像页面，展现了公众号系列数据，包含浏览统计、浏览点赞、在看、发文趋势、公布习惯等数据指标的统计模块。通过这些模块，用户能够直观的理解一个公众号的公布状况、文章流传状况等，不仅给运营者提供了全方位、可参考的数据，也给广告投放的用户提供主观投放参考。三、痛点与诉求上文列举的不同业务场景都离不开Elasticsearch弱小的查问和聚合能力，那么实现这样的性能有哪些痛点与诉求呢？从下面业务场景列举能够看出，清博大数据的业务基本上都是基于文本检索，那么它具备的特点包含：须要反对多种语言检索；因为是在线的SaaS零碎，须要实现亚秒级响应；须要反对上百个索引字段；须要满足聚合查问多和迭代频繁；基于以上的业务特点就要求Elasticsearch具备高性能、均衡检索的召回率和准确率，并具备动静伸缩的能力。基于以上的业务特点和服务要求，对清博大数据来讲，业务痛点能够分为三个方面：1、老本单篇文档不同于日志数据，占用索引空间大，所需的SSD存储低廉； 2、运维当业务数据一直减少，须要频繁扩节点；同时，因为是在线SaaS业务，所以须要实现亚秒级响应速度；并且在节点降级、减少内存等在线降级时，不进行服务。 3、兼容性实现Elasticsearch集群迁徙、本地化部署，业务代码无感知适配；云端备份索引能够兼容开源的Elasticsearch。针对以上的业务痛点，清博大数据对云端Elasticsearch也提出了三点诉求： 1、老本平滑扩缩容，索引反对冷热拆散，热数据才放到SSD存储，从而升高存储老本； 2、运维须要有简略的运维工具反对一键扩缩容和节点降级等能力；须要反对丰盛的运维指标，在达到肯定阈值时，能够有不同类型的报警告诉；须要反对平滑降级不对业务产生影响； 3、兼容性阿里云Elasticsearch 100%兼容开源生态，并反对自定义的分词器，实现热更新分词词典，不便备份与复原。云上备份与索引，能够疾速在开源Elasticsearch上复原或拉起服务。四、云上实际与收益清博大数据在迁徙之前是基于Apache Solr自建的搜寻集群，为了晋升搜寻性能和坚固集群稳定性，创立了很多小的Solr集群。在上游数据分析之后，通过一套路由机制写入到不同的Solr集群，在查问时通过同一套机制，主动抉择对应的集群。在不同的集群中查问不同的数据，能够扩散单个集群压力，如果有小集群异样只会影响局部业务。然而太多扩散且小的集群也会呈现很多问题，比方减少故障的概率、短少对立运维治理平台、运维治理老本过高、无奈主动裁减Shard、须要手动减少节点扩容等等。相比之下，阿里云Elasticsearch提供智能的、对立的运维平台，不仅能够多维度地监控告警，也能及时发现集群问题，而且阿里云ES专家的反对也缩小了大量的运维老本。阿里云ES主动Shard，晋升零碎性能，进步了零碎的检索性能；阿里云ES节点的伸缩能力，能够灵便应答业务逐渐减少，节俭大量一次性投入的老本。在迁徙过程中，清博大数据同步降级了数据架构，整个平台是分层的数据模式。最底层是数据接入层，包含上述提到的各平台社交文本数据。所有的数据源首先会推送到Kafka集群，通过音讯队列对各个业务模块进行检索。再往上一层是数据处理和存储层。在存储层，像新闻标题、公布工夫、原始URL等信息存储到HBASE。一些不须要检索内容的镜像数据会存到OSS上进行长期存储，并把OSS的门路存到HBASE，不便前面的查看。在数据处理这一层，应用 Flink 实时流解决引擎，通过RPC的形式实时调用NLP相干的算法服务，为每一条文本内容打上情感属性、情绪分类、新闻类型和地区等标签，不便上游业务应用。再上一层是整个ES的基础设施，包含ES集群和智能网关两层服务。在ES集群层，依据业务特点把近两年的数据放到冷数据集群，应用价格绝对较低的高效云盘，把近三个月的数据放到热数据集群，应用SSD盘进行冷热集群拆散，同时依据不同平台大小对索引进行拆分，分为微信、微博、短视频等等索引。为了进步ES的安全性和拜访的可控性，清博大数据开发了智能网关服务，屏蔽了直连ES的形式。在智能网关层，有很多业务都要调用ES数据，为了避免单个业务占用过多资源，影响到其余业务应用，网关能够为每个业务调配各自的QPS并设置优先级。一旦集群呈现问题，能够对低优先级的业务进行熔断限流，以保障高优先级的业务。因为在ES的数据层把索引依照起源进行拆分，数据被扩散到多个集群中，这会给查问带来肯定的麻烦。为了不便前端业务的调用，网关路由所有模块能够依据业务端查问的数据类型，主动路由到对应的索引，同时网关层也会对业务端查问进行优化，比方依据时间段抉择对应索引，而不是扫描全副索引。最下面一层是业务接入层，包含上文提到的舆情业务、指数业务、融媒业务等等。基于阿里云ES打造的对立数据平台，也能够看作是一个分层架构，如下图。最底层文档写入ES索引前，会先进入路由层。路由服务会依据文档的起源、公布工夫、机型状态等，抉择对应的集群以及索引，比方主动抉择对应平台或者是对应索引所在的机器。对日增数据量比拟少的平台，会依照周或月进行索引拆分。对日增数据量很大的平台，路由会按天创立索引，这样就防止单个索引过大、数据过于歪斜而影响整个集群性能的问题，使每个索引的大小放弃基本相同。再向上一层是多个ES集群，包含不同平台的数据集群和冷热数据集群。后面一层通过路由策略之后，最终数据会扩散到对应集群的对应索引中。为了不便查问，通过开发的Proxy，对用户特定的索引查问、多索引查问和聚合查问，甚至跨集群查问等，能够对数据进行查问汇合，做到对业务端底层的索引细节屏蔽、业务端无感知、升高业务端调用老本，同时也不便底层的迭代降级。基于以上的架构，在阿里云的ES数据平台提供近三个月超过100亿的热数据，在近三个月的索引占用空间超过60TB，日增网络公开内容数据超过1.2亿，单篇文档搜寻字段超过200。在这么大数据量的状况下，频繁变动降级会带来一些问题。值得一提的是，利用阿里云ES诊断性能，能够很不便地发现ES集群潜在的问题，也为集群的运维方向提供诊断经营。在阿里云ES各种性能的加持下，清博大数据平台的稳定性较之以前晋升了60%，整个运维工夫缩小了80%。正是因为阿里云Elasticsearch平台的各种能力，让团队能够把更多的精力放到产品开发和迭代上，比方基于平台能力疾速开发了轻薄融媒平台，为清博融媒平台提供内容检索服务。在开发的政府补贴类利用中提供政策搜寻服务，为前面的举荐算法提供杰出的后果，也为年初公众号经营画像类利用提供相干统计服务。除此之外，基于平台的能力还能提供更多的产品状态。原文链接本文为阿里云原创内容，未经容许不得转载。

关于ElasticSearch:prometheus监控之elasticsearch监控elasticsearchexporter

一、对于elasticsearch-exporterelasticsearch_exporter与ES集群是离开独立，不须要对原有的ES集群(可能有很多个)做任何批改，不须要重启，只有能拜访es集群即可。二、装置1.下载elasticsearch_exporter-1.1.0.linux-amd64.tar.gz安装包并解压到/usr/local目录抉择对应的版本进行下载：elasticsearch_exporter # 下载wget https://github.com/justwatchcom/elasticsearch_exporter/releases/download/v1.1.0/elasticsearch_exporter-1.1.0.linux-amd64.tar.gz# 解压tar -xvf elasticsearch_exporter-1.1.0.linux-amd64.tar.gzcd elasticsearch_exporter-1.1.0.linux-amd64/三、启动1.罕用参数解释 ## 参数阐明：--es.uri 默认http://localhost:9200，连贯到的Elasticsearch节点的地址（主机和端口）。这能够是本地节点（例如localhost：9200），也能够是近程Elasticsearch服务器的地址--es.all 默认flase，如果为true，则查问群集中所有节点的统计信息，而不仅仅是查问咱们连贯到的节点。--es.cluster_settings 默认flase，如果为true，请在统计信息中查问集群设置--es.indices 默认flase，如果为true，则查问统计信息以获取集群中的所有索引。--es.indices_settings 默认flase，如果为true，则查问集群中所有索引的设置统计信息。--es.shards 默认flase，如果为true，则查问集群中所有索引的统计信息，包含分片级统计信息（意味着es.indices = true）。--es.snapshots 默认flase，如果为true，则查问集群快照的统计信息。2.只有设置不同的-web.listen-address监听端口，可启动多个实例，别离监控不同的ES集群： # es集群1：10.xxx.xxx.10:9200nohup ./elasticsearch_exporter --es.all --es.indices --es.cluster_settings --es.indices_settings --es.shards --es.snapshots --es.timeout=10s --web.listen-address=":9114" --web.telemetry-path="/metrics" --es.uri http://10.xxx.xxx.10:9200 & # es集群2：10.xxx.xxx.11:9200nohup ./elasticsearch_exporter --es.all --es.indices --es.cluster_settings --es.indices_settings --es.shards --es.snapshots --es.timeout=10s --web.listen-address=":9115" --web.telemetry-path="/metrics" --es.uri http://10.xxx.xxx.11:9200 &3.如果es集群开启了x-pack验证则能够应用如下： nohup ./elasticsearch_exporter --es.all --es.indices --es.cluster_settings --es.indices_settings --es.shards --es.snapshots --es.uri http://用户名:明码@111.xxx.xxx.6:9200 &四、prometheus配置及grafana配置prometheus配置- job_name: 'elasticsearch' static_configs: - targets: ['111.xx.xxx.1:9114']2.grafana配置导入2322模板下载地址：https://grafana.com/grafana/dashboards/2322 ...

关于ElasticSearch:elasticSearch集群索引管理Curator

一、对于Curatorcurator容许对索引和快照执行许多不同的操作，罕用操作包含：从别名增加或删除索引更改分片路由调配更改分片路由调配敞开索引敞开索引创立索引创立索引删除索引删除索引删除快照删除快照关上被敞开的索引关上被敞开的索引curator版本Curator版本关系二、装置&卸载curator1.自己应用的装置形式（centos7环境下）下载对应的curator包下载地址： Elasticsearch Curator 5.8.3 RHEL/CentOS 7 Binary Package (RPM)Elasticsearch Curator 5.8.3 RHEL/CentOS 6 Binary Package (RPM)在elasticsearch集群所在的机器上装置curator rpm -ivh elasticsearch-curator-5.8.3-1.x86_64.rpm验证是否装置胜利 curator --version如果呈现如下谬误：Click will abort further execution because Python 3 was configured to use ASCII as encoding for the environment. Consult http://click.pocoo.org/python... mitigation steps. This system lists a couple of UTF-8 supporting locales thatyou can pick from. The following suitable locales wherediscovered: en_AG.utf8, en_AU.utf8, en_BW.utf8, en_CA.utf8, en_DK.utf8, en_GB.utf8, en_HK.utf8, en_IE.utf8, en_IN.utf8, en_NG.utf8, en_NZ.utf8, en_PH.utf8, en_SG.utf8, en_US.utf8, en_ZA.utf8, en_ZM.utf8, en_ZW.utf8解决形式： ...

关于elasticsearch:es相关命令

es 相干命令1. 查看索引，集群命令1.查看集群状态```curl -XGET 'localhost:9200/_cluster/_health?pretty'```2.查看集群衰弱状态```curl -XGET 'localhost:9200/_cat/nodes?v'```2. 查问语法1.范畴查问"query":{ "range":{ "gt":1, "lt":100 }}2. 聚合查问"aggs":{ "all_intersts":{ "terms":{"field":"interstece.keyword"}, "aggs":{"avg_price":{"avg":{"field":"price}}} }}3. 查问表字段映射curl 'localhost:9200/db/_mapping?pretty'4. 空查问"query":{ "match_all":{}}5. match查问会分词"query":{ "match":{ "age":"18" }}6. terms 查问查找tag是a或者b的"query":{ "terms":{"tag":["a","b"]}}7. term查问"query":{ "term":{"first_name":"zhangsan"}}//如果是text类型的话要加keyword，不然查不进去数据"query":{ "term":{"first_name.keyword":"zhangsan"}}8. exists 查问"query":{ "exists":{"field":"first_name"}}查问和过滤查问有相关性不会缓存过滤返回的后果是true|false 会缓存2. 更新语法3.es默认只会查出10条数据

关于elasticsearch:ElasticSearch-的索引统计信息及索引设置

索引统计信息GET /my-index-000001/_statsGET /index1,index2/_statsGET /_stats# 获取所有索引的merge和refresh统计信息GET /_stats/merge,refresh获取索引设置GET /my-index-000001/_settingsGET /my-index-000001,my-index-000002/_settingsGET /_all/_settingsGET /log_2099_*/_settingsGET /log_2099_-*/_settings/index.number_*更新索引设置PUT /my-index-000001/_settings{ "index" : { "number_of_replicas" : 2 }}具体的设置项可参考：https://www.elastic.co/guide/...重置索引设置PUT /my-index-000001/_settings{ "index" : { "refresh_interval" : null // 设为null能够复原默认值 }}批量索引数据ElasticSearch 是近实时搜索引擎，当须要批量索引数据时，能够先关掉主动刷新（数据刷新距离设为-1），批量操作执行完后再关上主动刷新，有助于放慢数据处理速度。 PUT /my-index-000001/_settings{ "index" : { "refresh_interval" : "-1" }}# 执行批量索引...PUT /my-index-000001/_settings{ "index" : { "refresh_interval" : "1s" }}POST /my-index-000001/_forcemerge?max_num_segments=5更新索引分析器只容许在敞开的索引中定义新的分析器。 POST /my-index-000001/_closePUT /my-index-000001/_settings{ "analysis" : { "analyzer":{ "content":{ "type":"custom", "tokenizer":"whitespace" } } }}POST /my-index-000001/_open

关于elasticsearch:ElasticSearch-的映射管理

提交映射PUT /my-index-000001PUT /my-index-000001/_mapping{ "properties": { "email": { "type": "keyword" } }}同时提交映射到多个索引# Create the two indicesPUT /my-index-000001PUT /my-index-000002# Update both mappingsPUT /my-index-000001,my-index-000002/_mapping{ "properties": { "user": { "properties": { "name": { "type": "keyword" } } } }}在已存在的对象字段中增加新属性PUT /my-index-000001{ "mappings": { "properties": { "name": { "properties": { "first": { "type": "text" } } } } }}PUT /my-index-000001/_mapping{ "properties": { "name": { "properties": { "last": { "type": "text" } } } }}在已存在的字段中增加多字段PUT /my-index-000001{ "mappings": { "properties": { "city": { "type": "text" } } }}PUT /my-index-000001/_mapping{ "properties": { "city": { "type": "text", "fields": { "raw": { "type": "keyword" } } } }}在已存在的字段中批改反对的映射参数PUT /my-index-000001{ "mappings": { "properties": { "user_id": { "type": "keyword", "ignore_above": 20 } } }}PUT /my-index-000001/_mapping{ "properties": { "user_id": { "type": "keyword", "ignore_above": 100 } }}在已存在的字段中批改映射除了批改反对的映射参数外，不能批改已有的字段映射或字段类型。更改已有字段可能会使曾经建设索引的数据有效。 ...

关于elasticsearch:ElasticSearch-的索引管理

创立索引PUT /my-index-000001索引名要求全副为小写，不能应用特殊字符，长度不能超过255字节。创立索引同时进行配置PUT /my-index-000001{ "settings": { "number_of_shards": 5, // 分片数量，默认1 "number_of_replicas": 1 // 正本数量，默认1 }}创立索引同时进行映射配置PUT /test{ "settings": { "number_of_shards": 1 }, "mappings": { "properties": { "field1": { "type": "text" } } }}删除索引DELETE /my-index-000001DELETE /_allDELETE /*反对以逗号分隔的列表或通配符表达式。获取索引GET /my-index-000001GET /_allGET /*索引是否存在HEAD /my-index-000001响应： 200 所有指定的索引或别名均存在404 一个或多个指定的索引或别名不存在

关于elasticsearch:ElasticSearch查询一

1. 筹备测试数据，将数据下载到本地:https://github.com/elastic/el... 数据结构:{ "account_number": 0, "balance": 16623, "firstname": "Bradshaw", "lastname": "Mckenzie", "age": 29, "gender": "F", "address": "244 Columbus Place", "employer": "Euron", "email": "bradshawmckenzie@euron.com", "city": "Hobucken", "state": "CO"}2. 导入数据到es进入到accounts.json文件的目录执行导入命令，该命令会主动创立bank索引curl -H "Content-Type: application/json" -XPOST "localhost:9200/bank/_bulk?pretty&refresh" --data-binary "@accounts.json" curl "localhost:9200/_cat/indices?v=true"3. 查问操作# 查问bank索引所有数据,默认显示10条GET /bank/_search# 分页查问并依据account_number降序GET /bank/_search{ "query": { "match_all": {} }, "sort": [ { "account_number": { "order": "desc" } } ], "from": 10, "size": 1}# 查问address蕴含mill或laneGET /bank/_search{ "query": { "match": { "address": "mill lane" } }}# 仅匹配蕴含mill lane的内容GET /bank/_search{ "query": { "match_phrase": { "address": "mill lane" } }}#应用bool来结构简单查问,age为40但state不为idGET /bank/_search{ "query": { "bool": { "must": [ { "match": { "age": "40" } } ], "must_not": [ { "match": { "state": "ID" } } ] } }}# 应用filter过滤数据GET /bank/_search{ "query": { "bool": { "must": [ { "match_all": {} } ], "filter": { "range": { "balance": { "gte": 20000, "lte": 30000 } } } } }}# 聚合查问GET /bank/_search{ "size": 0, "aggs": { "group_by_gender": { "terms": { "field": "gender.keyword" } } }}#嵌套聚合查问并排序GET /bank/_search{ "size": 0, "aggs": { "group_by_state": { "terms": { "field": "city.keyword", "order": { "average_balance": "desc" } }, "aggs": { "average_balance": { "avg": { "field": "balance" } } } } }}

关于elasticsearch:Docker安装ElasticSearch

1、从dockerHub拉取官网ElasticSearch镜像官网仓库：https://hub.docker.com/ docker pull elasticsearch:7.10.12、创立容器挂载目录并受权，长久化容器数据和配置创立三个目录别离挂载配置config、数据data、插件plugins mkdir -p /elasticsearch/data mkdir -p /elasticsearch/config mkdir -p /elasticsearch/plugins 授予读写执行权限 chmod -R 777 /elasticsearch3、创立docker-compose.yml文件，应用docker-compose启动容器version: '2'services: elasticsearch: container_name: elasticsearch image: elasticsearch:7.10.1 ports: - "9200:9200" volumes: - /elasticsearch/config/elasticsearch.yml:/usr/share/elasticsearch/config/elasticsearch.yml - /elasticsearch/data:/usr/share/elasticsearch/data - /elasticsearch/plugins:/usr/share/elasticsearch/plugins environment: - "ES_JAVA_OPTS=-Xms64m -Xmx128m" - "discovery.type=single-node" - "COMPOSE_PROJECT_NAME=elasticsearch-server" restart: always4、应用docker-compose在docker-compose.yml所在目录启动容器docker-compose up -d查看容器是否胜利启动 docker ps -a | grep elasticsearch 测试拜访curl http://192.168.0.50:9200/返回 { "name" : "37da3258e541", "cluster_name" : "elasticsearch", "cluster_uuid" : "pxYI8abQQA-F7wKqP6cG3w", "version" : { "number" : "7.10.1", "build_flavor" : "default", "build_type" : "docker", "build_hash" : "1c34507e66d7db1211f66f3513706fdf548736aa", "build_date" : "2020-12-05T01:00:33.671820Z", "build_snapshot" : false, "lucene_version" : "8.7.0", "minimum_wire_compatibility_version" : "6.8.0", "minimum_index_compatibility_version" : "6.0.0-beta1" }, "tagline" : "You Know, for Search"}胜利啦~~~ ...

关于elasticsearch:92-es-kafka

`//1.构架一个原生查询器NativeSearchQueryBuilder queryBuilder = new NativeSearchQueryBuilder();//2.source过滤//2.1 参数：final String[] includes, final String[] excludes//如果不想执行source过滤能够将该行正文queryBuilder.withSourceFilter(new FetchSourceFilter(strings,null));//3.查问条件queryBuilder.withQuery(QueryBuilders.matchQuery("name",name));//4.设置分页和排序规定queryBuilder .withPageable(PageRequest.of(page,5, Sort.by(Sort.Direction.ASC,"price")));//5.高亮HighlightBuilder.Field field = new HighlightBuilder.Field("name");field.preTags("<font style='color:red'>");field.postTags("</font>");queryBuilder.withHighlightFields(field);//7.查问AggregatedPage<Product> result = elasticsearchTemplate.queryForPage(queryBuilder.build(), Product.class,new EsResultMapper());List<Product> content = result.getContent();content.stream().forEach(product -> System.out.println(product));` `public class EsResultMapper implements SearchResultMapper { @Overridepublic <T> AggregatedPage<T> mapResults(SearchResponse response, Class<T> clazz, Pageable pageable) { //取得总记录数long totalHits = response.getHits().getTotalHits(); //记录列表 List<T> list = new ArrayList<>(); //获取原始的搜寻后果 SearchHits hits = response.getHits(); for (SearchHit hit : hits) { if (hits.getHits().length <= 0) { return null;} ...

关于elasticsearch:基于-Elasticsearch-的数据报表方案

文 | 闵令超网易智企高级利用开发工程师前言数据报表剖析对于企业管理者的剖析决策有着至关重要的作用，因而数据报表的灵便可用以及数据的准确性显得至关重要。本文会介绍基于 Elasticsearch 的数据指标零碎，心愿对大家有肯定的借鉴和帮忙。背景数据报表通常在业务开发中是必不可少的一部分，对于 To B 的利用更是如此。企业在应用产品的过程中必然须要对于整个的业务状况有一个精确的判断和剖析，这就须要咱们可能提供给企业尽可能多维度的具体的数据报表。初始数据报表计划在我的项目的初期，为了业务的疾速倒退，往往采取的是比较简单的架构进行解决，如下图所示。依据产品对于指标的定义，通常开发通过代码的模式间接定义指标的运算，依赖自研或者开源的定时任务调度零碎，跑出相应的指标计算结果，保留到两头表中，查问的时候依据不同的筛选条件，从不同的两头表中获取指标的计算结果。存在的问题口径不统一。在上述架构中，当不同的业务有数据穿插场景时，往往是从其余业务方复制相干指标计算的代码拿来应用，这会造成数据指标口径发生变化时，各个业务的雷同的指标呈现了指标口径不统一的问题。开发效率低。每次增加指标/批改指标都须要批改代码、增加数据库字段等多步骤，导致整个的指标开发周期特地的长。不同维度的指标的计算逻辑解决逻辑、工作不同，每次批改逻辑须要批改多个中央。基于 Elasticsearch 的数据报表计划随着业务的倒退，指标的定义越来越多，报表也变得越来越丰盛，基于定时工作架构的弊病裸露的越来越显著，开发的累赘变的越来越重，在这时候，就须要对上述架构降级，缩小业务开发的工作量。此阶段，因为数据量依然不是很大，同时为了业务不便开发和保护，能够参考数仓零碎，搭建一个繁难的数据指标零碎。思考到上述存在的问题，首先须要明确大的方向和指标。规范化数据指标的开发流程，保证数据口径的对立。提供数据指标平台，便于业务开发可能基于 SQL 开发大部分的指标，缩小指标的开发工作量，进步指标的开发效率。明确整个数据报表的生产流程，参考数仓建设计划，规范化整个数据指标的产出流程。提供无效的 SDK，不便业务方的调用。须要反对多数据源，在业务中往往不止一个数据源，可能会有 MySQL、Hive、ElasticSearch 等多个数据源，所以须要反对从多数据源会集数据的能力。须要对于指标的异样进行及时告警，不便开发排查业务异样。术语简介原子指标：原子指标是指最细粒度的指标，即不能再向下拆分的指标，例如指标 A=指标 B+指标 C，那么这里指标 B 和指标 C 即为原子指标。复合指标：复合指标是多个原子指标通过计算解决获取的后果，例如指标 A=指标 B+指标 C，这里指标 A 就是示意复合指标。维度：数据查问的角度。个别是指日期、客服组等信息。如下图中标红局部即为维度信息。工夫周期：工夫周期是用来形容一个指标的计算范畴。在统计指标的过程中必须指定用于计算的工夫周期字段，通常，原子指标的计算的最小工夫周期为小时，天数据基于小时数据做聚合得出。报表：报表是一系列复合指标/原子指标的汇合，通常业务方获取的指标数据都是一张报表。业务域：一个我的项目往往会有多条业务线，每条业务线咱们能够了解为一个业务域，以七鱼为例，如在线会话、呼叫等，任何的原子指标、复合指标、报表都属于某一个业务域。架构基于上述指标，这里以 Elasticsearch 的聚合查问能力为依靠，搭建如下的数据指标平台架构。整体分为5大部分：原始数据层：次要是关系型数据库中的表数据明细层：次要是通过 binlog 同步到 Elasticsearch 中保留。业务层：次要包含两大部分，指标计算和项目管理。指标计算次要是基于明细层数据以及业务开发和产品定义的指标口径，产出相应维度的指标。项目管理次要是维度、指标、业务域相干配置等。网关：提供对立的 SDK 便于业务方的间接调用。业务方/控制台，业务方调用sdk获取报表数据以及维度、指标等控制台的配置。从整个架构体系来看，上述架构次要是对立了各个业务的原始层和明细层数据，并基于此开发了数据指标配置零碎，可能疾速的响应业务需要，将数据指标的开发周期大大缩短，也防止了开发人员间接在代码外面编写指标计算代码，带来口径不对立或者反复建设的问题。原始数据层/明细层从上图中能够看到，最底层局部是原始数据层和明细层，这个是整个架构的根底所在。从原始层到明细层同步采纳 binlog+ 自定义音讯的同步形式，具体架构如下：同步数据次要有三种模式： binlog 模式。通过 binlog 模式，同步数据库中相应表中的数据，依据指定的关联表的惟一键，能够将多张表的数据同步到一张大宽表中，不便指标的运算。binlog 同步能够依附开源的 Canal、Maxwell 等组件，也能够是自研组件等。全量同步模式。当 binlog 同步呈现数据失落，或者须要历史数据同步时，采纳全量同步的模式进行数据的补全和修改。全量同步次要依赖业务的定时任务调度零碎。自定义 topic。当数据统计须要增加自定义字段而又不想在数据库中增加相应字段时，能够通过自定义 topic 将想要增加的字段增加到对应的大宽表中。明细层数据的存储在 es 中，通过明细层能够实现业务到数据的转换，保留维度信息以及最细粒度的数据。聚合层可基于明细层进行简单的指标计算。 ...

关于elasticsearch:Elasticsearch安装IK分词器联网离线

1、在线联网装置间接进入容器外部进行编辑 # 进入容器外部编辑,或者在Elasticsearch下的bin目录下执行elasticsearch-plugindocker exec -it elasticsearch bash# 装置IK分词器插件(Github官网)elasticsearch-plugin install https://github.com/medcl/elasticsearch-analysis-ik/releases/download/v6.7.0/elasticsearch-analysis-ik-6.7.0.zip# 或者减速下载（第三方减速）elasticsearch-plugin install https://github.91chifun.workers.dev//https://github.com/medcl/elasticsearch-analysis-ik/releases/download/v6.7.0/elasticsearch-analysis-ik-6.7.0.zip 期待下载实现而后cd，而后查看是否有ik分词器 cd plugins/ls 如果有ik分词器则装置实现，而后重新启动es而后拜访 2、离线装置首先下载，而后解压，如果不是容器形式装置间接解压plugins目录即可 # 下载wget https://github.com/medcl/elasticsearch-analysis-ik/releases/download/v6.7.0/elasticsearch-analysis-ik-6.7.0.zip# 减速wget https://github.91chifun.workers.dev//https://github.com/medcl/elasticsearch-analysis-ik/releases/download/v6.7.0/elasticsearch-analysis-ik-6.7.0.zip# 解压mkdir ./ikunzip elasticsearch-analysis-ik-6.7.0.zip -d ./ik/# 复制到容器内docker cp ik elasticsearch:/usr/share/elasticsearch/plugins/# 重启es节点docker restart elasticsearch3、测试咱们应用kibanna或者发送申请 # 最大分词（将词以细粒度分词，搜寻分词数量多，准确）GET _analyze{ "analyzer":"ik_max_word", "text":"我是中国人"}# 短语分词（将词拆分短语，分词数少）GET _analyze{ "analyzer":"ik_smart", "text":"我是中国人"} 如果返回如下的信息示意装置胜利 { "tokens" : [ { "token" : "我", "start_offset" : 0, "end_offset" : 1, "type" : "CN_CHAR", "position" : 0 }, { "token" : "是", "start_offset" : 1, "end_offset" : 2, "type" : "CN_CHAR", "position" : 1 }, { "token" : "中国人", "start_offset" : 2, "end_offset" : 5, "type" : "CN_WORD", "position" : 2 }, { "token" : "中国", "start_offset" : 2, "end_offset" : 4, "type" : "CN_WORD", "position" : 3 }, { "token" : "国人", "start_offset" : 3, "end_offset" : 5, "type" : "CN_WORD", "position" : 4 } ]}

关于elasticsearch:观察系统中的LoggingMetrics和Tracing

前言在上一篇文章察看零碎解决了什么它又须要什么我讲述了察看零碎的必要性以及察看零碎须要什么数据.然而以什么样的眼光对待传递给察看零碎的数据是含糊的,而事实上对待数据的眼光或者格局会作为顶层设计间接影响整个察看零碎的最初的性能体现和技术水平的高下. 很多公司喜爱把一些对分布式的察看零碎叫做日志解决零碎,告警零碎,监控零碎等,诚实讲都是全面的或者没有真正的了解察看零碎和监控零碎字面用词区别下的实质理念区别.一个优良的察看零碎不单是日志解决,监控,告警这些单维的性能组件.它是基于日志数据,指标数据等根底数据并联合链路追踪技术做数据综合解决后造成的齐备的无缝的察看平台. Logging,Metrics和Tracing的概念OpenTelemetry根本定义了一个好的察看零碎最初要做到的状态:终态就是实现Metrics、Tracing、Logging的交融,作为CNCF可察看性的终极解决方案. OpenTelemetry is a collection of tools, APIs, and SDKs. You use it to instrument, generate, collect, and export telemetry data (metrics, logs, and traces) for analysis in order to understand your software's performance and behavior.Tracing: 提供了一个申请从接管到处理完毕整个生命周期的跟踪门路，通常申请都是在分布式的零碎中解决，所以也叫做分布式链路追踪。Metrics: 提供量化的零碎内/内部各个维度的指标，个别包含Counter、Gauge、Histogram等。Logging: 提供零碎/过程最精细化的信息，例如某个要害变量、事件、拜访记录等。这三者在可察看性上缺一不可,基于Metrics的告警发现异常，通过Tracing定位问题(可疑)模块，依据模块具体的Logging定位到谬误本源，最初再基于这次问题考察教训调整Metrics(减少或者调整报警阈值等)以便下次能够更早发现/预防此类问题. 实现Metrics、Tracing、Logging交融的要害是可能拿到这三者之间的关联关系.这篇文章(Metrics, tracing, and logging)具体的形容了三者的定义. 上面我对这篇文章做简短的解释不便大家疾速了解,当然要全面的主观的理解还是要看原文. 首先咱们Metrics、Tracing、Logging能够用上面的韦恩图示意 Metrics中文能够叫度量或者指标,首先它的典型特色就是可聚合(aggregatable).什么是可聚合的呢,简略讲可聚合就是一种根本单位能够在一种维度区间上做数学计算(累加,均匀,).举个例子QPS就是一种Metrics,它的根本单位query是可聚合的,它的维度区间就是工夫区间,区间长度为1s,所以QPS通过聚合得出了每秒零碎被申请的次数.相似的Metrics有单个网络query的均匀拜访提早,MySQL的CPU资源使用率等. I think that the defining characteristic of metrics is that they are aggregatable: they are the atoms that compose into a single logical gauge, counter, or histogram over a span of time.Logging的典型特色就是它和孤立的事件(Event)强关联,是因为一个事件的产生所以导致了一条日志的产生.举个例子就是一个网络query是一个事件,它被云端接到后Nginx产生了一个拜访log. 大量的不同的内部事件间基本上是离散的,比方多个用户拜访云端业务时产生的5个事件间没有必然关系,所以在一个服务节点的角度上看这些事件产生的日志间也是离散的 ...

关于elasticsearch:观察系统解决了什么它又需要什么

为什么要有监控零碎在我从业4年多的历程中,大部分工夫是没有接触监控零碎的或者没有发现监控零碎的重要性.这很失常,因为IT界的演变实质上是从简略到简单从单节点到集群,从裸金属到齐全托管云服务的过程. 我工作过程中接触到的技术演变大抵也是就如上,也大抵经验了这几个阶段. 第一阶段: Java SSM单体利用+dubbo rpc 手动在单体利用所在的服务器上一一手动shell检索数据没有对单体利用的节点衰弱,性能,压力监控没有链路追踪这是最根底的服务,勉强有了微服务的概念实质上还是单体,没有任何的察看零碎概念.然而这个在当年还是够用的,因为单体利用这时数量无限,即便扩散到各个服务器然而手动查问还是勉强应酬. 第二阶段: Java Spring Cloud微服务,部署到裸金属上手动在单体利用所在的服务器上一一手动shell检索日志数据自带简略的单体利用的节点健康检查和容错自带简略的链路追踪这时有了根本的服务拆分和微服务的雏形了,然而还没有做到服务节点的动静伸缩. 这时节点的数量比拟多了,手动检索日志信息开始有点费劲,产生了一些察看零碎的需要和必要性. 第三阶段: Java Spring Cloud微服务,应用K8S编排日志数据依照节点的类型做了集中的存储,存储在ES中,在Kibana检索集中起来的数据,不用到每个容器中检索了自带高级的单体利用的节点健康检查和容错自带高级的链路追踪除了日志的检索降级了,其余的性能比方状态主动感知齐全没有这时有了动静伸缩了,手动检索节点的日志数据变得不可能,然而察看零碎没有成形.只好通过ELK技术集中存储日志而后搜寻,察看零碎变成了十分重要的平台需要第四阶段: 齐全上云,应用Serverless+K8S容器话.并且语言不再是java一种而是变成了Java/Python/Node/Go 根本没有了节点的概念,无奈晓得确切的服务节点拓扑和数量,ELK的简略应用只能解决分布式日志源头聚合和检索的问题在这个时候,察看零碎曾经变成了刚需,没有好的察看零碎团队很难直观的晓得当下的服务压力和资源消耗详细情况,这样就会重大当初团队的开发能力和故障反馈能力. 总结在容器化,云原生,serverles等新技术的大量应用事实下,以往的手动/半手动日志检索曾经齐全不能持续产生任何价值.它给整个开发团队提出了如下挑战不单是是日志的检索.新的技术的应用也对当初的后端服务提出了一些新的要求,比方性能监控,故障主动感知,链路追踪,高压力下的主动弹性解决等等. 在这个场景下,一个好的察看零碎必须做到这些根本的性能,不单是日志收集和检索它出现给咱们那些方面的信息首先是零碎多维的状态信息: 各种类型的日志数据.做到分布式收集->集中存储->数据索引->灵便检索服务的指标数据服务压力感知和指标数据服务衰弱度监控各服务间相互协作和调用时的性能状况APM数据随工夫线倒退而产生的外界压力曲线以及这些工夫点上对应的平台的性能体现用户的应用爱好和周期性法则服务uptime Serverless服务的生产时长,单个申请的服务耗时容器的全生命周期中服务时长裸金属服务器的启停工夫其中ELK技术栈大抵能解决大部分的问题不过链路追踪和更丰盛的可视化展示.ELK做的不是100%的完满,它须要在跨语言跨技术体系的日志设计这个顶层的设计上联合最合适的组件实现链路追踪.同时数据的可视化上Kibana有时略显繁多. 业界个别应用ELK+Grafana+Prometheus+云服务商的监控(比方AWS CloudWatch)实现更加平面的日志/指标收集->数据存储->数据的剖析(解析,提取,索引..)->数据的高级感知(服务链路流程感知,主动告警,主动扩缩容,主动压力调配,主动的资源事后筹备)->数据的展示(图形化展现,数据检索,趋势剖析) 它怎么展示在数据可视化上,个别咱们喜爱叫它'大屏',对于展现的技术个别这个没有规范,业界比拟风行的是Kibana或者Grafana,以Grafana绝对更加业余一些. 它须要那些数据次要是如下的根底数据: 日志数据,文本类型或者流式传输都可,不限于日志的传输模式,然而日志是要有格局或者能被预格式化的,这样不便自动化/人工的解读.单条日志是单个事件,代表某个工夫点某个服务做了什么,是点信息服务资源指标,这方面的数据有大量是有具体格局并做了记录的的,比方MySQL慢查问日志,然而大部分是实时的非记录的,比方服务器的CPU资源占用默认就没有日志记录,这也是点信息.服务器,服务节点等的心跳信息,用于确定工夫点的衰弱,这也是点信息.服务链路中的traceId,如果没有traceId或者相似的追踪定位点,那么一个网络申请过去通过了那些点是没法做工夫前后程序的链路连贯的,也就是点无奈连成线.这是针对某个流程,观测其演变过程,前因后果咱们成为线信息.上述的根底信息从产生数据的源进行获取,比方MySQL,Serverless实例,容器化节点,云厂商专有服务(SNS,SQS...) 在某个工夫窗口,观测某些指标的法则,以及指标与指标之间的分割咱们叫做面信息.基于上述的根底数据,剖析服务间的协同情况,将下面的线连成面才有可能能力造成服务间关联关系的感知. 对于整个平台全副服务的点->线->面的全局多维度感知和主动解决是一个好的察看零碎的实质诉求,同时记录面随工夫线的数据,聚合为更加欠缺的平面察看平台是这个零碎的现实状态. 实现察看零碎的技术层次模型本文原文链接: 察看零碎解决了什么它又须要什么

关于elasticsearch:快速理解ELK

ELK是什么ELK次要是代指Elastic Stack,它是elastic技术生态栈中的3个次要组件的缩写.这3个组件是: elasticsearch,logstash,kibana. 前面随着技术的欠缺又退出了beats.其中最为大家熟知的就是filebeats. filebeats不是beats外面的惟一组件,beats是一个大的家族,更多的beats组件请看: beats 多年的倒退后,Elastic Stack曾经从最后的elasticsearch倒退为一个欠缺的由多个组件独特合作的欠缺的生态. 它次要用于如下几个场景: 搜寻一些在线购物网站基于elasticsearch做为商品搜寻.比方京东,腾讯和阿里有宽泛的应用通用网页搜索引擎,比方duckduckgo社交网站,博客网站的垂直搜寻日志检索云端日志的检索,不便开发人员定位问题,以往须要在Linux上手动查看日志当初能够间接在kibana上疾速收集服务群的日志零碎状态信息的收集,检索,可视化展现. 大量用于云端服务群的状态感知上服务集群的指标信息可视化展现服务日志的检索业务经营信息的可视化服务集群的状态感知和异样状态捕捉,告警大数据分析ELK间的关系是什么简略的讲是高低关系: elasticsearch是外围负责数据的存储,对数据做索引并提供检索服务logstash是原始数据的传输通道,提供一些高级的性能,比方对原始数据做一些解决将无格局的数据转化为某种格局的数据后提供给elasticsearchbeats是数据的采集代理,个别装置在被采集的服务器上,抓取指标服务器的各项数据传输给logstash原始数据其实能够间接发送到elasticsearch,这是最原始的形式,这种形式的话对elasticsearch的压力会大一些,比方数据量周期性稳定会导致承载elasticsearch的服务器周期性的面临压力. 为了解决下面的问题,logstash呈现了,它相当于elasticsearch的小秘书,将本来要发送到elasticsearch的数据先简略整顿演绎一遍而后再发送到elasticsearch中,这样省去了elasticsearch承受原始数据的压力,让elasticsearch专一于数据的解决和保留 logstash的性能比拟全面并且资源消耗略大,如果只是须要采集指标的数据并不需要做过多的数据处理,那么咱们只须要一个轻量的采集器即可,这时就呈现了go语言写的beats,你能够认为beats就是快递员,它将各个零散指标上的数据一直的快递到秘书logstash这里. 这样就不用再每个指标上装置logstash了有些公司也会在快递员beats和秘书logstash间建一个相似于快递柜性能的缓存销峰零碎. 比方在beats和logstash间应用kafka来做传输的管道,这样就能够在日志数据霎时变大的时候挡住这个霎时的峰值,让logstash和elasticsearch始终以绝对平滑的资源占用稳固的运行. 在Elastic Stack中elasticsearch处于外围位置,其余的局部其实是可选的.elasticsearch通过RESTFul API和SDK裸露本人的交互接口,外围的服务能发送本人的数据到elasticsearch中就行. 上面的图片清晰的展现的下面我讲的关系本文原创链接: 疾速了解ELK

关于elasticsearch:eLasticSearch集群docker环境下利用dockerpose搭建es集群

1.配置dockercompose配置文件version: '2'services: elasticsearch: image: es/elasticsearch:7.7 container_name: es1 restart: always dns_search: . environment: - bootstrap.memory_lock=true - "ES_JAVA_OPTS=-Xms256m -Xmx256m" ulimits: memlock: soft: -1 hard: -1 volumes:# data索引数据存储门路，logs日志输入，config配置 - /etc/timezone:/etc/timezone - /etc/localtime:/etc/localtime - ./es/data:/usr/share/elasticsearch/data - ./es/logs:/usr/share/elasticsearch/logs - ./elasticsearch/config:/usr/share/elasticsearch/config ports: - 9200:9200 - 9300:9300 external_links: - es2 #同一机器下容器名称（为避免同一机器下docker容器之间不能通过ip进行互通） - es3 tty: truenetworks: default: external: name: esnetwork #同一机器下，所有节点须要在同一网络下2.eLasticSearch配置文件批改cluster.name: es-clusternode.name: es-node1network.bind_host: 0.0.0.0network.publish_host: 本机ip地址http.port: 9200transport.tcp.port: 9300http.cors.enabled: truehttp.cors.allow-origin: "*"##一下五行为配置X-pack平安xpack.security.enabled: truexpack.security.transport.ssl.enabled: truexpack.security.transport.ssl.verification_mode: certificate ##指定证书门路xpack.security.transport.ssl.keystore.path: elastic-certificates.p12xpack.security.transport.ssl.truststore.path: elastic-certificates.p12##是否参加master节点选举node.master: true ##是否存储数据node.data: true#discovery.seed_hosts: ["elasticsearch2:10293","elasticsearch1:10193"]#cluster.initial_master_nodes: ["es-node0","es-node1","es-node2"]## 指定该集群下所有节点及端口（同一机器下能够用容器名称代替机器ip(前提是须要在dockerCompose配置中增加该节点的容器名)）discovery.seed_hosts: ["141.3.186.01:9301","es2:9302","es3:9303"]##参加master节点选举的节点名称汇合cluster.initial_master_nodes: ["es-node1","es-node2","es-node3"]3.其余节点可按照此配置对立配置，需注意：集群名称需统一，容器名称、节点名称、ip地址、端口号等不同。配置实现后对立启动 docker-compose启动命令: ...

关于elasticsearch:ESElasticdump数据备份与数据转移索引还原

1.对于elasticdump？elasticdump原理 elasticdump是实现不同ElasticSearch集群之间索引迁徙的工具。默认状况下，ITOA集群部署胜利后，该工具存在于装置节点（客户端节点）上。不同ElasticSearch集群之间要实现索引数据的转移，须要应用到elasticdump工具。要实现ElasticSearch的数据迁徙，除了要实现索引中文档对象的迁徙外，还须要迁徙索引中映射模式的迁徙。对于某一个索引的映射信息能够通过ElasticSearch中的_plugin/head插件在web界面通过信息中的索引信息来查阅。如图1所示 2.elasticdump应用形式通过npm装置elasticdump #本地装置和全局装置的区别在于它是否主动给你设置环境变量，其余的没有区别# 本地装置$ npm install elasticdump$ ./bin/elasticdump# 全局装置$ npm install elasticdump -g$ elasticdump操作示例：导出 #格局：elasticdump --input {protocol}://{host}:{port}/{index} --output ./test_index.json#例子：将ES中的test_index 中的索引导出#导出以后索引的mapping构造$ elasticdump --input http://192.168.56.104:9200/test_index --output ./test_index_mapping.json --type=mapping#导出以后索引下的所有实在数据$ elasticdump --input http://192.168.56.104:9200/test_index --output ./test_index.json --type=data操作示例：导入 # 创立索引$ curl -XPUT http:192.168.56.104:9200/test_index#因为导入的是mapping，所以设置type为mapping$ elasticdump --input ./test_index_mapping.json --output http://192.168.56.105:9200/ --type=mapping#因为导入的是data（实在数据）所以设置type为data$ elasticdump --input ./test_index.json --output http://192.168.56.105:9200/ --type=data通过docker镜像应用elasticdump # 镜像下载$ docker pull taskrabbit/elasticsearch-dump# 上面还是例子：通过镜像导出数据到本地# 创立一个文件夹用于保留导出数据$ mkdir -p /root/data# 上面须要对门路进行映射并执行命令（导出mapping）$ docker run --rm -ti -v /data:/tmp taskrabbit/elasticsearch-dump \ --input=http://production.es.com:9200/my_index \ --output=/tmp/my_index_mapping.json \ --type=mapping# 导出（data）$ docker run --rm -ti -v /root/data:/tmp taskrabbit/elasticsearch-dump \ --input=http://192.168.56.104:9200/test_index \ --output=/tmp/elasticdump_export.json \ --type=data -----------------------------------------------------------------------------# 以下内容为ES -> ES的数据迁徙例子$ docker run --rm -ti taskrabbit/elasticsearch-dump \ --input=http://production.es.com:9200/my_index \ --output=http://staging.es.com:9200/my_index \ --type=mapping$ docker run --rm -ti taskrabbit/elasticsearch-dump \ --input=http://production.es.com:9200/my_index \ --output=http://staging.es.com:9200/my_index \ --type=data3.如果须要操作的es集群配置了xpack平安认证在对应的http前面，增加user:password@ ...

关于SegmentFault:ESes761开通安全防护认证流程

1.啥是X-Pack？X-Pack是Elastic Stack扩大性能，提供安全性，警报，监督，报告，机器学习和许多其余性能。 ES7.0+之后，默认状况下，当装置Elasticsearch时，会装置X-Pack，无需独自再装置。 1、5.X版本之前：没有x-pack，是独立的：security平安,watch查看，alert正告等独立单元。2、5.X版本：对本来的平安，正告，监督，图形和报告做了一个封装，造成了x-pack。3、6.3 版本之前：须要额定装置。4、6.3版本及之后：曾经集成在一起公布，无需额定装置，根底平安属于付费黄金版内容。 7 .1版本：根底平安收费。自6.8以及7.1+版本之后，根底级平安永恒收费。根底版本平安性能列表如下： 2.ES配置2.1集群化配置（docker环境）1.进入ES docker容器，生成节点证书借助elasticsearch-certutil命令生成证书（在elasticsearch目录下执行/usr/share/elasticsearch） /usr/share/elasticsearch/bin/elasticsearch-certutil.bat ca -out config/elastic-certificates.p12 -pass ""//-out 指定证书生成门路，-pass 默认无明码注：只须要应用由同一CA签名的证书，即可主动容许该节点退出集群 2.配置加密通信启用平安性能后，必须应用TLS来确保节点之间的通信已加密。在elasticsearch.yml核心新增配置如下： xpack.security.transport.ssl.enabled: truexpack.security.transport.ssl.verification_mode: certificate xpack.security.transport.ssl.keystore.path: elastic-certificates.p12 xpack.security.transport.ssl.truststore.path: elastic-certificates.p12 具体配置如下： cluster.name: es-dockernode.name: es-nodenamenetwork.bind_host: 0.0.0.0network.publish_host: ***.***.***.*** ##本机ip地址http.port: 9200 ## 凋谢端口transport.tcp.port: 9300 ##凋谢tcp端口http.cors.enabled: truehttp.cors.allow-origin: "*"xpack.security.enabled: truexpack.security.transport.ssl.enabled: truexpack.security.transport.ssl.verification_mode: certificate xpack.security.transport.ssl.keystore.path: elastic-certificates.p12xpack.security.transport.ssl.truststore.path: elastic-certificates.p12node.master: true node.data: truediscovery.seed_hosts: ["***.***.***.***:9300","elasticsearch2:10293","elasticsearch1:10193"]cluster.initial_master_nodes: ["es-nodename1","es-nodename2","es-nodename3"]留神：1.最好将证书与配置文件放在同一目录下 2.生成的这书最好手动赋一下权 chmod 644 *.ca 3.设置集群明码ES中内置了几个治理其余集成组件的账号即：apm_system, beats_system, elastic, kibana, logstash_system, remote_monitoring_user，应用之前，首先须要增加一下明码： /bin/elasticsearch-setup-passwords interactiveinteractive：给用户一一设置明码。auto：主动生成明码。留神：必须配置好xpack之后，能力设置明码。否则会报错。如果这个中央报如下谬误： Failed to determine the health of the cluster running at http://192.168.3.42:9200Unexpected response code [503] from calling GET http://192.168.3.42:9200/_cluster/health?prettyCause: master_not_discovered_exceptionIt is recommended that you resolve the issues with your cluster before running elasticsearch-setup-passwords.It is very likely that the password changes will fail when run against an unhealthy cluster.Do you want to continue with the password setup process [y/N]y可能是有脏数据导致，此时能够停掉es，删除 data 数据目录，而后重新启动在进行操作。 ...

关于elasticsearch:ElasticSearch-的标准分词器和关键词分词器

规范分词器如果没有指定分词器，将应用规范分词器 standard 作为默认的分词器。 POST _analyze{ "analyzer": "standard", "text": "The 2 QUICK Brown-Foxes jumped over the lazy dog's bone."}[ the, 2, quick, brown, foxes, jumped, over, the, lazy, dog's, bone ]规范分词器配置 max_token_length：最大标记长度。如果标记超过此长度，将以此长度作为距离，默认255。stopwords：一个预约义的进行词（如 _english_）或一个蕴含进行词的数组。默认 _none_。stopwords_path：进行词的文件门路。配置应用示例 PUT my-index-000001{ "settings": { "analysis": { "analyzer": { "my_english_analyzer": { "type": "standard", "max_token_length": 5, "stopwords": "_english_" } } } }}POST my-index-000001/_analyze{ "analyzer": "my_english_analyzer", "text": "The 2 QUICK Brown-Foxes jumped over the lazy dog's bone."}[ 2, quick, brown, foxes, jumpe, d, over, lazy, dog's, bone ]关键词分词器keyword 分词器是一个“空转”分词器，也就是说会将输出的字符串作为单个标记原样返回。 ...

关于芯片:Elasticsearch-操作

1.创立索引创立一个名为 products 的索引，用来存储商品数据。分片和正本参数阐明： number_of_shards：分片数量，默认值是 5number_of_replicas：正本数量，默认值是 1咱们有三个节点，在每个节点上都创立一个分片。每个分片在另两个节点上各创立一个正本。 # 创立索引，命名为 productsPUT /products{ "settings": { "number_of_shards": 3, "number_of_replicas": 2 }}2.创立映射在 products 索引中创立映射。 # 定义mapping，数据结构PUT /products/_mapping{ "properties": { "id": { "type": "long" }, "title": { "type": "text" }, "category": { "type": "text" }, "price": { "type": "float" }, "city": { "type": "text" }, "barcode": { "type": "keyword" } }}查看映射GET /products/_mapping映射（数据结构）相似于数据库表构造，索引数据也被分为多个数据字段，并且须要设置数据类型和其余属性。映射，是对索引中字段构造的定义和形容。罕用类型：数字类型： byte、short、integer、longfloat、doubleunsigned_long字符串类型： text ：会进行分词keyword ：不会进行分词，实用于email、主机地址、邮编等日期和工夫类型： date3.增加文档增加的文档会有一个名为_id的文档id，这个文档id能够主动生成，也能够手动指定，通常能够应用数据的id作为文档id。 # 增加文档PUT /products/_doc/10033{ "id":"10033", "title":"新一代PLAY:5无线智能音响系统", "category":"潮酷数码会场", "price":"3980.01", "city":"上海", "barcode":"527848718459"}PUT /products/_doc/10034{ "id":"10034", "title":" 高清电视盒子wifi 64位硬盘播放器", "category":"潮酷数码会场", "price":"398.00", "city":"浙江杭州", "barcode":"522994634119"}PUT /products/_doc/10035{ "id":"10035", "title":" 重低音入耳式防脱降噪音乐耳机", "category":"潮酷数码会场", "price":"860.00", "city":"浙江杭州", "barcode":"526558749068"}PUT /products/_doc/10036{ "id":"10036", "title":"2.0无线蓝牙录音师头戴式耳机", "category":"潮酷数码会场", "price":"2889.00", "city":"上海", "barcode":"37147009748"}PUT /products/_doc/10037{ "id":"10037", "title":"美国原创WiFi连贯家庭桌面音箱", "category":"潮酷数码会场", "price":"1580.01", "city":"上海", "barcode":"527783392239"}也能够主动生成 _id 值： ...

关于elasticsearch:Elasticsearch集群运维常用API二

一、Snapshot1、从已备份的快照中复原indices POST _snapshot/oss_bucket_name/snapshot_name/_restore?wait_for_completion=false{ "indices":"indices_name", "ignore_unavailable":"true", "index_settings": { "index.number_of_replicas": 0, "index.routing.allocation.total_shards_per_node":"10" }, "include_global_state":false}

关于elasticsearch:ElasticSearchhead-安装使用

装置 head 可视化工具elasticsearch-head 是一款用于 elasticsearch 的客户端工具。装置前须要先装置 node.js 和 npm。我的项目地址：https://github.com/mobz/elast... git clone git://github.com/mobz/elasticsearch-head.gitcd elasticsearch-headcnpm installnpm run start装置胜利后拜访 http://localhost:9100/ 即可查看到 ES 的相干信息。集群衰弱值的状态绿色，最衰弱的状态，代表所有的分片包含备份都可用；黄色，根本的分片可用，然而备份不可用（也可能是没有备份）；红色，局部的分片可用，表明分片有一部分损坏。此时执行查问局部数据仍能够查到；灰色，未连贯到elasticsearch服务。 head 的次要性能查看集群状态查看索引信息创立索引开关索引查看索引、类型、字段、数据信息执行根本查问执行复合查问（增删改等）

关于elasticsearch:ElasticSearch-安装使用

下载安装ES 基于 Java 开发，须要 JDK >= 1.8。下载地址：https://mirrors.huaweicloud.c... 下载后解压即可应用。目录构造bin 启动文件目录config 配置文件目录 log4j2.properties 日志配置文件 jvm.options 虚拟机配置文件 elasticsearch.yml ES配置文件，默认端口9200lib 相干jar包目录logs 日志目录modules 功能模块目录plugins 插件目录配置跨域拜访vim config/elasticsearch.ymlhttp.cors.enabled: truehttp.cors.allow-origin: "*"启动运行 bin/elasticsearch.bat，浏览器拜访 http://127.0.0.1:9200/ 即可看到 ES 的信息页面。

关于elasticsearch:ElasticSearch-简介

什么是索引将非结构化数据中的一部分信息提取进去，从新组织，使其变得有肯定构造，而后对此有肯定构造的数据进行搜寻，从而达到搜寻绝对较快的目标。这部分从非结构化数据中提取出的而后从新组织的信息，称之索引。什么是全文检索（Full-text Search）先建设索引，再对索引进行搜寻的过程就叫全文检索（Full-text Search）。什么是LuceneLucene 是 apache 下的一个开源的全文检索引擎工具包（它提供了许多的jar包，即实现全文检索的类库）。它提供了残缺的查问引擎和索引引擎，局部文本剖析引擎。Lucene的目标是为软件开发人员提供一个简略易用的工具包，以不便地在指标零碎中实现全文检索的性能。 Lucene 与搜索引擎的区别搜索引擎是对外提供全文检索服务的，是能够独自运行的。 Lucene 只是一个工具包，不能独自运行，须要在我的项目中退出 Lucene 的jar包，将最终的我的项目在JVM中运行。什么是ElasticSearchElasticSearch 是在 Apache Lucene 的根底上开发而成，对 Lucene 进行了封装和加强，是一个分布式的开源搜寻和剖析引擎，实用于所有类型的数据，包含文本、数字、天文空间、结构化和非结构化数据。。 ElasticSearch vs SolrSolr 装置绝对简单。ES 开箱即用，非常简略笨重。Solr 应用 Zookeeper 进行分布式治理。ES 自带分布式协调治理性能。Solr 反对多种格局的数据，如 JSON XML CSV。ES 只反对 JSON 格局。Solr 官网提供的性能更加丰盛。ES 更专一于外围性能，高级性能通过第三方插件提供。Solr 查问速度快，但更新索引速度慢。ES 建设索引速度快，实时性查问速度快。Solr 社区更成熟沉闷。ES 开发维护者较少，更新迭代快，学习应用老本高。

关于elasticsearch:利用iptables实现简单的ES-http端口访问限制

一、梳理容许拜访的IP地址1、ES客户端IP地址 192.168.32.120192.168.32.1212、集群中节点的IP地址 192.168.32.122192.168.32.123192.168.32.124二、登录ES主机(ubantu为例)，执行以下命令 # 创立iptables策略保留门路mkdir -p /etc/iptables/iptables.rule# 禁止所有IP拜访本机9200端口iptables -I INPUT -p tcp –dport 9200 -j REJECT# 容许集群内主机IP拜访本机9200端口iptables -I INPUT -s 192.168.32.123　-p tcp –dport 9200 -j ACCEPTiptables -I INPUT -s 192.168.32.124　-p tcp –dport 9200 -j ACCEPT# 容许ES客户端IP地址拜访本机9200端口iptables -I INPUT -s 192.168.32.120　-p tcp –dport 9200 -j ACCEPTiptables -I INPUT -s 192.168.32.121　-p tcp –dport 9200 -j ACCEPT# 查看已增加的iptables规定iptables -L -n --line-numbers# 删除已增加的某条iptables规定iptables -D INPUT 1#保留已增加的iptables规定到本地文件门路iptables-save > /etc/iptables/iptables.rule#从已保留的文件中复原iptables规定iptables-restore < /etc/iptables/iptables.rules#配置开机后主动执行加载iptables策略文件/etc/rc.d/rc.local

关于elasticsearch:Elasticsearch-集群的正确关机方式qbit

引子本文对 Elasticsearch 7.10 实用正确关机是为了避免数据失落或集群凌乱步骤1、长期禁用 shard 调配（重启后主动生效） PUT _cluster/settings{ "transient": { "cluster.routing.allocation.enable": "none" }}2、将所有数据落盘 POST _flush3、关机本文出自 qbit snap

关于elasticsearch:Elasticsearch中mapping全解实战

https://gobea.cn/blog/detail/Y5EyjK5e.html

关于elasticsearch:Elasticsearch-710-集群重启恢复慢qbit

背景简介本文针对集群重启分片长期调配不进来的问题（CLUSTER_RECOVERED）本文 ES 版本为 7.10.1本文集群有 3 个主节点，3 个协调节点，20 个数据节点解决方案官网文档： https://www.elastic.co/guide/...在每个 master 节点的 elasticsearch.yml 中减少或批改集群配置# 有 20 个节点退出集群就开始复原分片"gateway.expected_data_nodes": 20,# 如果期待 5 分钟后退出的节点还没有达到 20 个"gateway.recover_after_time": "5m"# 那么有 15 个节点退出集群就能够开始复原分片"gateway.recover_after_data_nodes": 15本文出自 qbit snap

关于elasticsearch:这篇实战攻略带你轻松入门Elasticsearch

内容概述什么是Elasticsearch，为什么要应用它？根底概念简介节点(node)索引(index)类型映射(mapping)文档(doc)本地环境搭建，创立第一个index罕用RESTful Api示例新增文档查问文档-不分词类型查问文档-分词类型内容概述本文内容次要集中在应用层，通过上面几个局部介绍以后最风行的搜寻工具：Elasticsearch，理解这些内容后，能够疾速开始应用它。什么是Elasticsearch，为什么要应用它？根底概念：节点，索引，类型映射和文档本地环境搭建，创立第一个index罕用RESTful Api示例什么是Elasticsearch，为什么要应用它？Elasticsearch 是一个分布式、RESTful 格调的搜寻和数据分析引擎。它基于Lunece实现，应用java语言编写。Lunece是一个优良的搜索引擎库，但它应用起来非常复杂。 Elasticsearch通过对 Lunece的封装，暗藏了复杂性，提供了应用简略的RESTful Api。同时也实现了分布式集群个性，具备存储数据大，查问性能好，扩大不便等特点。为什么要应用它在业务开发中，基于ES的个性，通常有上面这些场景须要应用它：存储大量数据。通过在应用mysql存储的时候，数据的单位是G。应用ES的时候，数据的单位是T。由此能够看出ES应用于大数据量的存储场景，基于分布式个性，它也反对备份和容灾，并且能够很容易程度扩大容量。分词搜索引擎。ES具备弱小的分词能力，能够反对高性能的实时搜寻。高效数据分析。ES提供的聚合剖析性能，可实现对保留的大量数据的近实时统计分析。根底概念简介要应用ES，须要理解几个最根本的概念，节点(node)，索引(index)，类型映射(mapping)和文档(doc)。节点(node)节点是组成ES集群的根本单位，每个节点是一个运行的ES实例。每个物理机器上能够有多个节点，应用不同的端口和节点名称。节点按次要性能能够分为三种：主节点(Master Node)，协调节点(Coordianting Node)和数据节点(Data Node)。上面简略介绍下：主节点：解决创立，删除索引等申请，保护集群状态信息。能够设置一个节点不承当主节点角色协调节点：负责解决申请。默认状况下，每个节点都能够是协调节点。数据节点：用来保留数据。能够设置一个节点不承当数据节点角色索引(index)索引是ES中的逻辑概念，是文档的容器。对ES的操作，根本都是对索引操作，一个ES集群中，能够创立多个索引。索引定义了一组文档的数据模型和解决办法。每个索引能够有多个主分片和正本分片，别离保留在不同的节点。主分片的作用是对索引的扩容，使一个索引的容量能够冲破单机的限度。正本分片是对数据的爱护，每个主分片对应一个或多个正本分片，当主分片所在节点宕机时，正本分片会被晋升为对应的主分片应用。一个主分片和它的正本分片，不会调配到同一个节点上。一个索引的分片数在创立时指定，如果要批改须要重建索引，代价很高。类型映射(mapping)mapping定义了一个索引中，文档保留的每个字段的数据类型。依据数据类型的不同，在增加文档时对每个字段的解决也不同。例如，对text类型的字段，会先应用分词器分词，生成倒排索引，用于之后的搜寻。对keyword类型的字段，不会分词，搜寻时只能准确查找。一个简略的mapping示例如下： { "javalogs": { //索引名称 "mappings": { "properties": { "log_content": { //text类型，分词，用于之后的分词索引 "type": "text" }, "date": {//工夫类型 "type": "date" }, "log_level": { //keyword类型，不分词 "type": "keyword" }, "ip": { "type": "keyword" } } } }}在6.x版本中，每个索引中还能够有多个type，辨别不同的mapping。在7.x中，type被勾销，每个索引只有一个type:_doc文档(doc)文档是Elasticsearch中的最小单位，每个索引都是有数量泛滥的文档组成的。文档中蕴含多个字段，每个字段的类型由mapping定义。在一个索引中每个文档都有一个惟一id，能够在增加时指定，也能够主动生成。上面通过一张图来形容，节点(node)，索引(index)和文档(doc)之间的关系。本地环境搭建，创立第一个index所有常识都要通过实际把握，所以在理解根本的概念和逻辑后，上面就进入实际环节。这里举荐应用docker来搭建本地开发环境，docker对应windows和mac零碎都有桌面版本，应用十分不便。因为网络限度，间接应用docker官网仓库拉取镜像会很慢，所以在装置实现后，须要在设置中将仓库的地址替换为国内源，这里举荐https://docker.mirrors.ustc.edu.cn，速度很快，设置如下： { "registry-mirrors": [ "https://docker.mirrors.ustc.edu.cn" ]} ...

关于elasticsearch:Elasticsearch索引生命周期管理方案

一、前言在 Elasticsearch 的日常中，有很多如存储系统日志、行为数据等方面的利用场景，这些场景的特点是数据量十分大，并且随着工夫的增长索引的数量也会持续增长，然而这些场景基本上只有最近一段时间的数据有应用价值或者会被常常应用（热数据），而历史数据简直没有作用或者很少会被应用（冷数据），这个时候就须要对索引进行肯定策略的保护治理甚至是删除清理，否则随着数据量越来越多除了节约磁盘与内存空间之外，还会重大影响 Elasticsearch 的性能；在 Elastic Stack 6.6 版本后推出了新性能 Index Lifecycle Management(索引生命周期治理)，反对针对索引的全生命周期托管治理，并且在 Kibana 上也提供了一套 UI 界面来配置策略。本文次要介绍 Elasticsearch 索引生命周期治理如何配置和应用。二、生命周期2.1. 阶段介绍索引生命周期分为4个阶段：hot、warm、cold、delete，其中hot次要负责对索引进行rollover操作。 rollover：滚动更新创立的新索引将增加到索引别名，并被指定为写索引。PS：4个阶段中只有hot阶段是必须的索引依据工夫参数min_age进入生命周期阶段，若未设置，默认是0ms。min_age通常是从创立索引的工夫开始计算，如果索引被设置为滚动索引，那么min_age是从索引滚动开始计算。留神，在查看min_age参数并进入下一个阶段前，以后阶段的操作必须实现。 2.2. 阶段动作阶段/action优先级设置勾销追随滚动索引分片调配只读强制段合并膨胀索引解冻索引删除hot√√√××××××warm√√×√√√√××cold√√×√×××√×delete××××××××√ 2.3. 例子上面以索引 syslog-2020.10.01 为例子，在索引创立 1 天后转为 Warm 阶段，30 天后转为 Cold 阶段，30 天后删除日期动作阶段2020-10-01创立索引 syslog-2020.10.01 ，解决读写申请hot阶段2020-10-02syslog-2020.10.01 改为只读warm阶段2020-11-01syslog-2020.10.01 为只读，并迁徙到冷节点贮存cold阶段2020-12-01删除索引 syslog-2020.10.01delete阶段三、模仿过程3.1. 创立索引生命周期策略假如 Policy 设定如下：索引以每10个文档做一次 RolloverRollover 后 5 秒转为 Warm 阶段Rollover 后 20 秒转为 Cold 阶段Rollover 后 40 秒删除curl -XPUT "http://$IP:9200/_ilm/policy/my_ilm_policy" \ -H 'Content-Type: application/json' \ -u elastic:changeme \ -d '{ "policy": { "phases": { "hot": { "actions": { "rollover": { "max_docs": "10" } } }, "warm": { "min_age": "5s", "actions": { "allocate": { "include": { "box_type": "warm" } } } }, "cold": { "min_age": "20s", "actions": { "allocate": { "include": { "box_type": "cold" } } } }, "delete": { "min_age": "40s", "actions": { "delete": {} } } } } }'ip、用户名和明码按理论状况批改 ...

关于elasticsearch:Elasticsearch-收集ES集群的慢查询

一、开启ES集群慢查问三种形式https://www.elastic.co/guide/...形式1、在elasticsearch.yml文件中增加相干配置（需重启节点失效）**#查问慢日志**index.search.slowlog.threshold.query.warn: 10sindex.search.slowlog.threshold.query.info: 5sindex.search.slowlog.threshold.query.debug: 2sindex.search.slowlog.threshold.query.trace: 500msindex.search.slowlog.threshold.fetch.warn: 1sindex.search.slowlog.threshold.fetch.info: 800msindex.search.slowlog.threshold.fetch.debug: 500msindex.search.slowlog.threshold.fetch.trace: 200msindex.search.slowlog.level: info**#写过程慢日志**index.indexing.slowlog.threshold.index.warn: 10sindex.indexing.slowlog.threshold.index.info: 5sindex.indexing.slowlog.threshold.index.debug: 2sindex.indexing.slowlog.threshold.index.trace: 500msindex.indexing.slowlog.level: infoindex.indexing.slowlog.source: 1000形式2、执行API动静批改某些索引的慢查问日志PUT /my-index-000001/_settings { "index.search.slowlog.threshold.query.warn": "10s", "index.search.slowlog.threshold.query.info": "5s", "index.search.slowlog.threshold.query.debug": "2s", "index.search.slowlog.threshold.query.trace": "500ms", "index.search.slowlog.threshold.fetch.warn": "1s", "index.search.slowlog.threshold.fetch.info": "800ms", "index.search.slowlog.threshold.fetch.debug": "500ms", "index.search.slowlog.threshold.fetch.trace": "200ms", "index.search.slowlog.level": "info" "index.indexing.slowlog.threshold.index.warn": "10s", "index.indexing.slowlog.threshold.index.info": "5s", "index.indexing.slowlog.threshold.index.debug": "2s", "index.indexing.slowlog.threshold.index.trace": "500ms", "index.indexing.slowlog.level": "info", "index.indexing.slowlog.source": "1000" }形式3、在template的settings中设置慢查问配置PUT _template/us_data { "order": 5, "index_patterns": ["*"], "settings": { "index": { "lifecycle": { "name": "ilm_elk" }, "codec": "best_compression", "routing": { "allocation": { "total_shards_per_node": "1" } }, "search": { "slowlog": { "level": "info", "threshold": { "fetch": { "warn": "2s", "debug": "800ms", "info": "1s" }, "query": { "warn": "10s", "debug": "2s", "info": "5s" } } } }, "refresh_interval": "50s", "indexing": { "slowlog": { "level": "info", "threshold": { "index": { "warn": "10s", "debug": "2s", "info": "5s" } }, "source": "2000" } }, "number_of_shards": "1", "translog": { "flush_threshold_size": "2gb", "sync_interval": "120s", "durability": "async" }, "merge": { "scheduler": { "max_thread_count": "2" } }, "unassigned": { "node_left": { "delayed_timeout": "30m" } }, "number_of_replicas": "1" } }, "mappings": {}, "aliases": {} }二、应用filebeat收集慢查问日志到ES三、应用kibana可视化慢查问日志

关于elasticsearch:用-logstash-同步-Mysql-数据到-ES-实现关键词高亮的全文搜索

1、应用背景咱们习惯性，将数据存储到mysql，那么怎么应用ES实现全文检索呢。Elasticsearch为咱们提供了一个插件logstash来同步咱们的数据库。 2、装置logsash插件注意事项：要装置跟es版本一样的版本。 logstash下载地址：https://www.elastic.co/downloads/logstash 在windows上面解压即可应用。我这里用的都是7.2.0版本。不须要再像2.x版本须要集成logstash-jdbc-input，能力实现数据同步。 3、配置logsash实现同步1）在根目录下新建文件夹mysqletc，用来搁置同步所须要的文件和mysql驱动文件夹内容： 2）将要同步的数据库对应的mysql驱动放到该文件夹 3）在创立的新文件夹中（mysqletc文件夹）中创立sql文件 sql文件里就是你须要同步到es中的数据的查问语句，如果是全量同步，只须要要select * from [table]即可。如果同步多个表格能够创立多个sql文件。比方我的： soul.sql SELECT * FROM soulmto_user.sql SELECT * FROM mto_user留神：结尾不要加分号，我加分号同步报错了 3）logstash链接数据库和Elasticsearch的conf文件名字轻易取，我这里习惯叫mysql.conf，内容如下： input { stdin {} jdbc { # mysql 数据库链接,shop为数据库名 jdbc_connection_string => "jdbc:mysql://114.67.169.20:3306/myblog" # 用户名和明码 jdbc_user => "root" jdbc_password => "Wylc!@#$5" # 驱动 jdbc_driver_library => "C:/softs/elk/logstash-7.2.0/mysqletc/mysql-connector-java-8.0.13.jar" # 驱动类名 jdbc_driver_class => "com.mysql.cj.jdbc.Driver" jdbc_paging_enabled => "true" jdbc_page_size => "50000" # 执行的sql 文件门路+名称 statement_filepath => "C:/softs/elk/logstash-7.2.0/mysqletc/soul.sql" # 设置监听距离各字段含意（由左至右）分、时、天、月、年，全副为*默认含意为每分钟都更新 schedule => "* * * * *" # 索引类型 type => "soul" } jdbc { # mysql 数据库链接,shop为数据库名 jdbc_connection_string => "jdbc:mysql://114.67.169.20:3306/myblog" # 用户名和明码 jdbc_user => "root" jdbc_password => "Wylc!@#$5" # 驱动 jdbc_driver_library => "C:/softs/elk/logstash-7.2.0/mysqletc/mysql-connector-java-8.0.13.jar" # 驱动类名 jdbc_driver_class => "com.mysql.cj.jdbc.Driver" jdbc_paging_enabled => "true" jdbc_page_size => "50000" # 执行的sql 文件门路+名称 statement_filepath => "C:/softs/elk/logstash-7.2.0/mysqletc/mto_user.sql" # 设置监听距离各字段含意（由左至右）分、时、天、月、年，全副为*默认含意为每分钟都更新 schedule => "* * * * *" # 索引类型 type => "mto_user" } } filter { json { source => "message" remove_field => ["message"] } } output { if [type]=="soul"{ elasticsearch { hosts => ["localhost:9200"] index => "soul" document_id => "%{id}" } } if [type]=="mto_user"{ elasticsearch { hosts => ["localhost:9200"] index => "mto_user" document_id => "%{id}" } } stdout { codec => json_lines } }留神：创立的所有文本文件肯定要是utf-8无BOM格局编码 ...

关于elasticsearch:es762-Could-not-index-event-to-Elasticsearch

报错如下 [2020-12-22T11:18:42,441][WARN ][logstash.outputs.elasticsearch][main] Could not index event to Elasticsearch. {:status=>400, :action=>["index", {:_id=>nil, :_index=>"logstash-insurance-data-push-2020-12-22", :routing=>nil, :_type=>"_doc"}, #<LogStash::Event:0xe216446>], :response=>{"index"=>{"_index"=>"logstash-insurance-data-push-2020-12-22", "_type"=>"_doc", "_id"=>nil, "status"=>400, "error"=>{"type"=>"illegal_argument_exception", "reason"=>"Validation Failed: 1: this action would add [10] total shards, but this cluster currently has [3000]/[3000] maximum shards open;"}}}}{ "level_value" => 20000, "ip" => "10.5.235.137", "hostName" => "uatapipeline-data-push-job-profile-a-55b8c45df7-jv4qk", "contextName" => "data-push-job-uatapipeline-data-push-job-profile-a-55b8c45df7-jv4qk-6", "tags" => [ [0] "_jsonparsefailure"Validation Failed: 1: this action would add [10] total shards, but this cluster currently has [3000]/[3000] maximum shards open问题：分片数量超过限度数1000起因： ELASTICSEARCH7版本及以上的，默认只容许1000个分片，因为集群分片数有余引起的。解决：在KIBANA的TOOLS中扭转长期设，如图： ...

关于elasticsearch:Springboot2x整合ElasticSearch7x实战二

本教程是系列教程，对于初学者能够对 ES 有一个整体意识和实际实战。还没开始的同学，倡议先读一下系列攻略目录：Springboot2.x整合ElasticSearch7.x实战目录本篇幅是继上一篇 Springboot2.x整合ElasticSearch7.x实战（一），适宜初学 Elasticsearch 的小白，能够跟着整个教程做一个练习。第三章分词器装置应用搜寻，少不了应用分词器，elasticsearch 自带了一些简略分词器，也能够应用第三方分词器插件，如 ik、pinyin 等。 Standard Analyzer - 默认分词器，按词切分，小写解决Simple Analyzer - 依照非字母切分(符号被过滤), 小写解决Stop Analyzer - 小写解决，停用词过滤(the,a,is)Whitespace Analyzer - 依照空格切分，不转小写Keyword Analyzer - 不分词，间接将输出当作输入Patter Analyzer - 正则表达式，默认\W+(非字符宰割)Language - 提供了30多种常见语言的分词器Customer Analyzer 自定义分词器ik分词器插件装置下载和elasticsearch版本统一教程应用的是 7.7.0 版本。筹备 ik 目录，cd plugins && mkdir ik下载wget https://github.com/medcl/elas...有些中央从github下载网络不好，我在课件里有插件压缩包。解压到对应ik目录解压文件到目录 elasticsearch-7.7.0/plugins/ik 下。重启es，查看是否装置胜利curl http://localhost:9200/_cat/pluginsrest 实例：拼音分词器插件装置下载和elasticsearch版本统一教程应用的是 7.7.0 版本。筹备 ik 目录，cd plugins && mkdir pinyin下载wget https://github.com/medcl/elas...有些中央从github下载网络不好，我在课件放了插件的压缩包。解压到对应pinyin目录解压文件到目录 elasticsearch-7.7.0/plugins/pinyin 下。 ...

关于elasticsearch:Elasticsearch-7x-分片问题

Unassigned shards 查看起因cat shardsGET _cat/shards?v&h=index,shard,prirep,state,unassigned.reasonCluster allocation explain APIGET _cluster/allocation/explain?pretty查看磁盘水位线GET _cluster/settings?include_defaults 重新分配尝试重新分配POST /_cluster/reroute?retry_failed=true本文出自 qbit snap

关于elasticsearch:Elasticsearch-7x-在-Kibana-中看不到监控信息qbit

景象（We couldn't activate monitoring）排查# 查看模板GET _cat/templates/.monitoring*?v# 查看是否有 .monitoring-es-* 的索引GET _cat/indices/.monitoring-*# 查看集群配置GET /_cluster/settings批改集群配置PUT _cluster/settings{ "persistent": { "xpack": { "monitoring": { "elasticsearch": { "collection": { "enabled": "true" } }, "collection": { "enabled": "true" } } } }}本文出自 qbit snap

关于elasticsearch:Elasticsearch-7x-中-msearch-使用案例

需要有一批文献，作者ID（user_id）是多值，传入一批 user_id，每个 user_id 取一篇文献进去。如上图，想要取 user_id 蕴含 222、444 的文献各一篇。数据筹备POST my_index/_bulk{"index":{"_id":1}}{"author_id":[111,222]}{"index":{"_id":2}}{"author_id":[222,333]}{"index":{"_id":3}}{"author_id":[444,555]}查问terms3 条全中，不合乎需要GET my_index/_search{ "query": { "constant_score": { "filter": { "terms": { "author_id": [ "222", "444" ] } } } }}bool + should + term3 条全中，不合乎需要GET my_index/_search{ "query": { "bool": { "should": [ { "term": { "author_id": "222" } }, { "term": { "author_id": "444" } } ], "minimum_should_match": 1 } }}_msearch222、444 各中一条，符合要求GET my_index/_msearch{"index":"my_index"}{"query":{"constant_score":{"filter":{"term":{"author_id":"222"}}}},"size":1,"terminate_after":1}{"index":"my_index"}{"query":{"constant_score":{"filter":{"term":{"author_id":"444"}}}},"size":1,"terminate_after":1}本文出自 qbit snap

关于elasticsearch:ElasticSearch基本概念及安装

与传统关系型数据库区别Relational DBElasticsearchdatabase索引（indices）表（tables）types行（rows）documents字段（columns）fields倒排索引 Inverted Index有时候也叫反向索引搜索引擎的外围个别过程，对文章分词，依据关键词建设倒排索引装置与Kibana集成，当然举荐docker装置 https://github.com/scauxiaoxu... 通过docker ps 查看运行中的容器通过9200端口查看elasticearch是否装置胜利 kibana装置胜利后的拜访5601端口登录查看客户端工具elasticsearch-head 应用Chrome插件形式

关于elasticsearch:大幅降低存储成本Elasticsearch可搜索快照是如何办到的

导语 | Elasticsearch 7.10 版本最近公布，该版本有一个重磅个性：Searchable snapshots （可搜寻快照性能），能够大幅度地升高存储老本。那么 Searchable snapshots 的应用形式和实现成果是怎么的呢，上面就让咱们来一探到底吧！本文作者：高斌龙，腾讯云大数据研发工程师。一、性能介绍在 Searchable snapshots 可搜寻快照性能公布之前，通过调用 _snapshot API 对索引打的快照，不论是存储在 S3 还是 HDFS 或者是腾讯云的对象存储 COS上，都是不可能间接进行查问的。快照只能用于数据的冷备份，如果要查问的话须要先调用 API 把快照复原到集群中，当快照中的索引初始化实现后，才能够去查问。而可搜寻快照性能就使得存储在远端 S3、HDFS、COS 中的快照可能满足查问的需要了，ES 的数据文件不是只能存储在本地文件系统上，还能够反对存储在远端的 S3、HDFS、COS 等存储介质上，实际上实现了存储与计算的拆散。 Searchable snapshots 可搜寻快照性能预计会给 ES 带来新的凋敝，因为有十分多的用户应用 ELK 架构构建日志零碎。日志的数据量是十分大的，然而查问的频率个别比拟低，所以用户的痛点是：在满足根本查问需要的条件下同时升高 ES 的存储老本。当初基于 Searchable snapshots 可搜寻快照性能，能够把大量的比拟旧的索引都存储到 S3/COS 上，真正须要查问的时候能够去查问 S3/COS 中的数据。因为 S3/COS 自身老本是非常低的，大概只有 SSD 磁盘的十分之一，所以应用 ES 存储数据的老本大大降低了。另外一方面，可搜寻快照性能也能够进步集群的稳定性，能够仅仅应用一个较小规模的集群撑持最近一段时间热索引的读写即可，老的索引都能够寄存在 S3/COS 中，真正须要查问的时候再去查 S3/COS 中的数据，因为集群规模小，不至于呈现一个超大规模的集群存储所有的数据，从而导致集群不稳固的景象产生。不过就以后 7.10 版本的可搜寻快照性能的特点来看，没有咱们料想的能够齐全实现存储计算拆散。因为当把一个存储在 S3/COS 上的快照 mount 到一个集群中时，须要先执行快照复原，把快照中的文件从 S3/COS 读取到集群的本地磁盘上，快照中的索引先进行初始化，索引所有的数据文件复原结束后该索引才变为 green。 ...

关于elasticsearch:elasticsearch

集群

关于elasticsearch:ElasticSearch-23-种映射参数详解

@[toc]ElasticSearch 系列教程咱们后面曾经连着发了四篇了，明天第五篇，咱们来聊一聊 Es 中的 23 种常见的映射参数。针对这 23 种常见的映射参数，松哥专门录制了一个视频教程：视频链接: https://pan.baidu.com/s/1J23m... 提取码: 6k2a 本文是松哥所录视频教程的一个笔记，笔记简明扼要，残缺内容小伙伴们能够参考视频。 1.ElasticSearch 映射参数1.1 analyzer定义文本字段的分词器。默认对索引和查问都是无效的。假如不必分词器，咱们先来看一下索引的后果，创立一个索引并增加一个文档： PUT blogPUT blog/_doc/1{ "title":"定义文本字段的分词器。默认对索引和查问都是无效的。"}查看词条向量（term vectors） GET blog/_termvectors/1{ "fields": ["title"]}查看后果如下： { "_index" : "blog", "_type" : "_doc", "_id" : "1", "_version" : 1, "found" : true, "took" : 0, "term_vectors" : { "title" : { "field_statistics" : { "sum_doc_freq" : 22, "doc_count" : 1, "sum_ttf" : 23 }, "terms" : { "义" : { "term_freq" : 1, "tokens" : [ { "position" : 1, "start_offset" : 1, "end_offset" : 2 } ] }, "分" : { "term_freq" : 1, "tokens" : [ { "position" : 7, "start_offset" : 7, "end_offset" : 8 } ] }, "和" : { "term_freq" : 1, "tokens" : [ { "position" : 15, "start_offset" : 16, "end_offset" : 17 } ] }, "器" : { "term_freq" : 1, "tokens" : [ { "position" : 9, "start_offset" : 9, "end_offset" : 10 } ] }, "字" : { "term_freq" : 1, "tokens" : [ { "position" : 4, "start_offset" : 4, "end_offset" : 5 } ] }, "定" : { "term_freq" : 1, "tokens" : [ { "position" : 0, "start_offset" : 0, "end_offset" : 1 } ] }, "对" : { "term_freq" : 1, "tokens" : [ { "position" : 12, "start_offset" : 13, "end_offset" : 14 } ] }, "引" : { "term_freq" : 1, "tokens" : [ { "position" : 14, "start_offset" : 15, "end_offset" : 16 } ] }, "效" : { "term_freq" : 1, "tokens" : [ { "position" : 21, "start_offset" : 22, "end_offset" : 23 } ] }, "文" : { "term_freq" : 1, "tokens" : [ { "position" : 2, "start_offset" : 2, "end_offset" : 3 } ] }, "是" : { "term_freq" : 1, "tokens" : [ { "position" : 19, "start_offset" : 20, "end_offset" : 21 } ] }, "有" : { "term_freq" : 1, "tokens" : [ { "position" : 20, "start_offset" : 21, "end_offset" : 22 } ] }, "本" : { "term_freq" : 1, "tokens" : [ { "position" : 3, "start_offset" : 3, "end_offset" : 4 } ] }, "查" : { "term_freq" : 1, "tokens" : [ { "position" : 16, "start_offset" : 17, "end_offset" : 18 } ] }, "段" : { "term_freq" : 1, "tokens" : [ { "position" : 5, "start_offset" : 5, "end_offset" : 6 } ] }, "的" : { "term_freq" : 2, "tokens" : [ { "position" : 6, "start_offset" : 6, "end_offset" : 7 }, { "position" : 22, "start_offset" : 23, "end_offset" : 24 } ] }, "索" : { "term_freq" : 1, "tokens" : [ { "position" : 13, "start_offset" : 14, "end_offset" : 15 } ] }, "认" : { "term_freq" : 1, "tokens" : [ { "position" : 11, "start_offset" : 12, "end_offset" : 13 } ] }, "词" : { "term_freq" : 1, "tokens" : [ { "position" : 8, "start_offset" : 8, "end_offset" : 9 } ] }, "询" : { "term_freq" : 1, "tokens" : [ { "position" : 17, "start_offset" : 18, "end_offset" : 19 } ] }, "都" : { "term_freq" : 1, "tokens" : [ { "position" : 18, "start_offset" : 19, "end_offset" : 20 } ] }, "默" : { "term_freq" : 1, "tokens" : [ { "position" : 10, "start_offset" : 11, "end_offset" : 12 } ] } } } }}能够看到，默认状况下，中文就是一个字一个字的分，这种分词形式没有任何意义。如果这样分词，查问就只能依照一个字一个字来查，像上面这样： ...

关于elasticsearch:腾讯看点视频推荐索引构建方案

一、背景在视频举荐场景中，一方面咱们须要让新启用的视频尽可能快的触达用户，这一点对于新闻类的内容尤为要害；另一方面咱们须要疾速辨认新物品的好坏，通过散发的流量，以及对应的后验数据，来判断新物品是否值得持续散发流量。而这两点对于索引先验数据和后验数据的提早都有很高的要求。下文将为大家介绍看点视频举荐的索引构建计划，心愿和大家一起交换。文章作者：纪文忠，腾讯QQ端举荐研发工程师。注：这里咱们把视频创立时就带有的数据称为先验数据，如tag，作者账号id等，而把用户行为反馈的数据称为后验数据，如曝光、点击、播放等。二、看点视频举荐整体架构从数据链路来看此架构图，从下往上来看，首先视频内容由内容核心通过音讯队列给到咱们，通过肯定的解决入库、建索引、生成正排/倒排数据，这时候在存储层可召回的内容约有1千万条。而后通过召回层，通过用户画像、点击历史等特色召回出数千条视频，给到粗排层；粗排将这数千条视频打分，取数百条给到精排层；精排再一次打分，给到重排；重排依据肯定规定和策略进行打散和干涉，最终取10+条给到用户；视频在用户侧曝光后，从上之下，是另一条数据链路：用户对视频的行为，如曝光、点击、播放、点赞、评论等通过上报至日志服务，而后通过实时/离线解决产生特色回到存储层，由此造成一个循环。基于此架构，咱们须要设计一套召回/倒排索引，可能以实时/近实时的提早来解决所有数据。三、方案设计在旧计划中，索引是每半小时定时构建的，无奈满足近实时的要求。在剖析这个索引构建的计划时，咱们遇到的次要挑战有：数据虽不要求强一致性，但须要保障最终一致性；后验数据写入量极大，看点用户行为每日达到百亿+；召回零碎要求高并发、低提早、高可用。1. 业界支流计划调研通过比照业界支流计划，咱们能够看到，基于Redis的计划灵活性较差，间接应用比拟艰难，须要进行较多定制化开发，能够首先排除。因而咱们可抉择的计划次要在自研或者抉择开源成熟计划。通过钻研，咱们发现如果自研索引开发成本较高，而简略的自研计划可能无奈满足业务需要，欠缺的自研索引计划所须要的开发成本往往较高，往往须要多人的团队来开发保护，最终咱们抉择了基于ES的索引服务。至于为什么抉择基于ES，而不是抉择基于Solr，次要是因为ES有更成熟的社区，以及有腾讯云PaaS服务反对，应用起来更加灵便不便。 2. 数据链路图（1）计划介绍如下图所示：这个计划从数据链路上分为两大块。第一块，先验数据链路，就是上半局部，咱们的数据源次要来自内容核心，通过解析服务写入到CDB中。其中这个链路又分为全量链路和增量链路。全量链路次要是在重建索引时才须要的，触发次数少但也重要。它从DB这里dump数据，写入kafka，而后通过写入服务写入ES。增量链路是确保其实时性的链路，通过监听binlog，发送音讯至kafka，写入服务生产kafka而后写入ES。第二块，是后验数据链路。看点的用户行为流水每天有上百亿，这个量级间接打入ES是相对扛不住的。所以咱们须要对此进行聚合计算。这里应用Flink做了1分钟滚动窗口的聚合，而后把后果输入到写模块，失去1分钟增量的后验数据。在这里，Redis存储近7天的后验数据，写模块生产到增量数据后，须要读出当天的数据，并于增量数据累加后写回Redis，并发送对应的rowkey和后验数据音讯给到Kafka，再经由ES写入服务生产、写入ES索引。（2）一致性问题剖析这个数据链路存在3个一致性问题须要小心解决：第一，Redis写模块这里，须要先读出数据，累加之后再写入。先读后写，须要保障原子性，而这里可能存在同时有其余线程在同一时间写入，造成数据不统一。解决方案1是通过redis加锁来实现；解决方案2如下图所示，在kafka队列中，应用rowkey作为分区key，确保同一rowkey调配至同一分区，而同一只能由同一消费者生产，也就是同一rowkey由一个过程解决，再接着以rowkey作为分线程key，应用hash算法分线程，这样同一rowkey就在同一线程内解决，因而解决了此处的一致性问题。另外，通过这种计划，同一流内的一致性问题都能够解决。第二，还是Redis写模块这里，咱们晓得Redis写入是须要先生产kafka的音讯的，那么这里就要求kafka音讯commit和redis写入须要在一个事务内实现，或者说须要保障原子性。如果这里先commit再进行redis写入，那么如果零碎在commit完且写入redis前宕机了，那么这条音讯将失落掉；如果先写入，在commit，那么这里就可能会反复生产。如何解决这个一致性问题呢？咱们通过先写入redis，并且写入的信息里带上工夫戳作为版本号，而后再commit音讯；写入前会比拟音讯版本号和redis的版本号，若小于，则间接抛弃；这样这个问题也解决了。第三，咱们察看到写入ES有3个独立的过程写入，不同流写入同一个索引也会引入一致性问题。这里咱们能够剖析出，次要是先验数据的写入可能会存在一致性问题，因为后验数据写入的是不同字段，而且只有update操作，不会删除或者插入。举一个例子，上游的MySQL这里删除一条数据，全量链路和增量链路同时执行，而刚好全量Dump时刚好取到这条数据，随后binlog写入delete记录，那么ES写入模块别离会生产到插入和写入两条音讯，而他本人无奈辨别先后顺序，最终可能导致先删除后插入，而DB里这条音讯是已删除的，这就造成了不统一。那么这里如何解决该问题呢？其实剖析到问题之后就比拟好办，罕用的方法就是利用Kfaka的回溯能力：在Dump全量数据前记录下以后工夫戳t1，Dump实现之后，将增量链路回溯至t1即可。而这段可能不统一的工夫窗口，也就是1分钟左右，业务上是齐全能够忍耐的。线上0停机高可用的在线索引降级流程如下图所示：（3）写入平滑因为Flink聚合后的数据有很大的毛刺，导入写入ES时服务不稳固，cpu和rt都有较大毛刺，写入状况如下图所示: 此处监控距离是10秒，能够看到，因为聚合窗口是1min，每分钟前10秒写入达到峰值，前面逐步缩小，而后新的一分钟开始时又周期性反复这种状况。对此咱们须要钻研出适合的平滑写入计划，这里间接应用固定阈值来平滑写入不适合，因为业务不同工夫写入量不同，无奈给出固定阈值。最终咱们应用以下计划来平滑写入：咱们应用自适应的限流器来平滑写，通过统计前1分钟接管的音讯总量，来计算以后每秒可发送的音讯总量。具体实现如下图所示，将该模块拆分为读线程和写线程，读线程统计接管音讯数，并把音讯存入队列；令牌桶数据每秒更新；写线程获取令牌桶，获取不到则期待，获取到了就写入。最终咱们平滑写入后的成果如图所示：在不同时间段，均能达到平滑的成果。四、召回性能调优1. 高并发场景优化因为存在多路召回，所以召回零碎有读放大的问题，咱们ES相干的召回，总qps是50W。这么大的申请量如果间接打入ES，肯定是扛不住的，那么如何来进行优化呢？因为大量申请的参数是雷同的，并且存在大量的热门key，因而咱们引入了多级缓存来进步召回的吞吐量和延迟时间。咱们多级缓存计划如下图所示：这个计划架构清晰，简单明了，整个链路: 本地缓存(BigCache)<->分布式缓存(Redis)<->ES。通过计算，整体缓存命中率为95+%，其中本地缓存命中率75+%，分布式缓存命中率20%，打入ES的申请量大概为5%。这就大大提高了召回的吞吐量并升高了RT。该计划还思考缓了存穿透和雪崩的问题，在线上上线之后，不久就产生了一次雪崩，ES全副申请失败，并且缓存全副未命中。起初咱们还在剖析，到底是缓存生效导致ES失败，还是ES失败导致设置申请生效，实际上这就是经典的缓存雪崩的问题。咱们剖析一下，这个计划解决了4点问题：本地缓存定时dump到磁盘中，服务重启时将磁盘中的缓存文件加载至本地缓存。奇妙设计缓存Value，蕴含申请后果和过期工夫，由业务自行判断是否过期；当上游申请失败时，间接缩短过期工夫，并将老后果返回上游。热点key生效后，申请上游资源前进行加锁，限度单key并发申请量，爱护上游不会被霎时流量打崩。最初应用限流器兜底，如果零碎整体超时或者失败率减少，会触发限流器限度总申请量。2. ES性能调优（1）设置正当的primary_shardsprimary_shards即主分片数，是ES索引拆分的分片数，对应底层Lucene的索引数。这个值越大，单申请的并发度就越高，但给到下层MergeResult的数量也会减少，因而这个数字不是越大越好。依据咱们的教训联合官网倡议，通常单个shard为1~50G比拟正当，因为整个索引大小10G，咱们计算出正当取值范畴为1~10个，接下里咱们通过压测来取最合适业务的值。压测后果如下图所示：依据压测数据，咱们抉择6作为主分片数，此时es的均匀rt13ms，99分位的rt为39ms。（2）申请后果过滤不须要的字段ES返回后果都是json，而且默认会带上source和_id,_version等字段，咱们把不必要的正排字段过滤掉，再应用filter_path把其余不须要的字段过滤掉，这样总共能缩小80%的包大小，过滤后果如下图所示：包大小由26k减小到5k，带来的收益是晋升了30%的吞吐性能和升高3ms左右的rt。（3）设置正当routing字段ES反对应用routing字段来对索引进行路由，即在建设索引时，能够将制订字段作为路由根据，通过哈希算法间接算出其对应的分片地位。 ...

关于elasticsearch:50elasticsearch搜索引擎用Django实现我的搜索以及热门搜索

【百度云搜寻，搜各种材料:http://www.lqkweb.com】【搜网盘，搜各种材料:http://www.swpan.cn】第三百七十一节，Python分布式爬虫打造搜索引擎Scrapy精讲—elasticsearch(搜索引擎)用Django实现我的搜寻以及热门我的搜素简略实现原理咱们能够用js来实现，首先用js获取到输出的搜索词设置一个数组里寄存搜素词，判断搜索词在数组里是否存在如果存在删除原来的词，从新将新词放在数组最后面如果不存在间接将新词放在数组最后面即可，而后循环数组显示后果即可热门搜寻实现原理，当用户搜寻一个词时，能够保留到数据库，而后记录搜寻次数，利用redis缓存搜寻次数最到的词，过一段时间更新一下缓存备注：Django联合Scrapy的开源我的项目能够学习一下django-dynamic-scraperhttps://github.com/holgerd77/... 补充默认的elasticsearch(搜索引擎)只能搜寻1万条数据，在大就会报错了** 设置办法步骤一：关上我的项目的索引库地址，将该索引先敞开，否则设置操步骤二无奈提交步骤二：关上复合查问，填入如下信息，记得抉择PUT形式提交，credit_trace_data改为本索引库中的索引，max_result_window设为20亿，此值是integer类型，不能无限大 http://127.0.0.1:9200/ PUT credit_trace_data/_settings?preserve_existing=true { "max_result_window" : "2000000000" } 最初点击提交申请，如果配置正确右侧窗口会显示如下信息如果要查问max_result_window时只须要将PUT改为get即可最初记得开启索引！

关于elasticsearch:ElasticSearch-动态映射和静态映射以及四种字段类型

@[toc]ElasticSearch 系列教程咱们后面曾经连着发了三篇了，明天第四篇，咱们来聊一聊 Es 中的动静映射、动态映射以及四种不同的字段类型。本文是松哥所录视频教程的一个笔记，笔记简明扼要，残缺内容小伙伴们能够参考视频，视频下载链接：https://pan.baidu.com/s/1oKiV... 提取码: p3sx 1.ElasticSearch 映射映射就是 Mapping，它用来定义一个文档以及文档所蕴含的字段该如何被存储和索引。所以，它其实有点相似于关系型数据库中表的定义。 1.1 映射分类动静映射顾名思义，就是主动创立进去的映射。es 依据存入的文档，主动剖析进去文档中字段的类型以及存储形式，这种就是动静映射。举一个简略例子，新建一个索引，而后查看索引信息：在创立好的索引信息中，能够看到，mappings 为空，这个 mappings 中保留的就是映射信息。当初咱们向索引中增加一个文档，如下： PUT blog/_doc/1{ "title":"1111", "date":"2020-11-11"}文档增加胜利后，就会主动生成 Mappings：能够看到，date 字段的类型为 date，title 的类型有两个，text 和 keyword。默认状况下，文档中如果新增了字段，mappings 中也会主动新增进来。有的时候，如果心愿新增字段时，可能抛出异样来揭示开发者，这个能够通过 mappings 中 dynamic 属性来配置。 dynamic 属性有三种取值： true，默认即此。主动增加新字段。false，疏忽新字段。strict，严格模式，发现新字段会抛出异样。具体配置形式如下，创立索引时指定 mappings（这其实就是动态映射）： PUT blog{ "mappings": { "dynamic":"strict", "properties": { "title":{ "type": "text" }, "age":{ "type":"long" } } }}而后向 blog 中索引中增加数据： PUT blog/_doc/2{ "title":"1111", "date":"2020-11-11", "age":99}在增加的文档中，多出了一个 date 字段，而该字段没有预约义，所以这个增加操作就回报错： ...

关于elasticsearch:ElasticSearch-文档并发处理以及文档路由

@[toc]ElasticSearch 系列教程咱们后面曾经连着发了两篇了，明天第三篇，咱们来聊一聊 Es 中的文档并发解决和文档路由问题。本文是松哥所录视频教程的一个笔记，笔记简明扼要，残缺内容小伙伴们能够参考视频，视频下载链接：https://pan.baidu.com/s/1TwyO... 提取码: aee2 1. ElasticSearch 文档基本操作1.1 新建文档首先新建一个索引。而后向索引中增加一个文档： PUT blog/_doc/1{ "title":"6. ElasticSearch 文档基本操作", "date":"2020-11-05", "content":"微信公众号**江南一点雨**后盾回复 **elasticsearch06** 下载本笔记。首先新建一个索引。"}1 示意新建文档的 id。增加胜利后，响应的 json 如下： { "_index" : "blog", "_type" : "_doc", "_id" : "1", "_version" : 1, "result" : "created", "_shards" : { "total" : 2, "successful" : 2, "failed" : 0 }, "_seq_no" : 0, "_primary_term" : 1}_index 示意文档索引。_type 示意文档的类型。_id 示意文档的 id。_version 示意文档的版本（更新文档，版本会主动加 1，针对一个文档的）。result 示意执行后果。_shards 示意分片信息。_seq_no 和 _primary_term 这两个也是版本控制用的（针对以后 index）。增加胜利后，能够查看增加的文档： ...

关于elasticsearch:elasticsearch笔记006文档APICRUD单文档更新操作

[toc] 1. 单文档 Update APIupdate API 依据提供的script更新文档; 从索引中获取document, 执行脚本, 并对新的后果进行索引. 如何确保 get 和 reindex 期间没有产生更新? --> 应用版本控制; 这种操作依然意味着对文档进行残缺的从新索引, 它只是移除了一些网络往返损耗，并缩小了get和索引之间版本抵触的机会.1. script更新: 数值计算示例: 新建一个document到 test 索引, 而后批改 counter=counter+4; 而后为tags新增一个 blue的色彩: #1. 新建一个document到 test 索引PUT test/_doc/1{ "counter" : 1, "tags" : ["red"]}将 "counter"的值加上给定的参数: POST test/_update/1{ "script" : { "source": "ctx._source.counter += params.count", "lang": "painless", "params" : { "count" : 4 } }}查看以后: GET test/_source/1 { "counter" : 5, "tags" : [ "red" ]}同理: counter=counter*2: ...

关于elasticsearch:elasticsearch笔记005文档APICRUD单文档删除操作

[toc] 1. 单文档Delete API1. 应用id删除documentDELETE /twitter/_doc/1{ "_index" : "twitter", "_type" : "_doc", "_id" : "1", "_version" : 2, "result" : "deleted", "_shards" : { "total" : 2, "successful" : 1, "failed" : 0 }, "_seq_no" : 1, "_primary_term" : 1}2. document 指定版本的删除索引的每个document 都有版本。在删除文档时，能够指定版本，确保删除的文档实际上曾经被删除，且在此期间没有产生更改; 对文档执行的每个写操作(包含删除)都会导致其版本减少;删除后的文档的版本号在短时间内依然可用，以便管制并发操作, 被删除文档的版本放弃可用的工夫长度由 index.gc_deletes这个设置(setting)决定: 默认是 60 seconds; 3. routing的索引的删除如果建索引时, 应用了 routing, 那么删除索引时, 也须要指定 routing; DELETE /twitter/_doc/1?routing=kimchy, 没有正确路由的状况下收回删除将导致文档不被删除。当按须要设置_routing映射并且没有指定路由值时，delete API将抛出一个RoutingMissingException并拒绝请求 4. 删除时查看沉闷分片数量收回删除操作时, 能够设置wait_for_active_shards参数，要求在开始解决删除申请之前，查看流动的切分正本的最小数量; 5. 删除时的 timeout在执行删除操作时，调配给执行删除操作的主shard可能不可用! 起因可能是主shard以后正在从存储中复原或正在进行从新定位; 默认状况下，delete操作将等主shard可用的时长为1分钟，而后失败并响应一个谬误。这个 timeout参数能够在删除时指定: DELETE /twitter/_doc/1?timeout=5m ...

关于elasticsearch:elasticsearch笔记004文档APICRUD单文档查操作

[toc] 单文档 get API1. Get根本查问GET weibo/_doc/1output: { "_index" : "weibo", "_type" : "_doc", "_id" : "1", "_version" : 3, "_seq_no" : 2, "_primary_term" : 1, "found" : true, "_source" : { "user" : "niewj", "post_date" : "2009-11-15T14:12:12", "message" : "trying out Elasticsearch" }}2. head查问文档是否存在GET weibo/_doc/2 后果: { "_index" : "weibo", "_type" : "_doc", "_id" : "2", "found" : false}能够看到id=2的文档不存在: HEAD weibo/_doc/2 后果: 404 - Not Found ...

关于elasticsearch:elasticsearch笔记003文档APICRUD单文档索引操作

[toc] 单文档Index API1. 索引一个文档PUT /weibo/_doc/1{ "user": "niewj", "post_date": "2020-11-20T17:00:00", "message": "trying out Elasticsearch"}output: { "_index" : "weibo", "_type" : "_doc", "_id" : "1", "_version" : 1, "result" : "created", "_shards" : { "total" : 2, "successful" : 1, "failed" : 0 }, "_seq_no" : 0, "_primary_term" : 1}索引如果不存在, 会主动创立一个索引;如果不存在dynamic mapping, index时会创立一个;如果须要, 新的字段和对象会主动退出到mapping 定义中;2. 可选项op_type或_create(put_if_absent)put默认是笼罩的; 然而如果应用一个op_type选项, 能够扭转这个逻辑: PUT /customer/_doc/5?op_type=create{ "name": "niewj5"}如果没有id=5的doc了, 索引胜利; 如果已有, 就会失败; 另一种写法: PUT /customer/_create/5{ "name": "niewj5"}output: ...

关于elasticsearch:Elasticsearch操作实践手册建议收藏篇

我是啤酒就辣条。但行好事，莫问前程。官网为咱们提供了多种语言操作Elasticsearch的API，能够很不便的在我的项目中操作。学习利用原生申请操作Elasticsearch，不便保护数据库，还能放慢学习应用不同语言的API。本博客应用kibana发动申请，应用kibana能够查看快捷键。索引操作创立索引创立索引应用PUT申请，前面跟上索引名称就好了，因为7.x默认type为_doc，所以前面不用跟上type了。在PUT简略申请同时，能够加上JSON申请体，进行简单创立。 PUT /user{ "settings": { "index": { "number_of_shards": 3, "number_of_replicas": 2 } }, "mappings": { "properties": { "name": { "type": "text" }, "age": {"type": "short"}, "city":{"type": "keyword"} } }}创立索引user，能够通过参数setting设置分片和正本数，通过number_of_shards设置一共有3个分片，通过number_of_replicas给每个分片设置2个正本，默认不指定的话，这两个参数都是1。通过mappings规定文档各个Filed插入类型。此外，还能够设置aliases字段，给索引创立别名，这样不仅能够通过别名拜访该索引，还能够定义查问条件、指定查问分片等等，详情请参考。删除索引删除索引，应用DELETE申请。 DELETE /user查看索引查看索引，应用GET申请，能够查看索引设置的参数。删除之后，我又从新增加索引，没有设置settings，所以分片和正本都是1。你也能够通过在索引前面加参数来查看某一具体参数，如： GET /user/_settingsGET /user/_mappingsGET /user/_aliases批改索引局部设置能够通过PUT申请批改局部索引的settings，例如，分片正本数量能够批改，然而分片数量不能够通过这种形式批改。 PUT /user/_settings{ "number_of_replicas": 3 }能够通过以上申请，批改分片正本。文档操作创立好索引，来看下文档的增删改查，这是日常业务用的最多的中央。插入文档新增文档应用PUT、POST申请。 PUT /<target>/_doc/<_id>POST /<target>/_doc/PUT /<target>/_create/<_id>POST /<target>/_create/<_id>target为索引名称，_doc为默认type。通过前两种申请可看出，id能够自行指定，也能够由ES主动生成。_create能够保障只有当文档不存在的时候进行插入，而_doc还能够用于文档更新。 POST /user/_doc/1{ "name":"pjjlt", "age":26, "city":"sjz"}更新文档更新文档能够应用PUT或者POST申请关键字，全量更新。 POST /user/_doc/1{ "name":"pjjlt", "age":3, "city":"sjz"}还能够通过_update命令部分更新，所谓部分更新，是讲申请体内不须要退出全副字段，只退出须要批改的字段就好，其余字段不变。全量更新会替换整个文档。 POST /user/_update/1{ "doc":{ "age": 26 }}此外还能够通过脚本批改，例如将所有存在age字段的文档，其值改成5岁。 ...

关于elasticsearch:Elasticsearch基本概念和索引原理

我是啤酒就辣条。但行好事，莫问前程。 Elasticsearch是什么？Elasticsearch是一个基于文档的NoSQL数据库，是一个分布式、RESTful格调的搜寻和数据分析引擎，同时也是Elastic Stack的外围，集中存储数据。Elasticsearch、Logstash、Kibana常常被用作日志剖析零碎，俗称ELK。说白了，就是一个数据库，搜寻贼快(然而插入更新较慢，要不然其余数据库别玩了)。速度快，还能够进行分词，非常适合做搜寻，例如商城的商品搜寻。为什么快，前面讲原理的时候会说，不单单是缓存的问题，原理十分精彩。而且它是nosql的，数据格式能够轻易造。Elasticsearch还为咱们提供了丰盛的RESTful格调的API，写代码的老本极低。最初它反对分布式，高性能(搜寻快)，高可用(某些节点宕机能够接着用)，可伸缩(能够不便的减少节点，解决物理内存上线问题)，适宜分布式系统开发。 Elasticsearch基本概念为了疾速理解Elasticsearch(前面可能会简称为ES)，能够与mysql几个概念做个比照。 ElasticsearchMysql字段(Filed)属性(列)文档(Document)记录(行)类型(Type)表索引(Index)数据库是不是分明多了？咱们说Elasticsearch是基于文档的，就是因为记录元素(被搜寻的最小单位)是文档。例如上面就是一个文档， { "email": "john@smith.com", "first_name": "John", "last_name": "Smith", "info": { "bio": "Eco-warrior and defender of the weak", "age": 25, "interests": [ "dolphins", "whales" ] }, "join_date": "2014/05/01"}文档格局看起来很像Json吧。email、first_name等等就是Filed。因为构造是Json，所以value值就很不便放任意类型，这就是nosql的益处。文档(Document)ES中的一个对象未来会和Java代码中的一个对象对应。文档的每一个Filed能够是任意类型，然而一旦某索引(Index)(咱们形容的时候，略过Type，然而Type仍然存在)中插入了一个文档，某Filed被第一次应用，ES就会设置好此Filed的类型。例如你插入user的name是字符串类型，当前再插入文档，name字段必须是字符串类型。所以，倡议在插入文档之前，先设置好每个Filed的类型。如果插入文档的时候，不指定id，ES会帮忙咱们主动生成一个id，倡议id是数字类型，这样搜寻会疾速很多。商城零碎中的商品id倡议应用雪花算法生成，这样既防止了自增id的安全性问题，又解决了字符串id检索慢的问题。类型(Type)对于Type，类型概念,在6.x版本中，一个索引(Index)能够领有多个Type。在7.x版本(目前最新版本)，一个索引只能领有一个Type，默认的type就是_doc，在7.x版本中，曾经倡议删除了。在将来的8.x版本会彻底删除。然而在7.x版本中，一个文档还必须归属于一个类型。索引(Index)都说ES中的索引相似于mysql中的数据库，我感觉将来索引有成为mysql中表概念的潜质。咱们把雷同特色(Filed数量和类型基本相同)的文档放到同一个索引(index)外面。这样不便提前通过mapping来规定各个Filed的类型。另外，索引名称必须全副小写，所以不倡议写成驼峰式。节点(Node)与分片(Shard) 因为生产环境下ES根本都是集群部署的，所以肯定少不了节点的概念，一个节点就是一个ES实例，就是一个Java过程，这些Java过程部署在不同的服务器上，减少ES可用性。 ES节点依据性能能够分为三种：主节点：职责是和集群操作相干的内容，如创立或删除索引，跟踪哪些节点是群集的一部分，并决定哪些分片调配给相干的节点。每个节点都可拜访集群的状态，然而只有主节点能够批改集群的状态。数据节点：数据节点次要是贮存数据的节点，对文档进行增删改查，聚合操作等等，数据节点对cpu，内存，io要求较高，当资源不够的时候，能够减少新的节点，很不便的进行数据拓展。客户端节点：本节点次要解决路由申请，散发索引的操作。实际上主节点和数据节点也有路由转发的性能，然而为了提高效率，还是倡议生产环境独自创立客户端节点。分片相似于mysql中的分表，在一个索引拆分成几个小索引，散布在不同的节点(不同服务器)上，每个小索引都具备齐备的性能，当客户端发来申请的时候，客户端节点找到适合的分片上的小索引，进行数据查问，这一过程对于用户来说都是通明的，用户外表上看只是在操作一个索引。利用分片，能够防止单个节点的物理限度，还能够减少吞吐量。倡议最开始一个索引要用多少分片设计好，因为批改分片数量是个相当麻烦的过程。作为分布式的数据库，ES必须为咱们提供数据冗余性能，这就是分片正本，就是将某个分片copy一份放到其余节点上。留神，这里分片和分片正本必须在不同的节点上！分片正本也能够进步吞吐量。分片正本不同于分片，能够很不便的进行批改。说完了所有概念，再去看本节最开始那张图，有一个索引，分了3分片在三个节点上，并且每个分片在不同的节点上有分片正本。 Elasticsearch索引原理看完下面的内容，你对Elasticsearch有了根本的意识，再去看基本操作(我前面要写一篇基操博客)，就能够在我的项目中应用Elasticsearch了。此刻你能够喘口气，以放松的心态看前面的内容。上面咱们就讲讲索引为什么快？首先，咱们晓得mysql底层数据结构应用的是B+Tree，这种BTree，将搜寻工夫复杂度变成了logN，曾经很快了，咱们Elasticsearch要比它还快。Elasticsearch是怎么做的呢？首先贮存构造要优化，而后再进步下和磁盘的交互效率。先说Elasticsearch索引构造，叫做倒排索引，啥是倒排索引呢？它的大略逻辑如下：为了讲清楚这个概念，咱们先看个例子，如下为咱们user的数据： IDNameAge1Kate242John243Bill294Kate265Brand29Elasticsearch会为以上数据建设两个索引树: TermPosting ListKate1,4Brand5John2Bill3TermPosting List241,2264293,5以上的索引树就叫做倒排索引，每个Filed字段对应着一组Term，每个Term前面跟着的id(还记着吗，这个主键用户不指定就会主动生成，所以肯定存在)就是Posting List，它是一组id，有了id再去磁盘中对应的文档就so fast了。你有没有发现，Term如果按序找会快点，将Term按序排，在进行二分查找，是不是速度就跟BTree一样了，工夫复杂度为LogN。这个有序的Term组就是Term Dictionary。那么问题又来了，比如说数据库中有name前缀为A的同学1000万个，前缀为Z的同学有3个，我要查前缀为Z的同学，那二分查找不也很屡次吗，所以，Elasticsearch把每个结尾的中央标记一下，拿进去，再放到一颗树里，速度不是就快了嘛。这棵树就是Term Index。Term Index前缀不肯定是第一个字符，比方A、Ab、Abz，这种都能够在Term Index树里。并且Term Dictionary可能会太大，会被放到磁盘中，防止内存占用太多。再看上面这张结构图是不是分明多了。因为Term Index被放到内存中，所以最好压缩一下，缩小内存应用，压缩应用的是FST，这个货色讲起来比较复杂，反正就是能压缩，内存变小就好了。 Term压缩完了，那么Posting List是不是也能够压缩一下，省省空间啊？既然都是id，应用过redis的同学霎时会想到bitMap，就是有个微小的数组，贮存着0或1，有就是1，没有就是0。例如下面的3、5放在BitMap中就是 1，0，1，0，0，0。虽说空间曾经显著小多了，然而如果一个Posting List只贮存着1，10000001这两个id，最初产生的数字是不是过大呢。于是乎，Roaring bitmaps就进去了，进行了一次指数降级，简略点说就是取商和余数贮存，被除数是65535。例如 1000，62101，131385，196658，这几个id，首先分组，分组规定就是商一样，例如下面id可分组为[(0,1000),(0,62101)],[],[(2,6915)],[(3,53)]。留神，没有商为1的值，我用空数组示意。此时，将某个组中的数字放到一个bitmap中。 ...

关于elasticsearch:49elasticsearch搜索引擎用Django实现搜索结果分页

【百度云搜寻，搜各种材料:http://www.lqkweb.com】【搜网盘，搜各种材料:http://www.swpan.cn】【酷站群，搜各种网站源码:http://www.kuzq.cn】逻辑处理函数计算搜寻耗时　在开始搜寻前：start_time = datetime.now()获取以后工夫　在搜寻完结后：end_time = datetime.now()获取以后工夫　last_time = (end_time-start_time).total_seconds()完结工夫减去开始工夫等于用时,转换成秒 from django.shortcuts import render# Create your views here.from django.shortcuts import render,HttpResponsefrom django.views.generic.base import Viewfrom app1.models import lagouType # 导入操作elasticsearch(搜索引擎)类import jsonfrom elasticsearch import Elasticsearch # 导入原生的elasticsearch(搜索引擎)接口client = Elasticsearch(hosts=["127.0.0.1"]) # 连贯原生的elasticsearchfrom datetime import datetimedef indexluoji(request): print(request.method) # 获取用户申请的门路 return render(request, 'index.html')def suggestluoji(request): # 搜寻主动补全逻辑解决 key_words = request.GET.get('s', '') # 获取到申请词 re_datas = [] if key_words: s = lagouType.search() # 实例化elasticsearch(搜索引擎)类的search查问 s = s.suggest('my_suggest', key_words, completion={ "field": "suggest", "fuzzy": { "fuzziness": 1 }, "size": 5 }) suggestions = s.execute_suggest() for match in suggestions.my_suggest[0].options: source = match._source re_datas.append(source["title"]) return HttpResponse(json.dumps(re_datas), content_type="application/json")def searchluoji(request): # 搜寻逻辑解决 key_words = request.GET.get('q', '') # 获取到申请词 page = request.GET.get('p', '1') # 获取拜访页码 try: page = int(page) except: page = 1 start_time = datetime.now() # 获取以后工夫 response = client.search( # 原生的elasticsearch接口的search()办法，就是搜寻，能够反对原生elasticsearch语句查问 index="lagou", # 设置索引名称 doc_type="biao", # 设置表名称 body={ # 书写elasticsearch语句 "query": { "multi_match": { # multi_match查问 "query": key_words, # 查问关键词 "fields": ["title", "description"] # 查问字段 } }, "from": (page-1)*10, # 从第几条开始获取 "size": 10, # 获取多少条数据 "highlight": { # 查问关键词高亮解决 "pre_tags": ['<span class="keyWord">'], # 高亮开始标签 "post_tags": ['</span>'], # 高亮完结标签 "fields": { # 高亮设置 "title": {}, # 高亮字段 "description": {} # 高亮字段 } } } ) end_time = datetime.now() # 获取以后工夫 last_time = (end_time-start_time).total_seconds() # 完结工夫减去开始工夫等于用时,转换成秒 total_nums = response["hits"]["total"] # 获取查问后果的总条数 if (page % 10) > 0: # 计算页数 paga_nums = int(total_nums/10)+1 else: paga_nums = int(total_nums/10) hit_list = [] # 设置一个列表来贮存搜寻到的信息，返回给html页面 for hit in response["hits"]["hits"]: # 循环查问到的后果 hit_dict = {} # 设置一个字典来贮存循环后果 if "title" in hit["highlight"]: # 判断title字段，如果高亮字段有类容 hit_dict["title"] = "".join(hit["highlight"]["title"]) # 获取高亮里的title else: hit_dict["title"] = hit["_source"]["title"] # 否则获取不是高亮里的title if "description" in hit["highlight"]: # 判断description字段，如果高亮字段有类容 hit_dict["description"] = "".join(hit["highlight"]["description"])[:500] # 获取高亮里的description else: hit_dict["description"] = hit["_source"]["description"] # 否则获取不是高亮里的description hit_dict["url"] = hit["_source"]["url"] # 获取返回url hit_list.append(hit_dict) # 将获取到内容的字典，增加到列表 return render(request, 'result.html', {"page": page, # 以后页码 "total_nums": total_nums, # 数据总条数 "all_hits": hit_list, # 数据列表 "key_words": key_words, # 搜索词 "paga_nums": paga_nums, # 页数 "last_time": last_time # 搜寻工夫 }) # 显示页面和将列表和搜索词返回到htmlHTML <!DOCTYPE html ><html xmlns="http://www.w3.org/1999/xhtml">{#引入动态文件门路#}{% load staticfiles %}<head><meta http-equiv="X-UA-Compatible" content="IE=emulateIE7" /><meta http-equiv="Content-Type" content="text/html; charset=utf-8" /><title>python-lcv-search搜索引擎</title><link href="{% static 'css/style.css'%}" rel="stylesheet" type="text/css" /><link href="{% static 'css/result.css'%}" rel="stylesheet" type="text/css" /></head><body><div id="container"> <div id="hd" class="ue-clear"> <a href="/"><div class="logo"></div></a> <div class="inputArea"> <input type="text" class="searchInput" value="{{ key_words }}"/> <input type="button" class="searchButton" onclick="add_search()"/> </div> </div> <div class="nav"> <ul class="searchList"> <li class="searchItem current" data-type="article">文章</li> <li class="searchItem" data-type="question">问答</li> <li class="searchItem" data-type="job">职位</li> </ul> </div> <div id="bd" class="ue-clear"> <div id="main"> <div class="sideBar"> <div class="subfield">网站</div> <ul class="subfieldContext"> <li> <span class="name">伯乐在线</span> <span class="unit">(None)</span> </li> <li> <span class="name">知乎</span> <span class="unit">(9862)</span> </li> <li> <span class="name">拉勾网</span> <span class="unit">(9862)</span> </li> <li class="more"> <a href="javascript:;"> <span class="text">更多</span> <i class="moreIcon"></i> </a> </li> </ul> <div class="sideBarShowHide"> <a href="javascript:;" class="icon"></a> </div> </div> <div class="resultArea"> <p class="resultTotal"> <span class="info">找到约 <span class="totalResult">{{ total_nums }}</span> 条后果(用时<span class="time">{{ last_time }}</span>秒)，共约<span class="totalPage">{{ paga_nums }}</span>页</span> </p> <div class="resultList"> {% for hit in all_hits %} <div class="resultItem"> <div class="itemHead"> <a href="{% autoescape off %} {{ hit.url }} {% endautoescape %}" target="_blank" class="title">{% autoescape off %} {{ hit.title }} {% endautoescape %}</a> <span class="divsion">-</span> <span class="fileType"> <span class="label">起源：</span> <span class="value">网络</span> </span> <span class="dependValue"> <span class="label">得分：</span> <span class="value">3.401155</span> </span> </div> <div class="itemBody"> {% autoescape off %} {{ hit.description }} {% endautoescape %} </div> </div> {% endfor %} </div>  <div class="pagination ue-clear"></div>  </div> <div class="historyArea"> <div class="hotSearch"> <h6>热门搜寻</h6> <ul class="historyList"> <li><a href="/search?q=linux">linux</a></li> </ul> </div> <div class="mySearch"> <h6>我的搜寻</h6> <ul class="historyList"> </ul> </div> </div> </div> </div></div><div id="foot">Copyright ©projectsedu.com 版权所有 E-mail:admin@projectsedu.com</div></body><script type="text/javascript" src="{% static 'js/jquery.js'%}"></script><script type="text/javascript" src="{% static 'js/global.js'%}"></script><script type="text/javascript" src="{% static 'js/pagination.js'%}"></script><script type="text/javascript"> var search_url = "/search/" $('.searchList').on('click', '.searchItem', function(){ $('.searchList .searchItem').removeClass('current'); $(this).addClass('current'); }); $.each($('.subfieldContext'), function(i, item){ $(this).find('li:gt(2)').hide().end().find('li:last').show(); }); function removeByValue(arr, val) { for(var i=0; i<arr.length; i++) { if(arr[i] == val) { arr.splice(i, 1); break; } } } $('.subfieldContext .more').click(function(e){ var $more = $(this).parent('.subfieldContext').find('.more'); if($more.hasClass('show')){ if($(this).hasClass('define')){ $(this).parent('.subfieldContext').find('.more').removeClass('show').find('.text').text('自定义'); }else{ $(this).parent('.subfieldContext').find('.more').removeClass('show').find('.text').text('更多'); } $(this).parent('.subfieldContext').find('li:gt(2)').hide().end().find('li:last').show(); }else{ $(this).parent('.subfieldContext').find('.more').addClass('show').find('.text').text('收起'); $(this).parent('.subfieldContext').find('li:gt(2)').show(); } }); $('.sideBarShowHide a').click(function(e) { if($('#main').hasClass('sideBarHide')){ $('#main').removeClass('sideBarHide'); $('#container').removeClass('sideBarHide'); }else{ $('#main').addClass('sideBarHide'); $('#container').addClass('sideBarHide'); } }); var key_words = "{{ key_words }}" //分页 $(".pagination").pagination({{ total_nums }}, { current_page :{{ page|add:'-1' }}, //以后页码 items_per_page :10, display_msg :true, callback :pageselectCallback }); function pageselectCallback(page_id, jq) { window.location.href=search_url+'?q='+key_words+'&p='+page_id } setHeight(); $(window).resize(function(){ setHeight(); }); function setHeight(){ if($('#container').outerHeight() < $(window).height()){ $('#container').height($(window).height()-33); } }</script><script type="text/javascript"> $('.searchList').on('click', '.searchItem', function(){ $('.searchList .searchItem').removeClass('current'); $(this).addClass('current'); }); // 联想下拉显示暗藏 $('.searchInput').on('focus', function(){ $('.dataList').show() }); // 联想下拉点击 $('.dataList').on('click', 'li', function(){ var text = $(this).text(); $('.searchInput').val(text); $('.dataList').hide() }); hideElement($('.dataList'), $('.searchInput'));</script><script> var searchArr; //定义一个search的，判断浏览器有无数据存储（搜寻历史） if(localStorage.search){ //如果有，转换成数组的模式寄存到searchArr的数组里（localStorage以字符串的模式存储，所以要把它转换成数组的模式） searchArr= localStorage.search.split(",") }else{ //如果没有，则定义searchArr为一个空的数组 searchArr = []; } //把存储的数据显示进去作为搜寻历史 MapSearchArr(); function add_search(){ var val = $(".searchInput").val(); if (val.length>=2){ //点击搜寻按钮时，去重 KillRepeat(val); //去重后把数组存储到浏览器localStorage localStorage.search = searchArr; //而后再把搜寻内容显示进去 MapSearchArr(); } window.location.href=search_url+'?q='+val+"&s_type="+$(".searchItem.current").attr('data-type') } function MapSearchArr(){ var tmpHtml = ""; var arrLen = 0 if (searchArr.length > 6){ arrLen = 6 }else { arrLen = searchArr.length } for (var i=0;i<arrLen;i++){ tmpHtml += '<li><a href="/search?q='+searchArr[i]+'">'+searchArr[i]+'</a></li>' } $(".mySearch .historyList").append(tmpHtml); } //去重 function KillRepeat(val){ var kill = 0; for (var i=0;i<searchArr.length;i++){ if(val===searchArr[i]){ kill ++; } } if(kill<1){ searchArr.unshift(val); }else { removeByValue(searchArr, val) searchArr.unshift(val) } }</script></html>后果：

关于elasticsearch:48elasticsearch搜索引擎用Django实现搜索功能

【百度云搜寻，搜各种材料:http://www.lqkweb.com】【搜网盘，搜各种材料:http://www.swpan.cn】【酷站群，搜各种网站源码:http://www.kuzq.cn】Django实现搜寻性能 1、在Django配置搜寻后果页的路由映射 """pachong URL ConfigurationThe `urlpatterns` list routes URLs to views. For more information please see: https://docs.djangoproject.com/en/1.10/topics/http/urls/Examples:Function views 1. Add an import: from my_app import views 2. Add a URL to urlpatterns: url(r'^/pre>, views.home, name='home')Class-based views 1. Add an import: from other_app.views import Home 2. Add a URL to urlpatterns: url(r'^/pre>, Home.as_view(), name='home')Including another URLconf 1. Import the include() function: from django.conf.urls import url, include 2. Add a URL to urlpatterns: url(r'^blog/', include('blog.urls'))"""from django.conf.urls import urlfrom django.contrib import adminfrom app1 import viewsurlpatterns = [ url(r'^admin/', admin.site.urls), url(r'^/pre>, views.indexluoji), url(r'^index/', views.indexluoji), url(r'^suggest//pre>, views.suggestluoji,name="suggest"), # 搜寻字段补全申请 url(r'^search//pre>, views.searchluoji,name="search"), # 搜寻]2、编写逻辑处理函数在逻辑处理函数里实现搜寻数据（1）获取到用户的搜索词（2）利用原生的elasticsearch(搜索引擎)接口，实现搜寻，注明：elasticsearch-dsl就是在原生的elasticsearch上做了封装 Elasticsearch()办法，连贯原生的elasticsearch服务器 search()办法，原生elasticsearch查询方法，反对原生的elasticsearch查问语句，返回的原生语句后果也就是字典模式的数据在查问语句里进行关键词高亮解决将查问到的后果，循环获取到后返回到html页面 from django.shortcuts import render# Create your views here.from django.shortcuts import render,HttpResponsefrom django.views.generic.base import Viewfrom app1.models import lagouType # 导入操作elasticsearch(搜索引擎)类import jsonfrom elasticsearch import Elasticsearch # 导入原生的elasticsearch(搜索引擎)接口client = Elasticsearch(hosts=["127.0.0.1"]) # 连贯原生的elasticsearchdef indexluoji(request): print(request.method) # 获取用户申请的门路 return render(request, 'index.html')def suggestluoji(request): # 搜寻主动补全逻辑解决 key_words = request.GET.get('s', '') # 获取到申请词 re_datas = [] if key_words: s = lagouType.search() # 实例化elasticsearch(搜索引擎)类的search查问 s = s.suggest('my_suggest', key_words, completion={ "field": "suggest", "fuzzy": { "fuzziness": 1 }, "size": 5 }) suggestions = s.execute_suggest() for match in suggestions.my_suggest[0].options: source = match._source re_datas.append(source["title"]) return HttpResponse(json.dumps(re_datas), content_type="application/json")def searchluoji(request): # 搜寻逻辑解决 key_words = request.GET.get('q', '') # 获取到申请词 response = client.search( # 原生的elasticsearch接口的search()办法，就是搜寻，能够反对原生elasticsearch语句查问 index="lagou", # 设置索引名称 doc_type="biao", # 设置表名称 body={ # 书写elasticsearch语句 "query": { "multi_match": { # multi_match查问 "query": key_words, # 查问关键词 "fields": ["title", "description"] # 查问字段 } }, "from": 0, # 从第几条开始获取 "size": 10, # 获取多少条数据 "highlight": { # 查问关键词高亮解决 "pre_tags": ['<span class="keyWord">'], # 高亮开始标签 "post_tags": ['</span>'], # 高亮完结标签 "fields": { # 高亮设置 "title": {}, # 高亮字段 "description": {} # 高亮字段 } } } ) total_nums = response["hits"]["total"] # 获取查问后果的总条数 hit_list = [] # 设置一个列表来贮存搜寻到的信息，返回给html页面 for hit in response["hits"]["hits"]: # 循环查问到的后果 hit_dict = {} # 设置一个字典来贮存循环后果 if "title" in hit["highlight"]: # 判断title字段，如果高亮字段有类容 hit_dict["title"] = "".join(hit["highlight"]["title"]) # 获取高亮里的title else: hit_dict["title"] = hit["_source"]["title"] # 否则获取不是高亮里的title if "description" in hit["highlight"]: # 判断description字段，如果高亮字段有类容 hit_dict["description"] = "".join(hit["highlight"]["description"])[:500] # 获取高亮里的description else: hit_dict["description"] = hit["_source"]["description"] # 否则获取不是高亮里的description hit_dict["url"] = hit["_source"]["url"] # 获取返回url hit_list.append(hit_dict) # 将获取到内容的字典，增加到列表 return render(request, 'result.html', {"all_hits": hit_list, "key_words": key_words}) #显示页面和将列表和搜索词返回到html3、html页面接管搜寻后果留神：因为Django实现了避免恶意代码写入，但凡通过变量传输到html页面的html类型代码，将会被主动转换成字符串形式显示，索引咱们须要在接管变量的字段用：{% autoescape off %} {{ 接管变量 }} {% endautoescape %}，来显示html代码，搜寻后因为进行了一次跳转，所以搜寻框里的搜索词将不存在，咱们须要在传递搜寻后果到页面的时候，将搜索词也传递进来填充到搜索框 <!DOCTYPE html ><html xmlns="http://www.w3.org/1999/xhtml">{#引入动态文件门路#}{% load staticfiles %}<head><meta http-equiv="X-UA-Compatible" content="IE=emulateIE7" /><meta http-equiv="Content-Type" content="text/html; charset=utf-8" /><title>python-lcv-search搜索引擎</title><link href="{% static 'css/style.css'%}" rel="stylesheet" type="text/css" /><link href="{% static 'css/result.css'%}" rel="stylesheet" type="text/css" /></head><body><div id="container"> <div id="hd" class="ue-clear"> <a href="/"><div class="logo"></div></a> <div class="inputArea"> <input type="text" class="searchInput" value="{{ key_words }}"/> <input type="button" class="searchButton" onclick="add_search()"/> </div> </div> <div class="nav"> <ul class="searchList"> <li class="searchItem current" data-type="article">文章</li> <li class="searchItem" data-type="question">问答</li> <li class="searchItem" data-type="job">职位</li> </ul> </div> <div id="bd" class="ue-clear"> <div id="main"> <div class="sideBar"> <div class="subfield">网站</div> <ul class="subfieldContext"> <li> <span class="name">伯乐在线</span> <span class="unit">(None)</span> </li> <li> <span class="name">知乎</span> <span class="unit">(9862)</span> </li> <li> <span class="name">拉勾网</span> <span class="unit">(9862)</span> </li> <li class="more"> <a href="javascript:;"> <span class="text">更多</span> <i class="moreIcon"></i> </a> </li> </ul> <div class="sideBarShowHide"> <a href="javascript:;" class="icon"></a> </div> </div> <div class="resultArea"> <p class="resultTotal"> <span class="info">找到约 <span class="totalResult">45</span> 条后果(用时<span class="time">0.643128</span>秒)，共约<span class="totalPage">5</span>页</span> </p> <div class="resultList"> {% for hit in all_hits %} <div class="resultItem"> <div class="itemHead"> <a href="{% autoescape off %} {{ hit.url }} {% endautoescape %}" target="_blank" class="title">{% autoescape off %} {{ hit.title }} {% endautoescape %}</a> <span class="divsion">-</span> <span class="fileType"> <span class="label">起源：</span> <span class="value">网络</span> </span> <span class="dependValue"> <span class="label">得分：</span> <span class="value">3.401155</span> </span> </div> <div class="itemBody"> {% autoescape off %} {{ hit.description }} {% endautoescape %} </div> </div> {% endfor %} </div>  <div class="pagination ue-clear"></div>  </div> <div class="historyArea"> <div class="hotSearch"> <h6>热门搜寻</h6> <ul class="historyList"> <li><a href="/search?q=linux">linux</a></li> </ul> </div> <div class="mySearch"> <h6>我的搜寻</h6> <ul class="historyList"> </ul> </div> </div> </div> </div></div><div id="foot">Copyright ©projectsedu.com 版权所有 E-mail:admin@projectsedu.com</div></body><script type="text/javascript" src="{% static 'js/jquery.js'%}"></script><script type="text/javascript" src="{% static 'js/global.js'%}"></script><script type="text/javascript" src="{% static 'js/pagination.js'%}"></script><script type="text/javascript"> var search_url = "/search/" $('.searchList').on('click', '.searchItem', function(){ $('.searchList .searchItem').removeClass('current'); $(this).addClass('current'); }); $.each($('.subfieldContext'), function(i, item){ $(this).find('li:gt(2)').hide().end().find('li:last').show(); }); function removeByValue(arr, val) { for(var i=0; i<arr.length; i++) { if(arr[i] == val) { arr.splice(i, 1); break; } } } $('.subfieldContext .more').click(function(e){ var $more = $(this).parent('.subfieldContext').find('.more'); if($more.hasClass('show')){ if($(this).hasClass('define')){ $(this).parent('.subfieldContext').find('.more').removeClass('show').find('.text').text('自定义'); }else{ $(this).parent('.subfieldContext').find('.more').removeClass('show').find('.text').text('更多'); } $(this).parent('.subfieldContext').find('li:gt(2)').hide().end().find('li:last').show(); }else{ $(this).parent('.subfieldContext').find('.more').addClass('show').find('.text').text('收起'); $(this).parent('.subfieldContext').find('li:gt(2)').show(); } }); $('.sideBarShowHide a').click(function(e) { if($('#main').hasClass('sideBarHide')){ $('#main').removeClass('sideBarHide'); $('#container').removeClass('sideBarHide'); }else{ $('#main').addClass('sideBarHide'); $('#container').addClass('sideBarHide'); } }); var key_words = "java" //分页 $(".pagination").pagination(45, { current_page :0, //以后页码 items_per_page :10, display_msg :true, callback :pageselectCallback }); function pageselectCallback(page_id, jq) { window.location.href=search_url+'?q='+key_words+'&p='+page_id } setHeight(); $(window).resize(function(){ setHeight(); }); function setHeight(){ if($('#container').outerHeight() < $(window).height()){ $('#container').height($(window).height()-33); } }</script><script type="text/javascript"> $('.searchList').on('click', '.searchItem', function(){ $('.searchList .searchItem').removeClass('current'); $(this).addClass('current'); }); // 联想下拉显示暗藏 $('.searchInput').on('focus', function(){ $('.dataList').show() }); // 联想下拉点击 $('.dataList').on('click', 'li', function(){ var text = $(this).text(); $('.searchInput').val(text); $('.dataList').hide() }); hideElement($('.dataList'), $('.searchInput'));</script><script> var searchArr; //定义一个search的，判断浏览器有无数据存储（搜寻历史） if(localStorage.search){ //如果有，转换成数组的模式寄存到searchArr的数组里（localStorage以字符串的模式存储，所以要把它转换成数组的模式） searchArr= localStorage.search.split(",") }else{ //如果没有，则定义searchArr为一个空的数组 searchArr = []; } //把存储的数据显示进去作为搜寻历史 MapSearchArr(); function add_search(){ var val = $(".searchInput").val(); if (val.length>=2){ //点击搜寻按钮时，去重 KillRepeat(val); //去重后把数组存储到浏览器localStorage localStorage.search = searchArr; //而后再把搜寻内容显示进去 MapSearchArr(); } window.location.href=search_url+'?q='+val+"&s_type="+$(".searchItem.current").attr('data-type') } function MapSearchArr(){ var tmpHtml = ""; var arrLen = 0 if (searchArr.length > 6){ arrLen = 6 }else { arrLen = searchArr.length } for (var i=0;i<arrLen;i++){ tmpHtml += '<li><a href="/search?q='+searchArr[i]+'">'+searchArr[i]+'</a></li>' } $(".mySearch .historyList").append(tmpHtml); } //去重 function KillRepeat(val){ var kill = 0; for (var i=0;i<searchArr.length;i++){ if(val===searchArr[i]){ kill ++; } } if(kill<1){ searchArr.unshift(val); }else { removeByValue(searchArr, val) searchArr.unshift(val) } }</script></html>最终成果

关于elasticsearch:ElasticSearch-入门

@[toc]松哥前段时间连载的 Spring Security 基本上告一段落了，接下来我会抽空将这个系列的教程整顿成一个系列分发给大家。最近一段时间本人也略微劳动了一下，不写教程的日子尽管能够早早睡觉然而又会感到无聊，得找点事件做，感觉是时候开启一波新的旅程了～ 2018 年国庆节期间 ElasticSearch 母公司上市，那个时候我就想写一个 es 教程，惋惜起初烂尾了，这事在我心里老是一个疙瘩。最近刚好有一个工夫空档，就想着能不能把这个系列给完结了。不同于之前的教程，这次的教程我打算出一个视频版+图文混合版的。视频为主，图文为辅。视频我会上传到百度网盘，文末会有文章对应的视频下载链接。 ElasticSearch 目前也算是十分火了，站内搜索、日志剖析都会用到它，而且还能够间接当成 NoSQL 数据库来应用。接下来，咱们就通过上面这个简略介绍，开启 es 之旅吧～松哥针对本文内容录制了一个视频，如下：视频下载链接：https://pan.baidu.com/s/1bIvt... 提取码: pm94 1.LuceneLucene 是一个开源、收费、高性能、纯 Java 编写的全文检索引擎，能够算作是开源畛域最好的全文检索工具包。在理论开发中，Lucene 简直实用于任何须要全文检索的场景，所以 Lucene 先后倒退出好多语言版本，例如 C++、C#、Python 等。早在 2005 年，Lucene 就降级为 Apache 顶级开源我的项目。它的作者是 Doug Cutting，有的人可能没听过这这个人，不过你必定听过他的另一个赫赫有名的作品 Hadoop。不过须要留神的是，Lucene 只是一个工具包，并非一个残缺的搜索引擎，开发者能够基于 Lucene 来开发残缺的搜索引擎。比拟驰名的有 Solr、ElasticSearch，不过在分布式和大数据环境下，ElasticSearch 更胜一筹。 Lucene 次要有如下特点：简略跨语言弱小的搜索引擎索引速度快索引文件兼容不同平台2.ElasticSearchElasticSearch 是一个分布式、可扩大、近实时性的高性能搜寻与数据分析引擎。ElasticSearch 基于 Java 编写，通过进一步封装 Lucene，将搜寻的复杂性屏蔽起来，开发者只须要一套简略的 RESTful API 就能够操作全文检索。 ElasticSearch 在分布式环境下体现优异，这也是它比拟受欢迎的起因之一。它反对 PB 级别的结构化或非结构化海量数据处理整体上来说，ElasticSearch 有三大性能：数据收集数据分析数据存储ElasticSearch 的次要特点： ...

关于elasticsearch:47elasticsearch搜索引擎用Django实现搜索的自动补全功能

【百度云搜寻，搜各种材料:http://www.lqkweb.com】【搜网盘，搜各种材料:http://www.swpan.cn】 elasticsearch(搜索引擎)提供了主动补全接口官网阐明：https://www.elastic.co/guide/... 1、创立搜寻主动补全字段suggest 主动补全须要用到一个字段名称为suggest类型为Completion类型的一个字段所以咱们须要用将后面的elasticsearch-dsl操作elasticsearch(搜索引擎)减少suggest类型为Completion 留神：因为elasticsearch-dsl源码问题，设置字段为Completion类型指定分词器时会报错，所以咱们须要重写CustomAnalyzer类只有Completion类型才是，其余类型不必，其余类型间接指定分词器即可 #!/usr/bin/env pythonfrom datetime import datetimefrom elasticsearch_dsl import DocType, Date, Nested, Boolean, \ analyzer, InnerObjectWrapper, Completion, Keyword, Text, Integer# 更多字段类型见第三百六十四节elasticsearch(搜索引擎)的mapping映射治理from elasticsearch_dsl.analysis import CustomAnalyzer as _CustomAnalyzer #导入CustomAnalyzer类from elasticsearch_dsl.connections import connections # 导入连贯elasticsearch(搜索引擎)服务器办法connections.create_connection(hosts=['127.0.0.1'])class CustomAnalyzer(_CustomAnalyzer): # 自定义CustomAnalyzer类，来重写CustomAnalyzer类 def get_analysis_definition(self): return {}ik_analyzer = CustomAnalyzer("ik_max_word", filter=["lowercase"]) # 实例化重写的CustomAnalyzer类传入分词器和大小写转，将大写转换成小写class lagouType(DocType): # 自定义一个类来继承DocType类 suggest = Completion(analyzer=ik_analyzer) # Text类型须要分词，所以须要晓得中文分词器，ik_max_wordwei为中文分词器 title = Text(analyzer="ik_max_word") # 设置，字段名称=字段类型，Text为字符串类型并且能够分词建设倒排索引 description = Text(analyzer="ik_max_word") keywords = Text(analyzer="ik_max_word") url = Keyword() # 设置，字段名称=字段类型，Keyword为一般字符串类型，不分词 riqi = Date() # 设置，字段名称=字段类型，Date日期类型 class Meta: # Meta是固定写法 index = "lagou" # 设置索引名称(相当于数据库名称) doc_type = 'biao' # 设置表名称if __name__ == "__main__": # 判断在本代码文件执行才执行外面的办法，其余页面调用的则不执行外面的办法 lagouType.init() # 生成elasticsearch(搜索引擎)的索引，表，字段等信息# 应用办法阐明：# 在要要操作elasticsearch(搜索引擎)的页面，导入此模块# lagou = lagouType() #实例化类# lagou.title = '值' #要写入字段=值# lagou.description = '值'# lagou.keywords = '值'# lagou.url = '值'# lagou.riqi = '值'# lagou.save() #将数据写入elasticsearch(搜索引擎)2、搜寻主动补全字段suggest写入数据搜寻主动补全字段suggest接管的要搜寻的字段分词数据，详情见上面的自定义分词函数 elasticsearch-dsl操作elasticsearch(搜索引擎) #!/usr/bin/env python# -*- coding:utf8 -*-#!/usr/bin/env pythonfrom datetime import datetimefrom elasticsearch_dsl import DocType, Date, Nested, Boolean, \ analyzer, InnerObjectWrapper, Completion, Keyword, Text, Integerfrom elasticsearch_dsl.connections import connections # 导入连贯elasticsearch(搜索引擎)服务器办法# 更多字段类型见第三百六十四节elasticsearch(搜索引擎)的mapping映射治理from elasticsearch_dsl.analysis import CustomAnalyzer as _CustomAnalyzer #导入CustomAnalyzer类connections.create_connection(hosts=['127.0.0.1'])class CustomAnalyzer(_CustomAnalyzer): # 自定义CustomAnalyzer类，来重写CustomAnalyzer类 def get_analysis_definition(self): return {}ik_analyzer = CustomAnalyzer("ik_max_word", filter=["lowercase"]) # 实例化重写的CustomAnalyzer类传入分词器和大小写转，将大写转换成小写class lagouType(DocType): # 自定义一个类来继承DocType类 suggest = Completion(analyzer=ik_analyzer) # Text类型须要分词，所以须要晓得中文分词器，ik_max_wordwei为中文分词器 title = Text(analyzer="ik_max_word") # 设置，字段名称=字段类型，Text为字符串类型并且能够分词建设倒排索引 description = Text(analyzer="ik_max_word") keywords = Text(analyzer="ik_max_word") url = Keyword() # 设置，字段名称=字段类型，Keyword为一般字符串类型，不分词 riqi = Date() # 设置，字段名称=字段类型，Date日期类型 class Meta: # Meta是固定写法 index = "lagou" # 设置索引名称(相当于数据库名称) doc_type = 'biao' # 设置表名称def gen_suggest(index, info_tuple): # 依据字符串生成搜寻倡议数组 """ 此函数次要用于,连贯elasticsearch(搜索引擎)，应用ik_max_word分词器，将传入的字符串进行分词，返回分词后的后果此函数须要两个参数：第一个参数：要调用elasticsearch(搜索引擎)分词的索引index，个别是（索引操作类._doc_type.index）第二个参数：是一个元组，元祖的元素也是元组，元素元祖里有两个值一个是要分词的字符串，第二个是分词的权重，多个分词传多个元祖如下书写格局： gen_suggest(lagouType._doc_type.index, (('字符串', 10),('字符串', 8))) """ es = connections.create_connection(lagouType._doc_type.using) # 连贯elasticsearch(搜索引擎)，应用操作搜索引擎的类上面的_doc_type.using连贯 used_words = set() suggests = [] for text, weight in info_tuple: if text: # 调用es的analyze接口分析字符串， words = es.indices.analyze(index=index, analyzer="ik_max_word", params={'filter':["lowercase"]}, body=text) anylyzed_words = set([r["token"] for r in words["tokens"] if len(r["token"])>1]) new_words = anylyzed_words - used_words else: new_words = set() if new_words: suggests.append({"input":list(new_words), "weight":weight}) # 返回分词后的列表，外面是字典， # 如：[{'input': ['录音', '广告'], 'weight': 10}, {'input': ['新能源', '汽车',], 'weight': 8}] return suggestsif __name__ == "__main__": # 判断在本代码文件执行才执行外面的办法，其余页面调用的则不执行外面的办法 lagouType.init() # 生成elasticsearch(搜索引擎)的索引，表，字段等信息# 应用办法阐明：# 在要要操作elasticsearch(搜索引擎)的页面，导入此模块# lagou = lagouType() #实例化类# lagou.title = '值' #要写入字段=值# lagou.description = '值'# lagou.keywords = '值'# lagou.url = '值'# lagou.riqi = '值'# lagou.save() #将数据写入elasticsearch(搜索引擎)suggest字段写入数据 # -*- coding: utf-8 -*-# Define here the models for your scraped items## See documentation in:# http://doc.scrapy.org/en/latest/topics/items.html# items.py,文件是专门用于，接管爬虫获取到的数据信息的，就相当于是容器文件import scrapyfrom scrapy.loader.processors import MapCompose, TakeFirstfrom scrapy.loader import ItemLoader # 导入ItemLoader类也就加载items容器类填充数据from adc.models.elasticsearch_orm import lagouType, gen_suggest # 导入elasticsearch操作模块class LagouItemLoader(ItemLoader): # 自定义Loader继承ItemLoader类，在爬虫页面调用这个类填充数据到Item类 default_output_processor = TakeFirst() # 默认利用ItemLoader类，加载items容器类填充数据，是列表类型，能够通过TakeFirst()办法，获取到列表里的内容def tianjia(value): # 自定义数据预处理函数 return value # 将解决后的数据返给Itemclass LagouItem(scrapy.Item): # 设置爬虫获取到的信息容器类 title = scrapy.Field( # 接管爬虫获取到的title信息 input_processor=MapCompose(tianjia), # 将数据预处理函数名称传入MapCompose办法里解决，数据预处理函数的形式参数value会主动接管字段title ) description = scrapy.Field() keywords = scrapy.Field() url = scrapy.Field() riqi = scrapy.Field() def save_to_es(self): lagou = lagouType() # 实例化elasticsearch(搜索引擎对象) lagou.title = self['title'] # 字段名称=值 lagou.description = self['description'] lagou.keywords = self['keywords'] lagou.url = self['url'] lagou.riqi = self['riqi'] # 将title和keywords数据传入分词函数，进行分词组合后返回写入搜寻倡议字段suggest lagou.suggest = gen_suggest(lagouType._doc_type.index, ((lagou.title, 10),(lagou.keywords, 8))) lagou.save() # 将数据写入elasticsearch(搜索引擎对象) return写入elasticsearch(搜索引擎)后的状况 { "_index": "lagou", "_type": "biao", "_id": "AV5MDu0NXJs9MkF5tFxW", "_version": 1, "_score": 1, "_source": { "title": "LED光催化灭蚊灯广告录音_广告录音网-火红广告录音_叫卖录音下载_语音广告制作", "keywords": "各类小商品,广告录音,叫卖录音,火红广告录音", "url": "http://www.luyin.org/post/2486.html", "suggest": [ { "input": [ "广告" , "火红" , "制作" , "叫卖" , "灭蚊灯" , "语音" , "下载" , "led" , "录音" , "灭蚊" , "光催化" , "催化" ], "weight": 10 } , { "input": [ "小商品" , "广告" , "各类" , "火红" , "叫卖" , "商品" , "小商" , "录音" ], "weight": 8 } ], "riqi": "2017-09-04T16:43:20", "description": "LED光催化灭蚊灯广告录音是广告录音网-火红广告录音中一篇对于各类小商品的文章，欢迎您浏览和评论,业余叫卖录音-广告录音-语音广告制作" }} 用Django实现搜寻的主动补全性能阐明 1.将搜寻框绑定一个事件，每输出一个字触发这个事件，获取到输入框里的内容，用ajax将输出的词申请到Django的逻辑处理函数。 2.在逻辑处理函数里，将申请词用elasticsearch(搜索引擎)的fuzzy含糊查问，查问suggest字段里存在申请词的数据，将查问到的数据增加到主动补全 html代码： <!DOCTYPE html ><html xmlns="http://www.w3.org/1999/xhtml">{#引入动态文件门路#}{% load staticfiles %}<head><meta http-equiv="X-UA-Compatible" content="IE=emulateIE7" /><meta http-equiv="Content-Type" content="text/html; charset=utf-8" /><title>lcv-search 搜索引擎</title><link href="{% static 'css/style.css'%}" rel="stylesheet" type="text/css" /><link href="{% static 'css/index.css'%}" rel="stylesheet" type="text/css" /></head><body><div id="container"> <div id="bd"> <div id="main"> <h1 class="title"> <div class="logo large"></div> </h1> <div class="nav ue-clear"> <ul class="searchList"> <li class="searchItem current" data-type="article">文章</li> <li class="searchItem" data-type="question">问答</li> <li class="searchItem" data-type="job">职位</li> </ul> </div> <div class="inputArea"> {% csrf_token %} <input type="text" class="searchInput" /> <input type="button" class="searchButton" onclick="add_search()" /> <ul class="dataList"> <li>如何学好设计</li> <li>界面设计</li> <li>UI设计培训要多少钱</li> <li>设计师学习</li> <li>哪里有好的网站</li> </ul> </div> <div class="historyArea"> <p class="history"> <label>热门搜寻：</label> </p> <p class="history mysearch"> <label>我的搜寻：</label> <span class="all-search"> <a href="javascript:;">专一界面设计网站</a> <a href="javascript:;">用户体验</a> <a href="javascript:;">互联网</a> <a href="javascript:;">资费套餐</a> </span> </p> </div> </div> </div> <div class="foot"> <div class="wrap"> <div class="copyright">Copyright ©uimaker.com 版权所有 E-mail:admin@uimaker.com</div> </div> </div></div></body><script type="text/javascript" src="{% static 'js/jquery.js'%}"></script><script type="text/javascript" src="{% static 'js/global.js'%}"></script><script type="text/javascript"> var suggest_url = "/suggest/" var search_url = "/search/" $('.searchList').on('click', '.searchItem', function(){ $('.searchList .searchItem').removeClass('current'); $(this).addClass('current'); }); function removeByValue(arr, val) { for(var i=0; i<arr.length; i++) { if(arr[i] == val) { arr.splice(i, 1); break; } } } // 搜寻倡议 $(function(){ $('.searchInput').bind(' input propertychange ',function(){ var searchText = $(this).val(); var tmpHtml = "" $.ajax({ cache: false, type: 'get', dataType:'json', url:suggest_url+"?s="+searchText+"&s_type="+$(".searchItem.current").attr('data-type'), async: true, success: function(data) { for (var i=0;i<data.length;i++){ tmpHtml += '<li><a href="'+search_url+'?q='+data[i]+'">'+data[i]+'</a></li>' } $(".dataList").html("") $(".dataList").append(tmpHtml); if (data.length == 0){ $('.dataList').hide() }else { $('.dataList').show() } } }); } ); }) hideElement($('.dataList'), $('.searchInput'));</script><script> var searchArr; //定义一个search的，判断浏览器有无数据存储（搜寻历史） if(localStorage.search){ //如果有，转换成数组的模式寄存到searchArr的数组里（localStorage以字符串的模式存储，所以要把它转换成数组的模式） searchArr= localStorage.search.split(",") }else{ //如果没有，则定义searchArr为一个空的数组 searchArr = []; } //把存储的数据显示进去作为搜寻历史 MapSearchArr(); function add_search(){ var val = $(".searchInput").val(); if (val.length>=2){ //点击搜寻按钮时，去重 KillRepeat(val); //去重后把数组存储到浏览器localStorage localStorage.search = searchArr; //而后再把搜寻内容显示进去 MapSearchArr(); } window.location.href=search_url+'?q='+val+"&s_type="+$(".searchItem.current").attr('data-type') } function MapSearchArr(){ var tmpHtml = ""; var arrLen = 0 if (searchArr.length >= 5){ arrLen = 5 }else { arrLen = searchArr.length } for (var i=0;i<arrLen;i++){ tmpHtml += '<a href="'+search_url+'?q='+searchArr[i]+'">'+searchArr[i]+'</a>' } $(".mysearch .all-search").html(tmpHtml); } //去重 function KillRepeat(val){ var kill = 0; for (var i=0;i<searchArr.length;i++){ if(val===searchArr[i]){ kill ++; } } if(kill<1){ searchArr.unshift(val); }else { removeByValue(searchArr, val) searchArr.unshift(val) } }</script></html>Django路由映射 """pachong URL ConfigurationThe `urlpatterns` list routes URLs to views. For more information please see: https://docs.djangoproject.com/en/1.10/topics/http/urls/Examples:Function views 1. Add an import: from my_app import views 2. Add a URL to urlpatterns: url(r'^/pre>, views.home, name='home')Class-based views 1. Add an import: from other_app.views import Home 2. Add a URL to urlpatterns: url(r'^/pre>, Home.as_view(), name='home')Including another URLconf 1. Import the include() function: from django.conf.urls import url, include 2. Add a URL to urlpatterns: url(r'^blog/', include('blog.urls'))"""from django.conf.urls import urlfrom django.contrib import adminfrom app1 import viewsurlpatterns = [ url(r'^admin/', admin.site.urls), url(r'^/pre>, views.indexluoji), url(r'^index/', views.indexluoji), url(r'^suggest//pre>, views.suggestluoji,name="suggest"), # 搜寻字段补全申请]Django动态文件配置 # Static files (CSS, JavaScript, Images)# https://docs.djangoproject.com/en/1.10/howto/static-files/#配置动态文件前缀STATIC_URL = '/static/'#配置动态文件目录STATICFILES_DIRS = [ os.path.join(BASE_DIR, 'static')]备注：搜寻主动补全fuzzy查问 #搜寻主动补全fuzzy查问POST lagou/biao/_search?pretty{ "suggest":{　#字段名称 "my_suggest":{　#自定义变量 "text":"广告",　#搜索词 "completion":{ "field":"suggest",　#搜寻字段 "fuzzy":{ "fuzziness":1　#编辑间隔 } } } }, "_source":"title"}Django逻辑解决文件 from django.shortcuts import render# Create your views here.from django.shortcuts import render,HttpResponsefrom django.views.generic.base import Viewfrom app1.models import lagouType #导入操作elasticsearch(搜索引擎)类import jsondef indexluoji(request): print(request.method) # 获取用户申请的门路 return render(request, 'index.html')def suggestluoji(request): # 搜寻主动补全逻辑解决 key_words = request.GET.get('s', '') # 获取到申请词 re_datas = [] if key_words: s = lagouType.search() # 实例化elasticsearch(搜索引擎)类的search查问 s = s.suggest('my_suggest', key_words, completion={ "field": "suggest", "fuzzy": { "fuzziness": 2 }, "size": 5 }) suggestions = s.execute_suggest() for match in suggestions.my_suggest[0].options: source = match._source re_datas.append(source["title"]) return HttpResponse(json.dumps(re_datas), content_type="application/json") 最终实现

关于elasticsearch:46elasticsearch搜索引擎scrapy写入数据到elasticsearch中

【百度云搜寻，搜各种材料:http://www.lqkweb.com】【搜网盘，搜各种材料:http://www.swpan.cn】后面咱们讲到的elasticsearch(搜索引擎)操作，如：增、删、改、查等操作都是用的elasticsearch的语言命令，就像sql命令一样，当然elasticsearch官网也提供了一个python操作elasticsearch(搜索引擎)的接口包，就像sqlalchemy操作数据库一样的ORM框，这样咱们操作elasticsearch就不必写命令了，用elasticsearch-dsl-py这个模块来操作，也就是用python的形式操作一个类即可 elasticsearch-dsl-py下载下载地址：https://github.com/elastic/el... 文档阐明：http://elasticsearch-dsl.read... 首先装置好elasticsearch-dsl-py模块 1、elasticsearch-dsl模块应用阐明 create_connection(hosts=['127.0.0.1'])：连贯elasticsearch(搜索引擎)服务器办法，能够连贯多台服务器class Meta：设置索引名称和表名称索引类名称.init(): 生成索引和表以及字段实例化索引类.save():将数据写入elasticsearch(搜索引擎) elasticsearch_orm.py 操作elasticsearch(搜索引擎)文件 #!/usr/bin/env python# -*- coding:utf8 -*-from datetime import datetimefrom elasticsearch_dsl import DocType, Date, Nested, Boolean, \ analyzer, InnerObjectWrapper, Completion, Keyword, Text, Integer# 更多字段类型见第三百六十四节elasticsearch(搜索引擎)的mapping映射治理from elasticsearch_dsl.connections import connections # 导入连贯elasticsearch(搜索引擎)服务器办法connections.create_connection(hosts=['127.0.0.1'])class lagouType(DocType): # 自定义一个类来继承DocType类 # Text类型须要分词，所以须要晓得中文分词器，ik_max_wordwei为中文分词器 title = Text(analyzer="ik_max_word") # 设置，字段名称=字段类型，Text为字符串类型并且能够分词建设倒排索引 description = Text(analyzer="ik_max_word") keywords = Text(analyzer="ik_max_word") url = Keyword() # 设置，字段名称=字段类型，Keyword为一般字符串类型，不分词 riqi = Date() # 设置，字段名称=字段类型，Date日期类型 class Meta: # Meta是固定写法 index = "lagou" # 设置索引名称(相当于数据库名称) doc_type = 'biao' # 设置表名称if __name__ == "__main__": # 判断在本代码文件执行才执行外面的办法，其余页面调用的则不执行外面的办法 lagouType.init() # 生成elasticsearch(搜索引擎)的索引，表，字段等信息# 应用办法阐明：# 在要要操作elasticsearch(搜索引擎)的页面，导入此模块# lagou = lagouType() #实例化类# lagou.title = '值' #要写入字段=值# lagou.description = '值'# lagou.keywords = '值'# lagou.url = '值'# lagou.riqi = '值'# lagou.save() #将数据写入elasticsearch(搜索引擎)2、scrapy写入数据到elasticsearch中爬虫文件 # -*- coding: utf-8 -*-import scrapyfrom scrapy.linkextractors import LinkExtractorfrom scrapy.spiders import CrawlSpider, Rulefrom adc.items import LagouItem,LagouItemLoader #导入items容器类,和ItemLoader类import timeclass LagouSpider(CrawlSpider): #创立爬虫类 name = 'lagou' #爬虫名称 allowed_domains = ['www.luyin.org'] #起始域名 start_urls = ['http://www.luyin.org/'] #起始url custom_settings = { "AUTOTHROTTLE_ENABLED": True, #笼罩掉settings.py里的雷同设置，开启COOKIES "DOWNLOAD_DELAY":5 } rules = ( #配置抓取列表页规定 Rule(LinkExtractor(allow=('ggwa/.*')), follow=True), #配置抓取内容页规定 Rule(LinkExtractor(allow=('post/\d+.html.*')), callback='parse_job', follow=True), ) def parse_job(self, response): #回调函数，留神：因为CrawlS模板的源码创立了parse回调函数，所以切记咱们不能创立parse名称的函数 atime = time.localtime(time.time()) #获取零碎以后工夫 dqatime = "{0}-{1}-{2} {3}:{4}:{5}".format( atime.tm_year, atime.tm_mon, atime.tm_mday, atime.tm_hour, atime.tm_min, atime.tm_sec ) # 将格式化工夫日期，独自取出来拼接成一个残缺日期 url = response.url item_loader = LagouItemLoader(LagouItem(), response=response) # 将数据填充进items.py文件的LagouItem item_loader.add_xpath('title', '/html/head/title/text()') item_loader.add_xpath('description', '/html/head/meta[@name="Description"]/@content') item_loader.add_xpath('keywords', '/html/head/meta[@name="keywords"]/@content') item_loader.add_value('url', url) item_loader.add_value('riqi', dqatime) article_item = item_loader.load_item()yield article_itemitems.py文件 # -*- coding: utf-8 -*-# Define here the models for your scraped items## See documentation in:# http://doc.scrapy.org/en/latest/topics/items.html#items.py,文件是专门用于，接管爬虫获取到的数据信息的，就相当于是容器文件import scrapyfrom scrapy.loader.processors import MapCompose,TakeFirstfrom scrapy.loader import ItemLoader #导入ItemLoader类也就加载items容器类填充数据from adc.models.elasticsearch_orm import lagouType #导入elasticsearch操作模块class LagouItemLoader(ItemLoader): #自定义Loader继承ItemLoader类，在爬虫页面调用这个类填充数据到Item类 default_output_processor = TakeFirst() #默认利用ItemLoader类，加载items容器类填充数据，是列表类型，能够通过TakeFirst()办法，获取到列表里的内容def tianjia(value): #自定义数据预处理函数 return value #将解决后的数据返给Itemclass LagouItem(scrapy.Item): #设置爬虫获取到的信息容器类 title = scrapy.Field( #接管爬虫获取到的title信息 input_processor=MapCompose(tianjia), #将数据预处理函数名称传入MapCompose办法里解决，数据预处理函数的形式参数value会主动接管字段title ) description = scrapy.Field() keywords = scrapy.Field() url = scrapy.Field() riqi = scrapy.Field() def save_to_es(self): lagou = lagouType() # 实例化elasticsearch(搜索引擎对象) lagou.title = self['title'] # 字段名称=值 lagou.description = self['description'] lagou.keywords = self['keywords'] lagou.url = self['url'] lagou.riqi = self['riqi'] lagou.save() # 将数据写入elasticsearch(搜索引擎对象) returnpipelines.py文件 # -*- coding: utf-8 -*-# Define your item pipelines here## Don't forget to add your pipeline to the ITEM_PIPELINES setting# See: http://doc.scrapy.org/en/latest/topics/item-pipeline.htmlfrom adc.models.elasticsearch_orm import lagouType #导入elasticsearch操作模块class AdcPipeline(object): def process_item(self, item, spider): #也能够在这里将数据写入elasticsearch搜索引擎，这里的毛病是对立解决 # lagou = lagouType() # lagou.title = item['title'] # lagou.description = item['description'] # lagou.keywords = item['keywords'] # lagou.url = item['url'] # lagou.riqi = item['riqi'] # lagou.save() item.save_to_es() #执行items.py文件的save_to_es办法将数据写入elasticsearch搜索引擎 return itemsettings.py文件，注册pipelines # Configure item pipelines# See http://scrapy.readthedocs.org/en/latest/topics/item-pipeline.htmlITEM_PIPELINES = { 'adc.pipelines.AdcPipeline': 300,}main.py爬虫启动文件 #!/usr/bin/env python# -*- coding:utf8 -*-from scrapy.cmdline import execute #导入执行scrapy命令办法import sysimport ossys.path.append(os.path.join(os.getcwd())) #给Python解释器，增加模块新门路 ,将main.py文件所在目录增加到Python解释器execute(['scrapy', 'crawl', 'lagou', '--nolog']) #执行scrapy命令# execute(['scrapy', 'crawl', 'lagou']) #执行scrapy命令运行爬虫写入elasticsearch(搜索引擎)状况补充：elasticsearch-dsl 的增删改查 #!/usr/bin/env python# -*- coding:utf8 -*-from datetime import datetimefrom elasticsearch_dsl import DocType, Date, Nested, Boolean, \ analyzer, InnerObjectWrapper, Completion, Keyword, Text, Integer# 更多字段类型见第三百六十四节elasticsearch(搜索引擎)的mapping映射治理from elasticsearch_dsl.connections import connections # 导入连贯elasticsearch(搜索引擎)服务器办法connections.create_connection(hosts=['127.0.0.1'])class lagouType(DocType): # 自定义一个类来继承DocType类 # Text类型须要分词，所以须要晓得中文分词器，ik_max_wordwei为中文分词器 title = Text(analyzer="ik_max_word") # 设置，字段名称=字段类型，Text为字符串类型并且能够分词建设倒排索引 description = Text(analyzer="ik_max_word") keywords = Text(analyzer="ik_max_word") url = Keyword() # 设置，字段名称=字段类型，Keyword为一般字符串类型，不分词 riqi = Date() # 设置，字段名称=字段类型，Date日期类型 class Meta: # Meta是固定写法 index = "lagou" # 设置索引名称(相当于数据库名称) doc_type = 'biao' # 设置表名称if __name__ == "__main__": # 判断在本代码文件执行才执行外面的办法，其余页面调用的则不执行外面的办法 lagouType.init() # 生成elasticsearch(搜索引擎)的索引，表，字段等信息# 应用办法阐明：# 在要要操作elasticsearch(搜索引擎)的页面，导入此模块# lagou = lagouType() #实例化类# lagou.title = '值' #要写入字段=值# lagou.description = '值'# lagou.keywords = '值'# lagou.url = '值'# lagou.riqi = '值'# lagou.save() #将数据写入elasticsearch(搜索引擎)1新增数据 from adc.models.elasticsearch_orm import lagouType #导入方才配置的elasticsearch操作模块　lagou = lagouType() # 实例化elasticsearch(搜索引擎对象)　lagou._id = 1　#自定义ID，很重要，当前都是依据ID来操作 lagou.title = self['title'] # 字段名称=值 lagou.description = self['description'] lagou.keywords = self['keywords'] lagou.url = self['url'] lagou.riqi = self['riqi'] lagou.save() # 将数据写入elasticsearch(搜索引擎对象)2删除指定数据 from adc.models.elasticsearch_orm import lagouType #导入方才配置的elasticsearch操作模块sousuo_orm = lagouType() # 实例化sousuo_orm.get(id=1).delete() # 删除id等于1的数据3批改指定的数据 from adc.models.elasticsearch_orm import lagouType #导入方才配置的elasticsearch操作模块sousuo_orm = lagouType() # 实例化sousuo_orm.get(id=1).update(title='123456789') # 批改id等于1的数据以上全副应用elasticsearch-dsl模块留神上面应用的原生elasticsearch模块删除指定应用，就是相当于删除指定数据库应用原生elasticsearch模块删除指定索引 from elasticsearch import Elasticsearch # 导入原生的elasticsearch(搜索引擎)接口client = Elasticsearch(hosts=settings.Elasticsearch_hosts) # 连贯原生的elasticsearch# 应用原生elasticsearch模块删除指定索引#要做容错解决，如果索引不存在会报错 try: client.indices.delete(index='jxiou_zuopin') except Exception as e: pass原生查问 from elasticsearch import Elasticsearch # 导入原生的elasticsearch(搜索引擎)接口 client = Elasticsearch(hosts=Elasticsearch_hosts) # 连贯原生的elasticsearchresponse = client.search( # 原生的elasticsearch接口的search()办法，就是搜寻，能够反对原生elasticsearch语句查问 index="jxiou_zuopin", # 设置索引名称 doc_type="zuopin", # 设置表名称 body={ # 书写elasticsearch语句 "query": { "multi_match": { # multi_match查问 "query": sousuoci, # 查问关键词 "fields": ["title"] # 查问字段 } }, "from": (page - 1) * tiaoshu, # 从第几条开始获取 "size": tiaoshu, # 获取多少条数据 "highlight": { # 查问关键词高亮解决 "pre_tags": ['<span class="gaoliang">'], # 高亮开始标签 "post_tags": ['</span>'], # 高亮完结标签 "fields": { # 高亮设置 "title": {} # 高亮字段 } } } ) # 开始获取数据 total_nums = response["hits"]["total"] # 获取查问后果的总条数 hit_list = [] # 设置一个列表来贮存搜寻到的信息，返回给html页面 for hit in response["hits"]["hits"]: # 循环查问到的后果 hit_dict = {} # 设置一个字典来贮存循环后果 if "title" in hit["highlight"]: # 判断title字段，如果高亮字段有类容 hit_dict["title"] = "".join(hit["highlight"]["title"]) # 获取高亮里的title else: hit_dict["title"] = hit["_source"]["title"] # 否则获取不是高亮里的title hit_dict["id"] = hit["_source"]["nid"] # 获取返回nid # 加密样音地址 hit_dict["yangsrc"] = jia_mi(str(hit["_source"]["yangsrc"])) # 获取返回yangsrc hit_list.append(hit_dict)

关于elasticsearch:elasticsearch笔记002API通用可选参数

[toc] 1. API通用可选参数1.1. 好看、格式化后果数据?pretty=true 格式化为json?format=yaml 后果展现为 yml?human=false 敞开 1h/1kb等人性化转换1.2 响应过滤：filter_path1.2.1 响应过滤用法原来申请： GET /bank/_doc/1原响应： { "_index" : "bank", "_type" : "_doc", "_id" : "1", "_version" : 3, "_seq_no" : 1001, "_primary_term" : 1, "found" : true, "_source" : { "account_number" : 1, "balance" : 39225, "firstname" : "Amber", "lastname" : "Duke", "age" : 32, "gender" : "M", "address" : "880 Holmes Lane", "employer" : "Pyrami", "email" : "amberduke@pyrami.com", "city" : "Brogan", "state" : "IL" }}加上响应过滤：采纳逗号分隔的过滤器列表 ...

关于elasticsearch:45elasticsearch搜索引擎的bool组合查询

【百度云搜寻，搜各种材料:http://www.lqkweb.com】【搜网盘，搜各种材料:http://www.swpan.cn】bool查问阐明 filter:[],字段的过滤，不参加打分must:[],如果有多个查问，都必须满足【并且】should:[],如果有多个查问，满足一个或者多个都匹配【或者】must_not:[],相同查问词一个都不满足的就匹配【取反，非】 # bool查问# 老版本的filtered曾经被bool替换#用 bool 包含 must should must_not filter 来实现#格局如下：#bool:{# "filter":[], 字段的过滤，不参加打分# "must":[], 如果有多个查问，都必须满足【并且】# "should":[], 如果有多个查问，满足一个或者多个都匹配【或者】# "must_not":[], 相同查问词一个都不满足的就匹配【取反，非】#}建设测试数据 #建设测试数据POST jobbole/job/_bulk{"index":{"_id":1}}{"salary":10,"title":"python"}{"index":{"_id":2}}{"salary":20,"title":"Scrapy"}{"index":{"_id":3}}{"salary":30,"title":"Django"}{"index":{"_id":4}}{"salary":40,"title":"Elasticsearch"} bool组合查问——最简略的filter过滤查问之term查问，相当于等于过滤查问到salary字段等于20的数据能够看出执行两个两个步骤，先查到所有数据，而后在查到的所有数据过滤查问到salary字段等于20的数据 # bool查问# 老版本的filtered曾经被bool替换#用 bool 包含 must should must_not filter 来实现#格局如下：#bool:{# "filter":[], 字段的过滤，不参加打分# "must":[], 如果有多个查问，都必须满足# "should":[], 如果有多个查问，满足一个或者多个都匹配# "must_not":[], 相同查问词一个都不满足的就匹配#}#简略过滤查问#最简略的filter过滤查问#如果咱们要查salary字段等于20的数据GET jobbole/job/_search{ "query": { "bool": { #bool组合查问 "must":{ #如果有多个查问词，都必须满足 "match_all":{} #查问所有字段 }, "filter": { #filter过滤 "term": { #term查问，不会将咱们的搜索词进行分词，将搜索词齐全匹配的查问 "salary": 20 #查问salary字段值为20 } } } }}#简略过滤查问#最简略的filter过滤查问#如果咱们要查salary字段等于20的数据GET jobbole/job/_search{ "query": { "bool": { "must":{ "match_all":{} }, "filter": { "term": { "salary": 20 } } } }} bool组合查问——最简略的filter过滤查问之terms查问，相当于或过滤查问到salary字段等于10或20的数据 # bool查问# 老版本的filtered曾经被bool替换#用 bool 包含 must should must_not filter 来实现#格局如下：#bool:{# "filter":[], 字段的过滤，不参加打分# "must":[], 如果有多个查问，都必须满足# "should":[], 如果有多个查问，满足一个或者多个都匹配# "must_not":[], 相同查问词一个都不满足的就匹配#}#简略过滤查问#最简略的filter过滤查问#如果咱们要查salary字段等于20的数据#过滤salary字段值为10或者20的数据GET jobbole/job/_search{ "query": { "bool": { "must":{ "match_all":{} }, "filter": { "terms": { "salary":[10,20] } } } }}留神：filter过滤里也能够用其余根本查问的 _analyze测试查看分词器解析的后果analyzer设置分词器类型ik_max_word精细化分词，ik_smart非精细化分词text设置词 #_analyze测试查看分词器解析的后果#analyzer设置分词器类型ik_max_word精细化分词，ik_smart非精细化分词#text设置词GET _analyze{ "analyzer": "ik_max_word", "text": "Python网络开发工程师"}GET _analyze{ "analyzer": "ik_smart", "text": "Python网络开发工程师"} bool组合查问——组合简单查问1查问salary字段等于20或者title字段等于python、salary字段不等于30、并且salary字段不等于10的数据 # bool查问# 老版本的filtered曾经被bool替换#用 bool 包含 must should must_not filter 来实现#格局如下：#bool:{# "filter":[], 字段的过滤，不参加打分# "must":[], 如果有多个查问，都必须满足【并且】# "should":[], 如果有多个查问，满足一个或者多个都匹配【或者】# "must_not":[], 相同查问词一个都不满足的就匹配【取反，非】#}# 查问salary字段等于20或者title字段等于python、salary字段不等于30、并且salary字段不等于10的数据GET jobbole/job/_search{ "query": { "bool": { "should": [ {"term":{"salary":20}}, {"term":{"title":"python"}} ], "must_not": [ {"term": {"salary":30}}, {"term": {"salary":10}}] } }}bool组合查问——组合简单查问2查问salary字段等于20或者title字段等于python、salary字段不等于30、并且salary字段不等于10的数据 # bool查问# 老版本的filtered曾经被bool替换#用 bool 包含 must should must_not filter 来实现#格局如下：#bool:{# "filter":[], 字段的过滤，不参加打分# "must":[], 如果有多个查问，都必须满足【并且】# "should":[], 如果有多个查问，满足一个或者多个都匹配【或者】# "must_not":[], 相同查问词一个都不满足的就匹配【取反，非】#}# 查问title字段等于python、或者、(title字段等于elasticsearch并且salary等于30)的数据GET jobbole/job/_search{ "query": { "bool": { "should":[ {"term":{"title":"python"}}, {"bool": { "must": [ {"term": {"title":"elasticsearch"}}, {"term":{"salary":30}} ] }} ] } }}bool组合查问——过滤空和非空 #建设数据POST bbole/jo/_bulk{"index":{"_id":"1"}}{"tags":["search"]}{"index":{"_id":"2"}}{"tags":["search","python"]}{"index":{"_id":"3"}}{"other_field":["some data"]}{"index":{"_id":"4"}}{"tags":null}{"index":{"_id":"1"}}{"tags":["search",null]}解决null空值的办法获取tags字段，值不为空并且值不为null的数据 # bool查问# 老版本的filtered曾经被bool替换#用 bool 包含 must should must_not filter 来实现#格局如下：#bool:{# "filter":[], 字段的过滤，不参加打分# "must":[], 如果有多个查问，都必须满足【并且】# "should":[], 如果有多个查问，满足一个或者多个都匹配【或者】# "must_not":[], 相同查问词一个都不满足的就匹配【取反，非】#}#解决null空值的办法#获取tags字段，值不为空并且值不为null的数据GET bbole/jo/_search{ "query": { "bool": { "filter": { "exists": { "field": "tags" } } } }}获取tags字段值为空或者为null的数据，如果数据没有tags字段也会获取 # bool查问# 老版本的filtered曾经被bool替换#用 bool 包含 must should must_not filter 来实现#格局如下：#bool:{# "filter":[], 字段的过滤，不参加打分# "must":[], 如果有多个查问，都必须满足【并且】# "should":[], 如果有多个查问，满足一个或者多个都匹配【或者】# "must_not":[], 相同查问词一个都不满足的就匹配【取反，非】#}#获取tags字段值为空或者为null的数据，如果数据没有tags字段也会获取GET bbole/jo/_search{ "query": { "bool": { "must_not": { "exists": { "field": "tags" } } } }}

关于elasticsearch:简单处理-Elasticsearch-terms-聚合不精确问题qbit

问题形容Elasticsearch 聚合数据后果不准确，怎么破？解决方案调大 shard_size调大 search.max_bucketsPUT _cluster/settings{ "transient": { "search.max_buckets": 1000000 }}本文出自 qbit snap

关于elasticsearch:44elasticsearch搜索引擎的基本查询

【百度云搜寻，搜各种材料:http://www.lqkweb.com】【搜网盘，搜各种材料:http://www.swpan.cn】1、elasticsearch(搜索引擎)的查问 elasticsearch是性能十分弱小的搜索引擎，应用它的目标就是为了疾速的查问到须要的数据查问分类：　根本查问：应用elasticsearch内置的查问条件进行查问　组合查问：把多个查问条件组合在一起进行复合查问　过滤：查问同时，通过filter条件在不影响打分的状况下筛选数据 2、elasticsearch(搜索引擎)创立数据首先咱们先创立索引、表、以及字段属性、字段类型、增加好数据留神：个别咱们中文应用ik_max_word中文分词解析器，所有在须要分词建设倒牌索引的字段都要指定，ik_max_word中文分词解析器零碎默认不是ik_max_word中文分词解析器 ik_max_word中文分词解析器是elasticsearch(搜索引擎)的一个插件，在elasticsearch装置目录的plugins/analysis-ik文件夹里，版本为5.1.1 更多阐明：https://github.com/medcl/elas... 阐明： #创立索引(设置字段类型)#留神：个别咱们中文应用ik_max_word中文分词解析器，所有在须要分词建设倒牌索引的字段都要指定，ik_max_word中文分词解析器#零碎默认不是ik_max_word中文分词解析器PUT jobbole #创立索引设置索引名称{ "mappings": { #设置mappings映射字段类型 "job": { #表名称 "properties": { #设置字段类型 "title":{ #表名称 "store": true, #字段属性true示意保留数据 "type": "text", #text类型，text类型能够分词，建设倒排索引 "analyzer": "ik_max_word" #设置分词解析器，ik_max_word是一个中文分词解析器插件 }, "company_name":{ #字段名称 "store": true, #字段属性true示意保留数据 "type": "keyword" #keyword一般字符串类型，不分词 }, "desc":{ #字段名称 "type": "text" #text类型，text类型能够分词，然而没有设置分词解析器，应用零碎默认 }, "comments":{ #字段名称 "type": "integer" #integer数字类型 }, "add_time":{ #字段名称 "type": "date", #date工夫类型 "format":"yyyy-MM-dd" #yyyy-MM-dd工夫格式化 } } } }}#保存文档(相当于数据库的写入数据)POST jobbole/job{ "title":"python django 开发工程师", #字段名称：值 "company_name":"美团科技有限公司", #字段名称：值 "desc":"对django的概念相熟，相熟python基础知识", #字段名称：值 "comments":20, #字段名称：值 "add_time":"2017-4-1" #字段名称：值}POST jobbole/job{ "title":"python scrapy redis 分布式爬虫根底", "company_name":"玉秀科技有限公司", "desc":"对scrapy的概念相熟，相熟redis基础知识", "comments":5, "add_time":"2017-4-2"}POST jobbole/job{ "title":"elasticsearch打造搜索引擎", "company_name":"通信科技有限公司", "desc":"对elasticsearch的概念相熟", "comments":10, "add_time":"2017-4-3"}POST jobbole/job{ "title":"pyhhon打造举荐引擎零碎", "company_name":"智能科技有限公司", "desc":"相熟举荐引擎零碎算法", "comments":60, "add_time":"2017-4-4"} 通过下面能够看到咱们创立了索引并且设置好了字段的属性、类型、以及分词解析器，创立了4条数据 3、elasticsearch(搜索引擎)根本查问 match查问【用的最多】会将咱们的搜索词在以后字段设置的分词器进行分词，到以后字段查找，匹配度越高排名靠前，如果搜索词是大写字母会自动转换成小写 #match查问#会将咱们的搜索词进行分词，到指定字段查找，匹配度越高排名靠前GET jobbole/job/_search{ "query": { "match": { "title": "搜索引擎" } }} term查问不会将咱们的搜索词进行分词，将搜索词齐全匹配的查问 term查问#不会将咱们的搜索词进行分词，将搜索词齐全匹配的查问GET jobbole/job/_search{ "query": { "term": { "title":"搜索引擎" } }} terms查问传递一个数组，将数组里的词别离匹配 #terms查问#传递一个数组，将数组里的词别离匹配GET jobbole/job/_search{ "query": { "terms": { "title":["工程师","django","零碎"] } }}管制查问的返回数量　from从第几条数据开始　size获取几条数据 #管制查问的返回数量#from从第几条数据开始#size获取几条数据 GET jobbole/job/_search{ "query": { "match": { "title": "搜索引擎" } }, "from": 0, "size": 3}match_all查问,查问所有数据 #match_all查问,查问所有数据GET jobbole/job/_search{ "query": { "match_all": {} }}match_phrase查问短语查问短语查问，会将搜索词分词，放进一个列表如[python,开发]而后搜寻的字段必须满足列表里的所有元素，才合乎slop是设置分词后[python,开发]python 与开发，之间隔着多少个字符算匹配距离字符数小于slop设置算匹配到，距离字符数大于slop设置不匹配 #match_phrase查问#短语查问#短语查问，会将搜索词分词，放进一个列表如[python,开发]#而后搜寻的字段必须满足列表里的所有元素，才合乎#slop是设置分词后[python,开发]python 与开发，之间隔着多少个字符算匹配#距离字符数小于slop设置算匹配到，距离字符数大于slop设置不匹配GET jobbole/job/_search{ "query": { "match_phrase": { "title": { "query": "elasticsearch引擎", "slop":3 } } }}multi_match查问比方能够指定多个字段比方查问title字段和desc字段外面蕴含python的关键词数据query设置搜索词fields要搜寻的字段title^3示意权重，示意title里合乎的关键词权重，是其余字段里合乎的关键词权重的3倍 #multi_match查问#比方能够指定多个字段#比方查问title字段和desc字段外面蕴含python的关键词数据#query设置搜索词#fields要搜寻的字段#title^3示意权重，示意title里合乎的关键词权重，是其余字段里合乎的关键词权重的3倍GET jobbole/job/_search{ "query": { "multi_match": { "query": "搜索引擎", "fields": ["title^3","desc"] } }} stored_fields设置搜寻后果只显示哪些字段留神：应用stored_fields要显示的字段store属性必须为true，如果要显示的字段没有设置store属性那么默认为false，如果为false将不会显示该字段 #stored_fields设置搜寻后果只显示哪些字段GET jobbole/job/_search{ "stored_fields": ["title","company_name"], "query": { "multi_match": { "query": "搜索引擎", "fields": ["title^3","desc"] } }} 通过sort搜寻后果排序留神：排序的字段必须是数字或者日期desc升序asc降序 #通过sort搜寻后果排序#留神：排序的字段必须是数字或者日期#desc升序#asc降序GET jobbole/job/_search{ "query": { "match_all": {} }, "sort": [{ "comments": { "order": "asc" } }]}range字段值范畴查问查问一个字段的值范畴留神：字段值必须是数字或者工夫gte大于等于ge大于lte小于等于lt小于boost是权重，能够给指定字段设置一个权重 #range字段值范畴查问#查问一个字段的值范畴#留神：字段值必须是数字或者工夫#gte大于等于#ge大于#lte小于等于#lt小于#boost是权重，能够给指定字段设置一个权重GET jobbole/job/_search{ "query": { "range": { "comments": { "gte": 10, "lte": 20, "boost": 2.0 } } }}range字段值为工夫范畴查问 #range字段值为工夫范畴查问#查问一个字段的工夫值范畴#留神：字段值必须是工夫#gte大于等于#ge大于#lte小于等于#lt小于#now为以后工夫GET jobbole/job/_search{ "query": { "range": { "add_time": { "gte": "2017-4-1", "lte": "now" } } }}wildcard查问，通配符查问*代表一个或者多个任意字符 #wildcard查问，通配符查问#*代表一个或者多个任意字符GET jobbole/job/_search{ "query": { "wildcard": { "title": { "value": "py*n", "boost": 2 } } }}fuzzy含糊查问 #fuzzy含糊搜寻#搜寻蕴含词的内容GET lagou/biao/_search{ "query": { "fuzzy": {"title": "广告"} }, "_source": ["title"]}#fuzziness设置编辑间隔,编辑间隔就是把要查找的字段值，编辑成查找的关键词须要编辑多少个步骤（插入、删除、替换）#prefix_length为关键词后面不参加变换的长度GET lagou/biao/_search{ "query": { "fuzzy": { "title": { "value": "广告录音", "fuzziness": 2, "prefix_length": 2 } } }, "_source": ["title"]}

关于elasticsearch:esrally-离线测试qbit

测试环境OS: Ubuntu 20.04.1 LTS x86_64Python: 3.8.5esrally: 2.0.2OpenJdk: 1.8.0_275git: 2.25.1装置pip3 装置pip3 install esrally查看版本$ esrally --versionesrally 2.0.2呈现以下界面即装置胜利esrally --version 下载测试数据集官网我的项目地址 https://github.com/elastic/ra...从/home/qbit/.rally/benchmarks/tracks/default/download.sh）中能够看到测试数据集寄存在 AWS 的 http://benchmarks.elasticsear... 门路下。下面的目录并不能间接拜访，咱们须要钻研外面的文件门路。查看有哪些默认数据集ll /home/qbit/.rally/benchmarks/tracks/default 以 geonames 为例，咱们在 /home/qbit/.rally/benchmarks/tracks/default/geonames/files.txt 文件中能够看到documents-2.json.bz2documents-2-1k.json.bz2能够拼接出以下 urlhttp://benchmarks.elasticsear...http://benchmarks.elasticsear... 下载文件并上传到 /home/qbit/.rally/benchmarks/data/geonames 目录本文出自 qbit snap

关于elasticsearch:41elasticsearch搜索引擎基本的索引和文档CRUD操作增删改查

【百度云搜寻，搜各种材料:http://www.lqkweb.com】【搜网盘，搜各种材料:http://www.swpan.cn】elasticsearch(搜索引擎)根本的索引和文档CRUD操作也就是根本的索引和文档、增、删、改、查、操作** 留神：以下操作都是在kibana里操作的 elasticsearch(搜索引擎)都是基于http办法来操作的 GET 申请指定的页面信息，并且返回实体主体 POST 向指定资源提交数据进行解决申请，数据被蕴含在申请体中，POST申请可能会导致新的资源的建设和/或已有资源的批改 PUT 向服务器传送的数据取代指定的文档的内容 DELETE 申请服务器删除指定的页面 1、索引初始化，相当于创立一个数据库用kibana创立代码阐明 # 初始化索引(也就是创立数据库)# PUT 索引名称"""PUT jobbole #设置索引名称{ "settings": { #设置 "index": { #索引 "number_of_shards":5, #设置分片数 "number_of_replicas":1 #设置正本数 } }}"""代码 # 初始化索引(也就是创立数据库)# PUT 索引名称PUT jobbole { "settings": { "index": { "number_of_shards":5, "number_of_replicas":1 } }} 咱们也能够应用可视化依据创立索引留神：索引一旦创立，分片数量不可批改，正本数量能够批改的 2、获取索引的settings(设置信息) GET 索引名称/_settings 获取指定索引的settings(设置信息)** # 初始化索引(也就是创立数据库)# PUT 索引名称PUT jobbole { "settings": { "index": { "number_of_shards":5, "number_of_replicas":1 } }}#获取指定索引的settings(设置信息)GET jobbole/_settings GET _all/_settings　获取所有索引的settings(设置信息) # 初始化索引(也就是创立数据库)# PUT 索引名称PUT jobbole { "settings": { "index": { "number_of_shards":5, "number_of_replicas":1 } }}#获取索引的settings(设置信息)#GET jobbole/_settings#获取所有索引的settings(设置信息)GET _all/_settings GET .索引名称,索引名称/_settings 获取多个索引的settings(设置信息) # 初始化索引(也就是创立数据库)# PUT 索引名称PUT jobbole { "settings": { "index": { "number_of_shards":5, "number_of_replicas":1 } }}#获取索引的settings(设置信息)#GET jobbole/_settings#获取所有索引的settings(设置信息)#GET _all/_settingsGET .kibana,jobbole/_settings 3、更新索引的settings(设置信息) PUT 索引名称/_settings 更新指定索引的设置信息 # 初始化索引(也就是创立数据库)# PUT 索引名称PUT jobbole { "settings": { "index": { "number_of_shards":5, "number_of_replicas":1 } }}#更新指定索引的settings(设置信息)PUT jobbole/_settings{ "number_of_replicas":2}#获取索引的settings(设置信息)GET jobbole/_settings 4、获取索引的(索引信息) GET _all 获取所有索引的索引信息 # 初始化索引(也就是创立数据库)# PUT 索引名称PUT jobbole { "settings": { "index": { "number_of_shards":5, "number_of_replicas":1 } }}#获取索引的settings(设置信息)#GET jobbole/_settingsGET _all GET 索引名称获取指定的索引信息 # 初始化索引(也就是创立数据库)# PUT 索引名称PUT jobbole { "settings": { "index": { "number_of_shards":5, "number_of_replicas":1 } }}#获取索引的settings(设置信息)#GET jobbole/_settings#GET _allGET jobbole 5、保存文档(相当于数据库的写入数据) PUT index(索引名称)/type(相当于表名称)/1(相当于id){字段：值} 保存文档自定义id(相当于数据库的写入数据)** #保存文档(相当于数据库的写入数据)PUT jobbole/job/1{ "title":"python分布式爬虫开发", "salary_min":15000, "city":"北京", "company":{ "name":"百度", "company_addr":"北京市软件园" }, "publish_date":"2017-4-16", "comments":15} 可视化查看 POST index(索引名称)/type(相当于表名称)/{字段：值} 保存文档主动生成id(相当于数据库的写入数据) 留神：主动生成id须要用POST办法** #保存文档(相当于数据库的写入数据)POST jobbole/job{ "title":"html开发", "salary_min":15000, "city":"上海", "company":{ "name":"微软", "company_addr":"上海市软件园" }, "publish_date":"2017-4-16", "comments":15} 6、获取文档(相当于查问数据) GET 索引名称/表名称/id 获取指定的文档所有信息 #获取文档(相当于查问数据)GET jobbole/job/1 GET 索引名称/表名称/id?_source 获取指定文档的所有字段 GET 索引名称/表名称/id?_source=字段名称,字段名称,字段名称获取指定文档的多个指定字段 GET 索引名称/表名称/id?_source=字段名称获取指定文档的一个指定字段 ...

关于elasticsearch:40elasticsearch搜索引擎倒排索引

【百度云搜寻，搜各种材料:http://www.lqkweb.com】【搜网盘，搜各种材料:http://www.swpan.cn】倒排索引倒排索引源于理论利用中须要依据属性的值来查找记录。这种索引表中的每一项都包含一个属性值和具备该属性值的各记录的地址。因为不是由记录来确定属性值，而是由属性值来确定记录的地位，因此称为倒排索引(inverted index)。带有倒排索引的文件咱们称为倒排索引文件，简称倒排文件(inverted file)。倒排索引原理就是将一句话进行分词并记录分词所存在的文章，当用户搜索词时能够间接查找到以后词所存在的文章倒排索引分词权重记录(词瓶) 分词权重记录，是通过(TF-IDF)来实现的，详情https://baike.so.com/doc/4336... 倒排索引待解决的问题这些问题elasticsearch(搜索引擎)曾经解决

关于elasticsearch:39elasticsearch搜索引擎的基本概念

【百度云搜寻，搜各种材料:http://www.lqkweb.com】【搜网盘，搜各种材料:http://www.swpan.cn】elasticsearch的基本概念 1、集群：一个或者多个节点组织在一起 2、节点：一个节点是集群中的一个服务器，由一个名字来标识，默认是一个随机的漫微角色的名字 3、分片：将索引(相当于数据库)划分为多份的能力，容许程度宰割和扩大，对个分片响应申请，提供性能和吞吐量 3、正本：创立分片的一份或者多份的能力(相当于备份),在一个节点失败其余节点能够顶上 elasticsearch的数据存储概念 1、index(索引，能够了解为数据库) 2、type(类型，能够了解为数据库表) 3、documents(文档，能够了解为数据库表的行) 4、fields(能够了解为数据库表的列) http办法 GET 申请指定的页面信息，并且返回实体主体 POST 向指定资源提交数据进行解决申请，数据被蕴含在申请体中，POST申请可能会导致新的资源的建设和/或已有资源的批改 PUT 向服务器传送的数据取代指定的文档的内容 DELETE 申请服务器删除指定的页面

关于elasticsearch:38elasticsearch搜索引擎介绍以及安装

【百度云搜寻，搜各种材料:http://bdy.lqkweb.com】【搜网盘，搜各种材料:http://www.swpan.cn】elasticsearch(搜索引擎)介绍 ElasticSearch是一个基于Lucene的搜寻服务器。它提供了一个分布式多用户能力的全文搜索引擎，基于RESTful web接口。Elasticsearch是用Java开发的，并作为Apache许可条款下的开放源码公布，是第二最风行的企业搜索引擎。设计用于云计算中，可能达到实时搜寻，稳固，牢靠，疾速，装置使用方便。咱们建设一个网站或应用程序，并要增加搜寻性能，令咱们受打击的是:搜寻工作是很难的。咱们心愿咱们的搜寻解决方案要快，咱们心愿有一个零配置和一个完全免费的搜寻模式，咱们心愿可能简略地应用JSON通过HTTP的索引数据，咱们心愿咱们的搜寻服务器始终可用，咱们心愿可能一台开始并扩大到数百，咱们要实时搜寻，咱们要简略的多租户，咱们心愿建设一个云的解决方案。Elasticsearch旨在解决所有这些问题和更多的问题。全文搜索引擎品种 1、elasticsearch 2、solr 3、sphinx 关系数据搜素毛病，也就是间接通过数据库搜寻 elasticsearch(搜索引擎)都能补救以上毛病 elasticsearch装置 1、elasticsearch是由Java开发的，所以首先要装置Java环境留神：elasticsearch所须要的Java环境必须大于或者等于1.8版本下载地址：http://www.oracle.com/technet... 咱们下载Windows x64版本，jdk-8u144-windows-x64.exe文件，间接装置装置好后，咱们cmd命令输出：java -version 查看java版本 2、elasticsearch-rtf装置下载地址：https://github.com/medcl/elas... 集成了咱们很多插件运行零碎可用内存>2G　以下是集成装置的官网插件，个别插件须要配置能力应用，可依据须要删除 plugins 目录无关的插件，重启 elasticsearch 失效。 bin/elasticsearch-plugin install discovery-multicastbin/elasticsearch-plugin install analysis-icubin/elasticsearch-plugin install analysis-kuromojibin/elasticsearch-plugin install analysis-phoneticbin/elasticsearch-plugin install analysis-smartcnbin/elasticsearch-plugin install analysis-stempelbin/elasticsearch-plugin install analysis-ukrainianbin/elasticsearch-plugin install discovery-filebin/elasticsearch-plugin install ingest-attachmentbin/elasticsearch-plugin install ingest-geoipbin/elasticsearch-plugin install ingest-user-agentbin/elasticsearch-plugin install mapper-attachmentsbin/elasticsearch-plugin install mapper-sizebin/elasticsearch-plugin install mapper-murmur3bin/elasticsearch-plugin install lang-javascriptbin/elasticsearch-plugin install lang-pythonbin/elasticsearch-plugin install repository-hdfsbin/elasticsearch-plugin install repository-s3bin/elasticsearch-plugin install repository-azurebin/elasticsearch-plugin install repository-gcsbin/elasticsearch-plugin install store-smbbin/elasticsearch-plugin install discovery-ec2bin/elasticsearch-plugin install discovery-azure-classicbin/elasticsearch-plugin install discovery-gce elasticsearch-rtf下载好解压后将文件夹复制到一个目录会失去以下文件双击进入bin文件夹里，按shlft+鼠标右键，在此处关上命令窗口，输出 elasticsearch.bat 回车运行而后在浏览器输出http://127.0.0.1:9200/ 返回数据阐明胜利 3、装置elasticsearch-rtf(搜索引擎)的可视化管理工具elasticsearch-head 留神：(搜索引擎)的可视化管理工具elasticsearch-head，的装置要用到node.js的npm 插件管理器所以要先装置node.js的npm 插件管理器下载地址：https://nodejs.org/en/download/ 咱们下载windows版本即可，下载后装置即可装置后cdm命令：npm 如下显示示意装置胜利 ...

关于elasticsearch:elasticsearch的开发应用

平时我的项目开发中，常常会遇到含糊搜寻的需要。通常当须要含糊搜寻的数据库字段不大，咱们能够简略通过字段名 like '%搜寻值%'实现，搜寻效率不高，而且就算加索引也无奈失效。对于数据库字段很大的，mysql还提供全文索引，开销也很大。有没有一种专门做搜寻的“数据库”呢？不仅能够实现高效的含糊搜寻，而且还能像百度、谷歌这类搜索引擎一样，从我输出的一段文字中，自动识别关键词进行搜寻。上面介绍的elasticsearch就是这方面的里手。 1. 简介全文搜寻属于最常见的需要，开源的 Elasticsearch是目前全文搜索引擎的首选。它能够疾速地贮存、搜寻和剖析海量数据。维基百科、Stack Overflow、Github 都采纳它。Elasticsearch 的底层是开源库 Lucene。然而，你没法间接用 Lucene，必须本人写代码去调用它的接口。Elasticsearch 是 Lucene 的封装，提供了 REST API 的操作接口，开箱即用。 index 索引elasticsearch 数据管理的顶层单位叫做 Index（索引）。它是单个数据库的同义词。每个 Index （即数据库）的名字必须是小写。上面的命令能够查看以后节点的所有 Index。 curl -X GET 'http://localhost:9200/_cat/indices?v'document 文档Index 外面单条的记录称为 Document（文档）。许多条 Document 形成了一个 Index，Document 应用 JSON 格局示意。同一个 Index 外面的 Document，不要求有雷同的构造（scheme），然而最好放弃雷同，这样有利于进步搜寻效率。 type (已移除)type 是之前存在的概念，elasticsearch 7.x 就不在应用。Document 能够分组，比方weather这个 Index 外面，能够按城市分组（北京和上海），这种分组就叫做 Type，它是虚构的逻辑分组，用来过滤 Document。然而不同的分组中，Document 的数据结构该当尽量保持一致，否则会影响搜寻效率，type的定位就很鸡肋。因而elasticsearch就间接做强制限度，在6.X 版本中，一个index下只能存在一个type；在 7.X 版本中，间接去除了 type 的概念，就是说 index 不再会有 type。从前的那些写法，能够间接用index下的_doc代替。倒排索引什么是倒排索引: 倒排索引也叫反向索引，艰深来讲正向索引是通过key找value，反向索引则是通过value找key。Elasticsearch 应用一种称为倒排索引的构造，它实用于疾速的全文搜寻。一个倒排索引由文档中所有不反复词的列表形成，对于其中每个词，有一个蕴含它的文档列表。倒排索引建设的是分词（Term）和文档（Document）之间的映射关系，在倒排索引中，数据是面向词（Term）而不是面向文档的。 ...

关于elasticsearch:elasticsearchanalysishao可能是东半球最好用的中文分词器

首先上地址elasticsearch-analysis-hao HAO ES 分词器简介如何开发一个ES分词插件请参考这里次要参考了 IK 和 HanLP其中有的源码是间接搬运的。相比IK，比IK更智能，更精确，更快。相比HanLp，比HanLP更轻量，分词更可控，没有一些智能的预测性能，并且HanLP也没有官网的ES插件。次要是IK ik_max_word是穷举所有可能词，导致搜寻一些不相干的也会被搜到。任性激动过分词后果竟然有任性性冲动动过,那么搜性冲动就会把这个doc搜寻到。南京市长江大桥，后果是南京市市长长江大桥，那么搜市长会把这个doc搜寻到。把HanLP的 DijkstraSegment抄了过去，同时做了一些优化。依据词频计算最短路，穷举出可能的词，而不是所有的词，如果穷举的词不对，能够调词频来纠正。反对emoji。反对元词，比方俄罗斯不会再拆分成俄和罗斯（罗斯是罕用人名）。这样搜罗斯就不会把俄罗斯相干文档召回不反对词性提供 Analyzer: hao_search_mode, hao_index_modeTokenizer: hao_search_mode, hao_index_mode VersionsGit tagES versionmasterES最新稳定版v7.7.17.7.1vX.Y.ZX.Y.Z应用装置形式1. bin/elasticsearch-plugin install file:///Users/xiaoming/Download/analysis-hao.zip 形式2. 解压后，放在es plugins目录即可。最初重启ES ES 版本升级如果没有你须要的对应ES版本，批改pom.xml->elasticsearch.version的值为对应版本，而后执行mvn clean package -Dmaven.test.skip=true，就能够失去插件的zip安装包。自定义分词器上面是自定义分词器可用的配置项配置项参数性能默认值enableIndexMode是否应用index模式，index模式为细颗粒度。hao_search_mode为false，hao_index_mode为true,细颗粒度适宜Term Query,粗颗粒度适宜Phrase查问enableFallBack如果分词报错，是否启动最细粒度分词，即按字分。倡议search_mode应用，不至于影响用户搜寻。index_mode不启动，以便及时报错告警告诉。false不启动降级enableFailDingMsg是否启动失败钉钉告诉,告诉地址为HttpAnalyzer.cfg.xml的dingWebHookUrl字段。falseenableSingleWord是否应用细粒度返回的单字。比方体力值，分词后果只存体力值,膂力,而不存值falseHaoAnalyzer.cfg.xml 配置参数性能备注baseDictionary根底词库文件名放在插件config目录或者es的config目录，不必更改customerDictionaryFile用户自定义近程词库文件会存储在插件config目录或者es的config目录remoteFreqDict近程用户自定义词库文件不便热更新，热更新通过上面两个参数定时更新。syncDicTim近程词库第一次同步工夫 hh:mm:ss-syncDicPeriodTime近程词库同步工夫距离,秒比方 syncDicTime=20:00:00,syncDicPeriodTime=86400，则是每天20点同步dingWebHookUrl钉钉机器人url用于分词异样，同步词库异样/胜利告诉 dingMsgContent机器人告诉文案留神配置钉钉机器人的时候关键词要和这个文案匹配，不然会音讯发送失败词库阐明优先读取 {ES_HOME}/config/analysis-hao/目录，没有读取 {ES_HOME}/plugins/analysis-hao/config目录下的文件根底词库根底词库是base_dictionary.json,是一个json文件，key为词，value为词频（int)。是能够批改的，能够增加词，能够批改词频。例如：奋发图强分词后果是奋, 发图, 强, 是因为发图这个词的词频太高了（因为呈现次数高），则能够升高词频，手动批改base_dictionary.json文件就好了。近程词库用户自定义词库会依照配置的工夫和周期定期执行。从近程词库更新实现后会主动笼罩当初的customerDictionaryFile。近程词库的文件格式每行格局为 {词},{词频},{是否元词}, 例如俄罗斯,1000,1。是否元词字段解释：1代表是元词，不会再细拆分，俄罗斯不会再拆分成俄和罗斯（罗斯是罕用人名）。这样搜罗斯就不会把俄罗斯相干文档召回。0就是能够持续细拆分，比方奋发图强示例索引demo建索引： PUT test/{ "settings": { "index": { "analysis": { "analyzer": { "search_analyzer": { "filter": [ "lowercase" ], "char_filter": [ "html_strip" ], "type": "custom", "tokenizer": "my_search_token" }, "title_analyzer": { "filter": [ "lowercase" ], "char_filter": [ "html_strip" ], "type": "custom", "tokenizer": "my_title_index_token" } }, "tokenizer": { "my_title_index_token": { "enableOOV": "false", "enableFailDingMsg": "true", "type": "hao_index_mode", "enableSingleWord": "true", "enableFallBack": "true" }, "my_search_token": { "enableOOV": "false", "enableFailDingMsg": "true", "type": "hao_search_mode", "enableSingleWord": "true", "enableFallBack": "true" } } }, "number_of_replicas": "0" } }, "mappings": { "properties": { "title": { "type": "text", "index_options": "offsets", "analyzer": "title_analyzer", "search_analyzer": "search_analyzer" } } }}测试分词 ...

关于elasticsearch:Elasticsearch-技术分享-ES-常用名词及结构

前言看完什么是 Elasticsearch 以及理解到了倒排索引的概念，上面就相熟下 ES 中罕用的一些名词。公众号：『刘志航』，记录工作学习中的技术、开发及源码笔记；时不时分享一些生存中的见闻感悟。欢送大佬来领导！罕用术语名词解释cluster一个或者多个 node 指定雷同的 cluster name，则它们会组成集群，并且主动选举 master，以及在故障时主动选举。node节点是属于集群的Elasticsearch的运行实例。在启动时，节点将应用单播来发现具备雷同集群名称的现有集群，并将尝试退出该集群。index相似关系数据库的表，映射一个或者多个主分片，同时领有零个或多个正本分片。index alias索引别名是用于援用一个或多个现有索引的辅助名称。大多数Elasticsearch API承受索引别名代替索引名称。mapping每个 index 都有一个 mapping ，定义一个 type 以及许多索引范畴的设置。mapping 能够明确定义，也能够在为文档建设索引后主动生成。shard分片是单个Lucene实例。最小的工作单位，由Elasticsearch主动治理。索引是指向主分片和正本分片的逻辑命名空间。primary shard每个文档都存储在一个主分片中。当您为文档建设索引时，将首先在主 shard 上建设索引，而后在主 shard 的所有正本上建设索引。默认状况下，索引具备一个主分片。您能够指定更多的次要分片来扩大索引能够解决的文档数量。创立索引后，您将无奈更改索引中的次要分片数量。然而，能够应用split API将索引拆分为新索引。replica shard每个主分片能够具备零个或多个正本。正本是 primary shard 的正本。documentdocument 是存储在 Elasticsearch 中的 JSON 文档。每个 document 都存储在索引中，并且有 type 和 id。被索引的 JSON 文档将存储在 _source 字段中，该字段在获取或搜寻文档时默认返回。id每个 document 都有不同的 id，没有指定的话，会主动生成。field一个 document 蕴含字段或键值对的列表。字段相似于关系数据库中表中的列。source field默认状况下，索引的JSON文档存储在 _source 字段中，并且将由所有 get 和 search 申请返回。这样，能够间接从搜寻后果中拜访原始对象，而无需执行第二步来从 ID 中检索对象。画图进去就是上面这个样子 ...

关于elasticsearch:Elasticsearch-基础入门教程

Elasticsearch根底入门教程，罕用的命令语句，可间接复制到kibana上应用，实用于6.x 7.x。1 集群/索引相干1.1 查看集群状态GET /_cat/health?v&pretty1.2 查看集群的索引状态GET /_cluster/health?pretty&level=indices1.3 查看索引信息GET /_cat/indices?v&pretty1.4 查看分片信息GET /_cat/shards?v&pretty1.5 查看各节点的容量应用状况GET /_cat/allocation?v&pretty1.6 查看各节点信息GET /_nodes/process?prettyGET /_cat/nodes?v1.7 查看某个节点信息GET /_nodes/node1/process?pretty1.8 查看某个索引分片信息GET /index/_search_shards1.9 查看某个索引的fielddataGET /_stats/fielddata?fields=*&index=xx1.10 查看es分词器的分词后果GET /_analyze/?pretty{ "analyzer": "ik_max_word", "text": "测试用例"}1.11 查看索引中某个文档具体字段的分词后果GET /index/type/id/_termvectors?fields=title1.12 设置搜寻的最大返回数（三种形式）1.12.1 全局配置PUT /_settings{ "index": { "max_result_window": 100000000 }}1.12.2 针对某个索引配置PUT /index/_settings{ "index": { "max_result_window": 100000000 }}1.12.3 配置文件在config/elasticsearch.yml文件，加上index.max_result_window: 100000000 2 搜寻相干2.1 match_all匹配所有 GET /index/_search{ "query": { "match_all": {} }}2.2 match_phrase短语匹配，要求所有的分词必须同时呈现在文档中，同时地位必须紧邻统一。 GET /index/_search{ "query": { "match_phrase": { "name": "quick brown fox" } }}2.3 matchmatch在匹配时会对所查找的关键词进行分词，而后按分词匹配查找。match会将关键词进行分词分成“my”和“cat”，查找时蕴含其中任一均可被匹配到。 ...

关于elasticsearch:重构实践基于腾讯云Elasticsearch搭建QQ邮箱全文检索

导语 | 随着用户邮件数量越来越多，邮件搜寻已是邮箱的基本功能。QQ 邮箱于 2008 年推出的自研搜索引擎面临着存储机器逐步老化，存储机型面临淘汰的境况。因而，须要搭建一套新的全文检索服务，迁徙存储数据。本文将介绍 QQ 邮箱全文检索的架构、实现细节与搜寻调优。文章作者：干胜，腾讯后盾研发工程师。一、重构背景QQ 邮箱的全文检索服务于2008年开始提供，应用中文分词算法和倒排索引构造实现自研搜索引擎。设计有二级索引，热数据寄存于正排索引反对实时检索，冷数据寄存于倒排索引反对分词搜寻。在应用旧全文检索过程中存在以下问题：机器老化、磁盘损坏导致丢数据；业务逻辑简单，代码宏大艰涩，难以保护；应用定制化kv存储，已无人保护；不存储原文，无奈实现原生高亮；未索引超大附件名。旧的全文检索在应用中长期存在上述问题，恰逢旧的存储机器裁撤，借此机会重构 QQ 邮箱的全文检索后盾服务。二、新全文检索架构Elasticsearch 是一个分布式的搜索引擎，反对存储、搜寻和数据分析，有良好的扩展性、稳定性和可维护性，在搜索引擎排名中蝉联第一。 ES 的底层存储引擎是 Lucene，ES 在 Lucene 的根底上提供分布式集群的能力以确保可靠性、提供 REST API 以确保可用性。 Lucene 底层应用倒排索引提供搜寻能力，应用 LSM tree 合并解决 Doc 放慢索引速度，应用 Translog 长久化数据，实现形式与邮箱旧全文检索类似。为了疾速搭建出一套新全文检索后盾并实现迁徙，QQ 邮箱全文检索的重构抉择 Elasticsearch 作为搜索引擎，同时响应自研上云号召，一步到位间接应用腾讯云 ES 构建搜寻服务。 1. 邮件搜寻特点邮箱的发信和收信行为都会触发写全文检索，而搜寻行为会触发读全文检索，出现显著的写多读少。区别于互联网搜寻，邮件检索有本人的特点：搜寻范畴准确度排序互联网搜寻整个互联网容忍大量漏搜或多搜按相关度排序邮件检索用户本人的邮箱要求准确后果按工夫排序，同时反对按发件人、工夫、已读未读进行分类 2. 全文检索后盾架构邮箱全文检索模块 fullsearch 的整体架构如上图所示，fullsearch 承当的性能是收录用户的邮件、记事等内容并提供查问。fullsearch 模块上游间接对接腾讯云 ES，内网通过 http 申请拜访 ES 的 REST API。模块上游的申请分为两类： ...

关于elasticsearch:Elasticsearch-如何做到快速检索-倒排索引的秘密

"All problems in computer science can be solved by another level of indirection.”– David J. Wheeler “计算机世界就是 trade-off 的艺术” 一、前言最近接触的几个我的项目都应用到了 Elasticsearch (以下简称 ES ) 来存储数据和对数据进行搜寻剖析，就对 ES 进行了一些学习。本文整顿自我本人的一次技术分享。本文不会关注 ES 外面的分布式技术、相干 API 的应用，而是专一分享下 ”ES 如何疾速检索“ 这个主题下面。这个也是我在学习之前对 ES 最感兴趣的局部。本文大抵包含以下内容：对于搜寻传统关系型数据库和 ES 的差异搜索引擎原理细究倒排索引倒排索引具体是个什么样子的（posting list -> term dic -> term index）对于 postings list 的一些巧技（FOR、Roaring Bitmaps）如何疾速做联结查问？二、对于搜寻先构想一个对于搜寻的场景，假如咱们要搜寻一首诗句内容中带“前”字的新诗，用传统关系型数据库和 ES 实现会有什么差异？如果用像 MySQL 这样的 RDBMS 来存储新诗的话，咱们应该会去应用这样的 SQL 去查问 ...

关于elasticsearch:elasticsearch笔记001基础操作

1. _cat查看信息1.1. _cat/health 查看集群健康状况1602493310 09:01:50 elasticsearch yellow 1 1 10 10 0 0 5 0 - 66.7%1.2. _cat/master 查看主节点信息bQY8I8hFSjmCHO_1-MKfZg 127.0.0.1 127.0.0.1 83c34a872f4c1.3 _cat/indices 查看索引信息green open .security-7 M61Q-ekUQmGZP1FtS8ukfQ 1 0 42 0 74kb 74kbyellow open niewj UuJpWw6UQcKBH8-TWquNng 5 1 0 0 1.3kb 1.3kbgreen open .kibana_task_manager_1 1ebsopUOSN-P8ToMX-mklA 1 0 2 0 22.5kb 22.5kbgreen open .apm-agent-configuration Le9Ig6qiSdaxMRLvmg43Lg 1 0 0 0 283b 283bgreen open kibana_sample_data_logs jo7AsHgeTniG509NZWUi-A 1 0 14074 0 11.7mb 11.7mbgreen open .kibana_1 o1ntzX2YRFGfU__BzFPYhg 1 0 47 0 109.1kb 109.1kb1.4 其余 _cat 命令/_cat/allocation/_cat/shards/_cat/shards/{index}/_cat/master/_cat/nodes/_cat/tasks/_cat/indices/_cat/indices/{index}/_cat/segments/_cat/segments/{index}/_cat/count/_cat/count/{index}/_cat/recovery/_cat/recovery/{index}/_cat/health/_cat/pending_tasks/_cat/aliases/_cat/aliases/{alias}/_cat/thread_pool/_cat/thread_pool/{thread_pools}/_cat/plugins/_cat/fielddata/_cat/fielddata/{fields}/_cat/nodeattrs/_cat/repositories/_cat/snapshots/{repository}/_cat/templates2. put/post 新增和批改二合一留神下划线开始的属性是元数据 ...

关于elasticsearch:accountsjson-elasticsearch官网的测试数据

关于elasticsearch:使用-nginx-快速搭建-ik-远程词典服务

测试环境Windows 10nginx 1.18.0步骤解压下载的压缩包，在外面新建 dic 目录编辑 conf 下的配置文件 nginx.confworker_processes 1;events { worker_connections 1024;}http { include mime.types; default_type application/octet-stream; sendfile on; keepalive_timeout 65; server { listen 8080; server_name localhost; location / { root html; index index.html index.htm; } location /dic/ { root ./; autoindex on; } error_page 500 502 503 504 /50x.html; location = /50x.html { root html; } }}只在默认配置文件中加了上面这几句 location /dic/ { root ./; autoindex on;}开关命令# 启动start nginx.exe# 重载nginx.exe -s reload# 敞开nginx.exe -s quit拜访 http://localhost:8080/dic/ 即可看到目录下的文件 ...

关于elasticsearch:Docker中使用elasticsearch762

宿主机上创立文件# 创立/mydata/elasticsearch/config/、/mydata/elasticsearch/datamkdir -p /mydata/elasticsearch/{config,data}echo "http.host: 0.0.0.0" > /mydata/elasticsearch/config/elasticsearch.ymlchmod -R 777 /mydata/elasticsearch/启动elasticsearchdocker run --name elasticsearch -p 9200:9200 -p 9300:9300 \-e "discovery.type=single-node" \-e ES_JAVA_OPTS="-Xms64m -Xmx512m" \-v /mydata/elasticsearch/config/elasticsearch.yml:/usr/share/elasticsearch/config/elasticsearch.yml \-v /mydata/elasticsearch/data:/usr/share/elasticsearch/data \-v /mydata/elasticsearch/plugins:/usr/share/elasticsearch/plugins \-d elasticsearch:7.6.2设置开机启动elasticsearchdocker update elasticsearch --restart=always启动kibanadocker run --name kibana \-e ELASTICSEARCH_HOSTS=http://192.168.33.200:9200 \-p 5601:5601 -d kibana:7.6.2测试查看elasticsearch版本信息# 拜访本人虚拟机的9200端口，例如： http://192.168.33.200:9200/{ "name" : "22799138e953", "cluster_name" : "elasticsearch", "cluster_uuid" : "x59rbg6aTzityKxaEIf1GA", "version" : { "number" : "7.6.2", "build_flavor" : "default", "build_type" : "docker", "build_hash" : "ef48eb35cf30adf4db14086e8aabd07ef6fb113f", "build_date" : "2020-03-26T06:34:37.794943Z", "build_snapshot" : false, "lucene_version" : "8.4.0", "minimum_wire_compatibility_version" : "6.8.0", "minimum_index_compatibility_version" : "6.0.0-beta1" }, "tagline" : "You Know, for Search"}通过Kibana客户端拜访elasticsearch拜访本人虚拟机的5601端口,在浏览器中关上Kibana客户端http://192.168.33.200:5601/app/kibana#/dev_tools/console ...

关于elasticsearch:殘荷听雨

Elasticsearch下载下载地址 : Elasticsearch 解压tar -xvf elasticsearch-7.6.2-linux-x86_64.tar.gz目录mkdir data [esroot@localhost elasticsearch-7.6.2]$ ll总用量 556drwxr-xr-x. 2 esroot root 4096 3月 26 14:36 bin #可执行文件，运行es的命令drwxr-xr-x. 2 esroot root 4096 8月 3 21:19 config #配置文件目录drwxrwxr-x. 2 esroot esroot 6 8月 3 22:27 data #本人创立寄存es存储文件drwxr-xr-x. 9 esroot root 99 3月 26 14:36 jdkdrwxr-xr-x. 3 esroot root 4096 3月 26 14:36 lib #依赖的jar-rw-r--r--. 1 esroot root 13675 3月 26 14:28 LICENSE.txtdrwxr-xr-x. 2 esroot root 4096 8月 3 21:53 logs #日志文件夹drwxr-xr-x. 38 esroot root 4096 3月 26 14:37 modules-rw-r--r--. 1 esroot root 523209 3月 26 14:36 NOTICE.txtdrwxr-xr-x. 2 esroot root 6 3月 26 14:36 plugins-rw-r--r--. 1 esroot root 8164 3月 26 14:28 README.asciidoc配置config 目录[esroot@localhost config]$ ll总用量 40-rw-rw----. 1 esroot root 199 8月 3 21:19 elasticsearch.keystore-rw-rw----. 1 esroot root 2831 3月 26 14:28 elasticsearch.yml #ES启动根底配置-rw-rw----. 1 esroot root 2301 3月 26 14:28 jvm.options #ES启动时JVM配置-rw-rw----. 1 esroot root 17545 3月 26 14:36 log4j2.properties #ES日志输入配置文件-rw-rw----. 1 esroot root 473 3月 26 14:36 role_mapping.yml-rw-rw----. 1 esroot root 197 3月 26 14:36 roles.yml-rw-rw----. 1 esroot root 0 3月 26 14:36 users-rw-rw----. 1 esroot root 0 3月 26 14:36 users_roleselasticsearch.yml 配置配置es集群名称（默认是被正文的，并且默认有一个集群名）# ---------------------------------- Cluster -----------------------------------## Use a descriptive name for your cluster:#cluster.name: my-application#配置以后es节点名称（默认是被正文的，并且默认有一个节点名）# ------------------------------------ Node ------------------------------------## Use a descriptive name for the node:#node.name: node-1## Add custom attributes to the node:##node.attr.rack: r1#配置存储数据目录门路（用逗号分隔多个地位）和日志文件门路# ----------------------------------- Paths ------------------------------------## Path to directory where to store the data (separate multiple locations by comma):#path.data: /usr/local/elasticsearch-7.6.2/data## Path to log files:#path.logs: /usr/local/elasticsearch-7.6.2/logs#绑定地址为特定 IP 地址（设置0.0.0.0能够让任何人拜访到你的 es），设置一个 http 申请端口（默认 9200）# ---------------------------------- Network -----------------------------------## Set the bind address to a specific IP (IPv4 or IPv6):#network.host: 0.0.0.0## Set a custom port for HTTP:#http.port: 9200## For more information, consult the network module documentation.#集群启动时，设置master节点列表（用逗号分隔，目前单机所以只配置了一个）# --------------------------------- Discovery ----------------------------------## Pass an initial list of hosts to perform discovery when this node is started:# The default list of hosts is ["127.0.0.1", "[::1]"]##discovery.seed_hosts: ["host1", "host2"]## Bootstrap the cluster using an initial set of master-eligible nodes:#cluster.initial_master_nodes: ["node-1"]#jvm.options 配置Xms、Xmx设置为统一即可 ...

关于elasticsearch:Elasticsearch-查询数据的工作原理是什么

起源：8rr.co/GsAa 面试题ES 写入数据的工作原理是什么啊？ES 查问数据的工作原理是什么啊？底层的 Lucene 介绍一下呗？倒排索引理解吗？面试官心理剖析问这个，其实面试官就是要看看你理解不理解 es 的一些基本原理，因为用 es 无非就是写入数据，搜寻数据。你要是不明确你发动一个写入和搜寻申请的时候，es 在干什么，那你真的是...... 对 es 根本就是个黑盒，你还无能啥？你惟一无能的就是用 es 的 api 读写数据了。要是出点什么问题，你啥都不晓得，那还能指望你什么呢？面试题分析es 写数据过程客户端抉择一个 node 发送申请过来，这个 node 就是 coordinating node （协调节点）。coordinating node 对 document 进行路由，将申请转发给对应的 node（有 primary shard）。理论的 node 上的 primary shard 解决申请，而后将数据同步到 replica node 。coordinating node 如果发现 primary node 和所有 replica node 都搞定之后，就返回响应后果给客户端。 es-write es 读数据过程能够通过 doc id 来查问，会依据 doc id 进行 hash，判断进去过后把 doc id 调配到了哪个 shard 下面去，从那个 shard 去查问。客户端发送申请到任意一个 node，成为 coordinate node 。coordinate node 对 doc id 进行哈希路由，将申请转发到对应的 node，此时会应用 round-robin 随机轮询算法，在 primary shard 以及其所有 replica 中随机抉择一个，让读申请负载平衡。接管申请的 node 返回 document 给 coordinate node 。coordinate node 返回 document 给客户端。es 搜寻数据过程es 最弱小的是做全文检索，就是比方你有三条数据： ...

关于elasticsearch:Elasticsearch-最佳实践

作者：散尽浮华原文：https://www.cnblogs.com/kevin... 之前在IDC机房环境部署了一套ELK日志集中剖析零碎, 这里简略总结下ELK中Elasticsearch衰弱状态相干问题, Elasticsearch的索引状态和集群状态传播着不同的意思。一. Elasticsearch 集群衰弱状态一个 Elasticsearch 集群至多包含一个节点和一个索引。或者它可能有一百个数据节点、三个独自的主节点，以及一小打客户端节点——这些独特操作一千个索引（以及上万个分片）。然而不论集群扩大到多大规模，你都会想要一个疾速获取集群状态的路径。Cluster Health API 充当的就是这个角色。你能够把它设想成是在一万英尺的高度鸟瞰集群。它能够通知你安心吧所有都好，或者正告你集群某个中央有问题。Elasticsearch 里其余 API 一样，cluster-health 会返回一个 JSON 响应。这对自动化和告警零碎来说，十分便于解析。响应中蕴含了和你集群无关的一些要害信息: 查看Elasticsearch衰弱状态 (*示意ES集群的master主节点) [root@elk-node03 ~]# curl -XGET 'http://10.0.8.47:9200/_cat/nodes?v'host ip heap.percent ram.percent load node.role master name 10.0.8.47 10.0.8.47 53 85 0.16 d * elk-node03.kevin.cn10.0.8.44 10.0.8.44 26 54 0.09 d m elk-node01.kevin.cn10.0.8.45 10.0.8.45 71 81 0.02 d m elk-node02.kevin.cn上面两条shell命令都能够监控到Elasticsearch衰弱状态 [root@elk-node03 ~]# curl 10.0.8.47:9200/_cat/health1554792912 14:55:12 kevin-elk green 3 3 4478 2239 0 0 0 0 - 100.0% [root@elk-node03 ~]# curl -X GET 'http://10.0.8.47:9200/_cluster/health?pretty'{ "cluster_name" : "kevin-elk", #集群名称 "status" : "green", #为 green 则代表衰弱没问题，如果是 yellow 或者 red 则是集群有问题 "timed_out" : false, #是否有超时 "number_of_nodes" : 3, #集群中的节点数量 "number_of_data_nodes" : 3, "active_primary_shards" : 2234, "active_shards" : 4468, "relocating_shards" : 0, "initializing_shards" : 0, "unassigned_shards" : 0, "delayed_unassigned_shards" : 0, "number_of_pending_tasks" : 0, "number_of_in_flight_fetch" : 0, "task_max_waiting_in_queue_millis" : 0, "active_shards_percent_as_number" : 100.0 #集群分片的可用性百分比，如果为0则示意不可用}失常状况下，Elasticsearch 集群衰弱状态分为三种： ...

关于elasticsearch:腾讯云Elasticsearch集群规划及性能优化实践

一、引言随着腾讯云 Elasticsearch 云产品性能越来越丰盛，ES 用户越来越多，云上的集群规模也越来越大。咱们在日常运维工作中也常常会遇到一些因为后期集群布局不到位，导致前期业务增长集群规模大了之后带来的各种各样的集群可用性及稳定性问题。这里列举下其中比拟典型的几种集群布局问题：节点规格布局问题：集群数量很大，然而每个节点的配置很低；索引分片布局问题：索引很小，然而设置了几十个分片，或者索引很大，只设置了两三个分片；分片数量布局问题：集群中蕴含 10万+ 的分片。正所谓磨刀不误砍柴工，只有后期做好充沛的集群评估布局工作，前期能力省去大量的运维工作。且可能长期保障集群的高可用和高稳定性。本文联合咱们在给腾讯云 ES 集群日常运维工作中遇到的各种集群问题及总结积淀的一些运维教训，来介绍下如何布局好集群容量及索引配置，以及所遵循的一些准则和教训。文章作者：吴容，腾讯云Elasticsearch研发工程师。二、集群规模及索引布局1. 集群规模评估（1）评估什么？集群规模的评估次要评估以下三个方面：第一，计算资源评估，计算资源的评估次要是评估单节点的CPU和内存。 ES的计算资源个别耗费在写入和查问过程，通过总结大量ES集群的运维教训，2C8G 的配置大略能反对 5k doc/s 的写入，32C64G 的配置大略能撑持 5w doc/s的写入能力。第二，存储资源评估，存储资源的评估次要是评估磁盘的类型及容量大小。例如ES集群应用什么类型的磁盘，SSD或者高性能云盘。以及每块盘的容量大小，是抉择单盘多容量，还是多盘少容量。而对于冷热拆散的集群，则默认应用SSD作为热节点，高性能云盘作为温节点。另外腾讯云ES反对单节点挂载多块云硬盘，且通过性能压测，3块盘相比于1块盘，吞吐量大概有2.8倍的晋升。因而如果对写入速度及IO性能要求较高，可抉择挂载多块 SSD 磁盘。 ES冷热拆散多盘集群示意图第三，节点数量评估，节点数量的评估次要是评估集群数据节点的数量。在等同集群性能的状况下，倡议优先选择高配置少节点的集群。例如 32C64G3 节点的集群相比于 8C16G12 节点的集群，在集群稳定性和扩容的便捷性上都有肯定的劣势。因为高配置的集群如果遇到性能瓶颈须要扩容，则只须要横向扩容，即向集群中退出更多等同配置的节点即可；而低配置的集群在扩容节点配置时，则须要纵向扩容。目前云上的纵向扩容形式有两种：第一种是滚动重启形式扩容，这对集群稳定性会有肯定的影响。第二种是数据迁徙形式扩容，其原理是先向集群中退出等同数量的高配置节点，而后将低配置节点上的数据迁徙到新节点上，最初再将低配置节点剔除集群，所以这种扩容流程工夫会比拟长，且老本较高。数据迁徙形式纵向扩容示意图（2）依据什么评估？集群规模评估次要依据以下三点来评估：具体的业务场景，如日志剖析、指标监控、搜寻业务；业务预计的查问及写入QPS；索引的数据总量。（3）集群规模评估准则这里联合咱们的运维教训，给出集群规模评估的几点参考倡议： 32C64G单节点配置通常可承载5W次/s的写入；写入量和数据量较大时，优先选择32C64G的节点配置；1T的数据量预计需耗费2-4GB的内存空间；搜寻场景优先选择大内存节点配置；存储容量 = 源数据 (1 + 正本数量) 1.45 （1 + 预留空间） ≈ 源数据 (1 + 正本数量) * 2.2.2. 索引配置评估（1）评估什么？索引配置的评估次要评估两点：第一，如何划分索引？在应用 index 时，倡议做好定期切换索引的打算。对于日志场景来说，写入不大的状况下倡议按天创立索引，而写入较大的状况下，则倡议按小时创立索引。定期滚动索引的益处次要包含：可能管制单个索引的大小，晋升读写性能；同时可能形式单个索引太大，影响故障复原的工夫；另外也能防止热索引过大，从而影响快照备份复原的工夫。 ...

关于elasticsearch:总结一些ES不常用的filter

写在后面ES内置的token filter很多，大部分理论工作中都用不到。这段时间筹备ES认证工程师的考试，备考的时候须要相熟这些不罕用的filter。ES官网对一些filter只是一笔带过，我就想着把备考的笔记整顿成博客备忘，也心愿能帮忙到有这方面需要的人。 length filer官网解释： A token filter of type length that removes words that are too long or too short for the stream.这个filter的性能是，去掉过长或者过短的单词。它有两个参数能够设置： min 定义最短长度，默认是0max 定义最长长度，默认是Integer.MAX_VALUE先来简略测试下它的成果， GET _analyze{ "tokenizer" : "standard", "filter": [{"type": "length", "min":1, "max":3 }], "text" : "The 2 QUICK Brown-Foxes jumped over the lazy dog's bone"}输入： { "tokens" : [ { "token" : "The", "start_offset" : 0, "end_offset" : 3, "type" : "<ALPHANUM>", "position" : 0 }, { "token" : "2", "start_offset" : 4, "end_offset" : 5, "type" : "<NUM>", "position" : 1 }, { "token" : "the", "start_offset" : 36, "end_offset" : 39, "type" : "<ALPHANUM>", "position" : 7 } ]}能够看到大于3的单词都被过滤掉了。 ...

关于elasticsearch:开发了一个google-drive搜索引擎

我的项目介绍https://github.com/gdtool/zhaopp https://zhao.pp.ua 是一个基于ElasticSearch的Google Drive 搜索引擎,疾速,高效,要害：可间接下载开发背景因为gd当初转存受限于1.5T限度,大家都在摸索一个新的资源分享形式; 本搜索引擎,可搜寻,可下载,尽管不能解决珍藏的需要,然而根本满足大家用文件的需要其实珍藏了几个P的资源,真正用到的又有多少?包含我在内,好多人陷入松鼠病不能自拔文件收录:19个团队盘; 420万文件; 1.9P资源奉献资源此搜索引擎内容齐全来自网友的无私奉献,心愿你的退出将gd-utils@googlegroups.com退出你的团队盘；告知作者进行索引

关于elasticsearch:elasticsearch创建中文索引

1、关上http://localhost:5601/app/dev_tools#/console 命令控制台2、执行如下命令 PUT my-index-000001//索引名称{ "settings": { "analysis": { "analyzer": { "default": { "type": "ik_max_word"//ik中文索引 }, "default_search": { "type": "ik_max_word"//ik中文索引 } } } }}IK分词器有两种分词模式：ik_max_word和ik_smart模式。ik_max_word 会将文本做最细粒度的拆分，比方会将“中华人民共和国人民大会堂”拆分为“中华人民共和国、中华人民、中华、华人、人民共和国、人民、共和国、大会堂、大会、会堂等词语。 ik_smart会做最粗粒度的拆分，比方会将“中华人民共和国人民大会堂”拆分为中华人民共和国、人民大会堂。

关于elasticsearch:elasticsearchkibana安装

1、在网站https://www.elastic.co/cn/downloads/kibana上下载kibana zip压缩包。2、将压缩包解压到没有空格与中文门路的目录中，如下图： 3、启动kibana.bat,启动过程有点慢，启动实现后拜访http://localhost:5601

关于elasticsearch:Elasticsearch-推荐相关qbit

High-Quality Recommendation Systems with Elasticsearch应用 ElasticSearch 实现高质量的举荐零碎Elasticsearch：significant terms aggregation本文出自 qbit snap

关于elasticsearch:Elasticsearch集群安装部署

Elasticsearch版本 rpm -ivh elasticsearch-6.8.3.rpm创立文件夹 mkdir /usr/share/elasticsearch/datamkdir /usr/share/elasticsearch/logs因为平安问题Elasticsearch不让用root用户间接运行，所以要创立新用户创立用户命令adduser es批改用户明码passwd es将es解压目录的所有者授予此用户chown -R es:es *批改elasticsearch.yml文件 #vi /etc/elasticsearch/elasticsearch.yml---------------------------------- Cluster -----------------------------------cluster.name: es_cluster------------------------------------ Node ------------------------------------node.name: node_1#----------------------------------- Paths ------------------------------------path.data: /usr/share/elasticsearch/datapath.logs: /usr/share/elasticsearch/logs#----------------------------------- Memory -----------------------------------network.host: 0.0.0.0http.port: 9200transport.tcp.port: 9300#--------------------------------- Discovery ----------------------------------discovery.zen.ping.unicast.hosts: ["10.2.15.183", "10.2.15.169", "10.2.15.186"]discovery.zen.minimum_master_nodes: 2gateway.recover_after_nodes: 2#---------------------------------- Various -----------------------------------node.master: truenode.data: truehttp.cors.enabled: truehttp.cors.allow-origin: "*"批改jvm.options文件 vi /etc/elasticsearch/jvm.options-Xms4g-Xmx4g批改limits.conf文件 vi /etc/security/limits.conf* soft nofile 65536* hard nofile 131072* soft nproc 4096* hard nproc 4096批改sysctl.conf文件 vi /etc/sysctl.confvm.max_map_count=655360将/elasticsearch 发送给其余两个服务器hadoop2, hadoop3 scp -r /usr/local/elasticsearch hadoop2:/usr/localscp -r /usr/local/elasticsearch hadoop3:/usr/local切换至es用户并启动 ...

关于elasticsearch:elasticsearch中文分词Ik安装

1、下载中文分词https://github.com/medcl/elasticsearch-analysis-ik2、解压elasticsearch-analysis-ik.zip文件。3、将解压文件拷贝到elasticsearch装置目录plugins目录ik目录下4重新启动elasticsearch,检测日志是否呈现如下插件。

关于elasticsearch:elasticsearch测试索引分词

//应用指定分析仪测试分词文本GET test_index/_analyze//test_index索引名称 { "analyzer": "ik_max_word",//分析仪 "text": "中华人民共和国" //测试分司文本}//应用指定索引字段的分析仪测试GET test_index/_analyze//test_index索引名称 { "field": "content",//应用索引指定字段的分析仪 "text": "中华人民共和国"}

关于elasticsearch:elasticsearch插件开发插件配置声明

es插件首先能够借助es的setting模块裸露配置项，从而提供给用户参数配置的可能。回顾一下上回的插件类代码片段： public class NacosPlugin extends Plugin { protected final Settings settings; public NacosPlugin(final Settings settings) { this.settings = settings; } @Override public List<Setting<?>> getSettings() { ... }}getSettings办法须要返回一个Setting汇合，es依据这个汇合把elasticsearch.yml中的配置项通过构造函数传递给插件。Setting类是泛型的。例如：Setting<Boolean>示意bool类型的配置项。在nacos-elasticsearch中通过申明NACOS_ENABLED配置作为性能开关： public static final Setting<Boolean> NACOS_ENABLED = Setting.boolSetting("nacos.register.enabled", false, Setting.Property.NodeScope);nacos.register.enabled即为配置在es中的配置项，咱们能够在配置文件中配置如下： nacos.register.enabled: true如果不配置，默认为代码中申明的false。在代码中能够通过get形式获取值： boolean enabled = NACOS_ENABLED.get(this.settings);比拟罕用的类型都能够作为Setting类型，说两个非凡的TimeValue和List。如果心愿提供用户配置工夫值： nacos.beat.interval: 20s能够申明为 public static final Setting<TimeValue> NACOS_BEAT_INTERVAL = Setting.timeSetting("nacos.beat.interval", TimeValue.timeValueSeconds(10), Setting.Property.NodeScope);如果心愿提供列表项： nacos.server.addrs: ["192.168.1.2:8848","192.168.1.2:8848"]能够申明为 public static final Setting<List<String>> NACOS_SERVERS = Setting.listSetting("nacos.server.addrs", Collections.emptyList(), x -> x, Setting.Property.NodeScope);值得一提的是，有些配置属于敏感信息，例如明码。es提供keystore来保留敏感配置项。用户通过elasticsearch-keystore工具保留配置项，而在代码外面能够获取到这些敏感配置项。例如nacos-elasticsearch反对用keystore保留明码(nacos.server.password.keystore)： ...