一.Eureka注册中心
1.1.Eureka简介
首先我们来解决第一问题，服务的管理。
网约车
这就好比是网约车出现以前，人们出门叫车只能叫出租车。一些私家车想做出租却没有资格，被称为黑车。而很多人想要约车，但是无奈出租车太少，不方便。私家车很多却不敢拦，而且满大街的车，谁知道哪个才是愿意载人的。一个想要，一个愿意给，就是缺少引子，缺乏管理啊。
此时滴滴这样的网约车平台出现了，所有想载客的私家车全部到滴滴注册，记录你的车型（服务类型），身份信息（联系方式）。这样提供服务的私家车，在滴滴那里都能找到，一目了然。
此时要叫车的人，只需要打开APP，输入你的目的地，选择车型（服务类型），滴滴自动安排一个符合需求的车到你面前，为你服务，完美！
Eureka是Netflix的一个子模块，也是核心模块之一。Eureka是一个基于REST服务，用于定位服务，以实现云端中间层服务发现和故障转移。服务注册与发现对于微服务架构来说是非常重要的，有了服务发现与注册，只需要使用服务的标识符，就可以访问到服务，而不需要修改服务调用的配置文件了。功能类似于dubbo的注册中心，比如Zookeeper。
1.2.Eureka基本架构
SpringCloud封装了Netflix公司开发的Eureka模块来实现服务注册和发现（请对比Zookeeper)。Eureka采用了C-S的设计架构。EurekaServer作为服务注册功能的服务器，它是服务注册中心。而系统中的其他微服务，使用Eureka的客户端连接到EurekaServer并维持心路连接。这样系统的维护人员就可以通过EurekaServer来监控系统中各个微服务是否正常运行。SpringCloud的一些其他模块（比如Zuul）就可以通过EurekaServer来发现系统中的其他微服务，并执行相关的逻辑。
- Eureka：就是服务注册中心（可以是一个集群），对外暴露自己的地址
- 提供者：启动后向Eureka注册自己信息（地址，提供什么服务）
- 消费者：向Eureka订阅服务，Eureka会将对应服务的所有提供者地址列表发送给消费者，并且定期更新
- 心跳(续约)：提供者定期通过http方式向Eureka刷新自己的状态
1.2.1 EurekaServer(注册中心)
EurekaServer作为一个独立的部署单元，以RESTAPI的形式为服务实例提供了注册、管理和查询等操作。同时，EurekaServer也为我们提供了可视化的监控页面，可以直观地看到各个EurekaServer当前的运行状态和所有已注册服务的情况。
1.2.2 EurekaClient(客户端)
●服务注册：
启动时，会调用服务注册方法，向EurekaServer注册自己的信息。EurekaServer会维护一个已注册服务的列表。当实例状态发生变化时（如自身检测认为Down的时候），也会向EurekaServer更新自己的服务状态，同时用replicateToPeers()向其它EurekaServer节点做状态同步。
●续约与剔除：
服务实例启动后，会周期性地向EurekaServer发送心跳以续约自己的信息，避免自己的注册信息被剔除。续约的方式与服务注册基本一致，首先更新自身状态，再同步到其它Peer。如果EurekaServer在一段时间内没有接收到某个微服务节点的心跳，EurekaServer将会注销该微服务节点（自我保护模式除外）。
●服务消费：ServiceConsumer本质上也是一个EurekaClient。它启动后，会从EurekaServer上获取所有实例的注册信息，包括IP地址、端口等，并缓存到本地。这些信息默认每30秒更新一次。前文提到过，如果与EurekaServer通信中断，ServiceConsumer仍然可以通过本地缓存与ServiceProvider通信。
●三处缓存
EurekaServer对注册列表进行缓存，默认时间为30s。
EurekaClient对获取到的注册信息进行缓存，默认时间为30s。
Ribbon会从上面提到的EurekaClient获取服务列表，将负载均衡后的结果缓存30s。
二.Eureka项目的构建
我们做三个角色
EurekaServer：提供服务注册和发现；
ServiceProvider：服务提供方，将自身服务注册到Eureka，从而使服务消费方能够找到；
ServiceConsumer：服务消费方，从Eureka获取注册服务列表，从而能够消费服务。
2.1 新建一个工程EurekaServer-7001
●依然使用spring提供的快速搭建工具：
●选择依赖，完整的Pom文件：
<?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>
<parent>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-parent</artifactId>
<version>2.1.4.RELEASE</version>
<relativePath/> <!-- lookup parent from repository -->
</parent>
<groupId>com.bruceliu.eureka.server</groupId>
<artifactId>eureka-server-7001</artifactId>
<version>0.0.1-SNAPSHOT</version>
<name>eureka-server-7001</name>
<description>Demo project for Spring Boot</description>
<properties>
<java.version>1.8</java.version>
<spring-cloud.version>Greenwich.SR1</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>
●编写启动类：
@SpringBootApplication
@EnableEurekaServer // 声明这个应用是一个EurekaServer
public class EurekaServer7001Application {
public static void main(String[] args) {
SpringApplication.run(EurekaServer7001Application.class, args);
}
}
●编写配置 yml：
server:
port: 7001 # 端口
spring:
application:
name: eureka-server-7001 # 应用名称，会在Eureka中显示
eureka:
client:
register-with-eureka: false # 是否注册自己的信息到EurekaServer，默认是true
fetch-registry: false #false表示自己端就是注册中心，我的职责就是维护服务实例，并不需要去检索服务
service-url: # EurekaServer的地址，现在是自己的地址，如果是集群，需要加上其它Server的地址。
defaultZone: http://127.0.0.1:${server.port}/eureka
●启动服务，并访问：http://127.0.0.1:7001
2.2.将user-service注册到Eureka
注册服务，就是在服务上添加Eureka的客户端依赖，客户端代码会自动把服务注册到EurekaServer中。
我们在springcloud-demo中添加Eureka客户端依赖：
●先添加SpringCloud依赖：
<!-- SpringCloud的依赖 -->
<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>
●然后是Eureka客户端：
<!-- Eureka客户端 -->
<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
</dependency>
在启动类上开启Eureka客户端功能
通过添加@EnableEurekaClient来开启Eureka客户端功能
@SpringBootApplication
@EnableEurekaClient // 开启EurekaClient功能
public class App {
public static void main(String[] args) {
SpringApplication.run(App.class, args);
System.out.println("提供者启动:7001");
}
}
●编写配置
# 应用名称
spring.application.name=springcloud-demo-service
# EurekaServer地址
eureka.client.service-url.defaultZone=http://127.0.0.1:7001/eureka
# 当调用getHostname获取实例的hostname时，返回ip而不是host名称
eureka.instance.prefer-ip-address=true
# 指定自己的ip信息，不指定的话会自己寻找
eureka.instance.ip-address=127.0.0.1
注意：
- 这里我们添加了spring.application.name属性来指定应用名称，将来会作为应用的id使用。
- 不用指定register-with-eureka和fetch-registry，因为默认是true
●重启项目，访问Eureka监控页面查看
我们发现service服务已经注册成功了!!!
2.3 消费者从Eureka获取服务
接下来我们修改springcloud-demo-consumer，尝试从EurekaServer获取服务。
方法与消费者类似，只需要在项目中添加EurekaClient依赖，就可以通过服务名称来获取信息了！
添加依赖：
●先添加SpringCloud依赖：
<!-- SpringCloud的依赖 -->
<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>
●然后是Eureka客户端：
<!-- Eureka客户端 -->
<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
</dependency>
●在启动类开启Eureka客户端：
@SpringBootApplication
@EnableDiscoveryClient // 开启EurekaClient功能
public class SpringcloudDemoConsumerApplication {
public static void main(String[] args) {
SpringApplication.run(SpringcloudDemoConsumerApplication.class, args);
}
}
●修改配置：
spring.application.name=springcloud-demo-consumer
# EurekaServer地址
eureka.client.service-url.defaultZone=http://127.0.0.1:7001/eureka
# 当调用getHostname获取实例的hostname时，返回ip而不是host名称
eureka.instance.prefer-ip-address=true
# 指定自己的ip信息，不指定的话会自己寻找
eureka.instance.ip-address=127.0.0.1
●修改代码，用DiscoveryClient类的方法，根据服务名称，获取服务实例：
@RestController
@RequestMapping("consumer")
public class ConsumerController {
@Autowired
private RestTemplate restTemplate;
@Autowired
private DiscoveryClient client;// Eureka客户端，可以获取到服务实例信息
@RequestMapping("/test")
public List<User> consumerTest(){
List<String>list=client.getServices();
System.out.println("*服务列表*"+list);
List<ServiceInstance> srvList=client.getInstances("springcloud-demo-service");
for(ServiceInstance element:srvList){
System.out.println(element.getServiceId()+"\t"+element.getHost()+"\t"+element.getPort()+"\t" +element.getUri());
}
// 因为只有一个UserService,因此我们直接get(0)获取
ServiceInstance instance = srvList.get(0);
// 获取ip和端口信息
String baseUrl = "http://"+instance.getHost() + ":" + instance.getPort()+"/all";
System.out.println("访问地址:"+baseUrl);
return this.restTemplate.getForObject(baseUrl,List.class);
}
}
●注册中心：
●访问测试：
2.4.注册微服务信息完善
●主机名称：服务名称修改默认：
●在springcloud-demo属性文件中加入
eureka.instance.instance-id=springcloud-demo-service-80
●修改后，查看页面
三、CAP理论
3.1.前言
分布式系统（distributed system）正变得越来越重要，大型网站几乎都是分布式的。
分布式系统的最大难点，就是各个节点的状态如何同步。CAP 定理是这方面的基本定理，也是理解分布式系统的起点。
3.2.分布式系统的三个指标
1998年，加州大学的计算机科学家 Eric Brewer 提出，分布式系统有三个指标。
Consistency
Availability
Partition tolerance
它们的第一个字母分别是 C、A、P。
Eric Brewer 说，这三个指标不可能同时做到。这个结论就叫做 CAP 定理。
一致性（C）：在分布式系统中的所有数据备份，在同一时刻是否同样的值。（等同于所有节点访问同一份最新的数据副本）
可用性（A）：在集群中一部分节点故障后，集群整体是否还能响应客户端的读写请求。（对数据更新具备高可用性）
分区容错性（P）：以实际效果而言，分区相当于对通信的时限要求。系统如果不能在时限内达成数据一致性，就意味着发生了分区的情况，必须就当前操作在C和A之间做出选择。
3.3.Partition tolerance
先看 Partition tolerance，中文叫做"分区容错"。
大多数分布式系统都分布在多个子网络。每个子网络就叫做一个区（partition）。分区容错的意思是，区间通信可能失败。比如，一台服务器放在中国，另一台服务器放在美国，这就是两个区，它们之间可能无法通信。
上图中，G1 和 G2 是两台跨区的服务器。G1 向 G2 发送一条消息，G2 可能无法收到。系统设计的时候，必须考虑到这种情况。
一般来说，分区容错无法避免，因此可以认为 CAP 的 P 总是成立。CAP 定理告诉我们，剩下的 C 和 A 无法同时做到。
3.4.Consistency
Consistency 中文叫做"一致性"。意思是，写操作之后的读操作，必须返回该值。举例来说，某条记录是 v0，用户向 G1 发起一个写操作，将其改为 v1。
接下来，用户的读操作就会得到 v1。这就叫一致性。
问题是，用户有可能向 G2 发起读操作，由于 G2 的值没有发生变化，因此返回的是 v0。G1 和 G2 读操作的结果不一致，这就不满足一致性了。
为了让 G2 也能变为 v1，就要在 G1 写操作的时候，让 G1 向 G2 发送一条消息，要求 G2 也改成 v1。
这样的话，用户向 G2 发起读操作，也能得到 v1。
3.5.Availability
Availability 中文叫做"可用性"，意思是只要收到用户的请求，服务器就必须给出回应。
用户可以选择向 G1 或 G2 发起读操作。不管是哪台服务器，只要收到请求，就必须告诉用户，到底是 v0 还是 v1，否则就不满足可用性。
3.6.Consistency 和 Availability 的矛盾
一致性和可用性，为什么不可能同时成立？答案很简单，因为可能通信失败（即出现分区容错）。
如果保证 G2 的一致性，那么 G1 必须在写操作时，锁定 G2 的读操作和写操作。只有数据同步后，才能重新开放读写。锁定期间，G2 不能读写，没有可用性不。
如果保证 G2 的可用性，那么势必不能锁定 G2，所以一致性不成立。
综上所述，G2 无法同时做到一致性和可用性。系统设计时只能选择一个目标。如果追求一致性，那么无法保证所有节点的可用性；如果追求所有节点的可用性，那就没法做到一致性。
在什么场合，可用性高于一致性？
举例来说，发布一张网页到 CDN，多个服务器有这张网页的副本。后来发现一个错误，需要更新网页，这时只能每个服务器都更新一遍。
一般来说，网页的更新不是特别强调一致性。短时期内，一些用户拿到老版本，另一些用户拿到新版本，问题不会特别大。当然，所有人最终都会看到新版本。所以，这个场合就是可用性高于一致性。
3.7. 作为服务注册中心，Eureka比zookeeper好在哪
CAP理论指出，一个分布式系统不可能同时满足C(一致性)、A(可用性)和P(分区容错性)。由于分区容错性P在是分布式系统中必须要保证的，因此我们只能在A和C之间进行权衡。
因此Zookeeper保证的是CP，Eureka则是AP。
3.7.1 Zookeeper保证CP
当向注册中心查询服务列表时，我们可以容忍注册中心返回的是几分钟以前的注册信息，但不能接受服务直接down掉不可用。也就是说，服务注册功能对可用性的要求要高于一致性。但是zk会出现这样一种情况，当master节点因为网络故障与其他节点失去联系时，剩余节点会重新进行leader选举。问题在于，选举leader的时间太长，30~120s,且选举期间整个zk集群都是不可用的，这就导致在选举期间注册服务瘫痪。在云部署的环境下，因网络问题使得zk集群失去master节点是较大概率会发生的事，虽然服务能够最终恢复，但是漫长的选举时间导致的注册长期不可用是不能容忍的。
3.7.2 Eureka保证AP
Eureka看明白了这一点，因此在设计时就优先保证可用性。Eureka各个节点都是平等的，几个节点挂掉不会影响正常节点的工作，剩余的节点依然可以提供注册和查询服务。而Eureka的客户端在向某个Eureka注册或时如果发现连接失败，则会自动切换至其它节点，只要有一台Eureka还在，就能保证注册服务可用(保证可用性)，只不过查到的信息可能不是最新的(不保证强一致性)。除此之外，Eureka还有一种自我保护机制，如果在15分钟内超过85%的节点都没有正常的心跳，那么Eureka就认为客户端与注册中心出现了网络故障，此时会出现以下几种情况：
- Eureka不再从注册列表中移除因为长时间没收到心跳而应该过期的服务
- Eureka仍然能够接受新服务的注册和查询请求，但是不会被同步到其它节点上(即保证当前节点依然可用)
- 当网络稳定时，当前实例新的注册信息会被同步到其它节点中
因此，Eureka可以很好的应对因网络故障导致部分节点失去联系的情况，而不会像zookeeper那样使整个注册服务瘫痪。
3.7.3.选择AP
放弃一致性，这里所指的一致性是强一致性，但是确保最终一致性。是很多分布式系统的选择。
小结：从cap的定理可以看出，分区容错性是一个最基本的要求，因为既然是一个分布式系统，必然要部署到两个或两个以上的节点上，否则，就不是分布式系统，因此我们只能在一致性和可用性寻求平衡。
四、Eureka注册中心高可用（HA)
4.1.Eureka基础架构
Eureka架构中的三个核心角色：
-
服务注册中心
Eureka的服务端应用，提供服务注册和发现功能，就是刚刚我们建立的eureka-server-7001 -
服务提供者
提供服务的应用，可以是SpringBoot应用，也可以是其它任意技术实现，只要对外提供的是Rest风格服务即可。本例中就是我们实现的springcloud-demo -
服务消费者
消费应用从注册中心获取服务列表，从而得知每个服务方的信息，知道去哪里调用服务方。本例中就是我们实现的springcloud-demo-consumer
4.2.高可用(HA High Availability)的Eureka Server
三高指标：高性能 高并发 高可用 (7x24x365)
Eureka Server即服务的注册中心，在刚才的案例中，我们只有一个EurekaServer，事实EurekaServer也可以是一个集群，形成高可用的Eureka中心。
Eureka Server除了单点运行之外，还可以通过运行多个实例，并进行互相注册的方式来实现高可用的部署。所以我们只需要将Eureke Server配置其他可用的 serviceUrl 就能实现高可用部署。
服务同步
多个Eureka Server之间也会互相注册为服务，当服务提供者注册到Eureka Server集群中的某个节点时，该节点会把服务的信息同步给集群中的每个节点，从而实现数据同步。因此，无论客户端访问到Eureka Server集群中的任意一个节点，都可以获取到完整的服务列表信息。
动手搭建高可用的EurekaServer
我们假设要搭建两条EurekaServer的集群，端口分别为：7001、7002、7003
1）我们修改原来的EurekaServer配置-7001：
server:
port: 7001 # 端口
spring:
application:
name: eureka-server-7001 # 应用名称，会在Eureka中显示
eureka:
instance:
hostname: eureka7001.com
client:
register-with-eureka: false # 是否注册自己的信息到EurekaServer，默认是true
fetch-registry: false #false表示自己端就是注册中心，我的职责就是维护服务实例，并不需要去检索服务
service-url: # EurekaServer的地址，现在是自己的地址，如果是集群，需要加上其它Server的地址。
defaultZone: http://eureka7002.com:7002/eureka,http://eureka7003.com:7003/eureka
所谓的高可用注册中心，其实就是把EurekaServer自己也作为一个服务进行注册，这样多个EurekaServer之间就能互相发现对方，从而形成集群。因此我们做了以下修改：
把service-url的值改成了另外一台EurekaServer的地址，而不是自己
2）我们修改原来的EurekaServer配置-7002：
server:
port: 7002 # 端口
spring:
application:
name: eureka-server-7002 # 应用名称，会在Eureka中显示
eureka:
instance:
hostname: eureka7002.com
client:
register-with-eureka: false # 是否注册自己的信息到EurekaServer，默认是true
fetch-registry: false #false表示自己端就是注册中心，我的职责就是维护服务实例，并不需要去检索服务
service-url: # EurekaServer的地址，现在是自己的地址，如果是集群，需要加上其它Server的地址。
defaultZone: http://eureka7001.com:7001/eureka,http://eureka7003.com:7003/eureka
3）我们修改原来的EurekaServer配置-7003：
server:
port: 7003 # 端口
spring:
application:
name: eureka-server-7003 # 应用名称，会在Eureka中显示
eureka:
instance:
hostname: eureka7003.com
client:
register-with-eureka: false # 是否注册自己的信息到EurekaServer，默认是true
fetch-registry: false #false表示自己端就是注册中心，我的职责就是维护服务实例，并不需要去检索服务
service-url: # EurekaServer的地址，现在是自己的地址，如果是集群，需要加上其它Server的地址。
defaultZone: http://eureka7001.com:7001/eureka,http://eureka7002.com:7002/eureka
4）在自己的hosts中加入端口映射
127.0.0.1 eureka7001.com
127.0.0.1 eureka7002.com
127.0.0.1 eureka7003.com
c:\windows\system32\drivers\etc\hosts
5）启动测试
注意：idea中一个应用不能启动两次，我们需要重新配置一个启动器：
然后启动即可。
6）springcloud-demo集群版，客户端注册服务到集群
因为EurekaServer不止一个，因此注册服务的时候，service-url参数需要变化：
# EurekaServer地址
eureka.client.service-url.defaultZone= 集群地址
7）测试服务是否注册
五、Eureka保护机制
5.1.什么是Eureka保护机制
官方解释： 自我保护模式正是一种针对网络异常波动的安全保护措施，使用自我保护模式能使Eureka集群更加的健壮、稳定的运行。
默认情况下，Eureka Client会定时的向 Eureka Server端发送心跳包，默认是30s发送一次，目的是告诉 Eureka Server当前客户端实例还处于存活状态，如果Eureka server在一定时间内没有收到实例的心跳，便会把该实例从注册表中删除（默认是90秒）,但是，如果短时间内丢失大量的实例心跳，便会触发Eureka server的自我保护机制的 ,默认自我保护机制处于开启状态，比如在开发测试时，需要频繁地重启微服务实例客户端，但是我们很少会把eureka server一起重启（因为在开发过程中不会修改eureka注册中心），当一分钟内收到的心跳数大量减少时，会触发该保护机制。可以在eureka管理界面看到Renews threshold和Renews(last min)，当Renews(last min)（最后一分钟收到的心跳数）小于Renews threshold（心跳阈值）的时候，如果某个服务实例宕机掉，触发保护机制，会出现红色的警告：
5.2.为什么要自我保护
因为同时保留"好数据"与"坏数据"总比丢掉任何数据要更好，当网络故障恢复后，这个 Eureka 节点会退出"自我保护模式"。
当一个服务未按时进行心跳续约时，在生产环境下，因为网络延迟等原因，心跳失败实例的比例很有可能超标，但是此时就把服务剔除列表并不妥当，因为服务可能没有宕机。Eureka就会把当前实例的注册信息保护起来，不予剔除。生产环境下这很有效，保证了大多数服务依然可用。
为了防止在一定时间内，Eureka Client与Eureka Server在网络不同的情况下，Eureka Server误将Eureka Client服务剔除，这个机制是为了对服务进行保护；
5.3.如何关闭Eureka自我保护机制
Eureka自我保护机制默认是开启的，如果如果需要关闭自我保护机制，按照下述方式： enable-self-preservation: false 开关关闭掉，然后修改客户端和服务端相关参数，保证异常服务能及时剔除；
5.3.1.Eureka Server配置
注册中心关闭自我保护机制，修改检查失效服务的时间，以确保注册中心将不可用的实例及时正确剔除
yml:
#Eureka自我保护机制
server:
#关闭eureka自我保护机制false（默认为true）
enable-self-preservation: false
# 配置Eureka Server清理无效节点的时间间隔（单位毫秒，默认60*1000毫秒,即60秒）
eviction-interval-timer-in-ms: 2000
#关闭自我保护:true 为开启自我保护，false 为关闭自我保护
eureka.server.enableSelfPreservation=false
#清理间隔(单位:毫秒，默认是 2*1000)
eureka.server.eviction.interval-timer-in-ms=2000
然后启动server和服务，观察关闭服务前后的变化
5.3.2.Eureka Client配置
减短客户端服务发送服务心跳给服务端的时间， 在开发测试时，将值设置设置小些，保证服务关闭后注册中心能及时踢出服务
eureka:
instance:
#eureka服务端在接受到实例的最后一次发出的心跳后，需要等待多久才可以将此删除，单位为秒（默认为90s），超过时间则剔除（客户端会按照此规则向Eureka服务端发送心跳检测包）
lease-expiration-duration-in-seconds: 90
#eureka客户端需要多长时间发送心跳给eureka服务端，单位为秒（默认为30s）,（客户端会按照此规则向Eureka服务端发送心跳检测包）
lease-renewal-interval-in-seconds: 2
- lease-renewal-interval-in-seconds：服务续约(renew)的间隔，默认为30秒
- lease-expiration-duration-in-seconds：服务失效时间，默认值90秒
获取服务列表
当服务消费者启动是，会检测eureka.client.fetch-registry=true参数的值，如果为true，则会从Eureka Server服务的列表只读备份，然后缓存在本地。并且每隔30秒会重新获取并更新数据。我们可以通过下面的参数来修改：
eureka:
client:
#表示eureka client间隔多久去拉取服务器注册信息,默认为30秒
registry-fetch-interval-seconds: 5
生产环境中，我们不需要修改这个值。
但是为了开发环境下，能够快速得到服务的最新状态，我们可以将其设置小一点。
5.4.开启和关闭Eureka保护机制的场景
5.4.1.开发环境关闭
当我们在使用微服务框架做项目开发的时候，如果注册中心是Eureka，因为会频繁的重启本地开发环境，调试和修改代码，但是不会频繁的重启Eureka Server，所以建议在测试环境、本地开发环境时关闭Eureka的自我保护机制，，如果触发了保护机制，则旧的服务实例没有被删除，这时请求有可能跑到旧的实例中，而该实例已经关闭了，这就导致请求错误，影响开发测试效率；
5.4.2.生产环境开启
Linux—>Docker容器化部署—>K8S
在微服务各个节点部署到生产环境了之后，建议开启Eureka自我保护环境，这一点还是比较重要的，因为在生产环境，并不会频繁的重启，而且有时在短时间内可能会发生服务与服务之间网络故障、重启Eureka Client客户端服务实例等其他原因导致通讯中断，所以一定要把自我保护机制打开，否则网络一旦终端，就无法恢复，导致误删除服务节点，造成生产故障；
六、Eureka注册中心优雅停服
由于eureka的自我保护机制，直接对服务进行停止会使得eureka serve进入自我保护模式。服务并不会从列表中删除。
6.1.不需要再 Eureka Server 中配置关闭自我保护
首先将服务开启自我保护
然后让对应的服务具有优雅停服的功能，比如provider服务
6.2.需要再服务中添加 actuator.jar 包
需要添加actuator的jar包，只需要将pom文件改成
<!--监控依赖-->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-actuator</artifactId>
</dependency>
注意actuator的依赖在spring-cloud-starter-eureka-server中，所以我们要将Eureka的依赖修改为此
上述依赖加入到Eureka的客户端中！！！
application.yml全局配置文件添加如下
management:
endpoints:
web:
exposure:
include: shutdown #暴漏shutdown端点服务
endpoint:
shutdown:
enabled: true
6.3.启动服务
然后在postman里边用post请求方式，请求如下地址
http://ip:port/actuator/shutdown
6.4.发送一个关闭服务的 URL 请求
我们也可以通过HttpClient来发送一个停止服务的请求
<dependency>
<groupId>org.apache.httpcomponents</groupId>
<artifactId>httpclient</artifactId>
<version>4.5.8</version>
</dependency>
创建一个java类
package com.bruceliu.utils;
import org.apache.http.NameValuePair;
import org.apache.http.client.entity.UrlEncodedFormEntity;
import org.apache.http.client.methods.CloseableHttpResponse;
import org.apache.http.client.methods.HttpGet;
import org.apache.http.client.methods.HttpPost;
import org.apache.http.client.utils.URIBuilder;
import org.apache.http.entity.ContentType;
import org.apache.http.entity.StringEntity;
import org.apache.http.impl.client.CloseableHttpClient;
import org.apache.http.impl.client.HttpClients;
import org.apache.http.message.BasicNameValuePair;
import org.apache.http.util.EntityUtils;
import java.io.IOException;
import java.net.URI;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
public class HttpClientUtil {
public static String doGet(String url, Map<String, String> param) {
// 创建Httpclient对象
CloseableHttpClient httpclient = HttpClients.createDefault();
String resultString = "";
CloseableHttpResponse response = null;
try {
// 创建uri
URIBuilder builder = new URIBuilder(url);
if (param != null) {
for (String key : param.keySet()) {
builder.addParameter(key, param.get(key));
}
}
URI uri = builder.build();
// 创建http GET请求
HttpGet httpGet = new HttpGet(uri);
// 执行请求
response = httpclient.execute(httpGet);
// 判断返回状态是否为200
if (response.getStatusLine().getStatusCode() == 200) {
resultString = EntityUtils.toString(response.getEntity(), "UTF-8");
}
} catch (Exception e) {
e.printStackTrace();
} finally {
try {
if (response != null) {
response.close();
}
httpclient.close();
} catch (IOException e) {
e.printStackTrace();
}
}
return resultString;
}
public static String doGet(String url) {
return doGet(url, null);
}
public static String doPost(String url, Map<String, String> param) {
// 创建Httpclient对象
CloseableHttpClient httpClient = HttpClients.createDefault();
CloseableHttpResponse response = null;
String resultString = "";
try {
// 创建Http Post请求
HttpPost httpPost = new HttpPost(url);
// 创建参数列表
if (param != null) {
List<NameValuePair> paramList = new ArrayList<>();
for (String key : param.keySet()) {
paramList.add(new BasicNameValuePair(key, param.get(key)));
}
// 模拟表单
UrlEncodedFormEntity entity = new UrlEncodedFormEntity(paramList, "utf-8");
httpPost.setEntity(entity);
}
// 执行http请求
response = httpClient.execute(httpPost);
resultString = EntityUtils.toString(response.getEntity(), "utf-8");
} catch (Exception e) {
e.printStackTrace();
} finally {
try {
response.close();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
return resultString;
}
public static String doPost(String url) {
return doPost(url, null);
}
public static String doPostJson(String url, String json) {
// 创建Httpclient对象
CloseableHttpClient httpClient = HttpClients.createDefault();
CloseableHttpResponse response = null;
String resultString = "";
try {
// 创建Http Post请求
HttpPost httpPost = new HttpPost(url);
// 创建请求内容
StringEntity entity = new StringEntity(json, ContentType.APPLICATION_JSON);
httpPost.setEntity(entity);
// 执行http请求
response = httpClient.execute(httpPost);
resultString = EntityUtils.toString(response.getEntity(), "utf-8");
} catch (Exception e) {
e.printStackTrace();
} finally {
try {
response.close();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
return resultString;
}
public static void main(String[] args) {
String url = "http://127.0.0.1:8080/actuator/shutdown";
//该url必须要使用dopost方式来发送
HttpClientUtil.doPost(url);
}
}
执行main方法，观察服务提供者及注册中心注册的服务
服务端的服务被停止了
919
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
