Zipkin部署

最新推荐文章于 2024-08-29 09:41:27 发布
最新推荐文章于 2024-08-29 09:41:27 发布
阅读量1.7k 收藏
点赞数
分类专栏： 框架源码研究

背景

系统中已存在以下三种类型的应用：

- 采用Spring boot开发
- 采用传统的Spring Web开发
- 采用CXF开发

随着系统复杂性增多，现在需要引入Zipkin来监测系统中各节点的链路耗时。

功能特性

  1. 采用Kafka作为数据收集器
    • 支持Sleuth采集方式
    • 支持Brave采集方式
  2. 采用ElasticSearch作为数据源

搭建Zipkin服务器

  1. maven 依赖
<dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-actuator</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-stream-binder-kafka</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-sleuth-zipkin-stream</artifactId>
        </dependency>
        <dependency>
            <groupId>io.zipkin.java</groupId>
            <artifactId>zipkin-autoconfigure-ui</artifactId>
            <version>${zipkin.version}</version>
        </dependency>
        <dependency>
            <groupId>io.zipkin.java</groupId>
            <artifactId>zipkin-collector-kafka10</artifactId>
            <version>${zipkin.version}</version>
        </dependency>
        <dependency>
            <groupId>io.zipkin.java</groupId>
            <artifactId>zipkin</artifactId>
            <version>${zipkin.version}</version>
        </dependency>
        <dependency>
            <groupId>io.zipkin.java</groupId>
            <artifactId>zipkin-server</artifactId>
            <version>${zipkin.version}</version>
        </dependency>
        <dependency>
            <groupId>io.zipkin.java</groupId>
            <artifactId>zipkin-autoconfigure-storage-elasticsearch-http</artifactId>
            <version>${zipkin.version}</version>
        </dependency>
        <dependency>
            <groupId>org.apache.zookeeper</groupId>
            <artifactId>zookeeper</artifactId>
            <version>${zookeeper.version}</version>
        </dependency>
  1. Zipkin应用实例
@EnableZipkinStreamServer
@SpringBootApplication
public class Application {

  @Autowired
  private StorageComponent storageComponent;

  @Autowired
  private BraveKafka braveKafka;

  @Bean
  public KafkaCollector kafka() {
    return KafkaCollector.builder()
        .bootstrapServers(braveKafka.getBootstrapServers())
        .topic(braveKafka.getTopic()).storage(storageComponent).build().start();
  }

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

部署配置

spring:
  application:
    name: qianfan-zipkin
  cloud:
    stream:
      kafka:
        binder:
          brokers: pgpool.hd.com:19092,pgdb1.hd.com:19092,pgdb2.hd.com:19092 #Sleuth方式收集
          zkNodes: pgpool.hd.com:12181,pgdb1.hd.com:12181,pgdb2.hd.com:12181
      bindings:
        sleuth:
          destination: sleuth-test #Sleuth方式收集
braveKafka:
  bootstrapServers: ${spring.cloud.stream.kafka.binder.brokers}
  topic: sleuth-test2 #Brave方式收集
zipkin:
  storage:
    elasticsearch:
      cluster: xxxxxx
      index: xxxxx
      hosts: 118.xxx.xx.xx:9200
      username: xxxxx
      password: xxxxxxx

应用接入

Spring Boot接入

  1. 在maven中增加依赖
    <dependency>
        <groupId>org.springframework.cloud</groupId>
        <artifactId>spring-cloud-starter-sleuth</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.cloud</groupId>
        <artifactId>spring-cloud-sleuth-stream</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.cloud</groupId>
        <artifactId>spring-cloud-stream-binder-kafka</artifactId>
    </dependency>
    <dependency>
        <groupId>org.apache.zookeeper</groupId>
        <artifactId>zookeeper</artifactId>
    </dependency>
  1. 在application.yml中增加以下配置
spring:
  cloud:
    stream:
      kafka:
        binder:
          brokers: pgpool.hd.com:19092,pgdb1.hd.com:19092,pgdb2.hd.com:19092
          zkNodes: pgpool.hd.com:12181,pgdb1.hd.com:12181,pgdb2.hd.com:12181
      bindings:
        sleuth:
          destination: sleuth-test
logging:
  level:
    org.springframework.web: DEBUG
  1. 建议应用本身不再指定日志输出格式，默认使用sleuth的日志格式，与zipkin统一。

Spring Web与CFX接入

理论上CXF可以直接使用Brave接入，但是官方最新的Brave只支持jax-rs版本为2.0.1且要求JDK>=1.8。而我本地的JDK=1.7，jax-rs版本为2.0-m10，所以采取了折衷方案，只使用brave jaxrs2中的两个过滤器。

  1. maven中新增：
      <properties>  
        <brave.version>4.7.2</brave.version>
        <zipkin-reporter.version>1.1.2</zipkin-reporter.version>
      </properties>
      
      <dependency>
        <groupId>io.zipkin.brave</groupId>
        <artifactId>brave</artifactId>
        <version>${brave.version}</version>
      </dependency>
      <dependency>
        <groupId>io.zipkin.reporter</groupId>
        <artifactId>zipkin-reporter</artifactId>
        <version>${zipkin-reporter.version}</version>
      </dependency>
      <dependency>
        <groupId>io.zipkin.reporter</groupId>
        <artifactId>zipkin-sender-kafka10</artifactId>
        <version>${zipkin-reporter.version}</version>
      </dependency>
      <dependency>
        <groupId>io.zipkin.brave</groupId>
        <artifactId>brave-context-log4j2</artifactId>
        <version>${brave.version}</version>
      </dependency>
      
      <!-- 拦截spring web必须　-->
      <dependency>
        <groupId>io.zipkin.brave</groupId>
        <artifactId>brave-instrumentation-spring-web</artifactId>
        <version>${brave.version}</version>
      </dependency>
      <dependency>
        <groupId>io.zipkin.brave</groupId>
        <artifactId>brave-instrumentation-spring-webmvc</artifactId>
        <version>${brave.version}</version>
      </dependency>
      
      
      <!-- 拦截jax-rs必须　-->
      <dependency>
        <groupId>io.zipkin.brave</groupId>
        <artifactId>brave-instrumentation-jaxrs2</artifactId>
        <version>${brave.version}</version>
      </dependency>
  1. 引入配置定义
import brave.Tracing;
import brave.context.log4j2.ThreadContextCurrentTraceContext;
import brave.http.HttpTracing;
import brave.sampler.Sampler;
import brave.spring.web.TracingClientHttpRequestInterceptor;
import brave.spring.webmvc.TracingHandlerInterceptor;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.http.client.ClientHttpRequestInterceptor;
import org.springframework.web.client.RestTemplate;
import zipkin.Span;
import zipkin.reporter.AsyncReporter;
import zipkin.reporter.Sender;
import zipkin.reporter.kafka10.KafkaSender;
import javax.annotation.PostConstruct;
import java.util.ArrayList;
import java.util.List;
@Configuration
public class WebTracingConfiguration {
    @Bean
    Sender sender() {
        return KafkaSender.builder().bootstrapServers("pgpool.hd.com:19092,pgdb1.hd.com:19092,pgdb2.hd.com:19092").topic("sleuth-test2").build();
    }

    /**
     * 用什么方式显示span信息
     */
    @Bean
    AsyncReporter<Span> spanReporter() {
        return AsyncReporter.create(sender());
    }

    @Bean
    Tracing tracing() {
        return Tracing.newBuilder()
                .localServiceName("dpos-web").reporter(spanReporter())
                .currentTraceContext(ThreadContextCurrentTraceContext.create()) // puts trace IDs into logs
                .sampler(Sampler.create(1f)).build();
    }

    // decides how to name and tag spans. By default they are named the same as the http method.
    @Bean
    HttpTracing httpTracing(Tracing tracing) {
        return HttpTracing.create(tracing);
    }

    // 拦截spring web
    @Bean
    TracingHandlerInterceptor serverInterceptor(HttpTracing tracing) {
        return (TracingHandlerInterceptor) TracingHandlerInterceptor.create(tracing);
    }
    
    //　拦截jax-rs 服务端
    @Bean(name = "tracingContainerFilter")
    TracingContainerFilter tracingContainerFilter(HttpTracing tracing) {
        return new TracingContainerFilter(tracing);
    }
    
    //　拦截jax-rs 客户端
    @Bean(name = "tracingClientFilter")
    TracingClientFilter tracingClientFilter(HttpTracing tracing) {
        return new TracingClientFilter(tracing);
    }
    

    // 拦截spring template
    @Bean
    TracingClientHttpRequestInterceptor clientInterceptor(HttpTracing tracing) {
        return (TracingClientHttpRequestInterceptor) TracingClientHttpRequestInterceptor.create(tracing);
    }
    
    @Autowired
    private RestTemplate restTemplate;

    /**
     * adds tracing to the application-defined rest template
     */
    @PostConstruct
    public void init() {
        List<ClientHttpRequestInterceptor> interceptors =
                new ArrayList<>(restTemplate.getInterceptors());
        interceptors.add(clientInterceptor(httpTracing(tracing())));
        restTemplate.setInterceptors(interceptors);
    }
}
  1. 在spring web xml中加入拦载
    <mvc:interceptors>
        <bean class="brave.spring.webmvc.TracingHandlerInterceptor"/>
    </mvc:interceptors>
  1. 在jax-rs服务中加入拦载
    <jaxrs:server id="dpos-auth-service.rsServices" address="/">
        <jaxrs:serviceBeans>
        <bean class="com.hd123.dpos.auth.rs.service.notification.RSSubscriptionConfigServiceImpl"
            p:service-ref="subscriptionConfigServiceImpl"
            p:codecBean-ref="dpos-auth-service.codecBean" />
        </jaxrs:serviceBeans>
        <jaxrs:providers>
            <ref bean="tracingContainerFilter" /> <!-- 拦截 -->
        </jaxrs:providers>
    </jaxrs:server>
  1. 在jax-rs客户端中加入拦截
  <jaxrs-client:client id="dpos-auth-api.rs.shopService"
    address="${dpos-auth-api.server.url:http://localhost:8080/dpos-auth-web}"
    serviceClass="com.hd123.dpos.auth.rs.api.shop.RSShopService">
    <jaxrs-client:providers>
      <ref bean="dpos-auth-api.jsonProvider" />
      <ref bean="tracingClientFilter"/> <!-- 拦截 -->
    </jaxrs-client:providers>
  </jaxrs-client:client>
  1. 实现jax-rs过滤器，来自官方的brave jaxrs2包中。
import brave.Span;
import brave.Tracer;
import brave.Tracer.SpanInScope;
import brave.http.HttpClientHandler;
import brave.http.HttpTracing;
import brave.propagation.Propagation;
import brave.propagation.TraceContext;
import javax.ws.rs.ConstrainedTo;
import javax.ws.rs.client.ClientRequestContext;
import javax.ws.rs.client.ClientRequestFilter;
import javax.ws.rs.client.ClientResponseContext;
import javax.ws.rs.client.ClientResponseFilter;
import javax.ws.rs.core.MultivaluedMap;
import javax.ws.rs.ext.Provider;
import static javax.ws.rs.ConstrainedTo.Type.CLIENT;
@Provider
@ConstrainedTo(CLIENT)
public class TracingClientFilter implements ClientRequestFilter, ClientResponseFilter {
    static final Propagation.Setter<MultivaluedMap, String> SETTER = new Propagation.Setter<MultivaluedMap, String>() {
        @Override
        public void put(MultivaluedMap carrier, String key, String value) {
            carrier.putSingle(key, value);
        }
    };

    final Tracer tracer;
    final HttpClientHandler<ClientRequestContext, ClientResponseContext> handler;
    final TraceContext.Injector<MultivaluedMap> injector;

    public TracingClientFilter(HttpTracing httpTracing) {
        if (httpTracing == null) throw new NullPointerException("HttpTracing == null");
        tracer = httpTracing.tracing().tracer();
        handler = HttpClientHandler.create(httpTracing, new HttpAdapter());
        injector = httpTracing.tracing().propagation().injector(SETTER);
    }

    @Override
    public void filter(ClientRequestContext request) {
        Span span = handler.handleSend(injector, request.getHeaders(), request);
        request.setProperty(SpanInScope.class.getName(), tracer.withSpanInScope(span));
    }

    @Override
    public void filter(ClientRequestContext request, ClientResponseContext response) {
        Span span = tracer.currentSpan();
        if (span == null) return;
        ((SpanInScope) request.getProperty(SpanInScope.class.getName())).close();
        handler.handleReceive(response, null, span);
    }

    static final class HttpAdapter
            extends brave.http.HttpClientAdapter<ClientRequestContext, ClientResponseContext> {

        @Override
        public String method(ClientRequestContext request) {
            return request.getMethod();
        }

        @Override
        public String path(ClientRequestContext request) {
            return request.getUri().getPath();
        }

        @Override
        public String url(ClientRequestContext request) {
            return request.getUri().toString();
        }

        @Override
        public String requestHeader(ClientRequestContext request, String name) {
            return request.getHeaderString(name);
        }

        @Override
        public Integer statusCode(ClientResponseContext response) {
            return response.getStatus();
        }
    }
}

import brave.Span;
import brave.Tracer;
import brave.http.HttpServerHandler;
import brave.http.HttpTracing;
import brave.jaxrs2.ContainerAdapter;
import brave.propagation.Propagation;
import brave.propagation.TraceContext;
import javax.ws.rs.ConstrainedTo;
import javax.ws.rs.container.*;
import javax.ws.rs.core.Context;
import javax.ws.rs.ext.Provider;
import java.lang.annotation.Annotation;
import static javax.ws.rs.ConstrainedTo.Type.SERVER;
@Provider
@ConstrainedTo(SERVER)
public class TracingContainerFilter implements ContainerRequestFilter, ContainerResponseFilter {

    final Tracer tracer;
    final HttpServerHandler<ContainerRequestContext, ContainerResponseContext> handler;
    final TraceContext.Extractor<ContainerRequestContext> extractor;

    public TracingContainerFilter(HttpTracing httpTracing) {
        tracer = httpTracing.tracing().tracer();
        handler = HttpServerHandler.create(httpTracing, new ContainerAdapter());
        extractor = httpTracing.tracing().propagation()
                .extractor(new Propagation.Getter<ContainerRequestContext, String>() {
                    @Override
                    public String get(ContainerRequestContext carrier, String key) {
                        return carrier.getHeaderString(key);
                    }
                });
    }

    /**
     * This implementation peeks to see if the request is async or not, which means {@link
     * PreMatching} cannot be used: pre-matching doesn't inject the resource info!
     */
    @Context
    ResourceInfo resourceInfo;

    @Override
    public void filter(ContainerRequestContext request) {
        if (resourceInfo != null) request.setProperty(ResourceInfo.class.getName(), resourceInfo);
        Span span = handler.handleReceive(extractor, request);
        request.removeProperty(ResourceInfo.class.getName());
        if (shouldPutSpanInScope(resourceInfo)) {
            request.setProperty(Tracer.SpanInScope.class.getName(), tracer.withSpanInScope(span));
        } else {
            request.setProperty(Span.class.getName(), span);
        }
    }

    @Override
    public void filter(ContainerRequestContext request, ContainerResponseContext response) {
        Span span = (Span) request.getProperty(Span.class.getName());
        Tracer.SpanInScope spanInScope = (Tracer.SpanInScope) request.getProperty(Tracer.SpanInScope.class.getName());
        if (span != null) { // asynchronous response or we couldn't figure it out
        } else if (spanInScope != null) { // synchronous response
            span = tracer.currentSpan();
            spanInScope.close();
        } else if (response.getStatus() == 404) {
            span = handler.handleReceive(extractor, request);
        } else {
            return; // unknown state
        }
        handler.handleSend(response, null, span);
    }

    /**
     * We shouldn't put a span in scope unless we know for sure the request is not async. That's
     * because we cannot detach if from the calling thread when async is used.
     */
    // TODO: add benchmark and cache if slow
    static boolean shouldPutSpanInScope(ResourceInfo resourceInfo) {
        if (resourceInfo == null) return false;
        for (Annotation[] annotations : resourceInfo.getResourceMethod().getParameterAnnotations()) {
            for (Annotation annotation : annotations) {
                if (annotation.annotationType().equals(Suspended.class)) {
                    return false;
                }
            }
        }
        return true;
    }
}

小礼物走一走，来简书关注我



作者：neilspears
链接：https://www.jianshu.com/p/41b39d6a9b2b
来源：简书
简书著作权归作者所有，任何形式的转载都请联系作者获得授权并注明出处。

zhousenshan
关注
专栏目录
SpringCloud Alibaba系列 Sleuth Zipkin（五）
又逢乱世
11-05 898
springcloud 链路追踪 Sleuth Zipkin
zipkin部署
架构师与哈苏
12-07 227
官网:https://zipkin.io/ java方式启动 curl -sSL https://zipkin.io/quickstart.sh | bash -s java -jar zipkin.jar 访问:http://your_host:9411 spring整合zipkin代码:gitee代码
探索高效追踪：Zipkin Reporter Java 项目深度解析
最新发布
gitblog_00728的博客
08-29 554
探索高效追踪：Zipkin Reporter Java 项目深度解析 zipkin-reporter-javaShared library for reporting zipkin spans on transports such as http or kafka项目地址:https://gitcode.com/gh_mirrors/zi/zipkin-reporter-java 在微服务架构日...
Zipkin 服务端部署
xu990128638的专栏
08-08 547
Zipkin 服务端部署 Zipkin 服务端部署非常简单，可以通过官网快速上手。 https://zipkin.io/pages/quickstart.html 1. 下载 Zipkin 最新 Jar 包 user@user-PC:/data$ curl -sSL https://zipkin.io/quickstart.sh | bash -s Thank you for trying Zipkin! This installer is provided as a quick-start helper,
K8S - 集群中部署Zipkin
迦南的专栏
04-22 4019
一、链路追踪部署流程 这里有两种部署流程，这里简单介绍下： 1、两种日志采集方式 方式一： 将链路日志直接推送到 Zipkin Server 进行聚合，存储到 ElasticSearch 中，最后再用 Zipkin UI 展示链路过程。 方式二： 将链路日志推送到 Kafka，然后启动 Zipkin Server 聚合日志，监听 Kafka ，如果有新的消息则进行拉取存入到 ElasticSeach，最后再用 Zipkin UI 展示链路过程。 两种方式的比较： 第一种方式使用与配置起来比较简单，并且
CentOS下zipkin部署
mojolang
05-04 1490
Zipkin 是 Twitter 的一个开源项目，允许开发者收集 Twitter 各个服务上的监控数据，并提供查询接口。zipkin是Twitter基于Google的Dapper这篇论文编写的，因为是Twitter做的东西，很多依赖包都已经被墙，所以在编译、部署的时候一定要翻墙。 前期环境准备 zipkin用scala语言编写的，使用Cassandra数据库作为存储，所以在环境上我们要准备ja...
SpringCloud可视化链路追踪系统Zipkin部署过程
08-19
SpringCloud 可视化链路追踪系统 Zipkin 部署过程 本文主要介绍了 SpringCloud 可视化链路追踪系统 Zipkin 部署过程，并提供了详细的示例代码，对大家的学习或者工作具有一定的参考学习价值。 什么是 Zipkin？ ...
Zipkin部署与SpringBoot集成
.
11-04 902
文章目录Zipkin一、入门Docker部署与SpringBoot集成over Zipkin 一、入门 OpenZipkin · A distributed tracing system ​ Zipkin 是 Twitter 的一个开源项目，它基于 Google Dapper 实现，它致力于收集服务的定时数据，以解决微服务架构中的延迟问题，包括数据的收集、存储、查找和展现。 我们可以使用它来收集各个服务器上请求链路的跟踪数据，并通过它提供的 REST API 接口来辅助我们查询跟踪数据以实现对分布式系统的监
Zipkin服务端搭建配置教程
03-30 1499
Zipkin服务搭建有多种方式：使用官方提供了可直接启动的Jar包，通过Docker镜像运行，或者自己手动添加依赖创建Zipkin服务器应用。 不过到了spring-boot 2.0后官方就不推荐自己通过手动添加依赖创建Zipkin服务器应用了。所以本文主要介绍前面两种方式。 一、基本介绍 1，什么是 Zipkin? （1）Zipkin是Twitter的一个开源项目，它基于Google Dapper实现。可以用来收集各个服务器上请求链路的跟踪数据，并通过...
SpringCloud Zipkin 环境搭建
qq_33240556的博客
03-06 572
Spring Cloud Zipkin 是一个分布式追踪系统，它基于 Google 的 Dapper 论文实现的开源项目 Zipkin 进行扩展，与 Spring Cloud 紧密集成以提供服务间的调用链跟踪功能。请注意，实际生产环境中可能需要调整一些其他配置项，例如采样率、服务名自定义等。此外，在集群环境中部署 Zipkin 时，还需要考虑存储后端（如 Elasticsearch 或 MySQL）的选择和配置。确保所有微服务都配置了 Sleuth 和 Zipkin，并正确启动。
zipkin
09-22
twitter的分布式跟踪系统
ZipKin原理学习(分布式实时数据追踪系统)+window部署zipkin+k8s部署zipkin
全栈工程师开发手册（原创）https://github.com/tencentmusic/cube-studio
01-08 4243
ZipKin入门介绍 Zipkin是一款开源的分布式实时数据追踪系统（Distributed Tracking System），基于 Google Dapper的论文设计而来，由 Twitter 公司开发贡献。其主要功能是聚集来自各个异构系统的实时监控数据。分布式跟踪系统还有其他比较成熟的实现，例如：Naver的Pinpoint、Apache的HTrace、阿里的鹰眼Tracing、京东的Hydr...
KubeSphere 部署 zipkin
秋叶清风的博客
07-24 397
KubeSphere 部署 zipkin
【教程分享】Docker搭建Zipkin，实现数据持久化到MySQL、ES
JavaEdge全是干货的技术号
08-27 934
Zipkin Server默认将追踪数据信息保存到内存，重启服务后追踪数据将不存在，Zipkin支持将追踪数据持久化到MySQL或ES。启动zipkin-server并请求，再次重启zipkin-server，可见依然存在请求链路录记录，并且MySQL表中存在记录。ES组件使用Elasticsearch 5+的功能，但已测试过与Elasticsearch 6-7.x的兼容性。若连接ES集群，--ES_HOSTS通过逗号分割，如：--ES_HOSTS=无需建立啥配置信息，只需启动jar时指定ES地址。
Zipkin安装和使用
xiaoyi52的专栏
12-01 4736
在前面的blog中介绍过apm原理和开源apm框架，这里继续介绍Zipkin的安装使用。 Zipkin官网：https://zipkin.io/pages/quickstart。 前文导航： 分布式跟踪系统选型与实践 Elastic APM安装和使用 Cat的安装和使用 ...
Linux/Mac 部署kafka、Zipkin，Zipkin整合kafka实现链路追踪
m0_52208135的博客
01-15 1220
SpringCloudAlibaba集成Sleuth+Zipkin，Mac环境部署kafka，并使用kafka记录链路。
zipkin之 CentOS 安装配置
希望我的博客，能解决你工作中的问题
08-25 609
1、下载jar包 curl -sSL https://zipkin.io/quickstart.sh | bash -s 备注：系统中安装jdk 1.8 以上 2、配置启动 1）经典模式只能支持web（http）采集数据 java -jar zipkin.jar 2）链路监控RabbitMQ java -jar zipkin.jar --zipkin.collector.rabbitmq.ad...
SpringCloud分布式微服务链路追踪方案：Zipkin
lucky_fd的博客
06-24 2006
Zipkin 是一个分布式追踪系统，主要用于收集、存储、处理和展示微服务架构中的链路数据。它帮助开发者分析和排查分布式系统中的性能问题，提供完整的请求路径视图。. 在微服务架构中，一个用户请求可能会涉及多个微服务的调用。每个微服务都有可能运行在不同的主机或容器中，传统的日志和监控系统难以提供完整的请求链路视图。而Zipkin能够帮助开发者： 快速定位问题：通过完整的请求路径视图，开发者可以快速找到导致请求延迟或错误的具体服务和代码位置。 优化系统性能：通过分析请求的延迟数据，开发者可以识别系统中的性能瓶颈
Docker部署Zipkin+RabbitMQ+MySQL：微服务监控实践与优化
本文档主要介绍了如何通过Docker部署Zipkin、RabbitMQ和MySQL，以支持在Spring Cloud微服务架构中实现服务治理与监控。作者在构建这个体系结构时，鉴于自身项目经历中的教训，意识到服务监控的重要性，并注意到在...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值