Shulou(Shulou.com)06/02 Report--

This article will explain in detail what is Dive into Eureka, the content of the article is of high quality, so the editor will share it with you for reference. I hope you will have a certain understanding of the relevant knowledge after reading this article.

1. What is Eureka?

The definition of itself in its official documentation is:

Eureka is a REST (Representational State Transfer) based service that is primarily used in the AWS cloud for locating services for the purpose of load balancing and failover of middle-tier servers. We call this service, the Eureka Server. Eureka also comes with a Java-based client component,the Eureka Client, which makes interactions with the service much easier. The client also has a built-in load balancer that does basic round-robin load balancing.

To put it simply, Eureka is a Netflix open source product that provides service registration and discovery, and provides the corresponding Java client.

2. Why Eureka?

So why did we use Eureka in the project? I have roughly summed up the following reasons:

It provides a complete implementation of Service Registry and Service Discovery

First of all, it provides a complete implementation, and it also withstands the test of Netflix's own production environment, which is relatively easy to use.

Seamless integration with Spring Cloud

Our project itself uses Spring Cloud and Spring Boot, and Spring Cloud also has a very complete set of open source code to integrate Eureka, so it is very easy to use.

In addition, Eureka also supports launching in our application's own container, which means that after our application is launched, it acts as both an Eureka and a service provider. This greatly improves the availability of the service.

Open Source

The last point is open source, because the code is open source, so it is very easy for us to understand its implementation principle and troubleshooting problems.

3. Dive into Eureka

I believe you have seen here, have a preliminary understanding of Eureka, and then let's take a closer look at it.

3.1 Overview3.1.1 Basic Architecture

The figure above briefly describes the basic architecture of Eureka, which consists of three roles:

Eureka Server

Provide service registration and discovery

Service Provider

Service provider

Register your own service with Eureka so that service consumers can find

Service Consumer

Service consumer

Get a list of registered services from Eureka so that services can be consumed

It is important to note that the three roles in the above figure are all logical roles. In practice, these roles can even be the same instance, for example, in our project, Eureka Server and Service Provider are the same JVM process.

3.1.2 More in depth

The above figure further shows the interaction between the three roles.

Service Provider will do Register (service registration), Renew (service renewal), Cancel (service offline) and other operations to Eureka Server.

Registration services are synchronized between Eureka Server to ensure consistent state

Service Consumer will obtain a list of registered services from Eureka Server and consume services

3.2 Demo

To give you a more intuitive impression, we can actually run it through a simple demo to get a better understanding of Eureka.

3.2.1 Git Repository

Git warehouse: git@github.com:nobodyiam/spring-cloud-in-action.git

This project uses Spring Cloud-related class libraries, including:

Spring Cloud Config

Spring Cloud Eureka (Netflix)

3.2.2 preparation work

The Demo project uses Spring Cloud Config for configuration, so the first step is to start Config Server locally.

Since the project is based on Spring Boot development, you can run com.nobodyiam.spring.cloud.in.action.config.ConfigServerApplication directly.

3.2.3 Eureka Server Demo

The name of Eureka Server's Demo module is: eureka-server.

3.2.3.1 Maven dependency

Eureka-server is a Spring Boot-based Web application, the first thing we need to do is to introduce Spring Cloud Eureka Server dependencies into pom.

Org.springframework.cloud spring-cloud-starter-eureka-server 1.1.0.RC23.2.3.2 enables Eureka Server

Enabling EurekaServer is as simple as adding @ EnableEurekaServer.

@ EnableEurekaServer@SpringBootApplicationpublic class EurekaServiceApplication {public static void main (String [] args) {SpringApplication.run (EurekaServiceApplication.class, args);}}

After completing the above configuration, start the application, and Eureka Server will start to work!

After startup, open http://localhost:8761 and you can see the screen of successful startup.

3.2.4 Service Provider and Service Consumer Demo

The name of Service Provider's Demo module is: reservation-service.

The name of Service Consumer's Demo module is: reservation-client.

3.2.4.1 Maven dependency

Both reservation-service and reservation-client are Web applications based on Spring Boot. The first thing we need to do is to introduce Spring Cloud Eureka dependencies into pom.

Org.springframework.cloud spring-cloud-starter-eureka 1.1.0.RC23.2.4.2 starts Service Provider

Enabling Service Provider is as simple as adding @ EnableDiscoveryClient.

@ EnableDiscoveryClient@SpringBootApplicationpublic class ReservationServiceApplication {public static void main (String [] args) {new SpringApplicationBuilder (ReservationServiceApplication.class) .run (args);}}

After completing the above configuration, start the application, and Server Provider will start to work!

After startup, open http://localhost:8761 and you can see that the service has been registered with Eureka Server.

3.2.4.3 start Service Consumer

Starting Service Consumer is actually the same as Service Provider, because the client provided by Eureka is essentially indistinguishable between Provider and Consumer, and in general, Provider will also be Consumer.

@ EnableDiscoveryClient@SpringBootApplicationpublic class ReservationClientApplication {@ Bean CommandLineRunner runner (DiscoveryClient dc) {return args-> {dc.getInstances ("reservation-service") .forEach (si-> System.out.println (String.format ("Found% s% s% s", si.getServiceId (), si.getHost (), si.getPort ();} } public static void main (String [] args) {SpringApplication.run (ReservationClientApplication.class, args);}}

All the currently registered reservation-service services can be obtained through dc.getInstances ("reservation-service") in the above code.

3.3 Eureka Server implementation details

Looking at the previous demo, we have a preliminary appreciation of the power of Spring Cloud and Eureka, through just a few lines of configuration to achieve service registration and discovery!

I'm sure you'll want to know how Eureka is implemented, so let's move on to Dive! First of all, let's take a look at several external interface implementations of Eureka Server.

3.3.1 Register

First, let's take a look at Register (Service Registration). This interface is called when Service Provider starts to implement service registration. At the same time, when the service status of Service Provider changes (such as when self-detection considers Down), it will also be called to update the service status.

The interface implementation is relatively simple, as shown in the following figure.

The ApplicationResource class receives the Http service request and calls the register method of PeerAwareInstanceRegistryImpl

After PeerAwareInstanceRegistryImpl completes the service registration, call replicateToPeers to synchronize the status to other Eureka Server nodes (Peer)

The list of registered services is saved in a nested hash map:

The key of the first layer of hash map is app name, which is the name of the application.

The key of the second layer hash map is instance name, which is the name of the instance.

Taking the screenshot in 3.2.4.2 as an example, RESERVATION-SERVICE is app name,jason-mbp.lan:reservation-service:8000 and instance name.

Hash map is defined as follows:

Private final ConcurrentHashMap registry = new ConcurrentHashMap (); 3.3.2 Renew

The Renew (Service Renewal) operation is invoked periodically by Service Provider, similar to heartbeat. It is mainly used to tell Eureka Server Service Provider that the service is still alive and avoid the service being removed. The interface implementation is shown in the following figure.

As you can see, the interface is implemented in the same way as register: first update its own status, and then synchronize to other Peer.

3.3.4 Fetch Registries

Fetch Registries is called by Service Consumer to get the services registered on Eureka Server.

To improve performance, the list of services is cached in Eureka Server and updated every 30 seconds.

3.3.6 How Peer Replicates

In the previous implementations of Register, Renew, and Cancel interfaces, we have seen that there will be replicateToPeers operations, which are used to synchronize the state between Peer.

In this way, Service Provider only needs to notify any Eureka Server to ensure that the status will be updated in all Eureka Server.

The specific implementation is actually very simple, that is, the Eureka Server that receives the Service Provider request, forwards the request to another Eureka Server, calls the same API, and passes in the same parameters, except that the isReplication=true will be marked in the header to avoid duplicate replicate.

3.3.7 How Peer Nodes are Discovered

Then you may wonder, how does Eureka Server know how many Peer there are?

After EurekaServer starts, it calls EurekaClientConfig.getEurekaServerServiceUrls to get all the Peer nodes and updates them periodically. The frequency of periodic updates can be configured through eureka.server.peerEurekaNodesUpdateIntervalMs.

The default implementation of this method is to read from the configuration file, so if the Eureka Server node is relatively fixed, it can be configured in the configuration file.

If you want to have more flexible control of EurekaServer nodes, such as dynamic capacity expansion / reduction, you can provide your own implementation by using override getEurekaServerServiceUrls method. For example, our project will read the EurekaServer list through the database.

The specific implementation is shown in the following figure:

3.4 Service Provider implementation details

Now let's take a look at the implementation details of Service Provider, which are mainly Register, Renew, and Cancel.

3.4.1 Register

A very important step for Service Provider to provide services is to register itself on Eureka Server.

The implementation of this part is relatively simple, you only need to call the Eureka Server interface to register during startup and when the instance state changes. It is important to note that you need to make sure that eureka.client.registerWithEureka=true is configured.

3.4.3 Cancel

When the Service Provider service shut down, you need to inform Eureka Server to delete itself in time, so as to prevent the client from invoking the offline service.

The logic itself is relatively simple, and by marking the method @ PreDestroy, it will be triggered when the shut down is served.

3.5 Service Consumer implementation details

The implementation of Service Consumer is relatively simple because it only involves getting and updating the list of services from Eureka Server.

3.5.1 Fetch Service Registries

Service Consumer fetches a list of all services from Eureka Server at startup and caches them locally. It is important to note that you need to make sure that eureka.client.shouldFetchRegistry=true is configured.

3.5.3 How Eureka Servers are Discovered

Service Consumer, like Service Provider, has a problem of how to know the Eureka Server address.

In fact, because Service Consumer and Service Provider essentially use the same Eureka client, this part of the logic is the same, so I won't repeat it here.

On what is Dive into Eureka to share here, I hope that the above content can be of some help to you, can learn more knowledge. If you think the article is good, you can share it for more people to see.

Welcome to subscribe "Shulou Technology Information " to get latest news, interesting things and hot topics in the IT industry, and controls the hottest and latest Internet news, technology news and IT industry trends.