CN116566910A - A method and device for detecting the state of a node itself - Google Patents

Abstract

The application aims to provide a method and equipment for detecting the state of a node, and the method and equipment provide a corresponding data interface for each node in a cluster, wherein the response content returned when the data interface is requested is the unique identifier of the node; the node to be detected acquires main node identification information returned by the main node from load balancing; comparing the main node identification information with the identification information of the node to be detected to obtain a comparison result; and judging whether the node to be detected is a master node or not according to the comparison result. Therefore, the node can judge whether the node is a master node or a slave node or not to be distributed with user traffic by load balancing, and the self identity is not required to be obtained from a dispatching center, so that the normal operation of dispatching is ensured, and the service cost is reduced.

Description

A method and device for detecting the state of a node itself

technical field

The present application relates to the field of computers, in particular to a method and device for detecting the state of a node itself.

Background technique

In a high-availability cluster, the master-slave method is often used to build the cluster. When the pressure on the master node is high or there is a problem, the request from the client is switched to the slave node by load balancing. At this time, the slave node becomes the master node, and the previous master node becomes the slave node after the problem is fixed. The switch itself is handled by load balancing, and the master-slave node does not know whether it is the master or the slave. However, the program in the node has some exclusive operations, which can only be operated by the master node or the slave node. This method needs to add an additional dispatch center, and the service overhead increases. In the case of frequent master-slave switching, it cannot update its own data in real time, resulting in scheduling errors. When nodes need to know their own identities, they will ask the dispatch center.

Contents of the invention

One purpose of the present application is to provide a method and device for detecting the status of a node itself, so as to solve the problems in the prior art that the additional service overhead increases and the self-data cannot be updated in real time in the case of frequent master-slave switching, resulting in scheduling errors.

According to one aspect of the present application, a method for detecting the state of a node itself is provided, the method comprising:

Provide a corresponding data interface for each node in the cluster, and the response content returned when the data interface is requested is the unique identifier of the node itself;

The node to be detected obtains the master node identification information returned by the master node from the load balancer;

Comparing the identification information of the master node with the identification information of the node to be detected to obtain a comparison result;

Whether the node to be detected is the master node is judged according to the comparison result.

Optionally, the method includes:

When each node in the cluster starts, identification information is generated for the node, and the identification information is stored on the node.

Optionally, before the node to be detected obtains the master node identification information returned by the master node from the load balancer, it includes:

Judging whether the node to be detected needs to operate resources in the cluster, if so, sending the target request to the load balancer when the node to be detected obtains its own identification information;

The target request is distributed to the master node through the load balancing to obtain the master node identification information returned by the master node.

Optionally, judging whether the node to be detected is a master node according to the comparison result includes:

If the comparison result shows that the obtained identification information of the master node is consistent with its own identification information, the node to be detected is the master node, otherwise it is the slave node.

Optionally, determining whether the node to be detected needs operating resources in the cluster includes:

Determine the first master node to which load balancing distributes user request traffic;

Judging whether the health check request sent by the load balancer to the first master node returns a failure, and if so, determining that the node to be checked needs operating resources in the cluster.

Optionally, the method includes:

When the node to be detected is determined to be the master node, update the data information of the node to be detected, and receive the user flow request sent by load balancing, wherein the data information of the node includes its own node status information.

According to still another aspect of the present application, a device for detecting the state of a node itself is also provided, and the device includes:

one or more processors; and

A memory storing computer readable instructions which, when executed, cause the processor to perform operations as described above.

According to still another aspect of the present application, there is also provided a computer-readable medium, on which computer-readable instructions are stored, and the computer-readable instructions can be executed by a processor to implement the aforementioned method.

Compared with the existing technology, this application provides each node in the cluster with a corresponding data interface, and the response content returned when the data interface is requested is the unique identifier of the node itself; the node to be detected obtains the master node from load balancing Returning the identification information of the master node; comparing the identification information of the master node with the identification information of the node to be detected to obtain a comparison result; judging whether the node to be detected is a master node according to the comparison result. In this way, the node can determine whether it is a master node or a slave node, and whether user traffic is distributed by load balancing, without obtaining its own identity from the dispatch center, ensuring normal scheduling and reducing service overhead.

Description of drawings

Other characteristics, objects and advantages of the present application will become more apparent by reading the detailed description of non-limiting embodiments made with reference to the following drawings:

FIG. 1 shows a schematic flowchart of a method for detecting the state of a node itself according to an aspect of the present application;

Fig. 2 shows a schematic diagram of data transmission of each node in the cluster in an embodiment of the present application.

The same or similar reference numerals in the drawings represent the same or similar components.

Detailed ways

The application will be described in further detail below in conjunction with the accompanying drawings.

In a typical configuration of this application, the terminal, the device serving the network, and the trusted party all include one or more processors (such as a central processing unit (Central Processing Unit, CPU)), an input/output interface, a network interface, and a memory .

Memory may include non-permanent memory in computer-readable media, random access memory (Random Access Memory, RAM) and/or non-volatile memory, such as read-only memory (Read Only Memory, ROM) or flash memory (flash RAM). Memory is an example of computer readable media.

Computer-readable media, including both permanent and non-permanent, removable and non-removable media, can be implemented by any method or technology for storage of information. Information may be computer readable instructions, data structures, modules of a program, or other data. Examples of computer storage media include, but are not limited to, phase-change memory (Phase-Change RAM, PRAM), static random access memory (Static Random Access Memory, SRAM), dynamic random access memory (Dynamic Random Access Memory, DRAM), Other types of random access memory (RAM), read-only memory (ROM), Electrically Erasable Programmable Read-Only Memory (EEPROM), flash memory or other memory technologies, read-only Compact Disc Read-Only Memory (CD-ROM), Digital Versatile Disk (DVD) or other optical storage, magnetic tape cassette, tape disk storage or other magnetic storage device or any other non- Transmission media that can be used to store information that can be accessed by a computing device. As defined herein, computer-readable media excludes non-transitory computer-readable media, such as modulated data signals and carrier waves.

Fig. 1 shows a schematic flowchart of a method for detecting the state of a node itself provided according to one aspect of the present application, the method includes: step S11 to step S14, wherein, step S11 provides a corresponding data interface for each node in the cluster , the response content returned when the data interface is requested is the unique identifier of the node itself; step S12, the node to be detected obtains the master node identification information returned by the master node from the load balance; step S13, combines the master node identification information with the The identification information of the detection node itself is compared to obtain a comparison result; step S14 , judging whether the node to be detected is a master node according to the comparison result. In this way, the node can determine whether it is a master node or a slave node, and whether user traffic is distributed by load balancing, without obtaining its own identity from the dispatch center, ensuring normal scheduling and reducing service overhead.

Specifically, in step S11, a corresponding data interface is provided for each node in the cluster, and the response content returned when the data interface is requested is the unique identifier of the node itself; here, the cluster is a high-availability cluster, and each A node provides a data interface, such as the schematic diagram shown in Figure 2, providing an http interface (named /a for example), which returns the data stored on the node. For example, the http interface of node A is /a, and the interface /a returns It is stored on node A, and the http interface of node B is /b, which returns and is stored on node B; thus, using the interface provided, the node can update the received data by itself. When the http interface is requested, the response is the identification information generated by the node itself, that is, the uuid is returned, and the uuid is stored on the node. For example, the http interface of node A returns the uuid of node A, and the uuid is stored on node A.

Specifically, in step S12, the node to be detected obtains the master node identification information returned by the master node from the load balancer; here, the node to be detected is a node in the cluster that needs to detect whether its own state is the master node, and the node to be detected is obtained from Load balancing obtains the primary node identification information returned by the primary node. The primary node here is the node that load balancing has determined to distribute user traffic to. For example, the primary node determined by load balancing is node XX, and the node to be detected is node 2. Then node 2 obtains the identification information of node XX.

Specifically, in step S13, the identification information of the master node is compared with the identification information of the node to be detected to obtain the comparison result; then, in step S14, it is judged whether the node to be detected is as the master node. Here, compare the obtained identification information of node X with the identification information of node 2 itself, and then judge the identity of node 2 and whether its own status is the master node according to the comparison result. For example, the IP of the load balancer is 192.168.0.5 , then the returned result of 192.168.0.5/a is the UUID of the master node, and load balancing will distribute the request to the master node. If 192.168.0.5/a is sent from the slave node, the obtained UUID of the master node is inconsistent with its own UUID . By comparing the UUID returned by the request through the load balancing interface with the UUID generated by itself, it is no longer necessary to send a request to the dispatch center to obtain its own identity and receive the data of its own identity sent by the dispatch center, reducing service overhead.

In an embodiment of the present application, when each node in the cluster is started, identification information is generated for the node, and the identification information is stored on the node. Here, each node in the cluster generates a unique string as its identifier in the cluster when it starts, and the string is stored on the node. As shown in Figure 2, node 1 is called uuid1 and node 2 It is called uuid2. In a specific embodiment, the string of uuid1 may be: 322923be20d34c73aee7091e3bdfbdd1. The character string is stored on this node, so that the identification information of itself can be obtained directly from the information stored on this node when subsequent comparison is performed.

In an embodiment of the present application, it is judged whether the node to be detected needs to operate resources in the cluster, and if so, the node to be detected sends a target request to the load balancer when obtaining its own identification information; Request to be assigned to the master node to obtain the master node identification information returned by the master node. Here, when a node needs to operate resources, it means that the node is load-balanced to distribute user traffic and needs to perform resource processing on user traffic. When a node needs to operate resources, it needs to determine whether it is the master node, because some resource operations can only be the master node Actions, such as resources entered by the user. At this time, obtain its own identification information and send a target request to the load balancer. The target request is the user traffic request allocated by the load balancer. The user traffic request is allocated through the load balancer to determine the master node, thereby obtaining the identity information of the master node, and the master node The identification information of the node is returned to the node to be detected; for example, in Figure 2, the node that needs to operate the resource is node 2, then the node 2 that needs to operate the resource will request the obtained uuid (for example, uuid1), and compare uuid1 with its own uuid2.

Following the above embodiment, determine the first master node to which the load balancer distributes user request traffic; determine whether the health check request sent by the load balancer to the first master node returns a failure, and if so, determine that the node to be detected is in the Operational resources are required in the cluster described above. Here, user traffic requests first reach load balancing, and are distributed to a node in the cluster through load balancing. For example, before the node to be detected detects its own state, the master node assigned by load balancing is node 1, and node 1 is the second node. One master node, when user traffic requests are too concurrent, node 1 responds slowly, load balancing will send health check requests to each node at regular intervals to check whether each node is available, when node 1 responds slowly, the health check fails , at this time, the load balancer will distribute user traffic requests to other nodes, and the node to be detected may need to operate resources, that is, the load balancer may switch node 1 to the node to be detected to process user traffic requests, and node 2 will perform exclusive resource operations .

In an embodiment of the present application, in step S14, if the comparison result shows that the obtained identification information of the master node is consistent with its own identification information, the node to be detected is the master node, otherwise it is the slave node. Here, if the identity information of the master node obtained from load balancing is the same as the identity information stored by itself, the node to be detected is the master node. If it is different, the node to be detected is the slave node. For example, when node 2 compares uuid, if Then node 2 is the master node, otherwise it is the slave node.

Following the above embodiment, when the node to be detected is determined to be the master node, update the data information of the node to be detected itself, and receive the user traffic request sent by load balancing, wherein the data information of the node itself includes its own node status information . Here, when a node detects that its own status is a master node, it needs to update its own data information, that is, update its own node status information, update its master node status, and also update its own configuration information for receiving user traffic requests for processing. And it will receive the user traffic requests assigned by the load balancer to process the user traffic requests.

In addition, an embodiment of the present application further provides a computer-readable medium, on which computer-readable instructions are stored, and the computer-readable instructions can be executed by a processor to implement the aforementioned method for detecting the state of a node itself.

Corresponding to the method described above, the present application also provides a terminal, which includes modules or units capable of performing the method steps described above in FIG. 1 or FIG. 2 or in various embodiments. These modules or units can , software, or a combination of hardware and software, which is not limited in this application. For example, in an embodiment of the present application, a device for detecting the state of a node itself is also provided, and the device includes:

one or more processors; and

A memory storing computer readable instructions which, when executed, cause the processor to perform operations as described above.

For example, computer readable instructions, when executed, cause the one or more processors to:

Provide a corresponding data interface for each node in the cluster, and the response content returned when the data interface is requested is the unique identifier of the node itself;

The node to be detected obtains the master node identification information returned by the master node from the load balancer;

Comparing the identification information of the master node with the identification information of the node to be detected to obtain a comparison result;

Whether the node to be detected is the master node is judged according to the comparison result.

Obviously, those skilled in the art can make various changes and modifications to the application without departing from the spirit and scope of the application. In this way, if these modifications and variations of the present application fall within the scope of the claims of the present application and their equivalent technologies, the present application is also intended to include these modifications and variations.

It should be noted that the present application can be implemented in software and/or a combination of software and hardware, for example, it can be implemented by using an application specific integrated circuit (ASIC), a general-purpose computer or any other similar hardware devices. In one embodiment, the software program of the present application can be executed by a processor to realize the steps or functions described above. Likewise, the software program (including associated data structures) of the present application can be stored in a computer-readable recording medium such as RAM memory, magnetic or optical drive or floppy disk and the like. In addition, some steps or functions of the present application may be implemented by hardware, for example, as a circuit that cooperates with a processor to execute each step or function.

In addition, a part of the present application can be applied as a computer program product, such as a computer program instruction. When it is executed by a computer, the method and/or technical solution according to the present application can be invoked or provided through the operation of the computer. The program instructions for invoking the method of the present application may be stored in a fixed or removable recording medium, and/or transmitted through a data stream in a broadcast or other signal-carrying medium, and/or stored in a in the working memory of the computer device on which the program instructions described above are executed. Here, an embodiment according to the present application includes an apparatus comprising a memory for storing computer program instructions and a processor for executing the program instructions, wherein when the computer program instructions are executed by the processor, triggering The operation of the device is based on the foregoing methods and/or technical solutions according to multiple embodiments of the present application.

It will be apparent to those skilled in the art that the present application is not limited to the details of the exemplary embodiments described above, but that the present application can be implemented in other specific forms without departing from the spirit or essential characteristics of the present application. Therefore, the embodiments should be regarded as exemplary and not restrictive in all points of view, and the scope of the application is defined by the appended claims rather than the foregoing description, and it is intended that the scope of the present application be defined by the appended claims rather than by the foregoing description. All changes within the meaning and range of equivalents of the elements are embraced in this application. Any reference sign in a claim should not be construed as limiting the claim concerned. In addition, it is obvious that the word "comprising" does not exclude other elements or steps, and the singular does not exclude the plural. The words first, second, etc. are used to denote names and do not imply any particular order.

Claims (8)

1. A method of detecting the status of a node itself, the method comprising:

providing a corresponding data interface for each node in the cluster, wherein the response content returned by the data interface when the data interface is requested is the unique identifier of the node;

the node to be detected acquires main node identification information returned by the main node from load balancing;

comparing the main node identification information with the identification information of the node to be detected to obtain a comparison result;

and judging whether the node to be detected is a master node or not according to the comparison result.

2. The method according to claim 1, characterized in that the method comprises:

generating identification information for a node when each node in the cluster is started, and storing the identification information on the node.

3. The method according to claim 1, wherein before the node to be detected obtains the master node identification information returned by the master node from the load balancing, the method comprises:

judging whether the node to be detected needs to operate resources in the cluster, if so, sending a target request to load balancing when the node to be detected acquires the identification information of the node to be detected;

and distributing the target request to the master node through the load balancing so as to obtain the master node identification information returned by the master node.

4. The method according to claim 1, wherein determining whether the node to be detected is a master node according to the comparison result includes:

if the comparison result shows that the acquired main node identification information is consistent with the self identification information, the node to be detected is the main node, otherwise, the node to be detected is the slave node.

5. A method according to claim 3, wherein determining whether a node to be detected requires operating resources in the cluster comprises:

determining a first main node to which load balancing distributes user request traffic;

and judging whether the health check request sent by the load balancing to the first main node fails to return, if so, determining that the node to be detected needs to operate resources in the cluster.

6. The method according to claim 1, characterized in that the method comprises:

when the node to be detected is determined to be a master node, updating data information of the node to be detected, and receiving a user flow request sent by load balancing, wherein the data information of the node to be detected comprises node state information of the node to be detected.

7. An apparatus for detecting the status of a node itself, the apparatus comprising:

one or more processors; and

a memory storing computer readable instructions that, when executed, cause the processor to perform the operations of the method of any one of claims 1 to 6.

8. A computer readable medium having stored thereon computer readable instructions executable by a processor to implement the method of any of claims 1 to 6.