Spring Cloud Sleuth 整合 Zipkin 进行服务链路追踪

柔情只为你懂 2023-10-01 23:36 39阅读 0赞

### 为何要进行服务链路追踪？ ###

在一个微服务系统架构中，一个完整的请求可能涉及到多个微服务的调用，这个调用形成一个链路。

比如，下单的请求，需要经过网关去调用业务服务，业务服务去调用订单服务，而订单服务同步调用商品服务和用户服务，用户服务又去调用积分服务：

![format_png][]

业务要求整个下单的请求要在 1s 内完成，测试发现请求下单接口耗时超过 2s ，这时我们就需要去定位发现是调用链路上的哪个环节耗时异常，进而去解决问题。

Spring Cloud就有这样一个组件专门做链路追踪，那就是 **Spring Cloud Sleuth** ，有如下功能：

*  跟踪请求的调用情况并将它发送到日志系统，从而可以从日志收集其中看到相关的调用情况。
 *  检测请求来自 Spring 应用程序的公共入口和出口点（servlet 过滤器、rest 模板、计划操作、消息通道、feign 客户端）。
 *  如果使用了 **Zipkin** 结合 **Sleuth** ，则应用程序将通过 HTTP 或者其他方式将 **Sleuth** 跟踪的请求情况发送到 **Zipkin** 。

这里提到的另一个组件 **Zipkin** 是一个能够收集所有服务监控数据的跟踪系统。有了 **Zipkin** 我们可以直观的查看调用链路，并且可以方便的看出服务之间的调用关系以及调用耗时。

Spring Cloud Sleuth和 **Zipkin** 的使用非常简单，官网上有很详细的文档：

Sleuth： [spring.io/projects/sp…][spring.io_projects_sp]

Zipkin： [zipkin.io/pages/quick…][zipkin.io_pages_quick]

下面我们来实操一下。

### 微服务调用链路环境搭建 ###

我们以开篇举的例子来搭建这样一个环境：

![format_png 1][]

还是以本 **Spring Cloud Alibaba** 系列文章的代码 **SpringCloudAlibabaDemo** 为例，目前已有 `gatwway-service` ， `order-service` 和 `user-service` ，我们再创建两个微服务项目 `product-service` 和 `loyalty-service` ，并形成一个调用链路。

完整代码仓库： [github.com/ChenDapengJ…][github.com_ChenDapengJ] 。

为了展示，这里贴出了调用逻辑上的关键代码。

`product-service` 查询商品信息：

@RestController
    @RequestMapping("/product")
    public class ProductController {
        @GetMapping("/price/{id}")
        public BigDecimal getPrice(@PathVariable("id") Long id) {
            if (id == 1) {
                return new BigDecimal("5899");
            }
            return new BigDecimal("5999");
        }
    }
    复制代码

`loyalty-service` 积分服务中获取用户积分和增加积分的 API ：

@RestController
    @Slf4j
    public class LoyaltyController {
    
        /**
         * 获取用户当前积分
         * @param id 用户id
         */
        @GetMapping("/score/{id}")
        public Integer getScore(@PathVariable("id") Long id) {
            log.info("获取用户 id={} 当前积分", id);
            return 1800;
        }
    
        /**
         * 为当前用户增加积分
         * @param id 用户id
         * @param lastScore 用户当前积分
         * @param addScore 要增加的积分
         */
        @GetMapping("/addScore")
        public Integer addScore(@RequestParam(value = "id") Long id,
                                @RequestParam(value = "lastScore") Integer lastScore,
                                @RequestParam(value = "addScore") Integer addScore) {
            log.info("用户 id={} 增加 {} 积分", id, addScore);
            return lastScore + addScore;
        }
    }
    复制代码

`user-service` 通过 **OpenFeign** 调用积分服务：

FeignClient 类：

@Service
    @FeignClient("loyalty-service")
    public interface LoyaltyService {
    
        @GetMapping("/score/{id}")
        Integer getScore(@PathVariable("id") Long id);
    
        @GetMapping("/addScore")
        Integer addScore(@RequestParam(value = "id") Long id,
                         @RequestParam(value = "lastScore") Integer lastScore,
                         @RequestParam(value = "addScore") Integer addScore);
    }
    复制代码

Controller 调用：

@Slf4j
    @RestController
    @RequestMapping("/user")
    public class UserController {
        
        private LoyaltyService loyaltyService;
    
        @GetMapping("/score/{id}")
        public Integer getScore(@PathVariable("id") Long id) {
            return loyaltyService.getScore(id);
        }
    
        @GetMapping("/addScore")
        public Integer addScore(@RequestParam Long id,
                                @RequestParam Integer lastScore,
                                @RequestParam Integer addScore) {
            return loyaltyService.addScore(id, lastScore, addScore);
        }
    
        @Autowired
        public void setLoyaltyService(LoyaltyService loyaltyService) {
            this.loyaltyService = loyaltyService;
        }
    }
    复制代码

`order-service` 订单服务通过 **OpenFeign** 调用 `user-service` 和 `product-service` ：

FeignClient 类 ：

@Service
    @FeignClient("product-service")
    public interface ProductService {
        BigDecimal getPrice(@PathVariable("id") Long id);
    }
    复制代码

@Service
    @FeignClient("user-service")
    public interface UserService {
        /**
         * 由于 user-service 使用了统一返回结果，所以此处的返回值是 ResponseResult
         * @param id 用户id
         * @return ResponseResult<Integer>
         */
        @GetMapping("/user/score/{id}")
        ResponseResult<Integer> getScore(@PathVariable("id") Long id);
    
        /**
         * 由于 user-service 使用了统一返回结果，所以此处的返回值是 ResponseResult
         */
        @GetMapping("/user/addScore")
        ResponseResult<Integer> addScore(@RequestParam(value = "id") Long id,
                         @RequestParam(value = "lastScore") Integer lastScore,
                         @RequestParam(value = "addScore") Integer addScore);
    }
    复制代码

Controller 调用 ：

@Slf4j
    @RestController
    @RequestMapping("/order")
    public class OrderController {
    
        private UserService userService;
    
        private ProductService productService;
    
        @GetMapping("/create")
        public String createOrder(@RequestParam("userId") Long userId, @RequestParam("productId") Long productId) {
            log.info("创建订单参数，userId={}, productId={}", userId, productId);
            // 商品服务-获取价格
            BigDecimal price = productService.getPrice(productId);
            log.info("获得 price={}", price);
            // 用户服务-查询当前积分，增加积分
            Integer currentScore = userService.getScore(userId).getData();
            log.info("获得 currentScore={}", price);
            // 增加积分
            Integer addScore = price.intValue();
            Integer finalScore = userService.addScore(userId, currentScore, addScore).getData();
            log.info("下单成功，用户 id={} 最终积分：{}", userId, finalScore);
            return "下单成功，用户 id=" + userId + " 最终积分：" + finalScore;
        }
    
        @Autowired
        public void setUserService(UserService userService) {
            this.userService = userService;
        }
    
        @Autowired
        public void setProductService(ProductService productService) {
            this.productService = productService;
        }
    }
    复制代码

网关 `gateway-service` 配置 Nacos 注册中心和路由：

spring:
      cloud:
        nacos:
          discovery:
            server-addr: 192.168.242.112:81
        gateway:
          routes:
            - id: order-service
              uri: lb://order-service
              predicates:
                - Path=/order/**
    复制代码

启动网关以及其他四个服务，

![format_png 2][]

然后可以在 Nacos 中看到注册进来的实例：

![format_png 3][]

所有服务启动成功之后，通过网关调用下单 API ：

![format_png 4][]

整个调用链路没有问题。

### Spring Cloud Sleuth 的使用 ###

要想使用 **Sleuth** ，只需简单几个操作即可。

除了 `gateway-service` 网关服务，其他四个服务均执行以下步骤：

1，导入 `spring-cloud-starter-sleuth` 依赖：

<dependency>
        <groupId>org.springframework.cloud</groupId>
        <artifactId>spring-cloud-starter-sleuth</artifactId>
    </dependency>
    复制代码

2， `org.springframework.web.servlet.DispatcherServlet` 日志级别调整为 **DEBUG** ：

logging:
      level:
        org.springframework.web.servlet.DispatcherServlet: DEBUG
    复制代码

然后重启这四个服务，再次通过网关访问下单 API ，看到每个服务都打印了这样的日志：

user-service ：

![format_png 5][]

product-service ：

![format_png 6][]

loyalty-service ：

![format_png 7][]

order-service ：

![format_png 8][]

这样形式的日志：

# [服务名,总链路ID,子链路ID]
    [order-service,5eda5d7bdcca0118,5eda5d7bdcca0118]
    复制代码

就是整体的一个调用链路信息。

### Zipkin 服务部署与使用 ###

#### 部署 Zipkin 服务 ####

简单来说， **Zipkin** 是用来图形化展示 **Sleuth** 收集来的信息的。

Zipkin需要单独安装，它是一个 Java 编写的 Web 项目，我们使用 **Docker Compose** 进行部署安装 **Zipkin** 。

Tip：我已经非常体贴的把 **Docker Compose** 的使用分享了，详见： [用 docker-compose 部署服务真是好用，根本停不下来！][docker-compose] 。

部署步骤：

1，创建 `/usr/local/zipkin` 目录，进入到该目录：

mkdir /usr/local/zipkin
    cd /usr/local/zipkin
    复制代码

2，创建 `docker-compose.yml` 文件，文件内容如下：

version: "3"
    services:
      zipkin:
       image: openzipkin/zipkin
       restart: always
       container_name: zipkin
       ports:
         - 9411:9411
    复制代码

这是简化版的 `docker-compose.yml` 配置文件，这样的配置就能启动 **Zipkin** 。更多的配置详见： [github.com/openzipkin-…][github.com_openzipkin-] 。

3，使用 `docker-compose up -d` 命令（ `-d` 表示后台启动）启动：

![format_png 9][]

部署成功后，访问 **Zipkin** ，端口为 **9411** ，访问地址： `http://192.168.242.112:9411/zipkin/`

![format_png 10][]

这样，一个 **Zipkin** 服务就部署完成了。

#### 将 Sleuth 收集到的日志信息发送到 Zipkin ####

首先，还是需要在微服务项目中导入 **spring-cloud-sleuth-zipkin** 的依赖：

<dependency>
        <groupId>org.springframework.cloud</groupId>
        <artifactId>spring-cloud-starter-sleuth</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.cloud</groupId>
        <artifactId>spring-cloud-sleuth-zipkin</artifactId>
    </dependency>
    复制代码

然后，增加一些配置，让 **Sleuth** 收集的信息发送到 **Zipkin** 服务上：

spring:
      cloud:
        nacos:
          discovery:
            server-addr: 192.168.242.112:81
      sleuth:
        enabled: true
        sampler:
          # 设置 Sleuth 收集信息的百分比，一般情况下，10%就够用了，这里设置100%观察
          rate: 100
      zipkin:
        sender:
          type: web
        base-url: http://192.168.242.112:9411/
    复制代码

好了，再来启动每个服务，然后访问下单接口再看下 **Zipkin** 的面板。访问 `http://192.168.242.112:9411/zipkin/` ：

![format_png 11][]

可以看到有一个请求出来了，点击 `SHOW` 查看详情：

![format_png 12][]

可以清楚地看到调用链路上每一步的耗时。

### 小结 ###

Spring Cloud Sleuth结合 **Zipkin** 可以对每个微服务进行链路追踪，从而帮助我们分析服务间调用关系以及调用耗费的时间。

本文只简单介绍了通过 web 方式（配置项： `spring.zipkin.sender.type=web` ）：

![format_png 13][]

也就是通过 HTTP 的方式发送数据到 **Zipkin** ，如果请求量比较大，这种方式其实性能是比较低的，一般情况下我们都是通过消息中间件来发送，比如 **RabbitMQ** 。

如果日志数据量比较大，一般推荐拥有更高吞吐量的 **Kafka** 来进行日志推送。

这种方式就是让服务将 **Sleuth** 收集的日志推给 **MQ** ，让 **Zipkin** 去监控 **MQ** 的信息，通过 **MQ** 的队列获取到服务的信息。这样就提高了性能。

而日志的存储则可以采用 **Elasticsearch** 对数据进行持久化，这样可以保证 **Zipkin** 重启后，链路信息不会丢失。

下次有机会再分享一下如何通过 **MQ** 发送调用链数据信息以及使用 **Elasticsearch** 持久化数据，今天就到这里了。

[format_png]: https://img-blog.csdnimg.cn/img_convert/52905b80457dd3ce0ae22e883bfddd42.webp?x-oss-process=image/format,png
[spring.io_projects_sp]: https://link.juejin.cn/?target=https%3A%2F%2Fspring.io%2Fprojects%2Fspring-cloud-sleuth
[zipkin.io_pages_quick]: https://link.juejin.cn/?target=https%3A%2F%2Fzipkin.io%2Fpages%2Fquickstart.html
[format_png 1]: https://img-blog.csdnimg.cn/img_convert/8b0bef8c116345cd5aa5746849cb12e1.webp?x-oss-process=image/format,png
[github.com_ChenDapengJ]: https://link.juejin.cn/?target=https%3A%2F%2Fgithub.com%2FChenDapengJava%2FSpringCloudAlibabaDemo
[format_png 2]: https://img-blog.csdnimg.cn/img_convert/ee51d6e972faa719ec81f41731f65f55.webp?x-oss-process=image/format,png
[format_png 3]: https://img-blog.csdnimg.cn/img_convert/89247c567f1ada47541b189c491efb30.webp?x-oss-process=image/format,png
[format_png 4]: https://img-blog.csdnimg.cn/img_convert/be14b5d8e8aed815d7954fcce358ef32.webp?x-oss-process=image/format,png
[format_png 5]: https://img-blog.csdnimg.cn/img_convert/5cf4e412e7c46cc5d5b54469014194b1.webp?x-oss-process=image/format,png
[format_png 6]: https://img-blog.csdnimg.cn/img_convert/6d5549430b45657171e2f60a05338f1a.webp?x-oss-process=image/format,png
[format_png 7]: https://img-blog.csdnimg.cn/img_convert/e173812e41adc1221289eaef485bc713.webp?x-oss-process=image/format,png
[format_png 8]: https://img-blog.csdnimg.cn/img_convert/a5a7864099bfe017337ae6711539a725.webp?x-oss-process=image/format,png
[docker-compose]: https://juejin.cn/post/7136362901996044325
[github.com_openzipkin-]: https://link.juejin.cn/?target=https%3A%2F%2Fgithub.com%2Fopenzipkin-attic%2Fdocker-zipkin%2Fblob%2Fmaster%2Fdocker-compose.yml
[format_png 9]: https://img-blog.csdnimg.cn/img_convert/93efe4dbdc8025939ace0be849208bf2.webp?x-oss-process=image/format,png
[format_png 10]: https://img-blog.csdnimg.cn/img_convert/b36f67ffd204c3c749259f0c66ff4b66.webp?x-oss-process=image/format,png
[format_png 11]: https://img-blog.csdnimg.cn/img_convert/7dda7d69e46e69160391afe5bb3cde5f.webp?x-oss-process=image/format,png
[format_png 12]: https://img-blog.csdnimg.cn/img_convert/3d942fb1aef920185e8ee809e0157fcf.webp?x-oss-process=image/format,png
[format_png 13]: https://img-blog.csdnimg.cn/img_convert/94c046ef455b87b51c38bbc1ac68fccd.webp?x-oss-process=image/format,png