Talk about RemoteRegionRegistry of eureka server



This paper mainly studies the RemoteRegionRegistry of eureka server


eureka-core-1.8.8-sources.jar! /com/netflix/eureka/registry/

     * Gets the list of all {@link Applications} from the registry in sorted
     * lexical order of {@link Application#getName()}.
     * @return the list of {@link Applications} in lexical order.
    public List<Application> getSortedApplications() {
        List<Application> apps = new ArrayList<Application>(getApplications().getRegisteredApplications());
        Collections.sort(apps, APP_COMPARATOR);
        return apps;


     * Get all applications in this instance registry, falling back to other regions if allowed in the Eureka config.
     * @return the list of all known applications
     * @see
    public Applications getApplications() {
        boolean disableTransparentFallback = serverConfig.disableTransparentFallbackToOtherRegion();
        if (disableTransparentFallback) {
            return getApplicationsFromLocalRegionOnly();
        } else {
            return getApplicationsFromAllRemoteRegions();  // Behavior of falling back to remote region can be disabled.

The default value of DisableTransparentFallbackToOtherError is false, which means GetApplicationsFromlRemoteReferences will be called.


     * Returns applications including instances from all remote regions. <br/>
     * Same as calling {@link #getApplicationsFromMultipleRegions(String[])} with a <code>null</code> argument.
    public Applications getApplicationsFromAllRemoteRegions() {
        return getApplicationsFromMultipleRegions(allKnownRemoteRegions);

Note that the allKnownRemoteRegions parameter is passed here and getapplicationsfrommultiplicities is called.


     * This method will return applications with instances from all passed remote regions as well as the current region.
     * Thus, this gives a union view of instances from multiple regions. <br/>
     * The application instances for which this union will be done can be restricted to the names returned by
     * {@link EurekaServerConfig#getRemoteRegionAppWhitelist(String)} for every region. In case, there is no whitelist
     * defined for a region, this method will also look for a global whitelist by passing <code>null</code> to the
     * method {@link EurekaServerConfig#getRemoteRegionAppWhitelist(String)} <br/>
     * If you are not selectively requesting for a remote region, use {@link #getApplicationsFromAllRemoteRegions()}
     * or {@link #getApplicationsFromLocalRegionOnly()}
     * @param remoteRegions The remote regions for which the instances are to be queried. The instances may be limited
     *                      by a whitelist as explained above. If <code>null</code> or empty no remote regions are
     *                      included.
     * @return The applications with instances from the passed remote regions as well as local region. The instances
     * from remote regions can be only for certain whitelisted apps as explained above.
    public Applications getApplicationsFromMultipleRegions(String[] remoteRegions) {

        boolean includeRemoteRegion = null != remoteRegions && remoteRegions.length != 0;

        logger.debug("Fetching applications registry with remote regions: {}, Regions argument {}",
                includeRemoteRegion, remoteRegions);

        if (includeRemoteRegion) {
        } else {
        Applications apps = new Applications();
        for (Entry<String, Map<String, Lease<InstanceInfo>>> entry : registry.entrySet()) {
            Application app = null;

            if (entry.getValue() != null) {
                for (Entry<String, Lease<InstanceInfo>> stringLeaseEntry : entry.getValue().entrySet()) {
                    Lease<InstanceInfo> lease = stringLeaseEntry.getValue();
                    if (app == null) {
                        app = new Application(lease.getHolder().getAppName());
            if (app != null) {
        if (includeRemoteRegion) {
            for (String remoteRegion : remoteRegions) {
                RemoteRegionRegistry remoteRegistry = regionNameVSRemoteRegistry.get(remoteRegion);
                if (null != remoteRegistry) {
                    Applications remoteApps = remoteRegistry.getApplications();
                    for (Application application : remoteApps.getRegisteredApplications()) {
                        if (shouldFetchFromRemoteRegistry(application.getName(), remoteRegion)) {
                  "Application {}  fetched from the remote region {}",
                                    application.getName(), remoteRegion);

                            Application appInstanceTillNow = apps.getRegisteredApplications(application.getName());
                            if (appInstanceTillNow == null) {
                                appInstanceTillNow = new Application(application.getName());
                            for (InstanceInfo instanceInfo : application.getInstances()) {
                        } else {
                            logger.debug("Application {} not fetched from the remote region {} as there exists a "
                                            + "whitelist and this app is not in the whitelist.",
                                    application.getName(), remoteRegion);
                } else {
                    logger.warn("No remote registry available for the remote region {}", remoteRegion);
        return apps;
  • Here, the remoteRegions parameter will be checked again to determine whether to includeRemoteRegion.
  • First get applications from the local registry.
  • If includeRemoteRegion is true, it is determined whether the REMOTEregion REGION REGION obtained from regionNameVSRemoteRegistry is null.
  • In addition, there is also the judgment of ShouldeftchFromRemoteregistry (Application. GetName (), Remote Region). If it is necessary to obtain, the registration information of remote registry is added to the apps result set.

shouldFetchFromRemoteRegistry(application.getName(), remoteRegion)

    private boolean shouldFetchFromRemoteRegistry(String appName, String remoteRegion) {
        Set<String> whiteList = serverConfig.getRemoteRegionAppWhitelist(remoteRegion);
        if (null == whiteList) {
            whiteList = serverConfig.getRemoteRegionAppWhitelist(null); // see global whitelist.
        return null == whiteList || whiteList.contains(appName);

It is judged here that if the AppWhitelist corresponding to the region is null, the global whiteList will prevail. if the whiteList is null or whitelist contains the app, it will return true, indicating that it needs to be obtained remotely.


eureka-core-1.8.8-sources.jar! /com/netflix/eureka/registry/

    protected void initRemoteRegionRegistry() throws MalformedURLException {
        Map<String, String> remoteRegionUrlsWithName = serverConfig.getRemoteRegionUrlsWithName();
        if (!remoteRegionUrlsWithName.isEmpty()) {
            allKnownRemoteRegions = new String[remoteRegionUrlsWithName.size()];
            int remoteRegionArrayIndex = 0;
            for (Map.Entry<String, String> remoteRegionUrlWithName : remoteRegionUrlsWithName.entrySet()) {
                RemoteRegionRegistry remoteRegionRegistry = new RemoteRegionRegistry(
                        new URL(remoteRegionUrlWithName.getValue()));
                regionNameVSRemoteRegistry.put(remoteRegionUrlWithName.getKey(), remoteRegionRegistry);
                allKnownRemoteRegions[remoteRegionArrayIndex++] = remoteRegionUrlWithName.getKey();
        }"Finished initializing remote region registries. All known remote regions: {}",
                (Object) allKnownRemoteRegions);

When eureka server initializes, it will call the initRemoteRegionRegistry method, which reads the configuration of remoteRegionUrlsWithName, and then creates a new RemoteRegionRegistry and puts it into the regionNameVSRemoteRegistry. In addition, it will also record regionName into allKnownRemoteRegions.
This method initializes the regionNameVSRemoteRegistry variable and allKnownRemoteRegions variable needed by the previous classes.


Eureka server’s getApplications method has a fallback by default, that is, it will pull the registration information of remoteRegion to the local, if remoteRegion is configured. The advantage of this is that if the service is deployed in different regions, if the service instances of the local region are all hung up, but the local eureka server is not hung up, then it will fallback to the service instances of the remote region, improving the availability.