微服务之链路追踪Zipkin

已于 2023-09-15 09:16:07 修改
阅读量99 收藏 2
点赞数 1
文章标签： 微服务 架构 spring cloud
于 2023-09-12 17:36:10 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/leichunlin_1988/article/details/132837084
版权

微服务之链路追踪

1.搭建Zipkin服务器

同时也作为Eureka的客户端注册到Eureka的服务中心。
引入依赖
pom.xml

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.1.0.RELEASE</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>spring.cloud</groupId>
    <artifactId>sleuth-zipkin</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <packaging>war</packaging>
    <name>sleuth-zipkin</name>
    <description>sleuth-zipkin project for Spring Boot</description>

    <properties>
        <java.version>1.8</java.version>
        <spring-cloud.version>Greenwich.RELEASE</spring-cloud.version>
    </properties>

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
        </dependency>
        <!-- sleuth -->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-sleuth</artifactId>
        </dependency>
        <!-- zipkin服务端包 -->
        <dependency>
            <groupId>io.zipkin.java</groupId>
            <artifactId>zipkin-server</artifactId>
            <version>2.12.3</version>
        </dependency>
        <!-- Zipkin用户配置包 -->
        <dependency>
            <groupId>io.zipkin.java</groupId>
            <artifactId>zipkin-autoconfigure-ui</artifactId>
            <version>2.12.3</version>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-tomcat</artifactId>
            <scope>provided</scope>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
    </dependencies>

    <dependencyManagement>
        <dependencies>
            <dependency>
                <groupId>org.springframework.cloud</groupId>
                <artifactId>spring-cloud-dependencies</artifactId>
                <version>${spring-cloud.version}</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
        </dependencies>
    </dependencyManagement>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>

</project>

application.yml

# 定义Spring应用名称，它是一个微服务的名称，一个微服务可拥有多个实例
spring:
  application:
    name: sleuth-zipkin

# 服务治理中心相互注册
eureka:
  client:
    serviceUrl:
      defaultZone: http://localhost:1001/eureka,http://localhost:1002/eureka
management:
  metrics:
    web:
      server:
        # 取消自动定时，不设置为false可能时间序列数量增长过大，导致异常
        auto-time-requests: false

server:
  port: 5001

启动类 SleuthZipkinApplication.java

package com.spring.cloud.sleuth.zipkin.main;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import zipkin2.server.internal.EnableZipkinServer;

@SpringBootApplication
// 驱动Zipkin服务器
@EnableZipkinServer
public class SleuthZipkinApplication {

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

}

2.搭建Zipkin客户端

同时也是Eureka的客户端。
sleuth-provider （服务提供模块）
引入依赖

pom.xml
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.1.0.RELEASE</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>spring.cloud</groupId>
    <artifactId>sleuth-provider</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <packaging>war</packaging>
    <name>sleuth-provider</name>
    <description>sleuth-provider project for Spring Boot</description>

    <properties>
        <java.version>1.8</java.version>
        <spring-cloud.version>Greenwich.RELEASE</spring-cloud.version>
    </properties>

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
        </dependency>
        <!-- sleuth -->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-sleuth</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-openfeign</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-zipkin</artifactId>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-tomcat</artifactId>
            <scope>provided</scope>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
    </dependencies>

    <dependencyManagement>
        <dependencies>
            <dependency>
                <groupId>org.springframework.cloud</groupId>
                <artifactId>spring-cloud-dependencies</artifactId>
                <version>${spring-cloud.version}</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
        </dependencies>
    </dependencyManagement>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>

</project>

application.yml配置文件

# 定义Spring应用名称，他是一个微服务的名称，一个微服务可以拥有多个实例
spring:
  application:
    name: sleuth-provider
  sleuth:
    sampler: # 样本配置
      # 百分比，默认0.1
      probability: 1.0
      # 速率，每秒追踪30次
      # rate: 30
  zipkin:
    base-url: http://localhost:5001
# 注册到服务治理中心
eureka:
  client:
    serviceUrl:
      defaultZone: http://localhost:1001/eureka,http://localhost:1002/eureka

server:
  port: 2001

启动类 SleuthProviderApplication.java

package com.spring.cloud.sleuth.provider.main;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication(scanBasePackages ="com.spring.cloud.sleuth.provider")
public class SleuthProviderApplication {

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

}

控制器 SleuthProviderController.java

package com.spring.cloud.sleuth.provider.controller;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RestController;

/**** imports ****/
@RestController
public class SleuthProviderController {
    // 日志对象（org.slf4j.Logger）
    private static final Logger logger
            = LoggerFactory.getLogger(SleuthProviderController.class);

    // 提供的服务
    @GetMapping("/hello/{name}")
    public String sayHello(@PathVariable("name") String name)  {
        logger.info("请求参数：{}" , name);
        String helloResult = "hello " + name;
        logger.info("请求结果：{}", helloResult);
        return helloResult;
    }
}

sleuth-consumer （服务消费模块）
引入依赖
pom.xml

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.1.0.RELEASE</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>spring.cloud</groupId>
    <artifactId>sleuth-consumer</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <packaging>war</packaging>
    <name>sleuth-consumer</name>
    <description>sleuth-consumer project for Spring Boot</description>

    <properties>
        <java.version>1.8</java.version>
        <spring-cloud.version>Greenwich.RELEASE</spring-cloud.version>
    </properties>

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-openfeign</artifactId>
        </dependency>
        <!-- sleuth -->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-sleuth</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-zipkin</artifactId>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-tomcat</artifactId>
            <scope>provided</scope>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
    </dependencies>

    <dependencyManagement>
        <dependencies>
            <dependency>
                <groupId>org.springframework.cloud</groupId>
                <artifactId>spring-cloud-dependencies</artifactId>
                <version>${spring-cloud.version}</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
        </dependencies>
    </dependencyManagement>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>

</project>

application.yml配置文件

# 定义Spring应用名称，他是一个微服务的名称，一个微服务可以拥有多个实例
spring:
  application:
    name: sleuth-consumer
  sleuth:
    sampler: # 样本配置
      # 百分比，默认0.1
      probability: 1.0
      # 速率，每秒追踪30次
      # rate: 30
  zipkin:
    base-url: http://localhost:5001
# 注册到服务治理中心
eureka:
  client:
    serviceUrl:
      defaultZone: http://localhost:1001/eureka,http://localhost:1002/eureka

server:
  port: 3001

启动类 SleuthConsumerApplication.java

package com.spring.cloud.sleuth.consumer.main;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.client.loadbalancer.LoadBalanced;
import org.springframework.cloud.openfeign.EnableFeignClients;
import org.springframework.context.annotation.Bean;
import org.springframework.web.client.RestTemplate;

/**** imports ****/
@SpringBootApplication( // 定义扫描包
        scanBasePackages = "com.spring.cloud.sleuth.consumer")
@EnableFeignClients( //扫描装配OpenFeign接口到IoC容器中 ①
        basePackages="com.spring.cloud.sleuth.consumer")
public class SleuthConsumerApplication {


    @Bean
    @LoadBalanced // 负载均衡
    public RestTemplate restTemplate() {
        return new RestTemplate();
    }

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

}

测试OpenFeign客户端，所以引入@FeignClient
SleuthFeign.java

package com.spring.cloud.sleuth.consumer.feign;

import org.springframework.cloud.openfeign.FeignClient;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;

// 声明为OpenFeign客户端
@FeignClient("sleuth-provider")
public interface SleuthFeign {

    @GetMapping("/hello/{name}")
    public String sayHello(@PathVariable("name") String name);
}

控制器 SleuthController.java

package com.spring.cloud.sleuth.consumer.controller;

import com.spring.cloud.sleuth.consumer.feign.SleuthFeign;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.client.RestTemplate;

/**** imports ****/
@RestController
public class SleuthController {
    // 日志
    private static final Logger logger
            = LoggerFactory.getLogger(SleuthController.class);

    @Autowired
    private RestTemplate restTemplate = null;

    @Autowired
    private SleuthFeign sleuthFeign = null;

    // Ribbon的调用
    @GetMapping("/hello/rest/{name}")
    public String testResTemplate(@PathVariable("name") String name) {
        logger.info("使用RestTemplate，请求参数：{}", name );
        String url = "http://sleuth-provider/hello/{name}";
        logger.info("使用RestTemplate，请求URL：{}", url );
        String result = restTemplate.getForObject(url, String.class, name);
        logger.info("使用RestTemplate，请求结果：{}", result );
        return result;
    }

    // OpenFeign的调用
    @GetMapping("/hello/feign/{name}")
    public String testFeign(@PathVariable("name") String name) {
        logger.info("使用Open Feign，请求参数：{}", name );
        String result = sleuthFeign.sayHello(name);
        logger.info("使用Open Feign，请求结果：{}", result );
        return result;
    }
}

3.搭建Eureka服务治理中心

请参考Eureka篇。只需修改下端口号。

链路追踪需要从网关开始追踪，所以需要搭建网关,前面有搭建Getway的文章了，这里结束zuul网关的搭建

4.搭建网关

sleuth-zuul （微服务实例，同时也是Eureka的客户端和Zipkin客户端）
pom.xml

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.1.0.RELEASE</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>spring.cloud</groupId>
    <artifactId>sleuth-zuul</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <packaging>war</packaging>
    <name>sleuth-zuul</name>
    <description>sleuth-zuul project for Spring Boot</description>

    <properties>
        <java.version>1.8</java.version>
        <spring-cloud.version>Greenwich.RELEASE</spring-cloud.version>
    </properties>

    <dependencies>
        <!-- Web -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <!-- sleuth -->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-sleuth</artifactId>
        </dependency>
        <!-- 服务发现 -->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
        </dependency>
        <!-- Zipkin客户端 -->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-zipkin</artifactId>
        </dependency>
        <!-- Zuul网关 -->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-netflix-zuul</artifactId>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-tomcat</artifactId>
            <scope>provided</scope>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
    </dependencies>

    <dependencyManagement>
        <dependencies>
            <dependency>
                <groupId>org.springframework.cloud</groupId>
                <artifactId>spring-cloud-dependencies</artifactId>
                <version>${spring-cloud.version}</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
        </dependencies>
    </dependencyManagement>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>

</project>

application.yml

# 定义Spring应用名称，他是一个微服务的名称，一个微服务可以拥有多个实例
spring:
  application:
    name: sleuth-zuul
  sleuth:
    sampler: # 样本配置
      # 百分比，默认0.1
      probability: 1.0
      # 速率，每秒追踪30次
      # rate: 30
  zipkin:
    base-url: http://localhost:5001

# 注册到服务治理中心
eureka:
  client:
    serviceUrl:
      defaultZone: http://localhost:1001/eureka,http://localhost:1002/eureka
# Zuul 路由配置
zuul:
  routes:
    provider:
      path: /provider/**
      service-id: sleuth-provider
    consumer:
      path: /consumer/**
      service-id: sleuth-consumer

server:
  port: 8001

启动类 SleuthZuulApplication.java

package com.spring.cloud.sleuth.zuul.main;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.netflix.zuul.EnableZuulProxy;

@SpringBootApplication(scanBasePackages="com.spring.cloud.sleuth.zuul")
@EnableZuulProxy // 驱动Zuul网关服务
public class SleuthZuulApplication {

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

}

自定义过滤器 TraceFilter.java

package com.spring.cloud.sleuth.zuul.filter;

import brave.Tracer;
import com.netflix.zuul.ZuulFilter;
import com.netflix.zuul.context.RequestContext;
import com.netflix.zuul.exception.ZuulException;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.cloud.netflix.zuul.filters.support.FilterConstants;
import org.springframework.stereotype.Component;

/**** imports ****/
@Component
public class TraceFilter extends ZuulFilter {

    private static final Logger logger
            = LoggerFactory.getLogger(TraceFilter.class);

    // 注入Brave的Tracer对象
    @Autowired
    private Tracer tracer = null; // ①

    @Override
    public Object run() throws ZuulException {
        // 添加一个span的属性标记
        tracer.currentSpan().tag("1001", "GET请求");
        // 当前trace id
        String traceId = tracer.currentSpan().context().traceIdString();
        // 当前 span id
        String spanId = tracer.currentSpan().context().spanIdString();
        // 日志打印
        logger.info("当前追踪参数：traceId={}，spanId={}", traceId, spanId);
        return null;
    }

    @Override
    public boolean shouldFilter() {
        // 获取请求上下文
        RequestContext ctx = RequestContext.getCurrentContext();
        // 判断是否GET请求
        return "GET".equalsIgnoreCase(ctx.getRequest().getMethod());
    }

    // 过滤器顺序
    @Override
    public int filterOrder() {
        return FilterConstants.PRE_DECORATION_FILTER_ORDER + 10;
    }

    // 过滤器类型为“pre”
    @Override
    public String filterType() {
        return FilterConstants.PRE_TYPE;
    }
}

启动各个微服务实例
浏览器访问http://localhost:8001/consumer/hello/feign/jim 和http://localhost:8001/consumer/hello/rest/jim
然后登录http://localhost:5001/zipkin/
就可以看到请求记录了。
同时sleuth-consumer的后台日志也可以看到请求日志。

芊芸爸
关注
  • 1
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
Zipkin实现分布式链路追踪
weixin_55258513的博客
02-20 239
Zipkin实现分布式链路追踪
spring cloud微服务配置log4j2日志组件和zipkin进行服务链路追踪
2401_84009317的博客
04-18 947
由于原架构使用的是logback作为日志组件。当然该日志组件还是挺好用的，很方便的进行了日志分割等操作。但是该组件是同步的，所以高访问的时候可能会影响效率，这里就换成log4j2支持异步的日志组件。（1）先exclusions排除掉默认的日志：（2） 引入log4j2相关依赖com.lmaxdisruptor3.3.6注：disruptor是一个基于无锁化环形队列的高性能并发框架，log4j2就是借助它进行高性能日志异步输出的。日志文件如下：自定义一些常量，之后使用${变量名}引用。
zipkin分布式追踪系统
09-27
Zipkin 是一个分布式追踪系统。 它有助于收集解决服务架构中的延迟问题所需的时间数据。 功能包括收集和查找此数据。如果您在日志文件中有跟踪 ID，则可以直接跳转到它。 否则，您可以根据服务、操作名称、标签和持续时间等属性进行查询。 会为你总结一些有趣的数据，比如在服务中花费的时间百分比，以及操作是否失败。 Zipkin UI 还提供了一个依赖关系图，显示有多少跟踪请求通过了每个应用程序。 这有助于识别聚合行为，包括错误路径或对已弃用服务的调用。 应用程序需要被“检测”以向 Zipkin 报告跟踪数据。 这通常意味着配置 跟踪器或检测库 。 向 Zipkin 报告数据的最流行方式是通过 HTTP 或 Kafka，但也有许多其他选项，例如 Apache ActiveMQ、gRPC 和 RabbitMQ。 提供给 UI 的数据存储在内存中，或者通过支持的后端（例如 Apache Cassandra 或 Elasticsearch）持久存储。 详情可看zipkin官网 【https://zipkin.io/】
Spring Cloud 系列文章之六：Spring Cloud Sleuth 与 Zipkin 的分布式追踪
阿里渣渣java研发组-群主
06-08 623
Spring Cloud Sleuth 是 Spring 提供的分布式追踪解决方案。它通过在微服务之间传递追踪信息，实现对请求的全链路追踪。Sleuth 自动为每个请求生成唯一的追踪 ID，并在调用链中传播这些信息，使得开发者可以轻松地追踪每个请求的路径。Zipkin 是 Twitter 开源的一个分布式追踪系统，用于收集和查询追踪数据。它与 Sleuth 无缝集成，提供了可视化界面，帮助开发者分析和优化微服务调用链。修改采样率默认情况下，Sleuth 会对部分请求进行采样。
「Java分享客栈」随时用随时翻：微服务链路追踪之zipkin搭建
xiangyangsanren的专栏
05-20 1093
微服务治理方案中，链路追踪是必修课，SpringCloud在生产环境中真正令人头疼的往往是接口在微服务间的调用，究竟哪个环节出现了问题，哪个环节耗时较长，本篇给你其中一个成熟的解决方案。
微服务链路追踪zipkin
weixin_42276861的博客
12-01 520
为了实现请求跟踪，当请求到达分布式系统的入口端点时，只需要服务跟踪框架为该请求创建一个唯一的标识（即TraceId），同时在分布式系统内部流转的时候，框架始终保持传递该唯一值，直到整个请求的返回。spring-cloud-sleuth-zipkin + spring-cloud-starter-sleuth 就相当于直接引入 spring-cloud-starter-zipkin，包含spring-cloud-sleuth-core。zipkin如果不配置存储的话，默认是在内存中的。
SpringCloud分布式微服务链路追踪方案：Zipkin
最新发布
lucky_fd的博客
06-24 1293
Zipkin 是一个分布式追踪系统，主要用于收集、存储、处理和展示微服务架构中的链路数据。它帮助开发者分析和排查分布式系统中的性能问题，提供完整的请求路径视图。. 在微服务架构中，一个用户请求可能会涉及多个微服务的调用。每个微服务都有可能运行在不同的主机或容器中，传统的日志和监控系统难以提供完整的请求链路视图。而Zipkin能够帮助开发者： 快速定位问题：通过完整的请求路径视图，开发者可以快速找到导致请求延迟或错误的具体服务和代码位置。 优化系统性能：通过分析请求的延迟数据，开发者可以识别系统中的性能瓶颈
微服务应用开发进阶①链路追踪Zipkin
Zzhou1990的博客
05-20 9476
简介 Zipkin 是一款开源的分布式实时数据追踪系统，由基于 Google Dapper 的论文设计而来，由 Twitter 公司提供开源实现，主要功能是聚集来自各个异构系统的实时监控数据，和微服务架构下的接口直接的调用链路和系统延时问题。 Spring Cloud Sleuth为Spring Cloud实现了分布式跟踪解决方案，集成了Zipkin 。 应用场景： 1、可以知道在那个环节耗时长，解决系统并发瓶颈 2、在旧、复杂系统，根据调用链路优化架构 ...
微服务调用链路追踪详解教程Zipkin.docx
11-10
总之，服务调用链路追踪和Zipkin的结合使用，为微服务架构带来了强大的监控能力，使得问题排查和性能优化更为高效。通过Sleuth的自动日志注入和Zipkin的数据收集与展示，我们可以清晰地看到请求在分布式系统中的流转...
「Java分享客栈」随时用随时翻：微服务链路追踪之zipkin搭建.doc
07-10
Java微服务链路追踪之Zipkin搭建 微服务链路追踪是微服务治理方案中的一项必修课，SpringCloud的组件其实使用很简单，但是在生产环境中真正令人头疼的问题往往是软件维护，接口在微服务间的调用究竟哪个环节出现了...
微服务架构之链路追踪.pdf
03-16
微服务架构之链路追踪.pdf
eureka-server+gateway-service+user-service+zipkin-server
07-18
eureka-server+gateway-service+user-service+zipkin-server 本文案例一共四个工程采用多Module形式。需要新建一个主Maven工程，主要指定了Spring Boot的版本为1.5.3，Spring Cloud版本为Dalston.RELEASE。包含了eureka-server工程，作为服务注册中心，eureka-server的创建过程这里不重复；zipkin-server作为链路追踪服务中心，负责存储链路数据；gateway-service作为服务网关工程，负责请求的转发,同时它也作为链路追踪客户端，负责产生数据，并上传给zipkin-service；user-service为一个应用服务，对外暴露API接口，同时它也作为链路追踪客户端，负责产生数据。
微服务springcloud之zipkin使用demo(链路追踪)
08-13
zipkin为分布式链路调用监控系统，聚合各业务系统调用延迟数据，达到链路调用监控跟踪。 zipkin主要涉及四个组件 collector storage search web UI 1.Collector接收各service传输的数据 2.Cassandra作为Storage的一...
毕业设计基于SpringCloud微服务分布式链路追踪项目源码.zip
06-12
毕业设计基于SpringCloud微服务分布式链路追踪系统源码 追踪实现 使用zipkin+sleuth实现 这个是比较成熟的分布式链路追踪实现方案 拦截器自定义实现 基于Google Dapper 论文，进行自定义实现。 原理： traceId ：...
微服务 Zipkin 链路追踪原理(图文详解)
mikechen的互联网架构
10-25 1323
一个看起来很简单的应用，可能需要数十或数百个服务来支撑，一个请求就要多次服务调用。当请求变慢、或者不能使用时，我们是不知道是哪个后台服务引起的。这时，我们使用Zipkin 就能解决这个问题。
微服务sleuth+zipkin---链路追踪+nacos配置中心
不惧困难 顽强拼搏
07-18 2210
sleuth+zipkin链路追踪作用：快速定位微服务的故障所在地。nacos配置中心====对配置做统一管理。
微服务之分布式链路追踪
qq_62377885的博客
04-15 1040
分布式链路追踪技术要解决的问题，分布式链路追踪（Distributed Tracing），就是将一次分布式请求还原成调用链路，进行日志记录，性能监控并将一次分布式请求的调用情况集中展示。比如各个服务节点上的耗时、请求具体到达哪台机器上、每个服务节点的请求状态等等。
SpringBoot 分布式链路踪系 ZipKin + Sleuth 服务链路追踪
qq_33240556的博客
03-06 372
启动带有 Sleuth 和 Zipkin 配置的 Spring Boot 应用。当微服务之间发生调用时，Sleuth 会在每个服务上创建和传播一个全局唯一的 Trace ID，并记录各个服务节点上的 Span 数据。在某些情况下，可能需要更细粒度地控制如何将 Sleuth 收集的数据发送到 Zipkin Server。以上是一个基本的整合流程，实际部署时还需要根据具体的 Zipkin Server 环境和项目需求进行相应的调整。），在这里可以查询和分析分布式系统中的服务调用链路、响应时间等信息。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

芊芸爸

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值