zuul+springboot+db+elk实现访问日志低延迟保存及可视化分析

最新推荐文章于 2022-11-07 16:55:27 发布
最新推荐文章于 2022-11-07 16:55:27 发布
阅读量1k 收藏
点赞数 1
文章标签： java elasticsearch kibana spring boot
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/kkwang1199/article/details/115841980
版权

做java的，一般小项目都是使用logback配置控制台、文件等对日志进行记录和持久化，但是随着微服务架构的越来越流行，各种微服务模块越来越多，节点也越来越多，线上日志的排查和访问统计也跟着变的更复杂和不便。

于是想着研究有什么更好的架构方案，网上找了一圈，质量参差不齐，但得到一个结论是，用elk(即elastic+logstash+kibana)是现在比较流行的方法。研究了一下，觉得应该不错，于是便着手开搞。

先介绍一下以前的流程，由于本文主要介绍api接口访问日志的保存和分析，故后台的系统日志就不做介绍了。

老版访问日志处理流程

上面这张图介绍的是老版本的流程，该系统是众多微服务之一，并且未架设网关。主要有几个问题：

1.未做限流处理，可能导致redis崩掉
2.及时性不够高，因为定时任务间隔较短
3.可能导致db cpu100%，因为db只有一个节点，所有读写、后台的操作都在此上进行
4.扩展性不好，此时如果需要记录别的微服务，得再来一遍
5.每新增一个新的维度数据分析统计，需要前后端配合开发进行可视化，效率低

为了解决上述问题，尝试了几种方案。

方案1：

logback配置直接输出到logstash，再通过logstash输出到es，再通过kibana展示。然后由于日志需要长期保存，为免es出现问题(es才用不久，了解不深)，将es中数据再同步到db。

遇到问题：

log.info(RequestModel)这样打日志，RequestModel中的信息会在logstash中单独以一个"message"字段进行保存，这对后面kibana写过滤表达式很难处理。后来采取java代码中"log.info("{} {} {}", request_uri, request_ip, request_param…)"这种日志产生后，仅希望将这些request_*字段输出至logstash，多余的字段不要，可用grok过滤，但一些自定义的字段不太会处理，正则表达式也不怎么会用，最终放弃。(其实是想到了别的方案)

方案2：

既然日志需要保存到db，那么logback配置就改为输出到db，再把数据传到es，再通过kibana展示。

遇到问题：仍然是关于仅保存自定义字段的需求，网上了解了一圈，默认是要3张表，肯定不是我要的；还有用继承重写的，但看起来仍然没有达到我的要求。并且还有一个连接池的问题没有解决，就也没有研究下去。

方案3：

既然日志需要自定义字段，这些中间件我又用不溜，那就自己处理吧。获取到请求信息以后，手动持久化到db，再把数据传到es，再通过kibana展示。

经过一番折腾，最终成功实现了方案3。

也介绍一下新的架构：
新版访问日志处理流程

改造关键点如下：

1.最前端架设了一道网关，所有的请求都通过网关进行转发，这样在网关层，就能统一实现限流、鉴权、熔断等，当然包括本文讲的日志。
2.日志获取处理完成后，在中间加一道阻塞式队列，用以保存日志和缓冲，要注意线程有关的配置和同步。
3.db脱离主业务db，专门另开一个db用以保存，且日志表不带任何索引(除主键)。

下面上主要的代码：

基础过滤类

package com.suitwin.gateway.zuul;
import java.util.ArrayList;
import java.util.List;
import com.netflix.zuul.ZuulFilter;
/**
 * @desc   抽象基础过滤，放置常量，供自定义的两种过滤器集成共用
 * @auth   kerry.wang
 * @date   2021年4月18日
 */
public abstract class ZuulFilterBase extends ZuulFilter {
	protected static final String KEY_BEFOREFILTERRESPONSE = "beforeFilterResponse";
	protected static final String KEY_REQS = "reqs";
	protected static final String UTF8 = "UTF-8";
	protected static final String CONTENTTYPE = "Content-type";
	protected static final String APPLICATIONJSON = "application/json;charset=utf-8";
	
	// 需要过滤做日志的微服务名称列表
	protected final static List<String> SERVICELIST = new ArrayList<String>(7) {
		private static final long serialVersionUID = -1153328974427768155L;
	{
		add("suitwin-epcv31");
		add("suitwin-epc");
		add("suitwin-amc");
		add("suitwin-bmc");
		add("suitwin-dmc");
		add("suitwin-mms");
		add("suitwin-trace");
	}};
}

网关转发的预过滤

package com.suitwin.gateway.zuul;
import java.io.IOException;
import javax.annotation.Resource;
import javax.servlet.http.HttpServletRequest;
import org.springframework.cloud.netflix.zuul.filters.support.FilterConstants;
import org.springframework.stereotype.Component;
import com.netflix.zuul.context.RequestContext;
import com.netflix.zuul.exception.ZuulException;
import com.suitwin.common.constant.ConstResponse;
import com.suitwin.common.util.RedisUtil;
import com.suitwin.common.util.StringUtil;
import com.suitwin.gateway.util.JwtUtil;
/**
 * @desc   自定义网关过滤器，转发前的过滤
 * @auth   kerry.wang
 * @date   2019年8月8日
 */
@Component
public class ZuulFiltersBefore extends ZuulFilterBase {
	@Resource(name="gatewayJwt")
	private JwtUtil jwt;
	
	@Override
	public boolean shouldFilter() {
		return true;// 设置开启过滤
	}
	/**
	 * 这里做令牌验证
	 */
	@Override
	public Object run() throws ZuulException {
		RequestContext ctx = RequestContext.getCurrentContext();
		
		// 保存请求的时间戳
		ctx.set(KEY_REQS, System.currentTimeMillis());
		
		// 如果需要令牌，拦截并校验
		if(tokenRequired(ctx)) {
			if(validToken(ctx)) {
				ctx.setSendZuulResponse(true);
			}
		}else {
			ctx.setSendZuulResponse(true);
		}
		
		return null;
	}
	
	@Override
	public String filterType() {
		return FilterConstants.PRE_TYPE;// 代表在路由转发之前进行过滤
	}
	@Override
	public int filterOrder() {	
		return 0;// 值越小，优先级越高
	}
	
	/**
	 * @desc   验证uri是否需要令牌校验
	 * @auth   kerry.wang
	 * @date   2021年4月9日
	 * @param  request_uri
	 * @return
	 */
	private boolean tokenRequired(RequestContext ctx) {
		String request_uri = ctx.getRequest().getRequestURI();
		for(String ignoreUri : ExcludePath.excludePathList) {
			if(request_uri.startsWith(ignoreUri) || request_uri.endsWith(ignoreUri)) {
				return false;
			}
		}
		return true;
	}
	/**
	 * @desc   验证令牌
	 * @auth   kerry.wang
	 * @date   2021年4月9日
	 * @param  request
	 */
	private boolean validToken(RequestContext ctx) {
		HttpServletRequest request = ctx.getRequest();
		String token = request.getHeader("token");
		String requestUri = request.getRequestURI();
		// token为空
        if (StringUtil.isEmpty(token)) {
        	return interceptRouter(ctx, ConstResponse.TOKEN_EMPTY.code(), ConstResponse.TOKEN_EMPTY.des(), requestUri);
        }
        // token过期
        String currentUser = RedisUtil.get(token);
        if (StringUtil.isEmpty(currentUser)) {
            return interceptRouter(ctx, ConstResponse.TOKEN_EXPIRED.code(), ConstResponse.TOKEN_EXPIRED.des(), requestUri);
        }
        String username = JwtUtil.getUsername(token);
        Integer companyID = JwtUtil.getCompanyID(token);
        
        // 验证令牌是否有效
        boolean verifyToken = companyID == null ? jwt.verify(token, username) : jwt.verify(token, username, companyID);
        if (!verifyToken) {
            return interceptRouter(ctx, ConstResponse.TOKEN_INVALID.code(), ConstResponse.TOKEN_INVALID.des(), requestUri);
        }
        
        if(StringUtil.notEmpty(username)) {
        	ctx.set("username", username);// 保存请求的用户
        }
        if(companyID != null) {
        	ctx.set("companyID", companyID);// 保存请求的公司
        }
		
		String requestFrom = JwtUtil.getPlatform(token);
		if(StringUtil.notEmpty(requestFrom)) {
			ctx.set("requestFrom", requestFrom);
		}
        return true;
	}
	
	/**
	 * @desc   拦截路由
	 * @auth   kerry.wang
	 * @date   2021年4月9日
	 * @param  ctx
	 * @param  code
	 * @param  msg
	 * @param  requestUri
	 */
	private boolean interceptRouter(RequestContext ctx, int code, String msg, String requestUri) {
		String respJson = "{\"code\":" + code + ", \"msg\":\"" + requestUri + " => " + msg + "\", \"data\":null}";
		// 在转发前被截断，做好标记，这样在转发后的拦截器中，就不再设置响应数据
		ctx.set(KEY_BEFOREFILTERRESPONSE, respJson);
		// 设置是否对请求进行路由
		ctx.setSendZuulResponse(false);
		ctx.setResponseStatusCode(200);
		try {
			ctx.getResponse().addHeader(CONTENTTYPE, APPLICATIONJSON);
			ctx.getResponse().getWriter().write(respJson);
		} catch (IOException e) {
			e.printStackTrace();
		}
		return false;
	}
	
	
}

网关转发响应后的过滤

package com.suitwin.gateway.zuul;
import java.io.IOException;
import java.io.InputStream;
import java.nio.charset.Charset;
import javax.annotation.Resource;
import javax.servlet.http.HttpServletRequest;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.cloud.netflix.zuul.filters.Route;
import org.springframework.cloud.netflix.zuul.filters.RouteLocator;
import org.springframework.cloud.netflix.zuul.filters.support.FilterConstants;
import org.springframework.stereotype.Component;
import org.springframework.util.StreamUtils;
import com.netflix.zuul.context.RequestContext;
import com.netflix.zuul.exception.ZuulException;
import com.suitwin.common.util.IPUtil;
import com.suitwin.common.util.StringUtil;
import com.suitwin.common.util.TimeUtil;
import com.suitwin.gateway.model.AccessLog;
import com.suitwin.gateway.service.ILogService;
/**
 * @desc   网关过滤器，获取转发后的响应之前的过滤
 * @auth   kerry.wang
 * @date   2021年4月13日
 */
@Component
public class ZuulFiltersAfter extends ZuulFilterBase {
	@Autowired
	private RouteLocator routeLocator;
	@Resource(name="dblog")
	private ILogService dbLog;
	
	@Override
	public boolean shouldFilter() {
		return true;// 设置开启过滤
	}
	
	@Override
	public Object run() throws ZuulException {
		// 获取转发请求后的响应数据
		RequestContext ctx = RequestContext.getCurrentContext();
		InputStream stream = ctx.getResponseDataStream();
		String body = null;
		try {
			body = StreamUtils.copyToString(stream, Charset.forName(UTF8));
		} catch (IOException e) {
			e.printStackTrace();
		}
		
		AccessLog accessLog = parseRequestInfo(ctx);
		
		if(accessLog != null) {
			// 是否已被ZuulFiltersBefore拦截并处理响应
			boolean hasInterceptedByBeforeFilter = ctx.containsKey(KEY_BEFOREFILTERRESPONSE);
			
			// 异步记录访问日志到logstash
//			logstashLog.doLog(log, body);
			// 异步塞入log队列
			dbLog.doLog(accessLog, hasInterceptedByBeforeFilter ? String.valueOf(ctx.get(KEY_BEFOREFILTERRESPONSE)) : body);
			
			// 通过前面转发前的拦截，对ctx是否配置了sendZuulResponse判断是否令牌验证正常。如果这里不加这段处理，ctx.setResponseBody将出错，response.getWriter has called... 
			if(hasInterceptedByBeforeFilter) {
				return null;
			}
		}
		
		// 将转发后的响应set回网关对请求的响应，不set的话，本次请求将没有任何相应数据
		ctx.setResponseBody(body);
		return null;
	}
	@Override
	public String filterType() {
		return FilterConstants.POST_TYPE;// 代表在路由转发并响应后进行过滤
	}
	@Override
	public int filterOrder() {
		return 0;
	}
	
	/**
	 * @desc   解析请求信息获得请求日志
	 * @auth   kerry.wang
	 * @date   2021年4月12日
	 * @param  ctx
	 * @return
	 */
	private AccessLog parseRequestInfo(RequestContext ctx) {
		HttpServletRequest req = ctx.getRequest();
		// 获取转发到的微服务名称
		Route route = routeLocator.getMatchingRoute(req.getRequestURI());
		if(!doFilter(route.getLocation())) {
			return null;
		}
		
		// ip位置信息
		String ip = IPUtil.getIpAddr(req);
		String country = "", province = "", city = "";
		if(StringUtil.notEmpty(ip)) {
			String ipInfo = IPUtil.getIpInfo(ip);
			if(StringUtil.notEmpty(ipInfo) && ipInfo.contains("|")) {
				// 中国|0|江苏|无锡|电信
				country = ipInfo.split("\\|")[0];
				province = ipInfo.split("\\|")[2];
				city = ipInfo.split("\\|")[3];
			}
		}
		// 请求耗时
		Long requestCost = System.currentTimeMillis() - Long.valueOf(String.valueOf(ctx.get(KEY_REQS)));
		
		AccessLog accessLog = new AccessLog();
		accessLog.setRequestUri(req.getRequestURI());
		accessLog.setRequestUrl(req.getRequestURL().toString());
		accessLog.setRequestIp(ip);
		accessLog.setRequestCountry(country);
		accessLog.setRequestProvince(province);
		accessLog.setRequestCity(city);
		accessLog.setRequestType(req.getMethod());
		accessLog.setRequestTime(TimeUtil.getCurrentDatetime_safety());
		accessLog.setRequestCost(requestCost);
		accessLog.setRequestService(route.getLocation());
		
		// 获取请求体参数
		try {
			InputStream in = req.getInputStream();
			String reqbody = StreamUtils.copyToString(in, Charset.forName(UTF8));
			if(StringUtil.notEmpty(reqbody)) {
				accessLog.setRequestParamBoby(reqbody);
			}
		}catch (Exception e) {
			e.printStackTrace();
		}
		
		// 获取请求url上的参数
		String queryString = req.getQueryString();
		if(StringUtil.notEmpty(queryString)) {
			accessLog.setRequestParamQuery(queryString);
		}
			
		if(ctx.containsKey("username")) {
			accessLog.setRequestUser(String.valueOf(ctx.get("username")));
		}
		if(ctx.containsKey("companyID")) {
			accessLog.setRequestCompany(String.valueOf(ctx.get("companyID")));
		}
		if(ctx.containsKey("requestFrom")) {
			accessLog.setRequestFrom(String.valueOf(ctx.get("requestFrom")));
		}
		return accessLog;
	}
	
	/**
	 * @desc   判断是否是需要过滤的微服务
	 * @auth   kerry.wang
	 * @date   2021年4月16日
	 * @param  service
	 * @return
	 */
	private boolean doFilter(String service) {
		return SERVICELIST.contains(service);
	}
	
}

日志业务处理保存

package com.suitwin.gateway.log;
import org.springframework.scheduling.annotation.Async;
import org.springframework.stereotype.Component;
import com.alibaba.fastjson.JSONObject;
import com.suitwin.common.util.StringUtil;
import com.suitwin.gateway.model.AccessLog;
import com.suitwin.gateway.service.ILogService;
import lombok.extern.slf4j.Slf4j;
@Component("dblog")
@Slf4j
public class DBLog implements ILogService {
	@Async("logExecutor")
	@Override
	public void doLog(AccessLog accessLog, String responseJson) {
		accessLog = convertRequestCompanyInfo(accessLog);
		accessLog = parseResponseInfo(accessLog, responseJson);
		try {
			LogTask.LOGQUEUE.put(accessLog);
		} catch (InterruptedException e) {
			log.error("===>>> logqueue put failed, " + e.getMessage());
		}
	}
	
	/**
	 * @desc   将请求中保存的公司id转换为公司名称
	 * @auth   kerry.wang
	 * @date   2021年4月13日
	 * @param  accessLog
	 * @return
	 */
	private AccessLog convertRequestCompanyInfo(AccessLog accessLog) {
		if(StringUtil.notEmpty(accessLog.getRequestUser())) {
			
		}
		if(StringUtil.notEmpty(accessLog.getRequestCompany())) {
			// 从db中根据公司id读取出公司名
//			accessLog.setRequestCompany(requestCompany);
			// 读取出公司所属行业
//			accessLog.setRequestUserIndustry(requestUserIndustry);
		}
		return accessLog;
	}
	/**
	 * @desc   解析响应信息
	 * @auth   kerry.wang
	 * @date   2021年4月13日
	 * @param  accessLog
	 * @param  responseJson
	 * @return
	 */
	private AccessLog parseResponseInfo(AccessLog accessLog, String responseJson) {
		if(StringUtil.notEmpty(responseJson)) {
			JSONObject jo = JSONObject.parseObject(responseJson);
			Integer requestResultcode = jo.getInteger("code");
			accessLog.setRequestResultcode(requestResultcode);
			if(requestResultcode == 100) {
				// 对vin、点选、oe搜索和零件关键词搜索接口做拦截，提取出其中的车辆有关信息
				String uri = accessLog.getRequestUri();
				
				if(uri.contains("parseVin/v")) {
					jo = JSONObject.parseObject(jo.getString("data"));
					accessLog.setRequestBrand(jo.getString("brand"));
					accessLog.setRequestFactory(jo.getString("factory"));
					accessLog.setRequestSeries(jo.getString("series"));
				}
				
				else if(uri.contains("getEpcModel/v")) {
					
				}
				
				else if(uri.contains("searchOe/v")) {
					
				}
				
				else if(uri.contains("xxxxx")) {
					
				}
			}
		}
		return accessLog;
		
		
		// 记点，存入nosql
	}
	
}

log持久化任务

package com.suitwin.gateway.log;
import java.util.List;
import java.util.Timer;
import java.util.TimerTask;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.CopyOnWriteArrayList;
import java.util.concurrent.LinkedBlockingQueue;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import com.suitwin.gateway.dao2.LogDao;
import com.suitwin.gateway.model.AccessLog;
import lombok.extern.slf4j.Slf4j;
@Component
@Slf4j
public class LogTask {
	private LogTask() {};
	// log队列
	public static BlockingQueue<AccessLog> LOGQUEUE = new LinkedBlockingQueue<AccessLog>(5000);
	// 待插入log集合
	private volatile List<AccessLog> LOGLIST = new CopyOnWriteArrayList<AccessLog>();
	@Autowired
	private LogDao logDao;
	// 最后一次日志插入时间
	private long lastLogTimeMillions = 0;
	// 定时任务间隔时间
	private final static int CHECKINTEVAL = 5 * 1000;
	// 空闲时间
	private final static int FREETIME = 30 * 1000;
	// 批量插入大小
	private final static int BATCHSIZE = 1000;
	
	/**
	 * @desc   创建日志队列的拉取任务，并生成检测器，单线程
	 * @auth   kerry.wang
	 * @date   2021年4月16日
	 */
	public void createLogJob() {
		checkQueue();
		log.info("===>>> Log job started...");
		while(true) {
			while(!LOGQUEUE.isEmpty()) {
				log.debug("===>>> detect queue logs, start to poll...");
				synchronized (LOGLIST) {
					LOGLIST.add(LOGQUEUE.poll());
					if(LOGLIST.size() > BATCHSIZE) {
						int rs = logDao.insertAccessLogBatch(LOGLIST);
						lastLogTimeMillions = System.currentTimeMillis();
						LOGLIST.clear();
						log.debug("===>>> createLogJob 批量插入了 " + rs);
					}
				}
			}
		}
	}
	
	/**
	 * @desc   任务队列空闲检查，5s检查一次，空闲超过5秒，将剩余待插入log集合写入db
	 * @auth   kerry.wang
	 * @date   2021年4月16日
	 */
	private void checkQueue() {
		log.info("===>>> Queue check timer started...");
		new Timer() {{
        	schedule(new TimerTask() {
        		@Override
        		public void run() {
        			log.debug("===>>> queue checking...");
        			// 如果日志插入线程空闲大于5s，则将队列中的剩余日志批量插入db
        			if(System.currentTimeMillis() - lastLogTimeMillions > FREETIME) {
        				// LOGLIST还要加一道锁，避免和Log job产生差异
        				synchronized (LOGLIST) {
        					if(!LOGLIST.isEmpty()) {
        						log.debug("===>>> detect remain logs, start to write...");
        						int rs = logDao.insertAccessLogBatch(LOGLIST);
        						LOGLIST.clear();
        						log.debug("===>>> checkQueue 批量插入了 " + rs);
        					}
        				}
        			}
        		}
        	}, 0, CHECKINTEVAL);
        }};
	}
	
}

塞入日志队列的异步线程池配置

package com.suitwin.gateway.config;
import java.util.concurrent.ThreadPoolExecutor.CallerRunsPolicy;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;
/**
 * @desc   配置spring boot @async异步注解的线程池
 * @auth   kerry.wang
 * @date   2021年1月22日
 * spring boot 2.0默认线程池每开启一个新的任务都是新开一个线程的。2.2默认线程池有8个
 */
@Configuration
public class AsyncConfig {
	/**
	 * @desc   为同步日志到队列创建最大16线程处理池
	 * @auth   kerry.wang
	 * @date   2021年1月22日
	 * @return
	 */
	@Bean(name = "logExecutor")
    public ThreadPoolTaskExecutor asyncExecutor() {
        ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
        // 核心线程数
        executor.setCorePoolSize(8);
        // 线程池维护线程的最大数量,只有在缓冲队列满了之后才会申请超过核心线程数的线程
        executor.setMaxPoolSize(16);
        // 队列最大长度
        executor.setQueueCapacity(5000);
        // 允许的空闲时间,当超过了核心线程数之外的线程在空闲时间到达之后会被销毁
        executor.setKeepAliveSeconds(100);
        // 线程前缀
        executor.setThreadNamePrefix("logExecutorThread-");
        // 这里使用第4种，保证一旦出现超过并发的上限时，依旧能够再次重试，否则会导致最终业务逻辑或数据不达预期
        executor.setRejectedExecutionHandler(new CallerRunsPolicy());
        executor.initialize();
        return executor;
    }
	
}

启动类

package com.suitwin.gateway;
import java.util.ArrayList;
import java.util.List;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.CommandLineRunner;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.autoconfigure.jdbc.DataSourceAutoConfiguration;
import org.springframework.cloud.client.discovery.EnableDiscoveryClient;
import org.springframework.cloud.netflix.zuul.EnableZuulProxy;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.scheduling.annotation.EnableAsync;
import org.springframework.web.cors.CorsConfiguration;
import org.springframework.web.cors.UrlBasedCorsConfigurationSource;
import org.springframework.web.filter.CorsFilter;
import com.suitwin.gateway.log.LogTask;
@EnableZuulProxy
//@SpringBootApplication// (exclude= {DruidDataSourceAutoConfigure.class, DataSourceAutoConfiguration.class, DataSourceTransactionManagerAutoConfiguration.class})
@SpringBootApplication(exclude= {DataSourceAutoConfiguration.class})
@EnableDiscoveryClient
@ComponentScan(basePackages = {"com.suitwin.common", "com.suitwin.gateway"})
@EnableAsync
public class SuitwinGatewayApplication implements CommandLineRunner {
	@Autowired
	private LogTask task;
	
	public static void main(String[] args) {
		SpringApplication.run(SuitwinGatewayApplication.class, args);
	}
	
    @Bean
    public CorsFilter corsFilter() {
        UrlBasedCorsConfigurationSource source = new UrlBasedCorsConfigurationSource();
        source.registerCorsConfiguration("/**", addcorsConfig());
        return new CorsFilter(source);
    }
	
    private CorsConfiguration addcorsConfig() {
        CorsConfiguration corsConfiguration = new CorsConfiguration();
        List<String> list = new ArrayList<>();
        list.add("*");
        corsConfiguration.setAllowedOrigins(list);
        corsConfiguration.addAllowedOrigin("*");
        corsConfiguration.addAllowedHeader("*");
        corsConfiguration.addAllowedMethod("*");
        corsConfiguration.setMaxAge(168000l);
        corsConfiguration.setAllowCredentials(true);
        return corsConfiguration;
    }
	@Override
	public void run(String... args) throws Exception {
		System.err.println("===>>> Suitwin gateway started..."  +Thread.currentThread().getName());
		task.createLogJob();
	}
}

下面是logstash的关键配置：

input {
	jdbc {
		jdbc_connection_string => "jdbc:mysql://192.168.0.234:3307/epc_cache?useUnicode=true&characterEncoding=UTF-8"
		jdbc_driver_library => "D:/mysql-connector-java-5.1.35.jar"
		jdbc_driver_class => "com.mysql.jdbc.Driver"
		jdbc_user => "root"
		jdbc_password => "root"
		schedule => "* * * * *"
		statement => "SELECT * FROM epc_cache.stw_gateway_log WHERE id > :sql_last_value"
		use_column_value => true
		tracking_column => "id"
		last_run_metadata_path => "D:/logstash_log.txt"
		clean_run => false
	}
}
output {
	elasticsearch {
		hosts => ["http://192.168.0.234:9200"]
		index => "suitwin-gateway-log"
		document_type => "weblog"
		document_id => "%{id}"
	}
	stdout {
		codec => json_lines
	}
}

以上一套下来，启动spring boot、logstash、es、mysql，即可实现日志保存到mysql和es

最后数据可视化：

打开kibana，先通过创建索引，实现目标日志表的基础查看
基础日志查看

如果想要通过kibana实现后台日志的查看(而非登录服务器查看日志文件)，选用上面介绍过的方案1即可，很方便。

ok，此时要进行分析了，可以通过filter过滤器，输入表达式，即可得到想要的结果，例如图中筛选了返回响应代码为106的日志。

那么如何构建图表，此时需要通过Visualize菜单进行创建。
可视化后的效果

上图展示了访问日志中，请求的汽车品牌的饼图统计。

ok，那么最终的各种树状图、折线图、饼图、热力图等等大屏数据展示如何完成？通过dashboard菜单。
仪表板效果

通过添加上一步创建的Visualize组件(需要保存)，即可将一个个单独的图表聚合到一个仪表板中进行显示，并且可以任意调节组件大小。

到此为止，整个流程就ok了，将其中的细节打磨一下，就能实现系统的所有日志处理，最终无需技术人员的介入，即可轻松完成平台访问情况的检测、统计、分析、可视化！

本方案的不足之处还请不吝赐教 – 来自一个什么都不会搞的产品经理

kkwang1199
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
微服务架构实战第九节 微服务可视化监控和链路追踪
fegus的博客
05-24 1377
29 监控原理：如何理解服务监控和 Spring Cloud Sleuth 的基本原理？ 从本课时开始，我们将讨论一个在微服务架构中非常重要的话题，即服务监控。今天我们将简要分析服务监控的基本原理，这是理解服务监控相关工具和框架的基础。同时，作为 Spring Cloud 中用于实现服务监控的专用工具，Spring Cloud Sleuth 为实现这些基本原理提供了完整而强大的解决方案。 服务监控基本原理 在微服务架构中，我们基于业务划分服务并对外暴露服务访问接口。试想这样一个场景，如果我们发现某一个业务
Zuul网关的请求与响应日志打印、服务回退和异常处理
hanxiaozhang的博客
09-26 5488
前言： Zuul是在SpringCloud微服务框架中经常使用网关组件，它提供了认证、鉴权、限流、动态路由、监控、弹性、安全、负载均衡等功能，平时我们在项目中经常Zuul路由、鉴权、监控、负载均衡等功能。我们今天就详细介绍一下请求与响应日志打印、服务回退和异常处理这个三个功能的配置方法。 一、请求与响应日志打印： 请求与响应日志打印主要是基于Zuul的filter过滤器实现的。Zuul一共有五种类型的filter过滤器，它们分别是：PRE（在请求被路由之前调用）、ROUTING（将请求路由到微服务）、
spring zuul的日志配置
dream8062的专栏
03-10 1万+
设置 zuul.debug.request=true  #如果设置了这个，默认所有的请求都会debug zuul.include-debug-header: true 未设置zuul.debug.request=true，可以 用zuul_host:zuul_port/路径?debug=true    debug你的指定请求  logging:       level:
elk消费kafka数据延迟过大的问题
fct2001140269的博客
01-29 4382
elk消费kafka数据延迟过大的问题 1.问题现象表述： 当前elk作为日志系统消费kafka日志数据有很大的延迟，即elk的消费kafka中日志的速度（200条/s）远 远低于maplearning生产日志的速度（平均3000条/s）（吐出的日志topic：log_trialproducetion）； 导致从kibana中查询最新的es日志数据的时间远远低于当前时间，在实际生产环境或【预上线】...
docker-compose观察实时日志_一次ELK日志延迟的排查
weixin_39894104的博客
11-28 284
现有架构：filebeat ==》 kafka ==》logstash ==》 es ==》 kibana环境描述：filebeat运行系统版本：CentOS Linux release 7.5.1804 (Core)filebeat版本：filebeat-5.6.3-x86_64.rpmkafka版本：0.8.2.1（kafka_2.10-0.8.2.1）filebeat宿主机配置：8C16G延...
SpringBoot + Zuul + ribbon 中实现负载均衡
04-07
而为了构建微服务架构，Spring Cloud提供了众多工具，如Zuul和Ribbon，它们可以帮助我们实现服务的路由和负载均衡。本文将深入探讨如何在Spring Boot项目中结合Zuul和Ribbon来实现这一功能。 首先，Zuul是Spring ...
springboot2.0 +zuul gateway + eureka + feign 整合
07-24
在本项目中，我们探索的是一个基于Spring Boot 2.0的微服务架构，其中集成了Zuul Gateway、Eureka服务发现以及Feign客户端调用。这是一个完整的微服务生态系统，旨在实现高效、可靠的分布式系统通信。让我们逐一深入...
springboot-zuul-session-redis:springboot+zuul实现session共享
05-08
springboot-zuul-session-redisspringboot+zuul实现session共享1、说明springsession+redis+springboot使用上一个repository就可以了。我们这里关注zuul的配置。2、zuul的默认配置，引入zuul的依赖,同时引入spring...
Spring Cloud+Spring Boot+Git&GitHub;+Spring in action+SpringBoot
09-03
本资源包涵盖了Spring Cloud、Spring Boot、版本控制工具Git及代码托管平台GitHub，以及Spring框架的经典书籍《Spring in Action》的相关内容，旨在帮助开发者深入理解和应用这些技术。 1. **Spring Boot**: Spring...
基于Vue+Springboot+Springcloud的博客项目.zip
最新发布
04-09
标题 "基于Vue+Springboot+Springcloud的博客项目.zip" 描述了一个综合性的现代Web应用程序开发项目，其中融合了前端的Vue.js框架、后端的Spring Boot微服务架构以及Spring Cloud的分布式系统管理。让我们详细了解...
Spring Cloud Zuul动态路由demo
09-21
基于Spring Cloud Zuul的动态路由实现demo，实现动态配置，实时刷新
26.ELK.针对‘ES中索引创建迟缓’问题优化
JCWang的博客
11-07 970
消息批次等待时间，当消息批次大小一直未达到默认的消息批次大小，在等待该时长后将消息发出。当存储超过95％的磁盘中的节点上分配了一个或多个分片的任何索引，该索引将被强制进入只读模式。如果你的架构中使用kafka消息队列系统作为缓存，也可以针对kafka进行优化。默认的消息批次大小，不要设置太大，会导致消息需要等很久才被发出，增加网络延时。增加服务器用于处理请求的线程数，其中可能包括磁盘I/O。生产者可以用来缓冲等待发送到服务器的消息的总内存字节数。在设置时，要考虑到系统与其他进程，保留一定的内存给他们。
ELK 性能优化实践
方志朋的博客
01-17 348
点击上方蓝色“方志朋”，选择“设为星标”回复“666”获取独家整理的学习资料！一、背景介绍近一年内对公司的 ELK 日志系统做过性能优化，也对 SkyWalking 使用的 ES 存储进行...
springcloud----Zuul动态路由
热门推荐
徐靖峰的专栏
04-01 6万+
前言Zuul 是Netflix 提供的一个开源组件,致力于在云平台上提供动态路由，监控，弹性，安全等边缘服务的框架。也有很多公司使用它来作为网关的重要组成部分，碰巧今年公司的架构组决定自研一个网关产品，集动态路由，动态权限，限流配额等功能为一体，为其他部门的项目提供统一的外网调用管理，最终形成产品(这方面阿里其实已经有成熟的网关产品了，但是不太适用于个性化的配置，也没有集成权限和限流降级)。不过这里
全新一代API网关，带可视化管理，文档贼友好！
Java_cola的博客
07-19 581
摘要 提到API网关，大家比较熟悉的有Spring Cloud体系中的Gateway和Zuul，这些网关在使用的时候基本都要修改配置文件或自己开发功能。今天给大家介绍一款功能强大的API网关apisix，自带可视化管理功能，多达三十种插件支持，希望对大家有所帮助！ 简介 apisix是一款云原生微服务API网关，可以为API提供终极性能、安全性、开源和可扩展的平台。apisix基于Nginx和etcd实现，与传统API网关相比，apisix具有动态路由和插件热加载，特别适合微服务系统下的API管理。 核.
Zuul&&Kong
Chaos Awakening
06-11 5140
网关(API Gateway )原由 之前学习分布式网站设计的时候，我们知道挡当应用体量提升的同时，我们的业务应用会逐步走向服务化，这样的架构适合大多数公司的演变，微服务的架构下，势必增加了op的工作量，每次新增一种服务，op就需要配置一套slb，还有原来的哪一套连接基础组件数据库缓存的机器ip白名单等，这些重复工作他需要反复维护，同事还需要维护一套slb机器和各个服务的对应关系，用来工作交接之类...
Spring Cloud Zuul网关 Filter、熔断、重试、高可用的使用方式。
weixin_33704591的博客
01-31 1939
时间过的很快，写springcloud(十)：服务网关zuul初级篇还在半年前，现在已经是2018年了，我们继续探讨Zuul更高级的使用方式。 上篇文章主要介绍了Zuul网关使用模式，以及自动转发机制，但其实Zuul还有更多的应用场景，比如：鉴权、流量转发、请求统计等等，这些功能都可以使用Zuul来实现。 Zuul的核心 Filter是Zuul的核心，用来实现对外服务的控制。Filter的生命周期...
学习微服务网关zuul，看这篇就够了
CSDN业界要闻
02-10 1550
戳蓝字“CSDN云计算”关注我们哦！作者：爱撒谎的男孩 原文：https://chenjiabing666.github.io/2018/12/25/zuul%E6%9C...
springboot+zuul
09-19
springboot zuul是一个基于Spring Cloud的网关服务，它可以将所有的请求转发到后端的不同微服务，实现了请求的路由、负载均衡、过滤、熔断等功能。 要使用springboot zuul，需要进行以下步骤： 1. 引入spring-cloud...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值