Spring Cloud Sleuth
的主要功能就是为 分布式系统 提供 追踪解决方案,并且兼容支持了 Zipkin
,只需要在 pom.xml
文件中引入相应的 依赖 即可。本文主要讲述 服务追踪组件 Zipkin
,Spring Cloud Sleuth
集成了 Zipkin
组件。它主要用于 聚集 来自各个 异构系统 的 实时监控数据,用来追踪 微服务架构 下的 系统延时问题。
Span
是一个基本的 工作单元,用于描述一次 RPC
调用,Span
通过一个 64
位的 spanId
作为 唯一标识。Zipkin
中的 Span
还有其他数据信息,比如 摘要、时间戳事件、关键值注释 (tags
) 以及 进度 ID
(通常是 IP
地址)。Span
在不断的启动和停止,同时记录了 时间信息,一个 Span
创建后,必须在未来的某个时刻停止它。
一系列 Span
组成的一个 树状结构。例如,如果你正在跑一个大型 分布式系统,可能需要创建一个 Trace
。
表示 基本标注列表,一个 Annotation
可以理解成 Span
生命周期中 重要时刻 的 数据快照,比如一个 Annotation
中一般包含 发生时刻(timestamp
)、事件类型(value
)、端点(endpoint
)等信息。其中 Annotation
的 事件类型 包含以下四类:
客户端 发起一个请求,这个 Annotion
描述了这个 Span
的开始。
服务端 获得请求并 准备开始 处理它,如果将 sr
减去 cs
的 时间戳 便可得到 网络延迟。
服务端 完成请求处理,如果将 ss
减去 sr
的 时间戳,便可得到 服务端 处理请求消耗的时间。
客户端 成功接收到 服务端 的响应,如果将 cr
减去 cs
的 时间戳,便可得到 整个请求 所消耗的 总时间。
本文案例主要由 四个模块 组成:
eureka-server:作为 服务注册中心。
zipkin-server:作为 链路追踪服务中心,负责存储 链路数据。
service-hi:对外暴露一个 测试接口,同时作为 链路追踪 的 服务端,负责 产生链路数据。
service-zuul:作为 路由网关,负责 请求转发,同时作为 链路追踪 的 客户端,产生 链路数据,并上传至 zipkin-server
。
在 8761
端口 开启 eureka-server
服务注册中心,参考前面的文章即可,这里不再演示创建。
新建一个 Spring Boot
应用模块 zipkin-server
,它的 pom.xml
完整依赖如下:
<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.0modelVersion>
<parent>
<groupId>org.springframework.bootgroupId>
<artifactId>spring-boot-starter-parentartifactId>
<version>1.5.3.RELEASEversion>
<relativePath/>
parent>
<groupId>io.github.ostenant.springcloudgroupId>
<artifactId>zipkin-serverartifactId>
<version>0.0.1-SNAPSHOTversion>
<name>zipkin-servername>
<description>Demo project for Spring Bootdescription>
<properties>
<java.version>1.8java.version>
<spring-cloud.version>Dalston.RELEASEspring-cloud.version>
properties>
<dependencies>
<dependency>
<groupId>org.springframework.cloudgroupId>
<artifactId>spring-cloud-starter-eurekaartifactId>
dependency>
<dependency>
<groupId>io.zipkin.javagroupId>
<artifactId>zipkin-serverartifactId>
dependency>
<dependency>
<groupId>io.zipkin.javagroupId>
<artifactId>zipkin-autoconfigure-uiartifactId>
dependency>
<dependency>
<groupId>org.springframework.bootgroupId>
<artifactId>spring-boot-starter-testartifactId>
<scope>testscope>
dependency>
dependencies>
<dependencyManagement>
<dependencies>
<dependency>
<groupId>org.springframework.cloudgroupId>
<artifactId>spring-cloud-dependenciesartifactId>
<version>${spring-cloud.version}version>
<type>pomtype>
<scope>importscope>
dependency>
dependencies>
dependencyManagement>
<build>
<plugins>
<plugin>
<groupId>org.springframework.bootgroupId>
<artifactId>spring-boot-maven-pluginartifactId>
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
新建一个 Spring Boot
应用模块 service-hi
,在它的 pom.xml
中引入 引入起步依赖 spring-cloud-starter-zipkin
,完整依赖如下:
<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.0modelVersion>
<parent>
<groupId>org.springframework.bootgroupId>
<artifactId>spring-boot-starter-parentartifactId>
<version>1.5.3.RELEASEversion>
<relativePath/>
parent>
<groupId>io.github.ostenant.springcloudgroupId>
<artifactId>service-hiartifactId>
<version>0.0.1-SNAPSHOTversion>
<name>eureka-clientname>
<description>Demo project for Spring Bootdescription>
<properties>
<java.version>1.8java.version>
<spring-cloud.version>Dalston.SR1spring-cloud.version>
properties>
<dependencies>
<dependency>
<groupId>org.springframework.cloudgroupId>
<artifactId>spring-cloud-starter-eurekaartifactId>
dependency>
<dependency>
<groupId>org.springframework.cloudgroupId>
<artifactId>spring-cloud-starter-zipkinartifactId>
dependency>
<dependency>
<groupId>org.springframework.bootgroupId>
<artifactId>spring-boot-starter-webartifactId>
dependency>
<dependency>
<groupId>org.springframework.bootgroupId>
<artifactId>spring-boot-starter-testartifactId>
<scope>testscope>
dependency>
dependencies>
<dependencyManagement>
<dependencies>
<dependency>
<groupId>org.springframework.cloudgroupId>
<artifactId>spring-cloud-dependenciesartifactId>
<version>${spring-cloud.version}version>
<type>pomtype>
<scope>importscope>
dependency>
dependencies>
dependencyManagement>
<build>
<plugins>
<plugin>
<groupId>org.springframework.bootgroupId>
<artifactId>spring-boot-maven-pluginartifactId>
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;
}
}
新建一个 Spring Boot
应用模块 service-zuul
,在 pom.xml
中引入依赖 spring-cloud-starter-zipkin
,完整依赖如下:
<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.0modelVersion>
<parent>
<groupId>org.springframework.bootgroupId>
<artifactId>spring-boot-starter-parentartifactId>
<version>1.5.3.RELEASEversion>
<relativePath/>
parent>
<groupId>io.github.ostenant.springcloudgroupId>
<artifactId>service-zuulartifactId>
<version>0.0.1-SNAPSHOTversion>
<name>service-zuulname>
<description>Demo project for Spring Bootdescription>
<properties>
<java.version>1.8java.version>
<spring-cloud.version>Dalston.SR1spring-cloud.version>
properties>
<dependencies>
<dependency>
<groupId>org.springframework.cloudgroupId>
<artifactId>spring-cloud-starter-eurekaartifactId>
dependency>
<dependency>
<groupId>org.springframework.cloudgroupId>
<artifactId>spring-cloud-starter-zuulartifactId>
dependency>
<dependency>
<groupId>org.springframework.bootgroupId>
<artifactId>spring-boot-starter-webartifactId>
dependency>
<dependency>
<groupId>org.springframework.cloudgroupId>
<artifactId>spring-cloud-starter-zipkinartifactId>
dependency>
<dependency>
<groupId>org.springframework.bootgroupId>
<artifactId>spring-boot-starter-testartifactId>
<scope>testscope>
dependency>
dependencies>
<dependencyManagement>
<dependencies>
<dependency>
<groupId>org.springframework.cloudgroupId>
<artifactId>spring-cloud-dependenciesartifactId>
<version>${spring-cloud.version}version>
<type>pomtype>
<scope>importscope>
dependency>
dependencies>
dependencyManagement>
<build>
<plugins>
<plugin>
<groupId>org.springframework.bootgroupId>
<artifactId>spring-boot-maven-pluginartifactId>
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);
}
}
完整 链路追踪模块 搭建完毕,总结一下:
搭建一台 zipkin server
作为 链路服务中心。
给各个 服务 引入 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
按钮,可以查看服务的 依赖关系。
现在需要实现一个功能:在 链路数据 中加上请求的 操作人。本案例在 service-zuul
网关服务 中实现。
新建一个 ZuulFilter
过滤器,它的类型为 post
类型,order
为 900
,开启 拦截功能。
在过滤器的 拦截逻辑方法 run()
里面,通过 Tracer
的 addTag()
方法加上 自定义 的数据,在本案例中加上了链路的 操作人。
也可以在这个 过滤器 中获取 当前链路 的 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;
}
}
首先改造 zipkin-server
项目模块,在它的 pom.xml
文件中将 zipkin-server
的依赖去掉,加上
spring-cloud-sleuth-zipkin-stream
和 spring-cloud-starter-stream-rabbit
的依赖,配置如下:
<dependency>
<groupId>org.springframework.cloudgroupId>
<artifactId>spring-cloud-sleuth-zipkin-streamartifactId>
dependency>
<dependency>
<groupId>org.springframework.cloudgroupId>
<artifactId>spring-cloud-starter-stream-rabbitartifactId>
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.cloudgroupId>
<artifactId>spring-cloud-sleuth-zipkin-streamartifactId>
dependency>
<dependency>
<groupId>org.springframework.cloudgroupId>
<artifactId>spring-cloud-starter-stream-rabbitartifactId>
dependency>
和前面的 zipkin-server
模块一样,同时在配置文件 applicayion.yml
加上 RabbitMQ
的配置。这样,就将链路的 数据上传 从 HTTP
改为用 消息代组件 RabbitMQ
的方式。
在上面的例子中,Zipkin Server
将数据存储在 内存 中,一旦应用服务 重启,之前的 链路数据全部丢失,这时候就需要引入 持久化机制。Zipkin
支持将 链路数据 存储在 MySQL
、Elasticsearch
和 Cassandra
数据库中。本节讲解如何使用 MySQL
存储。
Zipkin Client
有两种方式将 链路数据 传输到 Zipkin Server
中,一种是使用 HTTP
,另一种是使用 RabbitMQ
。Zipkin Server
通过这两种方式来 收集链路数据,并存储在 MySQL
中。
在 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.javagroupId>
<artifactId>zipkin-serverartifactId>
<version>1.19.0version>
dependency>
<dependency>
<groupId>io.zipkin.javagroupId>
<artifactId>zipkin-storage-mysqlartifactId>
<version>1.19.0version>
dependency>
<dependency>
<groupId>io.zipkin.javagroupId>
<artifactId>zipkin-autoconfigure-uiartifactId>
dependency>
<dependency>
<groupId>mysqlgroupId>
<artifactId>mysql-connector-javaartifactId>
dependency>
<dependency>
<groupId>org.springframework.bootgroupId>
<artifactId>spring-boot-starter-jdbcartifactId>
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
数据库中。
本节的案例是在使用 RabbitMQ
传输数据 基础上进行改造的,只需要改造 zipkin-server
的工程。
在 zipkin-server
工程的 pom.xml
文件中加上 MySQL
的 连接器依赖 mysql-connector-java
和 JDBC
的 起步依赖 spring-boot-starter-jdbc
,代码如下:
<dependency>
<groupId>mysqlgroupId>
<artifactId>mysql-connector-javaartifactId>
dependency>
<dependency>
<groupId>org.springframework.bootgroupId>
<artifactId>spring-boot-starter-jdbcartifactId>
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
数据库中初始化 数据库脚本,具体同上一节。
在 并发高 的情况下,使用 MySQL
存储 链路数据 显然不合理,这时可以选择使用 ElasticSearch
作为存储。
下载并安装 ElasticSearch
和 Kibana
,下载地址为 https://www.elastic.co/products/elasticsearch。安装完成后启动,其中 ElasticSearch
的 默认端口号 为 9200
,Kibana
的 默认端口号 为 5601
。
本节是在 第八节 的基础上进行改造。首先在 pom.xml
文件中加上 zipkin
的依赖和 zipkin-autoconfigure-storage-elasticsearch-http
的依赖,代码如下:
<dependency>
<groupId>io.zipkin.javagroupId>
<artifactId>zipkinartifactId>
<version>1.28.1version>
dependency>
<dependency>
<groupId>io.zipkin.javagroupId>
<artifactId>zipkin-autoconfigure-storage-elasticsearch-httpartifactId>
<version>1.28.1version>
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
里面。
上一节讲述了如何将 链路数据 存储在 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
,页面上出现 链路数据。
欢迎关注技术公众号: 零壹技术栈
本帐号将持续分享后端技术干货,包括虚拟机基础,多线程编程,高性能框架,异步、缓存和消息中间件,分布式和微服务,架构学习和进阶等学习资料和文章。