SpringCloud H版系列2--Eureka服务注册与发现以及Eureka集群搭建

雨点打透心脏的1/2处 2022-09-09 04:45 26阅读 0赞

书接上文([SpringCloud H版系列1][SpringCloud H_1])，搭建好项目整体框架，创建完成cloud-provider-payment8001和cloud-consumer-order80两个微服务子模块并能正常启动和访问。本项目来源尚硅谷周阳老师SpringCloud视频教程。

# 一、Eureka基础知识 #

## 1.1、什么是服务治理？ ##

Spring Cloud 封装了 Netflix 公司开发的 Eureka 模块来实现服务治理

在传统的rpc远程调用框架中，管理每个服务与服务之间依赖关系比较复杂，管理比较复杂，所以需要使用服务治理，管理服务于服务之间依赖关系，可以实现服务调用、负载均衡、容错等，实现服务发现与注册。

## 1.2、 什么是服务注册与发现？ ##

Eureka采用了CS的设计架构，Eureka Server 作为服务注册功能的服务器，它是服务注册中心。而系统中的其他微服务，使用 Eureka的客户端连接到 Eureka Server并维持心跳连接。这样系统的维护人员就可以通过 Eureka Server 来监控系统中各个微服务是否正常运行。

在服务注册与发现中，有一个注册中心。当服务器启动的时候，会把当前自己服务器的信息 比如 服务地址通讯地址等以别名方式注册到注册中心上。另一方（消费者|服务提供者），以该别名的方式去注册中心上获取到实际的服务通讯地址，然后再实现本地RPC调用RPC远程调用框架核心设计思想：在于注册中心，因为使用注册中心管理每个服务与服务之间的一个依赖关系(服务治理概念)。在任何rpc远程框架中，都会有一个注册中心(存放服务地址相关信息(接口地址))。  
![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA5oeS6Jmr6Jmrfg_size_20_color_FFFFFF_t_70_g_se_x_16]

## 1.3、Eureka两组件：Eureka Server和Eureka Client ##

**Eureka Server提供服务注册服务**

各个微服务节点通过配置启动后，会在EurekaServer中进行注册，这样EurekaServer中的服务注册表中将会存储所有可用服务节点的信息，服务节点的信息可以在界面中直观看到。

**EurekaClient通过注册中心进行访问**

是一个Java客户端，用于简化Eureka Server的交互，客户端同时也具备一个内置的、使用轮询(round-robin)负载算法的负载均衡器。在应用启动后，将会向Eureka Server发送心跳(默认周期为30秒)。如果Eureka Server在多个心跳周期内没有接收到某个节点的心跳，EurekaServer将会从服务注册表中把这个服务节点移除（默认90秒）

# 二、单机Eureka构建步骤 #

## 2.1、IDEA生成eurekaServer端服务注册中心类似物业公司 ##

2.1.1 建Module  
cloud-eureka-server7001  
2.1.2 改POM

<dependency>
        <groupId>org.springframework.cloud</groupId>
        <artifactId>spring-cloud-starter-netflix-eureka-server</artifactId>
    </dependency>

2.1.3 写YML

server:
      port: 7001
    
    eureka:
      instance:
        hostname: eureka7001.com   #eureka服务端的实例名称
      client:
        register-with-eureka: false   #false表示不向注册中心注册自己
        fetch-registry: false   #false表示自己端就是注册中心
        service-url:
          #集群：相互注册，相互守望
          defaultZone: http://eureka7001.com:7001/eureka/  #单机
          #defaultZone: http://eureka7002.com:7002/eureka/ #集群
      server:
        # 关闭自我保护机制，保证不可用服务被及时剔除
        enable-self-preservation: false
        eviction-interval-timer-in-ms: 2000
    spring:
      application:
        name: cloud-eureka-service

2.1.4 主启动

@SpringBootApplication
    @EnableEurekaServer  // 这个注解就是启动EurekaServer
    public class EurekaMain7001 { 
        public static void main(String[] args) { 
            SpringApplication.run(EurekaMain7001.class,args);
        }
    }

2.1.5 测试  
访问http://localhost:7001/，显示No application available 没有服务被发现，因为没有注册服务进来当然不可能有服务被发现。  
![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA5oeS6Jmr6Jmrfg_size_20_color_FFFFFF_t_70_g_se_x_16 1]

## 2.2、EurekaClient端cloud-provider-payment8001 ##

将其注册进EurekaServer成为服务提供者provider

## 自我保护机制 ##

自我保护机制的工作机制是：如果在15分钟内超过85%的客户端节点都没有正常的心跳，那么Eureka就认为客户端与注册中心出现了网络故障，Eureka Server自动进入自我保护机制。

## 2.3、EurekaClient端cloud-consumer-order80 ##

将其注册进EurekaServer成为服务消费者consumer。

测试参考  
[SpringCloud H版系列1＜PaymentMain8001和OrderMain80＞][SpringCloud H_1]

# 三、集群Eureka构建步骤 #

## 3.1、Eureka集群原理说明 ##

![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA5oeS6Jmr6Jmrfg_size_20_color_FFFFFF_t_70_g_se_x_16 2]  
问题：微服务RPC远程服务调用最核心的是什么  
高可用，试想你的注册中心只有一个only one， 它出故障了那就呵呵(￣▽￣)"了，会导致整个为服务环境不可用，所以

解决办法：**搭建Eureka注册中心集群 ，实现负载均衡+故障容错**

## 3.2、EurekaServer集群环境构建步骤 ##

3.2.1参考cloud-eureka-server7001  
3.2.2新建cloud-eureka-server7002  
3.2.4导入的依赖和7001是一样的  
![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA5oeS6Jmr6Jmrfg_size_15_color_FFFFFF_t_70_g_se_x_16]

3.2.5因为我们要模拟两台eureka 如果在本机上模拟， 需要改一下本机的配置映射文件。  
找到C:\\Windows\\System32\\drivers\\etc路径下的hosts文件  
![在这里插入图片描述][1927453ed0604342a599df97dd779f0b.png]  
修改映射配置添加进hosts文件 修改完 生效需要重启电脑才可以。  
![在这里插入图片描述][9a2a75f5e56741a6bea9c7bd519d5ead.png]  
3.2.6更改YML配置 让两台机器相互注册 相互守望  
7001

server:
      port: 7001
    
    
    eureka:
      instance:
        hostname: eureka7001.com   #eureka服务端的实例名称
      client:
        register-with-eureka: false   #false表示不向注册中心注册自己
        fetch-registry: false   #false表示自己端就是注册中心
        service-url:
          #集群：相互注册，相互守望
          defaultZone: http://eureka7001.com:7001/eureka/  #单机
          #defaultZone: http://eureka7002.com:7002/eureka/ #集群
      server:
        # 关闭自我保护机制，保证不可用服务被及时剔除
        enable-self-preservation: false
        eviction-interval-timer-in-ms: 2000
    spring:
      application:
        name: cloud-eureka-service

7002

server:
      port: 7002
    
    eureka:
      instance:
        hostname: eureka7002.com   #eureka服务端的实例名称
      client:
        register-with-eureka: false   #false表示不向注册中心注册自己
        fetch-registry: false   #false表示自己端就是注册中心
        service-url:
          defaultZone: http://eureka7001.com:7001/eureka/  #集群
    
    spring:
      application:
        name: cloud-eureka-service

3.2.7 7002主启动类

@SpringBootApplication
    @EnableEurekaServer
    public class EurekaMain7002
    { 
        public static void main(String[] args)
        { 
            SpringApplication.run(EurekaMain7002.class,args);
        }
    }

## 3.3、将支付服务8001微服务发布到上面2台Eureka集群配置中 ##

3.3.1 更改yml 配置

server:
      port: 8001
    
    spring:
      application:
        name: cloud-payment-service
      datasource:
        type: com.alibaba.druid.pool.DruidDataSource            # 当前数据源操作类型
        driver-class-name: org.gjt.mm.mysql.Driver              # mysql驱动包
        url: jdbc:mysql://localhost:3306/db2019?useUnicode=true&characterEncoding=utf-8&useSSL=false
        username: root
        password: 123456
    
    eureka:
      client:
        #表示是否将自己注册进EurekaServer默认为true。
        register-with-eureka: true
        #是否从EurekaServer抓取已有的注册信息，默认为true。单节点无所谓，集群必须设置为true才能配合ribbon使用负载均衡
        fetchRegistry: true
        service-url:
          #defaultZone: http://localhost:7001/eureka
          defaultZone: http://eureka7001.com:7001/eureka,http://eureka7002.com:7002/eureka  # 集群版
    
    mybatis:
      mapperLocations: classpath:mapper/*.xml
      type-aliases-package: com.atguigu.springcloud.entities    # 所有Entity别名类所在包

## 3.4、将订单服务80微服务发布到上面2台Eureka集群配置中 ##

3.4.1更改yml 配置

server:
      port: 80
    
    spring:
        application:
            name: cloud-order-service
    eureka:
      client:
        #表示是否将自己注册进EurekaServer默认为true。
        register-with-eureka: true
        #是否从EurekaServer抓取已有的注册信息，默认为true。单节点无所谓，集群必须设置为true才能配合ribbon使用负载均衡
        fetchRegistry: true
        service-url:
          #defaultZone: http://localhost:7001/eureka
          defaultZone: http://eureka7001.com:7001/eureka,http://eureka7002.com:7002/eureka  # 集群版

## 3.5、测试 ##

先要启动EurekaServer，7001/7002服务  
再要启动服务提供者provider，8001  
再要启动消费者，80  
http://localhost/consumer/payment/get/1

## 3.6、支付服务提供者8001集群环境构建 ##

3.6.1参考cloud-provider-payment8001  
3.6.2新建cloud-provider-payment8002  
3.6.3可以直接复制粘贴 ，只需要修改 yaml 文件中的端口号 和 启动类名字即可。  
3.6.4不过了更方便查看到我们调用的是那个微服务 我们将Controller 修改一下  
修改8001Controller

@RestController
    @Slf4j
    public class PaymentController
    { 
        @Value("${server.port}")
        private String serverPort;
    
        @Resource
        private PaymentService paymentService;
    
        @PostMapping(value = "/payment/create")
        public CommonResult create(@RequestBody Payment payment)
        { 
            int result = paymentService.create(payment);
            log.info("*****插入操作返回结果:" + result);
    
            if(result > 0)
            { 
                return new CommonResult(200,"插入成功,返回结果"+result+"\t 服务端口："+serverPort,payment);
            }else{ 
                return new CommonResult(444,"插入失败",null);
            }
        }
    
        @GetMapping(value = "/payment/get/{id}")
        public CommonResult<Payment> getPaymentById(@PathVariable("id") Long id)
        { 
            Payment payment = paymentService.getPaymentById(id);
            log.info("*****查询结果:{}",payment);
            if (payment != null) { 
                return new CommonResult(200,"查询成功"+"\t 服务端口："+serverPort,payment);
            }else{ 
                return new CommonResult(444,"没有对应记录,查询ID: "+id,null);
            }
        }
    }

8002 Controller

@RestController
    @Slf4j
    public class PaymentController
    { 
        @Value("${server.port}")
        private String serverPort;
    
        @Resource
        private PaymentService paymentService;
    
        @PostMapping(value = "/payment/create")
        public CommonResult create(@RequestBody Payment payment)
        { 
            int result = paymentService.create(payment);
            log.info("*****新增结果:" + result);
    
            if(result > 0)
            { 
                return new CommonResult(200,"插入成功,返回结果"+result+"\t 服务端口："+serverPort,payment);
            }else{ 
                return new CommonResult(444,"插入失败",null);
            }
        }
    
        @GetMapping(value = "/payment/get/{id}")
        public CommonResult<Payment> getPaymentById(@PathVariable("id") Long id)
        { 
            Payment payment = paymentService.getPaymentById(id);
            log.info("*****查询结果:{}",payment);
            if (payment != null) { 
                return new CommonResult(200,"查询成功"+"\t 服务端口："+serverPort,payment);
            }else{ 
                return new CommonResult(444,"没有对应记录,查询ID: "+id,null);
            }
        }
    }

## 3.7、负载均衡 ##

3.7.1出现bug 不能把订单服务地址写死 ，order80 OrderController

//public static final String PAYMENT_SRV = "http://localhost:8001";
     
    // 通过在eureka上注册过的微服务名称调用
    public static final String PAYMENT_SRV = "http://CLOUD-PAYMENT-SERVICE";

## 2.使用@LoadBalanced注解赋予RestTemplate负载均衡的能力 ##

## 3.order80 config包下ApplicationContextBean ##

@Configuration
    public class ApplicationContext { 
        //@Bean 代替了xml方式配置注入Spring
        @Bean
        @LoadBalanced //手写负载均衡算法，则注释掉
        //开启负载均衡注解，轮询查询8001和8002的EurekaClient
        public RestTemplate getRestTemplate(){ 
            //RestTemplate提供了多种便捷访问远程http服务的方法
            //是一种简单便捷访问restful服务模板类，是Spring提供的用于访问Rest服务的客户端模板工具类
            return new RestTemplate();
        }
    }

## 3.8测试 ##

先要启动EurekaServer，7001/7002服务  
再要启动服务提供者provider，8001/8002服务  
http://localhost/consumer/payment/get/1  
结果  
负载均衡效果达到  
8001/8002端口交替出现  
Ribbon和Eureka整合后Consumer可以直接调用服务而不用再关心地址和端口号，且该服务还有负载功能了。

# 四、actuator微服务信息完善 #

## 4.1、主机名称:服务名称修改 ##

修改cloud-provider-payment8001

eureka:
      client:
        #表示是否将自己注册进EurekaServer默认为true。
        register-with-eureka: true
        #是否从EurekaServer抓取已有的注册信息，默认为true。单节点无所谓，集群必须设置为true才能配合ribbon使用负载均衡
        fetchRegistry: true
        service-url:
          defaultZone: http://eureka7001.com:7001/eureka,http://eureka7002.com:7002/eureka  # 集群版
          #defaultZone: http://localhost:7001/eureka # 单机版
      instance:
        instance-id: payment8001

修改之后  
![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA5oeS6Jmr6Jmrfg_size_20_color_FFFFFF_t_70_g_se_x_16 3]

## 4.2、访问信息有IP信息提示 ##

当前问题 没有IP提示  
修改cloud-provider-payment8001

修改之后  
![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA5oeS6Jmr6Jmrfg_size_20_color_FFFFFF_t_70_g_se_x_16 4]

# 五、服务发现Discovery #

## 5.1对于注册进eureka里面的微服务，可以通过服务发现来获得该服务的信息 ##

修改cloud-provider-payment8001的Controller

@RestController
    @Slf4j
    public class PaymentController
    { 
        @Value("${server.port}")
        private String serverPort;
    
        @Resource
        private PaymentService paymentService;
    
        @Resource
        private DiscoveryClient discoveryClient;
    
        @PostMapping(value = "/payment/create")
        public CommonResult create(@RequestBody Payment payment)
        { 
            int result = paymentService.create(payment);
            log.info("*****插入操作返回结果:" + result);
    
            if(result > 0)
            { 
                return new CommonResult(200,"插入成功,返回结果"+result+"\t 服务端口："+serverPort,payment);
            }else{ 
                return new CommonResult(444,"插入失败",null);
            }
        }
    
        @GetMapping(value = "/payment/get/{id}")
        public CommonResult<Payment> getPaymentById(@PathVariable("id") Long id)
        { 
            Payment payment = paymentService.getPaymentById(id);
            log.info("*****查询结果:{}",payment);
            if (payment != null) { 
                return new CommonResult(200,"查询成功"+"\t 服务端口："+serverPort,payment);
            }else{ 
                return new CommonResult(444,"没有对应记录,查询ID: "+id,null);
            }
        }
    
        @GetMapping(value = "/payment/discovery")
        public Object discovery()
        { 
            List<String> services = discoveryClient.getServices();
            for (String element : services) { 
                System.out.println(element);
            }
    
            List<ServiceInstance> instances = discoveryClient.getInstances("CLOUD-PAYMENT-SERVICE");
            for (ServiceInstance element : instances) { 
                System.out.println(element.getServiceId() + "\t" + element.getHost() + "\t" + element.getPort() + "\t"
                        + element.getUri());
            }
            return this.discoveryClient;
        }
    }

## 5.2 8001主启动类 ##

@SpringBootApplication
    @EnableEurekaClient
    @EnableDiscoveryClient //服务发现
    public class PaymentMain8001
    { 
        public static void main(String[] args)
        { 
            SpringApplication.run(PaymentMain8001.class,args);
        }
    }

## 测试 ##

先要启动EurekaServer  
再启动8001主启动类，需要稍等一会儿  
http://localhost:8001/payment/discovery

# 六、Eureka自我保护 #

## 6.1、故障现象 ##

概述  
保护模式主要用于一组客户端和Eureka Server之间存在网络分区场景下的保护。一旦进入保护模式，  
Eureka Server将会尝试保护其服务注册表中的信息，不再删除服务注册表中的数据，也就是不会注销任何微服务。  
![在这里插入图片描述][52f08aff2e324c33813e5e6cc5fcac4e.png]

## 6.2、导致原因 ##

**为什么会产生Eureka自我保护机制？**

为了防止EurekaClient可以正常运行，但是 与 EurekaServer网络不通情况下，EurekaServer不会立刻将EurekaClient服务剔除

**什么是自我保护模式？**  
默认情况下，如果EurekaServer在一定时间内没有接收到某个微服务实例的心跳，EurekaServer将会注销该实例（默认90秒）。但是当网络分区故障发生(延时、卡顿、拥挤)时，微服务与EurekaServer之间无法正常通信，以上行为可能变得非常危险了——因为微服务本身其实是健康的，此时本不应该注销这个微服务。Eureka通过“自我保护模式”来解决这个问题——当EurekaServer节点在短时间内丢失过多客户端时（可能发生了网络分区故障），那么这个节点就会进入自我保护模式。

在自我保护模式中，Eureka Server会保护服务注册表中的信息，不再注销任何服务实例。  
它的设计哲学就是宁可保留错误的服务注册信息，也不盲目注销任何可能健康的服务实例。一句话讲解：好死不如赖活着  
![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA5oeS6Jmr6Jmrfg_size_20_color_FFFFFF_t_70_g_se_x_16 5]  
综上，自我保护模式是一种应对网络异常的安全保护措施。它的架构哲学是宁可同时保留所有微服务（健康的微服务和不健康的微服务都会保留）也不盲目注销任何健康的微服务。使用自我保护模式，可以让Eureka集群更加的健壮、稳定。

属于CAP里面的AP分支

## 6.3、怎么禁止自我保护 ##

注册中心eureakeServer端7001

出厂默认，自我保护机制是开启的 eureka.server.enable-self-preservation=true

使用eureka.server.enable-self-preservation = false 可以禁用自我保护模式

server:
      port: 7001
    
    spring:
      application:
        name: eureka-cluster-server
    
    eureka:
      instance:
        hostname: eureka7001.com
      client:
        register-with-eureka: false
        fetch-registry: false
        service-url:
          #defaultZone: http://eureka7002.com:7002/eureka,http://eureka7003.com:7003/eureka
          defaultZone: http://eureka7001.com:7001/eureka
      server:
        #关闭自我保护机制，保证不可用服务被及时踢除
           enable-self-preservation: false
        eviction-interval-timer-in-ms: 2000

关闭效果  
![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA5oeS6Jmr6Jmrfg_size_20_color_FFFFFF_t_70_g_se_x_16 6]  
6.4生产者客户端eureakeClient端8001

eureka:
      client: #服务提供者provider注册进eureka服务列表内
        service-url:
          register-with-eureka: true
          fetch-registry: true
          # cluster version
          #defaultZone: http://eureka7001.com:7001/eureka,http://eureka7002.com:7002/eureka,http://eureka7003.com:7003/eureka
          # singleton version
          defaultZone: http://eureka7001.com:7001/eureka
    #心跳检测与续约时间
    #开发时设置小些，保证服务关闭后注册中心能即使剔除服务
      instance:
      #Eureka客户端向服务端发送心跳的时间间隔，单位为秒(默认是30秒)
        lease-renewal-interval-in-seconds: 1
      #Eureka服务端在收到最后一次心跳后等待时间上限，单位为秒(默认是90秒)，超时将剔除服务
        lease-expiration-duration-in-seconds: 2

测试

7001和8001都配置完成

先启动7001再启动8001

![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA5oeS6Jmr6Jmrfg_size_20_color_FFFFFF_t_70_g_se_x_16 7]  
先关闭8001 我们可以看到立马就被删除啦。  
![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA5oeS6Jmr6Jmrfg_size_20_color_FFFFFF_t_70_g_se_x_16 8]

参考文章  
https://blog.csdn.net/weixin\_45821811/article/details/117620490

[SpringCloud H_1]: https://blog.csdn.net/jike11231/article/details/119965904?spm=1001.2014.3001.5502
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA5oeS6Jmr6Jmrfg_size_20_color_FFFFFF_t_70_g_se_x_16]: /images/20220829/03d30f53562740b0b26da6a9d3863bfb.png
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA5oeS6Jmr6Jmrfg_size_20_color_FFFFFF_t_70_g_se_x_16 1]: /images/20220829/1c39b8d41b6044d8a4428fce1add88fb.png
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA5oeS6Jmr6Jmrfg_size_20_color_FFFFFF_t_70_g_se_x_16 2]: /images/20220829/6b0adfa153284d9a88f6c55ebc49de51.png
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA5oeS6Jmr6Jmrfg_size_15_color_FFFFFF_t_70_g_se_x_16]: /images/20220829/9ffd30830b594ef09082ff29f0ad0247.png
[1927453ed0604342a599df97dd779f0b.png]: /images/20220829/c161963f7def4cefb3f37f21a1478f47.png
[9a2a75f5e56741a6bea9c7bd519d5ead.png]: /images/20220829/7766e317da2e43fdaa1375179d1bc665.png
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA5oeS6Jmr6Jmrfg_size_20_color_FFFFFF_t_70_g_se_x_16 3]: /images/20220829/99711c86c24e4b1380c2fcca8405b184.png
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA5oeS6Jmr6Jmrfg_size_20_color_FFFFFF_t_70_g_se_x_16 4]: /images/20220829/8444d467ec1f467b89e5184afc791eae.png
[52f08aff2e324c33813e5e6cc5fcac4e.png]: /images/20220829/88913f35882f42b69c5849a5f63476fa.png
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA5oeS6Jmr6Jmrfg_size_20_color_FFFFFF_t_70_g_se_x_16 5]: /images/20220829/5cff3beb39bd4574b5f76812bdef96ae.png
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA5oeS6Jmr6Jmrfg_size_20_color_FFFFFF_t_70_g_se_x_16 6]: /images/20220829/7134ea6a2ebc452b95eac986ea3b1aa1.png
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA5oeS6Jmr6Jmrfg_size_20_color_FFFFFF_t_70_g_se_x_16 7]: /images/20220829/04dc7eefc26d4780b110f2a19f1f0f2a.png
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA5oeS6Jmr6Jmrfg_size_20_color_FFFFFF_t_70_g_se_x_16 8]: /images/20220829/42e5285f6b3f43d4b864f2647c6e5596.png