Configuration data persistence method, system and equipment and storage medium

Abstract

The invention belongs to the technical field of data storage, provides a configuration data persistence method, system and equipment and a storage medium, and aims to solve the technical problem that a configuration management method in the prior art needs to restart a service after configuration modification. Comprising the steps that a ConfigMap object containing configuration file content is constructed, and the ConfigMap object is mounted in an updating file in a MinIO S3 Gateway container; obtaining operation data of a user, and preprocessing the operation data to obtain an operation configuration file; constructing a K8S API (Application Program Interface), and synchronously updating the operation configuration file to the ConfigMap object by utilizing the K8S API; the ConfigMap object is dynamically monitored, and when it is monitored that the content of the configuration file in the ConfigMap object is updated, the updated content of the configuration file is stored in the updating file.

Description

Technical Field

[0001] The present invention belongs to the technical field of data storage, and in particular relates to a configuration data persistence method, system, device and storage medium. Background Art

[0002] In modern cloud computing and containerized applications, Kubernetes (K8S) has become an important platform for managing and orchestrating containers. MinIO is a high-performance, distributed object storage system that is widely used in data storage and management. MinIOS3 Gateway is a mode provided by MinIO that enables MinIO to act as a middle-layer gateway to support existing object storage solutions (such as AWS S3). However, in the process of using MinIO S3 Gateway, effectively managing and persisting configuration information is the key to ensuring system stability and reliability.

[0003] In the prior art, in a distributed environment, configuration information is scattered on multiple nodes; configuration management often relies on operators to manually update configuration files and environment variables. After each configuration modification, the relevant services need to be restarted to make the new configuration take effect.

[0004] The prior art has the following technical problems:

[0005] 1. Configuration information is scattered across multiple nodes, making configuration management and updating complicated and inefficient. Each time a configuration is modified, the configuration files or environment variables on each node need to be manually updated, increasing the workload of operation and maintenance and the risk of errors.

[0006] 2. Manual management of configuration files and environment variables is not only error-prone, but also difficult to track and audit the history of configuration changes. As the scale and complexity of the system increase, the cost and risk of manual management will also increase. In addition, the lack of centralized configuration management tools and mechanisms makes team collaboration and coordination of configuration changes more difficult.

[0007] 3. The configuration management method requires restarting the service after modifying the configuration, which may cause service interruption and affect the availability and stability of the system. In a production environment with high availability requirements, serious consequences may occur. Summary of the invention

[0008] The present invention provides a configuration data persistence method, system, device and storage medium, aiming to solve the above existing problems that the configuration information is scattered on multiple nodes, and each time the configuration is modified, the configuration files or environment variables on each node need to be manually updated. Manual management of configuration files and environment variables is not only prone to errors, but also difficult to track and audit the configuration change history. And the configuration management method needs to restart the service after the configuration is modified.

[0009] The technical solution of the present invention to solve the above technical problem is as follows: a configuration data persistence method, comprising:

[0010] Build a ConfigMap object containing the contents of the configuration file and mount the ConfigMap object to the update file in the MinIO S3Gateway container;

[0011] Acquire user operation data, pre-process the operation data, and obtain an operation configuration file;

[0012] Build a K8S API, and use the K8S API to synchronously update the operation configuration file to the ConfigMap object;

[0013] The ConfigMap object is dynamically monitored, and when it is monitored that the configuration file content in the ConfigMap object is updated, the updated configuration file content is stored in the update file.

[0014] Furthermore, the above-mentioned ConfigMap object containing the configuration file content specifically includes:

[0015] Write a YAML file to define a ConfigMap resource containing the configuration file content, and obtain a ConfigMap object, wherein the configuration file content is stored in the ConfigMap object in the form of key-value pairs.

[0016] Furthermore, the above also includes:

[0017] Initialize the ConfigMap object. If it does not exist, create a ConfigMap object in the K8S platform. If it does exist, load the existing ConfigMap object.

[0018] Furthermore, the above-mentioned step of mounting the ConfigMap object into the update file in the MinIO S3 Gateway container specifically includes:

[0019] Based on the Pod file system, define the ConfigMap object as a volume and generate a mount path for the ConfigMap object;

[0020] Based on the mount path, mount the ConfigMap object into the update file in the MinIO S3 Gateway container.

[0021] Furthermore, the user's operation data mentioned above is the user information newly added by the user on the application interface; wherein the newly added user information includes modifying user information, adding new users, and changing user permissions.

[0022] Further, the above-mentioned use of the K8S API to synchronously update the operation configuration file to the ConfigMap object specifically includes:

[0023] Use the K8S.io library to build a client instance of the K8S API, and based on the client instance, establish interaction with the K8S API;

[0024] A ConfigMap update function is defined, and based on the ConfigMap update function, the operation configuration file is updated to the ConfigMap object through the K8S API.

[0025] Furthermore, the above also includes:

[0026] Use the IAM subsystem to authenticate and authorize users.

[0027] In a second aspect, in order to solve the above technical problems, the present invention further provides a configuration data persistence system, comprising:

[0028] The ConfigMap module is used to build a ConfigMap object containing the contents of the configuration file and mount the ConfigMap object into the update file in the MinIO S3 Gateway container;

[0029] A user information module is used to obtain the user's operation data, pre-process the operation data, and obtain an operation configuration file;

[0030] A K8S API module is used to build a K8S API and use the K8S API to synchronously update the operation configuration file to the ConfigMap object;

[0031] The dynamic update module is used to dynamically monitor the ConfigMap object, and when it is monitored that the configuration file content in the ConfigMap object is updated, the updated configuration file content is stored in the update file.

[0032] In a third aspect, in order to solve the above-mentioned technical problem, the present invention also provides an electronic device, which includes a memory, a processor, and a computer program stored in the memory and executable on the processor, and when the processor executes the computer program, the configuration data persistence method of the present application is implemented.

[0033] In a fourth aspect, in order to solve the above-mentioned technical problem, the present invention further provides a computer-readable storage medium, on which a computer program is stored, and when the computer program is executed by a processor, the configuration data persistence method of the present application is implemented.

[0034] Compared with the prior art, the present invention has the following advantages:

[0035] 1. By storing account and permission information in Kubernetes, the security and persistence of these sensitive data are ensured. Even if the MinIO S3 Gateway instance is restarted or rescheduled, the configuration information remains unchanged and will not be lost.

[0036] 2. By building a Kubernetes API client, we monitor changes in ConfigMap objects in real time and automatically copy the latest configuration file content to the mount point in the container. This allows configuration changes to take effect immediately without restarting the container.

[0037] 3. All configuration information is centrally stored in the Kubernetes cluster. Administrators can manage and maintain it through a unified interface or command line tools, reducing the complexity of operation and maintenance.

[0038] 4. Due to the use of ConfigMap, dynamic update of configuration information is supported, which improves the availability and reliability of the system.

[0039] Other features and advantages of the present invention will be described in the following description, and partly become apparent from the description, or understood by practicing the present invention. The purpose and other advantages of the present invention can be realized and obtained by the structures pointed out in the description, claims and drawings. BRIEF DESCRIPTION OF THE DRAWINGS

[0040] In order to more clearly illustrate the embodiments of the present invention or the technical solutions in the prior art, the drawings required for use in the embodiments or the description of the prior art will be briefly introduced below. Obviously, the drawings described below are some embodiments of the present invention. For ordinary technicians in this field, other drawings can be obtained based on these drawings without paying creative work.

[0041] Figure 1 A schematic diagram of a process of configuring data persistence according to an embodiment of the present invention is shown;

[0042] Figure 2 A schematic diagram of the MinIO-GateWay architecture according to an embodiment of the present invention is shown;

[0043] Figure 3It shows the usage scenario of ConfigMa according to an embodiment of the present invention;

[0044] Figure 4 A schematic diagram of the MinIO S3 GateWay startup process according to an embodiment of the present invention is shown;

[0045] Figure 5 A schematic diagram of the structure of a configuration data persistence system according to an embodiment of the present invention is shown;

[0046] Figure 6 A schematic structural diagram of an electronic device according to an embodiment of the present invention is shown. DETAILED DESCRIPTION

[0047] In order to make the purpose, technical solution and advantages of the embodiments of the present invention clearer, the technical solution in the embodiments of the present invention will be clearly and completely described below in conjunction with the drawings in the embodiments of the present invention. Obviously, the described embodiments are part of the embodiments of the present invention, not all of the embodiments. Based on the embodiments of the present invention, all other embodiments obtained by ordinary technicians in this field without creative work are within the scope of protection of the present invention.

[0048] Figure 1 A schematic diagram of a configuration data persistence method according to an embodiment of the present invention is shown. Figure 1 As shown, a configuration data persistence method of an embodiment of the present invention is implemented based on the MinIO-GateWay architecture and ConfigMap in K8S:

[0049] like Figure 2 The following is a schematic diagram of the MinIO-GateWay architecture, where users or applications initiate requests through the standard S3 API, which are first sent to the S3 API Router layer of the MinIO S3 Gateway. The S3 API Router is responsible for parsing the request and routing it to the correct backend implementation based on the configuration. Whether the backend is MinIO itself or other cloud storage services, the S3 API Router ensures that all requests follow the unified S3 compatible API standard.

[0050] ObjectLayer is an abstract interface that defines all the API methods of the MinIO object storage service for object operations, such as listing buckets, uploading objects, downloading objects, etc. When MinIO runs as a standalone object storage server, it implements the ObjectLayer interface to handle all object operations.

[0051] Taking the GCS gateway as an example, when a user requests a bucket list through the S3 API, the request will first reach the S3 APIRouter. The S3 API Router recognizes that this is a request for the GCS gateway and forwards it to the GCS gateway module that implements the ObjectLayer interface. The GCS gateway module internally calls the official SDK of Google Cloud Storage (GCS) to perform the actual API call to obtain the bucket list. The obtained data is then converted into a response format that conforms to the S3 standard and is ultimately returned to the end user.

[0052] like Figure 3 As shown, it is a schematic diagram of the ConfigMa usage scenario in this embodiment, specifically:

[0053] First, create a ConfigMap object, where the key-value pairs represent the file name and content of the configuration file. Next, in the Pod's configuration file, mount the ConfigMap object as a volume and specify the mount path. In the container's configuration, point the configuration file path to the file in the mounted volume.

[0054] A configuration data persistence method according to an embodiment of the present invention includes:

[0055] Build a ConfigMap object containing the contents of the configuration file and mount the ConfigMap object to the update file in the MinIO S3Gateway container;

[0056] Acquire user operation data, pre-process the operation data, and obtain an operation configuration file;

[0057] Build a K8S API, and use the K8S API to synchronously update the operation configuration file to the ConfigMap object;

[0058] The ConfigMap object is dynamically monitored, and when it is monitored that the configuration file content in the ConfigMap object is updated, the updated configuration file content is stored in the update file.

[0059] In this embodiment, at the beginning of the project, in order to dynamically update the application configuration file without restarting the container, use Figure 3 In the scenario shown in ConfigMap, information persistence is achieved by mounting configuration files.

[0060] Among them, use the Configmap configuration named gw-config to name it config and mount it to the / app / config.yaml file in the container to store the configuration information in the file. After adding configuration information to the Configmap, Kubernetes will automatically update the configuration information to the mounted file, and users can log in without additional operations.

[0061] Optionally, construct a ConfigMap object containing the contents of the configuration file, including:

[0062] Write a YAML file to define a ConfigMap resource containing the configuration file content, and obtain a ConfigMap object, wherein the configuration file content is stored in the ConfigMap object in the form of key-value pairs.

[0063] Optionally, also include:

[0064] Initialize the ConfigMap object. If it does not exist, create a ConfigMap object in the K8S platform. If it does exist, load the existing ConfigMap object.

[0065] Optionally, mounting the ConfigMap object into an update file in the MinIO S3 Gateway container specifically includes:

[0066] Based on the Pod file system, define the ConfigMap object as a volume and generate a mount path for the ConfigMap object;

[0067] Based on the mount path, mount the ConfigMap object into the update file in the MinIO S3 Gateway container.

[0068] Optionally, the user's operation data is user information newly added by the user on the application interface; wherein the newly added user information includes modifying user information, adding new users, and changing user permissions.

[0069] Optionally, using the K8S API to synchronously update the operation configuration file to the ConfigMap object specifically includes:

[0070] Use the K8S.io library to build a client instance of the K8S API, and based on the client instance, establish interaction with the K8S API;

[0071] A ConfigMap update function is defined, and based on the ConfigMap update function, the operation configuration file is updated to the ConfigMap object through the K8S API.

[0072] Among them, Figure 4 The figure shows the MinIO S3 GateWay startup process in this embodiment. It includes the following steps:

[0073] 1. Register system signal monitoring and initialize global level Locker:

[0074] The gateway runs as a resident process after startup. In order to handle termination and other signals gracefully, it needs to register signal listeners. In addition, a global lock mechanism (Locker) is initialized.

[0075] 2. Initialize ConfigMap:

[0076] In a Kubernetes environment, ConfigMap is an object used to store configuration data. The gateway checks if there is a ConfigMap configuration file specific to the application. If not, a new blank ConfigMap is created.

[0077] 3. Initialize the Gateway router:

[0078] This step involves setting up routing rules so that clients can interact with the gateway through a standard set of S3 APIs. The router is responsible for distributing incoming requests to the appropriate handlers.

[0079] 4. Initialize management function routing:

[0080] In addition to the basic S3 API, the gateway also provides a management interface that allows users to manage and operate user information and permissions. Any operation on user information will synchronously update the corresponding ConfigMap to maintain configuration consistency.

[0081] 5. Use Credentials to call NewGatewayLayer to get an ObjectLayer instance.

[0082] 6. Start the IAM subroutine:

[0083] The IAM subsystem is responsible for handling user authentication and authorization, ensuring that only properly authenticated users can perform specific operations.

[0084] 7. Start httpServer to listen for client requests:

[0085] Finally, the HTTP server starts listening for requests from clients. Once started, the gateway can receive and process S3 API calls.

[0086] Optionally, also include:

[0087] Use the IAM subsystem to authenticate and authorize users.

[0088] In this embodiment, the package under k8s.io is used to call the interface, as shown below:

[0089]

[0090] Initialize the K8S client in the above way, create a secret in k8s to save the k8s connection information, and mount it in the .kube / config directory in the container. The client is initialized in singleton mode when the program starts, and it will only be executed once. Determine whether the config file exists. If it exists, instantiate the client, and then directly use clientset to operate k8s resources.

[0091] In the command registration process explored in the source code above, s3GatewayMain will be executed. When the system configuration is loaded in the function, CreateConfigMap is called to initialize ConfigMap. When creating configmap, the get method is used to check whether configmap exists. If the err returned by the get method is not empty and err is not found, the create method is used to create configmap. As shown below:

[0092]

[0093]

[0094] Provide a method to update the map of configmap, as follows. The function input is a yaml file in string format. The name of the configmap is obtained through the system variable. The configmap is obtained using the get method. The configmap has been initialized when the command is registered, so the configmap here must exist. After fully modifying the data of the configmap, update it to k8s, as shown below:

[0095]

[0096] Subsequently, other functions for operating accounts and permissions depend on updateConfigMap to be generated in sequence: including: modifying or adding account information, deleting user information, modifying or adding permission information, and deleting permission information.

[0097] Finally, you only need to query the function of the interface according to the interface operation information exposed by the admin router. If the interface involves account or permission information, call the relevant function to synchronize the configmap.

[0098] Based on Figure 1 Based on the same principle as the method shown in , the embodiment of the present invention also provides a configuration data persistence system, such as Figure 5 As shown in, including:

[0099] The ConfigMap module is used to build a ConfigMap object containing the contents of the configuration file and mount the ConfigMap object into the update file in the MinIO S3 Gateway container;

[0100] A user information module is used to obtain the user's operation data, pre-process the operation data, and obtain an operation configuration file;

[0101] A K8S API module is used to build a K8S API and use the K8S API to synchronously update the operation configuration file to the ConfigMap object;

[0102] The dynamic update module is used to dynamically monitor the ConfigMap object, and when it is monitored that the configuration file content in the ConfigMap object is updated, the updated configuration file content is stored in the update file.

[0103] The configuration data persistence system of the embodiment of the present invention can execute the configuration data persistence method provided by the embodiment of the present invention. The implementation principles are similar. The actions performed by each module and unit in the configuration data persistence system in each embodiment of the present invention correspond to the steps in the configuration data persistence method in each embodiment of the present invention. For the detailed functional description of each module of the configuration data persistence system, please refer to the description in the corresponding configuration data persistence method shown in the previous text, which will not be repeated here.

[0104] Among them, the above-mentioned configuration data persistence system can be a computer program (including program code) running in a computer device, for example, the configuration data persistence system is an application software; the application software can be used to execute the corresponding steps in the method provided in the embodiment of the present invention.

[0105] In some embodiments, the configuration data persistence system provided by the embodiments of the present invention can be implemented in a combination of software and hardware. As an example, the configuration data persistence system provided by the embodiments of the present invention can be a processor in the form of a hardware decoding processor, which is programmed to execute the configuration data persistence method provided by the embodiments of the present invention. For example, the processor in the form of a hardware decoding processor can adopt one or more application-specific integrated circuits (ASICs), DSPs, programmable logic devices (PLDs), complex programmable logic devices (CPLDs), field programmable gate arrays (FPGAs), or other electronic components.

[0106] The modules involved in the embodiments of the present invention may be implemented by software or hardware, wherein the name of a module does not limit the module itself in some cases.

[0107] Based on the same principle as the method shown in the embodiments of the present invention, an electronic device is also provided in the embodiments of the present invention, which may include but is not limited to: a processor and a memory; the memory is used to store a computer program; the processor is used to execute the method shown in any embodiment of the present invention by calling the computer program.

[0108] In an alternative embodiment, an electronic device is provided, such as Figure 6 As shown, Figure 6 The electronic device shown includes: a processor and a memory. The processor and the memory are connected, such as through a bus. Optionally, the electronic device may also include a transceiver, which may be used for data exchange between the electronic device and other electronic devices, such as data transmission and / or data reception. It should be noted that in actual applications, the transceiver is not limited to one, and the structure of the electronic device does not constitute a limitation on the embodiments of the present invention.

[0109] The processor may be a CPU (Central Processing Unit), a general-purpose processor, a DSP (Digital Signal Processor), an ASIC (Application Specific Integrated Circuit), an FPGA (Field Programmable Gate Array) or other programmable logic devices, transistor logic devices, hardware components or any combination thereof. It may implement or execute various exemplary logic blocks, modules and circuits described in conjunction with the disclosure of the present invention. The processor may also be a combination that implements computing functions, such as a combination of one or more microprocessors, a combination of a DSP and a microprocessor, etc.

[0110] The bus may include a path to transmit information between the above components. The bus may be a PCI (Peripheral Component Interconnect) bus or an EISA (Extended Industry Standard Architecture) bus, etc. The bus may be divided into an address bus, a data bus, a control bus, etc. For ease of representation, Figure 6 Only one thick line is used in the diagram, but this does not mean that there is only one bus or only one type of bus.

[0111] The memory can be ROM (Read Only Memory) or other types of static storage devices that can store static information and instructions, RAM (Random Access Memory) or other types of dynamic storage devices that can store information and instructions, or it can be EEPROM (Electrically Erasable Programmable Read Only Memory), CD-ROM (Compact Disc Read Only Memory) or other optical disk storage, optical disk storage (including compressed optical disk, laser disc, optical disk, digital versatile disc, Blu-ray disc, etc.), magnetic disk storage medium or other magnetic storage device, or any other medium that can be used to carry or store the desired program code in the form of instructions or data structures and can be accessed by a computer, but is not limited to this.

[0112] The memory is used to store the application code (computer program) for executing the solution of the present invention, and the execution is controlled by the processor. The processor is used to execute the application code stored in the memory to implement the content shown in the above method embodiment.

[0113] The electronic device may also be a terminal device. Figure 6 The electronic device shown is only an example and should not bring any limitation to the functions and scope of use of the embodiments of the present invention.

[0114] An embodiment of the present invention provides a computer-readable storage medium, on which a computer program is stored. When the computer-readable storage medium is run on a computer, the computer can execute the corresponding contents of the aforementioned method embodiment.

[0115] According to another aspect of the present invention, a computer program product or a computer program is also provided, the computer program product or the computer program comprising computer instructions, the computer instructions being stored in a computer-readable storage medium. A processor of a computer device reads the computer instructions from the computer-readable storage medium, and the processor executes the computer instructions, so that the computer device executes the methods provided in the implementation modes of the above-mentioned various embodiments.

[0116] Computer program code for performing the operations of the present invention may be written in one or more programming languages, or a combination thereof, including object-oriented programming languages, such as Java, Smalltalk, C++, and conventional procedural programming languages, such as "C" or similar programming languages. The program code may be executed entirely on the user's computer, partially on the user's computer, as a separate software package, partially on the user's computer and partially on a remote computer, or entirely on a remote computer or server. In cases involving a remote computer, the remote computer may be connected to the user's computer through any type of network, including a local area network (LAN) or a wide area network (WAN), or may be connected to an external computer (e.g., through the Internet using an Internet service provider).

[0117] It should be understood that the flow charts and block diagrams in the accompanying drawings illustrate the possible implementation architecture, functions and operations of the method and computer program product according to various embodiments of the present invention. In this regard, each box in the flow chart or block diagram can represent a module, a program segment, or a part of a code, and the module, the program segment, or a part of the code contains one or more executable instructions for realizing the specified logical function. It should also be noted that in some alternative implementations, the functions marked in the box can also occur in a sequence different from that marked in the accompanying drawings. For example, two boxes represented in succession can actually be executed substantially in parallel, and they can sometimes be executed in the opposite order, depending on the functions involved. It should also be noted that each box in the block diagram and / or flow chart, and the combination of the boxes in the block diagram and / or flow chart can be implemented with a dedicated hardware-based system that performs a specified function or operation, or can be implemented with a combination of dedicated hardware and computer instructions.

[0118] The computer-readable storage medium provided by the embodiment of the present invention may be, for example, but not limited to, an electrical, magnetic, optical, electromagnetic, infrared, or semiconductor system, device or device, or any combination thereof. More specific examples of computer-readable storage media may include, but are not limited to, an electrical connection with one or more wires, a portable computer disk, a hard disk, a random access memory (RAM), a read-only memory (ROM), an erasable programmable read-only memory (EPROM or flash memory), an optical fiber, a portable compact disk read-only memory (CD-ROM), an optical storage device, a magnetic storage device, or any suitable combination thereof. In the present invention, a computer-readable storage medium may be any tangible medium containing or storing a program that may be used by or in conjunction with an instruction execution system, device, or device.

[0119] The computer-readable storage medium carries one or more programs. When the one or more programs are executed by the electronic device, the electronic device executes the method shown in the above embodiment.

[0120] The above description is only a preferred embodiment of the present invention and an explanation of the technical principles used. Those skilled in the art should understand that the disclosure scope involved in the present invention is not limited to the technical solution formed by a specific combination of the above technical features, but should also cover other technical solutions formed by any combination of the above technical features or their equivalent features without departing from the above disclosed concept. For example, the above features are replaced with the technical features with similar functions disclosed in the present invention (but not limited to) by each other.

Claims

1. A configuration data persistence method, characterized in that: The method comprises: Build a ConfigMap object containing the contents of the configuration file and mount the ConfigMap object to the update file in the MinIO S3Gateway container; Acquire user operation data, pre-process the operation data, and obtain an operation configuration file; Build a K8S API, and use the K8S API to synchronously update the operation configuration file to the ConfigMap object; The ConfigMap object is dynamically monitored, and when it is monitored that the configuration file content in the ConfigMap object is updated, the updated configuration file content is stored in the update file.

2. A configuration data persistence method according to claim 1, characterized in that: Constructing a ConfigMap object containing the contents of a configuration file specifically includes: Write a YAML file to define a ConfigMap resource containing the configuration file content, and obtain a ConfigMap object, wherein the configuration file content is stored in the ConfigMap object in the form of key-value pairs.

3. A configuration data persistence method according to claim 2, characterized in that: Also includes: Initialize the ConfigMap object, and if it does not exist, create a ConfigMap object in the K8S platform; If it exists, load the existing ConfigMap object.

4. A configuration data persistence method according to claim 1, characterized in that: Mounting the ConfigMap object to the update file in the MinIO S3 Gateway container specifically includes: Based on the Pod file system, define the ConfigMap object as a volume and generate a mount path for the ConfigMap object; Based on the mount path, mount the ConfigMap object into the update file in the MinIO S3 Gateway container.

5. A configuration data persistence method according to claim 1, characterized in that: The user's operation data is the user information newly added by the user on the application program interface; wherein the newly added user information includes modifying user information, adding new users, and changing user permissions.

6. A configuration data persistence method according to claim 1, characterized in that: Using the K8S API to synchronously update the operation configuration file to the ConfigMap object specifically includes: Use the K8S.io library to build a client instance of the K8S API, and establish interaction with the K8S API based on the client instance; A ConfigMap update function is defined, and based on the ConfigMap update function, the operation configuration file is updated to the ConfigMap object through the K8S API.

7. A configuration data persistence method according to claim 1, characterized in that: Also includes: Use the IAM subsystem to authenticate and authorize users.

8. A configuration data persistence system, characterized in that: include: The ConfigMap module is used to build a ConfigMap object containing the contents of the configuration file and mount the ConfigMap object into the update file in the MinIO S3 Gateway container; A user information module is used to obtain the user's operation data, pre-process the operation data, and obtain an operation configuration file; A K8S API module is used to build a K8S API and use the K8S API to synchronously update the operation configuration file to the ConfigMap object; The dynamic update module is used to dynamically monitor the ConfigMap object, and when it is monitored that the configuration file content in the ConfigMap object is updated, the updated configuration file content is stored in the update file.

9. An electronic device, characterized in that: The method comprises a memory, a processor, and a computer program stored in the memory and executable on the processor, wherein the processor implements the method according to any one of claims 1 to 7 when executing the computer program.

10. A computer storage medium, characterized in that: The computer storage medium stores a computer program, and when the computer program is executed by a processor, the method according to any one of claims 1 to 7 is implemented.

Images