Elasticsearch（7.x）集成
Spring Data Elasticsearch
Spring Data Elasticsearch 是 Spring Data 项目下的一个子模块，旨在为 Java 开发者提供一个简化与 Elasticsearch 搜索引擎交互的接口。它基于 Spring 框架的编程模型，通过 Repository 模式和注解驱动的方式，将 Elasticsearch 的复杂操作封装成简单的 Java 方法。
Spring Data集成
创建项目
创建个SpringBoot项目，使用Maven进行项目构建和依赖管理，集成了Spring Boot、Spring Data JPA和Spring Data Elasticsearch。
<!-- 依赖包 -->
<parent>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-parent</artifactId>
<version>2.3.6.RELEASE</version>
<relativePath/>
</parent>
<groupId>cn.good.yan</groupId>
<artifactId>es-spring</artifactId>
<version>1.0-SNAPSHOT</version>
<properties>
<maven.compiler.source>8</maven.compiler.source>
<maven.compiler.target>8</maven.compiler.target>
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
</properties>
<dependencies>
<dependency>
<groupId>org.projectlombok</groupId>
<artifactId>lombok</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-data-elasticsearch</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-devtools</artifactId>
<scope>runtime</scope>
<optional>true</optional>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-test</artifactId>
<scope>test</scope>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-test</artifactId>
</dependency>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-test</artifactId>
</dependency>
</dependencies>
配置文件
server.port=8090
# es 服务地址
elasticsearch.host=127.0.0.1
# es 服务端口
elasticsearch.port=1001
# 配置日志级别,开启 debug 日志
logging.level.cn.good.yan.es=debug
实体类
package cn.good.yan.es.pojo;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import lombok.ToString;
import org.springframework.data.annotation.Id;
import org.springframework.data.elasticsearch.annotations.Document;
import org.springframework.data.elasticsearch.annotations.Field;
import org.springframework.data.elasticsearch.annotations.FieldType;
/**
* ES - 实体
*/
@Data
@NoArgsConstructor
@AllArgsConstructor
@ToString
// product 索引名称， shards 主分片是3个，replicas副本是各1个
@Document(indexName = "product", shards = 3, replicas = 1)
public class Product {
//必须有id，是全局唯一的标识，等同于es中的"_id"
@Id
private Long id; //商品唯一标识
/**
* type : 字段数据类型
* analyzer : 分词器类型： ik_max_word=会将文本做最细粒度的拆分
* index : 是否索引(默认:true)
* Keyword : 短语,不进行分词
*/
@Field(type = FieldType.Text, analyzer = "ik_max_word")
private String title;//商品名称
// Keyword 是关键字，不能被分词
@Field(type = FieldType.Keyword)
private String category;//分类名称
@Field(type = FieldType.Double)
private Double price;//商品价格
// Keyword 是关键字，不能被分词，并且不能被查询，进行索引关联
@Field(type = FieldType.Keyword, index = false)
private String images;//图片地址
}
配置类
package cn.good.yan.es.config;
import lombok.Data;
import org.apache.http.HttpHost;
import org.elasticsearch.client.RestClient;
import org.elasticsearch.client.RestClientBuilder;
import org.elasticsearch.client.RestHighLevelClient;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.elasticsearch.config.AbstractElasticsearchConfiguration;
/**
* ES的配置类
* 在application.properties里配置过elasticsearch
*/
@ConfigurationProperties(prefix = "elasticsearch")
@Configuration
@Data
public class ElasticsearchConfig extends AbstractElasticsearchConfiguration {
private String host;
private Integer port;
//重写父类方法
@Override
public RestHighLevelClient elasticsearchClient() {
RestClientBuilder builder = RestClient.builder(new HttpHost(host, port));
RestHighLevelClient restHighLevelClient = new
RestHighLevelClient(builder);
return restHighLevelClient;
}
}
数据访问对象
package cn.good.yan.es.dao;
import cn.good.yan.es.pojo.Product;
import org.springframework.data.elasticsearch.repository.ElasticsearchRepository;
import org.springframework.stereotype.Repository;
/**
* ES-数据访问对象
*/
@SuppressWarnings("all")
@Repository
public interface ProductDao extends ElasticsearchRepository<Product, Long> {
}
集成测试-索引操作
package cn.good.yan;
import cn.good.yan.es.pojo.Product;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.data.elasticsearch.core.ElasticsearchRestTemplate;
/**
* ES - 测试类1 （初始化、创建删除索引）
* 1. 初始化，会创建索引
* 2. 删除指定索引
* 可在httml目录下，test1.http，查看ES中当前索引的情况
*/
@SpringBootTest
public class SpringDataESIndexTest1 {
@Autowired
private ElasticsearchRestTemplate elasticsearchRestTemplate;
// 1.创建索引并增加映射配置
// 运行，该测试，进行初始化，会把product索引创建出来
@Test
public void createIndex(){
// 创建索引，系统初始化会自动创建索引
System.out.println("创建索引，product索引创建成功");
}
// 2.删除索引，制定索引
@Test
public void deleteIndex(){
boolean flg = elasticsearchRestTemplate.deleteIndex(Product.class);
System.out.println("删除索引 = " + flg);
}
}
集成测试-文档操作
package cn.good.yan;
import cn.good.yan.es.dao.ProductDao;
import cn.good.yan.es.pojo.Product;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.data.domain.Page;
import org.springframework.data.domain.PageRequest;
import org.springframework.data.domain.Sort;
import java.util.ArrayList;
import java.util.List;
/**
* ES - 测试类2 （文档的增删改）
* 1. 新增-文档，
* 2. 修改-文档
* 3. 根据文档id查询
* 4. 根据该索引下的全部文档
* 5. 删除-文档
* 可在httml目录下，test2.http，查看ES中当前索引的情况
*/
@SpringBootTest
public class SpringDataESProductDaoTest2 {
@Autowired
private ProductDao productDao;
/**
* 1.新增-文档，
* 文档id是2，执行完，可在test2.http下，查看对应的结果
* <p>
* GET http://localhost:1001/product/_doc/2
*/
@Test
public void save() {
Product product = new Product();
product.setId(2L); // 文档id
product.setTitle("华为手机");
product.setCategory("手机");
product.setPrice(2999.0);
product.setImages("http://www.baidu/hw.jpg");
productDao.save(product);
}
/**
* 2.修改-文档
* 文档id是2，执行完，可在test2.http下，查看对应的结果
* <p>
* GET http://localhost:1001/product/_doc/2
*/
@Test
public void update() {
Product product = new Product();
product.setId(2L); // 文档id
product.setTitle("小米2手机");
product.setCategory("手机");
product.setPrice(3999.0);
product.setImages("http://www.baidu/xm.jpg");
productDao.save(product);
}
/**
* 3。根据文档id查询
* 文档id是2，执行完，可在test2.http下，查看对应的结果
*/
@Test
public void findById() {
Product product = productDao.findById(2L).get();
System.out.println(product);
}
/**
* 4.根据该索引下的全部文档
*/
@Test
public void findAll() {
Iterable<Product> products = productDao.findAll();
for (Product product : products) {
System.out.println(product);
}
}
/**
* 5. 删除-文档
* 文档id是2，执行完，可在test2.http下，查看对应的结果
*/
@Test
public void delete() {
Product product = new Product();
product.setId(2L);
productDao.delete(product);
}
/**
* 6. 批量新增
*/
@Test
public void saveAll() {
List<Product> productList = new ArrayList<>();
for (int i = 0; i < 10; i++) {
Product product = new Product();
product.setId(Long.valueOf(i));
product.setTitle("[" + i + "]OPPO手机");
product.setCategory("手机");
product.setPrice(4999.0 + i);
product.setImages("http://www.百度/oppo.jpg");
productList.add(product);
}
productDao.saveAll(productList);
}
/**
* 7.分页查询
*/
@Test
public void findByPageable() {
// 设置排序(排序方式，正序还是倒序，排序的 id)
Sort sort = Sort.by(Sort.Direction.DESC, "id");
int currentPage = 0; //当前页，第一页从 0 开始， 1 表示第二页
int pageSize = 5; //每页显示多少条
// 设置查询分页
PageRequest pageRequest = PageRequest.of(currentPage, pageSize, sort);
// 分页查询
Page<Product> productPage = productDao.findAll(pageRequest);
for (Product Product : productPage.getContent()) {
System.out.println(Product);
}
}
}
集成测试-文档搜索
package cn.good.yan;
import cn.good.yan.es.dao.ProductDao;
import cn.good.yan.es.pojo.Product;
import org.elasticsearch.index.query.QueryBuilders;
import org.elasticsearch.index.query.TermQueryBuilder;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.data.domain.PageRequest;
/**
* ES - 测试类3 （文档搜索）
* 1. term 查询
* 2. term 查询 查询加分页
* 可在httml目录下，test3.http，查看ES中当前索引的情况
*/
@SpringBootTest
public class SpringDataESSearchTest3 {
@Autowired
private ProductDao productDao;
/**
* 1. term 查询 ，前提ES的插件，需要安装IK分词器
* search(termQueryBuilder) 调用搜索方法，参数查询构建器对象
*/
@Test
public void termQuery(){
// 查询 title=OPPO 的文档数据
TermQueryBuilder termQueryBuilder = QueryBuilders.termQuery("category", "手机");
Iterable<Product> products = productDao.search(termQueryBuilder);
for (Product product : products) {
System.out.println(product);
}
}
/**
* 2. term 查询加分页
*/
@Test
public void termQueryByPage(){
int currentPage= 0 ; // 当前页，第一页从 0 开始， 1 表示第二页
int pageSize = 5; // 每页显示多少条
// 设置查询分页
PageRequest pageRequest = PageRequest.of(currentPage, pageSize);
TermQueryBuilder termQueryBuilder = QueryBuilders.termQuery("category", "手机");
Iterable<Product> products = productDao.search(termQueryBuilder,pageRequest);
for (Product product : products) {
System.out.println(product);
}
}
}
SparkStreaming集成
是Spark core API的扩展，支持实时数据流的处理，并且具有可扩展，高吞吐量，容错的特点。数据可以从许多来源获取,如Kafka， Flume，Kinesis或TCP sockets，并且可以使用复杂的算法进行处理，这些算法使用诸如 map，reduce，join和 window等高级函数表示。最后，处理后的数据可以推送到文件系统，数据库等。实际上，您可以将Spark的机器学习和图形处理算法应用于数据流。
需要安装scala插件，
<dependencies>
<dependency>
<groupId>org.apache.spark</groupId>
<artifactId>spark-core_2.12</artifactId>
<version>3.0.0</version>
</dependency>
<dependency>
<groupId>org.apache.spark</groupId>
<artifactId>spark-streaming_2.12</artifactId>
<version>3.0.0</version>
</dependency>
<dependency>
<groupId>org.elasticsearch</groupId>
<artifactId>elasticsearch</artifactId>
<version>7.8.0</version>
</dependency>
<!-- elasticsearch 的客户端 -->
<dependency>
<groupId>org.elasticsearch.client</groupId>
<artifactId>elasticsearch-rest-high-level-client</artifactId>
<version>7.8.0</version>
</dependency>
<!-- elasticsearch 依赖 2.x 的 log4j -->
<dependency>
<groupId>org.apache.logging.log4j</groupId>
<artifactId>log4j-api</artifactId>
<version>2.8.2</version>
</dependency>
<dependency>
<groupId>org.apache.logging.log4j</groupId>
<artifactId>log4j-core</artifactId>
<version>2.8.2</version>
</dependency>
</dependencies>
功能实现
import org.apache.http.HttpHost
import org.apache.spark.SparkConf
import org.apache.spark.streaming.dstream.ReceiverInputDStream
import org.apache.spark.streaming.{Seconds, StreamingContext}
import org.elasticsearch.action.index.IndexRequest
import org.elasticsearch.client.indices.CreateIndexRequest
import org.elasticsearch.client.{RequestOptions, RestClient, RestHighLevelClient}
import org.elasticsearch.common.xcontent.XContentType
import java.util.Date
object SparkStreamingESTest {
def main(args: Array[String]): Unit = {
val sparkConf = new SparkConf().setMaster("local[*]").setAppName("ESTest")
val ssc = new StreamingContext(sparkConf, Seconds(3))
val ds: ReceiverInputDStream[String] = ssc.socketTextStream("localhost", 9999)
ds.foreachRDD(
rdd => {
println("*************** " + new Date())
rdd.foreach(
data => {
val client = new RestHighLevelClient(RestClient.builder(new HttpHost("localhost", 9200, "http")));
// 新增文档 - 请求对象
val request = new IndexRequest();
// 设置索引及唯一性标识
val ss = data.split(" ")
println("ss = " + ss.mkString(","))
request.index("sparkstreaming").id(ss(0));
val productJson =
s"""
| { "data":"${ss(1)}" }
|""".stripMargin;
// 添加文档数据，数据格式为 JSON 格式
request.source(productJson,XContentType.JSON);
// 客户端发送请求，获取响应对象
val response = client.index(request,
RequestOptions.DEFAULT);
System.out.println("_index:" + response.getIndex());
System.out.println("_id:" + response.getId());
System.out.println("_result:" + response.getResult());
client.close()
}
)
}
)
ssc.start()
ssc.awaitTermination()
}
}
Flink集成
Apache Flink是一个框架和分布式处理引擎，用于对无界和有界数据流进行有状态计算。在Spark火热的同时，也默默地发展自己，并尝试着解决其他计算框架的问题。慢慢地，随着这些问题的解决，Flink 慢慢被绝大数程序员所熟知并进行大力推广，阿里公司在2015年改进Flink，并创建了内部分支Blink，目前服务于阿里集团内部搜索、推荐、广告和蚂蚁等大量核心实时业务。
<dependencies>
<dependency>
<groupId>org.apache.flink</groupId>
<artifactId>flink-scala_2.12</artifactId>
<version>1.12.0</version>
</dependency>
<dependency>
<groupId>org.apache.flink</groupId>
<artifactId>flink-streaming-scala_2.12</artifactId>
<version>1.12.0</version>
</dependency>
<dependency>
<groupId>org.apache.flink</groupId>
<artifactId>flink-clients_2.12</artifactId>
<version>1.12.0</version>
</dependency>
<dependency>
<groupId>org.apache.flink</groupId>
<artifactId>flink-connector-elasticsearch7_2.11</artifactId>
<version>1.12.0</version>
</dependency>
<!-- jackson -->
<dependency>
<groupId>com.fasterxml.jackson.core</groupId>
<artifactId>jackson-core</artifactId>
<version>2.11.1</version>
</dependency>
</dependencies>
功能实现
import org.apache.flink.api.common.functions.RuntimeContext;
import org.apache.flink.streaming.api.datastream.DataStreamSource;
import org.apache.flink.streaming.api.environment.StreamExecutionEnvironment;
import org.apache.flink.streaming.connectors.elasticsearch.ElasticsearchSinkFunction;
import org.apache.flink.streaming.connectors.elasticsearch.RequestIndexer;
import org.apache.flink.streaming.connectors.elasticsearch7.ElasticsearchSink;
import org.apache.http.HttpHost;
import org.elasticsearch.action.index.IndexRequest;
import org.elasticsearch.client.Requests;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
public class FlinkElasticsearchSinkTest {
public static void main(String[] args) throws Exception {
StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
DataStreamSource<String> source = env.socketTextStream("localhost", 9999);
List<HttpHost> httpHosts = new ArrayList<>();
httpHosts.add(new HttpHost("127.0.0.1", 9200, "http"));
//httpHosts.add(new HttpHost("10.2.3.1", 9200, "http"));
// use a ElasticsearchSink.Builder to create an ElasticsearchSink
ElasticsearchSink.Builder<String> esSinkBuilder = new ElasticsearchSink.Builder<>(httpHosts,
new ElasticsearchSinkFunction<String>() {
public IndexRequest createIndexRequest(String element) {
Map<String, String> json = new HashMap<>();
json.put("data", element);
return Requests.indexRequest()
.index("my-index")
//.type("my-type")
.source(json);
}
@Override
public void process(String element, RuntimeContext ctx, RequestIndexer indexer) {
indexer.add(createIndexRequest(element));
}
}
);
// configuration for the bulk requests; this instructs the sink to emit after every element, otherwise they would be buffered
esSinkBuilder.setBulkFlushMaxActions(1);
// provide a RestClientFactory for custom configuration on the internally createdREST client
// esSinkBuilder.setRestClientFactory(
// restClientBuilder -> {
// restClientBuilder.setDefaultHeaders(...)
// restClientBuilder.setMaxRetryTimeoutMillis(...)
// restClientBuilder.setPathPrefix(...)
// restClientBuilder.setHttpClientConfigCallback(...)
// }
// );
source.addSink(esSinkBuilder.build());
env.execute("flink-es");
}
}
Elasticsearch优化
硬件选择
ES基于Lucene，索引和文档数据存本地磁盘，存储路径可在config目录下的 elasticsearch.yml 配置文件中设置，如下：
# Path to directory where to store the data (separate multiple locations by comma):
path.data: /path/to/data
# Path to log files:
path.logs: /path/to/logs
ES很依赖磁盘，磁盘 I/O 往往是服务器瓶颈，吞吐量越大节点越稳。磁盘优化要点：
- 使用SSD（固态硬盘）比机械磁盘性能好很多
- 可用 RAID0 提升 I/O，不建议用镜像 / 校验 RAID，ES 副本已提供冗余
- 另外，使用多块硬盘，并允许ES通过多个path data目录配置把数据条带化分配到它们上面
- 不要使用远程挂载的存储，不要用 NFS、SMB 等远程存储，延迟高、严重影响性能
分片策略
合理设置分片数
ES 的分片和副本支撑了分布式与故障转移能力，但数量不可无限制分配；且索引分片数确定后，因路由机制限制无法后期修改。
业务索引的分片数量，需要架构师和技术人员提前预估业务增长规模，分阶段做横向扩展，并为下一阶段预留充足资源。一般来说，我们遵循一些原则：
-
需控制单个分片的硬盘占用量，不超过 ES 最大 JVM 堆空间（通常建议不超 32G）。例如总索引容量约 500G 时，分片数设置为 16 个左右即可；规划时需同时结合下文的节点数量原则。
-
分片数需结合节点数量（一个节点通常对应一台物理机）规划：若分片数远超节点数，易导致单个节点承载多个分片，一旦该节点故障，即便配置了 1 个以上副本，仍可能引发数据丢失、集群无法恢复。因此分片数一般不超过节点数的 3 倍。
-
主分片，副本和节点最大数之间数量，我们分配的时候可以参考以下关系：
节点数<=主分片数 *（副本数+1）
例子：如果我们有3个节点，分片不能超过9。
推迟分片分配
对于节点瞬时中断的问题，默认情况，集群会等待一分钟来查看节点是否会重新加入，如果这个节点在此期间重新加入，重新加入的节点会保持其现有的分片数据，不会触发新的分片分配。这样就可以减少 ES 在自动再平衡可用分片时所带来的极大开销。
通过修改参数 delayed_timeout ，可以延长再均衡的时间，可以全局设置也可以在索引级别进行修改：
#PUT /_all/_settings
{
"settings": {
"index.unassigned.node_left.delayed_timeout": "5m"
}
}
路由选择
Elasticsearch 如何知道一个文档应该存放到哪个分片中呢？它其实是通过下面这个公式来计算出来：
shard = hash(routing) % number_of_primary_shards
# 路由计算：hash（主键id）% 主分片数量 = 【0,1,2】
不带routing查询（全分片扫描）
当查询请求未指定 routing（路由）参数时，协调节点无法确定目标数据所在的具体分片，因此查询会经历两个核心步骤：
- 分发：协调节点将查询请求广播到索引的所有分片（主分片 / 副本分片均可）。
- 聚合：协调节点收集所有分片返回的查询结果，统一进行排序、去重等处理后，再将最终结果返回给用户。
带routing查询（精准分片定位）
若查询时指定了 routing 参数（如用户 ID、订单 ID 等），ES 会直接根据 routing 值的哈希结果，精准定位到存储该数据的唯一分片，无需遍历所有分片：
- 协调节点仅向目标分片发送查询请求。
- 目标分片返回结果后，协调节点无需大规模聚合排序，直接将结果返回给用户，查询效率大幅提升。
写入速度优化
ES 默认配置兼顾了数据可靠性、写入速度和搜索实时性，实际使用时需按业务需求偏向性优化。针对搜索要求低、写入要求高的场景，可通过以下策略提升写索引性能：
- 加大Translog Flush，目的是降低Iops、Writeblock。
- 增加Index Refesh间隔，目的是减少Segment Merge的次数。
- 调整Bulk 线程池和队列。
- 优化节点间的任务分布。
- 优化Lucene层的索引建立，目的是降低CPU及IO。
参考磁盘的具体写操作例图。
优化存储设备
ES 是一种密集使用磁盘的应用，在段合并的时候会频繁操作磁盘，所以对磁盘要求较高，当磁盘速度提升之后，集群的整体性能会大幅度提高。
合理使用合并
Lucene 以 “段” 存储数据，新数据写入会生成新段；段数量过多会占用更多句柄 / CPU、降低查询效率。由于段合并耗 I/O，ES 默认仅后台定期合并，策略偏保守。
减少 Refresh 的次数
Lucene 新增数据时会先写入内存，默认每隔1秒执行一次 Refresh，把数据刷到操作系统缓存，使其可被搜索。若对实时性要求不高，可延长 refresh_interval（比如设为 30 秒），减少刷新与段生成次数，降低 I/O 和合并压力，但会占用更多堆内存。
加大 Flush 设置
Flush 的主要目的是把文件缓存系统中的段持久化到硬盘，当 Translog 的数据量达到 512MB 或者 30 分钟时，会触发一次 Flush。
index.translog.flush_threshold_size 参数的默认值是 512MB；
可调大 index.translog.flush_threshold_size 参数，但需为系统文件缓存预留足够空间。
减少副本的数量
ES 为了保证集群的可用性，提供了 Replicas（副本）支持，然而每个副本也会执行分析、索引及可能的合并过程，所以 Replicas 的数量会严重影响写索引的效率。
如果我们需要大批量进行写入操作，可以先禁止Replica复制，在写入时可临时设 index.number_of_replicas: 0 关闭副本，写入完成后再恢复副本数。
内存设置
ES 默认安装后堆内存仅配置 1GB，远无法满足实际业务需求。若通过解压包安装，可在 ES 安装目录的 jvm.options 文件中调整堆内存：Xms 为堆初始大小，Xmx 为堆最大可分配内存（默认均为 1GB）。
确保 Xmx 和 Xms 的大小是相同的，其目的是为了能够在 Java 垃圾回收机制清理完堆区后不需要重新分隔计算堆区的大小而浪费资源，可以减轻伸缩堆大小带来的压力。
堆内存并非越大越好，需遵循：
- 不超物理内存 50%（保障 Lucene 缓存空间）
- 不超 32GB（避免 64 位指针带来的性能损耗）
最终我们都会采用31G设置
-Xms 31g
-Xmx 31g
假设你有个机器有 128 GB 的内存，你可以创建两个节点，每个节点内存分配不超过 32 GB。也就是说不超过 64 GB 内存给 ES 的堆内存，剩下的超过 64 GB 的内存给 Lucene。
重要配置
| 参数名 | 参数值 | 说明 |
|---|---|---|
| cluster.name | elasticsearch | 配置 ES 的集群名称，默认值是 ES，建议改成与所存数据相关的名称， ES 会自动发现在同一网段下的 集群名称相同的节点。 |
| node.name | node-1 | 集群中的节点名，在同一个集群中不能重复。节点 的名称一旦设置，就不能再改变了。当然，也可以 设 置 成 服 务 器 的 主 机 名 称 ， 例 如 node.name:${HOSTNAME}。 |
| node.master | true | 指定该节点是否有资格被选举成为 Master 节点，默 认是 True，如果被设置为 True，则只是有资格成为 Master 节点，具体能否成为 Master 节点，需要通 过选举产生。 |
| node.data | true | 指定该节点是否存储索引数据，默认为 True。数据 的增、删、改、查都是在 Data 节点完成的。 |
| index.number_of_shards | 1 | 设置都索引分片个数，默认是 1 片。也可以在创建 索引时设置该值，具体设置为多大都值要根据数据 量的大小来定。如果数据量不大，则设置成 1 时效 率最高 |
| index.number_of_replicas | 1 | 设置默认的索引副本个数，默认为 1 个。副本数越 多，集群的可用性越好，但是写索引时需要同步的 数据越多。 |
| transport.tcp.compress | true | 设置在节点间传输数据时是否压缩，默认为 False， 不压缩 |
| discovery.zen.minimum_master_nodes | 1 | 设置在选举 Master 节点时需要参与的最少的候选 主节点数，默认为 1。如果使用默认值，则当网络 不稳定时有可能会出现脑裂。 合理的 数值为 (master_eligible_nodes/2)+1 ，其中 master_eligible_nodes 表示集群中的候选主节点数 |
| discovery.zen.ping.timeout | 3s | 设置在集群中自动发现其他节点时 Ping 连接的超 时时间，默认为 3 秒。 在较差的网络环境下需要设置得大一点，防止因误 判该节点的存活状态而导致分片的转移 |
Elasticsearch面试题
为什么要使用 Elasticsearch？
Elasticsearch 擅长海量数据的快速全文检索、复杂查询、分布式存储与数据分析，是搜索、日志、大数据场景下的首选引擎。
Elasticsearch 的 master 选举流程？
- Elasticsearch 的主节点（master）选举由
ZenDiscovery模块负责，主要包含Ping（节点之间通过这个RPC来发现彼此） 和Unicast（单播模块包含-一个主机列表以控制哪些节点需要ping通）这两部分。 - 对所有可以成为master的节点（node master: true）根据nodeId字典排序，每次选举每个节点都把自 己所知道节点排一次序，然后选出第一个（第0位）节点，暂且认为它是master节点。
- 如果对某个节点的投票数达到一定的值（可以成为master节点数n/2+1）并且该节点自己也选举自己， 那这个节点就是master。否则重新选举一直到满足上述条件。
- master节点的职责主要包括集群、节点和索引的管理，不负责文档级别的管理；data节点可以关闭http 功能。
Elasticsearch 集群脑裂问题？
ES 脑裂成因：
1. 网络延迟导致部分节点失联，误判主节点宕机并选新主；
2. 主节点兼做 data 节点，负载过高无响应，触发重新选主；
3. data 节点 JVM 大规模 GC，进程无响应引发误判；
脑裂问题解决方案：
-
减少误判：调大
discovery.zen.ping_timeout（默认 3s，建议设为 6s）：延长节点判定主节点存活的响应超时时间，减少主节点因短暂无响应被误判宕机的情况。 -
选举触发：
discovery.zen.minimum_master_nodes（默认 1）控制选举触发的最小候选主节点数：需备选主节点数≥该值，且该数量的节点判定主节点宕机，才会选举新主。官方建议设为(候选主节点数/2)+1，避免脑裂。 -
角色分离：即master节点与data节点分离，限制角色
主节点配置为：node master: true，node data: false 从节点配置为：node master: false，node data: true
Elasticsearch 索引文档的流程？
ES 写入文档的核心是 “先写内存 + 日志，再异步落盘 + 刷新”，既保证写入性能，又兼顾数据可靠性，具体分 8 个核心步骤：
- 协调节点默认使用文档 ID 参与计算（也支持通过 routing），以便为路由提供合适的分片：shard = hash(document_id) % (num_of_primary_shards)
- 当分片所在的节点接收到来自协调节点的请求后，会将请求写入到 Memory Buffer，然后定时（默认是每隔 1 秒）写入到 Filesystem Cache，这个从 Memory Buffer 到 Filesystem Cache 的过程就叫做 refresh；
- 当然在某些情况下，存在 Momery Buffer 和 Filesystem Cache 的数据可能会丢失， ES 是通过 translog的机制来保证数据的可靠性的。其实现机制是接收到请求后，同时也会写入到 translog 中，当 Filesystemcache 中的数据写入到磁盘中时，才会清除掉，这个过程叫做 flush；
- 在 flush 过程中，内存中的缓冲将被清除，内容被写入一个新段，段的 fsync 将创建一个新的提交点，并将内容刷新到磁盘，旧的 translog 将被删除并开始一个新的 translog。
- flush 触发的时机是定时触发（默认 30 分钟）或者 translog 变得太大（默认为 512M）时；
Elasticsearch 更新和删除文档的流程？
- 删除和更新也都是写操作，但是 Elasticsearch 中的文档是不可变的，因此不能被删除或者改动以展示其变更；
- 磁盘上的每个段都有一个相应的.del 文件。当删除请求发送后，文档并没有真的被删除，而是在.del文件中被标记为删除。该文档依然能匹配查询，但是会在结果中被过滤掉。当段合并时，在.del 文件中被标记为删除的文档将不会被写入新段。
- 在新的文档被创建时， Elasticsearch 会为该文档指定一个版本号，当执行更新时，旧版本的文档在.del文件中被标记为删除，新版本的文档被索引到一个新段。旧版本的文档依然能匹配查询，但是会在结果中被过滤掉。
Elasticsearch 搜索的流程？
- 搜索被执行成一个两阶段过程，我们称之为 Query Then Fetch；
- 在初始查询阶段时，查询会广播到索引中每一个分片拷贝（主分片或者副本分片）。 每个分片在本地执行搜索并构建一个匹配文档的大小为 from + size 的优先队列。 PS：在搜索的时候是会查询Filesystem Cache 的，但是有部分数据还在 Memory Buffer，所以搜索是近实时的。
- 每个分片返回各自优先队列中 所有文档的 ID 和排序值 给协调节点，它合并这些值到自己的优先队列中来产生一个全局排序后的结果列表。
- 接下来就是取回阶段， 协调节点辨别出哪些文档需要被取回并向相关的分片提交多个 GET 请求。每个分片加载并丰富文档，如果有需要的话，接着返回文档给协调节点。一旦所有的文档都被取回了，协调节点返回结果给客户端。
- Query Then Fetch 的搜索类型在文档相关性打分的时候参考的是本分片的数据，这样在文档数量较少的时候可能不够准确， DFS Query Then Fetch 增加了一个预查询的处理，询问 Term 和 Document frequency，这个评分更准确，但是性能会变差。
Elasticsearch 在部署时，对 Linux 的设置有哪些优化方法？
-
64 GB 内存的机器是非常理想的， 但是 32 GB 和 16 GB 机器也是很常见的。少于 8 GB 会适得其反。
-
如果你要在更快的 CPUs 和更多的核心之间选择，选择更多的核心更好。多个内核提供的额外并发远胜过稍微快一点点的时钟频率。
-
如果你负担得起 SSD，它将远远超出任何旋转介质。 基于 SSD 的节点，查询和索引性能都有提升。如果你负担得起， SSD 是一个好的选择。
-
即使数据中心们近在咫尺，也要避免集群跨越多个数据中心。绝对要避免集群跨越大的地理距离。
-
请确保运行你应用程序的 JVM 和服务器的 JVM 是完全一样的。 在 Elasticsearch 的几个地方，使用 Java 的本地序列化。
-
通过设置 gateway.recover_after_nodes、 gateway.expected_nodes、 gateway.recover_after_time 可以在集群重启的时候避免过多的分片交换，这可能会让数据恢复从数个小时缩短为几秒钟。
-
Elasticsearch 默认被配置为使用单播发现，以防止节点无意中加入集群。只有在同一台机器上运行的节点才会自动组成集群。最好使用单播代替组播。
-
不要随意修改垃圾回收器（CMS）和各个线程池的大小。
-
把你的内存的（少于）一半给 Lucene（但不要超过 32 GB！），通过 ES_HEAP_SIZE 环境变量设置。
-
内存交换到磁盘对服务器性能来说是致命的。如果内存交换到磁盘上，一个 100 微秒的操作可能变成 10 毫秒。 再想想那么多 10 微秒的操作时延累加起来。 不难看出 swapping 对于性能是多么可怕。
-
Lucene 使用了大量的文件。同时， Elasticsearch 在节点和 HTTP 客户端之间进行通信也使用了大量的套接字。 所有这一切都需要足够的文件描述符。你应该增加你的文件描述符，设置一个很大的值，如 64,000。
GC 方面，在使用 Elasticsearch 时要注意什么？
倒排词典的索引需要常驻内存，无法 GC，需要监控 data node 上 segment memory 增长趋势。
各类缓存， field cache, filter cache, indexing cache, bulk queue 等等，要设置合理的大小，并且要应该根据最坏的情况来看 heap 是否够用，也就是各类缓存全部占满的时候，还有 heap 空间可以分配给其他任务吗？避免采用 clear cache 等“自欺欺人”的方式来释放内存。
避免返回大量结果集的搜索与聚合。确实需要大量拉取数据的场景，可以采用 scan & scroll api 来实现。
cluster stats 驻留内存并无法水平扩展，超大规模集群可以考虑分拆成多个集群通过 tribe node 连接。
想知道 heap 够不够，必须结合实际应用场景，并对集群的 heap 使用情况做持续的监控。
Elasticsearch 对于大数据量（上亿量级）的聚合如何实现？
Elasticsearch 提供的首个近似聚合是 cardinality 度量。它提供一个字段的基数，即该字段的 distinct或者 unique 值的数目。它是基于 HLL 算法的。 HLL 会先对我们的输入作哈希运算，然后根据哈希运算的结果中的 bits 做概率估算从而得到基数。其特点是：可配置的精度，用来控制内存的使用（更精确 ＝ 更多内存）；小的数据集精度是非常高的；我们可以通过配置参数，来设置去重需要的固定内存使用量。无论数千还是数十亿的唯一值，内存使用量只与你配置的精确度相关。
在并发情况下， Elasticsearch 如果保证读写一致？ 可以通过版本号使用乐观并发控制，以确保新版本不会被旧版本覆盖，由应用层来处理具体的冲突；
另外对于写操作，一致性级别支持 quorum/one/all，默认为 quorum，即只有当大多数分片可用时才允许写操作。但即使大多数可用，也可能存在因为网络等原因导致写入副本失败，这样该副本被认为故障，分片将会在一个不同的节点上重建。
对于读操作，可以设置 replication 为 sync(默认)，这使得操作在主分片和副本分片都完成后才会返回；如果设置 replication 为 async 时，也可以通过设置搜索请求参数_preference 为 primary 来查询主分片，确保文档是最新版本。
如何监控 Elasticsearch 集群状态？
- elasticsearch-head 插件。
- 通过 Kibana 监控 Elasticsearch。你可以实时查看你的集群健康状态和性能，也可以分析过去的集群、索引和节点指标。
是否了解字典树？
字典树（Trie 树 / 单词查找树）是一种哈希树变种的树形结构，核心用于统计、排序和存储大量字符串（如搜索引擎文本词频统计），核心优势是利用字符串公共前缀减少比较次数，查询效率高于哈希树。
其核心逻辑是 “空间换时间”，具备 3 个核心性质：
-
根节点无字符，其余节点仅存一个字符；
-
根到目标节点的路径字符拼接为对应字符串；
-
同一节点的子节点字符互不重复。
中文字典树的子节点常用哈希表存储，兼顾空间利用率与 O (1) 的查询效率。
Elasticsearch 中的集群、节点、索引、文档、类型是什么？
- 集群是一个或多个节点（服务器）的集合，它们共同保存您的整个数据，并提供跨所有节点的联合索引和搜索功能。群集由唯一名 称标识，默认情况下为"elasticsearch"。此名称很重要，因为如果节点设置为按名称加入群集，则该节点只能是群集的一部分。
- 节点是属于集群一部分的单个服务器。它存储数据并参与群集索引和搜索功能。
- 索引就像关系数据库中的“数据库”。它有一个定义多种类型的映射。索引是逻辑名称空间，映射到一个或多个主分片，并且可以有零个或多个副本分片。MySQL =>数据库，Elasticsearch=>索引。
- 文档类似于关系数据库中的一行。不同之处在于索引中的每个文档可以具有不同的结构(字段)，但是对于通用字段应该具有相同的数据类型。MySQL => Databases => Tables => Columns / Rows，Elasticsearch=> Indices => Types =>具有属性的文档Doc。
- 类型是索引的逻辑类别/分区，其语义完全取决于用户。
Elasticsearch 中的倒排索引是什么？
倒排索引是搜索引擎的核心。搜索引擎的主要目标是在查找发生搜索条件的文档时提供快速搜索。ES中的倒排索引其实就是 lucene 的倒排索引，区别于传统的正向索引， 倒排索引会再存储数据时将关键词和数据进行关联，保存到倒排表中，然后查询时，将查询内容进行分词后在倒排表中进行查询，最后匹配数据即可。
