微服务拆开以后,系统变成一个“大网”,一个用户请求可能要经过好几个服务才能把数据凑齐。以前单体应用的时候,出问题直接看日志就行。现在不行了,一个请求跨度好几个服务,每个服务都有自己的日志,出了问题你根本不知道它到底在哪一步卡住。这就像你在一个大楼里找一个人,楼梯多、房间多、走廊还拐弯,没有地图的话只能挨个房间敲门。Zipkin就是干这个用的——它帮你把一次请求从头到尾经过的所有“房间”串起来,形成一条链路,你顺着这条链路就能快速定位卡点在哪。
一、为什么要做链路追踪
先想一个场景:你打开一个购物App,点了一下“我的订单”,然后页面转了半天,最后超时了。这个看似简单的操作,在后端可能经历了:用户服务验证登录 -> 订单服务查订单列表 -> 商品服务查商品快照 -> 优惠券服务算折扣 -> 库存服务确认发货状态。任何一个环节慢了,整个页面就卡住了。在微服务架构下,每个服务都是独立部署、独立写日志的。如果靠人工去翻每个服务的日志,你得先知道请求是从哪个节点进去的,然后逐个排查。但实际场景中,服务之间调用关系非常复杂,A调B,B又调C,C还调D,有时候还有异步调用。根本没法靠猜。
链路追踪的核心就是把某一次完整的请求当成一个“链路”,给这个链路分配一个唯一的ID,然后让所有参与的服务都带上这个ID,把这些日志串起来。Zipkin就是一套非常成熟的链路追踪系统,它收集这些信息,并且用时间线的方式展示出来。一眼就能看出某个请求在哪个服务上花了多少时间,有没有报错。
二、Zipkin的基本概念
在深入“排查逻辑”之前,先得把Zipkin的几个关键术语搞清楚。这些名词不复杂,就像你看快递单上的信息一样。
2.1 Trace和Span
一个Trace代表一次完整的请求,从用户发出请求到最后拿到响应,整个过程。每个Trace有一个唯一编号,叫Trace ID。可以把Trace想象成一条“线程上的链子”。
一个Span是链路中的一个最小工作单元。比如用户服务调订单服务,这个调用过程本身就是一个Span。每个Span有自己的Span ID,并且会记录父Span ID是谁。这样所有的Span就能组成一棵树。假设一条链路有四个Span,它们的父子关系就像家里的族谱。举个例子:一个请求先经过网关,网关生成一个根Span,然后网关调用户服务,用户服务里面有个子Span,用户服务再去调订单服务,又生成一个孙Span。这些关系最后在Zipkin页面上会渲染成一个瀑布图。
2.2 如何把链路串起来
这里有个关键点:所有服务之间传递Trace ID和Span ID,不能靠嘴巴说。通常是通过HTTP头传递。比如常见的Header有X-Request-Id、X-B3-TraceId、X-B3-SpanId等。每个服务在处理请求的时候,从进来的Header里取出Trace ID,作为自己新的Span的根ID,同时把自己的Span ID再传给下一个被调用的服务。这样一层一层往下传,最后全部上报给Zipkin,Zipkin就能把所有Span按照Trace ID聚在一起。
三、基于Zipkin的排查逻辑,到底怎么用
下面我们进入正题。假设你已经在系统里接入了Zipkin,那么真正遇到一个线上问题,该怎么利用它来排查?我给你梳理一套实际可操作的“排查手册”。
3.1 第一步:看全局链路总览
打开Zipkin的Web界面,点击“查找”按钮。你会看到一个搜索框,这里可以按服务名、标签、耗时等条件过滤。如果用户反馈某个请求很慢,你最好能拿到一个当时触发的请求参数,比如订单号或者用户ID。如果系统里做了埋点,你可以直接用Trace ID精确查。没有的话,就选一个时间段,再把服务名指定为入口服务,搜索所有链路。
查到结果后,你会看到很多条Trace记录,每条后面都有总耗时。按照耗时从大到小排个序,通常最慢的那条就是你要找的。点击进去,你会看到一条瀑布图。每个横条是一个Span,横条的长度就是它消耗的时间。如果某个横条特别长,并且它下面没有子Span,那就说明瓶颈在这个服务自身,可能是数据库查询慢、外呼接口慢或者CPU忙。如果某个横条特别长,但它下面有一堆子Span,那就把下面子Span的耗时加起来看看,到底是谁占了大头。
举个例子,下面是我本地模拟的一个Java服务调用过程:
// 技术栈:Java + Spring Boot + Spring Cloud Sleuth + Zipkin
// 这是模拟一个订单查询接口,它会依次调用商品服务和库存服务
@Service
public class OrderQueryService {
// 注入RestTemplate,用来发起HTTP调用
private final RestTemplate restTemplate;
public OrderQueryService(RestTemplate restTemplate) {
this.restTemplate = restTemplate;
}
public String queryOrder(String orderId) {
// 模拟查订单信息,耗时300毫秒,这里并不真实连数据库,只是sleep
sleep(300);
String orderInfo = "订单信息:" + orderId;
// 调用商品服务,这里相对耗时较长,用于演示慢链路定位
String productInfo = restTemplate.getForObject(
"http://product-service/product/" + orderId,
String.class
);
// 调用库存服务,耗时较短
String stockInfo = restTemplate.getForObject(
"http://stock-service/stock/" + orderId,
String.class
);
return orderInfo + " " + productInfo + " " + stockInfo;
}
private void sleep(long millis) {
try {
Thread.sleep(millis);
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
}
}
}
在Zipkin页面上,你会看到三个Span:第一个是查询订单自己,第二个是调商品服务的客户端调用,第三个是调库存服务的客户端调用。如果商品服务的那个Span占了整条链路一半以上的时间,你就会很快盯上它。
3.2 第二步:看Span详情中的关键信息
点击瀑布图中任意一个Span,会出现一个详细信息的弹窗。里面有这个Span的起止时间、调用的URL、HTTP方法、状态码、以及自定义的Tag和注解。比如我可以在代码里为每次调用打上Tag:
// 技术栈:Java
// 利用Sleuth提供的Span对象,手动给Zipkin上报额外的业务信息
import brave.Span;
import brave.Tracer;
@RestController
public class OrderController {
private final Tracer tracer; // Sleuth的Tracer对象,来自Spring Cloud Sleuth
private final OrderQueryService orderQueryService;
public OrderController(Tracer tracer, OrderQueryService orderQueryService) {
this.tracer = tracer;
this.orderQueryService = orderQueryService;
}
@GetMapping("/order/{id}")
public String order(@PathVariable("id") String id) {
// 拿到当前链路的活动Span
Span currentSpan = tracer.currentSpan();
if (currentSpan != null) {
// 给这个Span添加一个自定义标签,方便排查时按业务维度过滤
currentSpan.tag("order.id", id);
currentSpan.tag("env", "production");
}
return orderQueryService.queryOrder(id);
}
}
这些Tag会原样显示在Zipkin的详情里。比如你可以在排查的时候按order.id过滤出特定订单的所有链路,而不用傻乎乎翻日志。
3.3 第三步:通过依赖图发现服务间调用是否正常
Zipkin除了提供单条链路的详情,还提供了一个“依赖分析”功能。它会统计一段时间内服务之间的调用关系以及成功率,画成一张节点和箭头的图。比如你可以看到“user-service”指向“order-service”的那条线,上面写着每分钟调用次数、错误率。如果某个箭头上的错误率明显上升,就说明两个服务之间的调用出问题了。这时你可以顺着这条边,然后到链路列表里搜索这两个服务的调用记录,筛选那些带有“error”标记的Trace,逐个点进去看具体是连接超时、返回5xx还是数据解析异常。
3.4 第四步:结合日志定位更深层原因
Zipkin只能告诉你“哪个服务慢”和“这个服务在这次请求中的表现”,但它并不能告诉你为什么慢。比如某个服务自身耗时2秒,这个时间是在处理内部业务逻辑,还是没有拿到数据库连接?这个时候,你需要回到该服务自己的日志系统,利用Trace ID把日志串起来。好消息是,现在很多日志框架都支持MDC,你可以把Trace ID自动放到日志上下文中。这样你直接搜Trace ID,就能搜出这个请求在该服务里的所有日志记录。比如下面这个配置就可以在logback中打印Trace ID:
# 技术栈:Java + Logback + Spring Cloud Sleuth
# 这是一个logback-spring.xml的核心片段,用于在日志中自动追加TraceId和SpanId
<pattern>
[%d{yyyy-MM-dd HH:mm:ss.SSS}] [%thread] [%X{traceId:-},%X{spanId:-}] %logger{36} - %msg%n
</pattern>
%X{traceId:-}的意思是从MDC里取出traceId,如果取不到就显示空。这样每条日志都能跟某一条链路绑定。排查的时候,先在Zipkin里拿到Trace ID,然后跑去对应服务日志系统里搜索这个ID,就能看到这个服务内部每一步的执行细节。比如看到“开始查询数据库”、“查询完毕共返回1000条记录”、“开始组装JSON”这些打印信息,你就能定位到真正耗时的地方是哪一个。
四、接入Zipkin的完整示例
光说不练假把式。下面用一个最精简的Java技术栈示例,把Zipkin从依赖引入到上报的完整流程跑通。这里用的是Spring Boot 2.7 + Spring Cloud Sleuth + Zipkin。注意Zipkin服务器本身我假设你已经安装好了,默认端口9411。
4.1 引入Maven依赖
<!-- 技术栈:Java (Maven项目) -->
<dependencies>
<!-- 引入Spring Boot Web,用于提供REST接口 -->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
<!-- 引入Sleuth,它负责管理Trace和Span -->
<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-starter-sleuth</artifactId>
<version>3.1.4</version>
</dependency>
<!-- 引入Zipkin的客户端上报依赖,把数据异步发送到Zipkin服务器 -->
<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-sleuth-zipkin</artifactId>
<version>3.1.4</version>
</dependency>
</dependencies>
4.2 在配置文件里指定Zipkin地址
# 技术栈:Java (Spring Boot配置文件)
server:
port: 8081
spring:
application:
name: order-service
# Zipkin相关配置
zipkin:
base-url: http://localhost:9411
sender:
type: web # 使用HTTP方式异步上报给Zipkin
sleuth:
sampler:
probability: 1.0 # 采样率,1.0表示所有请求都采集,生产环境建议0.1左右
这里我把采样率调成1.0,是为了演示方便。生产环境请求量大,全量采会导致额外开销,一般设个0.1或者0.01就够了。
4.3 写一个最简单的调用链
为了演示链路,我本地起了两个服务:order-service(端口8081)和product-service(端口8082)。order-service会用一个RestTemplate去调用product-service的接口。
// 技术栈:Java (Spring Boot)
// 订单服务主程序
@SpringBootApplication
public class OrderServiceApplication {
public static void main(String[] args) {
SpringApplication.run(OrderServiceApplication.class, args);
}
// 在Spring容器里声明一个RestTemplate,后续用它发起HTTP调用
// 注意要加@LoadBalanced吗?这里不需要,因为是走直连地址
@Bean
public RestTemplate restTemplate() {
return new RestTemplate();
}
}
// 技术栈:Java (Spring Boot)
// 订单服务对外接口,内部调用商品服务
@RestController
public class OrderController {
private final RestTemplate restTemplate;
public OrderController(RestTemplate restTemplate) {
this.restTemplate = restTemplate;
}
@GetMapping("/order/{id}")
public String order(@PathVariable String id) {
// 1. 模拟订单查询耗时100毫秒
sleep(100);
// 2. 调用商品服务接口,把参数id传过去
// 这里的URL写死为localhost,实际环境应该用服务发现
String productInfo = restTemplate.getForObject(
"http://localhost:8082/product/" + id,
String.class
);
// 3. 聚合结果返回
return "订单ID:" + id + " 商品信息:" + productInfo;
}
private void sleep(long millis) {
try {
Thread.sleep(millis);
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
}
}
}
而商品服务那边,只需要提供一个简单的记录日志的接口:
// 技术栈:Java (Spring Boot)
// 商品服务的主程序和控制器
@SpringBootApplication
public class ProductServiceApplication {
public static void main(String[] args) {
SpringApplication.run(ProductServiceApplication.class, args);
}
}
@RestController
public class ProductController {
@GetMapping("/product/{id}")
public String product(@PathVariable String id) {
// 模拟商品查询耗时200毫秒
try {
Thread.sleep(200);
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
}
return "商品-" + id;
}
}
启动这两个服务之后,访问http://localhost:8081/order/123。然后打开Zipkin界面,按服务名order-service查找,就能看到一条链路。点进去之后,瀑布图上会有两个Span:一个是对外处理请求的整体Span,一个是调用product-service的客户端Span。
五、什么场景下适合用Zipkin
链路追踪不是万能的,但它在下面几类场景中价值特别大。
第一类:慢请求定位。 用户反馈接口很慢,但无法确定是哪个服务慢。用Zipkin按照耗时排序,瞬间锁定最慢的Span。
第二类:依赖关系梳理。 一个服务可能同时被多个上游调用。如果某个服务挂了,影响面有多大?依赖图能直观看出谁在调用谁,这在做架构梳理和容量评估时很有用。
第三类:异常流量分析。 当突然出现大规模错误时,你可以通过Zipkin按错误状态过滤,然后按时间线观察是哪条链路最先开始报错,是不是依赖的基础服务出故障了。
第四类:面试讲复杂系统排查思路。 这个不算实际使用场景,但确实是简历上的加分项。你如果能讲清“当一个请求跨5个服务时怎么快速定位问题”,面试官会觉得你有分布式系统的实战经验。
六、Zipkin的优点和缺点
前面说了不少好处,这里摆开详细聊。
6.1 优点
接入成本低。Zipkin客户端支持多种语言,Java里用Spring Cloud Sleuth几乎零侵入,只要加依赖和配置,代码不用改多少。数据模型简单。Trace和Span两个概念,面试好讲,理解也容易。UI界面直观。瀑布图能一眼看清耗时分布,比翻日志高效得多。支持存储扩展。默认支持Cassandra、Elasticsearch、MySQL等,能满足不同规模系统的需求。
6.2 缺点
存储成本高。如果采样率太高,数据量巨大,需要定期清理或者归档。它本身不会做智能告警。Zipkin只负责数据展示,不会像APM系统那样自动告诉你“这里有问题”,你得上报警规则或者人工看。采样概率会牺牲一部分链路准确性。如果采用低采样率,那么一些低频异常链路可能根本不会被采到。排查单条链路时,它不包含应用日志的具体内容,需要配合日志系统使用。
七、使用Zipkin时需要注意的坑
这部分内容都是我实际踩过或者别人踩过的,值得记下来。
注意不要全量采样。 流量一大,全量采样会占用大量网络IO和存储空间。一般控制在1%到10%之间。但为了排查低频问题,可以设置一条“动态采样”规则,比如错误链路强制采样。
注意传递头不能丢。 如果你们的代码里用到了HTTP连接池、服务网关,一定要确保Header能透传。很多坑都是网关层把无关的Header过滤掉了,导致Trace ID断裂。排查方法很简单,在Zipkin里看到一条链路只有一两个Span,明显没走全,就检查Header有没有传下去。
注意异步线程的上下文传递。 如果你在代码里用了线程池或者@Async,那么子线程里面默认拿不到Trace上下文的。拿不到,就代表Zipkin上报的Span会变成两根断开的链路,或者根本没有子Span。解决办法是使用Tracer的nextSpan()手动传递,或者用ExecutorService包装器。
注意Zipkin服务器本身的稳定性。 如果Zipkin挂了,你的业务代码不能挂。所以上报必须采用异步方式,并且要设置超时时间。Sleuth默认的web上报也是异步的,不影响主链路,但如果你改了配置,要小心别把上报变成同步阻塞。
八、总结
Zipkin解决的核心问题是:在微服务架构下,把一次跨多个服务的请求,通过Trace和Span串成一条完整链路。排查逻辑说白了就三步:先看整体耗时分布,再定位慢Span,最后结合日志或代码究其原因。它不能替代日志系统,但它能给你的日志系统提供“导航坐标”。当你面对一堆微服务不知道从哪里开始时,Zipkin就是那张最直观的地图。
在实际项目中,不仅要会用Zipkin,更要懂得怎么调整采样率、怎么保持上下文传递不中断、怎么配合监控告警一起使用。一套好的链路追踪系统,不只是出问题时用来救火的工具,更是平时梳理系统性能瓶颈的重要参考。希望这篇文章能帮你从“到处翻日志”的苦海中解脱出来,把排查链路变成一件有条理的事。如果你还没在项目里接入Zipkin,建议从一个小模块试点开始,感受一下“全链路可视”的快乐。
评论
围绕“基于Zipkin的微服务链路追踪全链路排查逻辑梳理”参与讨论