CN113868184A - Configuration method and system of master-slave architecture cache-based configuration center - Google Patents
Configuration method and system of master-slave architecture cache-based configuration center Download PDFInfo
- Publication number
- CN113868184A CN113868184A CN202111115261.4A CN202111115261A CN113868184A CN 113868184 A CN113868184 A CN 113868184A CN 202111115261 A CN202111115261 A CN 202111115261A CN 113868184 A CN113868184 A CN 113868184A
- Authority
- CN
- China
- Prior art keywords
- node
- master
- configuration
- cache
- service
- Prior art date
- Legal status (The legal status is an assumption and is not a legal conclusion. Google has not performed a legal analysis and makes no representation as to the accuracy of the status listed.)
- Pending
Links
Images
Classifications
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F15/00—Digital computers in general; Data processing equipment in general
- G06F15/16—Combinations of two or more digital computers each having at least an arithmetic unit, a program unit and a register, e.g. for a simultaneous processing of several programs
- G06F15/161—Computing infrastructure, e.g. computer clusters, blade chassis or hardware partitioning
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F16/00—Information retrieval; Database structures therefor; File system structures therefor
- G06F16/20—Information retrieval; Database structures therefor; File system structures therefor of structured data, e.g. relational data
- G06F16/21—Design, administration or maintenance of databases
- G06F16/219—Managing data history or versioning
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F16/00—Information retrieval; Database structures therefor; File system structures therefor
- G06F16/20—Information retrieval; Database structures therefor; File system structures therefor of structured data, e.g. relational data
- G06F16/23—Updating
- G06F16/2379—Updates performed during online database operations; commit processing
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F16/00—Information retrieval; Database structures therefor; File system structures therefor
- G06F16/20—Information retrieval; Database structures therefor; File system structures therefor of structured data, e.g. relational data
- G06F16/27—Replication, distribution or synchronisation of data between databases or within a distributed database system; Distributed database system architectures therefor
-
- H—ELECTRICITY
- H04—ELECTRIC COMMUNICATION TECHNIQUE
- H04L—TRANSMISSION OF DIGITAL INFORMATION, e.g. TELEGRAPHIC COMMUNICATION
- H04L41/00—Arrangements for maintenance, administration or management of data switching networks, e.g. of packet switching networks
- H04L41/08—Configuration management of networks or network elements
- H04L41/0803—Configuration setting
- H04L41/0806—Configuration setting for initial configuration or provisioning, e.g. plug-and-play
Landscapes
- Engineering & Computer Science (AREA)
- Theoretical Computer Science (AREA)
- Databases & Information Systems (AREA)
- Physics & Mathematics (AREA)
- General Engineering & Computer Science (AREA)
- General Physics & Mathematics (AREA)
- Data Mining & Analysis (AREA)
- Computer Hardware Design (AREA)
- Computing Systems (AREA)
- Mathematical Physics (AREA)
- Software Systems (AREA)
- Computer Networks & Wireless Communication (AREA)
- Signal Processing (AREA)
- Information Retrieval, Db Structures And Fs Structures Therefor (AREA)
Abstract
The embodiment of the invention discloses a configuration method and a configuration system of a master-slave architecture cache-based configuration center, wherein the method comprises the following steps: constructing a Springboot type project; configuring parameters of a database and a Redis cluster to connect each node in a service cluster; each node is deployed with a configuration center service; creating a base component for operating the database and the Redis cluster in a correlation manner; performing master service selection to obtain a master node, wherein the master node is responsible for updating Redis configuration content; initializing a single-thread pool, and starting a timing updating thread to update a local cache; the beneficial effects are as follows: the local cache of the configuration center is combined with the database and the Redis cluster, so that the problem of strong dependence on a memory is avoided, and meanwhile, only the master node operates the Redis cluster by utilizing a master-slave architecture, so that the problem of repeated operation on the Redis cluster is reduced.
Description
Technical Field
The invention relates to the technical field of configuration centers, in particular to a configuration method and a configuration system of a master-slave architecture cache-based configuration center.
Background
At present, each time a single-machine configuration file of a system is modified, a code needs to be modified and the configuration file needs to be released online; the configuration center is based on files, the consumption of a disk IO to a system is large, and frequent Full GC conditions exist when a Java virtual machine runs; under the condition that the number of systems is limited, a local cache can be used as the storage of configuration, but a large number of systems are on-line and use a configuration center, and for the configuration center which only depends on the local cache, a memory can become a new bottleneck of the availability of the configuration center.
Disclosure of Invention
Aiming at technical defects in the prior art, embodiments of the present invention provide a method and a system for configuring a master-slave architecture cache-based configuration center, so as to overcome the defect of strong dependence on a machine memory in the prior art.
In order to achieve the above object, in a first aspect, an embodiment of the present invention provides a method for configuring a cache-based configuration center in a master-slave architecture, where the method includes:
constructing a Springboot type project;
configuring parameters of a database and a Redis cluster to connect each node in a service cluster; the method comprises the following steps that configuration center services are deployed on each node, and each service is registered to a zookeeper; the configuration center service comprises a main selection module; the Redis cluster comprises a Redis cache;
creating a base component for operating the database and the Redis cluster in a correlation manner;
initializing the master selection module, and performing master selection service to obtain a master node, wherein the master node is responsible for updating Redis configuration content;
and initializing a thread pool of a single thread, and starting a timing refreshing thread to update the local cache.
Preferably, the method further comprises:
after all the configuration information is loaded and the service detection is completed, adding each node into Nginx to provide service to the outside;
and the service party accessing the SDK requests the timed pull engineering configuration through Http.
Preferably, the step of performing the master selection service to obtain the master node specifically includes the following steps:
starting a node;
initializing and persisting nodes;
monitoring a selected main node notification from the zookeeper, wherein the notification comprises a deletion notification and a data change notification;
notifying a creation node according to the master selection node to realize master selection;
if the master selection is successful, the master node works; otherwise, it operates as a slave node.
Preferably, during initialization, all engineering configurations are pulled from the database, the engineering is divided into environments and versions, the Key is cached locally, and the Redis configuration content is read only when the environment and version information corresponding to the engineering is cached locally.
Preferably, the configuration center service further includes configuration management, and the management includes addition and deletion;
the new addition comprises the following steps:
newly adding engineering, environment, version and configuration;
the Redis cluster executes a SetEx command;
storing the configuration in a database;
maintaining and updating a local cache;
ending and returning;
the deleting includes:
newly adding engineering, environment, version and configuration;
the local cache removes the corresponding key;
keys corresponding to the DEL clusters;
deleting the configuration in the database;
and ending and returning.
Preferably, the updating the local cache by the timed refresh thread specifically includes:
the asynchronous thread updates the cache at regular time;
paging and inquiring a database, and pulling existing projects;
refreshing a local cache, and setting the existence of a Key corresponding to engineering configuration;
judging whether the node is a main node or not;
if so, executing a SetEx command to update a cache value in a Redis cache; otherwise, Redis cache update is not performed.
In a second aspect, an embodiment of the present invention provides a system for a master-slave architecture cache-based configuration center, where the system includes:
the construction module is used for constructing SpringBoot type projects;
the setting module is used for configuring parameters of a database and a Redis cluster so as to connect each node in the service cluster; the method comprises the following steps that configuration center services are deployed on each node, and each service is registered to a zookeeper; the configuration center service comprises a main selection module; the Redis cluster comprises a Redis cache;
the service module is used for creating a basic component for operating the database and the Redis cluster in a correlation mode;
a configuration module to:
initializing the master selection module, and performing master selection service to obtain a master node, wherein the master node is responsible for updating Redis configuration content;
and initializing a thread pool of a single thread, and starting a timing refreshing thread to update the local cache.
Preferably, the mobile terminal further comprises an interface module, wherein the interface module is configured to:
after all the configuration information is loaded and the service detection is completed, adding each node into Nginx to provide service to the outside;
and the service party accessing the SDK requests the timed pull engineering configuration through Http.
Preferably, the step of performing the master selection service to obtain the master node specifically includes the following steps:
starting a node;
initializing and persisting nodes;
monitoring a selected main node notification from the zookeeper, wherein the notification comprises a deletion notification and a data change notification;
notifying a creation node according to the master selection node to realize master selection;
if the master selection is successful, the master node works; otherwise, it operates as a slave node.
By implementing the embodiment of the invention, the problem of strong dependence on the memory is avoided by combining the local cache of the configuration center with the database and the Redis cluster, and meanwhile, only the master node operates the Redis cluster by utilizing the master-slave architecture, so that the problem of repeated operation on the Redis cluster is reduced.
Drawings
In order to more clearly illustrate the detailed description of the invention or the technical solutions in the prior art, the drawings that are needed in the detailed description of the invention or the prior art will be briefly described below.
Fig. 1 is a flowchart of a configuration method of a master-slave architecture cache-based configuration center according to an embodiment of the present invention;
FIG. 2 is a flow chart of a opt-in service provided by the present invention;
FIG. 3 is a flow chart of a timed refresh thread provided by the present invention;
FIG. 4 is a flow chart of an addition in configuration management according to the present invention;
FIG. 5 is a flow diagram of deletion in configuration management provided by the present invention;
FIG. 6 is a flow chart of an SDK pull configuration provided by the present invention;
FIG. 7 is a block diagram of a system of a master-slave architecture cache-based configuration center according to the present invention;
fig. 8 is an interaction diagram of a system of a master-slave architecture cache-based configuration center provided in the present invention.
Detailed Description
The technical solutions in the embodiments of the present invention will be clearly and completely described below with reference to the drawings in the embodiments of the present invention, and it is obvious that the described embodiments are some, not all, embodiments of the present invention. All other embodiments, which can be derived by a person skilled in the art from the embodiments given herein without making any creative effort, shall fall within the protection scope of the present invention.
For better understanding of the embodiments of the present invention, the following description is made for the related art:
ZooKeeper is a distributed, open-source distributed application coordination service, is an open-source implementation of Chubby of Google, and is an important component of Hadoop and Hbase. It is a software that provides a consistent service for distributed applications, and the functions provided include: configuration maintenance, domain name service, distributed synchronization, group service, etc.
Referring to fig. 1 to fig. 6, a method for configuring a master-slave architecture cache-based configuration center according to an embodiment of the present invention is applied to a server, and the method includes:
s101, constructing a Springboot type project.
In particular, the SpringBoot is a framework, and the generation of the framework simplifies the use of the framework, wherein the simplification means that a large amount of cumbersome configuration files required by a plurality of Spring frameworks are simplified, so the SpringBoot is a framework serving the framework, and the service scope is the simplified configuration files.
S102, configuring parameters of a database and a Redis cluster to connect each node in the service cluster; the method comprises the following steps that configuration center services are deployed on each node, and each service is registered to a zookeeper; the configuration center service comprises a main selection module; the Redis cluster includes a Redis cache.
Specifically, the configured parameters include a URL of the database, a user name of the database, and a password of the database; an address of a Redis cluster; the database and the Redis cluster both store engineering configuration; and the memory corresponding to each node is used as a local cache.
S103, creating a basic component for the association operation of the database and the Redis cluster.
Specifically, a basic entity is written, and the entity operates basic related services.
And S104, initializing the master selection module, and performing master selection service to obtain a master node, wherein the master node is responsible for updating Redis configuration content.
Specifically, the step of performing the master selection service to obtain the master node specifically includes the following steps:
starting a node;
initializing and persisting nodes;
monitoring a host node selection notification from the zookeeper, wherein the notification comprises a host node selection deletion notification and a host node selection data change notification;
notifying a creation node according to the master selection node to realize master selection;
if the master selection is successful, the master node works; otherwise, it operates as a slave node.
When the master node works, the process is as follows:
updating the flag bit of the main node;
starting a heartbeat holding thread;
and starting a cache data updating thread.
When the slave node works, the process is as follows:
updating the zone bit of the slave node;
and starting a thread for monitoring whether the main node exists.
And S105, initializing a thread pool of a single thread, and starting a timing refreshing thread to update the local cache.
Specifically, in this embodiment, the updating the local cache by the timed refresh thread specifically includes:
the asynchronous thread updates the cache at regular time;
paging and inquiring a database, and pulling existing projects;
refreshing a local cache, and setting the existence of a Key corresponding to engineering configuration; the Key is spliced by engineering/environment/version, exists in a Map, sets the existing flag bit to True, and cannot be acquired if the existing flag bit does not exist;
judging whether the node is a main node or not;
if so, executing a SetEx command to update a cache value in a Redis cache; otherwise, Redis cache update is not performed.
Meanwhile, during initialization, all engineering configurations are pulled from the database, the engineering is divided into environments and versions, the Key is cached locally, and the Redis configuration content is read only when the environment and version information corresponding to the engineering is cached locally.
Further, on the basis of the above scheme, the method further comprises:
after all the configuration information is loaded and the service detection is completed, adding each node into Nginx to provide services to the outside, and realizing load balancing through the Nginx;
and the service party accessing the SDK requests the timed pull engineering configuration through Http.
Correspondingly, the pulling process is as shown in fig. 6, a unique query condition key is formed according to the project name/environment/version, then whether the LocalCache contains the key is judged, and if yes, the key is read from the cache; when the cache does not exist, the configuration content is pulled from the database according to the project name/environment/version; therefore, the problem that local cache is not used is solved, and cache breakdown is easy to occur if the cache fails.
It should be noted that, cache breakdown means that there is no data in the cache but there is data in the database (generally, the cache time expires), and at this time, since there are many concurrent users, the cache is read at the same time, and the database is also read to obtain the data, the pressure of the database is increased instantaneously, which causes excessive pressure; in the embodiment, the key exists in the cache, and the key is not pulled from the database, so that the situation that the key is pulled from the database at the same time is avoided.
From the above description, it can be seen that, in the method provided by the embodiment of the present invention, by combining the local cache of the configuration center with the database and the Redis cluster, the problem of too strong dependence on the memory is avoided, and meanwhile, by using the master-slave architecture, only the master node operates the Redis cluster, thereby reducing the problem of repeated operation on the Redis cluster.
Furthermore, the configuration center service also comprises configuration management, and Redis updating operation can be directly executed through low-frequency modification;
the management comprises adding and deleting;
the new addition comprises the following steps:
newly adding engineering, environment, version and configuration;
the Redis cluster executes a SetEx command;
storing the configuration in a database;
maintaining and updating a local cache;
ending and returning;
the deleting includes:
newly adding engineering, environment, version and configuration;
the local cache removes the corresponding key;
keys corresponding to the DEL clusters;
deleting the configuration in the database;
and ending and returning.
Further, to improve the effectiveness of the execution, the configuration center service further includes a Redis cluster availability detection module, where the Redis cluster availability detection module is specifically configured to:
a thread is newly built by RedisChecker;
acquiring Redis connection;
executing a GETSet command;
sending alarm information abnormally; if not, no error is reported, and the cluster is ended if the cluster works normally.
Based on the same inventive concept, an embodiment of the present invention further provides a system of a master-slave architecture cache-based configuration center, which is shown in fig. 7 and 8, and includes:
the construction module is used for constructing SpringBoot type projects;
the setting module is used for configuring parameters of a database and a Redis cluster so as to connect each node in the service cluster; the method comprises the following steps that configuration center services are deployed on each node, and each service is registered to a zookeeper; the configuration center service comprises a main selection module; the Redis cluster comprises a Redis cache;
the service module is used for creating a basic component for operating the database and the Redis cluster in a correlation mode;
a configuration module to:
initializing the master selection module, and performing master selection service to obtain a master node, wherein the master node is responsible for updating Redis configuration content;
the step of performing the master selection service to obtain the master node specifically comprises the following steps:
starting a node;
initializing and persisting nodes;
monitoring a selected main node notification from the zookeeper, wherein the notification comprises a deletion notification and a data change notification;
notifying a creation node according to the master selection node to realize master selection;
if the master selection is successful, the master node works; otherwise, it operates as a slave node.
And initializing a thread pool of a single thread, and starting a timing refreshing thread to update the local cache.
The updating of the local cache by the timing updating thread specifically comprises the following steps:
the asynchronous thread updates the cache at regular time;
paging and inquiring a database, and pulling existing projects;
refreshing a local cache, and setting the existence of a Key corresponding to engineering configuration;
judging whether the node is a main node or not;
if so, executing a SetEx command to update a cache value in a Redis cache; otherwise, Redis cache update is not performed.
Further, when the system is applied, the system for a master-slave architecture cache-based configuration center further includes an interface module, where the interface module is configured to:
after all the configuration information is loaded and the service detection is completed, adding each node into Nginx to provide service to the outside;
and the service party accessing the SDK requests the timed pull engineering configuration through Http.
During initialization, all engineering configuration is firstly pulled from the database, the engineering is divided into environments and versions, a Key is cached to the local, and the Redis configuration content is read only when the environment and version information corresponding to the engineering is cached in the local.
It should be noted that, please refer to the foregoing method embodiment, for other modules included in the configuration center service and more specific working processes of the system, which are not described herein again.
In the whole scheme, the local cache of the configuration center is combined with the database and the Redis cluster, so that the problem of strong dependence on a memory is avoided, and meanwhile, only the master node operates the Redis cluster by utilizing a master-slave architecture, so that the problem of repeated operation on the Redis cluster is reduced.
Those of ordinary skill in the art will appreciate that the elements and algorithm steps of the examples described in connection with the embodiments disclosed herein may be embodied in electronic hardware, computer software, or combinations of both, and that the components and steps of the examples have been described in a functional general in the foregoing description for the purpose of illustrating clearly the interchangeability of hardware and software. Whether such functionality is implemented as hardware or software depends upon the particular application and design constraints imposed on the implementation. Skilled artisans may implement the described functionality in varying ways for each particular application, but such implementation decisions should not be interpreted as causing a departure from the scope of the present invention.
In the several embodiments provided in the present application, it should be understood that the disclosed units and methods may be implemented in other ways. For example, the above-described apparatus embodiments are merely illustrative, and for example, the division of the units is only one logical division, and other divisions may be realized in practice, for example, a plurality of units or components may be combined or integrated into another system, or some features may be omitted, or not executed. In addition, the shown or discussed mutual coupling or direct coupling or communication connection may be an indirect coupling or communication connection through some interfaces, devices or units, and may also be an electric, mechanical or other form of connection.
While the invention has been described with reference to specific embodiments, the invention is not limited thereto, and various equivalent modifications and substitutions can be easily made by those skilled in the art within the technical scope of the invention. Therefore, the protection scope of the present invention shall be subject to the protection scope of the claims.
Claims (9)
1. A method for configuring a cache-based configuration center of a master-slave architecture is characterized by comprising the following steps:
constructing a Springboot type project;
configuring parameters of a database and a Redis cluster to connect each node in a service cluster; the method comprises the following steps that configuration center services are deployed on each node, and each service is registered to a zookeeper; the configuration center service comprises a main selection module; the Redis cluster comprises a Redis cache;
creating a base component for operating the database and the Redis cluster in a correlation manner;
initializing the master selection module, and performing master selection service to obtain a master node, wherein the master node is responsible for updating Redis configuration content;
and initializing a thread pool of a single thread, and starting a timing refreshing thread to update the local cache.
2. The method of claim 1, wherein the method further comprises:
after all the configuration information is loaded and the service detection is completed, adding each node into Nginx to provide service to the outside;
and the service party accessing the SDK requests the timed pull engineering configuration through Http.
3. The method according to claim 1 or 2, wherein the step of performing the master-slave architecture cache-based configuration center to obtain the master node specifically comprises the steps of:
starting a node;
initializing and persisting nodes;
monitoring a selected main node notification from the zookeeper, wherein the notification comprises a deletion notification and a data change notification;
notifying a creation node according to the master selection node to realize master selection;
if the master selection is successful, the master node works; otherwise, it operates as a slave node.
4. The configuration method of a master-slave architecture cache-based configuration center according to claim 3, wherein during initialization, all engineering configurations are firstly pulled from the database, and are divided into different environments and versions according to engineering, and keys are cached locally, and only environment and version information corresponding to engineering is cached locally to read Redis configuration content.
5. The method as claimed in claim 4, wherein the configuration center service further comprises configuration management, the management comprises adding and deleting;
the new addition comprises the following steps:
newly adding engineering, environment, version and configuration;
the Redis cluster executes a SetEx command;
storing the configuration in a database;
maintaining and updating a local cache;
ending and returning;
the deleting includes:
newly adding engineering, environment, version and configuration;
the local cache removes the corresponding key;
keys corresponding to the DEL clusters;
deleting the configuration in the database;
and ending and returning.
6. The method according to claim 1, wherein the updating of the local cache by the timed refresh thread specifically comprises:
the asynchronous thread updates the cache at regular time;
paging and inquiring a database, and pulling existing projects;
refreshing a local cache, and setting the existence of a Key corresponding to engineering configuration;
judging whether the node is a main node or not;
if so, executing a SetEx command to update a cache value in a Redis cache; otherwise, Redis cache update is not performed.
7. A system for a master-slave architecture cache-based configuration center, the system comprising:
the construction module is used for constructing SpringBoot type projects;
the setting module is used for configuring parameters of a database and a Redis cluster so as to connect each node in the service cluster; the method comprises the following steps that configuration center services are deployed on each node, and each service is registered to a zookeeper; the configuration center service comprises a main selection module; the Redis cluster comprises a Redis cache;
the service module is used for creating a basic component for operating the database and the Redis cluster in a correlation mode;
a configuration module to:
initializing the master selection module, and performing master selection service to obtain a master node, wherein the master node is responsible for updating Redis configuration content;
and initializing a thread pool of a single thread, and starting a timing refreshing thread to update the local cache.
8. The system of a master-slave architecture cache-based configuration center of claim 7, further comprising an interface module for:
after all the configuration information is loaded and the service detection is completed, adding each node into Nginx to provide service to the outside;
and the service party accessing the SDK requests the timed pull engineering configuration through Http.
9. The system of claim 7, wherein the step of performing the master-slave architecture cache-based configuration center to obtain the master node comprises the following steps:
starting a node;
initializing and persisting nodes;
monitoring a selected main node notification from the zookeeper, wherein the notification comprises a deletion notification and a data change notification;
notifying a creation node according to the master selection node to realize master selection;
if the master selection is successful, the master node works; otherwise, it operates as a slave node.
Priority Applications (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN202111115261.4A CN113868184A (en) | 2021-09-23 | 2021-09-23 | Configuration method and system of master-slave architecture cache-based configuration center |
Applications Claiming Priority (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN202111115261.4A CN113868184A (en) | 2021-09-23 | 2021-09-23 | Configuration method and system of master-slave architecture cache-based configuration center |
Publications (1)
| Publication Number | Publication Date |
|---|---|
| CN113868184A true CN113868184A (en) | 2021-12-31 |
Family
ID=78993395
Family Applications (1)
| Application Number | Title | Priority Date | Filing Date |
|---|---|---|---|
| CN202111115261.4A Pending CN113868184A (en) | 2021-09-23 | 2021-09-23 | Configuration method and system of master-slave architecture cache-based configuration center |
Country Status (1)
| Country | Link |
|---|---|
| CN (1) | CN113868184A (en) |
Cited By (1)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN115002121A (en) * | 2022-08-03 | 2022-09-02 | 浩鲸云计算科技股份有限公司 | Method for realizing one-master multi-slave Git cluster based on preemption lock |
-
2021
- 2021-09-23 CN CN202111115261.4A patent/CN113868184A/en active Pending
Cited By (2)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN115002121A (en) * | 2022-08-03 | 2022-09-02 | 浩鲸云计算科技股份有限公司 | Method for realizing one-master multi-slave Git cluster based on preemption lock |
| CN115002121B (en) * | 2022-08-03 | 2022-11-11 | 浩鲸云计算科技股份有限公司 | Method for realizing one-master multi-slave Git cluster based on preemption lock |
Similar Documents
| Publication | Publication Date | Title |
|---|---|---|
| US8910138B2 (en) | Hot pluggable extensions for access management system | |
| CN106878376B (en) | Configuration management method and system | |
| CN110765023A (en) | Distributed system testing method and system based on chaos experiment | |
| CN111064626B (en) | Configuration updating method, device, server and readable storage medium | |
| CN109245908B (en) | Method and device for switching master cluster and slave cluster | |
| CN112636992B (en) | Dynamic routing method, device, equipment and storage medium | |
| CN110520844A (en) | Cloud management platform, virtual machine management method and its system | |
| CN111209120A (en) | Data synchronization method and device for microservice and computer readable storage medium | |
| CN111581239A (en) | Cache refreshing method and electronic equipment | |
| CN112947965A (en) | Containerized service updating method and device | |
| CN112685260A (en) | Method for monitoring server | |
| CN110442601B (en) | Openstack mirror image data parallel acceleration method and device | |
| CN111666167A (en) | Input event reading processing optimization method, nonvolatile memory and terminal equipment | |
| CN113868184A (en) | Configuration method and system of master-slave architecture cache-based configuration center | |
| CN114625535A (en) | Service deployment method and device for multiple Kubernetes clusters | |
| CN113590049B (en) | Storage volume cross-node cloning method, device, equipment and readable medium | |
| CN112363815A (en) | Redis cluster processing method and device, electronic equipment and computer readable storage medium | |
| CN112579550A (en) | Metadata information synchronization method and system of distributed file system | |
| CN117435569A (en) | Dynamic capacity expansion method, device, equipment, medium and program product for cache system | |
| CN112463251A (en) | Method and device for configuring hot publishing by uliweb framework | |
| CN110798358A (en) | Distributed service identification method and device, computer readable medium and electronic equipment | |
| CN114172917B (en) | Distributed cache system and deployment method thereof | |
| CN110851192B (en) | Method and device for responding to degraded switch configuration | |
| CN111324386B (en) | Method and device for starting split application program, electronic equipment and storage medium | |
| CN113609075A (en) | Method, system, storage medium and equipment for creating snapshot |
Legal Events
| Date | Code | Title | Description |
|---|---|---|---|
| PB01 | Publication | ||
| PB01 | Publication | ||
| SE01 | Entry into force of request for substantive examination | ||
| SE01 | Entry into force of request for substantive examination |