0Pricing
Advanced Spring Boot 4: Event-Driven Architecture (Kafka) · 课时

使用 Sleuth/Zipkin 进行分布式追踪

使用 Spring Cloud Sleuth 和 Zipkin 实现分布式追踪，跟踪事件在多个微服务之间的流转

使用 Sleuth/Zipkin 进行分布式追踪 是 CoddyKit 上的免费 Advanced Spring Boot 4: Event-Driven Architecture (Kafka) 课时。 这是第 3 节课，共 4 节。 你可以在下方免费阅读本课时的完整内容 — 然后在浏览器中使用内置代码编辑器和全天候 AI 导师进行实践。 这是 Advanced Spring Boot 4: Event-Driven Architecture (Kafka) 学习路径的一部分，你的进度在网页和 CoddyKit 应用中同步。 Advanced Spring Boot 4: Event-Driven Architecture (Kafka) 课程共包含 4 节课。

本课时的部分内容尚未翻译，以英文显示。

Why Trace Distributed Systems?

In a microservices architecture, a single user request often travels through many different services. This distributed nature makes it incredibly hard to track the flow of requests and pinpoint where issues occur.

Distributed tracing helps you visualize the full journey of a request across all services involved, making debugging and performance monitoring much easier.

Trace and Span: Your Navigation Tools

Distributed tracing relies on two core concepts:

  • Trace: Represents the complete journey of a request through a system, from start to finish. It's like a story of one operation.
  • Span: A single, logical unit of work within a trace. Each operation (e.g., an HTTP request, a database call, sending a Kafka message) gets its own span. Spans have parent-child relationships, showing cause and effect.

Meet Spring Cloud Sleuth

Spring Cloud Sleuth is a powerful library for Spring Boot applications that automatically adds distributed tracing capabilities. It instruments your application to generate, collect, and propagate trace information.

  • It automatically adds trace and span IDs to your logs.
  • It propagates these IDs across service boundaries (HTTP, messaging, etc.).

This means you don't have to manually manage trace IDs in most cases!

Getting Started: Add Sleuth & Zipkin

To integrate Spring Cloud Sleuth into your Spring Boot project, add the following dependencies to your pom.xml:

  • spring-cloud-starter-sleuth: The core tracing library.
  • spring-cloud-sleuth-zipkin: Integrates with Zipkin for trace visualization.
<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>

Minimal Sleuth Configuration

After adding the dependencies, a minimal configuration in your application.properties is usually enough to get started. Sleuth will automatically detect and configure itself.

To send traces to a Zipkin server, specify its URL:

spring.application.name=my-kafka-producer-app
spring.zipkin.base-url=http://localhost:9411
spring.sleuth.sampler.probability=1.0

Tracing Across Kafka Messages

One of Sleuth's key features is its ability to propagate trace context across messaging systems like Kafka. When you use Spring's KafkaTemplate to send messages:

  • Sleuth automatically injects trace and span IDs into the Kafka message headers.
  • When a @KafkaListener receives the message, Sleuth extracts these headers and continues the trace, linking the producer's span to the consumer's span.

This creates a continuous trace, even across asynchronous Kafka message flows.

Zipkin: See Your Traces

While Sleuth generates and propagates trace data, Zipkin is the distributed tracing system that collects, stores, and visualizes this data. It provides a user interface where you can:

  • Search for traces by service name, timestamp, or trace ID.
  • View a Gantt chart representation of a trace, showing the sequence and duration of spans.
  • Identify performance bottlenecks and errors across your microservices.

Spin Up Zipkin Locally

For local development and testing, you can easily run a Zipkin server using Docker. This provides a quick way to see your traces without complex setup.

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

Producer with Sleuth Instrumentation

Here's a simple Spring Boot Kafka producer. With Sleuth and Zipkin configured (as shown in earlier scenes), when you run this, Sleuth will automatically add tracing headers to the Kafka message. You would see the traceId and spanId in your application logs and in the Zipkin UI.

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.kafka.core.KafkaTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;

@SpringBootApplication
@RestController
public class SleuthKafkaProducerApplication {

    @Autowired
    private KafkaTemplate<String, String> kafkaTemplate;

    private static final String TOPIC = "my-traceable-topic";

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

    @GetMapping("/send")
    public String sendMessage(@RequestParam("message") String message) {
        kafkaTemplate.send(TOPIC, message);
        return "Message sent with trace context: " + message;
    }
}

Quick Check: Tracing Concepts

When a Spring Boot application with Spring Cloud Sleuth sends a message to Kafka, which of the following statements are true about trace information?

Lesson Summary: Tracing Your Flow

You've learned about distributed tracing, a critical technique for understanding complex microservice interactions. We covered:

  • The concepts of Trace (full request journey) and Span (individual operation).
  • How Spring Cloud Sleuth automatically instruments Spring Boot applications, including Kafka producers and consumers, to propagate tracing context.
  • The role of Zipkin in collecting and visualizing these traces, providing invaluable insights into your system's behavior.

With these tools, you can effectively monitor and debug your event-driven microservices!

常见问题解答

「使用 Sleuth/Zipkin 进行分布式追踪」课时是免费的吗？

是的 — 「使用 Sleuth/Zipkin 进行分布式追踪」的完整文本可在网页上免费阅读。要进行交互式练习（内置代码编辑器和全天候 AI 导师）并解锁 Advanced Spring Boot 4: Event-Driven Architecture (Kafka) 课程的其余内容，请升级到 CoddyKit PRO。 Advanced Spring Boot 4: Event-Driven Architecture (Kafka) 课程共包含 4 节课。

「使用 Sleuth/Zipkin 进行分布式追踪」这节课中我会学到什么？

使用 Spring Cloud Sleuth 和 Zipkin 实现分布式追踪，跟踪事件在多个微服务之间的流转 你通过在浏览器中直接运行的动手代码来练习 Advanced Spring Boot 4: Event-Driven Architecture (Kafka)，全天候 AI 导师会在你学习这节课的过程中回答你的问题。

学习 Advanced Spring Boot 4: Event-Driven Architecture (Kafka) 需要有经验吗？

无需任何先前经验。CoddyKit 上的 Advanced Spring Boot 4: Event-Driven Architecture (Kafka) 课程适合初学者到高级学习者，你可以从这里开始或从头开始，按照自己的节奏学习。 这是第 3 节课，共 4 节。

「使用 Sleuth/Zipkin 进行分布式追踪」课时需要多长时间？

大多数 CoddyKit 课程大约需要 5–10 分钟。每节课都很精短且互动，所以你能稳步进步，并在网页和应用中从离开的地方继续。

我能在这节 Advanced Spring Boot 4: Event-Driven Architecture (Kafka) 课中编写并运行代码吗？

能。每节 Advanced Spring Boot 4: Event-Driven Architecture (Kafka) 课都包含内置代码编辑器，你可以在浏览器中直接编写并运行真实代码，并获得即时 AI 反馈 — 无需本地设置。

此课程中的所有课时

  1. Kafka 指标（JMX）与健康检查
  2. 集成 Prometheus 和 Grafana
  3. 使用 Sleuth/Zipkin 进行分布式追踪
  4. 监控消费者滞后并设置告警
← 返回 Advanced Spring Boot 4: Event-Driven Architecture (Kafka)