springcloud+sleuth+zipkin+kafka+es

最新推荐文章于 2024-03-13 09:17:21 发布
最新推荐文章于 2024-03-13 09:17:21 发布
阅读量7.8k 收藏 11
点赞数
分类专栏： kafka springcloud zipkin sleuth
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/niemingming/article/details/79002846
版权
springcloud 同时被 3 个专栏收录
5 篇文章 0 订阅
订阅专栏
zipkin
2 篇文章 0 订阅
订阅专栏
sleuth
2 篇文章 0 订阅
订阅专栏

前面已经完成了Springcloud+sleuth+zipkin的入门，以及kafka的安装。至于ES这里就不在说明了，网上安装使用资料挺多的，这里仅仅是将其作为持久化工具使用。

环境说明

  1. jdk1.8 server 64位
  2. intellij IDEA 2017
  3. springboot 1.5.2.RELEASE
  4. Springcloud Dalston.SR5
  5. kafka 2.11-1.0.0
  6. zookeeper 3.4.10
  7. elasticsearch 5.6.4

1、启动环境

  1. 启动zookeeper
  2. 启动kafka
  3. 启动elasticsearch

2、创建zipkinserver

在pom.xml中加入如下内容：

 <dependencies>
        <!--springboot依赖-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <!--加入zipkin依赖-->
        <dependency>
            <groupId>io.zipkin.java</groupId>
            <artifactId>zipkin</artifactId>
            <version>2.4.2</version>
        </dependency>
        <!--引入zipkin的ES存储-->
        <dependency>
            <groupId>io.zipkin.java</groupId>
            <artifactId>zipkin-autoconfigure-storage-elasticsearch-http</artifactId>
            <version>2.4.2</version>
            <optional>true</optional>
        </dependency>
        <!--引入zipkin的流绑定-->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-sleuth-zipkin-stream</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-stream-kafka</artifactId>
        </dependency>
    </dependencies>

同时在resources中创建application.yml

#配置kafka
spring:
  sleuth:
    enabled: false
    sampler:
      percentage: 1.0
  cloud:
    stream:
      kafka:
        binder:
          brokers: localhost:9092
          zkNodes: localhost:2181
  #ES配置
zipkin:
  storage:
    type: elasticsearch
    elasticsearch:
      host: localhost:9200
      cluster: elasticsearch
      index: zipkin
      index-shards: 1
      index-replicas: 1

启动类增加如下注解：

@SpringBootApplication
@EnableZipkinStreamServer//配置可以作为zipkinserver
public class ZipkinServerApplication {

    public static void main(String[] args) {
        SpringApplication.run(ZipkinServerApplication.class,args);
    }
}

启动后可以 在控制台看到kafka的连接信息

3、创建目标服务一

在pom.xml中引入：

<dependencies>
        <!--引入springboot-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <!--引入zipkin绑定-->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-sleuth-zipkin-stream</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-sleuth</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-stream-binder-kafka</artifactId>
        </dependency>
        <!--引入logback日志输出配置，这时由于kafka绑定的是日志事件-->
        <dependency>
            <groupId>net.logstash.logback</groupId>
            <artifactId>logstash-logback-encoder</artifactId>
            <version>4.6</version>
        </dependency>
        <!--引入feign依赖-->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-feign</artifactId>
        </dependency>
    </dependencies>

注意对于日志依赖的引入。
在application.yml中加入如下配置：

server:
  port: 8082
spring:
  application:
    name: serverone
  sleuth:
    sampler:
      percentage: 1.0
  cloud:
    stream:
      kafka:
        binder:
          brokers: localhost:9092
          zkNodes: localhost:2181

创建logback-spring.xml并如下配置：

<?xml version="1.0" encoding="UTF-8"?>
<configuration>
    <include resource="org/springframework/boot/logging/logback/defaults.xml"/>

    <springProperty scope="context" name="springAppName" source="spring.application.name"/>
    <!-- Example for logging into the build folder of your project -->
    <property name="LOG_FILE" value="${BUILD_FOLDER:-build}/${springAppName}"/>

    <property name="CONSOLE_LOG_PATTERN"
              value="%clr(%d{yyyy-MM-dd HH:mm:ss.SSS}){faint} %clr(${LOG_LEVEL_PATTERN:-%5p}) %clr([${springAppName:-},%X{X-B3-TraceId:-},%X{X-B3-SpanId:-},%X{X-Span-Export:-}]){yellow} %clr(${PID:- }){magenta} %clr(---){faint} %clr([%15.15t]){faint} %clr(%-40.40logger{39}){cyan} %clr(:){faint} %m%n${LOG_EXCEPTION_CONVERSION_WORD:-%wEx}"/>

    <!-- Appender to log to console -->
    <appender name="console" class="ch.qos.logback.core.ConsoleAppender">
        <filter class="ch.qos.logback.classic.filter.ThresholdFilter">
            <!-- Minimum logging level to be presented in the console logs-->
            <level>INFO</level>
        </filter>
        <encoder>
            <pattern>${CONSOLE_LOG_PATTERN}</pattern>
            <charset>utf8</charset>
        </encoder>
    </appender>

    <!-- Appender to log to file -->
    <appender name="flatfile" class="ch.qos.logback.core.rolling.RollingFileAppender">
        <file>${LOG_FILE}</file>
        <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
            <fileNamePattern>${LOG_FILE}.%d{yyyy-MM-dd}.gz</fileNamePattern>
            <maxHistory>7</maxHistory>
        </rollingPolicy>
        <encoder>
            <pattern>${CONSOLE_LOG_PATTERN}</pattern>
            <charset>utf8</charset>
        </encoder>
    </appender>

    <!-- Appender to log to file in a JSON format -->
    <appender name="logstash" class="ch.qos.logback.core.rolling.RollingFileAppender">
        <file>${LOG_FILE}.json</file>
        <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
            <fileNamePattern>${LOG_FILE}.json.%d{yyyy-MM-dd}.gz</fileNamePattern>
            <maxHistory>7</maxHistory>
        </rollingPolicy>
        <encoder class="net.logstash.logback.encoder.LoggingEventCompositeJsonEncoder">
            <providers>
                <timestamp>
                    <timeZone>UTC</timeZone>
                </timestamp>
                <pattern>
                    <pattern>
                        {
                        "severity": "%level",
                        "service": "${springAppName:-}",
                        "trace": "%X{X-B3-TraceId:-}",
                        "span": "%X{X-B3-SpanId:-}",
                        "exportable": "%X{X-Span-Export:-}",
                        "pid": "${PID:-}",
                        "thread": "%thread",
                        "class": "%logger{40}",
                        "rest": "%message"
                        }
                    </pattern>
                </pattern>
            </providers>
        </encoder>
    </appender>

    <root level="INFO">
        <!--<appender-ref ref="console"/>-->
        <appender-ref ref="logstash"/>
        <!--<appender-ref ref="flatfile"/>-->
    </root>
</configuration>

在启动类加入如下配置：

@SpringBootApplication
@EnableFeignClients //引入feign支持
@EnableAutoConfiguration //引入自动配置，替代配置文件
public class ServerOneApplication {

    public static void main(String[] args) {
        SpringApplication.run(ServerOneApplication.class,args);
    }
}

创建的restTemplate 配置类为：

@Configuration
public class RestConfiguration {

    @Bean
    public RestTemplate restTemplate(){
        return new RestTemplate();
    }
}

feign的客户端为：

@FeignClient(name = "sleuthone",url = "http://localhost:8888")
public interface SleuthService {
    @RequestMapping("/sayHello/{name}")
    public String sayHello(@PathVariable(name = "name")String name);
}

调用的后台controller为：

@RestController
public class SleuthController {
    @Autowired
    private RestTemplate restTemplate;
    @Autowired
    private SleuthService sleuthService;

    @ResponseBody
    @RequestMapping("/restHello/{name}")
    public String restHello(@PathVariable String name) {
        return "rest " + restTemplate.getForObject("http://localhost:8888/sayHello/" + name,String.class);
    }

    @ResponseBody
    @RequestMapping("/feignHello/{name}")
    public String feignHello(@PathVariable String name) {
        return "feign " + sleuthService.sayHello(name);
    }
}

4、创建目标服务二

服务二与服务一基本相同，不同的地方在于服务二不需要引入feign了，其pom如下：

<dependencies>
        <!--依赖-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <!--引入链路调用信息-->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-sleuth</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-sleuth-zipkin-stream</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-stream-binder-kafka</artifactId>
        </dependency>
        <!--引入logback日志输出配置，这时由于kafka绑定的是日志事件-->
        <dependency>
            <groupId>net.logstash.logback</groupId>
            <artifactId>logstash-logback-encoder</artifactId>
            <version>4.6</version>
        </dependency>
    </dependencies>

其他一致，服务二仅提供一个sayHello服务。

@RestController
public class SleuthController {

    @ResponseBody
    @RequestMapping("/sayHello/{name}")
    public String sayHello(@PathVariable String name) {
        return "hello " + name;
    }
}

验证

分别访问http://localhost:8082/restHello/lisi
http://localhost:8082/feignHello/lisi
正确返回信息后，我们访问es查询数据
http://localhost:9200/zipkin*/_search?pretty
可以看到如下数据:

{
  "took" : 2,
  "timed_out" : false,
  "_shards" : {
    "total" : 2,
    "successful" : 2,
    "skipped" : 0,
    "failed" : 0
  },
  "hits" : {
    "total" : 37,
    "max_score" : 1.0,
    "hits" : [
      {
        "_index" : "zipkin:span-2018-01-08",
        "_type" : "span",
        "_id" : "AWDUsg4wSqtAFWoqJU1h",
        "_score" : 1.0,
        "_source" : {
          "traceId" : "45fc228abc4a4edf",
          "duration" : 4000,
          "shared" : true,
          "localEndpoint" : {
            "serviceName" : "servertwo",
            "ipv4" : "10.130.236.27",
            "port" : 8888 },
          "timestamp_millis" : 1515396926392,
          "kind" : "SERVER",
          "name" : "http:/sayhello/lisi",
          "id" : "d852bf5a65f75acb",
          "parentId" : "45fc228abc4a4edf",
          "timestamp" : 1515396926392000,
          "tags" : {
            "mvc.controller.class" : "SleuthController",
            "mvc.controller.method" : "sayHello",
            "spring.instance_id" : "01C702601479820.corp.haier.com:servertwo:8888" }
        }
      },
      {
        "_index" : "zipkin:span-2018-01-08",
        "_type" : "span",
        "_id" : "AWDUsg8wSqtAFWoqJU1i",
        "_score" : 1.0,
        "_source" : {
          "traceId" : "45fc228abc4a4edf",
          "duration" : 36000,
          "localEndpoint" : {
            "serviceName" : "serverone",
            "ipv4" : "10.130.236.27",
            "port" : 8082 },
          "timestamp_millis" : 1515396926361,
          "kind" : "CLIENT",
          "name" : "http:/sayhello/lisi",
          "id" : "d852bf5a65f75acb",
          "parentId" : "45fc228abc4a4edf",
          "timestamp" : 1515396926361000,
          "tags" : {
            "http.host" : "localhost",
            "http.method" : "GET",
            "http.path" : "/sayHello/lisi",
            "http.url" : "http://localhost:8888/sayHello/lisi",
            "spring.instance_id" : "01C702601479820.corp.haier.com:serverone:8082" }
        }
      },
      {
        "_index" : "zipkin:span-2018-01-08",
        "_type" : "span",
        "_id" : "AWDUsg8wSqtAFWoqJU1j",
        "_score" : 1.0,
        "_source" : {
          "traceId" : "45fc228abc4a4edf",
          "duration" : 56696,
          "localEndpoint" : {
            "serviceName" : "serverone",
            "ipv4" : "10.130.236.27",
            "port" : 8082 },
          "timestamp_millis" : 1515396926355,
          "kind" : "SERVER",
          "name" : "http:/feignhello/lisi",
          "id" : "45fc228abc4a4edf",
          "timestamp" : 1515396926355000,
          "tags" : {
            "mvc.controller.class" : "SleuthController",
            "mvc.controller.method" : "feignHello",
            "spring.instance_id" : "01C702601479820.corp.haier.com:serverone:8082" }
        }
      }
    ]
  }
}

我们需要注意：duration这里的单位是微妙，所以耗时56ms

问题汇总

1、数据没有进入到kafka通道，没有配置日志输出到日志文件，通过对源码分析，我们发现其kafka绑定的是日志事件
2、启动服务时，kafka停机或者不能消费参看上一篇关于kafka不能消费的问题。其实主要原因是jdk版本问题。

源码地址

niemingming
关注
  • 0
    点赞
  • 踩
  • 11
    收藏
    觉得还不错? 一键收藏
  • 17
    评论
专栏目录
(spring-cloud-sleuth-stream+mybatis+rabbit)+(kafka+elasticsearch+zipkin)
06-09
(spring-cloud-sleuth-stream+mybatis+rabbit)+(kafka+elasticsearch+zipkin)
SpringCloud（Finchley）整合sleuth、zipkin、kafka、es
dasnotsad的博客
11-08 4081
SpringCloud（Finchley）整合sleuth、zipkin、kafka、es 由于springcloud的Finchley版本发布以及springboot2.x的版本更新，很多配置都与以前大相径庭，最近需要使用目前最新的版本做一套springcloud的链路追踪功能，到处寻觅配置 你好！ 这是你第一次使用 Markdown编辑器 所展示的欢迎页。如果你想学习如何使用Markdown编...
Spring Boot 中的 Sleuth 详解
最新发布
JAVA领域优质创作者，基于分片网络查询方法专利发明者。
03-13 1230
Spring Boot 中的 Sleuth 是一个用于分布式追踪的库，它可以帮助你追踪和理解分布式系统中的请求如何跨越多个服务和网络调用。通过使用 Sleuth，你可以收集关于请求路径、延迟、异常等的信息，从而更容易地诊断问题并进行性能优化。
SpringCloud第12讲：调用链监控工具Sleuth+Zipkin
分享日常工作技术
01-19 1893
Sleuth是一个SpringCloud的分布式跟踪解决方案 一、术语 Span（跨度）：Sleuth的基本工作单元，他用一个64位的id唯一标识。除ID外，span还包含其他数据，例如：描述、时间戳事件、键值对的注解（标签）、spanID、span父ID等 trace（跟踪）：一组span组成的树状结构称为trace Annotation（标注）： CS(ClientSent客户端发送)：客户端发起一个请求，该annotation描述了span的开始； SR（ServerReceiv...
全链路spring cloud sleuth+zipkin(kafka)
qq_34196952的博客
05-17 4850
一、About ZipKinplease google二、 Demo Scene三、 Result Display四、Prepare1、soft versionkafka：2.10-0.10.2.0zokeeper：3.4.10elasticsearch：5.2.2jdk：1.8spring boot：1.5.3.RELEASEsprign cloud：Dalston.RELEASErabbit ...
sleuth+zipkin+kafka+elasticsearch搭建分布式链路追踪系统（一）
sharedCode源码交流
09-07 7062
环境准备 kafka的安装教程，https://blog.csdn.net/u012394095/article/details/81385414 elasticsearch安装 非常简单，从网上下载安装包，在本机上安装就好了。 搭建zipkin-server zipkin-parent的pom文件 &amp;lt;properties&amp;gt; &amp;lt;zip...
zipkin-demo:关于如何使用Spring Cloud Sleuth + Kafka + Zipkin + ElasticSearch的演示
05-14
A demo about how to use Spring Cloud Sleuth + Kafka + Zipkin + ElasticSearch 模块介绍 frontend 提供rest接口，处理用户请求，然后转发给backend处理。 backend 提供rest接口，处理fontend的请求。 zipkin-...
Spring Cloud Sleuth+RabbitMQ+Zipkin实现分布式链路追踪Demo程序
04-16
使用Spring Cloud Sleuth+RabbitMQ+Zipkin实现微服务分布式链路追踪，SpringCloud版本使用的是Greenwich.SR1
27-Spring Cloud服务追踪Sleuth与日志聚合Zipkin1
08-08
先在Zuul的application.yml增加对Feign Service的路由设置：给三个服务增加如下依赖：每个服务都增加Zipkin服务的URL：结果依次
Spring Cloud Sleuth整合zipkin过程解析
08-25
主要介绍了Spring Cloud Sleuth整合zipkin过程解析,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
springcloud-sleuth+zipkin入门一
niemingming的专栏
01-08 4233
说明 zipkin是twitter公司基于Google的drapper论文，创建一套分布式、服务计时框架，可以用于链路跟踪。目前有的java版本的实现有DropWizard zipkin和Springcloud-sleuth+zipkin等。本文是搭建Springcloud的入门实例。 重要概念 trace：个人理解，是一条链路的抽象，表示了一次完成的链路信息。traceid是该链路的唯
Spring Cloud Sleuth+Zipkin实践
superwind
08-23 661
一个由微服务构成的应用系统通过服务来划分问题域，通过REST请求服务API来连接服务来完成完整业务。对于入口的一个调用可能需要有多个后台服务协同完成，链路上任何一个调用超时或出错都可能造成前端请求的失败。服务的调用链也会越来越长，并形成一个树形的调用链。随着服务的增多，对调用链的分析也会越来越复杂。 针对服务化应用全链路追踪的问题，Google发表了Dapper论文，介绍了他们如何进行服务追踪分
spring cloud+es+kafka+zipkin windows环境搭建调用链监控
Authority_01的博客
12-08 1166
spring clouod+es+kafka+zipkin  windows环境搭建调用链监控 1、搭建elastic search 集群 2、搭建kafka环境 3、创建eureka注册中心，见附件项目elk-eureka-server 4、创建zipkin-server，见附件项目zipkin-server 5、创建其他微服务，client-1，client-2 6、互调和测试
SpringCloud，Sleuth+Zipkin
HoldonWithYourGoal的博客
04-19 842
一、介绍        SpringCloud Sleuth为微服务提供了调用链路追踪解决方案，并且兼容支持了Zipkin，只需要引入相应的依赖，配置，即可实现对链路的监控。       SpringCloud Sleuth可以追踪10种组件：async、Hystrix、messaging、websocket、rxjava、scheduling、web（Spring MVC Controller,...
spring-cloud-sleuth+zipkin追踪服务实现
勇仔博客
01-25 1076
在springCloud项目的方式构建服务 spring-cloud-sleuth只要在追踪的服务上配置就可以 spring.zipkin.base-url=http://localhost:8240 spring.sleuth.sampler.percentage=1.0(配置这个就可以) 1.0表示100%追踪//0.7表示70%追踪 1、zipkin-server服务
Spring Cloud Sleuth & Zipkin & Kafka链路追踪
t5721654的专栏
04-15 2620
使用背景 生产环境中，服务越来越多、内部调用关系越来越复杂，需要搭建一套链路追踪系统来分析、评测调用链的各个环节快慢以及系统拓扑图。 简介&说明 链路追踪其实就是个数据上报和收集展示的过程 zipkin是一款链路追踪系统，由服务端和客户端两方组成，服务端由Zipkin提供了，客户端就是我们的应用程序，它不限定是springboot应用，只要按照规范进行上报，服务端就能解析调用...
spring-cloud-sleuth+zipkin追踪服务
渔人
10-22 379
链路追踪：https://blog.csdn.net/wudiyong22/article/details/78930250
springcloud＋hadoop如何实现分布式网盘
09-02
此外，可以使用Spring Cloud的其他组件来实现更多的功能，例如使用Spring Cloud Stream来实现文件传输，使用Spring Cloud Task来实现定时清理和备份任务，使用Spring Cloud Sleuth来实现分布式链路追踪等。...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 17
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值