Spring Cloud实战系列(七) - 服务链路追踪Spring Cloud Sleuth

最新推荐文章于 2022-01-14 11:03:26 发布
最新推荐文章于 2022-01-14 11:03:26 发布
阅读量96 收藏
点赞数
文章标签： java 大数据 数据库
原文链接：https://juejin.im/post/5c56ead5e51d450165279d60
版权

相关

  1. Spring Cloud实战系列(一) - 服务注册与发现Eureka

  2. Spring Cloud实战系列(二) - 客户端调用Rest + Ribbon

  3. Spring Cloud实战系列(三) - 声明式客户端Feign

  4. Spring Cloud实战系列(四) - 熔断器Hystrix

  5. Spring Cloud实战系列(五) - 服务网关Zuul

  6. Spring Cloud实战系列(六) - 分布式配置中心Spring Cloud Config

  7. Spring Cloud实战系列(七) - 服务链路追踪Spring Cloud Sleuth

  8. Spring Cloud实战系列(八) - 微服务监控Spring Boot Admin

  9. Spring Cloud实战系列(九) - 服务认证授权Spring Cloud OAuth 2.0

  10. Spring Cloud实战系列(十) - 单点登录JWT与Spring Security OAuth

前言

Spring Cloud Sleuth 的主要功能就是为 分布式系统 提供 追踪解决方案，并且兼容支持了 Zipkin，只需要在 pom.xml 文件中引入相应的 依赖 即可。本文主要讲述 服务追踪组件 Zipkin，Spring Cloud Sleuth 集成了 Zipkin 组件。它主要用于 聚集 来自各个 异构系统 的 实时监控数据，用来追踪 微服务架构 下的 系统延时问题。

正文

1. 相关术语

1.1. Span

Span 是一个基本的 工作单元，用于描述一次 RPC 调用，Span 通过一个 64 位的 spanId 作为 唯一标识。Zipkin 中的 Span 还有其他数据信息，比如 摘要、时间戳事件、关键值注释 (tags) 以及 进度 ID (通常是 IP 地址)。Span 在不断的启动和停止，同时记录了 时间信息，一个 Span 创建后，必须在未来的某个时刻停止它。

1.2. Trace

一系列 Span 组成的一个 树状结构。例如，如果你正在跑一个大型 分布式系统，可能需要创建一个 Trace。

1.3. Annotation

表示 基本标注列表，一个 Annotation 可以理解成 Span 生命周期中 重要时刻 的 数据快照，比如一个 Annotation 中一般包含 发生时刻（timestamp）、事件类型（value）、端点（endpoint）等信息。其中 Annotation 的 事件类型 包含以下四类：

  • cs - Client Sent

客户端 发起一个请求，这个 Annotion 描述了这个 Span 的开始。

  • sr - Server Received

服务端 获得请求并 准备开始 处理它，如果将 sr 减去 cs 的 时间戳 便可得到 网络延迟。

  • ss - Server Sent

服务端 完成请求处理，如果将 ss 减去 sr 的 时间戳，便可得到 服务端 处理请求消耗的时间。

  • cr - Client Received

客户端 成功接收到 服务端 的响应，如果将 cr 减去 cs 的 时间戳，便可得到 整个请求 所消耗的 总时间。

2. 项目结构

本文案例主要由 四个模块 组成：

  • eureka-server：作为 服务注册中心。

  • zipkin-server：作为 链路追踪服务中心，负责存储 链路数据。

  • service-hi：对外暴露一个 测试接口，同时作为 链路追踪 的 服务端，负责 产生链路数据。

  • service-zuul：作为 路由网关，负责 请求转发，同时作为 链路追踪 的 客户端，产生 链路数据，并上传至 zipkin-server。

在 8761 端口 开启 eureka-server 服务注册中心，参考前面的文章即可，这里不再演示创建。

3. 构建zipkin-server

新建一个 Spring Boot 应用模块 zipkin-server，它的 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 http://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>1.5.3.RELEASE</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>

    <groupId>io.github.ostenant.springcloud</groupId>
    <artifactId>zipkin-server</artifactId>
    <version>0.0.1-SNAPSHOT</version>

    <name>zipkin-server</name>
    <description>Demo project for Spring Boot</description>

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

    <dependencies>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-eureka</artifactId>
        </dependency>
        <dependency>
            <groupId>io.zipkin.java</groupId>
            <artifactId>zipkin-server</artifactId>
        </dependency>
        <dependency>
            <groupId>io.zipkin.java</groupId>
            <artifactId>zipkin-autoconfigure-ui</artifactId>
        </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>
复制代码

在应用的入口类上, 加上注解 @EnableZipkinServer，开启 Zipkin Server 的功能。

@EnableZipkinServer
@EnableEurekaClient
@SpringBootApplication
public class ZipkinServerApplication {

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

在 配置文件 application.yml 中指定服务端口号为 9411，并向 Eureka 注册中心进行 服务注册。

eureka:
  client:
    service-url:
      defaultZone: http://localhost:8761/eureka/
server:
  port: 9411
spring:
  application:
    name: zipkin-server
复制代码

4. 构建service-hi

新建一个 Spring Boot 应用模块 service-hi，在它的 pom.xml 中引入 引入起步依赖 spring-cloud-starter-zipkin，完整依赖如下：

<?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 http://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>1.5.3.RELEASE</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>io.github.ostenant.springcloud</groupId>
    <artifactId>service-hi</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>eureka-client</name>
    <description>Demo project for Spring Boot</description>

    <properties>
        <java.version>1.8</java.version>
        <spring-cloud.version>Dalston.SR1</spring-cloud.version>
    </properties>

    <dependencies>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-eureka</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-web</artifactId>
        </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.zipkin.base-url 指定 zipkin server 的地址。

eureka:
  client:
    serviceUrl:
      defaultZone: http://localhost:8761/eureka/
server:
  port: 8763
spring:
  application:
    name: service-hi
  zipkin:
  # base-url: http://localhost:9411/
  # 若在同一个注册中心的话可以启用自动发现，省略base-url
    locator:
      discovery:
        enabled: true #自动发现
  sleuth:
    sampler:
      percentage: 1.0
复制代码

到此为止 ZipKin 客户端 已经整合完毕，最后在 应用启动类 上对外暴露一个 API 接口 方便测试。

@SpringBootApplication
@EnableEurekaClient
@RestController
public class ServiceHiApplication {

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

    @Value("${server.port}")
    private String port;

    @RequestMapping("/hi")
    public String home(@RequestParam String name) {
        return "Hi " + name + ", I am from port: " + port;
    }
}
复制代码

5. 构建service-zuul

新建一个 Spring Boot 应用模块 service-zuul，在 pom.xml 中引入依赖 spring-cloud-starter-zipkin，完整依赖如下：

<?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 http://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>1.5.3.RELEASE</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>

    <groupId>io.github.ostenant.springcloud</groupId>
    <artifactId>service-zuul</artifactId>
    <version>0.0.1-SNAPSHOT</version>

    <name>service-zuul</name>
    <description>Demo project for Spring Boot</description>

    <properties>
        <java.version>1.8</java.version>
        <spring-cloud.version>Dalston.SR1</spring-cloud.version>
    </properties>

    <dependencies>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-eureka</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-zuul</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</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-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.zipkin.base-url 指定 zipkin server 的地址。同时指定 service-hi 基于 zuul 的 服务路径 匹配前缀。

server:
  port: 8769
spring:
  application:
    name: service-zuul
  client:
    service-url:
      defaultZone: http://localhost:8761/eureka/
  sleuth:
    sampler:
      percentage: 1.0
  zipkin:
    # base-url: http://localhost:9411/
    # 若在同一个注册中心的话可以启用自动发现，省略base-url
    locator:
      discovery:
        enabled: true #自动发现
zuul:
  routes:
    api-hi:
      path: /api-hi/**
      serviceId: service-hi
复制代码

到这里可以发现，引入 ZipKin 服务只需要 导依赖、配置属性 两步即可。在应用的 启动类 上使用 @EnableZuulProxy 注解开启 路由网关。

@EnableZuulProxy
@EnableEurekaClient
@SpringBootApplication
public class ServiceZuulApplication {

    public static void main(String[] args) {
        SpringApplication.run(ServiceZuulApplication.class, args);
    }
}
复制代码

6. 测试追踪过程

完整 链路追踪模块 搭建完毕，总结一下：

  1. 搭建一台 zipkin server 作为 链路服务中心。

  2. 给各个 服务 引入 zipkin 依赖，配置 zipkin server 地址即可。

下面按顺序依次启动 eureka-server、service-zipkin、service-hi 和 service-zuul。访问服务网关，地址为： http://localhost:8769/api-hi/hi?name=vainlgory，服务响应内容如下：

Hi Vainlgory, I am from port: 8763

然后访问 http://localhost:9411，即访问 ZipKin 提供的可视化页面。

这个界面用于显示 ZipKin Server 收集的 链路数据，可以根据 服务名、开始时间、结束时间、请求消耗的时间 等条件来查找。单击 Find Tracks按钮，可以查看请求的 调用时间、消耗时间，以及请求的 链路情况。

单击顶部的 Dependencies 按钮，可以查看服务的 依赖关系。

7. 在链路数据中添加自定义数据

现在需要实现一个功能：在 链路数据 中加上请求的 操作人。本案例在 service-zuul 网关服务 中实现。

  1. 新建一个 ZuulFilter 过滤器，它的类型为 post 类型，order 为 900，开启 拦截功能。

  2. 在过滤器的 拦截逻辑方法 run() 里面，通过 Tracer 的 addTag() 方法加上 自定义 的数据，在本案例中加上了链路的 操作人。

  3. 也可以在这个 过滤器 中获取 当前链路 的 traceld 信息，traceld 作为 链路数据 的 唯一标识，可以存储在 log 日志中，方便后续查找，本案例只是将 traceld 的信息简单地打印在控制台上。代码如下：

@Component
public class LoggerFileter extends ZuulFilter {
    @Autowired
    private Tracer tracer;

    @Override
    public String filterType() {
        return FilterConstants.POST_TYPE;
    }

    @Override
    public int filterOrder() {
        return 900;
    }

    @Override
    public boolean shouldFilter() {
        return true;
    }

    @Override
    public Object run() {
        tracer.addTag("operator","forezp");
        System.out.println(tracer.getCurrentSpan().traceIdString());
        return null;
    }
}
复制代码

8. 使用RabbitMQ传输链路数据

首先改造 zipkin-server 项目模块，在它的 pom.xml 文件中将 zipkin-server 的依赖去掉，加上 spring-cloud-sleuth-zipkin-stream 和 spring-cloud-starter-stream-rabbit 的依赖，配置如下：

<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-rabbit</artifactId>
</dependency>
复制代码

在 zipkin-server 的配置文件 application.yml 中加上 RabbitMQ 的配置，包括 主机名、端口、用户名、密码，代码如下：

spring:
  rabbitmq:
    host: localhost
    port: 5672
    username: guest
    password: guest
复制代码

在应用的启动类 ZipkinServerApplication 上把注解 @EnableZipkinServer 替换为注解 ＠EnableZipkinStreamServer，开启 ZipkinStreamServer，代码如下：

@EnableEurekaClient
@SpringBootApplication
@EnableZipkinStreamServer
public class ZipkinServerApplication {

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

现在来改造 Zipkin Client（包括 service-zuul 和 service-hi 两个模块），分别在它们的 pom.xml 文件中将 spring-cloud-starter-zipkin 依赖改为 spring-cloud-sleuth-zipkin-stream 和 spring-cloud-starter-stream-rabbit，代码如下：

<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-rabbit</artifactId>
</dependency>
复制代码

和前面的 zipkin-server 模块一样，同时在配置文件 applicayion.yml 加上 RabbitMQ 的配置。这样，就将链路的 数据上传 从 HTTP 改为用 消息代组件 RabbitMQ 的方式。

9. 在MySQL数据库中存储链路数据

在上面的例子中，Zipkin Server 将数据存储在 内存 中，一旦应用服务 重启，之前的 链路数据全部丢失，这时候就需要引入 持久化机制。Zipkin 支持将 链路数据 存储在 MySQL、Elasticsearch 和 Cassandra 数据库中。本节讲解如何使用 MySQL 存储。

Zipkin Client 有两种方式将 链路数据 传输到 Zipkin Server 中，一种是使用 HTTP，另一种是使用 RabbitMQ。Zipkin Server 通过这两种方式来 收集链路数据，并存储在 MySQL 中。

9.1. 使用HTTP传输链路数据

在 zipkin-server 模块的 pom.xml 文件加上以下依赖：

  • Zipkin Server 的依赖 zipkin-server

  • Zipkin 的 MySQL 存储依赖 zipkin-storage-mysql

  • Zipkin Server 的 UI 界面依赖 zipkin-autoconfigure-ui

  • MySQL 的连接器依赖 mysql-connector-java

  • JDBC 的 起步依赖 spring-boot-starter-jdbc

代码如下：

<dependency>
    <groupId>io.zipkin.java</groupId>
    <artifactId>zipkin-server</artifactId>
    <version>1.19.0</version>
</dependency>
<dependency>
    <groupId>io.zipkin.java</groupId>
    <artifactId>zipkin-storage-mysql</artifactId>
    <version>1.19.0</version>
</dependency>
<dependency>
    <groupId>io.zipkin.java</groupId>
    <artifactId>zipkin-autoconfigure-ui</artifactId>
</dependency>
<dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
</dependency>
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-jdbc</artifactId>
</dependency>
复制代码

在 zipkin-server 模块的 配置文件 application.yml 中加上 数据源 的配置，包括 数据库 的 Url、用户名、密码 和 连接驱动，并且需要配置 zipkin.storage.type 为 mysql，代码如下：

spring:
  datasource:
    driver-class-name: com.mysql.jdbc.Driver
    url: jdbc:mysql://localhost:3306/spring-cloud-zipkin?useUnicode=true&characterEncoding=utf8&useSSL=false
    username: root
    password: 123456
zipkin:
  storage:
    type: mysql
复制代码

另外需要在 MySQL 数据库中放置数据库的 初始化脚本，创建包括 zipkin_spans、zipkin_annotations 和 zipkin_dependencies 这几张表。

CREATE TABLE IF NOT EXISTS zipkin_spans (
  `trace_id_high` BIGINT NOT NULL DEFAULT 0 COMMENT 'If non zero, this means the trace uses 128 bit traceIds instead of 64 bit',
  `trace_id` BIGINT NOT NULL,
  `id` BIGINT NOT NULL,
  `name` VARCHAR(255) NOT NULL,
  `parent_id` BIGINT,
  `debug` BIT(1),
  `start_ts` BIGINT COMMENT 'Span.timestamp(): epoch micros used for endTs query and to implement TTL',
  `duration` BIGINT COMMENT 'Span.duration(): micros used for minDuration and maxDuration query'
) ENGINE=InnoDB ROW_FORMAT=COMPRESSED CHARACTER SET=utf8 COLLATE utf8_general_ci;

ALTER TABLE zipkin_spans ADD UNIQUE KEY(`trace_id_high`, `trace_id`, `id`) COMMENT 'ignore insert on duplicate';
ALTER TABLE zipkin_spans ADD INDEX(`trace_id_high`, `trace_id`, `id`) COMMENT 'for joining with zipkin_annotations';
ALTER TABLE zipkin_spans ADD INDEX(`trace_id_high`, `trace_id`) COMMENT 'for getTracesByIds';
ALTER TABLE zipkin_spans ADD INDEX(`name`) COMMENT 'for getTraces and getSpanNames';
ALTER TABLE zipkin_spans ADD INDEX(`start_ts`) COMMENT 'for getTraces ordering and range';

CREATE TABLE IF NOT EXISTS zipkin_annotations (
  `trace_id_high` BIGINT NOT NULL DEFAULT 0 COMMENT 'If non zero, this means the trace uses 128 bit traceIds instead of 64 bit',
  `trace_id` BIGINT NOT NULL COMMENT 'coincides with zipkin_spans.trace_id',
  `span_id` BIGINT NOT NULL COMMENT 'coincides with zipkin_spans.id',
  `a_key` VARCHAR(255) NOT NULL COMMENT 'BinaryAnnotation.key or Annotation.value if type == -1',
  `a_value` BLOB COMMENT 'BinaryAnnotation.value(), which must be smaller than 64KB',
  `a_type` INT NOT NULL COMMENT 'BinaryAnnotation.type() or -1 if Annotation',
  `a_timestamp` BIGINT COMMENT 'Used to implement TTL; Annotation.timestamp or zipkin_spans.timestamp',
  `endpoint_ipv4` INT COMMENT 'Null when Binary/Annotation.endpoint is null',
  `endpoint_ipv6` BINARY(16) COMMENT 'Null when Binary/Annotation.endpoint is null, or no IPv6 address',
  `endpoint_port` SMALLINT COMMENT 'Null when Binary/Annotation.endpoint is null',
  `endpoint_service_name` VARCHAR(255) COMMENT 'Null when Binary/Annotation.endpoint is null'
) ENGINE=InnoDB ROW_FORMAT=COMPRESSED CHARACTER SET=utf8 COLLATE utf8_general_ci;

ALTER TABLE zipkin_annotations ADD UNIQUE KEY(`trace_id_high`, `trace_id`, `span_id`, `a_key`, `a_timestamp`) COMMENT 'Ignore insert on duplicate';
ALTER TABLE zipkin_annotations ADD INDEX(`trace_id_high`, `trace_id`, `span_id`) COMMENT 'for joining with zipkin_spans';
ALTER TABLE zipkin_annotations ADD INDEX(`trace_id_high`, `trace_id`) COMMENT 'for getTraces/ByIds';
ALTER TABLE zipkin_annotations ADD INDEX(`endpoint_service_name`) COMMENT 'for getTraces and getServiceNames';
ALTER TABLE zipkin_annotations ADD INDEX(`a_type`) COMMENT 'for getTraces';
ALTER TABLE zipkin_annotations ADD INDEX(`a_key`) COMMENT 'for getTraces';
ALTER TABLE zipkin_annotations ADD INDEX(`trace_id`, `span_id`, `a_key`) COMMENT 'for dependencies job';

CREATE TABLE IF NOT EXISTS zipkin_dependencies (
  `day` DATE NOT NULL,
  `parent` VARCHAR(255) NOT NULL,
  `child` VARCHAR(255) NOT NULL,
  `call_count` BIGINT,
  `error_count` BIGINT
) ENGINE=InnoDB ROW_FORMAT=COMPRESSED CHARACTER SET=utf8 COLLATE utf8_general_ci;

ALTER TABLE zipkin_dependencies ADD UNIQUE KEY(`day`, `parent`, `child`);
复制代码

最后需要在应用的启动类 ZipkinServerApplication 中注入 MySQLStorage 的 Bean，代码如下：

@Bean
public MySQLStorage mySQLStorage(DataSource datasource) {
    return MySQLStorage.builder()
        .datasource(datasource)
        .executor(Runnable::run)
        .build();
}
复制代码

只需要上述步骤，即可将使用 HTTP 传输的 链路数据 存储在 MySQL 数据库中。

9.2. 使用RabbitMQ传输链路数据

本节的案例是在使用 RabbitMQ 传输数据 基础上进行改造的，只需要改造 zipkin-server 的工程。

在 zipkin-server 工程的 pom.xml 文件中加上 MySQL 的 连接器依赖 mysql-connector-java 和 JDBC 的 起步依赖 spring-boot-starter-jdbc，代码如下：

<dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
</dependency>
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-jdbc</artifactId>
</dependency>
复制代码

在 zipkin-server 模块的 配置文件 application.yml 中加上 数据源 的配置，包括数据库的 Uri、用户名、密码 和 连接驱动，同样的配置 zipkin.storage.type 为 mysql，代码如下：

spring:
  datasource:
    url: jdbc:mysql://localhost:3306/spring-cloud-zipkin?useUnicode=true&characterEncoding=utf8&useSSL=false
    username: root
    password: 123456
    driver-class-name: com.mysql.jdbc.Driver
zipkin:
  storage:
    type: mysql
复制代码

另外需要在 MySQL数据库中初始化 数据库脚本，具体同上一节。

10. 在ElasticSearch中存储链路数据

在 并发高 的情况下，使用 MySQL 存储 链路数据 显然不合理，这时可以选择使用 ElasticSearch 作为存储。

下载并安装 ElasticSearch 和 Kibana，下载地址为 www.elastic.co/products/el…。安装完成后启动，其中 ElasticSearch 的 默认端口号 为 9200，Kibana 的 默认端口号 为 5601。

本节是在 第八节 的基础上进行改造。首先在 pom.xml 文件中加上 zipkin 的依赖和 zipkin-autoconfigure-storage-elasticsearch-http 的依赖，代码如下：

<dependency>
    <groupId>io.zipkin.java</groupId>
    <artifactId>zipkin</artifactId>
    <version>1.28.1</version>
</dependency>
<dependency>
    <groupId>io.zipkin.java</groupId>
    <artifactId>zipkin-autoconfigure-storage-elasticsearch-http</artifactId>
    <version>1.28.1</version>
</dependency>
复制代码

在应用的配置文件 application.yml 中加上 Zipkin 的配置，配置了 zipkin 的 存储类型（type) 为 Elasticsearch，使用的 存储组件（StorageComponent）为 Elasticsearch，然后需要配置 Elasticsearch，包括 hosts（ 可以配置 多个实例，用 “,” 隔开）。具体配置代码如下：

zipkin:
  storage:
    type: elasticsearch
    StorageComponent: elasticsearch
    elasticsearch:
      cluster: elasticsearch
      max-requests: 30
      index: zipkin
      index-shards: 3
      index-replicas: 1
      hosts: localhost:9200
复制代码

只需要完成这些配置，Zipkin Server 的 链路数据 就可以存储在 ElasticSearch 里面。

11. 用Kibana展示链路数据

上一节讲述了如何将 链路数据 存储在 ElasticSearch 中，ElasticSearch 可以和 Kibana 结合，将 链路数据 展示在 Kibana 上。安装完成后启动 Kibana，Kibana 默认会向 本地端口 为 9200 的 ElasticSearch 读取数据。Kibana 的 默认端口 为 5601，访问 Kibana 的主页 http://localhost:5601。

单击 Management 按钮，然后单击 Add New，添加一个 index。上一节 ElasticSearch 中写入 链路数据 的 index 配置的是 zipkin，在 Kibana 界面上填写 zipkin-*，单击 Create 按钮，创建完成 index 后，单击 Discover，页面上出现 链路数据。

参考

  • 方志朋《深入理解Spring Cloud与微服务构建》

欢迎关注技术公众号： 零壹技术栈

本帐号将持续分享后端技术干货，包括虚拟机基础，多线程编程，高性能框架，异步、缓存和消息中间件，分布式和微服务，架构学习和进阶等学习资料和文章。

weixin_33696822
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
SpringCloud链路追踪组件Sleuth配置方法解析
08-19
主要介绍了SpringCloud链路追踪组件Sleuth配置方法解析,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
Zipkin部署遇到的问题
Z_RenYong的博客
08-12 2245
1、首先把jar上传到服务器上（需要jar包的可以去阿里云中央仓库下载，速度快） 2、用数据库作为存储介质，启动zipkin-server 附：SQL建表语句 CREATE TABLE IF NOT EXISTS zipkin_spans ( `trace_id_high` BIGINT NOT NULL DEFAULT 0 COMMENT 'If non zero, this means the trace uses 128 bit traceIds instead of 6
springcloud微服务链路追踪组件之zipkin实战（十）
nandao158的博客
08-22 440
多个微服务之间的调用关系记录，称为服务链路追踪，这样可以很清楚的查看到，各服务之间的相互调用。比较流行的技术有 springcloud 的zipkin组件，skywalking,logstash等，今天主要讲解zipkin 的实战使用。 1、zipkin 服务端在springcloud 的F版本之后，官方给提供标准的服务jar包，下载地址是： 启动命令：java -jar XXXXXXXX.jar 这里重点强调一下 以上启动命令是没有连接数据库的，zipkin 默认是不连接数据库的，数据默认是存在内.
【Zipkin】zipkin-dependencies计算 - 源码解析
UckyK的专栏
01-17 586
zipkin-dependencies离线计算拓扑图依赖 本文分析mysql存储（后续准备接入Doris直接计算依赖关系，所以分析不关注存储） 查找main方法 ZipkinDependenciesJob case "mysql": MySQLDependenciesJob.builder() .logInitializer(logInitializer...
浅谈Spring-cloud 之 sleuth 服务链路跟踪
08-28
本篇文章主要介绍了浅谈Spring-cloud 之 sleuth 服务链路跟踪，小编觉得挺不错的，现在分享给大家，也给大家做个参考。一起跟随小编过来看看吧
spring cloud sleuth 全链路追踪 demo
10-25
spring cloud sleuth 全链路追踪
spring cloud sleuth 全链路追踪数据表
最新发布
10-25
spring cloud sleuth 全链路追踪数据表
sample-sleuth-users:Spring Cloud Sleuth的演示项目-Users Microservice
05-18
此应用程序取决于快速开始使用所有依赖项运行此示例的最简单方法是从docker compose进行安装，并在项目的根目录下简单运行docker： docker-compose up此命令将启动以下服务： 8080端口中的sample-sleuth-users 端口...
Spring Cloud应用进行服务追踪分析(Zipkin和spring cloud Sleuth)
南北雪树的专栏
05-22 1万+
摘要： 本文简单介绍了如何利用Zipkin对SpringCloud应用进行服务分析。在实际的应用场景中，Zipkin可以结合压力测试工具一起使用，分析系统在大压力下的可用性和性能。 设想这么一种情况，如果你的微服务数量逐渐增大，服务间的依赖关系越来越复杂，怎么分析它们之间的调用关系及相互的影响？ 服务追踪分析 一个由微服务构成的应用系统通过服务来划分问题域，通过REST请求服
Eclipse配置运行SpringCloud（Hoxton + 2.2.4）微服务框架 + 分布式链路跟踪 Sleuth+Zipkin（RabbitMQ+MySQL）
赵健乔的技术Blog
03-01 5234
Zipkin 是基于Dapper 实现(Google 分布式跟踪系统的论文)，它致力于收集服务的定时数据，以解决微服务架构中的延迟问题，包括数据的追踪收集、存储、查找和展现。Zipkin可以收集各个服务器上请求链路的跟踪数据，并通过它提供的 REST API 接口来辅助用户查询跟踪数据以实现对分布式系统的监控程序，从而及时地发现系统中出现的延迟升高问题并找出系统性能瓶颈的根源。
zipkin-dependencies全局调用链生成（三）
sharedCode源码交流
09-12 4315
问题背景 上一章我们使用了sleuth+zipkin+kafka+elasticsearch搭建了一个简单的分布式链路追踪系统 ，通过接口调用调试，如果已经自己试过的朋友肯定知道，默认全局的调用链是不会自动生成的 ， 通过看官网的文档，我们可以看到，使用elasticsearch作为存储的话，是需要使用一个 “spark job”来生成全局的调用链的。 https://github.com/...
dubbo分布式系统链路追踪_zipkin
johnhuster的专栏
09-11 5028
dubbo分布式系统链路追踪 zipkin
Zinkin进阶篇-Zipkin-dependencies的应用
热门推荐
海锋博客
01-30 1万+
前言 之前章节中已经实现了zipkin数据持久化至elasticsearch，但其带来了一个负面作用，无法正常显示dependencies。通过阅读zipkin在github说明，可以看到已经有了解决方案，本章将介绍如何实现并验证。 本章概要 1、寻找解决方案； 2、方案验证； 寻找解决方案 1、通过阅读Zipkin在Github(https://github.com/
SpringCloud之自己整理的Zipkin搭建过程
小达哥的博客
05-30 7060
给现有项目搭建项目（首先你得有服务注册中心、客户端、服务端）： 我是用的mysql+zikpin,pom.xml配置如下: <dependency> <groupId>org.springframework.cloud</groupId> <artifactId>spring-cloud-starter-zipkin&lt...
SpringCloud Sleuth+Zipkin链路追踪搭建
FYHannnnnn的博客
01-14 289
网关配置 Maven依赖 <!--链路追踪--> <dependency> <groupId>org.springframework.cloud</groupId> <artifactId>spring-cloud-starter-sleuth</artifactId> </dependency> <dependen
使用Zipkin给项目搭建链路追踪功能
qq_17831715的博客
03-18 810
使用Zipkin搭建蘑菇博客链路追踪 前言 Zipkin是一个开源的分布式的链路追踪系统，每个微服务都会向zipkin报告计时数据，聚合各业务系统调用延迟数据，达到链路调用监控跟踪。 如图，在复杂的调用链路中假设存在一条调用链路响应缓慢，如何定位其中延迟高的服务呢？ 日志： 通过分析调用链路上的每个服务日志得到结果 zipkin：使用zipkin的web UI可以一眼看出延迟高的服务 如图...
.NetCore实践篇：分布式监控Zipkin持久化之殇
ahilll的博客
09-20 479
前言 本系列已写了四篇文章，读本篇之前，可以先读前面几篇。 思考大纲：.Net架构篇:思考如何设计一款实用的分布式监控系统？ 实践篇一：.NetCore实践篇：分布式监控客户端ZipkinTracer从入门到放弃之路 实践篇二：.NetCore实践篇：分布式监控系统zipkin踩坑之路（二） 实践篇三：.NetCore实践篇：成功解决分布式监控ZipKin聚合依赖问题（三） 简要回顾 zipkin...
springcloud sleuth链路追踪
06-28
### 回答1： Spring Cloud Sleuth是一个分布式跟踪解决方案，它可以帮助开发人员在微服务架构中追踪请求的流程和调用链路。它通过为每个请求生成唯一的跟踪ID和跨服务的调用ID来实现这一目标。这些ID可以用于跟踪请求的流程和调用链路，从而帮助开发人员快速诊断和解决问题。Spring Cloud Sleuth还提供了一些可视化工具，如Zipkin，可以帮助开发人员更好地理解和分析跟踪数据。 ### 回答2： SpringCloud Sleuth是一个基于日志的分布式跟踪方案，它可以用于解决微服务架构下的分布式系统的链路追踪问题。在分布式系统中，一个请求经常会穿越多个服务，从而会形成一条复杂的链路，如果有一台或多台机器对此进行记录，那么将能够轻松地查看和理解一个请求的完整路径。这些信息能够帮助我们更快地定位问题所在，提高系统可靠性和稳定性。 Sleuth使用了Zipkin的架构和数据模型，通过在每个请求的Header中添加Trace Id和Span Id来实现链路追踪。Trace Id表示整个请求链路，Span Id表示每一个服务的一个简单步骤。使用这两个 Id，我们就可以将整个链路追踪下来，使得对请求的监测、记录和分析变得更加容易。 Sleuth结合了Spring Cloud日志管理和Zipkin的功能，能够自动收集各个微服务的请求跟踪信息，并将其发送到Zipkin服务器进行聚合分析，视图展现。通过Sleuth的ChainInvoker，可以实现对所有链路的统一管理。当一条请求跨越多个服务时，Sleuth会为每个服务实例生成唯一的spanId，并将这个spanId沿用到下一个服务实例，从而使得整条链路保留了完整的信息。此外，Sleuth还支持基于日志的采样策略和数据比较高效的存储，保证了高性能的分布式链路追踪。 Sleuth的主要应用场景是微服务架构下的链路跟踪和性能监控。微服务架构中有大量的服务，服务之间的关系错综复杂，因此链路追踪对于排查问题、优化性能非常重要。Sleuth能够方便地实现链路追踪和监测，并帮助我们快速定位问题所在，提高系统的可靠性和稳定性。 ### 回答3： Spring Cloud Sleuth 链路追踪是 Spring Cloud 微服务架构中的一项重要的功能模块。通过 Sleuth 链路追踪，我们可以跟踪整个分布式系统中的请求链路，从而了解每个操作所花费的时间、调用的服务以及调用顺序。在微服务架构中，服务调用会涉及到多个服务之间的协作，使用 Sleuth 链路追踪可以帮助我们很好地理解系统在内部的调用过程。 Sleuth 链路追踪的原理是在每个服务的请求中添加唯一的追踪 ID，通过这个追踪 ID，Sleuth 可以实现将每个请求相关的服务调用串联起来，形成完整的请求链路。追踪 ID 通常被称为 Trace ID，它作为请求的一部分，从前端发起请求的服务开始一直传递到最后一个服务。 通过 Sleuth 链路追踪，我们可以了解每个调用的服务名和 IP 地址，以及请求的耗时情况，在调试分布式系统时非常实用。此外，Sleuth 还支持将链路追踪信息集成到日志系统中，从而更好地协助开发人员进行故障排查。 Sleuth 链路追踪还提供了 Zipkin 集成，Zipkin 是一个开源的分布式链路追踪系统，可以将链路数据可视化显示，并提供了一些分析工具，帮助开发人员更好地理解系统的调用情况。 总之，Spring Cloud Sleuth 链路追踪是一个非常实用的工具，可以帮助我们更好地理解分布式系统中服务调用的情况，有效地解决微服务架构中的复杂度和故障排查的问题。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值