spring-cloud 分布式日志采集

由于微服务架构中每个服务可能分散在不同的服务器上，因此需要一套分布式日志的解决方案。spring-cloud提供了一个

用来trace服务的组件sleuth。它可以通过日志获得服务的依赖关系。基于sleuth，可以通过现有的日志工具实现分布式日志的采集。

这里使用的是ELK，也就是elasticsearch、logstash、kibana。

一、sleuth

第一步：sleuth管理端

 sleuth一般单独放在一个工程中。需要添加如下依赖

[java]  view plain  copy

1. <dependency>    
2.         <groupId>io.zipkin.java</groupId>    
3.         <artifactId>zipkin-autoconfigure-ui</artifactId>    
4.         <scope>runtime</scope>    
5.     </dependency>   
6.         
7.     <dependency>    
8.         <groupId>io.zipkin.java</groupId>    
9.         <artifactId>zipkin-server</artifactId>    
10.     </dependency>    

配置服务注册中心的地址

[html]  view plain  copy

1. eureka:   
2.   client:   
3.     serviceUrl:   
4.       defaultZone: http://localhost:1111/eureka/  

启动类加入服务发现的注解和zipkin的注解，如下

[java]  view plain  copy

1. package com.wlf.demo;  
2.   
3. import org.springframework.boot.SpringApplication;  
4. import org.springframework.boot.autoconfigure.SpringBootApplication;  
5. import org.springframework.cloud.client.discovery.EnableDiscoveryClient;  
6.   
7. import zipkin.server.EnableZipkinServer;  
8.   
9. @EnableDiscoveryClient   
10. @EnableZipkinServer    
11. @SpringBootApplication    
12. public class Application {  
13.         
14.     public static void main(String[] args) {    
15.         SpringApplication.run(Application.class, args);    
16.     }    
17.       
18. }  

这个时候启动并访问该微服务的地址，可以看到zipkin的管理页面了

第二步：被管理的微服务端

在我们的其他微服务端需要简单的配置，纳入到zipkin的管理之中

引入依赖

[html]  view plain  copy

1. <dependency>    
2.          <groupId>org.springframework.cloud</groupId>    
3.          <artifactId>spring-cloud-starter-sleuth</artifactId>    
4.      </dependency>    
5.        
6.      <dependency>    
7.          <groupId>org.springframework.cloud</groupId>    
8.          <artifactId>spring-cloud-sleuth-zipkin</artifactId>    
9.      </dependency>  

加入如下配置

[html]  view plain  copy

1. spring:   
2.   sleuth:   
3.     sampler:   
4.        percentage: 1  
5.   zipkin:   
6.     base-url: http://localhost:9411  

spring.sleuth.sampler.percentage：这个参数的意思是抓取100%的日志，只有通过抓取日志，才能获知依赖关系。但是

如果始终抓取日志的话对性能会有影响，因此可以自己配置。一般在开发环境，该值设置为1，生产环境视情况而定。

spring.zipkin.base-url：为第一步配置的zipkin管理端微服务的地址

现在分别启动服务注册中心，网关，需要的微服务，以及sleuth。

随便调用一个微服务

然后我们可以看到相关的跟踪日志

同样我们也可以看到微服务之间的依赖关系，这里是通过网关调用了myservice-consumer-feign微服务，然后通过

myservice-consumer-feign微服务调用了myservice-provider微服务

二、搭建ELK

1、elasticsearch的安装与配置，由于之前的文章已经介绍了elasticsearch的单点，集群的安装，head插件的安装。这里

不再总结。

elasticsearch单点搭建

 elasticsearch head插件安装

 elasticsearch集群搭建

2、kibana的安装，没什么好说的，解压，运行就可以了

3、logstash的安装，解压即可

在config下新建配置文件

[html]  view plain  copy

1. output {  
2. input {  
3.   tcp {  
4.       port => 4560  
5.       codec => json_lines  
6.   }  
7. }  
8.   
9. output {  
10.   elasticsearch {  
11.      hosts => ["192.168.160.66:9200","192.168.160.88:9200","192.168.160.166:9200"]  
12.      index => "applog"  
13.   }  
14. }  

  其中port为端口号，codec表示通过json格式，elasticsearch.hosts表示elasticsearch的地址，这里是集群。index

为日志存储的elasticsearch索引。

  启动需要调用bin下的logstash命令，通过-f指定配置文件

 4、使用kibana

 启动elasticsearch、head、kibana、logstash

创建索引applog

 将applog配置到kibana中，在index pattern中输入我们的applog索引

最后点击create即可

  点击菜单中的discover即可查看日志

  三、logback配置

spring-cloud、logstash都是支持logback的，因此需要为微服务配置好相应的logback-spring.xml

这里值得注意的是，在spring-boot中，logback-spring.xml的加载在application.yml之前。而我们需要在

logback-spring.xml中使用spring.application.name。因此，我们需要把spring.application.name配置提到bootstrap.yml中。

加载顺序为bootstrap.yml，logback-spring.xml，application.yml

相比普通的logback-spring.xml，我们主要配置这几样东西spring.application.name，logstash的appender

这里提供一个logback-spring.xml的例子

[html]  view plain  copy

1. <?xml version="1.0" encoding="UTF-8"?>  
2. <configuration scan="true" scanPeriod="10 seconds">  
3.                 
4.     <springProperty scope="context" name="springAppName"   
5.                     source="spring.application.name" />            
6.                 
7.     <property name="CONSOLE_LOG_PATTERN"  
8.               value="%date [%thread] %-5level %logger{36} - %msg%n" />                  
9.                       
10.     <appender name="stdout" class="ch.qos.logback.core.ConsoleAppender">  
11.         <withJansi>true</withJansi>  
12.         <encoder>  
13.            <pattern>${CONSOLE_LOG_PATTERN}</pattern>  
14.            <charset>utf8</charset>  
15.         </encoder>  
16.     </appender>        
17.       
18.     <appender name="logstash"  
19.         class="net.logstash.logback.appender.LogstashTcpSocketAppender">  
20.         <destination>192.168.160.66:4560</destination>    
21.         <encoder class="net.logstash.logback.encoder.LoggingEventCompositeJsonEncoder">  
22.             <providers>  
23.                 <timestamp>  
24.                     <timeZone>UTC</timeZone>  
25.                 </timestamp>  
26.                 <pattern>  
27.                     <pattern>  
28.                         {  
29.                           "severity":"%level",  
30.                           "service": "${springAppName:-}",    
31.                           "trace": "%X{X-B3-TraceId:-}",    
32.                           "span": "%X{X-B3-SpanId:-}",    
33.                           "exportable": "%X{X-Span-Export:-}",    
34.                           "pid": "${PID:-}",    
35.                           "thread": "%thread",    
36.                           "class": "%logger{40}",    
37.                           "rest": "%message"    
38.                         }  
39.                     </pattern>  
40.                 </pattern>  
41.             </providers>  
42.         </encoder>  
43.     </appender>  
44.       
45.     <appender name="dailyRollingFileAppender" class="ch.qos.logback.core.rolling.RollingFileAppender">  
46.       <File>main.log</File>  
47.       <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">  
48.         <FileNamePattern>main.%d{yyyy-MM-dd}.log</FileNamePattern>  
49.         <maxHistory>30</maxHistory>           
50.       </rollingPolicy>  
51.       <encoder>  
52.         <Pattern>%d{HH:mm:ss.SSS} [%thread] %-5level %logger{35} - %msg %n</Pattern>  
53.       </encoder>          
54.        <filter class="ch.qos.logback.classic.filter.ThresholdFilter">  
55.         <level>DEBUG</level>  
56.       </filter>  
57.     </appender>  
58.             
59.     <springProfile name="!production">   
60.         <logger name="com.myfee" level="DEBUG" />  
61.         <logger name="org.springframework.web" level="INFO"/>  
62.         <root level="info">    
63.             <appender-ref ref="stdout" />    
64.             <appender-ref ref="dailyRollingFileAppender" />    
65.             <appender-ref ref="logstash" />   
66.         </root>   
67.     </springProfile>  
68.       
69.     <springProfile name="production">   
70.         <logger name="com.myfee" level="DEBUG" />  
71.         <logger name="org.springframework.web" level="INFO"/>  
72.         <root level="info">    
73.             <appender-ref ref="stdout" />    
74.             <appender-ref ref="dailyRollingFileAppender" />   
75.             <appender-ref ref="logstash" />    
76.         </root>   
77.     </springProfile>  
78. </configuration>  

 我们把message信息配置到了rest字段中。

 三、查询日志

启动服务注册中心，网关，需要的微服务，以及sleuth

启动elasticsearch，head，kibana，logstash

 随便运行一个服务，比如

这里会输出一行日志，内容为myService-provider userController

             通过网关调用

    

              eclipse控制台输出日志

 

  在kibana中搜索日志

我们看到日志信息在rest字段中。另外，通过trace和span还可以跟踪到整个微服务的调用过程

 到此为止，整个日志采集就搭建完成了。系统上线后只需要在elasticsearch中就能搜索到各个服务器上，各个微服务的日志