Eureka注冊中心原理

1、簡介

Eureka 是 Netflix 出品的用於實現 服務注冊和發現的工具，Spring Cloud 封裝了 Netflix 公司開發的 Eureka 模塊來實現服務注冊和發現Eureka采用C-S的設計架構，包含Eureka Server 和Eureka Client兩個組件。

 2、原理

（圖片引用網上的）

2、一致性算法

CAP理論：C(一致性)、A(可用性)和P(分區容錯性)。

• 一致性：它要求在同一時刻點，分布式系統中的所有數據備份都處於同一狀態。
• 可用性：在系統集群的一部分節點宕機后，系統依然能夠響應用戶的請求。
• 分區容錯性：在網絡區間通信出現失敗，系統能夠容忍。

CAP理論指出，一個分布式系統不可能同時滿足C、A和P。基於網絡不穩定型，在分布式系統必須保證P在，因此我們只能在A和C之間進行權衡。

Zookeeper保證CP：
Zookeeper采用主從模式、paxos算法保證服務一致性，有leader節點和follow節點。當leader節點down掉之后，剩余節點會重新進行選舉。選舉過程中會導致服務不可用，丟掉了可用行。

Consul保證CP：

Consul采用主從模式、Raft算法保證服務一致性、基於Go語言開發的支持多數據中心分布式高可用的服務發布和注冊服務軟件；支持健康檢查，集群間通過RPC的方式調用(HTTP和DNS)。

Eureka保證AP：
Eureka各個節點是平等的，部分節點掛掉不影響正常節點的工作，剩余節點依然可以提供注冊和查詢服務。Eureka客戶端在向某個Eureka服務端注冊或發現連接失敗時，則會自動切換至其它Eureka服務端節點，只要有一個Eureka服務端節點正常，就能保證注冊服務可用(保證可用性)，只不過查到的信息可能不是最新的(不保證強一致性)。

 

常用服務發現產品對比：

3、架構圖

Eureka注冊中心未使用任何數據強一致性算法，僅通過注冊中心之間注冊服務數據復制方式保證的最終一致性。放棄數據強一致性，提升了注冊的效率、降低了注冊代價，同時提高了集群運行的健壯性。

4、健康檢查

 

5、服務端啟動過程分析

啟動服務從注解開始：@EnableEurekaServer

@EnableDiscoveryClient //客戶端發現與注冊 2 @Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Import(EurekaServerMarkerConfiguration.class) //服務端通過注解方式引入，啟動服務端 6 public @interface EnableEurekaServer {}

通過EurekaServerMarkerConfiguration類，找到EurekaServerAutoConfiguration自動配置類：

@Configuration
@Import(EurekaServerInitializerConfiguration.class) //注冊中心初始化器配置
@ConditionalOnBean(EurekaServerMarkerConfiguration.Marker.class) //發現上面的注解中引入Bean
@EnableConfigurationProperties({ EurekaDashboardProperties.class, //注冊中心可視化儀表板屬性
        InstanceRegistryProperties.class }) //實例注冊屬性
@PropertySource("classpath:/eureka/server.properties")
public class EurekaServerAutoConfiguration extends WebMvcConfigurerAdapter {
。。。。。。
}

類EurekaServerInitializerConfiguration初始化啟動注冊中心：

    @Override
    public void start() {
        new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    //TODO: is this class even needed now?
                    eurekaServerBootstrap.contextInitialized(EurekaServerInitializerConfiguration.this.servletContext);  9                     log.info("Started Eureka Server");

                    publish(new EurekaRegistryAvailableEvent(getEurekaServerConfig()));
                    EurekaServerInitializerConfiguration.this.running = true;
                    publish(new EurekaServerStartedEvent(getEurekaServerConfig()));
                }
                catch (Exception ex) {
                    // Help!
                    log.error("Could not initialize Eureka servlet context", ex);
                }
            }
        }).start(); //啟動一個新線程，在新線程中啟動注冊中心
    }

 

    public void contextInitialized(ServletContext context) {
        try {
            initEurekaEnvironment(); //初始化環境
            initEurekaServerContext(); //初始化上下文

            context.setAttribute(EurekaServerContext.class.getName(), this.serverContext);
        }
        catch (Throwable e) {
            log.error("Cannot bootstrap eureka server :", e);
            throw new RuntimeException("Cannot bootstrap eureka server :", e);
        }
    }

 

    protected void initEurekaEnvironment() throws Exception {
        log.info("Setting the eureka configuration..");

        String dataCenter = ConfigurationManager.getConfigInstance().getString(EUREKA_DATACENTER);
        if (dataCenter == null) {
            log.info(
                    "Eureka data center value eureka.datacenter is not set, defaulting to default");
            ConfigurationManager.getConfigInstance().setProperty(ARCHAIUS_DEPLOYMENT_DATACENTER, DEFAULT); //archaius.deployment.datacenter 11         }
        else {
            ConfigurationManager.getConfigInstance().setProperty(ARCHAIUS_DEPLOYMENT_DATACENTER, dataCenter);15         }
        String environment = ConfigurationManager.getConfigInstance().getString(EUREKA_ENVIRONMENT);
        if (environment == null) {
            ConfigurationManager.getConfigInstance().setProperty(ARCHAIUS_DEPLOYMENT_ENVIRONMENT, TEST); //archaius.deployment.environment 21             log.info(
                    "Eureka environment value eureka.environment is not set, defaulting to test");
        }
        else {
            ConfigurationManager.getConfigInstance().setProperty(ARCHAIUS_DEPLOYMENT_ENVIRONMENT, environment);
        }
    }

 

    protected void initEurekaServerContext() throws Exception {
        // For backward compatibility
        JsonXStream.getInstance().registerConverter(new V1AwareInstanceInfoConverter(),
                XStream.PRIORITY_VERY_HIGH);
        XmlXStream.getInstance().registerConverter(new V1AwareInstanceInfoConverter(),
                XStream.PRIORITY_VERY_HIGH);

        if (isAws(this.applicationInfoManager.getInfo())) {
            this.awsBinder = new AwsBinderDelegate(this.eurekaServerConfig, this.eurekaClientConfig, this.registry, this.applicationInfoManager);
            this.awsBinder.start();
        }

        EurekaServerContextHolder.initialize(this.serverContext);

        log.info("Initialized server context");

        // Copy registry from neighboring eureka node
        int registryCount = this.registry.syncUp();
        this.registry.openForTraffic(this.applicationInfoManager, registryCount);

        // Register all monitoring statistics.
        EurekaMonitors.registerAllStats(); //注冊監控中的統計數據
    }

 

客戶端將注冊服務到注冊中心，在org.springframework.cloud.netflix.eureka.server.InstanceRegistry類中，該類繼承com.netflix.eureka.registry.PeerAwareInstanceRegistryImpl類；PeerAwareInstanceRegistryImpl類繼承抽象類com.netflix.eureka.registry.AbstractInstanceRegistry（*），該類中的屬性registry屬性保存注冊服務數據。

private final ConcurrentHashMap registry = new ConcurrentHashMap(); //抽閑類使用ConcurrentHashMap作為數據中心，將數據保存在內存中

  

7、客戶端注冊過程分析

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
@Import(EnableDiscoveryClientImportSelector.class)
public @interface EnableDiscoveryClient {

    /**
     * If true, the ServiceRegistry will automatically register the local server.
     */
    boolean autoRegister() default true;
}

 

org.springframework.cloud.netflix.eureka.EurekaDiscoveryClientConfiguration類自動注冊服務內屬性serviceRegistry（org.springframework.cloud.netflix.eureka.serviceregistry.EurekaServiceRegistry類實例，實現org.springframework.cloud.client.serviceregistry.ServiceRegistry<EurekaRegistration>接口）調用register方法注冊服務。

    @Override
    public void start() { //實現org.springframework.context.Lifecycle生命周期接口start方法  3         // only set the port if the nonSecurePort is 0 and this.port != 0
        if (this.port.get() != 0 && this.registration.getNonSecurePort() == 0) {
            this.registration.setNonSecurePort(this.port.get());
        }

        // only initialize if nonSecurePort is greater than 0 and it isn't already running
        // because of containerPortInitializer below
        if (!this.running.get() && this.registration.getNonSecurePort() > 0) {

            this.serviceRegistry.register(this.registration); //注冊服務 13 
            this.context.publishEvent(new InstanceRegisteredEvent<>(this, this.registration.getInstanceConfig()));
            this.running.set(true);
        }
    }

 注冊服務客戶端：

    @Override
    public void register(EurekaRegistration reg) {
        maybeInitializeClient(reg);

        if (log.isInfoEnabled()) {
            log.info("Registering application " + reg.getInstanceConfig().getAppname()
                    + " with eureka with status "
                    + reg.getInstanceConfig().getInitialStatus());
        }

        reg.getApplicationInfoManager()
                .setInstanceStatus(reg.getInstanceConfig().getInitialStatus());

        if (reg.getHealthCheckHandler() != null) {
            reg.getEurekaClient().registerHealthCheck(reg.getHealthCheckHandler());
        }
    }

 

待完善！