Eureka自我保护机制

本文来说下Eureka自我保护机制

---

为什么要有自我保护机制

众所周知，Eureka在CAP理论当中是属于AP ， 也就说当产生网络分区时，Eureka保证系统的可用性，但不保证系统里面数据的一致性， 举个例子。

当发生网络分区的时候，Eureka-Server和client端的通信被终止，server端收不到大部分的client的续约，这个时候，如果直接将没有收到心跳的client端自动剔除，那么会将可用的client端剔除，这不符合AP理论，所以Eureka宁可保留也许已经宕机了的client端 ， 也不愿意将可以用的client端一起剔除。 从这一点上，也就保证了Eureka程序的健壮性，符合AP理论。

---

重要变量

this.expectedNumberOfRenewsPerMin = count * 2;
this.numberOfRenewsPerMinThreshold =(int) (this.expectedNumberOfRenewsPerMin * serverConfig.getRenewalPercentThreshold());

expectedNumberOfRenewsPerMin ：每分钟最大的续约数量，由于客户端是每30秒续约一次，一分钟就是续约2次， count代表的是客户端数量。

所以这个变量的计算公式 ： 客户端数量*2

numberOfRenewsPerMinThreshold ： 每分钟最小续约数量， 使用expectedNumberOfRenewsPerMin * serverConfig.getRenewalPercentThreshold()。
serverConfig.getRenewalPercentThreshold()的默认值为0.85 ， 也就是说每分钟的续约数量要大于85% 。

Eureka的自我保护机制，都是围绕这两个变量来实现的， 如果每分钟的续约数量小于numberOfRenewsPerMinThreshold ， 就会开启自动保护机制。

在此期间，不会再主动剔除任何一个客户端。

---

变量更新

Eureka-Server初始化，cancle主动下线， 客户端注册 ,定时器， 这四个场景会更新这两个变量。

---

Eureka-Server初始化

 protected void initEurekaServerContext() throws Exception {
 
     // ....省略N多代码
     // 服务刚刚启动的时候，去其他服务节点同步客户端的数量。
     int registryCount = this.registry.syncUp();
     // 这个方法里面计算expectedNumberOfRenewsPerMin的值
     this.registry.openForTraffic(this.applicationInfoManager, registryCount);
  
     // Register all monitoring statistics.
     EurekaMonitors.registerAllStats();
 }

 this.registry.openForTraffic(this.applicationInfoManager, registryCount);

 @Override
 public void openForTraffic(ApplicationInfoManager applicationInfoManager, int count) {
 
      // 此处初始化值，客户端数量*2 
     this.expectedNumberOfRenewsPerMin = count * 2;
      // serverConfig.getRenewalPercentThreshold() 默认为0.85
     this.numberOfRenewsPerMinThreshold =
             (int) (this.expectedNumberOfRenewsPerMin * serverConfig.getRenewalPercentThreshold());
      // ...省略N多代码
      // 开启定时清理过期客户端的定时器
     super.postInit();
}

---

cancle主动下线

 @Override
 public boolean cancel(final String appName, final String id,
                        final boolean isReplication) {
      if (super.cancel(appName, id, isReplication)) {
          replicateToPeers(Action.Cancel, appName, id, null, null, isReplication);
          synchronized (lock) {
              if (this.expectedNumberOfRenewsPerMin > 0) {
                  // 重点在这里，，，，，主动下线的时候，需要去更新每分钟最大续约数，
                  // 一个客户端的每30秒续约一次，一分钟就是续约两次，所以需要减2.
                  this.expectedNumberOfRenewsPerMin = this.expectedNumberOfRenewsPerMin - 2;
                  this.numberOfRenewsPerMinThreshold =
                         (int) (this.expectedNumberOfRenewsPerMin * serverConfig.getRenewalPercentThreshold());
             }
         }
         return true;
     }
     return false;
}

---

客户端注册

public void register(InstanceInfo registrant, int leaseDuration, boolean isReplication) {

     try {
         read.lock();
          // ....省略 N多代码
 
          if (existingLease != null && (existingLease.getHolder() != null)) {
              // ....省略 N多代码
          } else {
  
             synchronized (lock) {
                 if (this.expectedNumberOfRenewsPerMin > 0) {
                     // 重点在这里， 注册一个客户端，一个客户端每分钟需要两次续约，所以这里加2 
                     this.expectedNumberOfRenewsPerMin = this.expectedNumberOfRenewsPerMin + 2;
                     this.numberOfRenewsPerMinThreshold =
                             (int) (this.expectedNumberOfRenewsPerMin * serverConfig.getRenewalPercentThreshold());
                 }
             }
             logger.debug("No previous lease information found; it is new registration");
         }
         // ....省略 N多代码
     } finally {
         read.unlock();
     }
}

---

定时器

在Eureka-Server启动的时候，会进行初始化，执行路径如下：

DefaultEurekaServerContext 》@PostConstruct修饰的initialize()方法》init()

 @Override
 public void init(PeerEurekaNodes peerEurekaNodes) throws Exception {
      // .... 省略N多代码
      // 启动定时器
      scheduleRenewalThresholdUpdateTask();
      // .... 省略N多代码
  }
 
 
 private void scheduleRenewalThresholdUpdateTask() {
 
     timer.schedule(new TimerTask() {
                        @Override
                        public void run() {
                            updateRenewalThreshold();
                        }
                    }, serverConfig.getRenewalThresholdUpdateIntervalMs(),
             serverConfig.getRenewalThresholdUpdateIntervalMs());
 }


 private void updateRenewalThreshold() {
     try {
         Applications apps = eurekaClient.getApplications();
         // 计算有效的应用实例数量
         int count = 0;
         for (Application app : apps.getRegisteredApplications()) {
             for (InstanceInfo instance : app.getInstances()) {
                 if (this.isRegisterable(instance)) {
                     ++count;
                 }
             }
         }
         synchronized (lock) {
             // 重新计算值
             if ((count * 2) > (serverConfig.getRenewalPercentThreshold() * numberOfRenewsPerMinThreshold)
                     || (!this.isSelfPreservationModeEnabled())) {
                 this.expectedNumberOfRenewsPerMin = count * 2;
                 this.numberOfRenewsPerMinThreshold = (int) ((count * 2) * serverConfig.getRenewalPercentThreshold());
             }
          }
         logger.info("Current renewal threshold is : {}", numberOfRenewsPerMinThreshold);
     } catch (Throwable e) {
         logger.error("Cannot update renewal threshold", e);
     }
}

renewalThresholdUpdateIntervalMs : 默认为15分钟serverConfig.getRenewalPercentThreshold() * numberOfRenewsPerMinThreshold 这个地方有个这个比较，当前最小续约数0.85 ， 然后呢，count2 要大于他，这个意思，主要是为了防止开启自我保护机制之后，被定时器重新计算了expectedNumberOfRenewsPerMin 和numberOfRenewsPerMinThreshold 的值。

---

自我保护机制

一句话总结：某时刻某一个微服务不可以用了，eureka不会立刻清理，依旧会对该微服务的信息进行保存！

• 默认情况下，如果EurekaServer在一定时间内没有接收到某个微服务实例的心跳，EurekaServer将会注销该实例（默认90秒）。但是当网络分区故障发生时，微服务与Eureka之间无法正常通行，以上行为可能变得非常危险了–因为微服务本身其实是健康的，此时本不应该注销这个服务。Eureka通过自我保护机制来解决这个问题–当EurekaServer节点在短时间内丢失过多客户端时（可能发生了网络分区故障），那么这个节点就会进入自我保护模式。一旦进入该模式，EurekaServer就会保护服务注册表中的信息，不再删除服务注册表中的数据(也就是不会注销任何微服务）。当网络故障恢复后，该EurekaServer节点会自动退出自我保护模式。
• 在自我保护模式中，EurekaServer会保护服务注册表中的信息，不再注销任何服务实例。当它收到的心跳数重新恢复到阈值以上时，该EurekaServer节点就会自动退出自我保护模式。它的设计哲学就是宁可保留错误的服务注册信息，也不盲目注销任何可能健康的服务实例。一句话：好死不如赖活着。
• 综上，自我保护模式是一种应对网络异常的安全保护措施。它的架构哲学是宁可同时保留所有微服务（健康的微服务和不健康的微服务都会保留），也不盲目注销任何健康的微服务。使用自我保护模式，可以让Eureka集群更加的健壮和稳定。
• 在SpringCloud中，可以使用eureka.server.enable-self-preservation=false禁用自我保护模式【不推荐关闭自我保护机制】

---

开启

定期清理任务的线程最终执行的是这个方法，这里就直接开始讲

public void evict(long additionalLeaseMs) {

      logger.debug("Running the evict task");
      // 是否需要开启自我保护机制，如果需要，那么直接RETURE， 不需要继续往下执行了
      if (!isLeaseExpirationEnabled()) {
          logger.debug("DS: lease expiration is currently disabled.");
          return;
      }
 
      // ..... 省略N多代码，。这下面主要是做服务自动下线的操作的

 }

 @Override
public boolean isLeaseExpirationEnabled() {
      // 是否开启自我保护机制，这是个配置，默认为true
      if (!isSelfPreservationModeEnabled()) {
         return true;
      }
      // 计算是否需要自我保护
     return numberOfRenewsPerMinThreshold > 0 && getNumOfRenewsInLastMin() > numberOfRenewsPerMinThreshold;
}

从上面可以导，判断是否开启自我保护机制，主要在于计算每分钟最小续约数的值， getNumOfRenewInLastMin()这个获取的是每分钟的续约数量（每个客户端来续约的时候，都是会更新这个值得，每分钟重置一次，有线程去跑的）， 如果每分钟的续约数量>最小续约数，则不需要开启自我保护机制， 如果是小于，那么就是需要开启， 所以当返回false的时候，就需要开启自我保护机制了。

PS： 其实说白了，自我保护机制，就是在定时任务执行之前，判断每分钟的续约数量，然后决定是否继续执行下去。因此Eureka Server的过期时间（默认60s） ,客户端的续约时间（默认30s） , 这个配置最好不要更改，如果更改的话就会打破自我保护机制的规则。

---

解除

解除

• 当服务的网络分区解除之后，客户端能够和服务进行交互时，在续约的时候，更新每分钟的续约数，当每分钟的续约数大于85%时，则自动解除。
• 重启服务

---

本文小结

本文详细介绍了Eureka自我保护机制。