KR102519132B1 - System and method for operating self-growing software based on microservice - Google Patents

Abstract

A microservice-based self-growth software operating method is provided. The method may include identifying a unit function of at least one software operated in a system providing a predetermined service (hereinafter referred to as a service providing system); modularizing the software for each identified unit function (hereinafter referred to as module for each unit function); storing the module for each unit function in a storage; reading only some modules for each unit function stored in the storage and providing a service corresponding to the software; determining whether to autonomously respond to the service by tracking operating state data of the service providing system; and reading out at least one module for each unit function from among the stored modules for each unit function according to the autonomous correspondence and applying it to the software.

Description

Microservice-based self-growth software operating system and method {SYSTEM AND METHOD FOR OPERATING SELF-GROWING SOFTWARE BASED ON MICROSERVICE}

The present invention relates to a microservice-based self-growing software operating system and method.

Conventionally, when an unexpected situation such as changed requirements or defects occurs for IoT, production facilities, or various unmanned operating systems, in a situation where immediate intervention by the operator is difficult, it is operated in a state where defects exist according to importance or urgency, or for a certain period of time There was a problem with the system needing to be stopped for a while.

In addition, in the conventional automatic update technology, it is common to have to stop the operation of the system until new software is transmitted and applied. Also, since this is done in a way to replace the entire software with a new one rather than a growth-type architecture of partial elements of the software, there are many limitations depending on the network situation or the environment of the applied system.

An embodiment of the present invention minimizes administrator's intervention or system operation interruption to solve various issues such as errors, defects, and requirements for new functions in the operation of an IT system loaded with and running software. It provides a microservice-based self-growing software operating system and method that can solve issues while doing so.

However, the technical problem to be achieved by the present embodiment is not limited to the technical problem as described above, and other technical problems may exist.

As a technical means for achieving the above-mentioned technical problem, the microservice-based self-growth software operating method according to the first aspect of the present invention is at least one operating system that provides a predetermined service (hereinafter referred to as a service providing system). identifying unit functions of the software; modularizing the software for each identified unit function (hereinafter referred to as module for each unit function); storing the module for each unit function in a storage; reading only some modules for each unit function stored in the storage and providing a service corresponding to the software; determining whether to autonomously respond to the service by tracking operating state data of the service providing system; and reading out at least one module for each unit function from among the stored modules for each unit function according to the autonomous correspondence and applying it to the software. At this time, the operating state data includes resource usage, memory usage, and input/output data of the service providing system.

In some embodiments of the present invention, the step of tracking operating state data of the service providing system and determining whether to autonomously respond to the service may include changes in the operating state of the service providing system based on the operating state data and searching whether at least one of the pattern changes of the operating state data occurs; determining whether the software is defective by analyzing the operating state data when at least one of the operating state change and the pattern change occurs; and determining to take the autonomous response when it is determined that the software defect exists.

In some embodiments of the present invention, the step of determining whether the software is defective by analyzing the operating state data may include a predetermined first time interval analyzed based on the operating state data and after the first time interval. In the first and second time intervals, the amount of resource usage of the service providing system in the second consecutive predetermined time period exceeds the first predetermined error range, but the data being collected or processed corresponding to the software When the change in the amount of collection or throughput is within a predetermined second error range, it may be determined that the software has a defect.

In some embodiments of the present invention, the step of reading out at least one module for each unit function from among the stored modules for each unit function according to whether or not the autonomous correspondence is performed and applying the module to the software may include detecting a defect in the software among the modules for each unit function stored in the storage. Searching whether a corresponding module for each unit function is stored; and downloading the searched module for each unit function and loading the module into the memory.

In some embodiments of the present invention, the step of reading out at least one module for each unit function from among the stored modules for each unit function according to whether or not the autonomous correspondence is performed and applying the module to the software determines whether or not the module for each unit function can be downloaded according to the search result. judging; and if it is impossible to download the module for each unit function, dynamically loading or calling (remote procedure call) the module for each unit function stored in the storage to apply the module to the software.

In some embodiments of the present invention, the step of reading at least one module for each unit function from among the stored modules for each unit function according to whether or not the autonomous correspondence is performed and applying the module to the software may include determining to download the searched module for each unit function. , Dynamically loading or calling (remote procedure call) functions of modules for each unit function stored in the storage and applying them to the software may be further included.

In some embodiments of the present invention, the step of tracking operating state data of the service providing system and determining whether to autonomously respond to the service may include changes in the operating state of the service providing system based on the operating state data and searching whether at least one of the pattern changes of the operating state data occurs; determining whether at least one of sample data and meta data can be extracted from the operating state data when at least one of the operating state change and the pattern change occurs; and determining to perform the autonomous correspondence when extraction of the sample data or meta data is possible.

In some embodiments of the present invention, the step of reading out at least one module for each unit function from among the stored modules for each unit function according to whether or not the autonomous correspondence is performed and applying the module to the software includes the sample data or meta data among the modules for each unit function in the storage. searching whether a module for each unit function corresponding to is stored; and downloading the searched module for each unit function and loading the module into the memory.

In addition, the microservice-based self-growth software operating system according to the second aspect of the present invention includes a storage in which modules for each unit function of software providing predetermined services are stored, and a program for reading the module for each unit function and providing the service A communication module that reads a stored memory, a module for each unit function stored in the storage, and transmits the read module to the memory, and a processor that executes a program stored in the memory, wherein the processor executes the program, and the part stored in the storage Provides the service by reading only modules for each unit function of the software, tracks operating state data related to the software, determines whether or not to respond autonomously corresponding to the service, and determines at least one of the modules for each unit function stored in the storage according to the autonomous response. A module for each unit function is read and applied to the software, and the operating state data includes resource usage, memory usage, and input/output data.

In some embodiments of the present invention, the processor searches whether at least one of a change in the operating state of the software and a change in the pattern of the operating state data occurs based on the operating state data, and the change in the operating state and When at least one of the pattern changes occurs, the operating state data is analyzed to determine whether to take the autonomous response, and the operating state data is analyzed to determine whether or not the software is defective. When it is determined that the software has a defect, When at least one of sample data and meta data can be extracted from the operating state data, it may be determined to respond autonomously.

In some embodiments of the present invention, the processor may include at least one unit of a module for each unit function corresponding to a defect in the software among modules for each unit function stored in the storage, and a module for each unit function corresponding to at least one of the sample data and meta data. It may be searched whether a module for each function is stored, and the searched module for each unit function may be downloaded and loaded into the memory.

In some embodiments of the present invention, the processor determines whether the module for each unit function can be downloaded according to the search result, and if the download of the module for each unit function is impossible, the module for each unit function stored in the storage is called (Remote Procedure Call ) and can be applied to the software.

In addition to this, another method for implementing the present invention, another system, and a computer readable recording medium recording a computer program for executing the method may be further provided.

According to the present invention as described above, when various operational issues of the service providing system occur, it is possible to quickly respond before the intervention of the administrator or, in some cases, without requiring the intervention of the administrator, thereby improving the safety and stability of service provision.

In addition, while enabling software modularization and dynamic connection and calling of modules, it is possible to call functions of modules that exist in remote locations even without directly possessing software modules, thereby responding to various operational needs and situations. There are advantages to being able to. That is, after the self-growth trigger, a new module for each unit function is used even before module reception is completed, or self-growth can be applied even in a computing environment having limited resources such as IoT.

In addition, it is possible to perform system maintenance that is more advanced than automatic update technology by eliminating the need to necessarily accompany the administrator's intervention and system operation shutdown.

The effects of the present invention are not limited to the effects mentioned above, and other effects not mentioned will be clearly understood by those skilled in the art from the description below.

1 is a flowchart of a self-growing software operating method according to an embodiment of the present invention.
Figure 2 is a diagram for explaining a process according to whether or not to respond autonomously in an embodiment of the present invention.
3A to 3D are diagrams illustrating an example of reading a module for each unit function in an embodiment of the present invention.
4 is a diagram for explaining a self-growing software operating system according to an embodiment of the present invention.

Advantages and features of the present invention, and methods of achieving them, will become clear with reference to the detailed description of the following embodiments taken in conjunction with the accompanying drawings. However, the present invention is not limited to the embodiments disclosed below, but may be implemented in various different forms, only these embodiments are intended to complete the disclosure of the present invention, and are common in the art to which the present invention belongs. It is provided to fully inform the person skilled in the art of the scope of the invention, and the invention is only defined by the scope of the claims.

Terminology used herein is for describing the embodiments and is not intended to limit the present invention. In this specification, singular forms also include plural forms unless specifically stated otherwise in a phrase. As used herein, "comprises" and/or "comprising" does not exclude the presence or addition of one or more other elements other than the recited elements. Like reference numerals throughout the specification refer to like elements, and “and/or” includes each and every combination of one or more of the recited elements. Although "first", "second", etc. are used to describe various components, these components are not limited by these terms, of course. These terms are only used to distinguish one component from another. Accordingly, it goes without saying that the first element mentioned below may also be the second element within the technical spirit of the present invention.

Unless otherwise defined, all terms (including technical and scientific terms) used in this specification may be used with meanings commonly understood by those skilled in the art to which the present invention belongs. In addition, terms defined in commonly used dictionaries are not interpreted ideally or excessively unless explicitly specifically defined.

The present invention relates to a microservice-based self-growing software operating system (100) and method.

An embodiment of the present invention can grasp the time and requirements for self-growth by appropriate artificial intelligence technology, and based on this, it can support the structural growth of software in the future.

One embodiment of the present invention is characterized by applying self-growth software technology, which is an intelligent software technology capable of improving performance or function by autonomously adding or changing its own components as needed. In one embodiment of the present invention, the self-development software technology recognizes the operating situation of the software and derives the matters that need to be changed, such as improvement or addition, and artificial intelligence technology that is running a self-generated or externally acquired module. It consists of software architecture techniques that can be added to software.

Referring to FIGS. 1 to 5 , a microservice-based self-growth software operating method (hereinafter, self-growth software operating method) according to an embodiment of the present invention will be described.

1 is a flowchart of a self-growing software operating method according to an embodiment of the present invention.

Meanwhile, the steps shown in FIG. 1 may be understood to be performed by a server (hereinafter referred to as a server) operated by the self-growing software operating system 100, but is not limited thereto.

First, the server identifies a unit function of at least one software operated in a system providing a predetermined service (hereinafter, a service providing system) (S110), and modularizes the software for each identified unit function (hereinafter, a module for each unit function). (S120).

In one embodiment, the server identifies the first unit function and the second unit function of the software, modularizes a part corresponding to the identified first unit function to generate a first unit function module, and corresponds to the second unit function. A second unit function module is created by modularizing the part to be performed.

In this case, the first and second unit functions are referred to for convenience of description, and are not limited to entire unit functions constituting software. That is, the software may be modularized into at least one module for each unit function according to the identified unit function.

In addition, it goes without saying that the unit function in an embodiment of the present invention may be composed of a combination of a plurality of unit functions, or may be modularized into modules for each unit function after the plurality of unit functions are grouped and configured.

On the other hand, in one embodiment of the present invention, the service providing system and the software operating system 100 may be executed on an independent server computer, or may be implemented as one server and loaded as a server program on the server computer to be serviced. there is. Preferably, the service providing system can be operated separately from the software operating system 100 in the present invention in a remote location.

Next, after the server stores the module for each unit function in the storage (S130), the server reads only some of the modules for each unit function stored in the storage and provides a service corresponding to the software (S140).

In other words, the server does not link the module in charge of each unit function at the time of compilation, but allows the server to load and call the module in the memory of the service providing system at the time necessary during operation, but manages the module for each unit function in the storage to achieve self-growth. We can enable you to respond quickly to your needs.

Meanwhile, as a unit function corresponding to software is added, the server may identify a unit function corresponding to the added part to create a module for each unit function, and store it in a storage.

Next, the server tracks the operating state data of the service providing system to determine whether or not to respond autonomously corresponding to the service (S150), and reads at least one module for each unit function among stored modules for each unit function according to whether or not to respond autonomously to the software. Apply (S160).

As an embodiment, the operating state data may include resource usage such as CPU load of the service providing system, memory usage, and input/output data. Such operating state data can be continuously learned through pre-learned machine learning algorithms. For example, operation state data may be set as input data of a machine learning algorithm, and autonomous response necessity may be set as output data to perform learning, and the server may determine autonomous response using the learned machine learning algorithm. there is.

In one embodiment, the server tracks and analyzes operating state data during a first predetermined time interval, and tracks and analyzes operating state data during a second predetermined time interval consecutive after the first time interval. . At this time, in the present invention, for convenience, the first time interval corresponds to the usual operating state of the service providing system, and the second time interval is determined to be a state in which autonomous response is required due to a specific issue occurring unlike the usual operating state. let's assume

Figure 2 is a diagram for explaining a process according to whether or not to respond autonomously in an embodiment of the present invention.

First, the server searches whether at least one of a change in the operating state of the service providing system and a change in the pattern of the operating state data has occurred based on the operating state data (S205).

Next, when at least one of a change in operating conditions and a change in pattern occurs, the server analyzes the operating state data to determine whether or not the software is defective (S210). In addition, the server determines to autonomously respond when it is determined that a software defect exists.

For example, the server calculates the usage of each resource of the service providing system in a first predetermined time interval and a second predetermined time interval consecutive after the first time interval, which is analyzed based on operating state data, with a predetermined first error. While exceeding the range, if the change in the amount of collection or processing amount in the first and second time intervals of the data being collected or processed corresponding to the software is within the second predetermined error range, it can be determined that the software has a defect. .

That is, when the CPU load or memory usage of the service providing system abnormally increases, the server determines whether or not there is something to be improved for the module for each function of the first unit that triggers the situation. module can be applied.

In another embodiment, when at least one of a change in operating situation and a change in pattern occurs, the server determines whether at least one of sample data and meta data can be extracted from the operating state data (S215 and S225), and determines that it is extractable. In this case, after extracting sample data or meta data (S220 and S230), it may be determined to autonomously respond based on this.

In other words, based on the operating state data, the server searches for the collection of data of a different pattern than the one normally collected and processed by the service providing system, and sends samples of the collected data to the storage to determine if there is a corresponding module for each unit function. After discovery, the searched module for each unit function can be applied to software.

Alternatively, based on the operating state data, meta data specifying basic information about the functions of modules required for the software corresponding to the service is extracted, and after searching whether there is a module for each unit function corresponding to the extracted meta data in the repository, search Modules for each unit function can be applied to software.

At this time, in an embodiment of the present invention, when at least one of a change in operating situation and a change in pattern occurs, whether there is a defect in the software, whether sample data can be extracted, and whether or not meta data can be extracted are shown in FIG. As shown in FIG. 2, it may be judged sequentially, and unlike FIG. 2, it is also possible to independently determine whether or not to respond autonomously depending on whether one corresponds to the other.

3A to 3D are diagrams illustrating an example of reading a module for each unit function in an embodiment of the present invention.

If there is a defect in the software, the server searches whether a module for each unit function corresponding to the defect in the software is stored among the modules for each unit function stored in the storage based on this (S235).

And, if there is a module for each unit function corresponding to the software defect (S240), the searched module for each unit function may be downloaded and loaded into the memory of the service providing system (S250).

As an embodiment, the server may determine whether the module for each unit function searched for can be downloaded or loaded into a memory based on resources or network conditions of the service providing system.

If it is determined that the module for each unit function cannot be downloaded or loaded in the memory of the service providing system (S245-N), the server dynamically loads the module for each unit function stored in the storage as shown in FIGS. 3A to 3C or can be called (Remote Procedure Call) and applied to software (Application Core Module). At this time, the server may dynamically load and apply the module for each unit function (FIG. 3A) or call and apply the module for each unit function (FIG. 3B). Alternatively, when there are a plurality of modules for each unit function to be applied, they may be simultaneously read and applied as shown in FIG. 3C.

Accordingly, the service providing system has the advantage of being able to implement self-growth that can be applied through dynamic loading or calling of functions to be added or changed, even if it does not directly hold necessary unit function modules in the memory. In addition, there is an advantage in that self-growth software can be implemented even when the computing environment of the service providing system is limited.

As another embodiment, upon determining to download the searched module for each unit function, the server may call the module for each unit function stored in the storage and apply the module to the software.

That is, as shown in FIG. 3D, the server can dynamically load or call the downloaded module for each unit function even while downloading the module for each unit function, and can also dynamically load or call a function for a new module for each unit function that is different from the downloaded module. Through this, there is an advantage in that it is possible to call and use new functions through RPC without downloading modules for each new unit function in a limited computing environment such as IoT.

For example, the server calculates the download time and application completion time of the module for each unit function based on situation information such as network resources and data size information of the module for each unit function to be downloaded (hereinafter, a first time), and If the first time exceeds the second time after calculating the total time (hereinafter referred to as the second time) required for dynamic loading or calling and application of the may apply.

As such, the self-growth software operating method according to an embodiment of the present invention is involved in overall operation of software to which self-growth technology is applied, that is, management of installation and operation of modules for each unit function, connection and call of modules for each unit function, Modules for each unit function may not be linked to software in advance when the entire software is compiled, but may be dynamically loaded and called into the memory of the service providing system at the time of need so as to be interlocked with software.

On the other hand, in one embodiment of the present invention, after detecting a change in the operating situation or pattern occurrence of data in a service providing system, when there is no software defect and sample data and meta data cannot be extracted, or in this case, However, if there is no module for each unit function corresponding to the storage, the manager may be finally notified (S260). That is, in one embodiment of the present invention, the administrator's intervention is made in the last process.

Meanwhile, in the above description, steps S110 to S260 may be further divided into additional steps, or combined into fewer steps, according to an embodiment of the present invention. Also, some steps may be omitted if necessary, and the order of steps may be changed. In addition, even if other omitted contents, the contents described in FIGS. 1 to 3D are also applied to the microservice-based self-growth software operating system 100 of FIG. 4 .

Hereinafter, a microservice-based self-growing software operating system (100, hereinafter referred to as a self-growing software operating system) according to an embodiment of the present invention will be described.

4 is a diagram for explaining a self-growing software operating system 100 according to an embodiment of the present invention.

Referring to FIG. 4 , the self-growing software operating system 100 includes a storage 110 , a memory 120 , a communication module 130 and a processor 140 .

The storage 110 stores modules for each unit function of software providing predetermined services, and the memory 120 stores programs for reading out modules for each unit function and providing services.

The communication module 130 reads modules for each unit function stored in the storage 110 and transmits them to the memory 120, and the processor 140 executes a program stored in the memory 120.

The processor 140 provides a service by reading only some of the modules for each unit function stored in the storage 110, and autonomously responds corresponding to the service by tracking operating state data including resource usage, memory usage, and input/output data related to software. At least one module for each unit function among the modules for each unit function stored in the storage 110 is read out and applied to the software according to the autonomous correspondence.

The self-growth software operating method according to an embodiment of the present invention described above may be implemented as a program (or application) to be executed in combination with a server, which is hardware, and stored in a medium.

The aforementioned program is C, C++, JAVA, machine language, etc. It may include a code coded in a computer language of. These codes may include functional codes related to functions defining necessary functions for executing the methods, and include control codes related to execution procedures necessary for the processor of the computer to execute the functions according to a predetermined procedure. can do. In addition, these codes may further include memory reference related codes for which location (address address) of the computer's internal or external memory should be referenced for additional information or media required for the computer's processor to execute the functions. there is. In addition, when the processor of the computer needs to communicate with any other remote computer or server in order to execute the functions, the code uses the computer's communication module to determine how to communicate with any other remote computer or server. It may further include communication-related codes for whether to communicate, what kind of information or media to transmit/receive during communication, and the like.

The storage medium is not a medium that stores data for a short moment, such as a register, cache, or memory, but a medium that stores data semi-permanently and is readable by a device. Specifically, examples of the storage medium include ROM, RAM, CD-ROM, magnetic tape, floppy disk, optical data storage device, etc., but are not limited thereto. That is, the program may be stored in various recording media on various servers accessible by the computer or various recording media on the user's computer. In addition, the medium may be distributed to computer systems connected through a network, and computer readable codes may be stored in a distributed manner.

Steps of a method or algorithm described in connection with an embodiment of the present invention may be implemented directly in hardware, implemented in a software module executed by hardware, or implemented by a combination thereof. A software module may include random access memory (RAM), read only memory (ROM), erasable programmable ROM (EPROM), electrically erasable programmable ROM (EEPROM), flash memory, hard disk, removable disk, CD-ROM, or It may reside in any form of computer readable recording medium well known in the art to which the present invention pertains.

Although the embodiments of the present invention have been described with reference to the accompanying drawings, those skilled in the art to which the present invention pertains can be implemented in other specific forms without changing the technical spirit or essential features of the present invention. you will be able to understand Therefore, it should be understood that the embodiments described above are illustrative in all respects and not restrictive.

100: self-growth software operating system
110: storage
120: memory
130: communication module
140: processor

Claims (12)

In a method performed by a computer,
identifying a unit function of at least one software operated in a system providing a predetermined service (hereinafter referred to as a service providing system);
modularizing the software for each identified unit function (hereinafter referred to as module for each unit function);
storing the module for each unit function in a storage;
reading only some modules for each unit function stored in the storage and providing a service corresponding to the software;
determining whether to autonomously respond to the service by tracking operating state data of the service providing system; and
Reading at least one module for each unit function among the stored modules for each unit function according to whether the autonomous correspondence is performed and applying the module to the software;
The operating state data includes resource usage, memory usage, and input/output data of the service providing system,
The step of tracking the operating state data of the service providing system and determining whether to respond autonomously corresponding to the service,
Setting the operating state data as an input terminal and setting the need for autonomous response as an output terminal to determine autonomous response using a learned machine learning algorithm,
The step of reading at least one module for each unit function among the stored modules for each unit function according to whether or not the autonomous correspondence is performed and applying the module to the software,
When it is determined to download the module for each unit function that has been searched for according to the autonomous correspondence, the module for each unit function being downloaded is dynamically loaded or called (Remote Procedure Call) while the searched module for each unit function is being downloaded. Further comprising the step of applying to the software,
The step of applying the software,
Based on the network status information and the data size information of the module for each unit function to be downloaded, the first time, which is the download time and application completion time of the module for each unit function to be downloaded, is calculated, and it takes time to dynamically load or call and apply the same module for each unit function. After calculating the second time, which is the total time to be used, determining whether the first time exceeds the second time, and if it exceeds, dynamically loading or calling a module for each unit function at the same time as downloading to apply the software to the software. person,
Microservice-based self-growth software operation method.
According to claim 1,
The step of tracking the operating state data of the service providing system and determining whether to respond autonomously corresponding to the service,
searching for whether at least one of a change in an operating state of the service providing system and a change in a pattern of the operating state data occurs based on the operating state data;
determining whether the software is defective by analyzing the operating state data when at least one of the operating state change and the pattern change occurs; and
Including the step of determining that the autonomous response is to be made when it is determined that a defect in the software exists.
Microservice-based self-growth software operation method.
According to claim 2,
Analyzing the operating state data to determine whether the software is defective,
Each resource usage of the service providing system in a first predetermined time interval and a predetermined second time interval consecutive after the first time interval, analyzed based on the operating state data, falls within a predetermined first error range. exceed,
Determining that a defect exists in the software when a change in the amount of collection or processing in the first and second time intervals of data being collected or processed corresponding to the software is within a second predetermined error range,
Microservice-based self-growth software operation method.
According to claim 2,
The step of reading at least one module for each unit function among the stored modules for each unit function according to whether or not the autonomous correspondence is performed and applying the module to the software,
searching for a module for each unit function corresponding to a defect in the software among the modules for each unit function stored in the storage; and
Including the step of downloading the searched module for each unit function and loading it into the memory,
Microservice-based self-growth software operation method.
According to claim 4,
The step of reading at least one module for each unit function among the stored modules for each unit function according to whether or not the autonomous correspondence is performed and applying the module to the software,
determining whether a module for each unit function can be downloaded according to the search result; and
Further comprising the step of dynamically loading or calling (remote procedure call) the module for each unit function stored in the storage and applying it to the software when it is impossible to download the module for each unit function.
Microservice-based self-growth software operation method.
delete According to claim 1,
The step of tracking the operating state data of the service providing system and determining whether to respond autonomously corresponding to the service,
searching for whether at least one of a change in an operating state of the service providing system and a change in a pattern of the operating state data occurs based on the operating state data;
determining whether at least one of sample data and meta data can be extracted from the operating state data when at least one of the operating state change and the pattern change occurs; and
Including the step of determining to respond autonomously when extraction of the sample data or meta data is possible,
Microservice-based self-growth software operation method.
According to claim 7,
The step of reading at least one module for each unit function among the stored modules for each unit function according to whether or not the autonomous correspondence is performed and applying the module to the software,
searching whether a module for each unit function corresponding to the sample data or meta data among modules for each unit function is stored in the storage; and
Including the step of downloading the searched module for each unit function and loading it into the memory,
Microservice-based self-growth software operation method.
In a self-growing software operating system based on microservices,
A repository in which modules for each unit function of software providing predetermined services are stored;
a memory storing a program for reading the module for each unit function and providing the service;
A communication module for reading the module for each unit function stored in the storage and transmitting it to the memory; and
Including a processor that executes the program stored in the memory,
As the program is executed, the processor provides the service by reading only some of the modules for each unit function stored in the storage, and tracks operating state data related to the software to determine whether or not to autonomously respond to the service, , reading at least one module for each unit function from among the modules for each unit function stored in the storage according to whether or not the autonomous correspondence is performed and applying the module to the software;
The operating state data includes resource usage, memory usage, and input/output data.
The processor sets the operating state data as an input terminal and sets the need for autonomous response as an output terminal to determine whether to autonomously respond using a learned machine learning algorithm,
When it is determined to download the module for each unit function that has been searched for according to the autonomous correspondence, the module for each unit function being downloaded is dynamically loaded or called (Remote Procedure Call) while the searched module for each unit function is being downloaded. applied to the software,
Based on the network status information and the data size information of the module for each unit function to be downloaded, the first time, which is the download time and application completion time of the module for each unit function to be downloaded, is calculated, and it takes time to dynamically load or call and apply the same module for each unit function. After calculating the second time, which is the total time to be used, determining whether the first time exceeds the second time, and if it exceeds, dynamically loading or calling a module for each unit function at the same time as downloading to apply the software to the software. person,
Self-growing software operating system based on microservices.
According to claim 9,
The processor searches whether at least one of a change in the operating state of the software and a change in the pattern of the operating state data occurs based on the operating state data, and determines whether at least one of the change in the operating state and the pattern change has occurred. In this case, the operating state data is analyzed to determine whether to respond autonomously,
Analyzing the operating state data to determine whether or not the software is defective, and when it is determined that the software has a defect, determining to respond autonomously if at least one of sample data and meta data can be extracted from the operating state data person,
Self-growing software operating system based on microservices.
According to claim 10,
The processor determines whether at least one module for each unit function among modules for each unit function stored in the storage is stored, among modules for each unit function corresponding to a defect in the software and modules for each unit function corresponding to at least one of the sample data and meta data. Searching, downloading the searched module for each unit function and loading it into the memory,
Self-growing software operating system based on microservices.
According to claim 11,
The processor determines whether the module for each unit function can be downloaded according to the search result, and if it is impossible to download the module for each unit function, calling the module for each unit function stored in the storage (Remote Procedure Call) to apply the module to the software person,
Self-growing software operating system based on microservices.

Images