四、初探[ElasticSearch]集群架构原理与搜索技术

这篇具有很好参考价值的文章主要介绍了四、初探[ElasticSearch]集群架构原理与搜索技术。希望对大家有所帮助。如果存在错误或未考虑完全的地方,请大家不吝赐教,您也可以点击"举报违法"按钮提交疑问。

一、浅析Elasticsearch架构原理

1.Elasticsearch的节点类型

在Elasticsearch主要分成两类节点,一类是Master,一类是DataNode。

1.1 Master节点

在Elasticsearch启动时,会选举出来一个Master节点。采用Zen Discovery1机制选出master节点并且找到集群中的其他节点,并建立连接。一个Elasticsearch集群中,只有一个Master节点。(这里的一个是在集群范围中的,而不是指定某台服务器一直就是主节点,主节点所在服务器宕机,其他的某一个节点有机会成为master节点)

Master节点主要功能::

  1. 管理索引和分片的创建、删除和重新分配。
  2. 监测节点的状态,并在需要时进行重分配。
  3. 协调节点之间的数据复制和同步工作。
  4. 处理集群级别操作,如创建或删除索引、添加或删除节点等。
  5. 维护集群的健康状态,并在集群出现问题时采取措施解决。
  6. 维护元数据2

1.2DataNode节点

与master节点不同,datanode节点可能会有多个。这个取决于你集群的节点数量,因为master在集群中只能有一个,其余为DataNode节点。
DataNode节点主要功能:

  1. 存储和索引数据:Data Node 节点会将索引分片存储在本地磁盘上,并对查询请求进行响应。
  2. 复制和同步数据:为了确保数据的可靠性和高可用性,ElasticSearch 会将每个原始分片的多个副本存储在不同的 Data Node 节点上,并定期将各节点上的数据进行同步。
  3. 参与搜索和聚合操作:当客户端提交搜索请求时,Data Node 节点会使用本地缓存和分片数据完成搜索和聚合操作。
  4. 执行数据维护操作:例如,清理过期数据和压缩分片等。

二、分片和副本机制

在第一篇文章中也有介绍过这俩个概念,这里在集群中再次进行解释
四、初探[ElasticSearch]集群架构原理与搜索技术

2.1分片

ElasticSearch是一个分布式的搜索引擎,索引索引可以分成一份或多份,多份分片分布在不同节点当中。ElasticSearch会自动管理分片,如果发现分片分布不均衡,就会自动迁移。

2.2副本

在ElasticSearch中每个分片都有一个主分片,可能会有若干个副本分片(默认一个分片,一个副本),这些副本也会分布在不同的节点上。

2.3指定分片、副本数量

PUT /test_index06
{
  "mappings": {
    "properties": {
      "name": {
        "type": "keyword",
        "index": true,
        "store": true
      },
      ................
    }
  },
  //设置分片数量1,副本数量2
  "settings": {
    "number_of_shards": 1,
    "number_of_replicas": 2
  }
}

2.4查看分片、主分片、副本分片

GET /_cat/indices?v

三、Elasticsearch工作流程

3.1Elasticsearch文档写入原理

四、初探[ElasticSearch]集群架构原理与搜索技术

如何知道我插入一条数据要保存到那个分片呢?

shard = hash(routing) % number_of_primary_shards
routing 是一个可变值,默认是文档的 _id。
number_of_primary_shards为分片数量
你也可以使用自己的自定义分片键,只需在索引时指定"_routing"字段即可。

3.2Elasticsearch检索原理

四、初探[ElasticSearch]集群架构原理与搜索技术
客户端发起查询请求,某个DataNode接收到请求,该DataNode就会成为协调节点。
协调节点(Coordinating Node)将查询请求广播到每一个数据节点,这些数据节点的分片会处理该查询请求, 每个分片进行数据查询,将符合条件的数据放在一个优先队列中,并将这些数据的文档ID、节点信息、分片信息返回给协调节点。
协调节点将所有的结果进行汇总,并进行全局排序, 协调节点向包含这些文档ID的分片发送get请求,对应的分片将文档数据返回给协调节点,最后协调节点将数据返回给客户端。

四、Elasticsearch准实时索引实现

四、初探[ElasticSearch]集群架构原理与搜索技术

4.1溢写到文件系统缓存

当数据写入到ES分片时,会首先写入到内存中,然后通过内存的buffer生成一个segment,并刷到文件系统缓存中,数据可以被检索(注意不是直接刷到磁盘)ES中默认1秒,refresh缓存一次。

4.2写translog保障容错

在写入到内存中的同时,也会记录translog日志,在refresh期间出现异常,会根据translog来进行数据恢复
等到文件系统缓存中的segment数据都刷到磁盘中,清空translog文件。

4.3flush到磁盘(刷盘)

ES默认每隔30分钟会将文件系统缓存的数据刷入到磁盘。

4.4segment合并

Segment太多时,ES定期会将多个segment合并成为大的segment,减少索引查询时IO开销,此阶段ES会真正的物理删除(之前执行过的delete的数据)。

五.手动控制搜索结果精准度

5.1operator与minimum_should_match简单使用

①查询document中的remark字段包含java或developer词组。

GET /test_index05/_search
{
  "query": {
    "match": {
      "remark": "java developer"
    }
  }
}

或者这样查询

GET /test_index05/_search
{
  "query": {
    "match": {
      "remark": {
        "query": "java developer",
        "operator": "or"
      }
    }
  }
}

结果

 "hits" : [
      {
        "_index" : "test_index05",
        "_type" : "_doc",
        "_id" : "2",
        "_score" : 0.77041256,
        "_source" : {
          "name" : "宝塔镇河妖",
          "sex" : 1,
          "age" : 25,
          "address" : "上海",
          "remark" : "java developer"
        }
      },
      {
        "_index" : "test_index05",
        "_type" : "_doc",
        "_id" : "1",
        "_score" : 0.21110919,
        "_source" : {
          "name" : "天王盖地虎",
          "sex" : 1,
          "age" : 25,
          "address" : "上海",
          "remark" : "java"
        }
      }
    ]

②查询document中的remark字段,同时包含java和developer词组

GET /test_index05/_search
{
  "query": {
    "match": {
      "remark": {
        "query": "java developer",
        "operator": "and"
      }
    }
  }
}

结果

"hits" : [
      {
        "_index" : "test_index05",
        "_type" : "_doc",
        "_id" : "2",
        "_score" : 0.77041256,
        "_source" : {
          "name" : "宝塔镇河妖",
          "sex" : 1,
          "age" : 25,
          "address" : "上海",
          "remark" : "java developer"
        }
      }
    ]

③minimum_should_match可以使用百分比或固定数字。百分比代表query搜索条件中词条百分比,如果无法整除,向下匹配(如,query条件有3个单词,如果使用百分比提供精准度计算,那么是无法除尽的,如果需要至少匹配两个单词,则需要用67%来进行描述。如果使用66%描述,ES则认为匹配一个单词即可)。固定数字代表query搜索条件中的词条,至少需要匹配多少个。
③-1百分比
查询内容包括java 或developer或assistant中匹配度达到66%即文档内容中,至少包括一个单词出现。

GET /test_index05/_search
{
  "query": {
    "match": {
      "remark": {
        "query": "java developer assistant",
        "minimum_should_match": "66%"
      }
    }
  }
}
"hits" : [
      {
        "_index" : "test_index05",
        "_type" : "_doc",
        "_id" : "1",
        "_score" : 0.21110919,
        "_source" : {
          "name" : "天王盖地虎",
          "sex" : 1,
          "age" : 25,
          "address" : "上海",
          "remark" : "java"
        }
      },
      {
        "_index" : "test_index05",
        "_type" : "_doc",
        "_id" : "2",
        "_score" : 0.160443,
        "_source" : {
          "name" : "宝塔镇河妖",
          "sex" : 1,
          "age" : 25,
          "address" : "上海",
          "remark" : "java developer"
        }
      }
    ]

查询内容包括java 或architect 或assistant中匹配度达到67%即文档内容中,至少包括两个个单词出现。

GET /test_index05/_search
{
  "query": {
    "match": {
      "remark": {
        "query": "java developer assistant",
        "minimum_should_match": "67%"
      }
    }
  }
}

结果

"hits" : [
      {
        "_index" : "test_index05",
        "_type" : "_doc",
        "_id" : "2",
        "_score" : 0.77041256,
        "_source" : {
          "name" : "宝塔镇河妖",
          "sex" : 1,
          "age" : 25,
          "address" : "上海",
          "remark" : "java developer"
        }
      }
    ]

③-2固定数字
查询的内容中至少出现下面三个条件中的两个,即java、developer、assistant这三个单词,至少有两个同时出现才符合条件。

GET /test_index05/_search
{
  "query": {
    "bool": {
      "should": [
        {
          "match": {
            "remark": "java"
          }
        },
        {
          "match": {
            "remark": "developer"
          }
        },
        {
          "match": {
            "remark": "assistant"
          }
        }
      ],
      "minimum_should_match": 2
    }
  }
}

结果

"hits" : [
      {
        "_index" : "test_index05",
        "_type" : "_doc",
        "_id" : "2",
        "_score" : 0.77041256,
        "_source" : {
          "name" : "宝塔镇河妖",
          "sex" : 1,
          "age" : 25,
          "address" : "上海",
          "remark" : "java developer"
        }
      }
    ]

5.2、match 的底层转换

我们输入的查询语句

GET /test_index05/_search
{
  "query": {
    "match": {
      "remark": "java developer"
    }
  }
}

转换后的查询语句

GET /test_index05/_search
{
  "query": {
    "bool": {
      "should": [
        {
          "term": {
            "remark": "java"
          }
        },
        {
          "term": {
            "remark": {
              "value": "developer"
            }
          }
        }
      ]
    }
  }
}

查询语句

GET /test_index05/_search
{
  "query": {
    "match": {
      "remark": {
        "query": "java developer",
        "operator": "and"
      }
    }
  }
}

转换后

GET /test_index05/_search
{
  "query": {
    "bool": {
      "must": [
        {
          "term": {
            "remark": "java"
          }
        },
        {
          "term": {
            "remark": {
              "value": "developer"
            }
          }
        }
      ]
    }
  }
}

查询条件

GET /test_index05/_search
{
  "query": {
    "match": {
      "remark": {
        "query": "java developer assistant",
        "minimum_should_match": "68%"
      }
    }
  }
}

转换后

GET /test_index05/_search
{
  "query": {
    "bool": {
      "should": [
        {
          "term": {
            "remark": "java"
          }
        },
        {
          "term": {
            "remark": "developer"
          }
        },
        {
          "term": {
            "remark": "assistant"
          }
        }
      ],
      "minimum_should_match": 2
    }
  }
}

使用转换后的语法执行搜索,效率更高。

5.3、boost权重控制

搜索document中remark字段中包含java的数据,如果remark中包含developer或assistant,则包含assistant的document优先显示。(就是将assistant数据匹配时的相关度分数增加)。
一般用于搜索时相关度排序使用。如:电商中的综合排序。将一个商品的销量,广告投放,评价值,库存,单价比较综合排序。在上述的排序元素中,广告投放权重最高,库存权重最低。还有就是百度搜索内容时前几一般都是广告。

例如
索引test_index05下全部数据为

"hits" : [
      {
        "_index" : "test_index05",
        "_type" : "_doc",
        "_id" : "1",
        "_score" : 1.0,
        "_source" : {
          "name" : "天王盖地虎",
          "sex" : 1,
          "age" : 25,
          "address" : "上海",
          "remark" : "java"
        }
      },
      {
        "_index" : "test_index05",
        "_type" : "_doc",
        "_id" : "2",
        "_score" : 1.0,
        "_source" : {
          "name" : "宝塔镇河妖",
          "sex" : 1,
          "age" : 25,
          "address" : "上海",
          "remark" : "java developer"
        }
      },
      {
        "_index" : "test_index05",
        "_type" : "_doc",
        "_id" : "3",
        "_score" : 1.0,
        "_source" : {
          "name" : "铁锅炖大鹅",
          "sex" : 1,
          "age" : 19,
          "address" : "天津",
          "remark" : "java assistant"
        }
      }
    ]

查询(boost越高,表示权重越高,越优先展示)

GET /test_index05/_search
{
  "query": {
    "bool": {
      "must": [
        {
          "match": {
            "remark": "java"
          }
        }
      ],
      "should": [
        {
          "match": {
            "remark": {
              "query": "developer",
              "boost": 1
            }
          }
        },
        {
          "match": {
            "remark": {
              "query": "assistant",
              "boost": 3
            }
          }
        }
      ]
    }
  }
}

结果

"hits" : [
      {
        "_index" : "test_index05",
        "_type" : "_doc",
        "_id" : "3",
        "_score" : 2.3016074,
        "_source" : {
          "name" : "铁锅炖大鹅",
          "sex" : 1,
          "age" : 19,
          "address" : "天津",
          "remark" : "java assistant"
        }
      },
      {
        "_index" : "test_index05",
        "_type" : "_doc",
        "_id" : "2",
        "_score" : 1.474477,
        "_source" : {
          "name" : "宝塔镇河妖",
          "sex" : 1,
          "age" : 25,
          "address" : "上海",
          "remark" : "java developer"
        }
      },
      {
        "_index" : "test_index05",
        "_type" : "_doc",
        "_id" : "1",
        "_score" : 0.43250346,
        "_source" : {
          "name" : "天王盖地虎",
          "sex" : 1,
          "age" : 25,
          "address" : "上海",
          "remark" : "java"
        }
      }
    ]

查询

GET /test_index05/_search
{
  "query": {
    "bool": {
      "must": [
        {
          "match": {
            "remark": "java"
          }
        }
      ],
      "should": [
        {
          "match": {
            "remark": {
              "query": "developer",
              "boost": 2
            }
          }
        },
        {
          "match": {
            "remark": {
              "query": "assistant",
              "boost": 1
            }
          }
        }
      ]
    }
  }
}

结果

"hits" : [
      {
        "_index" : "test_index05",
        "_type" : "_doc",
        "_id" : "2",
        "_score" : 2.611973,
        "_source" : {
          "name" : "宝塔镇河妖",
          "sex" : 1,
          "age" : 25,
          "address" : "上海",
          "remark" : "java developer"
        }
      },
      {
        "_index" : "test_index05",
        "_type" : "_doc",
        "_id" : "3",
        "_score" : 0.9918565,
        "_source" : {
          "name" : "铁锅炖大鹅",
          "sex" : 1,
          "age" : 19,
          "address" : "天津",
          "remark" : "java assistant"
        }
      },
      {
        "_index" : "test_index05",
        "_type" : "_doc",
        "_id" : "1",
        "_score" : 0.43250346,
        "_source" : {
          "name" : "天王盖地虎",
          "sex" : 1,
          "age" : 25,
          "address" : "上海",
          "remark" : "java"
        }
      }
    ]

5.4、基于dis_max实现best fields策略进行多字段搜索

best_fields策略: 搜索的document中的某一个field,尽可能多的匹配搜索条件。
most_fields策略:与best fields相反的是,尽可能多的字段匹配到搜索条件。

dis_max语法: 直接获取搜索的多条件中的,单条件query相关度分数最高的数据,以这个数据做相关度排序。

best fields策略实现举例(是找name字段中’秀儿’匹配相关度分数或remark字段中’java developer’匹配相关度分数,哪个高,就使用哪一个相关度分数进行结果排序。)

GET /test_index06/_search
{
  "query": {
    "dis_max": {
      "queries": [
        {
          "match": {
            "remark": "java developer"
          }
        },
        {
          "match": {
            "name": "秀儿"
          }
        }
      ]
    }
  }
}

结果

"hits" : [
      {
        "_index" : "test_index06",
        "_type" : "_doc",
        "_id" : "vkjNUIcB14FuHovqnIz1",
        "_score" : 2.3842063,
        "_source" : {
          "name" : "秀儿",
          "sex" : 1,
          "age" : 26,
          "book" : "Spring",
          "remark" : "C developer"
        }
      },
      {
        "_index" : "test_index06",
        "_type" : "_doc",
        "_id" : "vEjNUIcB14FuHovqKIyb",
        "_score" : 1.781607,
        "_source" : {
          "name" : "rod",
          "sex" : 1,
          "age" : 25,
          "book" : "Spring",
          "remark" : "java developer"
        }
      },
      {
        "_index" : "test_index06",
        "_type" : "_doc",
        "_id" : "vUjNUIcB14FuHovqaYzA",
        "_score" : 0.24116206,
        "_source" : {
          "name" : "rods",
          "sex" : 1,
          "age" : 26,
          "book" : "Spring",
          "remark" : "python developer"
        }
      },
      {
        "_index" : "test_index06",
        "_type" : "_doc",
        "_id" : "v0jOUIcB14FuHovqTYw0",
        "_score" : 0.24116206,
        "_source" : {
          "name" : "Tom",
          "sex" : 1,
          "age" : 26,
          "book" : "Spring",
          "remark" : "C developer"
        }
      },
      {
        "_index" : "test_index06",
        "_type" : "_doc",
        "_id" : "wEjOUIcB14FuHovqYYw0",
        "_score" : 0.24116206,
        "_source" : {
          "name" : "Amy",
          "sex" : 1,
          "age" : 26,
          "book" : "Spring",
          "remark" : "C developer"
        }
      }
    ]

5.5、基于tie_breaker参数优化dis_max搜索效果

我不想根据打分最高的那个字段进行排序展示,我想让其他的字段也参与进来咋办?

dis_max是将多个搜索query条件中相关度分数最高的用于结果排序,忽略其他query分数,在某些情况下,可能还需要其他query条件中的相关度介入最终的结果排序,这个时候可以使用tie_breaker参数来优化dis_max搜索。tie_breaker参数代表的含义是:将其他query搜索条件的相关度分数乘以参数值,再参与到结果排序中。如果不定义此参数,相当于参数值为0。所以其他query条件的相关度分数被忽略。

tie_breaker指定的值最大为1,除最高分字段,设置其他字段打分的策略,即其他字段得分乘指定的系数,如果不加这个tie_breaker则默认为0

GET /test_index06/_search
{
  "query": {
    "dis_max": {
      "queries": [
        {
          "match": {
            "remark": "java developer"
          }
        },
        {
          "match": {
            "name": "秀儿"
          }
        }
      ],
      "tie_breaker": 0.5
    }
  }
}

结果

"hits" : [
      {
        "_index" : "test_index06",
        "_type" : "_doc",
        "_id" : "vkjNUIcB14FuHovqnIz1",
        "_score" : 2.5047874,
        "_source" : {
          "name" : "秀儿",
          "sex" : 1,
          "age" : 26,
          "book" : "Spring",
          "remark" : "C developer"
        }
      },
      {
        "_index" : "test_index06",
        "_type" : "_doc",
        "_id" : "vEjNUIcB14FuHovqKIyb",
        "_score" : 1.781607,
        "_source" : {
          "name" : "rod",
          "sex" : 1,
          "age" : 25,
          "book" : "Spring",
          "remark" : "java developer"
        }
      },
      {
        "_index" : "test_index06",
        "_type" : "_doc",
        "_id" : "vUjNUIcB14FuHovqaYzA",
        "_score" : 0.24116206,
        "_source" : {
          "name" : "rods",
          "sex" : 1,
          "age" : 26,
          "book" : "Spring",
          "remark" : "python developer"
        }
      },
      {
        "_index" : "test_index06",
        "_type" : "_doc",
        "_id" : "v0jOUIcB14FuHovqTYw0",
        "_score" : 0.24116206,
        "_source" : {
          "name" : "Tom",
          "sex" : 1,
          "age" : 26,
          "book" : "Spring",
          "remark" : "C developer"
        }
      },
      {
        "_index" : "test_index06",
        "_type" : "_doc",
        "_id" : "wEjOUIcB14FuHovqYYw0",
        "_score" : 0.24116206,
        "_source" : {
          "name" : "Amy",
          "sex" : 1,
          "age" : 26,
          "book" : "Spring",
          "remark" : "C developer"
        }
      }
    ]

5.6、使用multi_match简化dis_max+tie_breaker(不常用)

ES中相同结果的搜索也可以使用不同的语法语句来实现。

查询方式1

GET /test_index06/_search
{
  "query": {
    "dis_max": {
      "queries": [
        {
          "match": {
            "name": "Tom"
          }
        },
        {
          "match": {
            "remark": {
              "query": "java developer",
              "boost": 2,
              "minimum_should_match": 2
            }
          }
        }
      ],
      "tie_breaker": 0.5
    }
  }
}

结果

"hits" : {
    "total" : {
      "value" : 2,
      "relation" : "eq"
    },
    "max_score" : 3.563214,
    "hits" : [
      {
        "_index" : "test_index06",
        "_type" : "_doc",
        "_id" : "vEjNUIcB14FuHovqKIyb",
        "_score" : 3.563214,
        "_source" : {
          "name" : "rod",
          "sex" : 1,
          "age" : 25,
          "book" : "Spring",
          "remark" : "java developer"
        }
      },
      {
        "_index" : "test_index06",
        "_type" : "_doc",
        "_id" : "v0jOUIcB14FuHovqTYw0",
        "_score" : 1.6360589,
        "_source" : {
          "name" : "Tom",
          "sex" : 1,
          "age" : 26,
          "book" : "Spring",
          "remark" : "C developer"
        }
      }
    ]

查询方式2(其中type常用的有best_fields和most_fields。^n代表权重,相当于"boost":n。)

GET /test_index06/_search
{
  "query": {
    "multi_match": {
      "query": "Tom java developer",
      "fields": [
        "name",
        "remark^2"
      ],
      "type": "best_fields",
      "tie_breaker": 0.5,
      "minimum_should_match": "50%"
    }
  }
}

结果

"hits" : [
      {
        "_index" : "test_index06",
        "_type" : "_doc",
        "_id" : "vEjNUIcB14FuHovqKIyb",
        "_score" : 3.563214,
        "_source" : {
          "name" : "rod",
          "sex" : 1,
          "age" : 25,
          "book" : "Spring",
          "remark" : "java developer"
        }
      },
      {
        "_index" : "test_index06",
        "_type" : "_doc",
        "_id" : "v0jOUIcB14FuHovqTYw0",
        "_score" : 1.877221,
        "_source" : {
          "name" : "Tom",
          "sex" : 1,
          "age" : 26,
          "book" : "Spring",
          "remark" : "C developer"
        }
      },
      {
        "_index" : "test_index06",
        "_type" : "_doc",
        "_id" : "vUjNUIcB14FuHovqaYzA",
        "_score" : 0.48232412,
        "_source" : {
          "name" : "rods",
          "sex" : 1,
          "age" : 26,
          "book" : "Spring",
          "remark" : "python developer"
        }
      },
      {
        "_index" : "test_index06",
        "_type" : "_doc",
        "_id" : "vkjNUIcB14FuHovqnIz1",
        "_score" : 0.48232412,
        "_source" : {
          "name" : "秀儿",
          "sex" : 1,
          "age" : 26,
          "book" : "Spring",
          "remark" : "C developer"
        }
      },
      {
        "_index" : "test_index06",
        "_type" : "_doc",
        "_id" : "wEjOUIcB14FuHovqYYw0",
        "_score" : 0.48232412,
        "_source" : {
          "name" : "Amy",
          "sex" : 1,
          "age" : 26,
          "book" : "Spring",
          "remark" : "C developer"
        }
      }
    ]

5.7、cross_fields搜索

cross fields : 一个唯一的标识,分部在多个fields中,使用这种唯一标识搜索数据就称为cross fields搜索。如:人名可以分为姓和名,地址可以分为省、市、区县、街道等。那么使用人名或地址来搜索document,就称为cross fields搜索。实现这种搜索,一般都是使用most fields搜索策略。因为这就不是一个field的问题。Cross fields搜索策略,是从多个字段中搜索条件数据。默认情况下,和most fields搜索的逻辑是一致的,计算相关度分数是和best fields策略一致的。一般来说,如果使用cross fields搜索策略,那么都会携带一个额外的参数operator。用来标记搜索条件如何在多个字段中匹配。在ES中也有cross fields搜索策略

例如(搜索条件中的java必须在name或remark字段中匹配,developer也必须在name或remark字段中匹配。)

GET /test_index06/_search
{
  "query": {
    "multi_match": {
      "query": "java developer",
      "fields": [
        "name",
        "remark"
      ],
      "type": "cross_fields",
      "operator": "and"
    }
  }
}

结果

"hits" : {
    "total" : {
      "value" : 1,
      "relation" : "eq"
    },
    "max_score" : 1.781607,
    "hits" : [
      {
        "_index" : "test_index06",
        "_type" : "_doc",
        "_id" : "vEjNUIcB14FuHovqKIyb",
        "_score" : 1.781607,
        "_source" : {
          "name" : "rod",
          "sex" : 1,
          "age" : 25,
          "book" : "Spring",
          "remark" : "java developer"
        }
      }
    ]

most field策略问题:most fields策略是尽可能匹配更多的字段,所以会导致精确搜索结果排序问题。又因为cross fields搜索,不能使用minimum_should_match来去除长尾数据。所以在使用most fields和cross fields策略搜索数据的时候,都有不同的缺陷。所以商业项目开发中,都推荐使用best fields策略实现搜索。

5.8、copy_to组合fields

场景:在电商网站,如果在搜索框中输入“手机”,点击搜索,那么是在商品的类型名称、商品的名称、商品的卖点、商品的描述等字段中,哪一个字段内进行数据的匹配?如果使用某一个字段做搜索不合适,那么使用_all做搜索是否合适?也不合适,因为_all字段中可能包含图片,价格等字段。

假设,有一个字段,其中的内容包括(但不限于):商品类型名称、商品名称、商品卖点等字段的数据内容。是否可以在这个特殊的字段上进行数据搜索匹配?(我理解的就是融合多个字段为一个,理解为该商品的摘要信息。)

以keyword字段举例,它包括了category_name、product_name、sell_point三个字段的内容。

{
  "category_name" : "手机",
  "product_name" : "一加6T手机",
  "price" : 568800,
  "sell_point" : "国产Android手机",
  "tags": ["8G+128G", "256G可扩展"],
  "color" : "红色",
  "keyword" : "手机 一加6T手机 国产Android手机"
}

copy_to : 就是将多个字段,复制到一个字段中,实现一个多字段组合。copy_to可以解决cross fields搜索问题,在商业项目中,也用于解决搜索条件默认字段问题。 如果需要使用copy_to语法,则需要在定义index的时候,手工指定mapping映射策略。

例如

PUT /test_index07/_mapping
{
  "properties": {
    "provice": {
      "type": "text",
      "analyzer": "standard",
      "copy_to": "address"
    },
    "city": {
      "type": "text",
      "analyzer": "standard",
      "copy_to": "address"
    },
    "street": {
      "type": "text",
      "analyzer": "standard",
      "copy_to": "address"
    },
    "address": {
      "type": "text",
      "analyzer": "standard"
    }
  }
}

上述的mapping定义中,是新增了4个字段,分别是provice、city、street、address,其中provice、city、street三个字段的值,会自动复制到address字段中,实现一个字段的组合。那么在搜索地址的时候,就可以在address字段中做条件匹配,从而避免most fields策略导致的问题。在维护数据的时候,不需对address字段特殊的维护。因为address字段是一个组合字段,是由ES自动维护的。类似java代码中的推导属性。在存储的时候,未必存在,但是在逻辑上是一定存在的,因为address是由3个物理存在的属性province、city、street组成的。

5.9、近似匹配

给定一个短语,或者单词,匹配包含全部或者部分的内容。

举例(test_index06中remark字段没有go相关内容)

GET /test_index06/_search
{
  "query": {
    "match": {
      "remark": "developer go"
    }
  }
}

结果

"hits" : [
      {
        "_index" : "test_index06",
        "_type" : "_doc",
        "_id" : "vEjNUIcB14FuHovqKIyb",
        "_score" : 0.24116206,
        "_source" : {
          "name" : "rod",
          "sex" : 1,
          "age" : 25,
          "book" : "Spring",
          "remark" : "java developer"
        }
      },
      {
        "_index" : "test_index06",
        "_type" : "_doc",
        "_id" : "vUjNUIcB14FuHovqaYzA",
        "_score" : 0.24116206,
        "_source" : {
          "name" : "rods",
          "sex" : 1,
          "age" : 26,
          "book" : "Spring",
          "remark" : "python developer"
        }
      },
      {
        "_index" : "test_index06",
        "_type" : "_doc",
        "_id" : "vkjNUIcB14FuHovqnIz1",
        "_score" : 0.24116206,
        "_source" : {
          "name" : "秀儿",
          "sex" : 1,
          "age" : 26,
          "book" : "Spring",
          "remark" : "C developer"
        }
      },
      {
        "_index" : "test_index06",
        "_type" : "_doc",
        "_id" : "v0jOUIcB14FuHovqTYw0",
        "_score" : 0.24116206,
        "_source" : {
          "name" : "Tom",
          "sex" : 1,
          "age" : 26,
          "book" : "Spring",
          "remark" : "C developer"
        }
      },
      {
        "_index" : "test_index06",
        "_type" : "_doc",
        "_id" : "wEjOUIcB14FuHovqYYw0",
        "_score" : 0.24116206,
        "_source" : {
          "name" : "Amy",
          "sex" : 1,
          "age" : 26,
          "book" : "Spring",
          "remark" : "C developer"
        }
      }
    ]

举例

GET /test_index06/_search
{
  "query": {
    "match": {
      "remark": "developerAA"
    }
  }
}

结果

"hits" : [ ]

如果需要的结果是有特殊要求,如:java developer 必须是一个完整的短语,不可分割;或document中的field内,包含的java 和developer 单词,且两个单词之间离的越近,相关度分数越高。那么这种特殊要求的搜索就是近似搜索。 搜索包括javb内容,搜索条件在java developer数据中搜索,或包括 j 搜索提示等数据近似搜索的一部分。如何上述特殊要求的搜索,使用match搜索语法就无法实现了。

5.10、match_phrase

短语搜索。就是搜索条件不分词。代表搜索条件不可分割。

举例(只会匹配出,java developer同时出现,并且连续的内容,即java developer为一个整体出现)

GET /test_index06/_search
{
  "query": {
    "match_phrase": {
      "remark": "java developer"
    }
  }
}

结果

"hits" : [
      {
        "_index" : "test_index06",
        "_type" : "_doc",
        "_id" : "vEjNUIcB14FuHovqKIyb",
        "_score" : 1.7816072,
        "_source" : {
          "name" : "rod",
          "sex" : 1,
          "age" : 25,
          "book" : "Spring",
          "remark" : "java developer"
        }
      }
    ]

5.10.1match phrase原理 —— term position

ES是如何实现match phrase短语搜索的?其实在ES中,使用match phrase做搜索的时候,也是和match类似,首先对搜索条件进行分词-analyze。将搜索条件拆分成hello和world。既然是分词后再搜索,ES是如何实现短语搜索的?
这里涉及到了倒排索引的建立过程。在倒排索引建立的时候,ES会先对document数据进行分词,如:

查询如下句子是如何分词的

GET _analyze
{
  "text": "hello world, java spark",
  "analyzer": "standard"
}

结果

{
  "tokens" : [
    {
      "token" : "hello",
      "start_offset" : 0,
      "end_offset" : 5,
      "type" : "<ALPHANUM>",
      "position" : 0
    },
    {
      "token" : "world",
      "start_offset" : 6,
      "end_offset" : 11,
      "type" : "<ALPHANUM>",
      "position" : 1
    },
    {
      "token" : "java",
      "start_offset" : 13,
      "end_offset" : 17,
      "type" : "<ALPHANUM>",
      "position" : 2
    },
    {
      "token" : "spark",
      "start_offset" : 18,
      "end_offset" : 23,
      "type" : "<ALPHANUM>",
      "position" : 3
    }
  ]
}

从上述结果中,可以看到。ES在做分词的时候,除了将数据切分外,还会保留一个position。position代表的是这个词在整个数据中的下标。当ES执行match phrase搜索的时候,首先将搜索条件hello world分词为hello和world。然后在倒排索引中检索数据,如果hello和world都在某个document的某个field出现时,那么检查这两个匹配到的单词的position是否是连续的,如果是连续的,代表匹配成功,如果是不连续的,则匹配失败。

5.10.2match phrase搜索参数 – slop

场景举例:在做搜索操作的是,如果搜索参数是hello spark。而ES中存储的数据是hello world, java spark。那么使用match phrase则无法搜索到。在这个时候,可以使用match来解决这个问题。但是,当我们需要在搜索的结果中,做一个特殊的要求:hello和spark两个单词距离越近,document在结果集合中排序越靠前,这个时候再使用match则未必能得到想要的结果。

ES的搜索中,对match phrase提供了参数slop。slop代表match phrase短语搜索的时候,单词最多移动多少次,可以实现数据匹配。在所有匹配结果中,多个单词距离越近,相关度评分越高,排序越靠前。这种使用slop参数的match phrase搜索,就称为近似匹配(proximity search)

在Elasticsearch中,slop是指在查询语句中,词项之间可以允许的最大距离。它是一种模糊匹配(fuzzy matching)方式,用于解决用户输入错误或者数据存储时不准确的情况。
当我们进行一个带有slop参数的查询时,Elasticsearch将按照文档中出现的顺序检查查询语句中的每个词,并尝试找到它们之间最接近的匹配。如果两个词之间的距离小于或等于slop的值,则它们被认为是匹配的。
例子:
假设我们有以下三个文档:

{
  "id": 1,
  "title": "quick brown fox"
}
{
  "id": 2,
  "title": "quick red fox"
}
{
  "id": 3,
  "title": "slow brown dog"
}

我们希望查找包含“quick”和“fox”的文档,并且它们之间的最大距离为1。我们可以使用以下查询:

{
  "query": {
    "match_phrase": {
      "title": {
        "query": "quick fox",
        "slop": 1
      }
    }
  }
}

该查询将返回文档1和2,但不会返回文档3,因为“slow”和“brown”之间的距离大于1。(关于距离你可以去看下对应的position字段,即match phrase原理 —— term position下讲解的内容)

需要注意的是,slop值越大,匹配的结果会越多,但是精度也会降低。因此,在使用slop时,需要根据实际情况进行权衡。

5.11使用match和proximity search实现召回率和精准度平衡。

召回率:召回率就是搜索结果比率,如:索引A中有100个document,搜索时返回多少个document,就是召回率(recall)。
精准度:就是搜索结果的准确率,如:搜索条件为hello java,在搜索结果中尽可能让短语匹配和hello java离的近的结果排序靠前,就是精准度(precision)。
如果在搜索的时候,只使用match phrase语法,会导致召回率低下,因为搜索结果中必须包含短语(包括proximity search)。
如果在搜索的时候,只使用match语法,会导致精准度底下,因为搜索结果排序是根据相关度分数算法计算得到。
那么如果需要在结果中兼顾召回率和精准度的时候,就需要将match和proximity search混合使用,来得到搜索结果。

索引test_index08下所有内容

"hits" : {
    "total" : {
      "value" : 4,
      "relation" : "eq"
    },
    "max_score" : 1.0,
    "hits" : [
      {
        "_index" : "test_index08",
        "_type" : "_doc",
        "_id" : "3",
        "_score" : 1.0,
        "_source" : {
          "f" : "hello, java is very good, spark is also very good"
        }
      },
      {
        "_index" : "test_index08",
        "_type" : "_doc",
        "_id" : "4",
        "_score" : 1.0,
        "_source" : {
          "f" : "java and spark, development language "
        }
      },
      {
        "_index" : "test_index08",
        "_type" : "_doc",
        "_id" : "5",
        "_score" : 1.0,
        "_source" : {
          "f" : "Java Spark is a fast and general-purpose cluster computing system. It provides high-level APIs in Java, Scala, Python and R, and an optimized engine that supports general execution graphs."
        }
      },
      {
        "_index" : "test_index08",
        "_type" : "_doc",
        "_id" : "6",
        "_score" : 1.0,
        "_source" : {
          "f" : "java spark and, development language "
        }
      }
    ]

查询1

GET /test_index08/_search
{
  "query": {
    "match": {
      "f": "java spark"
    }
  }
}

结果

"hits" : {
    "total" : {
      "value" : 4,
      "relation" : "eq"
    },
    "max_score" : 0.28046143,
    "hits" : [
      {
        "_index" : "test_index08",
        "_type" : "_doc",
        "_id" : "4",
        "_score" : 0.28046143,
        "_source" : {
          "f" : "java and spark, development language "
        }
      },
      {
        "_index" : "test_index08",
        "_type" : "_doc",
        "_id" : "6",
        "_score" : 0.28046143,
        "_source" : {
          "f" : "java spark and, development language "
        }
      },
      {
        "_index" : "test_index08",
        "_type" : "_doc",
        "_id" : "3",
        "_score" : 0.23111339,
        "_source" : {
          "f" : "hello, java is very good, spark is also very good"
        }
      },
      {
        "_index" : "test_index08",
        "_type" : "_doc",
        "_id" : "5",
        "_score" : 0.16973917,
        "_source" : {
          "f" : "Java Spark is a fast and general-purpose cluster computing system. It provides high-level APIs in Java, Scala, Python and R, and an optimized engine that supports general execution graphs."
        }
      }
    ]

查询2

GET /test_index08/_search
{
  "query": {
    "bool": {
      "must": [
        {
          "match": {
            "f": "java spark"
          }
        }
      ],
      "should": [
        {
          "match_phrase": {
            "f": {
              "query": "java spark",
              "slop": 50
            }
          }
        }
      ]
    }
  }
}

结果

"hits" : [
      {
        "_index" : "test_index08",
        "_type" : "_doc",
        "_id" : "6",
        "_score" : 0.56092286,
        "_source" : {
          "f" : "java spark and, development language "
        }
      },
      {
        "_index" : "test_index08",
        "_type" : "_doc",
        "_id" : "4",
        "_score" : 0.4815065,
        "_source" : {
          "f" : "java and spark, development language "
        }
      },
      {
        "_index" : "test_index08",
        "_type" : "_doc",
        "_id" : "3",
        "_score" : 0.32339638,
        "_source" : {
          "f" : "hello, java is very good, spark is also very good"
        }
      },
      {
        "_index" : "test_index08",
        "_type" : "_doc",
        "_id" : "5",
        "_score" : 0.30782324,
        "_source" : {
          "f" : "Java Spark is a fast and general-purpose cluster computing system. It provides high-level APIs in Java, Scala, Python and R, and an optimized engine that supports general execution graphs."
        }
      }
    ]

5.12前缀搜索 prefix search

使用前缀匹配实现搜索能力。通常针对keyword类型字段,也就是不分词的字段。

GET /test_a/_mapping
{
  "test_a" : {
    "mappings" : {
      "properties" : {
        "f" : {
          "type" : "text",
          "fields" : {
            "keyword" : {
              "type" : "keyword",
              "ignore_above" : 256
            }
          }
        }
      }
    }
  }
}

所有数据如下

"hits" : [
      {
        "_index" : "test_a",
        "_type" : "_doc",
        "_id" : "3",
        "_score" : 1.0,
        "_source" : {
          "f" : "hello, java is very good, spark is also very good"
        }
      },
      {
        "_index" : "test_a",
        "_type" : "_doc",
        "_id" : "4",
        "_score" : 1.0,
        "_source" : {
          "f" : "java and spark, development language "
        }
      }
    ]

查询

GET /test_a/_search
{
  "query": {
    "prefix": {
      "f.keyword": {
        "value": "j"
      }
    }
  }
}

结果

    "hits" : [
      {
        "_index" : "test_a",
        "_type" : "_doc",
        "_id" : "4",
        "_score" : 1.0,
        "_source" : {
          "f" : "java and spark, development language "
        }
      }
    ]

查询

GET /test_a/_search
{
  "query": {
    "prefix": {
      "f.keyword": {
        "value": "J"
      }
    }
  }
}

结果

"hits" : [ ]

针对前缀搜索,是对keyword类型字段而言。而keyword类型字段数据大小写敏感。前缀搜索效率比较低。前缀搜索不会计算相关度分数。前缀越短,效率越低。如果使用前缀搜索,建议使用长前缀。因为前缀搜索需要扫描完整的索引内容,所以前缀越长,相对效率越高。

5.13通配符搜索

通配符可以在倒排索引中使用,也可以在keyword类型字段中使用。
(性能很低,也是需要扫描完整的索引)
? :表示一个任意字符
*·:表示0~n个任意字符
查询

GET /test_a/_search
{
  "query": {
    "wildcard": {
      "f.keyword": {
        "value": "?e*o*"
      }
    }
  }
}

结果

"hits" : [
      {
        "_index" : "test_a",
        "_type" : "_doc",
        "_id" : "3",
        "_score" : 1.0,
        "_source" : {
          "f" : "hello, java is very good, spark is also very good"
        }
      }
    ]

5.14正则搜索

在Elasticsearch中,regexp查询是一种使用正则表达式进行搜索的查询方式。它可以在指定字段上匹配满足正则表达式的文本。

ES支持正则表达式,可以在倒排索引或keyword类型字段中使用。
例如,假设我们有一个包含文档标题和内容的索引,并想要查找所有标题或内容中包含“Elastic”和“search”的文档。这时候,就可以使用regexp查询来实现:

{
    "query": {
        "regexp": {
            "_all": ".*Elastic.*search.*"
        }
    }
}

在上述例子中,“_all” 表示对所有字段进行搜索,".*"表示任意字符出现0次或多次。

需要注意的是,正则表达式的查询效率较低,因为它需要对每个文档的每个字段都进行逐一匹配。如果对性能要求较高,应该尽量避免使用正则表达式查询。

另外,Elasticsearch还支持设置正则表达式的参数,如ignore_case(是否忽略大小写),max_determinized_states(最大化自动机状态数),boost(权重系数),以及flags(正则表达式标志)。这些参数可以提高查询的准确性和灵活性。

再举例

GET /test_a/_search
{
  "query": {
    "regexp": {
      "f.keyword": "[A-z].+"
    }
  }
}

结果

"hits" : [
      {
        "_index" : "test_a",
        "_type" : "_doc",
        "_id" : "3",
        "_score" : 1.0,
        "_source" : {
          "f" : "hello, java is very good, spark is also very good"
        }
      },
      {
        "_index" : "test_a",
        "_type" : "_doc",
        "_id" : "4",
        "_score" : 1.0,
        "_source" : {
          "f" : "java and spark, development language "
        }
      }
    ]

性能很低,需要扫描完整索引,应该尽量避免在大型索引中使用

5.15搜索推荐

在Elasticsearch中,match_phrase_prefix查询是一种结合了match和prefix两种查询的组合查询。它可以用于匹配以指定前缀开头的短语。

具体来说,match_phrase_prefix查询会先将查询字符串拆分成一个个词项(term),然后使用前缀匹配算法进行匹配。通常情况下,match_phrase_prefix查询适用于需要匹配长短语但又希望支持前缀匹配的场景。
搜索推荐: search as your type, 搜索提示。如:索引中有若干数据以“hello”开头,那么在输入hello的时候,推荐相关信息。(类似百度输入框)

查询

GET /test_a/_search
{
  "query": {
    "match_phrase_prefix": {
      "f": {
        "query": "java s",
        "slop": 10,
        "max_expansions": 10
      }
    }
  }
}

结果

"hits" : [
      {
        "_index" : "test_a",
        "_type" : "_doc",
        "_id" : "4",
        "_score" : 0.28650534,
        "_source" : {
          "f" : "java and spark, development language "
        }
      },
      {
        "_index" : "test_a",
        "_type" : "_doc",
        "_id" : "3",
        "_score" : 0.11460209,
        "_source" : {
          "f" : "hello, java is very good, spark is also very good"
        }
      }
    ]

其原理和match phrase类似,是先使用match匹配term数据(java),然后在指定的slop移动次数范围内,前缀匹配(s),max_expansions是用于指定prefix最多匹配多少个term(单词),超过这个数量就不再匹配了。
这种语法的限制是,只有最后一个term会执行前缀搜索。
执行性能很差,最后一个term是需要扫描所有符合slop要求的倒排索引的term。
因为效率较低,如果必须使用,则一定要使用参数max_expansions。

5.16fuzzy模糊搜索技术

Elasticsearch中的fuzzy模糊搜索技术是一种基于编辑距离(Levenshtein Distance)算法的全文检索技术。它允许在查询时匹配相似但不完全相同的单词。具体来说,当我们进行一个fuzzy query时,Elasticsearch将会在索引中查找与查询字符串最接近的项。如果查询字符串中有一个拼写错误或者一个字符丢失,fuzzy search可以帮助我们找到那些被错误拼写的项。另外,fuzzy search也能够在搜索时匹配多个单词之间的相似性。在Elasticsearch中,我们可以使用fuzziness参数来设置模糊度,该参数表示最大编辑距离,即允许的最大差异数量。默认值为2,这意味着如果两个单词的编辑距离超过2,则它们将不会被匹配。我们可以通过增加或减少该参数来调整模糊度,以便更好地满足我们的需求。

搜索的时候,可能搜索条件文本输入错误,如:hello world -> hello word。这种拼写错误还是很常见的。fuzzy技术就是用于解决错误拼写的(在英文中很有效,在中文中几乎无效。)。其中fuzziness代表value的值word可以修改多少个字母来进行拼写错误的纠正(修改字母的数量包含字母变更,增加或减少字母。)。f代表要搜索的字段名称。
查询

GET /test_a/_search
{
  "query": {
    "fuzzy": {
      "f": {
        "value": "word",
        "fuzziness": 2
      }
    }
  }
}

结果

 "hits" : [
      {
        "_index" : "test_a",
        "_type" : "_doc",
        "_id" : "3",
        "_score" : 0.43569255,
        "_source" : {
          "f" : "hello, java is very good, spark is also very good"
        }
      }
    ]

  1. Zen Discovery 是 Elasticsearch 中的一种自动发现机制,它用于在分布式环境下管理节点的发现和连接。Zen Discovery 能够自动感知节点的加入和离开,并在必要时重新分配数据和重新平衡群集。
    Zen Discovery 机制包括以下几个方面:
    1.Ping 操作:每个节点会定期向其他节点发送 ping 请求,以确定其他节点是否还在运行。如果一个节点在一定时间内没有响应,那么它就被认为已经离开了群集。
    2.Unicast 发现:节点之间可以通过互相发送地址列表来进行发现。在这种方式下,节点需要知道其他节点的 IP 地址和端口号,才能够加入群集。当节点启动时,它会向配置的节点列表发送加入请求,如果请求成功,则会将该节点加入群集。
    3.Multicast 发现:在使用 Multicast 发现机制时,节点可以通过多播地址来进行发现。每个节点将自己的 IP 地址和端口号发布到特定的多播地址上,其他节点可以从该地址上接收到所有节点的信息,从而发现新的节点。这种方式下,节点可以更加灵活地管理群集,可以随时加入和离开群集。
    4.Master 选举:Zen Discovery 还包括了 Master 节点的选举机制,选举出的 Master 节点会负责协调群集中的各个节点。
    (当然,在某些情况下,可能需要手动指定主节点或禁用主节点竞选过程。可以通过在 elasticsearch.yml 配置文件中设置 node.master 参数来实现。如果将该参数设置为 false,则表示禁用该节点的主节点竞选功能;如果将该参数设置为 true,则表示该节点可以参与主节点竞选。默认情况下,所有节点都会参与主节点竞选,因此无需手动配置。) ↩︎

  2. 在 ElasticSearch 集群中,Master 节点维护的元数据包括以下信息:
    1.集群状态:保存了当前集群的状态,如运行状态、健康状态等。
    2.索引元数据:保存了所有索引的信息,例如字段映射、分片数量、副本数量、索引别名等。
    3.节点元数据:保存了所有节点的信息,例如 IP 地址、节点名称、可用空间、JVM 信息等。
    4.分片分配信息:保存了每个分片所属的节点信息、是否是主分片等。
    5.节点故障检测信息:保存了节点最近一次的心跳信息和下线时间,用于检测节点是否失效。
    这些元数据都存储在 Master 节点的内存中,并与其他节点进行同步,以确保集群中所有节点都拥有相同的元数据视图。通过 Master 节点维护这些元数据,可以实现集群管理和协调,确保数据的高可用性、一致性和完整性。 ↩︎文章来源地址https://www.toymoban.com/news/detail-484387.html

到了这里,关于四、初探[ElasticSearch]集群架构原理与搜索技术的文章就介绍完了。如果您还想了解更多内容,请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章,希望大家以后多多支持TOY模板网!

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处: 如若内容造成侵权/违法违规/事实不符,请点击违法举报进行投诉反馈,一经查实,立即删除!

领支付宝红包 赞助服务器费用

相关文章

  • 大数据小白初探HDFS架构原理:带你揭秘背后的真相(一)

             目录 1.前言 2. HDFS架构 2.1 架构定义 2.2 揭秘架构 2.3 HDFS核心结构  3. HDFS 的优缺点         3.1 HDFS 的优点         3.2 HDFS 的缺点 4. HDFS 的应用场景 5. 总结         前面的文章写了一篇,大数据方面的基础知识,目的是希望大数据小白可以对大数据能有个清楚

    2024年02月21日
    浏览(49)
  • Elasticsearch:搜索架构

    为了理解为什么全文搜索是一个很难解决的问题,让我们想一个例子。 假设你正在托管一个博客发布网站,其中包含数亿甚至数十亿的博客文章,每个博客文章包含数百个单词,类似于 CSDN。 执行全文搜索意味着任何用户都可以搜索 “java” 或 “学习编程” 之类的内容,并

    2024年02月04日
    浏览(33)
  • ElasticSearch(五)集群架构

            特性:高可用 可扩展         优势:提高系统可用性,部分节点停止服务整个集群不受影响                    存储可水平扩展 概念 集群         一个集群可以有一个或者多个节点         不同的集群通过不同的名字来区分,默认名字“elasticsearch“   

    2024年01月17日
    浏览(38)
  • Elasticsearch 集群架构监测 调试 优化

    Elasticsearch7.x是一个基于Lucene的分布式搜索引擎具有以下特点: 高性能:能够处理海量数据并实现实时搜索。其内置了负载均衡和容错机制,提供了高可用性和伸缩性。 灵活性:支持文本全文检索、结构化搜索、地理位置搜索等多种搜索方式,同时支持自定义插件扩展。 易用

    2024年02月13日
    浏览(40)
  • 架构师系列-搜索引擎ElasticSearch(一)

    wget https://artifacts.elastic.co/downloads/elasticsearch/elasticsearch-7.17.5- linux-x86_64.tar.gz tar -zvxf elasticsearch-7.17.5-linux-x86_64.tar.gz 关闭防火墙 配置elasticsearch.yml   修改Linux句柄数   关闭swap 因为ES的数据大量都是常驻内存的,一旦使用了虚拟内存就会导致查询速度下降,一般需要关闭 swap,

    2024年04月14日
    浏览(44)
  • 【ES专题】ElasticSearch集群架构剖析

    个人感觉集群架构其实都有点大同小异,看了这么多集群架构之后,感觉无非要考虑的地方就几点: 使用何种通信协议去同步数据,互相通信 采用何种策略同步数据(异步还是同步) 如何保证一致性,保证到什么程度(【最终一致性】 or【实时一致性 / 强一致性】) 使用何

    2024年02月04日
    浏览(59)
  • 架构师系列-搜索引擎ElasticSearch(四)- 高级查询

    ES查询 该方式可以通过kabana、curl、elasticsearch-head(纯前端)去操作 term查询和字段类型有关系,首先回顾一下ElasticSearch两个数据类型 ElasticSearch两个数据类型 1、text:会分词,不支持聚合 2、keyword:不会分词,将全部内容作为一个词条,支持聚合 term查询:不会对查询条件进

    2024年04月15日
    浏览(71)
  • 【ElasticSearch系列-06】Es集群架构的搭建以及集群的核心概念

    ElasticSearch系列整体栏目 内容 链接地址 【一】ElasticSearch下载和安装 https://zhenghuisheng.blog.csdn.net/article/details/129260827 【二】ElasticSearch概念和基本操作 https://blog.csdn.net/zhenghuishengq/article/details/134121631 【三】ElasticSearch的高级查询Query DSL https://blog.csdn.net/zhenghuishengq/article/details/1

    2024年02月04日
    浏览(60)
  • Elasticsearch数据搜索原理

    Elasticsearch 是一个开源的、基于 Lucene 的分布式搜索和分析引擎,设计用于云计算环境中,能够实现实时的、可扩展的搜索、分析和探索全文和结构化数据。它具有高度的可扩展性,可以在短时间内搜索和分析大量数据。 Elasticsearch 不仅仅是一个全文搜索引擎,它还提供了分布

    2024年02月08日
    浏览(46)
  • Elasticsearch集群搭建、数据分片以及位置坐标实现附近的人搜索

    es使用两种不同的方式来发现对方: 广播 单播 也可以同时使用两者,但默认的广播,单播需要已知节点列表来完成 当es实例启动的时候,它发送了广播的ping请求到地址 224.2.2.4:54328 。而其他的es实例使用同样的集群名称响应了这个请求。 一般这个默认的集群名称就是上面的

    2024年02月06日
    浏览(51)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包,优惠每天领

二维码1

领取红包

二维码2

领红包