一、Zipkin 介绍

Zipkin 是什么？

Zipkin的官方介绍：https://zipkin.apache.org/

Zipkin是一款开源的分布式实时数据追踪系统（Distributed Tracking System），基于 Google Dapper的论文设计而来，由 Twitter 公司开发贡献。其主要功能是聚集来自各个异构系统的实时监控数据。分布式跟踪系统还有其他比较成熟的实现，例如：Naver的Pinpoint、Apache的HTrace、阿里的鹰眼Tracing、京东的Hydra、新浪的Watchman，美团点评的CAT，skywalking等。

为什么用 Zipkin？

随着业务越来越复杂，系统也随之进行各种拆分，特别是随着微服务架构和容器技术的兴起，看似简单的一个应用，后台可能有几十个甚至几百个服务在支撑；一个前端的请求可能需要多次的服务调用最后才能完成；当请求变慢或者不可用时，我们无法得知是哪个后台服务引起的，这时就需要解决如何快速定位服务故障点，Zipkin分布式跟踪系统就能很好的解决这样的问题。

Zipkin的一些基本概念？

Brave

Brave 是用来装备 Java 程序的类库，提供了面向 Standard Servlet、Spring MVC、Http Client、JAX RS、Jersey、Resteasy 和 MySQL 等接口的装备能力，可以通过编写简单的配置和代码，让基于这些框架构建的应用可以向 Zipkin报告数据。同时 Brave 也提供了非常简单且标准化的接口，在以上封装无法满足要求的时候可以方便扩展与定制。

如下图是 Brave 的结构图。Brave 利用 reporter 向 Zipkin的 Collector 发送 trace 信息。
Zipkin — 微服务链路跟踪 - 图1

Brave 主要是利用拦截器在请求前和请求后分别埋点。例如 Spingmvc 监控使用 Interceptors，Mysql 监控使用 statementInterceptors。同理 Dubbo 的监控是利用 com.alibaba.dubbo.rpc.Filter 来过滤生产者和消费者的请求。

traceId

一次请求全局只有一个traceId。用来在海量的请求中找到同一链路的几次请求。比如servlet服务器接收到用户请求，调用dubbo服务，然后将结果返回给用户，整条链路只有一个traceId。开始于用户请求，结束于用户收到结果。

  • spanId

一个链路中每次请求都会有一个spanId。例如一次rpc，一次sql都会有一个单独的spanId从属于traceId。

  • cs

Clent Sent 客户端发起请求的时间，比如 dubbo 调用端开始执行远程调用之前。

  • cr

Client Receive 客户端收到处理完请求的时间。

  • ss

Server Receive 服务端处理完逻辑的时间。

  • sr

Server Receive 服务端收到调用端请求的时间。

  1. sr - cs = 请求在网络上的耗时
  2. ss - sr = 服务端处理请求的耗时
  3. cr - ss = 回应在网络上的耗时
  4. cr - cs = 一次调用的整体耗时

Zipkin的工作过程

当用户发起一次调用时，Zipkin 的客户端会在入口处为整条调用链路生成一个全局唯一的 trace id，并为这条链路中的每一次分布式调用生成一个 span id。span 与 span 之间可以有父子嵌套关系，代表分布式调用中的上下游关系。span 和 span 之间可以是兄弟关系，代表当前调用下的两次子调用。一个 trace 由一组 span 组成，可以看成是由 trace 为根节点，span 为若干个子节点的一棵树。

Zipkin 会将 trace 相关的信息在调用链路上传递，并在每个调用边界结束时异步的把当前调用的耗时信息上报给 Zipkin Server。Zipkin Server 在收到 trace 信息后，将其存储起来。随后 Zipkin 的 Web UI 会通过 API 访问的方式从存储中将 trace 信息提取出来分析并展示。

Zipkin — 微服务链路跟踪 - 图2

二、Zipkin的部署与运行

Zipkin的 github 地址：https://github.com/apache/incubator-zipkin

Docker 方式

  1. docker run -d -p 9411:9411 openzipkin/zipkin

Jar 包方式（JDK8）

  1. curl -sSL https://zipkin.io/quickstart.sh | bash -s
  2. java -jar zipkin.jar

注意：以上方式的 Zipkin 都是基于内存存储，Zipkin 重启后数据会丢失，建议测试环境使用。Zipkin 支持的存储类型有 inMemory、MySql、Cassandra、以及 ElasticsSearch 几种方式。正式环境推荐使用 Cassandra 和 ElasticSearch。

zipkin 基于 mysql 存储进行启动

1、在mysql数据库中创建zipkin需要用到的表结构

  1. --
  2. -- Copyright 2015-2019 The OpenZipkin Authors
  3. --
  4. -- Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except
  5. -- in compliance with the License. You may obtain a copy of the License at
  6. --
  7. -- http://www.apache.org/licenses/LICENSE-2.0
  8. --
  9. -- Unless required by applicable law or agreed to in writing, software distributed under the License
  10. -- is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express
  11. -- or implied. See the License for the specific language governing permissions and limitations under
  12. -- the License.
  13. --
  15. CREATE DATABASE `zipkin` /*!40100 DEFAULT CHARACTER SET utf8 */;
  16. use zipkin;
  18. CREATE TABLE IF NOT EXISTS zipkin_spans (
  19.   `trace_id_high` BIGINT NOT NULL DEFAULT 0 COMMENT 'If non zero, this means the trace uses 128 bit traceIds instead of 64 bit',
  20.   `trace_id` BIGINT NOT NULL,
  21.   `id` BIGINT NOT NULL,
  22.   `name` VARCHAR(255) NOT NULL,
  23.   `remote_service_name` VARCHAR(255),
  24.   `parent_id` BIGINT,
  25.   `debug` BIT(1),
  26.   `start_ts` BIGINT COMMENT 'Span.timestamp(): epoch micros used for endTs query and to implement TTL',
  27.   `duration` BIGINT COMMENT 'Span.duration(): micros used for minDuration and maxDuration query',
  28.   PRIMARY KEY (`trace_id_high`, `trace_id`, `id`)
  29. ) ENGINE=InnoDB ROW_FORMAT=COMPRESSED CHARACTER SET=utf8 COLLATE utf8_general_ci;
  31. ALTER TABLE zipkin_spans ADD INDEX(`trace_id_high`, `trace_id`) COMMENT 'for getTracesByIds';
  32. ALTER TABLE zipkin_spans ADD INDEX(`name`) COMMENT 'for getTraces and getSpanNames';
  33. ALTER TABLE zipkin_spans ADD INDEX(`remote_service_name`) COMMENT 'for getTraces and getRemoteServiceNames';
  34. ALTER TABLE zipkin_spans ADD INDEX(`start_ts`) COMMENT 'for getTraces ordering and range';
  36. CREATE TABLE IF NOT EXISTS zipkin_annotations (
  37.   `trace_id_high` BIGINT NOT NULL DEFAULT 0 COMMENT 'If non zero, this means the trace uses 128 bit traceIds instead of 64 bit',
  38.   `trace_id` BIGINT NOT NULL COMMENT 'coincides with zipkin_spans.trace_id',
  39.   `span_id` BIGINT NOT NULL COMMENT 'coincides with zipkin_spans.id',
  40.   `a_key` VARCHAR(255) NOT NULL COMMENT 'BinaryAnnotation.key or Annotation.value if type == -1',
  41.   `a_value` BLOB COMMENT 'BinaryAnnotation.value(), which must be smaller than 64KB',
  42.   `a_type` INT NOT NULL COMMENT 'BinaryAnnotation.type() or -1 if Annotation',
  43.   `a_timestamp` BIGINT COMMENT 'Used to implement TTL; Annotation.timestamp or zipkin_spans.timestamp',
  44.   `endpoint_ipv4` INT COMMENT 'Null when Binary/Annotation.endpoint is null',
  45.   `endpoint_ipv6` BINARY(16) COMMENT 'Null when Binary/Annotation.endpoint is null, or no IPv6 address',
  46.   `endpoint_port` SMALLINT COMMENT 'Null when Binary/Annotation.endpoint is null',
  47.   `endpoint_service_name` VARCHAR(255) COMMENT 'Null when Binary/Annotation.endpoint is null'
  48. ) ENGINE=InnoDB ROW_FORMAT=COMPRESSED CHARACTER SET=utf8 COLLATE utf8_general_ci;
  50. ALTER TABLE zipkin_annotations ADD UNIQUE KEY(`trace_id_high`, `trace_id`, `span_id`, `a_key`, `a_timestamp`) COMMENT 'Ignore insert on duplicate';
  51. ALTER TABLE zipkin_annotations ADD INDEX(`trace_id_high`, `trace_id`, `span_id`) COMMENT 'for joining with zipkin_spans';
  52. ALTER TABLE zipkin_annotations ADD INDEX(`trace_id_high`, `trace_id`) COMMENT 'for getTraces/ByIds';
  53. ALTER TABLE zipkin_annotations ADD INDEX(`endpoint_service_name`) COMMENT 'for getTraces and getServiceNames';
  54. ALTER TABLE zipkin_annotations ADD INDEX(`a_type`) COMMENT 'for getTraces and autocomplete values';
  55. ALTER TABLE zipkin_annotations ADD INDEX(`a_key`) COMMENT 'for getTraces and autocomplete values';
  56. ALTER TABLE zipkin_annotations ADD INDEX(`trace_id`, `span_id`, `a_key`) COMMENT 'for dependencies job';
  58. CREATE TABLE IF NOT EXISTS zipkin_dependencies (
  59.   `day` DATE NOT NULL,
  60.   `parent` VARCHAR(255) NOT NULL,
  61.   `child` VARCHAR(255) NOT NULL,
  62.   `call_count` BIGINT,
  63.   `error_count` BIGINT,
  64.   PRIMARY KEY (`day`, `parent`, `child`)
  65. ) ENGINE=InnoDB ROW_FORMAT=COMPRESSED CHARACTER SET=utf8 COLLATE utf8_general_ci;

2、编写docker-compose文件

  1. #编写内容
  2. #注意mysql数据库版本最好是5.6-5.7的，我用mysql8.0连接不成功
  4. version: '2'
  5. services:
  6.   # The zipkin process services the UI, and also exposes a POST endpoint that
  7.   # instrumentation can send trace data to. Scribe is disabled by default.
  8.   zipkin:
  9.     image: openzipkin/zipkin
  10.     container_name: zipkin
  11.     environment:
  12.       - STORAGE_TYPE=mysql
  13.       # Point the zipkin at the storage backend
  14.       - MYSQL_DB=your database name
  15.       - MYSQL_USER=your database username
  16.       - MYSQL_PASS=your database password
  17.       - MYSQL_HOST=your database host
  18.       - MYSQL_TCP_PORT=your database port
  19.       # Uncomment to enable scribe
  20.       # - SCRIBE_ENABLED=true
  21.       # Uncomment to enable self-tracing
  22.       # - SELF_TRACING_ENABLED=true
  23.       # Uncomment to 10:17 debug logging
  24.       # - JAVA_OPTS=-Dlogging.level.zipkin=DEBUG -Dlogging.level.zipkin2=DEBUG
  25.     network_mode: host
  26.     ports:
  27.       # Port used for the Zipkin UI and HTTP Api
  28.       - 9411:9411
  29.       # Uncomment if you set SCRIBE_ENABLED=true
  30.       # - 9410:9410
  31.     #networks: 
  32.     #  - default 
  33.     #  - my_net #创建网路 docker network create my_net 删除网络 docker network rm my_net
  34. #networks: 
  35.   #my_net: 
  36.     #external: true
  1. STORAGE_TYPE=mysql
  2. MYSQL_DB=zipkin
  3. MYSQL_USER=root
  4. MYSQL_PASS=123456
  5. MYSQL_HOST=127.0.0.1
  6. MYSQL_TCP_PORT=3306
  7. STORAGE_TYPE=mysql MYSQL_DB=zipkin MYSQL_USER=root MYSQL_PASS='123456' MYSQL_HOST='127.0.0.1' MYSQL_TCP_PORT=3306 java -jar zipkin.jar > start.logger 2>&1 &

3、启动zipkin后，在浏览器中访问

  1. #启动服务编排，在docker-compose.yml所在文件目录执行
  2. docker-compose up -d
  4. #查看服务日志
  5. docker-compose logs

启动后，访问 http://127.0.0.1:9411 可以看到效果：
Zipkin — 微服务链路跟踪 - 图3
Zipkin — 微服务链路跟踪 - 图4

至此，zipkin服务就安装完成了，需要注意的是mysql版本8.0是不行的，需要5.6或者5.7。

三、Zipkin 与 Dubbo 和 Springmvc 的集成

上面我们搭建好了 Zipkin 服务器，现在的任务就是如何把我们系统内产生的请求数据报送给 Zipkin 服务器，以便在 UI 上渲染出来。

1. pom.xml

  1.         <!-- 使用 okhttp3 作为 reporter -->
  2.         <dependency>
  3.             <groupId>io.zipkin.reporter2</groupId>
  4.             <artifactId>zipkin-sender-okhttp3</artifactId>
  5.             <version>2.8.2</version>
  6.         </dependency>
  7.         <!--  brave 对 dubbo 的集成 -->
  8.         <dependency>
  9.             <groupId>io.zipkin.brave</groupId>
  10.             <artifactId>brave-instrumentation-dubbo-rpc</artifactId>
  11.             <version>5.6.3</version>
  12.         </dependency>
  13.         <!--  brave 对 mvc 的集成 -->
  14.         <dependency>
  15.             <groupId>io.zipkin.brave</groupId>
  16.             <artifactId>brave-instrumentation-spring-webmvc</artifactId>
  17.             <version>5.6.3</version>
  18.         </dependency>

2. application.yml

  1. zipkin:
  2.   url: http://127.0.0.1:9411/api/v2/spans
  3.   connectTimeout: 5000
  4.   readTimeout: 10000
  5.   # 取样率，指的是多次请求中有百分之多少传到zipkin。例如 1.0 是全部取样，0.5是 50% 取样
  6.   rate: 1.0f

3. ZipkinProperties.java

  1. @Configuration
  2. @ConfigurationProperties("zipkin")
  3. public class ZipkinProperties {
  6.     @Value("${spring.application.name}")
  7.     private String serviceName;
  8.     private String url;
  9.     private Long connectTimeout;
  10.     private Long readTimeout;
  11.     private Float rate;
  14.     /*getter and setter*/
  15. }

注意：记得在 SpringBoot 的启动类上加上 @EnableConfigurationProperties 注解才能使 @ConfigurationProperties(“zipkin”) 生效哦！

4. ZipkinConfig.java

  1. @Configuration
  2. public class ZipkinConfig {
  4.     @Autowired
  5.     private ZipkinProperties zipkinProperties;
  7.     /**
  8.      * 为了实现 dubbo rpc调用的拦截
  9.      *
  10.      * @return
  11.      */
  12.     @Bean
  13.     public Tracing tracing() {
  14.         Sender sender = OkHttpSender.create(zipkinProperties.getUrl());
  15.         AsyncReporter reporter = AsyncReporter.builder(sender)
  16.                 .closeTimeout(zipkinProperties.getConnectTimeout(), TimeUnit.MILLISECONDS)
  17.                 .messageTimeout(zipkinProperties.getReadTimeout(), TimeUnit.MILLISECONDS)
  18.                 .build();
  19.         Tracing tracing = Tracing.newBuilder()
  20.                 .localServiceName(zipkinProperties.getServiceName())
  21.                 .propagationFactory(ExtraFieldPropagation.newFactory(B3Propagation.FACTORY, "shiliew"))
  22.                 .sampler(Sampler.create(zipkinProperties.getRate()))
  23.                 .spanReporter(reporter)
  24.                 .build();
  25.         return tracing;
  26.     }
  29.     /**
  30.      * MVC Filter，为了实现 SpringMvc 调用的拦截
  31.      * @param tracing
  32.      * @return
  33.      */
  34.     @Bean
  35.     public Filter tracingFilter(Tracing tracing) {
  36.         HttpTracing httpTracing = HttpTracing.create(tracing);
  37.         httpTracing.toBuilder()
  38.                 .serverParser(new HttpServerParser() {
  39.                     @Override
  40.                     public <Req> String spanName(HttpAdapter<Req, ?> adapter, Req req) {
  41.                         return adapter.path(req);
  42.                     }
  43.                 })
  44.                 .clientParser(new HttpClientParser() {
  45.                     @Override
  46.                     public <Req> String spanName(HttpAdapter<Req, ?> adapter, Req req) {
  47.                         return adapter.path(req);
  48.                     }
  49.                 }).build();
  50.         return TracingFilter.create(httpTracing);
  51.     }
  52. }

如此，我们就把 Zipkin 和 Dubbo 以及 Springmvc 的集成做好了：
Zipkin — 微服务链路跟踪 - 图5

四、Zipkin 与 Spring Cloud 的集成

在 Spring Cloud 中整合 zipkin 则更为简单了。只需在 pom.xml 中引入相关依赖：

  1.         <dependency>
  2.             <groupId>org.springframework.cloud</groupId>
  3.             <artifactId>spring-cloud-starter-zipkin</artifactId>
  4.         </dependency>

然后，在 application.yml 中配置 zipkin-server 的路径：

  1. spring:
  2.   zipkin:
  3.     base-url: http://localhost:9411/

tips：

  • Zipkin Server 一定要在调用后才会产生数据，不会先把服务的信息注册上去。
  • MVC 的拦截，span 的名字是以请求方式命名的，如下：
    Zipkin — 微服务链路跟踪 - 图6
  • 如果仍然想查看，某个请求路径的调用情况呢？
    Zipkin — 微服务链路跟踪 - 图7
  • 以上介绍的方式，链路信息均通过 HTTP 发送到 Zipkin-Server 上，生产上为了不影响主流程的性能，可考虑使用消息队列。

Reference