eureka

一、参考地址

二、仍然拷贝一份介绍

　　Eureka是一项基于REST（代表性状态转移）的服务，主要在AWS云中用于定位服务，以实现负载均衡和中间层服务器的故障转移。

在Netflix，Eureka除了在中间层负载平衡中发挥关键作用外，还用于以下目的。

• 为了协助Netflix Asgard，这是一项开放源代码服务，可简化云部署，

  • 在发生问题的情况下快速回滚版本，避免重新启动100个实例，这可能需要很长时间。
  • 在滚动推送中，以避免出现问题时将新版本传播到所有实例。

• 对于我们的cassandra（一种分布式key-value数据库）部署，可以使实例流量减少以进行维护。

• 为我们的memcached（分布式的高速内存型缓存系统）缓存服务标识环中的节点列表。

• 用于出于各种其他原因承载有关服务的其他其他特定于应用程序的元数据。

三、如何开始应用

• 启动Eureka-Server：文档参考

  @SpringBootApplication
  @EnableEurekaServer
  public class Application {
  
      public static void main(String[] args) {
          new SpringApplicationBuilder(Application.class).web(true).run(args);
      }
  
  }

• 配置文件：文档参考

  spring:
    application:
      # 应用名称，服务中心注册的是这个，同名被认为是同一个服务
      name: eureka-server
  eureka:
    client:
      # 是否注册到服务中心，一般服务中心本身不注册到服务中心是可以的
      register-with-eureka: false
      # 设置成true的时候，启动的时候会同步服务中心的注册信息（这个是客户端的操作）
      fetch-registry: false
  ---
  spring:
    # 可以被认为用于区分不同的配置环境用
    profiles:
      peer1
  eureka:
    client:
      # 配置服务中心地址
      serviceUrl:
        defaultZone: http://peer1:8761/eureka/,http://peer2:8762/eureka/,http://peer3:8763/eureka/
    instance:
      # 域名地址，不过个人感觉应该生产环境用集群内的高并发会比较多，应该会用内网IP吧
      hostname: peer1
  server:
    port: 8761
  ---
  spring:
    profiles: peer2
  server:
    port: 8762
  eureka:
    client:
      serviceUrl:
        defaultZone: http://peer1:8761/eureka/,http://peer2:8762/eureka/,http://peer3:8763/eureka/
    instance:
      hostname: peer2
  ---
  spring:
    profiles: peer3
  server:
    port: 8763
  eureka:
    client:
      serviceUrl:
        defaultZone: http://peer1:8761/eureka/,http://peer2:8762/eureka/,http://peer3:8763/eureka/
    instance:
      hostname: peer3

四、源码阅读：

• 入口：@EnableEurekaServer->@Import EurekaServerMarkerConfiguration->bean Marker->EurekaServerAutoConfiguration(@ConditionalOnBean(EurekaServerMarkerConfiguration.Marker.class))

• EurekaServerAutoConfiguration

  • DefaultEurekaServerContext

    　　 @Bean
        @ConditionalOnMissingBean
        public EurekaServerContext eurekaServerContext(ServerCodecs serverCodecs,
                PeerAwareInstanceRegistry registry, PeerEurekaNodes peerEurekaNodes) {
            return new DefaultEurekaServerContext(this.eurekaServerConfig, serverCodecs,
                    registry, peerEurekaNodes, this.applicationInfoManager);
        }

    • initialize->peerEurekaNodes.start();　// 同步和开启定时同步节点信息

      public void start() {
              taskExecutor = Executors.newSingleThreadScheduledExecutor(
                      new ThreadFactory() {
                          @Override
                          public Thread newThread(Runnable r) {
                              Thread thread = new Thread(r, "Eureka-PeerNodesUpdater");
                              thread.setDaemon(true);
                              return thread;
                          }
                      }
              );
              try {
                  updatePeerEurekaNodes(resolvePeerUrls());
                  Runnable peersUpdateTask = new Runnable() {
                      @Override
                      public void run() {
                          try {
                              updatePeerEurekaNodes(resolvePeerUrls());
                          } catch (Throwable e) {
                              logger.error("Cannot update the replica Nodes", e);
                          }
      
                      }
                  };
                  taskExecutor.scheduleWithFixedDelay(
                          peersUpdateTask,
                          serverConfig.getPeerEurekaNodesUpdateIntervalMs(),
                          serverConfig.getPeerEurekaNodesUpdateIntervalMs(),
                          TimeUnit.MILLISECONDS
                  );
              } catch (Exception e) {
                  throw new IllegalStateException(e);
              }
              for (PeerEurekaNode node : peerEurekaNodes) {
                  logger.info("Replica node URL:  {}", node.getServiceUrl());
              }
          }

    • initialize->registry.init(peerEurekaNodes);  // PeerAwareInstanceRegistryImpl ，很大一部分的逻辑就在这里了

      　　@Override
          public void init(PeerEurekaNodes peerEurekaNodes) throws Exception {
              // 最后重复的次数,这边用的是cas的方式，start里面启动一个定时器，不断将当前状态（同步的次数）同步到最后一次的状态（最后一次同步了几次）
              this.numberOfReplicationsLastMin.start();
              // 普通设值
              this.peerEurekaNodes = peerEurekaNodes;
              // 初始化response 缓存，这边有个方法shouldUseReadOnlyResponseCache（从useReadOnlyResponseCache属性读），如果设其属性为false，则不会启动定时同步write缓存到read缓存的任务，且读取的时候都从write缓存读，实现较高的一致性，这边源码不是很复杂，建议自己看一下吧
              initializedResponseCache();
              // 开启定时更新续约阈值的任务，会通过计算当前可注册的应用总数来和公式计算结果进行比较，大的话，重新设置expectedNumberOfClientsSendingRenews为可注册的应用总数，来保证稳定性；这块还没弄的很清楚
              scheduleRenewalThresholdUpdateTask();
              // 估摸着是把远程的区域注册进来
              initRemoteRegionRegistry();
      
              try {
                  // 注册到监控中
                  Monitors.registerObject(this);
              } catch (Throwable e) {
                  logger.warn("Cannot register the JMX monitor for the InstanceRegistry :", e);
              }
          }

       
• 　　

五、优化点

• 自我保护
• 剔除
• 缓存

eureka

原文：https://www.cnblogs.com/gabin/p/13759199.html