容器化安装环境

Docker中安装并启动ElasticSearch

前置配置

第一步：在宿主机上执行echo “net.ipv4.ip_forward=1” >>/usr/lib/sysctl.d/00-system.conf

2.第二步：重启network和docker服务
[root@localhost /]# systemctl restart network && systemctl restart docker

安装ElasticSearch

1.下载镜像

docker pull elasticsearch:7.6.2

2.创建挂载的目录

mkdir -p /mydata/elasticsearch/config
mkdir -p /mydata/elasticsearch/data
mkdir -p /mydata/elasticsearch/plugins
echo "http.host: 0.0.0.0" >> /mydata/elasticsearch/config/elasticsearch.yml

3.创建容器并启动

chmod -R 777 /mydata/elasticsearch/data /mydata/elasticsearch/config /mydata/elasticsearch/plugins

docker run --name elasticsearch -p 9200:9200  -p 9300:9300 \
-e "discovery.type=single-node" \
-e ES_JAVA_OPTS="-Xms84m -Xmx512m" \
-v /mydata/elasticsearch/config/elasticsearch.yml:/usr/share/elasticsearch/config/elasticsearch.yml \
-v /mydata/elasticsearch/data:/usr/share/elasticsearch/data \
-v /mydata/elasticsearch/plugins:/usr/share/elasticsearch/plugins \
-d elasticsearch:7.6.2

其中elasticsearch.yml是挂载的配置文件，data是挂载的数据，plugins是es的插件，如ik，而数据挂载需要权限，需要设置data文件的权限为可读可写,需要下边的指令。
chmod -R 777 要修改的路径

-e "discovery.type=single-node" 设置为单节点
特别注意：
-e ES_JAVA_OPTS="-Xms256m -Xmx256m" \ 测试环境下，设置ES的初始内存和最大内存，否则导致过大启动不了ES

访问查看

4.修改配置

进入容器&打开文件

docker exec -it elasticsearch bash
cd config
vi elasticsearch.yml

进入config目录里创建elasticsearch.yml文件，并使用vi命令插入如下内容：

http.host: 0.0.0.0

5.重启es并设置密码

配置x-pack 不然会报错

1. 进入

   docker exec -it elasticsearch bash
   

   目录，执行以下命令：

   ./bin/elasticsearch-setup-passwords interactive
   

2. 会出现以下错误信息：

   Unexpected response code [500] from calling GET http://127.0.0.1:9200/_security/_authenticate?pretty  
   It doesn't look like the X-Pack security feature is enabled on this Elasticsearch node.
   Please check if you have enabled X-Pack security in your elasticsearch.yml configuration file.
   

3. 我们需要配置文件中开启x-pack验证，修改

   config/elasticsearch.yml
   

   配置文件，在尾部添加以下内容，然后重启elasticsearch：

   xpack.security.enabled: true
   

   ./bin/elasticsearch -d
   

4. 重复第1步，为elastic、apm_system、kibana、logstash_system、beats_system、remote_monitoring_user设置密码，这里我设置了统一密码：123456，具体操作：

cd bin
elasticsearch-setup-passwords interactive
// 输出
Initiating the setup of passwords for reserved users elastic,apm_system,kibana,kibana_system,logstash_system,beats_system,remote_monitoring_user.
You will be prompted to enter passwords as the process progresses.
Please confirm that you would like to continue [y/N]Y
 
 
Enter password for [elastic]:
Reenter password for [elastic]:
Enter password for [apm_system]:
Reenter password for [apm_system]:
Enter password for [kibana_system]:
Reenter password for [kibana_system]:
Enter password for [logstash_system]:
Reenter password for [logstash_system]:
Enter password for [beats_system]:
Reenter password for [beats_system]:
Enter password for [remote_monitoring_user]:
Reenter password for [remote_monitoring_user]:
Changed password for user [apm_system]
Changed password for user [kibana_system]
Changed password for user [kibana]
Changed password for user [logstash_system]
Changed password for user [beats_system]
Changed password for user [remote_monitoring_user]
Changed password for user [elastic]

5.先不加用户密码进行访问：curl 127.0.0.1:9200：

{
  "error": {
    "root_cause": [
      {
        "type": "security_exception",
        "reason": "missing authentication credentials for REST request [/]",
        "header": {
          "WWW-Authenticate": "Basic realm=\"security\" charset=\"UTF-8\""
        }
      }
    ],
    "type": "security_exception",
    "reason": "missing authentication credentials for REST request [/]",
    "header": {
      "WWW-Authenticate": "Basic realm=\"security\" charset=\"UTF-8\""
    }
  },
  "status": 401
}

6.CURL密码访问Elasticsearch

curl -u elastic:123456 127.0.0.1:9200
# 或者
curl -u elastic 127.0.0.1:9200
Enter host password for user 'elastic': 123456

成功打印：

安装 elasticsearch-head

此时如果想查看es的服务是否启动正常，还可以基于docker来安装es的插件。过程基本一样，先docker去拉取插件，然后docker运行容器：

 docker pull mobz/elasticsearch-head:5

执行docker命令后，也可以使用docker ps -a来查看是否成功启动。不过更好的方式是和es服务链接上。因此接下来首先需要修改es的config目录的配置文件elasticsearch.yml，在其后面增加两行语句：

http.cors.enabled: true   
http.cors.allow-origin: "*"

主要目的就是允许跨域请求。

由于修改了配置文件，所以需要重启一下es的服务。直接运行如下语句：

docker restart elasticsearch

到此就可以使用网页浏览器来查看es的运行状况了。打开一个浏览器，地址栏上输入安装es插件的服务器ip地址和其端口号：

安装Kibana

7.6版本Kibana启动 参数 ELASTICSEARCH_URL

docker pull kibana:7.6.2

docker run --name kibana -e ELASTICSEARCH_HOSTS=http://自己的IP地址:9200 -p 5601:5601 -d kibana:7.6.2
//docker run --name kibana -e ELASTICSEARCH_URL=http://自己的IP地址:9200 -p 5601:5601 -d kibana:7.6.2

或者 

docker run --name kibana -d --link YOUR_ELASTICSEARCH_CONTAINER_NAME_OR_ID:elasticsearch -p 5601:5601 kibana:7.6.2
YOUR_ELASTICSEARCH_CONTAINER_NAME_OR_ID：Elasticsearch容器的名字或容器ID

修改配置

1、进入容器&打开文件

docker exec -it kibana bash
cd config
vi kibana.yml

2、编辑文件

IpAddress：docker inspect es查看es容器内部的ip地址 （link启动容器需要查看）

server.name: kibana
server.host: "0.0.0.0"
elasticsearch.hosts: [ "http://192.168.59.139:9200" ]
xpack.monitoring.ui.container.elasticsearch.enabled: true
elasticsearch.username: "elastic"
elasticsearch.password: "123456"
i18n.locale: "zh-CN"

3、退出&重启

exit
docker restart kibana

然后访问页面
http://自己的IP地址:5601/app/kibana

kibana操作ElasticSearch

文档操作

1. _cat

GET /_cat/node 查看所有节点
GET /_cat/health 查看es健康状况
GET /_cat/master 查看主节点
GET /_cat/indices 查看所有索引

2. 保存文档

保存一个数据，保存在那个索引的那个类型下，指定用唯一的标识，customer为索引,external为类型,1为标识。其中PUT和POST都可以，POST新增。如果不指定ID，会自动生成ID，指定ID就会修改这个数据，并新增版本号。PUT可以新增可以修改，PUT必须指定ID，一般都用来修改操作，不指定ID会报错。

PUT customer/external/1
{
  "name":"张三"
}

返回结果
{
  "_index" : "customer",
  "_type" : "external",
  "_id" : "1",
  "_version" : 3,
  "result" : "updated",
  "_shards" : {
    "total" : 2,
    "successful" : 1,
    "failed" : 0
  },
  "_seq_no" : 1001,
  "_primary_term" : 2
}

3. 查询文档

GET customer/external/1
    
结果:
{
  "_index" : "customer", //在那个索引
  "_type" : "external", //在那个类型
  "_id" : "1", //记录ID
  "_version" : 1, //版本号
  "_seq_no" : 0, //并发控制字段，每次更新就+1，可用于乐观锁
  "_primary_term" : 1, //主分片重新分配，如重启，就会变化
  "found" : true, //true就是找到数据了
  "_source" : { //数据
    "name" : "张三"
  }
}

4. 更新文档

POST操作带_update会对比原来的数据，如果是一样的那就不会更新了
POST customer/external/1/_update
{
  "doc":{
    "name":"你好"
  }
}
POST操作不带_update会直接更新操作
POST customer/external/1
{
  "name":"你好"
}

5. 删除文档

DELETE customer/external/1

安装FileBeat

拉取 镜像

docker  pull elastic/filebeat:7.6.2

拉取完成之后，先不着急启动，在启动之前需要完成先建立一份映射的配置文filebeat.docker.yml,选择目录创建filebeat.docker.yml

#=========================== Filebeat inputs ==============
filebeat.inputs:
- input_type: log
  enable: true
  paths:  # 采集日志的路径这里是容器内的path
   - /usr/share/filebeat/logs/*.log
  multiline.pattern: '^[0-9]{4}-[0-9]{2}-[0-9]{2}'
  multiline.negate: true
  multiline.match: after
  multiline.timeout: 10s
  # 为每个项目标识,或者分组，可区分不同格式的日志
  tags: ["pre-logs"]
  # 这个文件记录日志读取的位置，如果容器重启，可以从记录的位置开始取日志
  registry_file: /usr/share/filebeat/data/
  fields:
    logsource: node1
    logtype: pre

#-------------------------- Elasticsearch output ---------
output.elasticsearch:
    hosts: ["http://192.168.59.139:9200"]

为什么不直接去filbeat容器里面去改配置文件呢？因为filebeat容器的配置文件是只读的不可更改，所以只能通过映射配置文件的方式修改。

docker run --user=root -d \
-v /home/filebeat/filebeat.docker.yml:/usr/share/filebeat/filebeat.yml \
-v /home/logs:/usr/share/filebeat/logs \
-v /home/data:/usr/share/filebeat/data \
--link elasticsearch \
--link kibana  \
--name filebeat    elastic/filebeat:7.6.2

docker run --name filebeat -d --user root \
-v /Users/lihaodong/Desktop/log:/usr/share/filebeat/logs \
-v /usr/local/src/elk/filebeat/config/filebeat.yml:/usr/share/filebeat/filebeat.yml \
-v /usr/local/src/elk/filebeat/data:/usr/share/filebeat/data \
docker.elastic.co/beats/filebeat:7.6.2

建立好配置文件之后，启动filebeat容器

docker run --user=root -d \
-v /home/filebeat.docker.yml:/usr/share/filebeat/filebeat.yml \
-v /home/logs:/usr/share/filebeat/logs \
-v /home/data:/usr/share/filebeat/data \
--link elasticsearch \
--link kibana  \
--name filebeat  elastic/filebeat:7.6.2

docker run --name filebeat -d --user root \
-v /Users/lihaodong/Desktop/log:/usr/share/filebeat/logs \
-v /usr/local/src/elk/filebeat/config/filebeat.yml:/usr/share/filebeat/filebeat.yml \
-v /usr/local/src/elk/filebeat/data:/usr/share/filebeat/data \
docker.elastic.co/beats/filebeat:7.6.2

这里 -v 就是挂载目录的意思就是将自己本地的目录挂载到容器当中，第一个挂载映射的是配置文件，第二个是要收集的日志目录，如果不挂载日志目录的话，filebeat是不会收集日志的，因为在容器里面根本找不到要收集的路径。–user=root 指定启动用户，因为读取文件可能没有权限，link起的别名等信息可以在同一网络中通过别名访问。

docker run --name filebeat -d --user root \
-v /Users/lihaodong/Desktop/log:/usr/share/filebeat/logs \
-v /usr/local/src/elk/filebeat/config/filebeat.yml:/usr/share/filebeat/filebeat.yml \
-v /usr/local/src/elk/filebeat/data:/usr/share/filebeat/data \
docker.elastic.co/beats/filebeat:7.6.2

可以看到filebeat已经成功启动了，如果启动失败的话可以看filebeat的配置文件es和kibana的host是否正确。

在收集日志的目录下面添加日志文件，或者更新日志，然后去kibana查看是否有filebeat的索引生成（必须是添加或者更新日志，原有的数据不会同步）。

手动创建模拟下，可以看到被filebeat加载收集了

通过elasticsearch-head查看日志索引状态

Kibana中可以看到已经有生成了索引并且有数据了，在Discover查看具体数据

注意：参考下一节内容预先配置下索引

参考： 配置filebeat.yml文件

#============================== Kibana =====================================

# Starting with Beats version 6.0.0, the dashboards are loaded via the Kibana API.
# This requires a Kibana endpoint configuration.
setup.kibana:

  # Kibana Host
  # Scheme and port can be left out and will be set to the default (http and 5601)
  # In case you specify and additional path, the scheme is required: http://localhost:5601/path
  # IPv6 addresses should always be defined as: https://[2001:db8::1]:5601
  host: "192.168.110.130:5601"  #指定kibana
  username: "elastic"   #用户
  password: "${ES_PWD}"  #密码，这里使用了keystore，防止明文密码

  # Kibana Space ID
  # ID of the Kibana Space into which the dashboards should be loaded. By default,
  # the Default Space will be used.
  #space.id:

#================================ Outputs =====================================

# Configure what output to use when sending the data collected by the beat.

#-------------------------- Elasticsearch output ------------------------------
output.elasticsearch:
  # Array of hosts to connect to.
  hosts: ["192.168.110.130:9200","192.168.110.131:9200"]

  # Protocol - either `http` (default) or `https`.
  #protocol: "https"

  # Authentication credentials - either API key or username/password.
  #api_key: "id:api_key"
  username: "elastic"  #es的用户
  password: "${ES_PWD}" # es的密码
  #这里不能指定index，因为我没有配置模板，会自动生成一个名为filebeat-%{[beat.version]}-%{+yyyy.MM.dd}的索引

简单介绍如何配置索引

在Kibana中配置索引

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接

配置筛选字段 这里按照时间

创建成功了

查看最终索引数据

模拟手动添加日志 查看控制台实时采集了

我们到Kibana里查询下 可以看到最终的日志信息

可以通过搜索或者日期筛选，字段筛选，等等各种操作查看你需要的日志信息。或者可以在 日志目录下 查看日志

Kibana基本操作

清理配置的索引数据

日志可视化

保存这个视图，并加入仪表盘中

实战练习

1. 通过rsyslog收集本机所有日志
2. 通过filebeat收集日志，给到elasticsearch
3. Elasticsearch分析日志
4. Elasticsearch将分析结果给到kibana

通过rsyslog收集本机所有日志

修改配置文件
[root@VM-20-10-centos ~]# vim /etc/rsyslog.conf
解封2行
module(load="imudp") # needs to be done just once
input(type="imudp" port="514")
新增一行
# Save boot messages also to boot.log
local7.*                                                /var/log/boot.log
#以下为新增，即将所有日志都收集到一个文件
*.*                                                     /var/log/baism.log

systemctl restart rsyslog

docker run --name filebeat2 -d --user root \
-v /var/log:/usr/share/filebeat/logs \
-v /usr/local/src/elk/filebeat2/config/filebeat.yml:/usr/share/filebeat/filebeat.yml \
-v /usr/local/src/elk/filebeat2/data:/usr/share/filebeat/data \
docker.elastic.co/beats/filebeat:7.6.2

docker exec -it filebeat3 bash
/usr/share/filebeat/logs
mkdir  syslog 

docker run --name filebeat3 -d --user root \
-v /home/logs:/usr/share/filebeat/logs/syslog \
-v /usr/local/src/elk/filebeat3/config/filebeat.yml:/usr/share/filebeat/filebeat.yml \
-v /usr/local/src/elk/filebeat3/data:/usr/share/filebeat/data \
docker.elastic.co/beats/filebeat:7.6.2

filebeat.inputs:
- input_type: log
  enable: true
  paths:  # 采集日志的路径这里是容器内的path 
   - /usr/share/filebeat/logs/syslog/*.log
  multiline.pattern: '^[0-9]{4}-[0-9]{2}-[0-9]{2}'
  multiline.negate: true
  multiline.match: after
  multiline.timeout: 10s
  # 为每个项目标识,或者分组，可区分不同格式的日志
  tags: ["pre-logs3"]
  # 这个文件记录日志读取的位置，如果容器重启，可以从记录的位置开始取日志
  registry_file: /usr/share/filebeat/data/
  fields:
    logsource: node1
    logtype: pre

#-------------------------- Elasticsearch output ---------
output.elasticsearch:
    hosts: ["http://192.168.59.139:9200"]

rest-high-level-client整合ElasticSearch

1.导入依赖

		<!-- 修改springboot默认整合的es的版本 -->
        <properties>
            <java.version>1.8</java.version>
            <elasticsearch.version>7.6.2</elasticsearch.version>
        </properties>
    
        <!-- elasticsearch-rest-high-level-client -->
        <dependency>
            <groupId>org.elasticsearch.client</groupId>
            <artifactId>elasticsearch-rest-high-level-client</artifactId>
            <version>7.6.2</version>
        </dependency>
        
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>1.2.68</version>
        </dependency>

2.编写配置类

@Configuration
public class ElasticSearchClientConfig {
    @Bean
    public RestHighLevelClient restHighLevelClient(){
        RestHighLevelClient client = new RestHighLevelClient(
                RestClient.builder(
                        new HttpHost("自己的IP地址", 9200, "http")
                )
        );
        return client;
    }
}

3.进行es的索引操作

@Autowired
    @Qualifier("restHighLevelClient")
    private RestHighLevelClient client;
    //index名字，静态一般都是放在另一个类中的
    public static final String ES_INDEX="han_index";

    //创建索引
    @Test
    public void createIndex() throws IOException {
        //1. 创建索引
        CreateIndexRequest index = new CreateIndexRequest(ES_INDEX);
        //2. 客户端执行请求,请求后获得相应
        CreateIndexResponse response = client.indices().create(index, RequestOptions.DEFAULT);
        //3.打印结果
        System.out.println(response.toString());
    }
    //测试索引是否存在
    @Test
    public void exitIndex() throws IOException{
        //1.
        GetIndexRequest request = new GetIndexRequest(ES_INDEX);
        boolean exists = client.indices().exists(request, RequestOptions.DEFAULT);
        System.out.println("是否存在"+exists);
    }
    //删除索引
    @Test
    public void deleteIndex() throws IOException{
        DeleteIndexRequest request = new DeleteIndexRequest(ES_INDEX);
        AcknowledgedResponse response = client.indices().delete(request, RequestOptions.DEFAULT);
        System.out.println("是否删除"+response);
    }

4.es的文档操作

 @Autowired
    @Qualifier("restHighLevelClient")
    private RestHighLevelClient client;

    public static final String ES_INDEX="han_index";

    //创建文档
    @Test
    public void createDocument() throws IOException {
        //创建对象
        UserInfo userInfo = new UserInfo("张三",12);
        //创建请求
        IndexRequest request = new IndexRequest(ES_INDEX);
        //规则
        request.id("1").timeout(TimeValue.timeValueSeconds(1));
        //将数据放到请求中
        request.source(JSON.toJSONString(userInfo), XContentType.JSON);
        //客户端发送请求，获取相应的结果
        IndexResponse response = client.index(request, RequestOptions.DEFAULT);
        //打印一下
        System.out.println(response.toString());
        System.out.println(response.status());
    }

    //判断是否存在
    @Test
    public void exitDocument() throws IOException {
        GetRequest request = new GetRequest(ES_INDEX, "1");
        //不获取返回的_source 的上下文
        request.fetchSourceContext(new FetchSourceContext(false));
        request.storedFields("_none");

        boolean exists = client.exists(request, RequestOptions.DEFAULT);
        System.out.println(exists);
    }

    //获取文档信息
    @Test
    public void getDocument() throws IOException {
        GetRequest request = new GetRequest(ES_INDEX, "1");
        GetResponse response = client.get(request, RequestOptions.DEFAULT);
        System.out.println("获取到的结果"+response.getSourceAsString());
    }

    //更新文档
    @Test
    public void updateDocument() throws IOException {
        //创建对象
        UserInfo userInfo = new UserInfo("李四",12);

        UpdateRequest request = new UpdateRequest(ES_INDEX, "1");
        request.timeout("1s");

        request.doc(JSON.toJSONString(userInfo),XContentType.JSON);
        UpdateResponse response = client.update(request, RequestOptions.DEFAULT);
        System.out.println(response.status());
    }

    //删除文档
    @Test
    public void deleteDocument() throws IOException{
        DeleteRequest request = new DeleteRequest(ES_INDEX, "1");
        request.timeout("1s");

        DeleteResponse response = client.delete(request, RequestOptions.DEFAULT);
        System.out.println(response.status());
    }

    //批量添加
    @Test
    public void bulkDocument() throws IOException{
        BulkRequest request = new BulkRequest();
        request.timeout("10s");

        ArrayList<UserInfo> userInfos = new ArrayList<>();
        userInfos.add(new UserInfo("李四",1));
        userInfos.add(new UserInfo("李四",2));
        userInfos.add(new UserInfo("李四",3));
        userInfos.add(new UserInfo("李四",4));
        userInfos.add(new UserInfo("李四",5));
        userInfos.add(new UserInfo("李四",6));
        userInfos.add(new UserInfo("李四",7));

        //进行批处理请求
        for (int i = 0; i <userInfos.size() ; i++) {
            request.add(
                    new IndexRequest(ES_INDEX)
                    .id(""+(i+1))
                    .source(JSON.toJSONString(userInfos.get(i)),XContentType.JSON));
        }

        BulkResponse response = client.bulk(request, RequestOptions.DEFAULT);
        System.out.println(response.hasFailures());
    }

    //查询
    @Test
    public void SearchDocument() throws IOException{
        SearchRequest request = new SearchRequest(ES_INDEX);
        //构建搜索条件
        SearchSourceBuilder builder = new SearchSourceBuilder();

        //查询条件使用QueryBuilders工具来实现
        //QueryBuilders.termQuery 精准查询
        //QueryBuilders.matchAllQuery() 匹配全部
        MatchQueryBuilder matchQuery = QueryBuilders.matchQuery("name", "李四");
        builder.query(matchQuery);
        builder.timeout(new TimeValue(60, TimeUnit.SECONDS));

        request.source(builder);

        SearchResponse response = client.search(request, RequestOptions.DEFAULT);
        System.out.println("查询出的结果"+JSON.toJSONString(response.getHits()));
    }