Docker-Compose部署ELK

1.概述

1.1定义

对于大规模的日志，需要集中化的管理。而ELK提供了一整套解决方案，并且都是开源软件，之间互相配合使用，完美衔接，高效的满足了很多场合的应用。ELK是三种技术产品的简称，包括Elasticsearch、Logstash、Kibana，可在项目中作为日志框架使用。

1.2功能说明

Elasticsearch是个开源分布式搜索引擎，提供搜集、分析、存储数据三大功能。

Logstash 主要是用来日志的搜集、分析、过滤日志的工具，支持大量的数据获取方式。

Kibana 也是一个开源和免费的工具，Kibana可以为 Logstash 和 ElasticSearch 提供的日志分析友好的 Web 界面，可以帮助汇总、分析和搜索重要数据日志。

它们的作用如图：

简单来说，应用服务生产日志，通过Logger产生日志并输出；Logstash通过http接收应用服务产生的日志；Elasticsearch为日志提供全文检索功能；kibana为Elasticsearch提供图形化界面。

Compose 安装

前往另一篇文章教程，安装docker Docker 安装 RabbitMQ

Linux 上我们可以从 Github 上下载它的二进制包来使用，最新发行的版本地址：https://github.com/docker/compose/releases。

 点击这下载 v2.2.2

运行以下命令以下载 Docker Compose 的当前稳定版本：

$ sudo curl -L "https://github.com/docker/compose/releases/download/1.24.1/docker-compose-$(uname -s)-$(uname -m)" -o /usr/local/bin/docker-compose

要安装其他版本的 Compose，请替换 1.24.1。

将可执行权限应用于二进制文件：

$ sudo chmod +x /usr/local/bin/docker-compose

创建软链：

$ sudo ln -s /usr/local/bin/docker-compose /usr/bin/docker-compose

测试是否安装成功：

$ docker-compose --version
cker\-compose version 1.24.1, build 4667896b

注意： 对于 alpine，需要以下依赖包： py-pip，python-dev，libffi-dev，openssl-dev，gcc，libc-dev，和 make。

2.部署ELK

本文在Linux上部署，以/opt作为根目录进行说明。

2.1创建目录和文件

1）创建docker-elk目录，在此目录创建文件和其他目录

mkdir /opt/docker_elk

2）创建logstash配置文件

mkdir /opt/docker_elk/logstash
touch  /opt/docker_elk/logstash/logstash.conf

3）配置logstash.conf，其内容如下

input {
  tcp {
    mode => "server"
    host => "0.0.0.0"
    port => 4560
    codec => json
  }
}
output {
  elasticsearch {
    hosts => "elasticsearch:9200"
    index => "logstash-%{+YYYY.MM.dd}"
    user => "elastic"
    password => "nn23rSWQ5xzRkSgE"
  }
}

4）创建kibana配置文件

mkdir /opt/docker_elk/kibana
touch  /opt/docker_elk/kibana/kibana.yml

5）配置kibana.yml，其内容如下

server.host: "0.0.0.0"
elasticsearch.hosts: ["http://elasticsearch:9200"]
elasticsearch.username: "elastic"
elasticsearch.password: "nn23rSWQ5xzRkSgE"  # 替换为你的实际密码
xpack.security.enabled: true
i18n.locale: "zh-CN"

配置kibana的用户密码，设置中文语言

6）创建docker-compose.yml文件

touch /opt/docker_elk/docker-compose.yml

2.2配置docker-compose并启动

打开docker-compose.yml，

cd /opt/docker_elk
vi docker_compose.yml

配置内容如下：

version: '3.7'
services:
  elasticsearch:
    image: elasticsearch:7.2.0
    container_name: elasticsearch
    privileged: true
    user: root
    environment:
      - cluster.name=elasticsearch
      - discovery.type=single-node
      - ES_JAVA_OPTS=-Xms512m -Xmx512m
      # 启用安全功能，如果不需要密码，改为false
      - xpack.security.enabled=true
      # 启用传输层SSL（无网环境下可以禁用）
      - xpack.security.transport.ssl.enabled=false
      # 初始化内置用户密码
      - ELASTIC_PASSWORD=nn23rSWQ5xzRkSgE  # 设置elastic用户的密码
    volumes:
      - /opt/docker_elk/elasticsearch/plugins:/usr/share/elasticsearch/plugins
      - /opt/docker_elk/elasticsearch/data:/usr/share/elasticsearch/data
    ports:
      - 9200:9200
      - 9300:9300
    healthcheck:
      test: ["CMD", "curl", "-f", "-u", "elastic:nn23rSWQ5xzRkSgE", "http://localhost:9200"]
      interval: 30s
      timeout: 10s
      retries: 3

  logstash:
    image: logstash:7.2.0
    container_name: logstash
    ports:
      - 4560:4560
    privileged: true
    environment:
      - TZ=Asia/Shanghai
      # 配置Logstash使用认证连接ES
      - LS_JAVA_OPTS=-Dlogstash.monitoring.elasticsearch.username=elastic -Dlogstash.monitoring.elasticsearch.password=nn23rSWQ5xzRkSgE
    volumes:
      - /opt/docker_elk/logstash/logstash.conf:/usr/share/logstash/pipeline/logstash.conf
    depends_on:
      - elasticsearch
    links:
      - elasticsearch:es

  kibana:
    image: kibana:7.2.0
    container_name: kibana
    ports:
      - 5601:5601
    privileged: true
    links:
      - elasticsearch:es
    depends_on:
      - elasticsearch
    volumes:
    # 挂载配置文件
      - /opt/docker_elk/kibana/kibana.yml:/usr/share/kibana/config/kibana.yml
    healthcheck:
      test: ["CMD", "curl", "-u", "elastic:nn23rSWQ5xzRkSgE", "-f", "http://localhost:5601/api/status"]
      interval: 30s
      timeout: 10s
      retries: 3
    restart: unless-stopped

这里使用privileged设置为true是赋予这个容器root权限。然后启动

docker-compose up -d

在启动时，如果Elasticsearch启动报错，说/usr/share/elasticsearch/data下的文件无权限，那么需要给宿主机授予读写权限

chmod 777 /opt/docker_elk/elasticsearch/data

若启动报错，需要先关闭并删除容器后再重新启动。关闭删除命令：

docker-compose down

2.3打开kibana

1）http://192.168.0.150:5601，访问Kibana web界面。点击左侧设置，进入Management界面

2）点击index Patterns后，点击创建索引

3）点击创建索引，

4）创建名称为logstash-*的index，

5）然后在Next Step(下一步)中选择@timestamp的filter

6）创建完成之后，点击Discover，并选择刚才创建的index

3.收集日志

本文通过SpringBoot架构把日志信息记录到logstash。

3.1环境准备

新建一个springboot的项目，需要导入web的依赖

 <dependency>
    <groupId>org.springframework.boot</groupId>  
    <artifactId>spring-boot-starter-web</artifactId>  
</dependency>

除此之外，需要导入logstash的依赖：

 <!--集成logstash-->
<dependency>  
    <groupId>net.logstash.logback</groupId>  
    <artifactId>logstash-logback-encoder</artifactId>  
    <version>6.6</version>  
</dependency>

3.2使用logback记录日志

logback是SpringBoot自带的日志，只要导入了web的依赖即可使用。

1）在测试包下新建一个测试类和测试方法

  import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
import org.junit.jupiter.api.Test;
import org.springframework.boot.test.context.SpringBootTest;

@SpringBootTest
public class AppTest {

    //创建日志对象
    Logger logger = LoggerFactory.getLogger(this.getClass());   
    @Test public void test1() {   
         logger.info("logback的日志信息过来了");   
         logger.error("logback的错误信息过来了");   
     }   
}

2）在需要目录新建logback-spring.xml

<?xml version="1.0" encoding="UTF-8"?>
<!--该日志将日志级别不同的log信息保存到不同的文件中 -->
<configuration scan="true" scanPeriod="60 seconds" debug="true">
    <springProperty scope="context" name="logstashHost" source="logstash.host"/>
    <springProperty scope="context" name="logstashPort" source="logstash.port"/>
    <springProperty scope="context" name="logstashEnabled" source="logstash.enabled"/>
    <springProperty scope="context" name="appName" source="spring.application.name" defaultValue="application"/>
    <contextName>logstash-test</contextName>
    <!-- 这个是控制台日志输出格式 方便调试对比-->

    <appender name="console" class="ch.qos.logback.core.ConsoleAppender">
        <encoder>
            <pattern>%d{yyyy-MM-dd HH:mm:ss} %contextName %-5level %logger{50} -%msg%n</pattern>
        </encoder>
    </appender>
    <appender name="stash" class="net.logstash.logback.appender.LogstashTcpSocketAppender">
        <!--  这是是logstash服务器地址 端口， 可以配置在yml配置文件中-->
        <!-- <destination>192.168.247.130:4560</destination>-->
        <destination>${logstashHost}:${logstashPort}</destination>
        <!--输出的格式，推荐使用这个-->

        <encoder class="net.logstash.logback.encoder.LogstashEncoder">
              <providers>
                  <!--如果使用traceId , 需要在请求开始注入id，后续代码会展示-->
                  <mdc>
                      <includeMdcKeyName>traceId</includeMdcKeyName>
                  </mdc>
                  <timestamp/>
                  <version/>
                  <message/>
                  <loggerName/>
                  <threadName/>
                  <logLevel/>
                  <callerData/>
              </providers>
              <customFields>{"appName":"${appName}"}</customFields>
        </encoder>
    </appender>
    <root level="info">

        <appender-ref ref="console"/>

        <appender-ref ref="stash"/>
    </root>
</configuration>

3）启动测试方法，查看kibana的日志信息

查看信息时，建议在左侧Available fields中筛选出"message"信息，"thread_name"字段可选。筛选的字段在左侧也可以看到，右侧看到的信息就比较清晰。

需要注意的是，在这些日志中，时间是logstash收集日志时的创建时间，并不是原始日志的记录时间。

4）使用 traceId 追踪 , MVC拦截器

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import org.springframework.web.servlet.HandlerInterceptor;

public class TraceIdInterceptor implements HandlerInterceptor {
    
    @Override
    public boolean preHandle(HttpServletRequest request, 
                           HttpServletResponse response, 
                           Object handler) {
        // 优先从请求头获取TraceID
        String traceId = request.getHeader("X-Trace-ID");
        if (traceId == null || traceId.isEmpty()) {
            traceId = TraceIdUtil.generateTraceId();
        }
        TraceIdUtil.generateIfAbsent();
        response.setHeader("X-Trace-ID", traceId);
        return true;
    }
    
    @Override
    public void afterCompletion(HttpServletRequest request, 
                              HttpServletResponse response, 
                              Object handler, 
                              Exception ex) {
        TraceIdUtil.clear();
    }
}

注册拦截器

import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;

@Configuration
public class WebConfig implements WebMvcConfigurer {
    
    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        registry.addInterceptor(new TraceIdInterceptor());
    }
}

3.3使用log4j2记录日志

要使用log4j2，则必须排除SpringBoot自带的日志。

1）排除logback并导入依赖

   <dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter</artifactId>
    <exclusions>
        <!-- 引入log4j日志时需去掉默认的logback -->
        <exclusion>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-logging</artifactId>
        </exclusion>
    </exclusions>
</dependency>

<!-- 日志管理log4j2 -->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-log4j2</artifactId>
    <version>2.1.0.RELEASE</version>
</dependency>

2）在资源目录下新建log4j2.xml

 <?xml version="1.0" encoding="UTF-8"?>

<configuration status="info">
    <Properties>
        <!-- 声明日志文件存储的目录 -->
        <Property name="LOG_HOME">E:\logs</Property>
        <Property name="LOG_PATTERN"
                  value="%date{yyyy-MM-dd HH:mm:ss.SSS} %-5level [%thread][%class{36}:%line] - %msg%n"></Property>
    </Properties>

    <Appenders>
        <!--输出控制台的配置-->
        <Console name="Console" target="SYSTEM_OUT">
            <!--控制台只输出level及以上级别的信息（onMatch），其他的直接拒绝（onMismatch）-->
            <ThresholdFilter level="info" onMatch="ACCEPT" onMismatch="DENY"/>
            <!-- 输出日志的格式-->
            <PatternLayout pattern="${LOG_PATTERN}"/>
        </Console>

        <!--这输出日志到文件的配置，每次大小超过size，则这size大小的日志会自动存入按年份-月份建立的文件夹下面并进行压缩，作为存档-->
        <RollingFile name="RollingFile" fileName="${LOG_HOME}\app_${date:yyyy-MM-dd}.log"
                     filePattern="${LOG_HOME}\${date:yyyy-MM}\app_%d{yyyy-MM-dd}_%i.log">
            <ThresholdFilter level="info" onMatch="ACCEPT" onMismatch="DENY"/>
            <!-- 输出日志的格式-->
            <PatternLayout pattern="${LOG_PATTERN}"/>
            <!-- 日志文件大小 -->
            <SizeBasedTriggeringPolicy size="20MB"/>
            <!-- 最多保留文件数 -->
            <DefaultRolloverStrategy max="30"/>
        </RollingFile>

        <!--输出到logstash的appender-->
        <Socket name="Socket" host="192.168.86.128" port="4560" protocol="TCP">
            <!--输出到logstash的日志格式-->
            <PatternLayout pattern="${LOG_PATTERN}"/>
        </Socket>
    </Appenders>

    <!--然后定义Logger，只有定义了Logger并引入的Appender，Appender才会生效。Root中level配置了日志级别，可配置其他级别-->
    <Loggers>
        <Root level="info">
            <AppenderRef ref="Console"/>
            <AppenderRef ref="RollingFile"/>
            <AppenderRef ref="Socket"/>
        </Root>
    </Loggers>

</configuration>

主要的上面红色的部分，需要指定logstash服务的ip和记录日志的端口。

3）在测试类新建测试方法

import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
import org.junit.jupiter.api.Test;
import org.springframework.boot.test.context.SpringBootTest;

@SpringBootTest
public class AppTest {

    //创建日志对象
    Logger logger = LogManager.getLogger(this.getClass());

    ...

    @Test
    public void test2() {
        logger.info("我是log4j2的日志信息");
        logger.error("我是log4j2的错误信息");
    }
}

4）启动测试方法，查看kibana的日志信息

查看信息时，建议在左侧Available fields中筛选出"message"信息，"thread_name"字段可选。筛选的字段在左侧也可以看到，右侧看到的信息就比较清晰，包含了日志本身的时间，这是是配置日志配置的。