sleuth + kafka + zipkin

最新推荐文章于 2024-03-07 09:47:30 发布
最新推荐文章于 2024-03-07 09:47:30 发布
阅读量1.6k 收藏
点赞数
分类专栏： Spring Cloud
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u012965203/article/details/100006531
版权

一、基本环境

  • zipkin
  • zookeeper
  • kafka
  • 一个eureka项目
  • 一个消费者项目
  • 一个提供者项目

二、zipkin下载与启动

参考 https://blog.csdn.net/u012965203/article/details/100006168

三、zookeeper下载与安装

参考 https://blog.csdn.net/u012965203/article/details/90302171

四、kafka下载与安装

参考  https://blog.csdn.net/u012965203/article/details/92634343

       https://blog.csdn.net/u012965203/article/details/92796384

注意点：kafka配置问题（如果在阿里云）

五、创建eureka项目

（1）创建项目，命名00-eurekaserver-8000

（2）依赖

<?xml version="1.0" encoding="UTF-8"?>
<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.0</modelVersion>
 
    <groupId>com.abc</groupId>
    <artifactId>00-eurekaserver-8000</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <packaging>jar</packaging>
 
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.1.7.RELEASE</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
 
    <properties>
        <java.version>1.8</java.version>
        <spring-cloud.version>Greenwich.SR2</spring-cloud.version>
    </properties>
 
    <dependencies>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-netflix-eureka-server</artifactId>
        </dependency>
 
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
    </dependencies>
 
    <dependencyManagement>
        <dependencies>
            <dependency>
                <groupId>org.springframework.cloud</groupId>
                <artifactId>spring-cloud-dependencies</artifactId>
                <version>${spring-cloud.version}</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
        </dependencies>
    </dependencyManagement>
 
    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>
 
</project>

（3）application.yml配置

server:
  port: 8000
 
eureka:
  instance:
    hostname: localhost  # 指定Eureka主机
  client:
    register-with-eureka: false   # 指定当前主机是否向Eureka服务器进行注册
    fetch-registry: false    # 指定当前主机是否要从Eurka服务器下载服务注册列表
    service-url:   # 服务暴露地址
     defaultZone: http://localhost:8000/eureka
#     defaultZone: http://${eureka.instance.hostname}:${server.port}/eureka
 
#  server:
#    enable-self-preservation: false    # 关闭自我保护

（4）启动类

package com.abc.eureka;
 
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.netflix.eureka.server.EnableEurekaServer;
 
@SpringBootApplication
@EnableEurekaServer   // 开启Eureka服务
public class EurekaServerApplication {
 
    public static void main(String[] args) {
        SpringApplication.run(EurekaServerApplication.class, args);
    }
}

六、创建消费项目

（1） 创建项目

（2）依赖

<?xml version="1.0" encoding="UTF-8"?>
<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.0</modelVersion>

    <groupId>com.abc</groupId>
    <artifactId>07-kafka-sleuth-consumer-8080</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <packaging>jar</packaging>

    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.1.5.RELEASE</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>

    <properties>
        <java.version>1.8</java.version>
        <spring-cloud.version>Greenwich.SR1</spring-cloud.version>
    </properties>

    <dependencies>
        <!--kafka依赖-->
        <dependency>
            <groupId>org.springframework.kafka</groupId>
            <artifactId>spring-kafka</artifactId>
        </dependency>
        <!--zipkin客户端依赖，其包含了sleuth依赖-->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-zipkin</artifactId>
        </dependency>

        <!--feign依赖-->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-openfeign</artifactId>
        </dependency>
        <!--actuator依赖-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-actuator</artifactId>
        </dependency>
        <!--eureka客户端依赖-->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </dependency>
    </dependencies>

    <dependencyManagement>
        <dependencies>
            <dependency>
                <groupId>org.springframework.cloud</groupId>
                <artifactId>spring-cloud-dependencies</artifactId>
                <version>${spring-cloud.version}</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
        </dependencies>
    </dependencyManagement>


    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>


</project>

（3）application.yml配置

（4）实体类

package com.abc.consumer.bean;

import lombok.Data;

@Data
public class Depart {
    private Integer id;
    private String name;
}

（5）RestTemplate类

package com.abc.consumer.codeconfig;

import org.springframework.cloud.client.loadbalancer.LoadBalanced;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.client.RestTemplate;

@Configuration
public class DepartCodeConfig {

    @LoadBalanced
    @Bean
    public RestTemplate restTemplate() {
        return new RestTemplate();
    }
}

（6）控制层

package com.abc.consumer.controller;

import com.abc.consumer.bean.Depart;
import com.abc.consumer.service.DepartService;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

import java.util.List;

@Slf4j
@RestController
@RequestMapping("/consumer/depart")
public class DepartController {
    @Autowired
    private DepartService service;

   
    @GetMapping("/get/{id}")
    public Depart getHandle(@PathVariable("id") int id) {
        log.info("消费者的处理器方法被调用");
        return service.getDepartById(id);
    }

}

（7）接口层

package com.abc.consumer.service;


import com.abc.consumer.bean.Depart;
import org.springframework.cloud.openfeign.FeignClient;
import org.springframework.stereotype.Service;
import org.springframework.web.bind.annotation.*;

import java.util.List;

@Service
@FeignClient("abcmsc-provider-depart")
@RequestMapping("/provider/depart")
public interface DepartService {
   
    boolean modifyDepart(@RequestBody Depart depart);
    @GetMapping("/get/{id}")
    Depart getDepartById(@PathVariable("id") int id);
  
}

（8）启动类

package com.abc.consumer;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.openfeign.EnableFeignClients;

// 指定Feign接口所在的包
@EnableFeignClients(basePackages = "com.abc.consumer.service")
@SpringBootApplication
public class ConsumerApplication {

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

}

七、创建提供者项目

（1）创建项目

（2）依赖

<?xml version="1.0" encoding="UTF-8"?>
<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.0</modelVersion>

    <groupId>com.abc</groupId>
    <artifactId>07-kafka-sleuth-provider-8081</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <packaging>jar</packaging>

    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.1.5.RELEASE</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>

    <properties>
        <java.version>1.8</java.version>
        <spring-cloud.version>Greenwich.SR1</spring-cloud.version>
    </properties>

    <dependencies>
        <!--kafka依赖-->
        <dependency>
            <groupId>org.springframework.kafka</groupId>
            <artifactId>spring-kafka</artifactId>
        </dependency>

        <!--zipkin客户端依赖，其包含了sleuth依赖-->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-zipkin</artifactId>
        </dependency>

        <!--actuator依赖-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-actuator</artifactId>
        </dependency>
        <!--eureka客户端依赖-->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
        </dependency>
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid</artifactId>
            <version>1.1.10</version>
        </dependency>
        <!--修改MySQL驱动版本-->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.47</version>
            <scope>runtime</scope>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-jpa</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </dependency>
    </dependencies>

    <dependencyManagement>
        <dependencies>
            <dependency>
                <groupId>org.springframework.cloud</groupId>
                <artifactId>spring-cloud-dependencies</artifactId>
                <version>${spring-cloud.version}</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
        </dependencies>
    </dependencyManagement>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>


</project>

（3）application.yml配置

（4）实体类

package com.abc.provider.bean;

import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
import lombok.Data;

import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;

@Data
@Entity
@JsonIgnoreProperties({"hibernateLazyInitializer", "handler", "fieldHandler"})
public class Depart {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Integer id;
    private String name;
}

（5）数据链路层

package com.abc.provider.repository;

import com.abc.provider.bean.Depart;
import org.springframework.data.jpa.repository.JpaRepository;

// 第一个泛型：当前Repository的操作对象类型
// 第二个泛型：当前Repository的操作对象的id类型
public interface DepartRepository extends JpaRepository<Depart, Integer> {
}

（6）控制层

package com.abc.provider.controller;

import com.abc.provider.bean.Depart;
import com.abc.provider.service.DepartService;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.cloud.client.ServiceInstance;
import org.springframework.cloud.client.discovery.DiscoveryClient;
import org.springframework.web.bind.annotation.*;

import java.util.List;

@Slf4j
@RequestMapping("/provider/depart")
@RestController
public class DepartController {
    @Autowired
    private DepartService service;

    @GetMapping("/get/{id}")
    public Depart getHandle(@PathVariable("id") int id) {
        log.info("生产者的处理器方法被调用");
        return service.getDepartById(id);
    }


}

（7）接口层

package com.abc.provider.service;


import com.abc.provider.bean.Depart;

import java.util.List;

public interface DepartService {
    Depart getDepartById(int id);
}

（8）接口实现类

package com.abc.provider.service;

import com.abc.provider.bean.Depart;
import com.abc.provider.repository.DepartRepository;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.List;

@Service
public class DepartServiceImpl implements DepartService {
    @Autowired
    private DepartRepository repository;

    @Override
    public Depart getDepartById(int id) {
        if(repository.existsById(id)) {
            return repository.getOne(id);
        }
        Depart depart = new Depart();
        depart.setName("no this depart");
        return depart;
    }

}

（9）启动类

package com.abc.provider;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class ProviderApplication {

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

八、测试

（1）启动zookeeper

（2）启动kafka

（3）启动zipkin

java -DKAFKA_BOOTSTRAP_SERVERS=localhost:9092 -jar zipkin.jar

（4）启动eureka项目

（5）启动消费项目

（6）启动消费项目

（7）效果

请求  http://localhost:8080/consumer/depart/get/2之后

访问 http://localhost:9411/zipkin/

2014Team
关注
专栏目录
【zipkin】kafka对接zipkin（kafka）
UckyK的专栏
12-31 2130
环境准备 以kafka的方式导入 property配置 # kafka集群地址 spring.kafka.bootstrap-servers=你的kafka地址 # kafka的topic，默认则为zipkin spring.zipkin.kafka.topic=zzzzipkin # 不配置则使用http spring.zipkin.sender.type=kafka pom配置 ...
SpringCloud | 五、Spring Cloud Sleuth + Zipkin + Kafka + Elasticsearch + Kibana 服务调用全链路跟踪[Finchley版]
GiraffePeng的博客
08-14 2038
Spring Cloud体系下的服务调用全链路跟踪。
Spring Cloud Sleuth & Zipkin & Kafka链路追踪
t5721654的专栏
04-15 2732
使用背景 生产环境中，服务越来越多、内部调用关系越来越复杂，需要搭建一套链路追踪系统来分析、评测调用链的各个环节快慢以及系统拓扑图。 简介&说明 链路追踪其实就是个数据上报和收集展示的过程 zipkin是一款链路追踪系统，由服务端和客户端两方组成，服务端由Zipkin提供了，客户端就是我们的应用程序，它不限定是springboot应用，只要按照规范进行上报，服务端就能解析调用...
Spring Cloud Sleuth kafka es 全链路监控
wangbaosongmsn的博客
07-10 176
https://blog.csdn.net/jiachengwin/article/details/82500167
Spring Cloud Sleuth超详细实战
weixin_34356310的博客
08-06 1455
转载请标明出处：blog.csdn.net/forezp/arti…本文出自方志朋的博客 为什么需要Spring Cloud Sleuth 微服务架构是一个分布式架构，它按业务划分服务单元，一个分布式系统往往有很多个服务单元。由于服务单元数量众多，业务的复杂性，如果出现了错误和异常，很难去定位。主要体现在，一个请求可能需要调用很多个服务，而内部服务的调用复杂性，决定了问题难以定位。所以微服务架...
Spring Cloud Sleuth通过Kafka将链路追踪日志输出到ELK
weixin_30267691的博客
07-27 388
1、工程简介 elk-eureka-server作为其他三个项目的服务注册中心 elk-kafka-client调用elk-kafka-server，elk-kafka-server再调用elk-kafka-server1 2、新建springboot项目elk-eureka-server pom.xml内容如下 1 <?xml version="1.0" ...
zipkin-demo:关于如何使用Spring Cloud Sleuth + Kafka + Zipkin + ElasticSearch的演示
05-14
A demo about how to use Spring Cloud Sleuth + Kafka + Zipkin + ElasticSearch 模块介绍 frontend 提供rest接口，处理用户请求，然后转发给backend处理。 backend 提供rest接口，处理fontend的请求。 zipkin-...
spring-cloud-learning:Springcloud + rabbitmq + kafka + slueth + zipkin + lcn + redis
03-22
本项目"spring-cloud-learning:Springcloud + rabbitmq + kafka + slueth + zipkin + lcn + redis"是针对Spring Cloud的一系列实践教程，涉及到的关键技术包括： 1. **Spring Cloud Eureka**：注册与发现服务，它是...
zipkin+kafka+Elasticsearch 集成
liu9403的博客
03-24 530
1. zipkin+kafka+ES 集成 客户端数据采集后发送到kafka(client->kafka)；zipkin服务端订阅kafka数据后，持久化到elasticsearch(kafa<-zipkin->elasticsearch) zipkin服务端：基于docker或jar包 1.1 服务端 1.1.1 服务端环境 elasticsearch版本: elasticsearch-7.10.2 kafka版本:kafka_2.13-2.5 根据需求以docker或jar包方式
分布式链路追踪之Spring Cloud Sleuth+Zipkin最全教程
a1472750149的博客
11-18 2812
今天这篇文章陈某介绍一下链路追踪相关的知识，以Spring Cloud Sleuth和zipkin这两个组件为主，后续文章介绍另外一种。 文章的目录如下： 为什么需要链路追踪？ 大型分布式微服务系统中，一个系统被拆分成N多个模块，这些模块负责不同的功能，组合成一套系统，最终可以提供丰富的功能。在这种分布式架构中，一次请求往往需要涉及到多个服务，如下图： 服务之间的调用错综复杂，对于维护的成本成倍增加，势必存在以下几个问题： 服务之间的依赖与被依赖的关系如何能够清晰的看到？ 出现异常时如何
zipkin-storage-kafka:基于Kafka的Zipkin存储
05-08
邮编存储：Kafka [EXPERIMENTAL] 基于Kafka的Zipkin存储。 +----------------------------*zipkin*---------------------------------------------- | [ dependency-storage ]--->( dependencies ) | ^ +-->( autocomplete-tags ) ( collected-spans )-|->[ partitioning ]
(spring-cloud-sleuth-stream+mybatis+rabbit)+(kafka+elasticsearch+zipkin)
06-09
(spring-cloud-sleuth-stream+mybatis+rabbit)+(kafka+elasticsearch+zipkin)
windows环境搭建调用链监控 spring cloud+es+kafka+zipkin
12-08
windows环境搭建调用链监控 spring cloud+es+kafka+zipkin
zipkin+kafka+elasticsearch
anboguan0765的博客
09-27 215
1.安装zookeeper（3.4.6） 安装过程（略） 启动zookeeper ./bin/zkServer.sh start 或者bin/zookeeper-server-start.sh conf/zoo.cfg netstat -tunlp|grep 2181 #查看zookeeper端口 2. kafka 安装部署（kafka_2.12-0.11.0.0） 2.1 ...
Zipkin：Zipkin源码解析-KafkaCollector
最新发布
qq_33240556的博客
03-07 462
在分布式追踪场景中，应用通过 Brave 库生成的 Span 数据可以被发送到 Kafka 集群，然后由 Zipkin 服务端的 KafkaCollector 负责消费这些消息，并将它们转化为内部格式存储起来，以便后续进行查询和分析。为了深入理解 KafkaCollector 的工作原理，源码分析可以从上述关键点出发，结合实际代码查看 KafkaCollector 类及其相关辅助类的实现，从而了解其具体的工作流程和设计细节。
在spring-cloud的Finchley.SR1 版本中使用 zipkin+kafka+elasticsearch实现链路追踪
学习交流
09-21 1800
本文主要使用Spring Cloud Sleuth来实现分布式链路追踪，利用Kafka实现异步的方式通信实现分布式追踪，使用Elasticsearch持久化追踪日志数据，使用Zipkin-Server查看追踪内容。 关于搭建Spring Cloud微服务，安装zk、kafka、elasticsearch的就不在此重复了。直接进入主题。 1、搭建Zipkin-Server      在Spri...
Kubnernetes 集群部署 Zipkin+Kafka+ElasticSearch 实现链路追踪
Mo小泽的技术博客
12-17 2219
我们这里将链路日志推送到 Kafka，然后启动 Zipkin Server 聚合日志，监听 Kafka ，如果有新的消息则进行拉取存入到 ElasticSeach，最后再用 Zipkin UI 展示链路过程
分布式链路追踪 sleuth+KAFKA+ES
weixin_48420669的博客
09-16 1668
微服务请求跟踪链路概述Sleuth是什么?Zipkin 和 SleuthZipkin 使用项目编写然后微服务之间调用就可以在zipkin上显示,感觉没什么用的功能 概述 为什么需要微服务请求跟踪链路? 在项目庞大了之后,许多的微服务之间相互调用,有可能一个地方出了,需要及时发现,就需要一个能监控服务的一个服务. Sleuth是什么? 是一套完整的微服务跟踪解决方案,内部兼容了 zipkin Zipkin 和 Sleuth Sleuth 是监控服务, Zipkin 负责展现 Zipkin 使用 Spring
Spring Cloud Sleuth+Zipkin
tanksyg的专栏
01-18 2198
二、SpringBoot 2.X整合Sleuth+Zipkin 在微服务系统中，各个服务之间的调用关系比较复杂。一个 HTTP 请求可能会调用多个不同的微服务来处理，在调用过程中可能因为某个服务异常（网络延迟过高或发送错误）导致请求失败，所有需要有服务追踪来监控，方便快速定位问题点。Spring Cloud Sleuth 提供了分布式服务链路监控的解决方案。 1、简介 Zipkin（是Twitt...
Springcloud Sleuth 集成调用跟踪：Kafka、Elasticsearch、Zipkin 实现
"本文档主要介绍了如何在SpringCloud项目中集成调用跟踪系统，采用Springcloud Sleuth配合Kafka、Elasticsearch以及Zipkin进行日志收集与分析，以实现微服务间的请求链路追踪。" 在分布式系统中，特别是在基于...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

2014Team

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值