ElasticSearch与ElasticSearch可视化（亲测）

很久没写博客了，平时都是记录到有道云笔记的：我这里直接cv笔记了，格式可能和csdn不一样，文章挺长的，我也就不一点一点向csdn写了，建议直接看我的有道云笔记，有问题可以留言问我：

文档：ElasticSearch与ElasticSearch可视化（...
链接：http://note.youdao.com/noteshare?id=c9c68246ba3d5b1c60fc127002ea3743&sub=367E44F30FE9481087AA59757FDBE813

华为云镜像：【es：7.6.1】
ElasticSearch: https://mirrors.huaweicloud.com/elasticsearch/?C=N&O=D
logstash: https://mirrors.huaweicloud.com/logstash/?C=N&O=D
kibana: https://mirrors.huaweicloud.com/kibana/?C=N&O=D

ElasticSearch:地址：/usr/local/Elasticsearch/elasticsearch-5.6.13/
安装：

//cd
cd Elasticsearch
//下载
wget https://artifacts.elastic.co/downloads/elasticsearch/elasticsearch-5.6.13.tar.gz
//解压
tar -zxvf elasticsearch-5.6.13.tar.gz

1更改用户和组
//添加用户组
[root@iz2vceej7yes1arlt6mczgz Elasticsearch]# groupadd es
//添加用户
[root@iz2vceej7yes1arlt6mczgz Elasticsearch]# useradd -g es elasticsearch-7.6.1

chown -R 非root用户名:非root组名 elasticsearch-7.6.1
//我创建的为【chown -R elasticsearch-7.6.1:es Elasticsearch/】

修改es配置,改变集群的名字，节点的名字，path.data和path.logs，network.host：

vi elasticsearch.yml [ pwd:/usr/local/Elasticsearch/elasticsearch-5.6.13/config ]
cluster.name: my-application
node.name: node-1
path.data: /data/elastic/data
path.logs: /data/elastic/logs
network.host: 该机器的ip

运行es：

./bin/elasticsearch
或者后台运行
./bin/elasticsearch -d

关闭es：
找出进程号
ps -ef | grep elasticsearch
kill掉

启动报错内存不足：
cd config
vi jvm.options
将：
-Xms2g
-Xmx2g
修改为
-Xms512m
-Xmx512m

参考文献：https://blog.csdn.net/zz_i80/article/details/84318503

新建非root用户组：
　　//1、创建用户：elasticsearch
[root@iZbp1bb2egi7w0ueys548pZ bin]# adduser elasticsearch
　//　2、创建用户密码，需要输入两次【root】
[root@iZbp1bb2egi7w0ueys548pZ bin]# passwd elasticsearch
　//　3、将对应的文件夹权限赋给该用户
[root@iZbp1bb2egi7w0ueys548pZ local]# chown -R elasticsearch elasticsearch-6.0.0
　//　4、切换至elasticsearch用户
[root@iZbp1bb2egi7w0ueys548pZ etc]# su elasticsearch
　//　5、进入启动目录启动 /usr/local/elasticsearch-6.0.0/bin 使用后台启动方式：./elasticsearch -d
[elasticsearch@vmt10003 bin]$ ./elasticsearch -d

向非root用户赋权：
[root@iz2vceej7yes1arlt6mczgz bin]# chown -R elasticsearch /usr/local/Elasticsearch/elasticsearch-5.6.13

ElasticSearch启动报错，bootstrap checks failed：
修改elasticsearch.yml配置文件：
network.host: 0.0.0.0//外网访问

报错如下：
ERROR: [2] bootstrap checks failed
[1]: max file descriptors [4096] for elasticsearch process is too low, increase to at least [65536]
[2]: max virtual memory areas vm.max_map_count [65530] is too low, increase to at least [262144]

解决：
编辑 /etc/security/limits.conf，追加以下内容；

• soft nofile 65536
• hard nofile 65536

编辑 /etc/sysctl.conf，追加以下内容：
vm.max_map_count=655360

保存后，执行：
sysctl -p

重新启动：./elasticsearch -d ===>>>解决

kibana：
下载：www.baid.com
解压： tar -zxvf kibana-6.4.3-linux-x86_64.tar.gz

修改/config 下的配置文件kibana.yml：
server.port: 5601 //kibana 外网访问端口
server.host: “192.168.252.130” //kibana 外网访问IP(当前服务IP)
elasticsearch.url: “http:// 192.168.252.130:9200” //这个是你elasticsearch服务器ip+端口

切换到kibana-6.4.3-linux-x86_64/bin 目录 启动kibana【kibana可能因为版本不同而可能需要切换到非root用户】：
[root@localhost bin]# ./kibana
[root@localhost bin]# nohup ./kibana & //kibana后台启动

外网访问 ip:5601出现图形化界面即可完成：

查看端口的使用情况：
netstat -lntp

报错：
[root@iz2vceej7yes1arlt6mczgz bin]# ./kibana
./kibana: line 24: /usr/local/kibana-5.6.13/kibana-5.6.13-darwin-x86_64/bin/…/node/bin/node: cannot execute binary file
./kibana: line 24: /usr/local/kibana-5.6.13/kibana-5.6.13-darwin-x86_64/bin/…/node/bin/node: Success

权限问题：
赋予权限：
chmod o+x /usr

ElasticSearch与mysql的对应关系:
mysql:数据库===>表===>行===>列
es: 索引===>类型==>文档==>字段

es index的mapping在建好之后是不可以更改字段类型的

添加索引/类型/文档
PUT /megacorp/employee/1
{
“firstName”:“John”,
“lastName”:“Tom”,
“age”:“20”,
“sex”:“1”,
“about”:“let,s me see ,one day day1”,
“interests”:[“book”,“music”]
}

get获取数据:

GET /megacorp/employee/1 获取文档为1的文档的内容

搜索所有文档：
GET /megacorp/employee/_search

尝试下搜索姓氏为 Smith 的雇员
GET /megacorp/employee/_search?q=last_name:Smith

查询表达式 [查询所有名为 Smith 的搜索]:
GET /megacorp/employee/_search
{
“query” : {
“match” : {
“last_name” : “Smith”
}
}
}

同样搜索姓氏为 Smith 的员工，但这次我们只需要年龄大于 30 的:
GET /megacorp/employee/_search
{
“query” : {
“bool”: {
“must”: {
“match” : {
“last_name” : “smith”
}
},
“filter”: {
“range” : {
“age” : { “gt” : 30 } =--------------gt 表示_大于
}
}
}
}
}

搜索下所有喜欢攀岩（rock climbing）的员工：
GET /megacorp/employee/_search
{
“query” : {
“match” : {
“about” : “rock climbing”
}
}
}

短语搜索 [匹配同时包含 “rock” 和 “climbing” ，并且 二者以短语 “rock climbing” 的形式紧挨着的雇员记录]: --------match_phrase 查询
GET /megacorp/employee/_search
{
“query” : {
“match_phrase” : {
“about” : “rock climbing”
}
}
}

高亮搜索:
GET /megacorp/employee/_search
{
“query” : {
“match_phrase” : {
“about” : “rock climbing”
}
},
“highlight”: {
“fields” : {
“about” : {}
}
}
}

聚合与 SQL 中的 GROUP BY 类似但更强大。

聚合可能出错:[聚合需要大量的内存，聚合前，需要将相应的字段开启聚合]
PUT megacorp/_mapping/employee/
{
“properties”: {
“interests”: {
“type”: “text”,
“fielddata”: true
}}}

挖掘出员工中最受欢迎的兴趣爱好：
GET /megacorp/employee/_search
{
“aggs”: {
“all_interests”: {
“terms”: { “field”: “interests” }
} }}

叫 Smith 的员工中最受欢迎的兴趣爱好,组合查询:
GET /megacorp/employee/_search
{
“query”: {
“match”: {
“last_name”: “smith”
}
},
“aggs”: {
“all_interests”: {
“terms”: {
“field”: “interests”
}}}}

分级汇总聚合。比如，查询特定兴趣爱好员工的平均年龄：
GET /megacorp/employee/_search
{
“aggs” : {
“all_interests” : {
“terms” : { “field” : “interests” },
“aggs” : {
“avg_age” : {
“avg” : { “field” : “age” }
}
}}}}

分级汇总聚合:

GET /megacorp/employee/_search
{
“aggs”:{
“all_interests”:{
“terms”: {
“field”: “interests”
}
},
“avg_age”:{
“avg”: {
“field”: “age”
}
}
}
}

获取集群健康状态:
GET /_cluster/health

返回结果:
status 字段指示着当前集群在总体上是否工作正常。它的三种颜色含义如下：
green
所有的主分片和副本分片都正常运行。
yellow
所有的主分片都正常运行，但不是所有的副本分片都正常运行。
red
有主分片没能正常运行

分片与副本:[集群内创建名为
blogs 的索引。 索引在默认情况下会被分配5个主分片， 但是为了演示目的，我们将分配3个主分片和一份副本（每个主分片拥有一个副本分片）]
PUT /blogs
{
“settings” : {
“number_of_shards” : 3,
“number_of_replicas” : 1
}
}

在添加文档的时候如果不需要自己生成id.可以采用post,es会自己生成id:
POST /website/blog/
{
“title”: “My second blog entry”,
“text”: “Still trying this out…”,
“date”: “2014/01/01”
}

自动生成的 ID 是 URL-safe、 基于 Base64 编码且长度为20个字符的 GUID 字符串。 这些 GUID 字符串由可修改的 FlakeID 模式生成，这种模式允许多个节点并行生成唯一 ID ，且互相之间的冲突概率几乎为零。

检测一个文档是否存在:
HEAD /megacorp/employee/7

创建文档的时候,在自定义id时判断是否已经存在该文档:[在 URL 末端使用 /_create :]
PUT /website/blog/123/_create
{ … }

如果创建新文档的请求成功执行，Elasticsearch 会返回元数据和一个 201 Created 的 HTTP 响应码。
另一方面，如果具有相同的 _index 、 _type 和 _id 的文档已经存在，Elasticsearch 将会返回 409 Conflict 响应码

删除文档:
DELETE /website/blog/123

通过update来向已经存在的文档进行数据的合并:[新增tags属性]
POST /megacorp/employee/5/_update
{
“doc”:{
“view”:0
}
}

使用脚本来更新文档:
POST /megacorp/employee/5/_update
{
“script” : “ctx._source.view+=1”
}

结果如下:
{
“took”: 2,
“timed_out”: false,
“_shards”: {
“total”: 5,
“successful”: 5,
“skipped”: 0,
“failed”: 0
},
“hits”: {
“total”: 6,
“max_score”: 1,
“hits”: [
{
“_index”: “megacorp”,
“_type”: “employee”,
“_id”: “5”,
“_score”: 1,
“_source”: {
“firstName”: “uio”,
“lastName”: “Tyui”,
“age”: “17”,
“sex”: “3”,
“about”: “let,s me see ,one day day 6”,
“interests”: [
“bk”,
“mc”
],
“view”: 1 -----------------------------------------------------------view加1 [原来是0]
}
},}

通过使用脚本给 tags 数组添加一个新的标签:
POST /website/blog/1/_update
{
“script” : “ctx._source.tags+=new_tag”, ---------------------------------------------向tags数组添加一个new_tag[search]元素
“params” : {
“new_tag” : “search”
}}

结果如下:
{
“_index”: “website”,
“_type”: “blog”,
“_id”: “1”,
“_version”: 5,
“found”: true,
“_source”: {
“title”: “My first blog entry”,
“text”: “Starting to get the hang of this…”,
“tags”: [“testing”, “search”],
“views”: 1
}
}

在脚本中使用三目表达式:
POST /website/blog/1/_update
{
“script” : “ctx.op = ctx._source.views == count ? ‘delete’ : ‘none’”,
“params” : {
“count”: 1
}}

尝试更新一个不存在的文档:使用 upsert 参数，指定如果文档不存在就应该先创建它
POST /website/pageviews/1/_update
{
“script” : “ctx._source.views+=1”, --------------对views属性加1
“upsert”: {
“views”: 1 ------------------如果views不存在:默认定义views为1
}}

java操作es【这些现在不建议采用】:
API文档:
https://www.elastic.co/guide/en/elasticsearch/client/java-rest/master/java-rest-high-cluster-health.html

代码如下:
public class Rest {
private static RestClient restClient;

public void getRestClient(){
    final CredentialsProvider credentialsProvider = new BasicCredentialsProvider();
    credentialsProvider.setCredentials(AuthScope.ANY,
            new UsernamePasswordCredentials("elastic", "changeme"));
    restClient = RestClient.builder(new HttpHost("es的ip",9200,"http"))
            .setHttpClientConfigCallback(new RestClientBuilder.HttpClientConfigCallback() {
                public HttpAsyncClientBuilder customizeHttpClient(HttpAsyncClientBuilder httpClientBuilder) {
                    return httpClientBuilder.setDefaultCredentialsProvider(credentialsProvider);
                } }).build();}

@Before
public void getRest(){
    restClient = RestClient.builder(new HttpHost("es的ip", 9200, "http")).build();
}

/**
 * 查看api信息
 * @throws Exception
 */
@Test
public void CatApi() throws Exception{
    String method = "GET";
    String endpoint = "/_cat";
    Response response = restClient.performRequest(method,endpoint);
    System.out.println(EntityUtils.toString(response.getEntity()));
}

/**
 * 创建索引
 * @throws Exception
 */
@Test
public void CreateIndex() throws Exception{
    String method = "PUT";
    String endpoint = "/db_dev";
    Response response = restClient.performRequest(method,endpoint);
    System.out.println(EntityUtils.toString(response.getEntity()));
}

/**
 * 创建文档
 * @throws Exception
 */
@Test
public void CreateDocument()throws Exception{
    String method = "PUT";
    String endpoint = "/megacorp/employee/12";
    HttpEntity entity = new NStringEntity(
            "{\n" +
                    " \"user\" : \"sdrtest\",\n" +
                    " \"post_date\" : \"2020-12-01T14:12:12\",\n" +
                    " \"message\" : \"sdr_test_Elasticsearch\"\n" +
                    "}", ContentType.APPLICATION_JSON);

    Response response = restClient.performRequest(method,endpoint, Collections.<String, String>emptyMap(),entity);
    System.out.println(EntityUtils.toString(response.getEntity())); }

/**
 * 获取文档
 * @throws Exception
 */
@Test
public void getDocument()throws Exception{
    String method = "GET";
    String endpoint = "/megacorp/employee/12";
    Response response = restClient.performRequest(method,endpoint);
    System.out.println(EntityUtils.toString(response.getEntity()));
}

/**
 * 查询所有数据
 * @throws Exception
 */
@Test
public void QueryAll() throws Exception {
    String method = "POST";
    String endpoint = "/megacorp/employee/_search";
    HttpEntity entity = new NStringEntity("{\n" +
            " \"query\": {\n" +
            " \"match_all\": {}\n" +
            " }\n" +
            "}", ContentType.APPLICATION_JSON);
    Response response = restClient.performRequest(method,endpoint,Collections.<String, String>emptyMap(),entity);
    System.out.println(EntityUtils.toString(response.getEntity()));
}

/**

• 更新数据 注意逗号分隔

• @throws Exception
  /
  @Test
  public void UpdateByScript() throws Exception {
  String method = “POST”;
  String endpoint = “/megacorp/employee/12_update”;
  HttpEntity entity = new NStringEntity("{\n" +
  " “doc”: {\n" +
  " “user”:“sss”,\n" +
  ““post_date”:“2020-20-20”,\n”+
  " “message”:“saaaa”\n" +
  " }\n" +
  “}”, ContentType.APPLICATION_JSON);
  Response response = restClient.performRequest(method,endpoint,Collections.<String, String>emptyMap(),entity);
  System.out.println(EntityUtils.toString(response.getEntity()));
  }
  /*

• 删除数据 注意逗号分隔

• @throws Exception
  */
  @Test
  public void DelectByScript() throws Exception {
  String method = “DELETE”;
  String endpoint = “/megacorp/employee/1”;
  HttpEntity entity = new NStringEntity("{\n" +

       "}", ContentType.APPLICATION_JSON);
  

  Response response = restClient.performRequest(method,endpoint);
  System.out.println(EntityUtils.toString(response.getEntity()));
  }

ELK [ E:就是es，L：分词器，k：kinan可化]：

ik最小分词器：【ik_smart:最小切分】

最细粒度划分：【穷尽词库的可能：ik_max_word】:

如果需要自己分词的话，编写自己的词库，配置到配置文件即可：【自定义分词器】

es命令操作：

es数据类型：

修改es索引的值：【两者方法，1：put直接覆盖，2：update：】

put和post比较：

注意：在·存储字段的时候尽量设置为text，keyword的类型分词器不会对其生效的

排序：

查出来的结果一般很多，可以通过_source来对结果进行筛选：

分页查询：

must命令：【and】

should命令：【or】；

must_not命令：【not】

过滤器：【filter】：对数据进行过滤操作

通过tags进行条件查询：【like】

高亮查询：【把查询出来的结果里面的name字段的 “狂神说” 高亮显示 】

自定义高亮查询 【把高亮的字段的样式自定义：例如自定义为红色】：

term是代表完全匹配，即不进行分词器分析，文档中必须包含整个搜索的词汇
match和term的区别是,match查询的时候,elasticsearch会根据你给定的字段提供合适的分析器,而term查询不会有分析器分析的过程，match查询相当于模糊匹配,只包含其中一部分关键词就行

springboot整合es：
一，引入maven依赖，注意引入的依赖的版本要和安装的版本对应

二，编写es的config配置类：

创建一个空索引：

判断这个索引是否存在：

删除索引：

对于文档的操作：
文档实体类：

向es的索引库中添加文档：

判断文档是否存在：

获取文档的信息：

更新文档信息：

删除文档记录;

向索引中批量插入数据：

批量删除和更新都是一样的，只不过把add换成update或者delect这种 【不写id就是es自动生成 的随机id】

查询：

查询：

要查什么分页这些，可以直接点from，点size

这种可以直接点：