ElasticSearch入门和环境部署

最新推荐文章于 2024-08-28 22:18:40 发布

Ferry.

最新推荐文章于 2024-08-28 22:18:40 发布

阅读量797

点赞数 30

文章标签： elasticsearch 全文检索

本文链接：https://blog.csdn.net/weixin_44522680/article/details/136377037

版权

文章目录

HTTP索引操作
- 创建索引
- 查询和删除索引
HTTP文档操作
HTTP全文检索、完全匹配、高亮匹配
HTTP聚合查询
HTTP映射关系
JavaAPI环境准备
JavaAPI索引操作
- JavaAPI索引创建
- JavaAPI索引查询删除
JavaAPI文档操作
Windows集群部署
Linux单点部署
Linux集群部署

Elaticsearch，简称为 ES， ES 是一个开源的高扩展的分布式全文搜索引擎，是整个 ElasticStack 技术栈的核心。

启动ES：
进入 bin 文件目录，点击 elasticsearch.bat 文件启动 ES 服务。
注意： 9300 端口为 Elasticsearch 集群间组件的通信端口， 9200 端口为浏览器访问的 http协议 RESTful 端口。
打开浏览器，输入地址： http://localhost:9200，测试返回结果。
在这里插入图片描述

HTTP索引操作

创建索引

在 Postman 中，向 ES 服务器发 PUT 请求： http://localhost:9200/shopping.
如果重复发 PUT 请求： http://localhost:9200/shopping 添加索引，会返回错误信息。

查询和删除索引

查看所有索引
在 Postman 中，向 ES 服务器发 GET 请求： http://127.0.0.1:9200/_cat/indices?v
这里请求路径中的_cat 表示查看的意思， indices 表示索引，所以整体含义就是查看当前 ES服务器中的所有索引，就好像 MySQL 中的 show tables 的感觉，响应结果如下：

health status index    uuid                   pri rep docs.count docs.deleted store.size pri.store.size
yellow open   shopping J0WlEhh4R7aDrfIc3AkwWQ   1   1          0            0       208b           208b

在这里插入图片描述

查询单个索引   在 Postman 中，向 ES 服务器发 GET 请求 ： http://localhost:9200/shopping
删除索引      在 Postman 中，向 ES 服务器发 DELETE请求 ： http://localhost:9200/shopping

HTTP文档操作

创建文档（post新增）

POST    http://localhost:9200/shopping/_doc        	  #使用系统生成id
POST    http://localhost:9200/shopping/_doc/1        #使用指定id，
PUT      http://localhost:9200/shopping/_doc/1        #当使用指定主键id时，请求方式也可以为put
POST   http://localhost:9200/shopping/_doc/1       #使用指定id，不存在创建，存在更新（版本递增）

在 Postman 中，向 ES 服务器发 POST 请求 : http://127.0.0.1:9200/shopping/_doc，请求体JSON内容为：

{
    "title":"小米手机",
    "category":"小米",
    "images":"http://www.gulixueyuan.com/xm.jpg",
    "price":3999.00
}

查询文档(条件查询、分页、查询排序、多条件、范围)

GET    http://localhost:9200/shopping/_doc/1              #查询单个文档
GET    http://localhost:9200/shopping/_search              #查询全部文档,确保Body为空才能查出来

//条件查询
GET    http://localhost:9200/shopping/_search?q=category:小米    #根据条件查询,url上加参数
GET    http://localhost:9200/shopping/_search                    #条件查询，根据JSON请求体，请求体如下如下
{
    "query":{
     "match":{
        "category":"小米"
     }
    }
}
GET    http://localhost:9200/shopping/_search            #带请求体方式查询所有内容，请求体如下：
{
    "query":{
     "match_all":{}
    }
}
GET    http://localhost:9200/shopping/_search            #带请求体方式查询指定字段，请求体如下：
{
    "query":{
     "match_all":{}
    },
    "_source":["title"]
}

//分页查询               
GET http://127.0.0.1:9200/shopping/_search        #分页查询，请求体如下：
{
    "query":{
        "match_all":{}
    },
    "from":0,
    "size":2
}

//查询排序
GET http://127.0.0.1:9200/shopping/_search        #查询排序，请求体如下：
{
    "query":{
     "match_all":{}
    },
    "sort":{
     "price":{
        "order":"desc"
     }
    }
}

多条件查询

//多条件查询（&&）找到小米牌子，价格为3999元的。（must相当于数据库的&&）
GET http://127.0.0.1:9200/shopping/_search        #多条件查询，请求体如下：
{
    "query":{
        "bool":{
            "must":[{
                "match":{
                    "category":"小米"
                }
            },{
                "match":{
                    "price":3999.00
                }
            }]
        }
    }
}

//(||)找到小米和华为牌子的。（should相当于数据库的||）
{
    "query":{
        "bool":{
            "should":[{
                "match":{
                    "category":"小米"
                }
            },{
                "match":{
                    "category":"华为"
                }
            }]
        }        
    }
}

范围查询

//找出小米和华为的牌子，价格大于2000元的手机
GET http://127.0.0.1:9200/shopping/_search        #范围查询，请求体如下：
{
    "query":{
        "bool":{
            "should":[{
                "match":{
                    "category":"小米"
                }
            },{
                "match":{
                    "category":"华为"
                }
            }],
            "filter":{
                "range":{
                    "price":{
                        "gt":2000
                    }
                }
            }
        }
    }
}

修改/删除文档

POST  http://127.0.0.1:9200/shopping/_doc/1       #全量修改
POST  http://127.0.0.1:9200/shopping/_update/1    #局部修改

DELETE http://localhost:9200/books/_doc/1         #不会立即从磁盘移除，标记成已删除(逻辑删除)

请求体JSON内容为：

#全量修改请求体
{
    "title":"华为手机",
    "category":"华为",
    "images":"http://www.gulixueyuan.com/hw.jpg",
    "price":1999.00
}

 #局部修改请求体
 {
    "doc": {
        "title":"小米手机",
        "category":"小米"
    }
}

HTTP全文检索、完全匹配、高亮匹配

全文检索

例如：如果品牌输入“小华”，返回的结果带有品牌小米和华为。

GET http://127.0.0.1:9200/shopping/_search        #全文检索，请求体如下：
{
    "query":{
        "match":{
            "category" : "小华"
        }
    }
}

完全匹配

例如：输入“为”，品牌带为字的都会匹配出来。(输入小为是返回不了华为和小米的，注意是match_phrase)

GET http://127.0.0.1:9200/shopping/_search        #完全匹配，请求体如下：
{
    "query":{
        "match_phrase":{
            "category" : "为"
        }
    }
}

高亮匹配

GET http://127.0.0.1:9200/shopping/_search        #高亮匹配，请求体如下：
{
  "query":{
        "match_phrase":{
            "category" : "为"
        }
    },
    "highlight":{
        "fields":{
            "category":{}//<----高亮这字段
        }
    }
}

HTTP聚合查询

聚合允许使用者对 es 文档进行统计分析，类似与关系型数据库中的 group by，当然还有很多其他的聚合，例如取最大值max、平均值avg等等。

//对price字段进行分组
GET http://127.0.0.1:9200/shopping/_search
{
    "aggs":{//聚合操作
        "price_group":{//名称，随意起名
            "terms":{//分组
                "field":"price"//分组字段
            }
        }
    },
 "size":0 //不加这一项，返回的结果会附带原始数据
}

//对所有手机价格进行求平均值
GET http://127.0.0.1:9200/shopping/_search
{
    "aggs":{
        "price_avg":{//名称，随意起名
            "avg":{//求平均
                "field":"price"
            }
        }
    },
    "size":0
}

HTTP映射关系

有了索引库，等于有了数据库中的 database。
接下来就需要建索引库(index)中的映射了，类似于数据库(database)中的表结构(table)。
创建数据库表需要设置字段名称，类型，长度，约束等；索引库也一样，需要知道这个类型下有哪些字段，每个字段有哪些约束信息，这就叫做映射(mapping)。

PUT http://localhost:9200/user  #创建一个索引

PUT http://localhost:9200/user/_mapping #创建映射
{
    "properties": {
        "name":{
            "type": "text",
            "index": true
        },
        "sex":{
            "type": "keyword",
            "index": true
        },
        "tel":{
            "type": "keyword",
            "index": false
        }
    }
}

GET http://127.0.0.1:9200/user/_mapping #查询映射

PUT http://localhost:9200/user/_create/1001 #新增数据，这个是文档的新增操作，指明id主键可以用put来新增
{
    "name":"小米",
    "sex":"男的",
    "tel":"1111"
}

GET http://127.0.0.1:9200/user/_search #查找name中含有“小”的数据
{
    "query":{
        "match":{
        "name":"小"
        }
    }
}

GET http://127.0.0.1:9200/user/_search   #查找sex含有“男”
的数据
#找不想要的结果，只因创建映射时"sex"的类型为"keyword"。"sex"只能完全为”男的“，才能得出原数据。
{
    "query":{
        "match":{
        "sex":"男"
        }
    }
}

GET http://127.0.0.1:9200/user/_search
    #查询电话
#报错只因创建映射时"tel"的"index"为false。
{
    "query":{
        "match":{
        "tel":"11"
        }
    }
}

JavaAPI环境准备

添加依赖

    <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>
    <dependency>
        <groupId>com.fasterxml.jackson.core</groupId>
        <artifactId>jackson-databind</artifactId>
        <version>2.9.9</version>
    </dependency>
    <!-- junit 单元测试 -->
    <dependency>
        <groupId>junit</groupId>
        <artifactId>junit</artifactId>
        <version>4.12</version>
    </dependency>

测试HelloElasticsearch

public class HelloElasticsearch {
    public static void main(String[] args) throws IOException {
        // 创建ES客户端对象
        RestHighLevelClient client = new RestHighLevelClient(
                RestClient.builder(new HttpHost("localhost", 9200, "http")));
//    ...
        System.out.println(client);

        // 关闭客户端连接
        client.close();
    }
}

JavaAPI索引操作

每一次都要创建ES客户端对象且最后关闭

public static void main(String[] args) throws IOException {
    // 创建ES客户端对象
    RestHighLevelClient client = new RestHighLevelClient(
            RestClient.builder(new HttpHost("localhost", 9200, "http")));
            
   -----------下面的代码加载这里
   
   // 关闭客户端连接
    client.close();
}

JavaAPI索引创建

public static void main(String[] args) throws IOException {
    // 创建ES客户端对象
    RestHighLevelClient client = new RestHighLevelClient(
            RestClient.builder(new HttpHost("localhost", 9200, "http")));

    //创建索引
    CreateIndexRequest request = new CreateIndexRequest("book");
    CreateIndexResponse response = client.indices().create(request, RequestOptions.DEFAULT);
    //响应状态
    boolean acknowledged = response.isAcknowledged();
    System.out.println("索引操作："+acknowledged);
    // 关闭客户端连接
    client.close();
}

JavaAPI索引查询删除

//查询
    //查询索引
    GetIndexRequest request = new GetIndexRequest("user2");
    GetIndexResponse response = client.indices().get(request, RequestOptions.DEFAULT);
    //响应状态
    System.out.println(response.getAliases());
    System.out.println(response.getMappings());
    System.out.println(response.getSettings());


//删除
    //删除索引
    DeleteIndexRequest request = new DeleteIndexRequest("user2");
    AcknowledgedResponse response = client.indices().delete(request, RequestOptions.DEFAULT);
    //响应状态
    System.out.println("操作结果:"+response.isAcknowledged());

JavaAPI文档操作

新增修改

//新增
    //插入数据
    IndexRequest request = new IndexRequest("user2");
    request.index("user2").id("1001");

    User user=new User();
    user.setName("zhangsan");
    user.setSex("男");
    user.setAge(18);
    //向ES中插入数据，必须将数据转换为JSON格式
    ObjectMapper object=new ObjectMapper();
    String projectJson = object.writeValueAsString(user);
    //添加文档数据，数据格式为json格式
    request.source(projectJson, XContentType.JSON);

    //客户端发送请求，获得响应数据
    IndexResponse response = client.index(request, RequestOptions.DEFAULT);
    System.out.println(response.getIndex());
    System.out.println(response.getId());
    System.out.println(response.getResult());


//修改文档--请求对象
UpdateRequest request = new UpdateRequest();
//配置修改参数
request.index("user2").id("1001");

User user=new User();
user.setAge(30);
//向ES中插入数据，必须将数据转换为JSON格式
ObjectMapper object=new ObjectMapper();
String projectJson = object.writeValueAsString(user);
//添加文档数据，数据格式为json格式
request.doc(projectJson, XContentType.JSON);

//客户端发送请求，获得响应数据
UpdateResponse response = client.update(request, RequestOptions.DEFAULT);
System.out.println(response.getIndex());
System.out.println(response.getId());
System.out.println(response.getResult());

查询删除

//查询
//查询文档--请求对象
GetRequest request = new GetRequest();
request = request.index("user2").id("1001");


//客户端发送请求，获得响应数据
GetResponse response = client.get(request, RequestOptions.DEFAULT);
System.out.println(response.getIndex());
System.out.println(response.getId());
System.out.println(response.getSourceAsString());


//删除文档
//删除文档--请求对象
DeleteRequest request = new DeleteRequest();
request = request.index("user2").id("1001");


//客户端发送请求，获得响应数据
DeleteResponse response = client.delete(request, RequestOptions.DEFAULT);

System.out.println(response.getResult());

批量新增、删除

//批量新增
//批量插入数据
BulkRequest request = new BulkRequest("user2");
request.add(new IndexRequest().index("user2").id("1002").source(XContentType.JSON,"name","lisi"));
request.add(new IndexRequest().index("user2").id("1003").source(XContentType.JSON,"name","wangwu"));
request.add(new IndexRequest().index("user2").id("1004").source(XContentType.JSON,"name","zhaoliu"));


//客户端发送请求，获得响应数据
BulkResponse responses = client.bulk(request, RequestOptions.DEFAULT);
System.out.println(responses.getTook());
System.out.println(responses.getItems());


//批量删除
//批量删除数据
BulkRequest request = new BulkRequest("user2");
request.add(new DeleteRequest().index("user2").id("1004"));
request.add(new DeleteRequest().index("user2").id("1003"));


//客户端发送请求，获得响应数据
BulkResponse responses = client.bulk(request, RequestOptions.DEFAULT);
System.out.println(responses.getTook());
System.out.println(responses.getItems());

高级查询-全量查询

//全量查询,查询索引中全部的数据
SearchRequest request = new SearchRequest();
request.indices("user2");

request.source(new SearchSourceBuilder().query(QueryBuilders.matchAllQuery()));
//客户端发送请求，获得响应数据
SearchResponse response = client.search(request, RequestOptions.DEFAULT);

SearchHits hits = response.getHits();
System.out.println(hits.getTotalHits());
System.out.println(response.getTook());

for (SearchHit hit : hits ){
    System.out.println(hit.getSourceAsString());
}

高级查询-分页、条件、排序

条件查询和普通查询差不多，只修改部分。

SearchRequest request = new SearchRequest();
request.indices("user2");

request.source(new SearchSourceBuilder().query(QueryBuilders.termQuery("name","lisa")));
SearchResponse response = client.search(request, RequestOptions.DEFAULT);

SearchHits hits = response.getHits();
System.out.println(response.getTook());
System.out.println(hits.getTotalHits());

for (SearchHit hit:hits){
    System.out.println(hit.getSourceAsString());
}

分页查询

SearchSourceBuilder sourceBuilder = new SearchSourceBuilder();
sourceBuilder.query(QueryBuilders.matchAllQuery());
//分页查询
//当前页其实索引（第一条数据的顺序号），from
sourceBuilder.from(0);
//每页显示多少条
sourceBuilder.size(2);
request.source(sourceBuilder);

SearchResponse response = client.search(request, RequestOptions.DEFAULT);

查询排序

SearchSourceBuilder sourceBuilder = new SearchSourceBuilder();
sourceBuilder.query(QueryBuilders.matchAllQuery());

//排序
sourceBuilder.sort("age", SortOrder.DESC);
request.source(sourceBuilder);

SearchResponse response = client.search(request, RequestOptions.DEFAULT);

高级查询-组合查询、范围查询

组合查询

SearchSourceBuilder sourceBuilder = new SearchSourceBuilder();
BoolQueryBuilder boolQueryBuilder = QueryBuilders.boolQuery();

//必须包含
boolQueryBuilder.must(QueryBuilders.matchQuery("age",30));
//一定不含
boolQueryBuilder.mustNot(QueryBuilders.matchQuery("name","zhangsan"));
//可能包含
boolQueryBuilder.should(QueryBuilders.matchQuery("sex","男"));

sourceBuilder.query(boolQueryBuilder);
request.source(sourceBuilder);

SearchResponse response = client.search(request, RequestOptions.DEFAULT);

范围查询

SearchSourceBuilder sourceBuilder = new SearchSourceBuilder();
        RangeQueryBuilder rangeQuery = QueryBuilders.rangeQuery("age");
        //大于等于
//        rangeQuery.gte("30");
        //小于等于
        rangeQuery.lte("30");


        sourceBuilder.query(rangeQuery);
        request.source(sourceBuilder);

        SearchResponse response = client.search(request, RequestOptions.DEFAULT);

高级查询-模糊查询、高亮查询

模糊查询

SearchRequest request = new SearchRequest();
request.indices("user2");

SearchSourceBuilder sourceBuilder = new SearchSourceBuilder();
FuzzyQueryBuilder fuzzyQueryBuilder = QueryBuilders.fuzzyQuery("name", "wangwu").fuzziness(Fuzziness.ONE);


sourceBuilder.query(fuzzyQueryBuilder);
request.source(sourceBuilder);

SearchResponse response = client.search(request, RequestOptions.DEFAULT);

高亮查询

SearchSourceBuilder sourceBuilder = new SearchSourceBuilder();
//构建查询方式：高亮查询
TermQueryBuilder termQueryBuilder = QueryBuilders.termQuery("name", "zhangsan");
//设置查询方式
sourceBuilder.query(termQueryBuilder);
//构建高亮字段
HighlightBuilder highlightBuilder = new HighlightBuilder();
highlightBuilder.preTags("<font color='red'>");//设置标签前缀
highlightBuilder.postTags("</font>");//设置标签后缀
highlightBuilder.field("name");//设置高亮字段
//设置高亮构建对象
sourceBuilder.highlighter(highlightBuilder);
request.source(sourceBuilder);

SearchResponse response = client.search(request, RequestOptions.DEFAULT);

高级查询-最大值查询、分组查询

最大值查询

SearchRequest request = new SearchRequest();
request.indices("user2");

SearchSourceBuilder sourceBuilder = new SearchSourceBuilder();

MaxAggregationBuilder aggregationBuilder = AggregationBuilders.max("maxAge").field("age");
sourceBuilder.aggregation(aggregationBuilder);

request.source(sourceBuilder);

SearchResponse response = client.search(request, RequestOptions.DEFAULT);

分组查询

SearchSourceBuilder sourceBuilder = new SearchSourceBuilder();

TermsAggregationBuilder termsAggregationBuilder = AggregationBuilders.terms("age_groupby").field("age");
sourceBuilder.aggregation(termsAggregationBuilder);

request.source(sourceBuilder);

SearchResponse response = client.search(request, RequestOptions.DEFAULT);

Windows集群部署

一、创建 elasticsearch-cluster 文件夹

创建 elasticsearch-7.8.0-cluster 文件夹，在内部复制三个 elasticsearch 服务。
在这里插入图片描述

二、修改集群文件目录中每个节点的 config/elasticsearch.yml 配置文件

node-1001:

#节点 1 的配置信息：
#集群名称，节点之间要保持一致
cluster.name: my-elasticsearch
#节点名称，集群内要唯一
node.name: node-1001
node.master: true
node.data: true
#ip 地址
network.host: localhost
#http 端口
http.port: 1001
#tcp 监听端口
transport.tcp.port: 9301
#discovery.seed_hosts: ["localhost:9301", "localhost:9302","localhost:9303"]
#discovery.zen.fd.ping_timeout: 1m
#discovery.zen.fd.ping_retries: 5
#集群内的可以被选为主节点的节点列表
#cluster.initial_master_nodes: ["node-1", "node-2","node-3"]
#跨域配置
#action.destructive_requires_name: true
http.cors.enabled: true
http.cors.allow-origin: "*"

node-1002:

#节点 2 的配置信息：
#集群名称，节点之间要保持一致
cluster.name: my-elasticsearch
#节点名称，集群内要唯一
node.name: node-1002
node.master: false
node.data: true
#ip 地址
network.host: localhost
#http 端口
http.port: 1002
#tcp 监听端口
transport.tcp.port: 9302
discovery.seed_hosts: ["localhost:9301"]
discovery.zen.fd.ping_timeout: 1m
discovery.zen.fd.ping_retries: 5
#集群内的可以被选为主节点的节点列表
#cluster.initial_master_nodes: ["node-1", "node-2","node-3"]
#跨域配置
#action.destructive_requires_name: true
http.cors.enabled: true
http.cors.allow-origin: "*"

node-1003:

#节点 3 的配置信息：
#集群名称，节点之间要保持一致
cluster.name: my-elasticsearch
#节点名称，集群内要唯一
node.name: node-1003
node.master: false
node.data: true
#ip 地址
network.host: localhost
#http 端口
http.port: 1003
#tcp 监听端口
transport.tcp.port: 9303
#候选主节点的地址，在开启服务后可以被选为主节点
discovery.seed_hosts: ["localhost:9301", "localhost:9302"]
discovery.zen.fd.ping_timeout: 1m
discovery.zen.fd.ping_retries: 5
#集群内的可以被选为主节点的节点列表
#cluster.initial_master_nodes: ["node-1", "node-2","node-3"]
#跨域配置
#action.destructive_requires_name: true
http.cors.enabled: true
http.cors.allow-origin: "*"

三、如果有必要，删除每个节点中的 data 目录中所有内容。

四、启动集群

分别依次双击执行节点的bin/elasticsearch.bat, 启动节点服务器（可以编写一个脚本启动），启动后，会自动加入指定名称的集群。

五、测试集群

一、用Postman，查看集群状态
status字段指示着当前集群在总体上是否工作正常。它的三种颜色含义如下：

green：所有的主分片和副本分片都正常运行。
yellow：所有的主分片都正常运行，但不是所有的副本分片都正常运行。
red：有主分片没能正常运行。

GET http://127.0.0.1:1001/_cluster/health
GET http://127.0.0.1:1002/_cluster/health
GET http://127.0.0.1:1003/_cluster/health

二、用Postman，在一节点增加索引，另一节点获取索引
向集群中的node-1001节点增加索引：

#PUT http://127.0.0.1:1001/user

向集群中的node-1003节点获取索引：

#GET http://127.0.0.1:1003/user

Linux单点部署

下载软件

解压软件

# 解压缩
tar -zxvf elasticsearch-7.8.0-linux-x86_64.tar.gz -C /opt/module
# 改名
mv elasticsearch-7.8.0 es

创建用户

因为安全问题， Elasticsearch 不允许 root 用户直接运行，所以要创建新用户，在 root 用户中创建新用户。

useradd es #新增 es 用户
passwd es #为 es 用户设置密码
userdel -r es #如果错了，可以删除再加
chown -R es:es /opt/module/es #文件夹所有者

修改配置文件

修改/opt/module/es/config/elasticsearch.yml文件

# 加入如下配置
cluster.name: elasticsearch
node.name: node-1
network.host: 0.0.0.0
http.port: 9200
cluster.initial_master_nodes: ["node-1"]

修改/etc/security/limits.conf

# 在文件末尾中增加下面内容
# 每个进程可以打开的文件数的限制
es soft nofile 65536
es hard nofile 65536

修改/etc/security/limits.d/20-nproc.conf

# 在文件末尾中增加下面内容
# 每个进程可以打开的文件数的限制
es soft nofile 65536
es hard nofile 65536
# 操作系统级别对每个用户创建的进程数的限制
* hard nproc 4096
# 注： * 带表 Linux 所有用户名称

修改/etc/sysctl.conf

# 在文件中增加下面内容
# 一个进程可以拥有的 VMA(虚拟内存区域)的数量,默认值为 65536
vm.max_map_count=655360

重新加载

sysctl -p

启动软件

使用 ES 用户启动

cd /opt/module/es/
#启动
bin/elasticsearch
#后台启动
bin/elasticsearch -d

启动时，会动态生成文件，如果文件所属用户不匹配，会发生错误，需要重新进行修改用户和用户组。

关闭防火墙

#暂时关闭防火墙
systemctl stop firewalld
#永久关闭防火墙
systemctl enable firewalld.service #打开防火墙永久性生效，重启后不会复原
systemctl disable firewalld.service #关闭防火墙，永久性生效，重启后不会复原

测试软件

浏览器中输入地址： http://linux1:9200/

Linux集群部署

下载软件

解压软件

# 解压缩
tar -zxvf elasticsearch-7.8.0-linux-x86_64.tar.gz -C /opt/module
# 改名
mv elasticsearch-7.8.0 es-cluster

将软件分发到其他节点： linux2, linux3。

创建用户

因为安全问题， Elasticsearch 不允许 root 用户直接运行，所以要创建新用户，在 root 用户中创建新用户。

useradd es #新增 es 用户
passwd es #为 es 用户设置密码
userdel -r es #如果错了，可以删除再加
chown -R es:es /opt/module/es #文件夹所有者

修改配置文件

修改/opt/module/es/config/elasticsearch.yml文件，分发文件

# 加入如下配置
#集群名称
cluster.name: cluster-es
#节点名称， 每个节点的名称不能重复
node.name: node-1
#ip 地址， 每个节点的地址不能重复
network.host: linux1
#是不是有资格主节点
node.master: true
node.data: true
http.port: 9200
# head 插件需要这打开这两个配置
http.cors.allow-origin: "*"
http.cors.enabled: true
http.max_content_length: 200mb
#es7.x 之后新增的配置，初始化一个新的集群时需要此配置来选举 master
cluster.initial_master_nodes: ["node-1"]
#es7.x 之后新增的配置，节点发现
discovery.seed_hosts: ["linux1:9300","linux2:9300","linux3:9300"]
gateway.recover_after_nodes: 2
network.tcp.keep_alive: true
network.tcp.no_delay: true
transport.tcp.compress: true
#集群内同时启动的数据任务个数，默认是 2 个
cluster.routing.allocation.cluster_concurrent_rebalance: 16
#添加或删除节点及负载均衡时并发恢复的线程个数，默认 4 个
cluster.routing.allocation.node_concurrent_recoveries: 16
#初始化数据恢复时，并发恢复线程的个数，默认 4 个
cluster.routing.allocation.node_initial_primaries_recoveries: 16

修改/etc/security/limits.conf，分发文件

# 在文件末尾中增加下面内容

es soft nofile 65536
es hard nofile 65536

修改/etc/security/limits.d/20-nproc.conf，分发文件

# 在文件末尾中增加下面内容
es soft nofile 65536
es hard nofile 65536
\* hard nproc 4096
\# 注： * 带表 Linux 所有用户名称

修改/etc/sysctl.conf

# 在文件中增加下面内容
vm.max_map_count=655360

重新加载

sysctl -p

启动软件

分别在不同节点上启动 ES 软件

cd /opt/module/es/
#启动
bin/elasticsearch
#后台启动
bin/elasticsearch -d

测试集群

在这里插入图片描述

Ferry.

关注

30
点赞
踩
9

收藏

觉得还不错? 一键收藏
0
评论
复制链接

分享到 QQ

分享到新浪微博

扫一扫

ElasticSearch入门和环境部署

文章目录

HTTP索引操作

创建索引

查询和删除索引

HTTP文档操作

创建文档（post新增）

查询文档(条件查询、分页、查询排序、多条件、范围)

修改/删除文档

HTTP全文检索、完全匹配、高亮匹配

全文检索

完全匹配

高亮匹配

HTTP聚合查询

HTTP映射关系

JavaAPI环境准备

JavaAPI索引操作

JavaAPI索引创建

JavaAPI索引查询删除

JavaAPI文档操作

新增修改

查询删除

批量新增、删除

高级查询-全量查询

高级查询-分页、条件、排序

高级查询-组合查询、范围查询

高级查询-模糊查询、高亮查询

高级查询-最大值查询、分组查询

Windows集群部署

一、创建 elasticsearch-cluster 文件夹

二、修改集群文件目录中每个节点的 config/elasticsearch.yml 配置文件

三、如果有必要，删除每个节点中的 data 目录中所有内容 。

四、启动集群

五、测试集群

Linux单点部署

下载软件

解压软件

创建用户

修改配置文件

启动软件

测试软件

Linux集群部署

下载软件

解压软件

创建用户

修改配置文件

启动软件

测试集群

三、如果有必要，删除每个节点中的 data 目录中所有内容。