Part 01: distributed registry

author : TaoYuanming of the Western Wei Dynasty
Blog : https://blog.springlearn.cn/

A big copy of the world code , Copying around can improve , See if you can copy ！

One 、 What is a registry

What is? Registry Center , Registry Center It is often encountered under the distributed application system . For distributed system applications, it is horizontal expansion . Here's the picture User App This service , have 2 Servers
But when users come in from the gateway to access , How does the gateway know this User App How many services are there and what is the network address of each service ? So we need a place to collect the address and name of each application .
Often this place is called Registry Center . Applications in a distributed environment will register their own network address to this place at startup , And naming .

Two 、 The role of the registry

But can the registry only register services ? Of course not. , If you only do this thing , Then isn't it a waste of your own resources ? The registration center should do

Okay , Let's look at the distributed environment , How much is the location of the Registration Center important 了 , If there is no registry , The services on the network are Blind person 了 . So this system
We should reconsider his design Usability , And even if the registration center hangs up , Don't be blind between services . At least leave one to the Registration Center Restart time .

Okay , I know so much , Let's start designing directly .

3、 ... and 、 Design registry

3.1 ip The address for

The point to pay attention to here is not to get it 127.0.0.1 This local loopback address . There are many similar tool Networks , This is not the point . Just have a look .

public class HostUtils {
    
    private static String ip;
    private static String hostName;
    private static void resolveHost() throws Exception {
    
        InetAddress localHost = InetAddress.getLocalHost();
        hostName = localHost.getHostName();
        ip = localHost.getHostAddress();
        if (localHost.isLoopbackAddress()) {
    
            Enumeration<NetworkInterface> networkInterfaces = NetworkInterface.getNetworkInterfaces();
            while (networkInterfaces.hasMoreElements()) {
    
                NetworkInterface networkInterface = networkInterfaces.nextElement();
                Enumeration<InetAddress> inetAddresses = networkInterface.getInetAddresses();
                while (inetAddresses.hasMoreElements()) {
    
                    InetAddress inetAddress = inetAddresses.nextElement();
                    if (!inetAddress.isLoopbackAddress() && (inetAddress instanceof Inet4Address)) {
    
                        ip = inetAddress.getHostAddress();
                    }
                }
            }
        }
    }
    public static String getIp() {
    
        return ip;
    }
    public static String getHostName() {
    
        return hostName;
    }
    static {
    
        try {
    
            resolveHost();
        } catch (Exception e) {
    
            e.printStackTrace();
        }
    }
}

3.2 Communication protocol & Technology selection

Communication protocols are generally designed to be compatible with multilingual environments , Best used http agreement . Because it's widely used . Of course, you can also customize the Protocol . Here's a recommended one
Xiaobian is based on Netty Encapsulated communication framework mojito Here we mainly consider versatility , Use
http agreement . Because now microservices are used Spring Cloud More of , Therefore, the framework selection of our registry uses Spring Boot

Here we can use SpringBoot Of Endpoint Implement your own extension points , At the same time, you can also use the self-contained health examination ability of the service , Condition monitoring .

The implementation idea is described below

3.3 Interaction process

3.3.1 Server capability

• Provide service registration interface
  • Data can fall into the database , Also record the memory cache , Large amount of services can be considered redis
  • At the same time, it should fall into the file , Avoid the database hanging and restore it from the file to the cache
• Provide service offline interface
  • When the service is offline , Actively call the offline interface of the Registration Center , The registration center should provide the ability to passively accept offline
  • When the service condition is bad during the rotation training , Actively mark the service as offline , When the service state is restored, it is marked as normal
• Provide service health examination ability
  • Rotate the health check interface of the registered machine , Dynamically update node status
  • Start timing task , Regularly send status check , Check the client service status
• Provide service discovery interface
  • By passing the service name , Return the service list corresponding to the service name
• Provide application configuration capability
  • Achieve service isolation , Do not configure a service , Push to all servers , Just push to the corresponding node of this service
  • Can actively initiate configuration change messages

3.3.2 Client capabilities

• Service registration capability
  • Realization ApplicationContextInitializer Read the application configuration when the application starts , Then register yourself in the Registration Center
  • Configure the registry , Pull it down at the same time , Put it in Spring Configuration environment
• Take the initiative to go offline when the service is restarted or down
  • utilize @PreDestroy Destruction method , Or register Jvm Hooks Program
• Service discovery capability
  • Get the service list interface according to the service name , At the same time, cache a local copy
  • If the registry does not respond , Be able to use local cache , Give the registry a time to restart
• Listen for server configuration information
  • Refresh the monitored configuration changes to Spring Containers Dynamic binding configuration scheme reference
• Open the health check

Four 、 Common registries

Registration center comparison

4.1 Zookeeper

What is? ZooKeeper？

It can be used ZooKeeper To do it ： Unified configuration management 、 Unified naming service 、 Distributed lock 、 Cluster management .

ZooKeeper Data structure of , Follow Unix File systems are very similar , It can be seen as a tree , Each node is called ZNode. Each node can be identified by a path , Structure diagram is as follows ：

that ZooKeeper The star " Trees " What are the characteristics ？？ZooKeeper We call this the Znode,Znode There are two types ：

brief / temporary (Ephemeral)： When the client and the server are disconnected , Created Znode( node ) It will be deleted automatically
persistent (Persistent)： When the client and the server are disconnected , Created Znode( node ) Does not delete

in addition Zookeeper It provides the ability of node monitoring , When a node changes, a notification event will be initiated . We can do some things according to this feature , For example, if the node is deleted, remove the services registered on the node .

zookeepr api

4.2 Eureka

Eureka What is it ?
Eureka yes SpringBoot The default registry component . There is no ability to configure

4.3 Consul

Consul Is a tool for service discovery and configuration .Consul It's distributed , Highly available , And it's highly scalable , And it's easy to develop and use . It provides a fully functional control panel , The main features are ： Service discovery 、 health examination 、 Key value storage 、 Security service communication 、 Multi-data center 、ServiceMesh.Consul In the design, many functions to be used in distributed service governance are included .

4.4 Nacos

Nacos Commit to discovering 、 Configure and manage microservices .Nacos Provides an easy-to-use feature set , Help you realize dynamic service discovery 、 Service configuration management 、 Service and traffic management .Nacos Build... More quickly and easily 、 Deliver and manage microservice platforms . Nacos Is to build in “ service ” Modern application architecture centered ( For example, the microservices paradigm 、 Cloud native paradigm ) Service infrastructure .Nacos To support as RPC Registry Center , for example ： Support Dubbo frame ; Also have the ability of microservice registry , for example ：SpringCloud frame .

5、 ... and 、 summary

The registration centers on the market have the above , The core logic thinking is not bad . among Consul and Nacos It supports configuration . If we develop a registry , There is no need to study its source code .
Only when we want to be a registration center , At this time, we can study the source code . For general development use , Just know what he does .