elk+kafka实现分布式日志收集

背景：在传统项目中，如果在生产环境中，有多台不同的服务器集群，如果生产环境需要通过日志定位项目的Bug的话，需要在每台节点上使用传统的命令方式查询，这样效率非常低下。

原理：使用SpringAop进行日志收集，然后通过kafka将日志发送给logstash，logstash再将日志写入elasticsearch，这样elasticsearch就有了日志数据了，最后，则使用kibana将存放在elasticsearch中的日志数据显示出来，并且可以做实时的数据图表分析等等。

1.docker安装kafka

1. 下载kafka镜像：docker pull wurstmeister/kafka
2. 下载Zookeeper镜像：docker pull wurstmeister/zookeeper
3. 先运行Zookeeper：docker run -d --name zookeeper -p 2181:2181 -t wurstmeister/zookeeper
4. 运行Kafka环境`：

docker run --name kafka01 \
-p 9092:9092 \
-e KAFKA_BROKER_ID=0 \
-e KAFKA_ZOOKEEPER_CONNECT=192.168.8.192:2181 \
-e KAFKA_ADVERTISED_LISTENERS=PLAINTEXT://192.168.8.192:9092 \
-e KAFKA_LISTENERS=PLAINTEXT://0.0.0.0:9092 \
-d  wurstmeister/kafka 

5. 运行图形化ui kafka-manager（本文用不到）：

docker run -itd \
--restart=always \
--name=kafka-manager \
-p 9000:9000 \
-e ZK_HOSTS="192.168.8.192:2181" \
sheepkiller/kafka-manager

测试图形化ui有没有启动成功:http://192.168.8.192:9000

2.操作Kafka

1. 进入Kafka容器内：docker exec -it kafka01 /bin/bash
2. 创建主题my_log: /opt/kafka/bin/kafka-topics.sh --create --zookeeper 192.168.8.192:2181 --replication-factor 1 --partitions 1 --topic my_log
3. 查询创建的主题：/opt/kafka/bin/kafka-topics.sh --list --zookeeper 192.168.8.192:2181

3.代码实现
实现流程:

1.新建springcloud-kafka服务
2. 项目使用Aop技术拦截日志信息，封装成json数据，将日志信息投递 my_log 主题中。
3. Logstash 订阅my_log主题 获取日志信息，输出到ES中
4. 自己公司的定时系统，调用ES查询Error异常以邮件方式发送给测试专员，测试人员就能知道生产环境的异常情况。

1.maven引入配置

		<!-- springboot 整合Kafka -->
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter</artifactId>
			<version>2.0.1.RELEASE</version>
		</dependency>
		<dependency>
			<groupId>org.springframework.kafka</groupId>
			<artifactId>spring-kafka</artifactId>
			<version>2.1.5.RELEASE</version>
		</dependency>
		<dependency>
			<groupId>com.alibaba</groupId>
			<artifactId>fastjson</artifactId>
			<version>1.2.47</version>
		</dependency>

2.新建AopLogAspect 切面类

package com.test.elk.aop;

import java.text.SimpleDateFormat;
import java.util.Arrays;
import java.util.Date;

import javax.servlet.http.HttpServletRequest;

import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.annotation.AfterReturning;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.aspectj.lang.annotation.Pointcut;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import org.springframework.web.context.request.RequestContextHolder;
import org.springframework.web.context.request.ServletRequestAttributes;

import com.alibaba.fastjson.JSONObject;
import com.test.elk.kafka.KafkaSender;

@Aspect
@Component
public class AopLogAspect {
	@Autowired
	private KafkaSender<JSONObject> kafkaSender;

	// 申明一个切点 里面是 execution表达式
	@Pointcut("execution(* com.test.*.api.service.impl.*.*(..))")
	private void serviceAspect() {
	}

	// 请求method前打印内容
	@Before(value = "serviceAspect()")
	public void methodBefore(JoinPoint joinPoint) {
		ServletRequestAttributes requestAttributes = (ServletRequestAttributes) RequestContextHolder
				.getRequestAttributes();
		HttpServletRequest request = requestAttributes.getRequest();

		// // 打印请求内容
		// log.info("===============请求内容===============");
		// log.info("请求地址:" + request.getRequestURL().toString());
		// log.info("请求方式:" + request.getMethod());
		// log.info("请求类方法:" + joinPoint.getSignature());
		// log.info("请求类方法参数:" + Arrays.toString(joinPoint.getArgs()));
		// log.info("===============请求内容===============");

		JSONObject jsonObject = new JSONObject();
		SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");// 设置日期格式
		// 请求时间
		jsonObject.put("request_time", df.format(new Date()));
		// 请求URL
		jsonObject.put("request_url", request.getRequestURL().toString());
		// 请求的方法
		jsonObject.put("request_method", request.getMethod());
		// 请求类方法
		jsonObject.put("signature", joinPoint.getSignature());
		// 请求参数
		jsonObject.put("request_args", Arrays.toString(joinPoint.getArgs()));

		// 加上ip和端口号
		JSONObject requestJsonObject = new JSONObject();
		requestJsonObject.put("request", jsonObject);

		kafkaSender.send(requestJsonObject);
	}

	// 在方法执行完结后打印返回内容
	@AfterReturning(returning = "o", pointcut = "serviceAspect()")
	public void methodAfterReturing(Object o) {
		// log.info("--------------返回内容----------------");
		// log.info("Response内容:" + gson.toJson(o));
		// log.info("--------------返回内容----------------");
		JSONObject respJSONObject = new JSONObject();
		JSONObject jsonObject = new JSONObject();
		SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");// 设置日期格式
		jsonObject.put("response_time", df.format(new Date()));
		jsonObject.put("response_content", JSONObject.toJSONString(o));
		respJSONObject.put("response", jsonObject);
		kafkaSender.send(respJSONObject);

	}
}

3.新建KafkaSender

package com.test.elk.kafka;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.kafka.core.KafkaTemplate;
import org.springframework.kafka.support.SendResult;
import org.springframework.stereotype.Component;
import org.springframework.util.concurrent.ListenableFuture;
import org.springframework.util.concurrent.ListenableFutureCallback;

import com.alibaba.fastjson.JSON;

import lombok.extern.slf4j.Slf4j;

@Component
@Slf4j
public class KafkaSender<T> {

	@Autowired
	private KafkaTemplate<String, Object> kafkaTemplate;

	/**
	 * kafka 发送消息
	 *
	 * @param obj
	 *            消息对象
	 */
	public void send(T obj) {
		String jsonObj = JSON.toJSONString(obj);
		log.info("------------ message = {}", jsonObj);
		// 发送消息 实现可配置化 主题是可配置化
		ListenableFuture<SendResult<String, Object>> future = kafkaTemplate.send("my_log", jsonObj);
		future.addCallback(new ListenableFutureCallback<SendResult<String, Object>>() {
			@Override
			public void onFailure(Throwable throwable) {
				log.info("Produce: The message failed to be sent:" + throwable.getMessage());
			}

			@Override
			public void onSuccess(SendResult<String, Object> stringObjectSendResult) {
				// TODO 业务处理
				log.info("Produce: The message was sent successfully:");
				log.info("Produce: _+_+_+_+_+_+_+ result: " + stringObjectSendResult.toString());
			}
		});
	}
}

4.通过logstash从kafka读取数据输出到elasticsearch中

4.1下载logstash：wget https://artifacts.elastic.co/downloads/logstash/logstash-6.2.3.tar.gz

4.2解压：tar -zxvf logstash-6.2.3.tar.gz

4.3新建logstash.conf

input {   
    kafka {
   		 # 注意这里配置的kafka的broker地址不是zk的地址
        bootstrap_servers => ["192.168.8.192:9092"] 
        # 自定义groupid
        group_id => "logstash"
        # kafka topic 名称   
        topics => ["my_log"]  
        consumer_threads => 5 
        decorate_events => true
        codec => "json"
        }
}
output {
  elasticsearch { hosts => ["192.168.8.192:9200"] }
  stdout { codec => rubydebug } 
}

4.4运行logstash： bin/logstash -f logstash.conf

5.订单服务pom文件引入springcloud-kafka依赖

		<!--kafka -->
		<dependency>
			<groupId>com.test</groupId>
			<artifactId>springcloud-kafka</artifactId>
			<version>0.0.1-SNAPSHOT</version>
		</dependency>

至此elk+kafka实现分布式日志收集就大功告成了~~

`