Elastic Stack之Elasticsearch教程

1.Elastic Stack简介
2.Elasticsearch
   2.1 简介 2.2 安装 2.2.1 版本说明 2.2.2 下载 2.2.3 单机版安装 2.2.4  elasticsearch-head 2.3 基本概念 2.4 RESTful API 2.4.1 创建非结构化数据 2.4.2 插入数据 2.4.3 更新数据 2.4.4 删除数据 2.4.5 搜索数据 2.4.6 DSL搜索 2.4.7 高亮显示 2.4.8 聚合
3. 核心详解
    3.1 文档 3.2 查询响应  3.2.1 pretty 3.2.2 指定响应字段 3.3 判断文档是否存在 3.4 批量操作 3.4.1 批量查询 3.4.2 _bulk操作 3.5 分页 3.6 映射 3.7 结构化查询 3.7.1 term查询 3.7.2 terms查询 3.7.3 range查询 3.7.4 exists 查询 3.7.5 match查询 3.7.6 bool查询
4. 中文分词
    4.1 什么是分词 4.2 分词api 4.3 中文分词
5. 全文搜索
    5.1 构造数据 5.2 单词搜索 5.3 多词搜索 5.4 组合搜索 5.5 权重
6. Elasticsearch集群
    6.1 集群节点 6.2 搭建集群 6.3 分片和副本 6.4 故障转移 6.4.1 将data节点停止 6.4.2 将master节点停止 6.5 分布式文档 6.5.1 路由 6.5.2 文档写操作 6.5.3 搜索文档（单个文档） 6.5.4 全文搜索
7. Java客户端
    7.1 REST客户端 7.2 构造数据 7.3 REST低级客户端 7.3.1 创建工程 7.3.2 编写测试用例 7.4 REST高级客户端 7.4.1 引入依赖 7.4.2 编写测试用例

8. Elasticsearch、Filebeat、Kibana添加安全认证
------------------------------------------------------------------------------------------------------------------------------------

1.Elastic Stack简介

        如果你没有听说过Elastic Stack，那你一定听说过ELK，实际上ELK是三款软件的简称，分别是Elasticsearch、Logstash、Kibana组成，在发展的过程中，又有新成员Beats的加入，所以就形成了Elastic Stack。所以说，ELK是旧的称呼，Elastic Stack是新的名字。

全系的Elastic Stack技术栈包括：

Elasticsearch
Elasticsearch 基于java，是个开源分布式搜索引擎，它的特点有：分布式，零配置，自动发现，索引自动分片，索引副本机制，restful风格接口，多数据源，自动搜索负载等。
Logstash
Logstash 基于java，是一个开源的用于收集,分析和存储日志的工具。
Kibana
Kibana 基于nodejs，也是一个开源和免费的工具，Kibana可以为 Logstash 和 ElasticSearch 提供的日志分析友好的Web 界面，可以汇总、分析和搜索重要数据日志。
Beats
Beats是elastic公司开源的一款采集系统监控数据的代理agent，是在被监控服务器上以客户端形式运行的数据收集器的统称，可以直接把数据发送给Elasticsearch或者通过Logstash发送给Elasticsearch，然后进行后续的数据分析活动。

Logstash和Beats在数据收集功能上有一定的重复，现在更多的是采用Beats来做数据采集，Logstash更多的做一些数据的处理，包括字符串分割、字符串提取，早期没有Beats的时候，使用Logstash做数据采集，现在有了Beats，就使用Beats，因为Beats功能更加强大。

Beats是一个综合的名字，它有一些子项目组成，由如下组成:
Packetbeat：是一个网络数据包分析器，用于监控、收集网络流量信息，Packetbeat嗅探服务器之间的流量，解析应用层协议，并关联到消息的处理，其支 持ICMP (v4 and v6)、DNS、HTTP、Mysql、PostgreSQL、Redis、MongoDB、Memcache等协议；
Filebeat：用于监控、收集服务器日志文件，其已取代 logstash forwarder；
Metricbeat：可定期获取外部系统的监控指标信息，其可以监控、收集 Apache、HAProxy、MongoDB、MySQL、Nginx、PostgreSQL、Redis、System、Zookeeper等服务；
Winlogbeat：用于监控、收集Windows系统的日志信息；

2.Elasticsearch
2.1 简介

ElasticSearch是一个基于Lucene的搜索服务器。它提供了一个分布式多用户能力的全文搜索引擎，基于RESTful web接口操作ES，也可以利用Java API。Elasticsearch是用Java开发的，并作为Apache许可条款下的开放源码发布，是当前流行的企业级搜索引擎。设计用于云计算中，能够达到实时搜索，稳定，可靠，快速，安装使用方便。
官网：https://www.elastic.co/cn/elasticsearch/

2.2 安装
2.2.1 版本说明

Elasticsearch的发展是非常快速的，所以在ES5.0之前，ELK的各个版本都不统一，出现了版本号混乱的状态，所以从5.0开始，所有Elastic Stack中的项目全部统一版本号。目前最新版本是7.9.3，我们将基于这一版本进行学习。

2.2.2 下载

地址：https://www.elastic.co/cn/downloads/elasticsearch

2.2.3 单机版安装

将下载好的elasticsearch解压到指定目录：tar -zxvf elasticsearch-7.9.3-linux-x86_64.tar.gz -C /opt/

修改Linux系统的限制配置，将文件创建数修改为65536个，使用root用户修改。

再次启动：bin/elasticsearch -d   说明-d是指后台启动

验证： curl http://localhost:9200  如下，表示单机版启动成功，如果启动还报错，根据报错提示修改一下配置。

2.2.4  elasticsearch-head

由于ES官方并没有为ES提供界面管理工具，仅仅是提供了后台的服务。elasticsearch-head是一个为ES开发的一个页面客户端工具，其源码托管于GitHub，地址为：https://github.com/mobz/elasticsearch-head
head提供了4种安装方式：
源码安装，通过npm run start启动（不推荐）
通过docker安装（推荐）
通过chrome插件安装（推荐）
通过ES的plugin方式安装（不推荐）

这里安装的谷歌插件，通过浏览器进行访问：

2.3 基本概念

2.4 RESTful API

在Elasticsearch中，提供了功能丰富的RESTful API的操作，包括基本的CRUD、创建索引、删除索引等操作。 

2.4.1 创建非结构化数据

2.4.2 插入数据

2.4.3 更新数据

在Elasticsearch中，文档数据是不为修改的，但是可以通过覆盖的方式进行更新。

PUT /haoke/user/1001 
{
    "id": 1001,
    "name": "张三",
    "age": 21,
    "sex": "女"
}

可以看到数据已经被覆盖了。
问题来了，可以局部更新吗？ -- 可以的。
前面不是说，文档数据不能更新吗？ 其实是这样的：在内部，依然会查询到这个文档数据，然后进行覆盖操作，步骤如下：
1. 从旧文档中检索JSON
2. 修改它
3. 删除旧文档
4. 索引新文档
示例：

#注意：这里多了_update标识 POST /haoke/user/1001/_update 
{
    "doc": {
        "age": 23
    }
}

2.4.4 删除数据

在Elasticsearch中，删除文档数据，只需要发起DELETE请求即可。

DELETE /haoke/user/1001

说明：删除一个文档也不会立即从磁盘上移除，它只是被标记成已删除。Elasticsearch将会在你之后添加更多索引的时候才会在后台进行删除内容的清理。
2.4.5 搜索数据

根据id搜索数据  GET /haoke/user/yAjcnHUBau-AZQnWpW8f

搜索全部数据  GET /haoke/user/_search  （默认返回10条数据）

关键字搜素数据 

#查询年龄等于20的用户

2.4.6 DSL搜索

2.4.7 高亮显示

POST /haoke/user/_search 
{
    "query": {
        "match": {
            "name": "张三 李四"
        }
    },
    "highlight": {
        "fields": {
            "name": {}
        }
    }
}

2.4.8 聚合

在Elasticsearch中，支持聚合操作，类似SQL中的group by操作。

POST /haoke/user/_search 
{
    "aggs": {
        "all_interests": {
            "terms": {
                "field": "age"
            }
        }
    }
}

从结果可以看出，年龄31的有2条数据，20的有2条数据。
3. 核心详解
3.1 文档

在Elasticsearch中，文档以JSON格式进行存储，可以是复杂的结构，如：

{
    "_index": "haoke",
    "_type": "user",
    "_id": "1005",
    "_version": 1,
    "_score": 1,
    "_source": {
        "id": 1005,
        "name": "孙七",
        "age": 27,
        "sex": "女",
        "card": {
            "card_number": "123456789"
        }
    }
}

3.2 查询响应
3.2.1 pretty

可以在查询url后面添加pretty参数，使得返回的json更易查看。

3.2.2 指定响应字段

在响应的数据中，如果我们不需要全部的字段，可以指定某些需要的字段进行返回

GET /haoke/user/1001?_source=id,name

如不需要返回元数据，仅仅返回原始数据，可以这样： GET /haoke/user/1001/_source

还可以这样： GET /haoke/user/1001/_source?_source=id,name

3.3 判断文档是否存在

如果我们只需要判断文档是否存在，而不是查询文档内容，那么可以这样：HEAD /haoke/user/1001  有返回200状态码，没有返回404状态码
3.4 批量操作 

有些情况下可以通过批量操作以减少网络请求。如：批量查询、批量插入数据。
3.4.1 批量查询  

POST /haoke/user/_mget 
{
    "ids": [
        "1001",
        "1003"
    ]
}

3.4.2 _bulk操作

POST /haoke/user/_bulk

在Elasticsearch中，支持批量的插入、修改、删除操作，都是通过_bulk的api完成的。请求格式如下：（请求格式不同寻常） 

{ action: { metadata }}n 
{ request body }n 
{ action: { metadata }}n 
{ request body }n 
...

批量插入数据：

{"create":{"_index":"haoke","_type":"user","_id":2001}} 
{"id":2001,"name":"name1","age": 20,"sex": "男"} 
{"create":{"_index":"haoke","_type":"user","_id":2002}} 
{"id":2002,"name":"name2","age": 20,"sex": "男"} 
{"create":{"_index":"haoke","_type":"user","_id":2003}} 
{"id":2003,"name":"name3","age": 20,"sex": "男"}

注意最后一行的回车。

3.5 分页

和SQL使用 LIMIT 关键字返回只有一页的结果一样，Elasticsearch接受 from 和 size 参数：

size: 结果数，默认10 
from: 跳过开始的结果数，默认0

如果你想每页显示5个结果，页码从1到3，那请求如下：

GET /_search?size=5 
GET /_search?size=5&from=5 
GET /_search?size=5&from=10

应该当心分页太深或者一次请求太多的结果。结果在返回前会被排序。但是记住一个搜索请求常常涉及多个分片。每个分片生成自己排好序的结果，它们接着需要集中起来排序以确保整体排序正确。

GET /haoke/user/_search?size=1&from=2

在集群系统中深度分页
为了理解为什么深度分页是有问题的，让我们假设在一个有5个主分片的索引中搜索。当我们请求结果的第一页（结果1到10）时，每个分片产生自己最顶端10个结果然后返回它们给请求节点(requesting node)，它再排序这所有的50个结果以选出顶端的10个结果。
现在假设我们请求第1000页——结果10001到10010。工作方式都相同，不同的是每个分片都必须产生顶端的10010个结果。然后请求节点排序这50050个结果并丢弃50040个！
你可以看到在分布式系统中，排序结果的花费随着分页的深入而成倍增长。这也是为什么网络搜索引擎中任何语句不能返回多于1000个结果的原因。
3.6 映射

前面我们创建的索引以及插入数据，都是由Elasticsearch进行自动判断类型，有些时候我们是需要进行明确字段类型的，否则，自动判断的类型和实际需求是不相符的。
自动判断的规则如下：

Elasticsearch中支持的类型如下：

string类型在ElasticSearch 旧版本中使用较多，从ElasticSearch 5.x开始不再支持string，由text和 keyword类型替代。
text类型，当一个字段是要被全文搜索的，比如Email内容、产品描述，应该使用text类型。设置text类型以后，字段内容会被分析，在生成倒排索引以前，字符串会被分析器分成一个一个词项。text类型的字段不用于排序，很少用于聚合。
keyword类型适用于索引结构化的字段，比如email地址、主机名、状态码和标签。如果字段需要进行过滤(比如查找已发布博客中status属性为published的文章)、排序、聚合。
keyword类型的字段只能通过精确值搜索到

官网7.4以上默认不在支持指定索引类型 : https://www.elastic.co/guide/en/elasticsearch/reference/current/removal-of-types.html#_typeless_apis_in_7_0

创建明确类型的索引：PUT /yz_test 

{
    "settings": {
        "index": {
            "number_of_shards": "2",
            "number_of_replicas": "0"
        }
    },
    "mappings": {
                "properties": {
                        "name": {
                                "type": "text"
                        },
                        "age": {
                                "type": "integer"
                        },
                        "mail": {
                                "type": "keyword"
                        },
                        "hobby": {
                                "type": "text"
                        }
                }
        }
}

查看映射：GET /yz_test/_mappings

插入数据：POST /yz_test/_bulk

{"index":{"_index":"yz_test"}} 
{"name":"张三","age": 20,"mail": "111@qq.com","hobby":"羽毛球、乒乓球、足球"} 
{"index":{"_index":"yz_test"}} 
{"name":"李四","age": 21,"mail": "222@qq.com","hobby":"羽毛球、乒乓球、足球、篮球"} 
{"index":{"_index":"yz_test"}} 
{"name":"王五","age": 22,"mail": "333@qq.com","hobby":"羽毛球、篮球、游泳、听音乐"} 
{"index":{"_index":"yz_test"}} 
{"name":"赵六","age": 23,"mail": "444@qq.com","hobby":"跑步、游泳"} 
{"index":{"_index":"yz_test"}} 
{"name":"孙七","age": 24,"mail": "555@qq.com","hobby":"听音乐、看电影"}

3.7 结构化查询
3.7.1 term查询

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

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

示例：

POST /yz_test/_search 
{
    "query": {
        "term": {
            "age": 20
        }
    }
}

3.7.2 terms查询

3.7.3 range查询

range 过滤允许我们按照指定范围查找一批数据：

{
    "range": {
        "age": {
            "gte": 20,
            "lt": 30
        }
    }
}

package com.example.demo;

import org.apache.http.HttpHost;
import org.elasticsearch.action.ActionListener;
import org.elasticsearch.action.delete.DeleteRequest;
import org.elasticsearch.action.delete.DeleteResponse;
import org.elasticsearch.action.get.GetRequest;
import org.elasticsearch.action.get.GetResponse;
import org.elasticsearch.action.index.IndexRequest;
import org.elasticsearch.action.index.IndexResponse;
import org.elasticsearch.action.search.SearchRequest;
import org.elasticsearch.action.search.SearchResponse;
import org.elasticsearch.action.update.UpdateRequest;
import org.elasticsearch.action.update.UpdateResponse;
import org.elasticsearch.client.RequestOptions;
import org.elasticsearch.client.RestClient;
import org.elasticsearch.client.RestClientBuilder;
import org.elasticsearch.client.RestHighLevelClient;
import org.elasticsearch.common.Strings;
import org.elasticsearch.common.unit.TimeValue;
import org.elasticsearch.index.query.QueryBuilders;
import org.elasticsearch.search.SearchHit;
import org.elasticsearch.search.SearchHits;
import org.elasticsearch.search.builder.SearchSourceBuilder;
import org.elasticsearch.search.fetch.subphase.FetchSourceContext;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;

import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.TimeUnit;

/**
 * Description:
 * Author: yz
 * Date: Created in 2020/11/19 13:40
 */
public class TestESHighRest {
    private RestHighLevelClient client;

    @Before
    public void init() {
        RestClientBuilder restClientBuilder = RestClient.builder(
                new HttpHost("192.168.226.30", 9200, "http"),
                new HttpHost("192.168.226.31", 9200, "http"),
                new HttpHost("192.168.226.32", 9200, "http"));
        this.client = new RestHighLevelClient(restClientBuilder);
    }

    @After
    public void after() throws Exception {
        this.client.close();
    }

    /**
     * 新增文档，同步操作
     *
     * @throws Exception
     */
    @Test
    public void testCreate() throws Exception {
        Map<String, Object> data = new HashMap<>();
        data.put("id", "2002");
        data.put("title", "南京西路 拎包入住 一室一厅");
        data.put("price", "4500");
        IndexRequest indexRequest = new IndexRequest("haoke", "house").source(data);
        IndexResponse indexResponse = this.client.index(indexRequest, RequestOptions.DEFAULT);
        System.out.println("id->" + indexResponse.getId());
        System.out.println("index->" + indexResponse.getIndex());
        System.out.println("type->" + indexResponse.getType());
        System.out.println("version->" + indexResponse.getVersion());
        System.out.println("result->" + indexResponse.getResult());
        System.out.println("shardInfo->" + indexResponse.getShardInfo());
    }

    /**
     * 新增文档，异步操作
     *
     * @throws Exception
     */
    @Test
    public void testCreateAsync() throws Exception {
        Map<String, Object> data = new HashMap<>();
        data.put("id", "2003");
        data.put("title", "南京东路 最新房源 二室一厅");
        data.put("price", "5500");
        IndexRequest indexRequest = new IndexRequest("haoke", "house").source(data);
        this.client.indexAsync(indexRequest, RequestOptions.DEFAULT, new ActionListener<IndexResponse>() {
            @Override
            public void onResponse(IndexResponse indexResponse) {
                System.out.println("id->" + indexResponse.getId());
                System.out.println("index->" + indexResponse.getIndex());
                System.out.println("type->" + indexResponse.getType());
                System.out.println("version->" + indexResponse.getVersion());
                System.out.println("result->" + indexResponse.getResult());
                System.out.println("shardInfo->" + indexResponse.getShardInfo());
            }

            @Override
            public void onFailure(Exception e) {
                System.out.println(e);
            }
        });
        System.out.println("ok");
        Thread.sleep(20000);
    }

    /**
     * 指定返回的字段
     *
     * @throws Exception
     */
    @Test
    public void testQuery() throws Exception {
        GetRequest getRequest = new GetRequest("haoke", "house", "GkpdE2gBCKv8opxuOj12");
        String[] includes = new String[]{"title", "id"};
        String[] excludes = Strings.EMPTY_ARRAY;
        FetchSourceContext fetchSourceContext = new FetchSourceContext(true, includes, excludes);
        getRequest.fetchSourceContext(fetchSourceContext);
        GetResponse response = this.client.get(getRequest, RequestOptions.DEFAULT);
        System.out.println("数据 -> " + response.getSource());
    }

    /**
     * 判断是否存在
     *
     * @throws Exception
     */
    @Test
    public void testExists() throws Exception {
        GetRequest getRequest = new GetRequest("haoke", "house", "GkpdE2gBCKv8opxuOj12"); // 不返回的字段
        getRequest.fetchSourceContext(new FetchSourceContext(false));
        boolean exists = this.client.exists(getRequest, RequestOptions.DEFAULT);
        System.out.println("exists -> " + exists);
    }

    /**
     * 删除数据
     *
     * @throws Exception
     */
    @Test
    public void testDelete() throws Exception {
        DeleteRequest deleteRequest = new DeleteRequest("haoke", "house", "GkpdE2gBCKv8opxuOj12");
        DeleteResponse response = this.client.delete(deleteRequest, RequestOptions.DEFAULT);
        System.out.println(response.status());// OK or NOT_FOUND }
    }

    /*** 更新数据 ** @throws Exception */
    @Test
    public void testUpdate() throws Exception {
        UpdateRequest updateRequest = new UpdateRequest("haoke", "house", "G0pfE2gBCKv8opxuRz1y");
        Map<String, Object> data = new HashMap<>();
        data.put("title", "张江高科2");
        data.put("price", "5000");
        updateRequest.doc(data);
        UpdateResponse response = this.client.update(updateRequest, RequestOptions.DEFAULT);
        System.out.println("version -> " + response.getVersion());
    }

    /**
     * 测试搜索
     *
     * @throws Exception
     */
    @Test
    public void testSearch() throws Exception {
        SearchRequest searchRequest = new SearchRequest("haoke");
        searchRequest.types("house");
        SearchSourceBuilder sourceBuilder = new SearchSourceBuilder();
        sourceBuilder.query(QueryBuilders.matchQuery("title", "拎包入住"));
        sourceBuilder.from(0);
        sourceBuilder.size(5);
        sourceBuilder.timeout(new TimeValue(60, TimeUnit.SECONDS));
        searchRequest.source(sourceBuilder);
        SearchResponse search = this.client.search(searchRequest, RequestOptions.DEFAULT);
        System.out.println("搜索到 " + search.getHits().getTotalHits() + " 条数据.");
        SearchHits hits = search.getHits();
        for (SearchHit hit : hits) {
            System.out.println(hit.getSourceAsString());
        }
    }
}

创建数据：

返回指定的字段：

测试条件搜索：

8. Elasticsearch、Filebeat、Kibana添加安全认证

问题描述：经测试发现，电销管理系统存在Elasticsearch未授权访问漏洞（高危）：接口：http://192.168.226.30:9200/ 可直接遍历Elasticsearch敏感接口，去查询其所属的数据库以及相关内容

解决：X-pack安全配置  生成节点证书（从 6.8.0 和 7.1.0 版本开始，x-pack安全功能免费提供）

1. 生成证书颁发机构：执行bin/elasticsearch-certutil ca命令，会提示输入文件目录和密码，我这里没有输入直接回车了，然后生成elastic-stack-ca.p12文件。
2. 生成证书和私钥：执行bin/elasticsearch-certutil cert --ca elastic-stack-ca.p12（elastic-stack-ca.p12 是前面生成的证书），会提示输入证书颁发机构密码，证书生成目录和证书密码，我这里都没有设置。生成文件elastic-certificates.p12。
   加密集群中的节点之间的通信和账户验证
3. 在/opt/elasticsearch-7.10.0/config目录下面创建xpack目录，并将前面生成的elastic-certificates.p12证书移进去。并将证书复制给其他节点。
4. 配置elasticsearch.yml配置文件（其他节点配置一样），添加：

 

xpack.security.enabled: true
xpack.security.transport.ssl.enabled: true
xpack.security.transport.ssl.verification_mode: certificate
xpack.security.transport.ssl.keystore.path: xpack/elastic-certificates.p12
xpack.security.transport.ssl.truststore.path: xpack/elastic-certificates.p12

1. 如果生成生成证书和私钥的时候设置了密码，则还需要进行下面操作（每个节点都要）添加密码：

bin/elasticsearch-keystore add xpack.security.transport.ssl.keystore.secure_password
bin/elasticsearch-keystore add xpack.security.transport.ssl.truststore.secure_password

1. 运行elasticsearch
2. 设置密码(账号默认为elastic)
   在elasticsearch-7.10.0/bin/目录下运行:
   ./elasticsearch-setup-passwords interactive
   它会不止是设置elasticsearch，其他的kibana、logstash也会一起设置了，密码最好全设置同一个，也可以用下面命令自动生成密码：

./elasticsearch-setup-passwords auto

1. 修改密码方式

curl -H "Content-Type:application/json" -XPOST -u elastic 'http://172.31.10.148:9201/_xpack/security/user/elastic/_password' -d '{ "password" : "123456" }'

• 添加xdt账户并添加至admin角色操作方法

curl -XPOST -H 'Content-type: application/json' -u elastic:elastic 'http://10.59.30.96:9200/_xpack/security/user/xdt?pretty' -d '{
   "password" : "123456",
   "full_name" : "xdt",
   "roles" : ["admin"],
   "email" : "xdt@bakclass.com"
 }'

加密HTTP客户端通信（选配）

1. 配置elasticsearch.yml配置文件（其他节点配置一样），添加：

xpack.security.http.ssl.enabled: true
xpack.security.http.ssl.keystore.path: certs/elastic-certificates.p12
xpack.security.http.ssl.truststore.path: certs/elastic-certificates.p12

elasticsearch.yml

filebeat.yml

kibana.yml

参考：https://blog.csdn.net/xiexiong0702/article/details/109855842

elasticsearch7.x  x-pack破解：

x-pack是收费项目,默认一个月有效期。官网https://license.elastic.co/registration申请的license一年有效期，我这里改成了50年有效期，随意更改。

x-pack的lisence校验在elasticsearch-7.10.0/modules/x-pack-core的x-pack-core-7.10.0.jar中，破解之前需要用反编译工具(如：JD-GUI，luyten)把jar打开源码出来，修改两个class：

org.elasticsearch.license.LicenseVerifier.class 验证licence是否有效
org.elasticsearch.xpack.core.XPackBuild.class 验证jar包是否被修改

修改后的效果，LicenseVerifier.java 把校验全删掉：

XPackBuild.java 静态代码块中 try的部分全部删除

把java文件编译成class，通过WinRAR打开x-pack-core-7.10.0.jar,将修改好的class放入到对应的目录中：

将修改过的x-pack-core-7.10.0.jar 放入到服务器对应的目录中

禁用elasticsearch安全协议

导出许可证书之前要先关闭xpack安全认证，打开../config/elasticsearch.yml文件在末尾添加:xpack.security.enabled: false

并启动elasticsearch服务：./bin/elasticsearch -d

下载证书：https://license.elastic.co/registration 修改下载的证书有效期，黑体部分：

{"license":{"uid":"de954ef5-cfb0-4b6b-b4aa-7d4104da19bf","type":"platinum","issue_date_in_millis":1607644800000,"expiry_date_in_millis":2524579200999,"max_nodes":100,"issued_to":"yang zeng (google)","issuer":"Web Form","signature":"AAAAAwAAAA0D7IvcscVpQh8kG8GsAAABmC9ZN0hjZDBGYnVyRXpCOW5Bb3FjZDAxOWpSbTVoMVZwUzRxVk1PSmkxaktJRVl5MUYvUWh3bHZVUTllbXNPbzBUemtnbWpBbmlWRmRZb25KNFlBR2x0TXc2K2p1Y1VtMG1UQU9TRGZVSGRwaEJGUjE3bXd3LzRqZ05iLzRteWFNekdxRGpIYlFwYkJiNUs0U1hTVlJKNVlXekMrSlVUdFIvV0FNeWdOYnlESDc3MWhlY3hSQmdKSjJ2ZTcvYlBFOHhPQlV3ZHdDQ0tHcG5uOElCaDJ4K1hob29xSG85N0kvTWV3THhlQk9NL01VMFRjNDZpZEVXeUtUMXIyMlIveFpJUkk2WUdveEZaME9XWitGUi9WNTZVQW1FMG1DenhZU0ZmeXlZakVEMjZFT2NvOWxpZGlqVmlHNC8rWVVUYzMwRGVySHpIdURzKzFiRDl4TmM1TUp2VTBOUlJZUlAyV0ZVL2kvVk10L0NsbXNFYVZwT3NSU082dFNNa2prQ0ZsclZ4NTltbU1CVE5lR09Bck93V2J1Y3c9PQAAAQA1Q6ycx7Of0lc1ShV7S6sX+bbNyMVHx8HUpwUKPoGNveBsn8cyFZnau0bBEcb97pLAl5XDYWYBFsytPP8vzSW3fPQhcgBUUefUNC9a5ow2veq1H3h/L5AJv2P1NPAFvOzmSC1Wxh88xKm4EdMtUgzrXc6isV8bOoFENBN1bZHHMxsi4dKyQjKfgXmkF8fT3IQaUj532h5RMUb3MfmSX/14DM7W5R1I8I0Vji9nEUEqld69QP7zsG6pNuNGbNj7iBYy+Nsnaw0DijQOfPjEJZ8baONTtzn/vN00vkakG3ANmtCP7svfOKvpAVMAd0QncpCzFgHhfuoox/F8QLiUmCdP","start_date_in_millis":1607644800000}}

许可证书分有三类GOLD(黄金),PLATINUM(白金),ENTERPRISE(企业)，我上面把type手动改成了白金版，然后再把过期时间改到了2050年

新建一个license.json,把上边修改过的许可json串复制进去

激活 上传激活文件：

我已经上传过，所以会显示到期时间：

开启elasticsearch安全协议

导出许可证书之后要开启xpack安全认证，打开../config/elasticsearch.yml文件在末尾添加:xpack.security.enabled: true

并启动elasticsearch服务：./bin/elasticsearch -d

xpack有效期查看：

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

最后

以上就是开心未来为你收集整理的Elastic Stack之Elasticsearch教程的全部内容，希望文章能够帮你解决Elastic Stack之Elasticsearch教程所遇到的程序开发问题。

如果觉得靠谱客网站的内容还不错，欢迎将靠谱客网站推荐给程序员好友。