Computer environment construction system and computer environment construction method
The system addresses the challenge of identifying modification targets in software migration by using container-based virtualization to create hierarchized execution environments, simplifying the management of software assets in new computer environments.
Patent Information
- Application Number
- JP2023078847
- Authority / Receiving Office
- JP · JP
- Patent Type
- Applications
- Current Assignee / Owner
- Filing Date
- 2023-05-11
- Publication Date
- 2024-11-21
AI Technical Summary
In the migration of software assets to new computer environments, the lack of appropriate isolation and hierarchy in execution environments leads to difficulties in identifying and managing modification targets, resulting in potential extensive corrections.
A computer environment construction system that selects elements based on logical relationships and dependencies, generating a hierarchized structure for independent execution environments using container-based virtualization, and deploys these environments to nodes with a deployment management unit.
Facilitates easy identification and management of modification targets, reducing the complexity and effort required in updating or modifying software assets in new environments.
Smart Images

Figure 2024162883000001_ABST
Abstract
Description
[Technical field]
[0001] The present invention relates to a computer environment construction system and a computer environment construction method. [Background technology]
[0002] Traditionally, existing software assets (resources) for control systems or infrastructure systems have been migrated to new hardware, OS (Operating System), or new IT technology environments such as virtualized environments in order to utilize existing assets.
[0003] Regarding the construction of a system using virtualization technology, for example, Patent Document 1 discloses a technology for creating a virtual computer (virtual machine) within a physical node and running multiple different OSs in parallel within the same physical node. The technology described in Patent Document 1 makes it possible to use physical devices efficiently, and is expected to reduce resource management costs. [Prior art documents] [Patent documents]
[0004] [Patent Document 1] Patent No. 7118230 Summary of the Invention [Problem to be solved by the invention]
[0005] In recent years, it has become common to form independent execution environments for execution units such as software functions or packages in existing software assets, and to deploy each of the formed execution environments in a new computer environment after migration. The independent execution environments can be constructed, for example, using software stacks, virtual machines, and containers generated by container-based virtualization technology. In each independent execution environment, library files, programs, and the like required for software execution are arranged in a hierarchical structure.
[0006] Therefore, if the units of isolation for the execution environment and the hierarchical structure are not set properly, when modifying software based on the operation of a new environment or adding new functions, it may not be possible to clearly identify the corresponding areas to be modified, or the amount of modifications that need to be made may become enormous.
[0007] The present invention has been made in consideration of the above circumstances, and an object of the present invention is to provide a computer environment to which existing software assets can be migrated, which makes it possible to easily clarify the objects to be modified. [Means for solving the problem]
[0008] A computing environment construction system according to one embodiment of the present invention includes a hierarchical information generation unit that assigns elements to one of a plurality of layers based on information on the logical relationships and dependencies between each element that constitutes an application to be migrated to a new computing environment, and a deployment management unit that generates an independent execution environment including the plurality of layers and deploys the independent environment to a node in a real environment. Effect of the Invention
[0009] According to at least one aspect of the present invention, a computer environment to which existing software assets are migrated is provided, which allows easy clarification of the object to be modified. Problems, configurations and effects other than those described above will become apparent from the following description of the embodiments. [Brief description of the drawings]
[0010] [Figure 1] FIG. 2 is a diagram illustrating an example of a package configuration of existing middleware to be containerized according to the first embodiment of the present invention. [Diagram 2] FIG. 2 is a diagram illustrating an example of the configuration of a container image according to the first embodiment of the present invention. [Diagram 3] 1 is a block diagram showing an example of a functional configuration of a virtualization environment construction system according to a first embodiment of the present invention. [Figure 4]1 is a block diagram showing an example of a hardware configuration of a virtualization environment construction system according to a first embodiment of the present invention. [Diagram 5] FIG. 2 is a diagram showing an example of the configuration of a library list according to the first embodiment of the present invention. [Figure 6] FIG. 2 is a diagram showing an example of a configuration of a hierarchical configuration table according to the first embodiment of the present invention. [Figure 7] 10 is a flowchart showing an example of a procedure of a library list generation process performed by a library list generation unit according to the first embodiment of the present invention. [Figure 8] 5 is a flowchart showing an example of a procedure for generating a hierarchical configuration table by a classification unit according to the first embodiment of the present invention. [Figure 9] FIG. 4 is a diagram showing an example of a generation process of a hierarchical configuration table according to the first embodiment of the present invention. [Figure 10] 10 is a flowchart showing an example of a procedure of a container image generation process performed by an image generation unit according to the first embodiment of the present invention. [Figure 11] 10 is a flowchart showing an example of a procedure of a container image generation process performed by an image generation unit according to the first embodiment of the present invention. [Figure 12] FIG. 2 is a diagram showing an example of a design file in which the names of post-build products to be deployed in each layer according to the first embodiment of the present invention are described. [Figure 13] FIG. 2 is a diagram illustrating an example of a process for generating a container image according to the first embodiment of the present invention. [Figure 14] 10 is a flowchart illustrating an example of a procedure of deployment determination processing by a deployment determining unit according to the first embodiment of the present invention. [Figure 15] 5 is a flowchart showing an example of a procedure of update management processing by an update management unit 23 of the deployment / update management unit 20 according to the first embodiment of the present invention. [Figure 16] FIG. 11 is a diagram illustrating an example of the configuration of a software stack according to a second embodiment of the present invention. [Figure 17] FIG. 11 is a block diagram showing an example of the functional configuration of a computer environment construction system according to a second embodiment of the present invention. [Figure 18] FIG. 11 is a diagram illustrating an example of a process for generating a software stack according to the second embodiment of the present invention. DETAILED DESCRIPTION OF THE PREFERRED EMBODIMENTS
[0011] Hereinafter, an embodiment of the present invention will be described with reference to the drawings. In each drawing, the same components are given the same reference numerals. The following description and drawings are examples for explaining the present invention, and are omitted and simplified as appropriate for clarity of explanation. The present invention can be implemented in various other forms. Unless otherwise specified, each component may be singular or plural.
[0012] <First embodiment> In a first embodiment of the present invention, a virtualization environment construction system, which is an example of a computer environment construction system of the present invention, uses container-based virtualization technology to containerize middleware applications, which are existing software assets. Container-based virtualization is a technology that forms independent spaces (one example of an independent execution environment) called "containers" on a host OS and constructs an execution environment for applications in each independent space. Each container shares the resources of the logically separated host OS and can operate separately, so that the user can treat each container as if it were an individual server.
[0013] In this embodiment, for example, it is assumed that applications constituting middleware that controls each device or equipment on a manufacturing line are containerized. From the viewpoint of maintainability, it is preferable to containerize in units of application packages.
[0014] FIG. 1 is a diagram showing an example of a package configuration of existing middleware to be containerized. Each block in FIG. 1 indicates a package, and the letters "Nc", "Nb" and so on in each block indicate the name of the package. The capital letters in the package name are assigned letters corresponding to the classification of the package functions. For example, "N" is assigned to a package that provides functions shared between packages, "G" is assigned to a package with a function for performing image display-related processing, and "D" is assigned to a package with a function for performing data processing.
[0015] The arrows in the figure indicate the direction of input and output of information between each package. The cooperation between packages indicated by the arrows is performed via a Dynamic Link Library (DLL) file (an example of a shared library file). Therefore, when the cooperation between packages is tight, such as the middleware illustrated in FIG. 1, if the DLL files and packages are not appropriately containerized, problems such as the number of containers to be modified when a certain modification is performed may occur.
[0016] The virtualization environment construction system according to this embodiment containerizes existing software assets by classification that allows easy and clear identification of the target (scope) of modification when modification is performed. Specifically, the virtualization environment construction system constructs containers based on information such as logical relationships between packages indicated by the functions of existing packages and dependencies indicated by input and output of information between packages.
[0017] Figure 2 is a diagram showing an example of the configuration of a container image. A container image is binary data that describes an application to be executed as a container, a group of libraries on which the application depends, the settings of the container itself, etc. Then, a container is generated by executing the container image using a command, and the container is executed.
[0018] A container image has a layered structure as shown in Figure 2. The container image shown in Figure 2 is layered from the bottom up, with an OS base image, a common settings image, a common library image in layer 1, a group library image in layer 2, and a package image in layer 3.
[0019] The common setting image describes OS registry settings, environment variable settings, security settings, etc. The common library image of layer 1 (an example of the first layer) describes DLL files and setting contents that are commonly used in all packages.
[0020] The group library image of layer 2 (an example of the second layer) describes DLL files and setting contents commonly used in each group of functions such as image display function, data processing function, etc. In other words, the group library image of layer 2 is generated corresponding to each function of the package.
[0021] The package image of layer 3 (an example of the third layer) describes the DLL files and configuration contents on which a single package depends. The package image of layer 3 shown in FIG. 2 is generated for each package shown in FIG. 1. The names "Ga", "Gb", etc. in layer 3 shown in FIG. 2 correspond to the package names shown in FIG. 1. The vertically divided area enclosed by the dashed line frame in FIG. 2 corresponds to one container. The dashed line frame, which is wider than the dashed line frame, indicates the range of the container image installed in each node (terminal device) in the actual environment.
[0022] As shown in Figure 2, the group library image of layer 2 is generated separately for units such as image display function and data processing function, so it is possible to easily and clearly associate the node where the container is implemented with the function. This also makes it easy to identify the scope of modification (the container to be modified) when a modification is requested from the development environment.
[0023] 2, a DLL file that is less dependent on other DLL files is placed in a lower layer. A DLL file that is less dependent is a file that is referenced by other DLL files or packages many times and / or a file that is modified less frequently (number of times). In other words, in this embodiment, the virtualization environment construction system generates a container image based on information such as the dependency relationship of the DLL file and the modification history of the package.
[0024] [Virtualization environment construction system configuration] Next, the configuration of the virtualization environment construction system according to this embodiment will be described with reference to Fig. 3. Fig. 3 is a block diagram showing an example of the functional configuration of the virtualization environment construction system 1.
[0025] 3, the virtualization environment construction system 1 (an example of a virtualization environment construction system) includes a hierarchical information generation unit 10 and a deployment and update management unit 20. The hierarchical information generation unit 10 and the deployment and update management unit 20 in the virtualization environment construction system 1 may be provided in the same device, or may be provided in separate devices connected via a network.
[0026] (Hierarchical information generation unit) The layer information generator 10 generates a layer configuration table 14 that stores information such as DLL file dependencies and package revision history, and generates a container image based on the information in the layer configuration table 14. The deployment / update manager 20 deploys containers to nodes based on the information in the layer configuration table 14, and modifies or updates the information in the container based on the revisions entered by the user.
[0027] The hierarchical information generating unit 10 includes a library list generating unit 12 (denoted as “LIB list generating unit” in the drawing), a classification unit 13, a hierarchical configuration table 14, and an image generating unit 15.
[0028] The library list generating unit 12 generates a library list 121 (see FIG. 5) that is the basis of the hierarchical configuration table 14, based on information on the modification log of the source code (hereinafter also simply referred to as "source") of each package to be containerized. The library list 121 is a list that stores information on DLL files on which each package depends, information on functions (I / F functions) called by each DLL file, information on the number of modifications of the DLL files and executable programs included in each package, etc. The library list 121 will be described in detail with reference to FIG. 5 described later, and the procedure for generating the library list 121 will be described in detail with reference to FIG. 7 described later.
[0029] The library list generating unit 12 obtains the source of the package, for example, the modification log of the executable binary file, using a tool such as dumpbin. If the executable binary file is written in IL (Intermediate Language) format, the library list generating unit 12 can obtain the modification log of the executable binary file using a tool such as ildasm.
[0030] The library list generating unit 12 also lists post-build products from the build files of each acquired source, and acquires information on dependent DLL files and functions used in each post-build product. The build files include, for example, solution files. The post-build products include information on the names of processes to be executed, libraries such as DLL files, and the like.
[0031] Furthermore, the library list generation unit 12 acquires a commit log of the source using a command such as git log, and acquires information on the revision frequency of each package, for example, the number of revisions, based on the information in the acquired commit log. Then, the library list generation unit 12 uses the acquired information to generate the library list 121. Note that the method by which the library list generation unit 12 acquires the revision history may be a method other than the above.
[0032] The classification unit 13 generates a hierarchical configuration table 14, which is referred to when generating or modifying a container image, based on the information of the library list 121 generated by the library list generation unit 12. The hierarchical configuration table 14 is a table that stores information about each DLL file stored in the library list 121, classification results of each DLL file into layers of the container image, etc. An example of the configuration of the hierarchical configuration table 14 will be described in detail with reference to FIG. 6 described later.
[0033] The classification unit 13 classifies each DLL file so that a DLL file with a larger number of overlaps in the referencing package and / or a DLL file with a lower frequency of modification is placed in a lower layer. Then, the classification unit 13 generates the hierarchical configuration table 14 using the information in the library list 121 and the information of the classification result of each DLL file. The process of generating the hierarchical configuration table 14 by the classification unit 13 will be described in detail with reference to Figs. 8 and 9 described later.
[0034] The image generation unit 15 generates a container image based on the contents of the hierarchical configuration table 14 generated by the classification unit 13. The container image generated by the image generation unit 15 is stored in a repository 151 (denoted as "repo" in the figure). The container image generation process by the image generation unit 15 will be described in detail with reference to Figs. 10 to 12 described later. The container image generated by the image generation unit 15 may be stored in a registry such as Docker Hub provided as a service, or a registry built using a registry construction tool.
[0035] (Deployment / Update Management Department) The deployment / update management unit 20 (an example of a deployment management unit) includes a deployment determination unit 21, a deployment unit 22, and an update management unit . The deployment determination unit 21 determines the deployment of each container in a node based on the information stored in the hierarchical configuration table 14. More specifically, the deployment determination unit 21 determines that containers in the same functional group are deployed in the same node. The deployment determination process by the deployment determination unit 21 will be described in detail with reference to FIG. 13, which will be described later.
[0036] The deployment unit 22 actually deploys the containers to the nodes based on the content of the deployment determined by the deployment determining unit 21. When the update management unit 23 receives a modification instruction from the development environment, it refers to the hierarchical configuration table 14 to identify and modify the container image to be modified, and downloads the difference between the container image and the modification content, thereby modifying the container. The update management process by the update management unit 23 will be described in detail with reference to FIG. 15 below.
[0037] [Example of computer hardware configuration] Next, the hardware configuration of the device for realizing the functions of the virtualization environment creation system 1 according to this embodiment will be described with reference to FIG.
[0038] Fig. 4 is a block diagram showing an example of the hardware configuration of the virtualization environment construction system 1. A calculator 200 shown in Fig. 4 is hardware used as a so-called computer.
[0039] The computer 200 includes a control unit 210, a non-volatile storage 220, a display unit 230, an operation input unit 240, and a communication I / F (Interface) 250, which are all connected to a bus B.
[0040] The control unit 210 includes a central processing unit (CPU) 211, a read only memory (ROM) 212, and a random access memory (RAM) 213.
[0041] The CPU 211 reads out program code of software for implementing each function according to this embodiment from the ROM 212, expands it in the RAM 213, and executes it. Variables, parameters, etc. generated during the arithmetic processing are temporarily written in the RAM 213.
[0042] Each function of the hierarchical information generator 10 and the deployment / update manager 20 of the virtualization environment construction system 1 is realized by the CPU 211 reading out the corresponding program code from the ROM 212, expanding it in the RAM 213, and executing it.
[0043] The control unit 210 may include a processing device such as a micro-processing unit (MPU) instead of the CPU 211. Alternatively, the control unit 210 may include a dedicated circuit (such as a field-programmable gate array (FPGA) or an application specific integrated circuit (ASIC)) that performs specific processing.
[0044] The non-volatile storage 220 may be, for example, a hard disk drive (HDD), a solid state drive (SSD), a flexible disk, an optical disk, a magneto-optical disk, a CD-ROM, a CD-R, a non-volatile memory card, etc. In addition to an operating system (OS) and various parameters, programs for operating the computer 200, etc. are recorded in this non-volatile storage 220. The programs may be stored in the ROM 212.
[0045] The display unit 230 is, for example, a monitor configured with an LCD (Liquid Crystal Display) or the like, and displays the results of processing performed by the computer 200, and the like. The operation input unit 240 is configured with, for example, a keyboard, a mouse, a touch sensor, etc., and generates an operation signal according to an operation by a user and supplies the operation signal to the CPU 211. The display unit 230 and the operation input unit 240 may be integrated into a single unit as a touch panel. The calculator 200 may be configured without the display unit 230 and the operation input unit 240.
[0046] The program is stored in the form of a computer-readable program code, and the CPU 211 sequentially executes operations according to the program code. In other words, the ROM 212 or the non-volatile storage 220 is used as an example of a computer-readable non-transitory recording medium that stores a program executed by a computer.
[0047] The source 11, the hierarchical configuration table 14 and the repository 151 of the hierarchical information generator 10 of the virtualization environment construction system 1 are formed in the non-volatile storage 220 or the ROM 212.
[0048] The communication I / F 250 may be, for example, a network interface card (NIC), and may transmit and receive various data to and from external devices via a network or communication line.
[0049] [Library list configuration example] Next, the configuration of the library list 121 generated by the library list generating unit 12 (see FIG. 3) will be described with reference to FIG 5. FIG 5 is a diagram showing an example of the configuration of the library list 121.
[0050] As shown in FIG. 5, library list 121 has the following items: "Package name" (denoted as "PKG name" in the figure), "Post-build product", "Dependent DLL name", "DLL function name", and "Modification frequency".
[0051] The "Package name" field stores the name of the package. The "Post-build product" field stores information about the product after the build. The "Dependent DLL name" field stores the name of the DLL file on which the package depends. The "DLL function name" field stores information about functions written in the DLL file that are called by the package or other DLL files, etc. The "Modification frequency" field stores information about the number of times the package has been modified in the past.
[0052] [Example of hierarchical configuration table] Next, the configuration of the hierarchical configuration table 14 generated by the image generating unit 15 (see FIG. 3) will be described with reference to Fig. 6. Fig. 6 is a diagram showing an example of the configuration of the hierarchical configuration table 14.
[0053] 6, the hierarchical configuration table 14 has the following items: "DLL name," "List of packages used," "Modification frequency," "Number of packages used," "Duplication," "Affiliated package," and "Layer." (In the figure, "package" is written as "PKG.")
[0054] The "DLL name" field stores the name of the DLL file. The "Using package list" field stores the names of the packages that use that DLL file. The "Modification frequency" field stores the number of times the DLL file has been modified. The "Number of packages using" field stores the number of packages that use that DLL file.
[0055] The "overlap" field stores the number of packages that use the DLL file, i.e., the number of overlaps of references to the DLL file from the perspective of the package. The "belonging package" field stores the name of the package to which the DLL file is assigned (belongs) in the container.
[0056] The "Layer" item stores information about the layer in which the DLL file is located. The layer information includes the common library image in layer 1, the group library image in layer 2, and the package library image in layer 3 (see Figure 2).
[0057] As described above, the classification unit 13 classifies each DLL file such that a DLL file with a larger number of overlaps with the reference package and / or a DLL file with a lower frequency of modification is placed in a lower layer. Note that the hierarchical configuration table 14 may include both the classification results into layers determined by prioritizing the degree of overlap and the classification results into layers determined by prioritizing the frequency of modification.
[0058] Alternatively, information other than the degree of duplication and the frequency of modification may be used as information to be referenced when classifying into layers. For example, information on the size (amount of data) of a DLL file (library) may be referenced. Since DLL files that have a large number of referencing packages or DLL files (high degree of duplication) tend to have a large file capacity, the classification unit 13 can assign large DLL files to lower layers.
[0059] [Library list generation process] Next, a process of generating the library list 121 by the library list generating unit 12 (see FIG. 3) will be described with reference to Fig. 7. Fig. 7 is a flowchart showing an example of a procedure of the process of generating the library list 121 by the library list generating unit 12.
[0060] First, the library list generation unit 12 collects modification logs for each source of the package (step S1). Next, the library list generation unit 12 lists the products after the build from the build files for each source collected in step S1 (step S2).
[0061] Next, the library list generation unit 12 starts the DLL information acquisition process (step S3). The DLL information acquisition process is repeated the same number of times as the number of post-build products from which DLL information is to be acquired. In the DLL information acquisition process, the library list generation unit 12 acquires information on DLL files used by the post-build products from the binary information of the post-build products (step S4).
[0062] Next, the library list generation unit 12 obtains, from the information of the DLL file obtained in step S4, information on other DLL files on which the DLL file depends, and information on functions (I / F functions) called by the DLL file (step S5).
[0063] Next, the library list generation unit 12 judges whether or not there is a dependent DLL file (step S6). If it is judged in step S6 that there is no dependent DLL file (if the judgment in step S6 is NO), the library list generation unit 12 returns to step S4 and performs the process. That is, the library list generation unit 12 obtains the DLL file information of the next post-build product.
[0064] On the other hand, if it is determined in step S6 that there is a dependent DLL file (YES in step S6), the library list generation unit 12 performs the process of step S5. Then, when there are no more post-build products from which DLL information is to be obtained, the library list generation unit 12 ends the DLL information obtaining process.
[0065] After the DLL information acquisition process is completed, the library list generation unit 12 generates the library list 121 by using the information acquired by the DLL information acquisition process and the information on the revision history (number of times) collected from the commit log, etc. (Step S7). After the process of Step S7, the library list generation process by the library list generation unit 12 ends.
[0066] [Hierarchy configuration table generation process] Next, a description will be given of the process of generating hierarchical configuration table 14 by classification unit 13. Fig. 8 is a flowchart showing an example of the procedure of the process of generating hierarchical configuration table 14 by classification unit 13.
[0067] The classification unit 13 generates the hierarchical configuration table 14 by performing three-phase processing, Phase 1 to Phase 3 (denoted as PH1 to PH3 in the drawing). First, the classification unit 13 reads the library list 121 and generates statistical data for each DLL file (Step S11). The statistical data is data configured from information on the number of overlapping packages that use the DLL file, the name of the package to which the DLL file belongs (is dependent), and the frequency of modification.
[0068] Next, as the process of Phase 1, the classification unit 13 performs a process of allocating each DLL file to layers 1 to 3 (step S12). The allocation process is repeated the same number of times as the number of DLL files to be allocated.
[0069] In the process of phase 1, the classification unit 13 first assigns DLL files whose package overlap count exceeds a predetermined threshold to layer 1 (common library image) (step S13). The package overlap count threshold is indicated by, for example, the ratio (%) of the overlap count to the total number of packages.
[0070] Next, the classification unit 13 assigns the DLL file, which has no overlapping packages and has "1" package usage count, to layer 3 (step S14). The DLL file being used by one package means that the DLL file is used only by that package. Therefore, the classification unit 13 assigns such a DLL file to the top layer 3 (package image) where the package itself is deployed.
[0071] Next, the classification unit 13 assigns the DLL files that have not been assigned to layer 1 or layer 3 to layer 2 (group library image) (step S15). When there are no more DLL files to be assigned, the classification unit 13 ends the process of assigning each DLL file to layers 1 to 3.
[0072] Next, in Phase 2, the classification unit 13 adjusts layer allocation for the DLL files already assigned to layer 1 based on information on the frequency of revision in the statistical data generated in step S11 (step S16). Specifically, the classification unit 13 moves from layer 1 to layer 2 those DLL files that have been revised a predetermined threshold or more among the DLL files assigned to layer 1 in step S13.
[0073] For example, there is a high possibility that each container having the image display processing function shown in Fig. 2 will be frequently modified based on the user's instruction to change the specifications, etc. By moving the DLL file corresponding to such a function to layer 2 and implementing the container in the node for each function group of layer 2, it is possible to limit the scope of modifications to within the node (node 1 in the example shown in Fig. 2).
[0074] Next, in phase 3, the classification unit 13 adjusts the placement of the DLL file in layer 2 based on the information on the package name to which the DLL file belongs (depends) in the statistical data generated in step S11 (step S17). Specifically, the classification unit 13 divides layer 2 into functional groups based on the information on the package name to which the DLL file belongs (depends), and moves the DLL file corresponding to the functional group to the functional group. Fig. 2 shows an example in which the functional groups are divided into three groups: "image display processing", "data processing", and "server processing".
[0075] Next, the classification unit 13 generates the hierarchical configuration table 14 using the statistical data of each DLL file created in step S11 and the information on the allocation results of each DLL file to each layer performed in steps S13 to S17 (step S18). After the process of step S18, the process of generating the hierarchical configuration table by the classification unit 13 ends.
[0076] Fig. 9 is a diagram showing an example of a process for generating the hierarchical configuration table 14. Fig. 9 shows an example of the configuration of a container image after each process of phase 1 to phase 3 is executed. When the classification unit 13 executes the process of phase 1 in step S13 of Fig. 8, the container image becomes the state shown on the left side of Fig. 9. That is, the container image becomes the state in which a common library image (layer 1), a group library image (layer 2), and a package image (layer 3) are layered on top of the OS base image and the common setting image.
[0077] When the classification unit 13 performs the process of phase 2 in step S16 of Fig. 8, the container image becomes the state shown in the center of Fig. 9. Note that the OS base image and the common setting image are omitted from the container image shown in the center of Fig. 9. In the container image shown in the center of Fig. 9, the layer of the common library image (layer 1) is thinner and the layer of the group library image (layer 2) is thicker compared to the container image shown on the left side. This is because the DLL file assigned to the common library image (layer 1) has been moved to the group library image (layer 2) by the process of phase 2.
[0078] When the classification unit 13 performs the process of phase 3 in step S17 of Fig. 8, the container image becomes in the state shown on the right side of Fig. 9. Note that the OS base image and the common setting image are also omitted from the container image shown on the right side of Fig. 9. In the container image shown on the right side of Fig. 9, the group library image (layer 2) is divided into each function group such as "image processing function" and "server function". Note that the number of divided function groups is not limited to three and may be another number.
[0079] [Container image generation process] Next, a description will be given of a container image generation process performed by the image generation unit 15. Fig. 10 and Fig. 11 are flowcharts showing an example of a procedure for the container image generation process performed by the image generation unit 15.
[0080] First, the image generation unit 15 (see FIG. 3) of the layer information generation unit 10 acquires the post-build product name for the container image generation target from among the post-build product items in the library list 121 (see FIG. 5) (step S21). Next, the image generation unit 15 performs a container image generation process for layer 1 (step S22). The container image generation process for layer 1 is repeated the number of times equal to the number of DLL files assigned to layer 1 in the layer configuration table 14.
[0081] In the container image generation process for layer 1, the image generation unit 15 first refers to the hierarchical configuration table 14 to list (obtain) the post-build product names to be placed in layer 1, and generates a design file Fc1 (see Figure 12) that serves as the basis for the container image (step S23).
[0082] FIG. 12 is a diagram showing an example of a design file in which the names of post-build products to be deployed in each layer are described. Fig. 12 shows a design file Fc1 for layer 1 generated in step S23 of Fig. 10, a design file Fc2 for layer 2 generated by a process described later, and a design file Fc3 for layer 3. In each of the design files Fc1 to Fc3 in Fig. 12, the name of the post-build product to be arranged in each of the layers 1 to 3 is described.
[0083] After processing step S23 in FIG. 10, the image generation unit 15 generates a container image of layer 1 by launching the installers for each package and installing the post-build products described in the design file Fc1 generated in step S23 (step S24).
[0084] Next, the image generating unit 15 performs a container image generating process for layer 2 (step S25). In the container image generating process for layer 2, the image generating unit 15 first sets layer 1 as a base image (step S26). Next, the image generating unit 15 refers to the hierarchical configuration table 14, lists (obtains) the post-build product names to be placed in layer 2, and generates a design file Fc2 (see FIG. 12) (step S27). Next, the image generating unit 15 generates a container image for layer 2 by installing the post-build products described in the design file Fc2 generated in step S27 (step S28).
[0085] The above-mentioned processes of steps S27 and S28 are repeated the number of times equal to the number of DLL files assigned to layer 2 in the layer configuration table 14.
[0086] Next, the image generation unit 15 performs a container image generation process for layer 3 (step S29 in FIG. 11). In the container image generation process for layer 3, the image generation unit 15 first sets layer 2 as a base image (step S30). Next, the image generation unit 15 refers to the hierarchical configuration table 14, lists (obtains) the names of post-build products to be placed in layer 3, and generates a design file Fc3 (see FIG. 12) (step S31). Next, the image generation unit 15 generates a container image for layer 3 by installing the post-build products described in the design file Fc3 generated in step S31 (step S32).
[0087] The above-described processes of steps S31 and S32 are repeated the number of times equal to the number of DLL files assigned to layer 3 in the hierarchical configuration table 14. After the process of step S32, the container image generation process by the image generation unit 15 ends. Note that the container image generation process by the image generation unit 15 may be performed using a function such as Dockerfile.
[0088] Fig. 13 is a diagram showing an example of a process for generating a container image. Fig. 13A shows a state in which layer 1 (common library image) is formed on an OS base image and a common setting image. Fig. 13B shows a state in which multiple layer 2 (group library images) are formed on layer 1. Fig. 13C shows a state in which layer 3 (package image) is formed on layer 2.
[0089] [Deployment decision processing] Next, the deployment decision process by the deployment deciding unit 21 of the deployment / update management unit 20 will be described with reference to Fig. 14. Fig. 14 is a flowchart showing an example of the procedure of the deployment decision process by the deployment deciding unit 21.
[0090] First, the deployment determination unit 21 identifies a group (a layer 3 group) to which an object (such as a DLL file or a package) to be deployed to a node (not shown) belongs (step S41) based on the contents of the hierarchical configuration table 14. Since the name of the package is written in the item of the belonging package in the hierarchical configuration table 14 (see FIG. 6), the group to which the package belongs is identified from the package name.
[0091] Next, the deployment determining unit 21 deploys DLL files, packages, etc. that belong to (are associated with) the same function group in layer 2 to the same node (step S42). After the process of step S42, the deployment determination process by the deployment determining unit 21 ends.
[0092] For example, as shown in Figure 2, assume that three containers belonging to the layer 3 packages "Ga", "Gb", and "Gc" are deployed to one node 1. Also assume that one container each corresponding to "Ga", "Gb", and "Gc" are deployed to the node in that order. "Ga", "Gb", and "Gc" are packages that belong to the same image display function, and therefore belong to the same layer 2. In other words, they share the same layer 2 container image.
[0093] Therefore, for example, when generating a container image for the second "Gb" group, the deployment unit 22 (see FIG. 3) can reuse the container images for layers 1 and 2 that have already been generated when generating the container for the first "Ga" group. That is, when deploying a container for the "Gb" group, the deployment unit 22 only needs to download (obtain from the repository 151 (see FIG. 3)) and deploy only the container image for the package portion for layer 3, which is the difference from the container image for "Ga". That is, according to this embodiment, the amount of data to be downloaded by each container can be reduced, and the time required to generate a container image can also be saved.
[0094] [Update Management Process] Next, an update management process by the update management unit 23 of the deployment / update management unit 20 will be described with reference to Fig. 15. Fig. 15 is a flowchart showing an example of the procedure of the update management process by the update management unit 23 of the deployment / update management unit 20.
[0095] When a modification request is received from the development environment, the update management unit 23 first identifies the dependency relationship of the library (DLL file) to be modified based on the contents of the hierarchical configuration table 14 (step S51). Next, the update management unit 23 updates the container image of the library in the dependency relationship identified in step S51 (step S52). Specifically, the update management unit 23 modifies the relevant portion of the design file that is the source of the container image, and builds the container image from the design file.
[0096] Next, the update management unit 23 downloads the difference between the container image updated in step S52 and the current container image from the repository 151 (step S53). Next, the update management unit 23 restarts the updated container image (step S54). When restarting the container, if a start-up condition such as a start-up order is set, the update management unit 23 restarts the container when the condition is satisfied. After the process of step S54, the update management process by the update management unit 23 ends.
[0097] The virtualization environment construction system 1 according to the embodiment described above includes a hierarchical information generating unit 10 that assigns an element to one of a plurality of layers that constitute a virtualization environment based on information on the logical relationship and dependency between each element that constitutes an application (package) to be virtualized. Furthermore, the virtualization environment construction system 1 includes a deployment / update management unit 20 that generates a container as an independent space including a plurality of layers, deploys the container to a node in the real environment, and identifies and modifies the element deployed to the node based on information on the logical relationship and dependency between each element. Therefore, according to this embodiment, a virtualization environment in which the target of modification can be easily clarified is provided.
[0098] In the above-described embodiment, the deployment and update management unit 20 generates containers in application package units. Therefore, according to this embodiment, when a modification instruction is received from the development environment, the deployment and update management unit 20 can search for the portion to be modified by targeting the containers generated in package units, and can easily clarify the modification target.
[0099] Furthermore, in the above-described embodiment, the layering information generator 10 generates a layer configuration table 14 that describes information on the logical relationships and dependencies between the DLL files that make up the package, and information on the results of assigning the DLL files to layers, based on information on the modification history of the application's source code. The deployment and update manager 20 then deploys the container to a node and modifies the container, based on the information described in the layer configuration table 14. Therefore, according to this embodiment, the deployment and update manager 20 can easily identify the container to be modified and the DLL files in the container, based on the information described in the layer configuration table 14.
[0100] In the above-described embodiment, the container includes three layers, from the lowest layer 1 to the highest layer 3. The layer information generator 10 places elements (such as DLL files) related to settings shared by a plurality of packages in layer 1, and elements (such as DLL files) related to settings shared in units of functions possessed by the packages in layer 2. Furthermore, the layer information generator 10 places elements (such as DLL files) related to settings used by the packages in layer 3.
[0101] In the above-described embodiment, the layer information generator 10 places elements whose calling DLL file overlap exceeds a predetermined threshold in layer 1, and moves elements whose modification frequency exceeds a predetermined threshold among the DLL files placed in the layers from layer 1 to layer 2. As a result, DLL files whose referencing DLL files overlap a lot and whose modification frequency is low are placed in layer 1, and DLL files that are shared in package function units and whose modification frequency is relatively high are placed in layer 2.
[0102] Since a container image is composed of information on the difference with the lower layer, the higher the layer, the higher the dependency on the lower layer. Therefore, according to this embodiment, the more frequently a DLL file is expected to be modified, the higher the layer is placed, so that the scope of modification of a package that is expected to be modified frequently can be narrowed.
[0103] Furthermore, in the above-described embodiment, the deployment / update management unit 20 deploys, to one node, a plurality of containers that correspond to a section of layer 2 provided in units of package functional groups among the containers. As a result, for the second and subsequent containers deployed to the same node, it is only necessary to download information that is the difference from the information held by the first container already set, thereby reducing the amount of data stored in the container and the time required for container generation work.
[0104] Furthermore, in the above-described embodiment, by using a container-based virtualization technology as the virtualization technology, the application operating environment in each container can be made independent, thereby improving portability. Also, since each container can be regarded as an independent computer environment, it is possible to duplicate shared libraries included in the containers between the containers.
[0105] In the above-described embodiments, the computer environment construction system 1 constructs a virtualized environment using a container-based virtualization technology, but the present invention is not limited to this. Any virtualization technology other than the container-based virtualization technology may be used as long as it is capable of constructing an independent execution environment having a layer structure.
[0106] <Second embodiment> Next, a second embodiment of the present invention will be described with reference to Fig. 16 to Fig. 18. In the second embodiment, a computer environment construction system according to the present invention migrates existing software assets to a computer (bare machine) using software (solution) stack technology. Software stacking is a method of stacking mutually interoperable protocols and software to realize one system or function as a whole.
[0107] FIG. 16 is a diagram showing an example of the configuration of a configuration file image according to the second embodiment. The software stack does not have a hierarchy of an OS base image because it uses an OS that runs on a bare machine. The other hierarchical configurations are the same as those of the container image according to the first embodiment shown in FIG. 2. The configuration file image according to this embodiment is also generated by the image generation unit 15 (see FIG. 17) of the layering information generation unit 10 based on the hierarchical configuration table 14 (see FIG. 6) generated by the procedure shown in FIG. 8.
[0108] Fig. 17 is a block diagram showing an example of a functional configuration of a computer environment construction system 1A according to the second embodiment. The computer environment construction system 1A shown in Fig. 17 differs from the virtualization environment construction device 1 according to the first embodiment shown in Fig. 3 in that the image generation unit 15 of the layered information generation unit 10 generates a configuration file image of a software stack instead of a container image, and that the deployment destination by the deployment / update management unit 20 is an actual environment on a bare machine.
[0109] Fig. 18 is a diagram showing an example of a process for generating a configuration file image according to this embodiment. The difference between the process for generating a configuration file image shown in Fig. 18 and the process for generating a container image according to the first embodiment shown in Fig. 13 is that the configuration file image according to this embodiment does not include a hierarchy of an OS base image. In this embodiment, the area enclosed by the dashed frame in Fig. 18 is made up of files assigned to each layer.
[0110] According to the above-described second embodiment, that is, when the environment to which the existing software assets are migrated is a bare machine in a physical environment, it is possible to obtain the same effects as those obtained by the first embodiment.
[0111] In addition, the above-described embodiment describes the system configuration in detail and specifically in order to explain the present invention in an easy-to-understand manner, and is not necessarily limited to having all of the configurations described.
[0112] In addition, the control lines or information lines shown by solid lines or arrows in Figures 3 and 4 are those considered necessary for explanation, and do not necessarily show all control lines or information lines in the product. In reality, it can be considered that almost all components are connected to each other.
[0113] In addition, in this specification, the processing steps describing chronological processing include not only processing that is performed chronologically in the order described, but also processing that is not necessarily performed chronologically but is performed in parallel or individually (for example, parallel processing or processing by objects).
[0114] In addition, each component of the computer environment construction system according to each embodiment of the present disclosure may be implemented in any hardware as long as the hardware can transmit and receive information to each other via a network. In addition, the processing performed by a certain processing unit may be realized by a single piece of hardware, or may be realized by distributed processing by multiple pieces of hardware. [Explanation of symbols]
[0115] 1...Virtualization environment construction system, 1A...Computer environment construction system, 10...Hierarchical information generation unit, 12...Library list generation unit, 13...Classification unit, 14...Hierarchical configuration table, 15...Image generation unit, 20...Deployment / update management unit, 21...Deployment decision unit, 22...Deployment unit, 23...Update management unit, 121...Library list
Claims
1. a layering information generating unit that assigns elements constituting an application to be migrated to a new computer environment to one of a plurality of layers based on information on logical relationships and dependencies between the elements; A deployment management unit that generates an independent execution environment including a plurality of the layers and deploys the independent execution environment to a node in a real environment. Computer environment construction system.
2. The deployment management unit identifies and modifies the elements deployed on the nodes based on information about logical relationships and dependencies between the elements.
2. A computer environment construction system according to claim 1.
3. The deployment management unit generates the independent execution environment for each package of the application.
3. A computer environment construction system according to claim 2.
4. the layering information generating unit generates a layer configuration table containing information on logical relationships and dependencies between elements constituting the application and information on the results of allocation of the elements to the layers, based on information on a revision history of a source code of the application; The deployment management unit deploys the independent execution environment to the node based on the information in the hierarchical configuration table, and modifies the elements deployed in the independent execution environment.
4. A computer environment construction system according to claim 3.
5. the plurality of layers includes a first layer, a second layer disposed on the first layer, and a third layer disposed on the second layer; The hierarchical information generating unit arranges the elements related to settings shared by a plurality of the packages in the first layer, arranges the elements related to settings shared in units of functions possessed by the elements in the second layer, and arranges the elements related to settings used by the packages in the third layer.
5. A computer environment construction system according to claim 4.
6. The logical relationship is a relationship indicated by the functions possessed by the package, and the dependency is information indicated by the degree of overlap of the calling element when the element is called by another element, and the frequency of modification of the element.
6. A computer environment construction system according to claim 5.
7. The layering information generating unit arranges the elements whose overlapping degree of the calling element exceeds a predetermined threshold in the first layer, and moves the elements whose modification frequency exceeds a predetermined threshold among the elements arranged in the first layer from the first layer to the second layer.
7. A computer environment construction system according to claim 6.
8. The deployment management unit deploys, on one node, a plurality of the independent execution environments that correspond to a section of the second layer that is divided for each function that the element has, among the independent execution environments.
8. A computer environment construction system according to claim 7.
9. The elements include executable files and shared library files of the application; The elements are called by other elements through functions in the shared library file.
9. A computer environment construction system according to claim 8.
10. The independent execution environment is a virtual machine formed by virtualization technology.
2. A computer environment construction system according to claim 1.
11. The independent execution environment is a container virtualized by container-based virtualization technology.
2. A computer environment construction system according to claim 1.
12. a step of allocating each element of an application to be migrated to a new computing environment to one of a plurality of layers based on information of logical relationships and dependencies between the elements; and generating an independent execution environment including a plurality of the layers and deploying the independent execution environment to a node in a real environment. How to build a computer environment.
Citation Information
Patent Citations
VM / container and volume placement determination method and storage system in HCI environment
JP7118230B2
