Cause inference apparatus, and cause inference method

Abstract

To infer a cause of construction failure generated during construction of a system, without requiring a lot of man-hours.SOLUTION: A cause inference apparatus for inferring a cause of construction failure of a system for constructing infrastructure resources in a predetermined execution environment, is formed of a computer having an arithmetic device for executing predetermined arithmetic processing and a storage device connected to the arithmetic device. The arithmetic device includes: a cause table creating unit for, by using information on an execution environment estimated based on construction information of the system, creating a cause table in which an error during the construction is recorded in association with the infrastructure resources, restriction in construction of the infrastructure resources, and a cause of the error; and a cause inference unit for specifying the cause of the error generated during construction of the infrastructure resources.SELECTED DRAWING: Figure 1

Description

[Technical field]

[0001] The present invention relates to a cause inference device that infers the cause of a failure in system construction. [Background technology]

[0002] In recent years, the virtualization of IT (Information Technology) resources has progressed with the development of cloud computing technology. Due to such technological development, attention has been focused on automatic system construction technology that utilizes virtualization technologies such as virtual servers and containers, and IaC (Infrastructure as Code), which deploys systems based on source code and configuration files.

[0003] The following prior art is included as background art in this technical field. Patent Document 1 (JP 2021-157612 A) describes an information processing system including a conversion unit that converts a sheet describing system requirements and application requirements of a cloud service into computer-interpretable code, a storage control unit that stores the code in a storage unit, and a determination control unit that controls to deploy resources on a cloud based on the code, execute tests on the resources, and determine whether the resources can be used.

[0004] Furthermore, Patent Document 2 (JP Patent Publication No. 2003-150407) describes an automatic recovery system that includes a monitoring device and a recovery instruction device and recovers from a failure that has occurred in a monitored device. The monitoring device has a receiving means for receiving electronic information notifying the occurrence of a failure from the monitored device and a storage means for storing the received electronic information. The recovery instruction device has an analyzing means for analyzing the cause of the failure that has occurred in the monitored device by referring to the storage means of the monitoring device, a generating means for generating electronic information for recovering from the failure based on the analysis result by the analyzing means, and a transmitting means for transmitting the electronic information generated by the generating means to the monitored device. [Prior art documents] [Patent documents]

[0005] [Patent Document 1] JP 2021-157612 A [Patent Document 2] JP 2003-150407 A Summary of the Invention [Problem to be solved by the invention]

[0006] According to the technology described in Patent Document 1, an order sheet containing system requirements is converted into source code and resource deployment is automated. By using the technology described in Patent Document 1, a system can be automatically constructed in accordance with the system requirements even if the user does not have coding knowledge. However, if the environment assumed by the developer differs from the environment the user is attempting to construct, the construction of the system may fail. In this case, it is necessary to clarify the cause of the failure and modify the source code or the environment to be constructed.

[0007] Regarding this issue, Patent Document 2 describes a technique for acquiring information about an error, identifying the cause of the error by referring to a cause table, determining a countermeasure by referring to a countermeasure table, and executing a correction program, etc., based on the countermeasure. This makes it possible to infer the cause from the cause table by inputting an error statement, etc., that occurs when construction of a system fails.

[0008] The technology of Patent Document 2 has a problem in that it requires man-hours to create a cause table. In addition, it is difficult to infer the cause with high accuracy for errors that occur due to differences in environments.

[0009] The present invention has been made in consideration of the above-mentioned problems, and has an object to enable a user to infer the cause of a construction failure that occurs when building a system and respond to the failure without incurring additional man-hours. [Means for solving the problem]

[0010] A representative example of the invention disclosed in the present application is as follows: That is, a cause inference device for inferring a cause of failure in construction of a system that constructs infrastructure resources in a specified execution environment is configured by a computer having a calculation device that executes specified arithmetic processing and a storage device connected to the calculation device, characterized in that the calculation device comprises a cause table creation unit that uses construction information of the system and information of the execution environment assumed by the construction information of the system to create a cause table that records errors during the construction in association with the infrastructure resources, constraints in the construction of the infrastructure resources, and the causes of the errors, and a cause inference unit that refers to the cause table and identifies the cause of an error that occurs during the construction of the infrastructure resources. Effect of the Invention

[0011] According to one aspect of the present invention, the cause of a system construction failure that occurs can be grasped and dealt with promptly. Problems, configurations, and effects other than those described above will become apparent from the following description of the embodiment of the present invention. [Brief description of the drawings]

[0012] [Figure 1] FIG. 1 is a diagram illustrating an example of a configuration of a cause inference device according to a first embodiment. [Diagram 2] 1 is a diagram illustrating an example of a hardware configuration of a cause inference device according to a first embodiment. [Diagram 3] 6 is a flowchart showing an example of the operation of a cause table creating unit according to the first embodiment. [Figure 4] FIG. 4 is a diagram showing an example of a constraint list according to the first embodiment. [Diagram 5] FIG. 4 is a diagram showing an example of a source code relating to a deployment process of an execution environment according to the first embodiment. [Figure 6] FIG. 4 is a diagram showing an example of a cause table according to the first embodiment. [Figure 7] 5 is a flowchart showing an example of the operation of a cause inference unit according to the first embodiment. [Figure 8] FIG. 13 is a diagram showing an example of a GUI presented in step S201. [Figure 9] FIG. 13 is a diagram showing an example of a GUI presented in step S205. [Figure 10] 10 is a flowchart showing an example of the operation of a cause inference unit according to the second embodiment. [Figure 11] FIG. 13 is a diagram showing an example of a GUI presented in step S301. DETAILED DESCRIPTION OF THE PREFERRED EMBODIMENTS

[0013] <Embodiment 1> 1 is a diagram showing an example of the configuration of a cause inference device 100 according to the first embodiment of the present invention. The cause inference device 100 is configured by a computer having a constraint list 110, a repository 120, a cause table creation unit 130, a cause table 140, and a cause inference unit 150.

[0014] The cause inference device 100 registers in advance source codes of a deployment template 121 and a module 122 in a repository 120. The repository 120 may be a known repository provided by, for example, a cloud service or OSS. An example of the source code will be described later with reference to FIG. 5.

[0015] Although FIG. 1 shows an example in which a plurality of templates 121 and modules 122 are managed in one repository 120, the repository 120 may be divided for each source code corresponding to a project.

[0016] Here, the source code is utilized to construct a specific system 161 or an execution environment 160 including a network required by the system 161. For example, one system 161 does not have a configuration corresponding to one template 121, and a module 122 which is a set of functions constituting a part of the system 161 is also included in the source code. In this case, a plurality of modules 122 are combined to create a system source code for one system 161. Note that, although details will be described later, the management information is composed of various information for management and display by the cause inference device 100, and entities or references of the templates 121 and modules 122 which are source codes for constructing the system 161.

[0017] When a user 101 of the cause inference device 100 deploys a template 121 or a module 122 of the repository 120, the cause table creation unit 130 uses the constraint list 110 and the like to associate the system 161 that is the target of deployment with an error that may occur at the time of construction failure and the cause of the construction failure, thereby creating a cause table 140. For example, the execution environment 160 to which the constraints defined in the constraint list 110 are assigned is created, the template 121 or the module 122 of the repository 120 is deployed, and it is confirmed whether an error occurs. If an error occurs, it is determined that the construction of the template 121 or the module 122 of the repository 120 has failed due to the constraint, and the information is added to the cause table 140. A specific example of the process will be described later with reference to FIG. 4.

[0018] The user 101 inputs to the cause inference unit 150 error information that occurs when construction actually fails and information about the system to be constructed.

[0019] Thereafter, the cause inference unit 150 searches the cause table 140 based on the input information to display and correct the cause of the construction failure. A specific example of the process will be described later with reference to FIG.

[0020] The execution environment 160 is an environment for operating the system 161. The execution environment 160 is, for example, a cluster of IT resources managed by an orchestration tool provided by a public cloud service or a private cloud service. It also includes network IT resources required for operating the system 161, creation authority required for deploying the system 161, and certificates of devices associated with the system 161. The execution environment 160 for operating the system 161 selected by the user 101 may be in a format specified by the user 101. In this case, the execution environment 160 may be a different execution environment for each user 101, or one execution environment may be shared.

[0021] In the following figures and explanations, the execution environment 160 is an IaaS (Infrastructure as a Service) public cloud of a public cloud service, the deployment process is Terraform, and the template 121 and the module 131 are source codes written in HCL (HashiCorp Configuration Language) defined by Terraform. However, this embodiment is not limited to the above configuration. For example, a combination of Kubernetes as the execution environment 160, a container as a target to be built in the execution environment 160, and Helm as the deployment process may be adopted.

[0022] FIG. 2 is a diagram illustrating an example of a hardware configuration of the cause inference device 100 according to the first embodiment.

[0023] As shown in FIG. 2, the cause inference device 100 has hardware such as a calculation unit 210, a storage unit 220, an input / output unit (Interface) 230, and a communication unit 240.

[0024] The calculation unit 210 has a cause table creation unit 130, a cause inference unit 150, and a display unit 213. The calculation unit 210 and each of the functional units included in the calculation unit 210 can be configured by hardware such as a circuit device that implements these functions, or can be configured by a calculation device such as a CPU (Central Processing Unit) executing software that implements these functions.

[0025] The storage unit 220 is configured by a storage device that stores data used by the arithmetic unit 210, and includes a ROM, which is a non-volatile storage element, and a RAM, which is a volatile storage element. The ROM stores immutable programs (e.g., BIOS) and the like. The RAM is a high-speed, volatile storage element such as a DRAM (Dynamic Random Access Memory), and temporarily stores programs executed by the processor 1 and data used when the programs are executed. The storage unit 220 also includes a large-capacity, non-volatile auxiliary storage device, such as a magnetic storage device (HDD) or a flash memory (SSD).

[0026] The input / output unit 230 is an interface that receives input from an operator and outputs the processing results by the calculation unit 210 in a format that can be viewed by the user, and is composed of input devices such as a keyboard and a mouse, and output devices such as a display device and a printer. Note that a user terminal connected to the cause inference device 100 via a network may provide the input device and the output device. In this case, the cause inference device 100 may have a web server function, and the user terminal may access the cause inference device 100 using a predetermined protocol (e.g., http).

[0027] The communication unit 240 is a network interface device that controls communication with other devices in accordance with a predetermined protocol, and is, for example, a communication chip or a NIC (Network Interface Card), and controls communication with the runtime environment 160 and communication with the user 101.

[0028] When each unit of the cause inference device 100 receives data, the data may be received via the input / output unit 230 or the communication unit 240 .

[0029] The programs executed by the calculation unit 210 are provided to the cause inference device 100 from removable media (such as a CD-ROM or a flash memory) or via a network, and are stored in a non-volatile auxiliary storage device of the storage unit 220, which is a non-transitory storage medium. For this reason, it is preferable that the cause inference device 100 has an interface for reading data from removable media.

[0030] The cause inference device 100 is a computer system configured on one physical computer, or on multiple logically or physically configured computers, and may run on a virtual computer constructed on multiple physical computer resources. For example, multiple programs that realize the functions of the cause inference device 100 may each run on a separate physical or logical computer, or multiple programs may be combined to run on a single physical or logical computer.

[0031] 3 is a flowchart showing an example of the operation of the cause table creating unit 130 according to embodiment 1. Each step in FIG. 3 will be described below.

[0032] (Figure 3: Step S101) The cause table creating unit 130 creates the constraint list 110. The constraint list 110 is obtained by extracting, as constraints, differences between the execution environment 160 that is assumed by the templates 121 and modules 122 in the repository 120 and the execution environment 160 that the user 101 attempts to build.

[0033] 4 is a diagram showing an example of the constraint list 110. The constraint list 110 includes a major category indicating the type of constraint and details indicating the details of the constraint. For example, the major categories include a "network" for constructing the template 121 and the module 122 of the repository 120, "authority" for constructing them, and a "device" to which the system 161 is related. The details are specific setting values ​​required for constructing the execution environment 160 described later.

[0034] For example, "Network Subnet Address_prefixes = ["10.0.0.0 / 26"]" in description 111 means that Subnet is deployed as a resource and the setting value Address_prefixes is deployed as ["10.0.0.0 / 26"]. Also, "Authority User role {Action:CreateNetwork,Effect:Deny}" in description 112 means the authority set when constructing a template 121 or a module 122 in repository 120. And, "Device Device role {Action:Publish,Effect:Deny}" in description 203 means the authority as to whether a device connected to system 161 to be constructed is permitted to operate on system 161.

[0035] A method of creating the constraint list 110 will be illustrated. First, the cause table creation unit 130 acquires information on the execution environment 160 in which the user 101 will build the system 161. For example, the network IT resources required for operating the system 161 in the execution environment 160 specified by the user 101 may be acquired as source code using a function for exporting the network IT resources as source code of each cloud vendor. In addition, for the creation account information specified by the user 101, creation authority required for deploying the system 161 may be acquired using a function for acquiring authority of each cloud vendor.

[0036] If information on the execution environment 160 to be constructed cannot be obtained, information on the execution environment 160, such as a publicly available general reference architecture, may be used. For example, in Azure, system examples suitable for various purposes are published at the Azure Architecture Center, and information including network information that ensures security can be obtained as source code to construct the execution environment 160. Information on the execution environment 160 used in the past may also be used.

[0037] After acquiring the information, the cause table creation unit 130 acquires the difference by comparing the information of the execution environment 160 to be constructed acquired in step S201 with the execution environment 160 assumed by the template 121 and the module 122 of the repository 120. For example, the IT resources related to the network of the assumed execution environment 160 are acquired as source code using a function for exporting as source code of each cloud vendor, and the source code is used to extract parts related to the same network resource from the source code of the IT resources related to the network of the execution environment 160 to be constructed acquired in step S201, and each parameter is compared to see if they are the same. As a result of the comparison, the parameters that are not the same are associated with the resource and saved as a difference. In addition, as for the account information for the assumption of creation, the creation authority is acquired for the account information used when creating the template 121 and the module 122 of the repository 120 using a function for acquiring the authority of each cloud vendor, and a comparison is made to see if the authority is included in the creation authority of the execution environment 160 to be constructed acquired in step S201. As a result of the comparison, if the authority is not included, the creation authority is saved as a difference.

[0038] Then, the cause table creation unit 130 adds the difference saved in step S202 to the constraint list 110. For example, for a difference related to a network, the major category of constraints is set to network, the detailed resource to the target network resource, and the setting value to the parameter of the target execution environment 160 where there is a difference. Also, for a difference related to authority, the major category of constraints is set to authority, the detailed resource to the target authority name, and the setting value to the content of the authority.

[0039] Although the procedure for automatically creating the constraint list 110 has been explained so far, the constraint list 110 is used to simulate the execution environment 160 constructed by the user 101. Therefore, the constraint list 110 may be input by the user 101, or may be input from information on the execution environment 160 constructed in the past.

[0040] (FIG. 3: Step S102) The cause table creation unit 130 selects a constraint from the constraint list 110 and creates the execution environment 160. For example, a constraint on a network causes infrastructure resources 162 related to the network to be deployed on the execution environment 160 using a deployment tool based on detailed setting values ​​and source code for deploying detailed resource information. Also, a constraint on authority causes an account with the appropriate authority to be created as an account required for deploying the infrastructure resources 162 on the execution environment 160, and the infrastructure resources 162 are deployed on the execution environment 160 after the account is specified.

[0041] Fig. 5 is a diagram showing an example of source code related to the deployment process of the execution environment 160. The source code and the deployment process will be explained with reference to Fig. 5. Here, the case where Terraform is used as the deployment process will be explained. Terraform is an open source infrastructure automatic construction tool developed by HashiCorp.

[0042] The template information generally includes source code such as main.tf 300 that defines what infrastructure resources 162 are to be deployed, a variables file in a format such as variables.tf 310 that defines the variables to be given to each infrastructure resource 162 and default values ​​for those variables, and a variable input file in a format such as auto.input.tfvars 320 that defines the setting values ​​for the variables to be given to each infrastructure resource 162.

[0043] For example, statement 301 (resource "aws_s3_bucket" "s3_bucket") means to deploy aws_s3_bucket as a resource. Also, statement 302 (bucket = "${var.foo}") means to read statement 311 (variable "foo" {}) defined in variables.tf310.

[0044] If no value is specified for the variable with the variable key "foo" during the deployment process, the default value "foo:1" is used. Note that if a different value, for example, the value "foo = "dev-var"" is specified for the variable with the variable key "foo" during the deployment process, the description 311 is generated as "foo:"dev-var"".

[0045] Additionally, template files may contain programmatic elements, e.g. if statements. Terraform defines the programmatic elements that can be used to control how many resources are built with the count variable. Specifying the value "S3_count = 1" in auto.input.tfvars320 will create one "resource "aws_s3_bucket" "s3_bucket"".

[0046] As described above, a deployment tool may be used to deploy network resources on the execution environment 160 based on the source code. This process may be created by improving an existing tool such as Terraform.

[0047] Note that multiple constraints may be selected from the constraint list 110. In that case, it is preferable to assign constraints on authority first, and then assign constraints on the network, because authority is involved when deploying an execution environment 160 to which a constraint on the network has been assigned.

[0048] (FIG. 3: Step S103) In step S103, the cause table creation unit 130 deploys the template 121 and the module 122 of the repository 120 to the created execution environment 160. Then, a test that has been previously performed on the template 121 and the module 122 of the repository 120 may be executed. In this case, since the test is performed on the template 121 and the module 122 of the same repository 120, it is presumed that the difference in the execution environment 160 is the main cause of the failure of the confirmed test.

[0049] (FIG. 3: Step S104) It is checked whether an error occurs in the test in step S103. For example, due to authority restrictions, the deployment of the template 121 or module 122 in the repository 120 that had been successful may fail, resulting in an error. This is because the expected authority was not sufficient to create the template 121 or module 122. Also, after the deployment of the template 121 or module 122 in the repository 120, a communication test that had previously been successful may fail. This is because the expected network operation is prohibited due to network restrictions in the execution environment 160.

[0050] (FIG. 3: Step S105) If an error is confirmed in step S104, the cause table creating unit 130 extracts the details of the error, such as the error statement when the error occurred and the test execution result.

[0051] (FIG. 3: Step S106) The cause table creation unit 130 stores the error detected in step S105 in the cause table 140 by associating the error information, construction target information such as the template 121 and module 122 to be constructed, and constraints. Then, as described in step S103, the cause of failure of a deployment or test that was successful in advance in the execution environment 160 is mainly considered to be due to differences resulting from the imposition of constraints from the expected execution environment 160, so the constraint information is stored in the cause table 140 as the cause.

[0052] 6 is a diagram showing an example of the cause table 140. The cause table 140 created in step S106 will be described with reference to FIG.

[0053] The cause table 140 has a construction target 401, a constraint 402, an error 403, and a cause 404. The construction target 401 is construction target information such as the template 121 and the module 122 to be constructed, and includes, for example, the name of the construction target and the path of the template 121 and the module 122 to be constructed. The constraint 402 is a difference between the execution environment 160 and other execution environments 160, and includes, for example, the setting value of the infrastructure resource 162 related to the network and the path of the template 121 and the module 122. It may also include authority information representing authority. The error 403 is information on the error, and includes, for example, text information such as character information notifying the occurrence of the error, an outline of the error content, and the location 723 of the error. The cause 404 is the cause of the error for the error content that occurred, and since, for example, the difference in the execution environment 160 due to the constraint 402 is considered to be the cause of the error, the constraint 402 and the cause 404 usually have the same data.

[0054] The cause table 140 does not need to include all of the information described above, and each item may store information in a different format.

[0055] As explained above, the cause table creation unit 130 recreates the execution environment 160 to be deployed by the user 101 using the constraints selected from the constraint list 110, attempts to deploy templates 121 and modules 122 of the repository 120 that have been confirmed to work on the recreated execution environment 160, and when an error occurs, adds the cause table 140 with the difference in the execution environment 160, i.e., the constraint, as the cause. However, the method of identifying the error is not necessarily limited to this method.

[0056] For example, the error may be identified by statically analyzing the source code of the template 121 or the module 122 in the repository 120. For example, for a restriction on authority, by statically analyzing the source code of the template 121 or the module 122 in the repository 120, it is possible to confirm whether the resource related to the authority is included. For example, for the description 202 ("Authority User role {Action:CreateNetwork,Effect:Deny}"), a network resource related to CreateNetwork cannot be deployed. Therefore, the lexical content of the source code is analyzed based on the grammar of the programming language, converted into a token string, and the converted token string is converted into a tree structure to obtain a tree structure as a result of the conversion, and the resource name is confirmed based on the tree structure to determine whether the resource name related to the network is included. Since it is assumed that the network-related resource cannot be deployed, it is assumed that the resource related to the network identified due to this restriction will cause a deployment error, so it may be added to the cause table 140. In this case, since no simulation is performed, the cause table 140 can be created quickly. On the other hand, the method of reproducing the execution environment 160 described here has the advantage of widening the scope of the confirmation since the infrastructure resource 162 can be tested. These methods may be carried out either alone or in combination.

[0057] In addition, although the execution environment 160 with new constraints is reproduced this time, the method of reproducing the execution environment 160 is not necessarily limited to this method. For example, if the execution environment 160 deployed by the user 101 can be used by the cause inference device 100, it is not necessary to create a new execution environment 160. In this case, the template 121 and the module 122 of the repository 120 are attempted to be deployed to the execution environment 160 specified by the user 101, and when an error occurs, the difference in the execution environment 160, that is, the constraint, is taken as the cause and the cause is added to the cause table 140. In this case, it is assumed that there are multiple constraints, and the multiple constraints are added to the cause table 140 as causes. In addition, the constraints of the execution environment 160 deployed by the user 101 may be changed. For example, by performing a process to remove the constraints of the execution environment 160 and then attempting to deploy the template 121 and the module 122 of the repository 120, the aforementioned constraints are reduced, making it easier to identify the cause. In this case, the time required to reproduce the new execution environment 160 can be shortened, so that the cause table 140 can be created in a short time. On the other hand, in the method of reproducing execution environment 160 described here, by reproducing a new execution environment 160, strong authority to directly use execution environment 160 is not required, and a robust security state can be maintained. Furthermore, even if execution environment 160 is already being used by another system 161, cause table 140 can be created without affecting the other system 161.

[0058] Fig. 7 is a flowchart showing an example of the operation of the cause inference unit 150 according to embodiment 1. Each step in Fig. 7 will be described below.

[0059] (Figure 7: Step S201) The cause inference unit 150 receives construction information and execution environment information from the user 101. The construction information is information on the system 161 and infrastructure resources 162 that the user 101 constructs. The execution environment information is information on the external environment, such as the network on which the system 161 and infrastructure resources 162 are constructed, the authority to construct them, and related devices. For example, since each cloud vendor provides metadata as standard indicating that the infrastructure resources 162 have the same purpose, it is possible to use this to extract infrastructure resources 162 to which metadata indicating that they are the execution environment 160 has been added. Therefore, metadata may be received as external environment information.

[0060] Fig. 8 is a diagram showing an example of a GUI presented in step S201. The display unit 213 displays a cause inference GUI 400 shown in Fig. 8. The user 101 inputs construction information and execution environment information on the cause inference GUI 400.

[0061] In the example shown in FIG. 8, options of a data analysis service, a data acquisition service, and a data visualization service are displayed as the construction target under an item called construction target 501. These data analysis services, data acquisition services, and data visualization services correspond to infrastructure resources 162 deployed by templates 121 and modules 122 in repository 120. When user 101 changes the construction target, the inference result of cause table 140 described below changes. For example, when data analysis service is selected, a cause related to the data analysis service is inferred from cause table 140. The options are just an example, and other options may be used. Also, it is possible to request input of source code to be used for deployment without displaying options.

[0062] 8, metadata indicating that it is an execution environment is input as the execution environment information in the item of execution environment metadata 502. When the user 101 changes the execution environment metadata 502, the inference result of the cause table 140 described later changes. For example, based on the input metadata, constraint information related to the network is extracted in step S202 described later. That is, based on the input metadata, infrastructure resources 162 related to the network are extracted. The input method is one example, and individual input of infrastructure resources 162 related to the network may be requested.

[0063] 8, information on the account to which the infrastructure resource 162 is deployed is input as execution environment information in the constructor 503 field. When the user 101 changes the constructor 503, the inference result of the cause table 140, which will be described later, changes. For example, based on the input constructor 503, constraint information on authority is extracted in step S202, which will be described later. Constraints on authority are extracted based on the input constructor 503. The input method is one example, and the user may be allowed to select from among account candidates.

[0064] 8, a device related to the infrastructure resource 162 is input in the device 504 field as execution environment information. When the user 101 changes the device 504, the inference result in the cause table 140, which will be described later, changes. For example, based on the input device 504, information on the certificate assigned to the device is obtained, and constraint information related to the device is extracted in step S202, which will be described later. The input method is one example, and the device may be selected from among candidate devices.

[0065] The information displayed in FIG. 8 is an example, and other information may be used.

[0066] (FIG. 7: Step S202) The cause inference unit 150 extracts constraints from the information of the execution environment 160 that the user 101 is trying to build from the construction information received in step S201. For example, as described in step S102, the function of exporting as source code of each cloud vendor is used to obtain IT resources related to the network of the execution environment 160 to be built as source code, and the source code is used to extract parts related to the same network resource from the source code of the IT resources related to the network of the execution environment 160 to be built obtained in step S201, and each parameter is compared to see if they are the same. As a result of the comparison, different parameters are associated with the resource and extracted as constraints. In addition, for the account information for the premised creation, the function of obtaining the creation authority of each cloud vendor is used to obtain account information used when creating the template 121 or module 122 of the repository 120, and a comparison is made to see if the authority is included in the creation authority of the execution environment 160 to be built obtained in step S201. As a result of the comparison, if the authority is not included, the creation authority is extracted as a constraint.

[0067] (FIG. 7: Step S203) The cause inference unit 150 infers the cause using the cause table 140. For example, the construction target is searched for in the cause table 140 using the information of the construction target acquired in step S201 as a key. When multiple rows are searched for, the constraint in the cause table 140 is searched for using the constraint acquired in step S202 as a key. The searched constraint is an error that may occur in the cause table 140 included in the identified row. In this case, since the constraint is the cause of the error, the error that may occur and the constraint that is the cause are paired and a value is returned. This process is one example, and for example, when there are multiple construction targets, the above-mentioned process may be performed for each of them as a unit of infrastructure resource, or all of the identified multiple errors may be returned.

[0068] (FIG. 7: Step S204) The cause inference unit 150 judges whether or not a cause has been inferred from the result of step S204. If a cause has been inferred, the process proceeds to step S205, and if a cause has not been inferred, the process ends.

[0069] (FIG. 7: Step S205) When the cause is inferred in step S204, the cause inference unit 150 presents the identified error and its cause to the user 101. This makes it possible to grasp and correct errors that occur due to differences in environments.

[0070] FIG. 9 is a diagram showing an example of a GUI presented in step S205. The display unit 213 displays the cause inference GU600 shown in FIG. 9. The user 101 displays the error and the cause identified on the cause inference GU600. In FIG. 9, information on the error identified in step S203 is displayed in an error 601, and the cause of the error identified in step S203 is displayed in a cause 602. Since it is considered that the error is caused by a constraint, when the correction start button 603 is operated, the execution environment 160 of the user 101 is corrected so as to eliminate the constraint. Note that this requires the user 101 to have authority to change the execution environment 160, so this is executed if the user 101 allows it. In other cases, the user 101 tries to understand the constraint that is the cause and correct it. This is because, in the execution environment 160 with strong security, the user 101 does not have authority to change the execution environment 160, and the user 101 may not be able to solve the problem by himself, such as by inquiring to another administrator.

[0071] Although the cause table creating unit 130 has been described as automatically adding the cause table 140, the cause table 140 does not necessarily have to be added automatically, and the cause table 140 may be created by the user from past cases.

[0072] <Embodiment 1: Summary> The cause inference device 100 according to the first embodiment uses information on the environment to be constructed to clarify constraints that will cause construction failure, creates a cause table 140 by associating the system, constraints, and construction failure errors, and in the event of a construction failure, can infer the cause of the construction failure from the cause table 140, or grasp the cause of a construction failure that may occur before construction. Therefore, when the user 101 constructs a new infrastructure resource 162, the cause inference device 100 can quickly grasp and correct errors, thereby reducing the number of man-hours required for correction. Also, since there is no need to create the cause table 140, the number of man-hours required for response can be reduced.

[0073] <Embodiment 2> Next, a second embodiment of the present invention will be described. In the second embodiment, if the user 101 fails to build, the cause of the error is identified and corrected. As a result, even when the user 101 responds to an error, the cause of the error can be quickly identified and corrected by referring to the cause table 140. Note that in the second embodiment, differences from the first embodiment will be mainly described, and descriptions of the same configuration and processing as the first embodiment will be omitted.

[0074] Fig. 10 is a flowchart showing an example of the operation of the cause inference unit 150 according to embodiment 2. Each step in Fig. 10 will be described below.

[0075] (FIG. 10: Step S301) The cause inference unit 150 receives construction information, error information, and execution environment information from the user 101. The construction information and execution environment information are the same as those in the first embodiment. The error information is information relating to an error displayed when the user 101 fails in construction. For example, it is an error statement indicating the content of the error displayed when construction fails and its error code.

[0076] Fig. 11 is a diagram showing an example of a GUI presented in step S301. The display unit 213 displays a cause inference GUI 700 shown in Fig. 11. The user 101 inputs construction information, error information, and execution environment information on the cause inference GUI 700.

[0077] 11 shows an example in which an error statement displayed when construction fails is input as the error information in an item called error information 701. When the user 101 changes the error statement, the inference result in the cause table 140, which will be described later, changes. For example, when an error statement is input, the cause of the target error is inferred from the cause table 140. The input method is one example, and the user may be allowed to select from among candidates for the error statement.

[0078] The information displayed in FIG. 8 is an example, and other information may be used.

[0079] (FIG. 7: Step S302) Step S302 is the same as step S202. If no external environment information is input in step S301, step S302 may be skipped.

[0080] (FIG. 7: Step S303) The cause inference unit 150 infers the cause using the cause table 140. For example, the cause table 140 is searched for construction targets using the error information and construction information acquired in step S301 as keys. When multiple rows are searched for, the constraints in the cause table 140 are searched for using the constraints acquired in step S302 as keys. The searched constraints are errors that may cause errors in the cause table 140 included in the identified row. In this case, since the constraint is the cause of the error, the constraint that is the cause is returned as a value. This process is one example, and when there are multiple errors or construction targets, for example, the above-mentioned process may be performed for each of them as an infrastructure resource unit, or all of the identified multiple causes may be returned.

[0081] (FIG. 7: Steps S304 to S305) Steps S304 to S305 are the same as steps S204 to S205. In step S304, it is determined whether the value of the cause, which is the result of S303, has been returned.

[0082] <Embodiment 2: Summary> In the second embodiment of the present invention, the user 101 can identify the cause of an error and make corrections when construction fails. This allows the user 101 to quickly identify and correct the cause of the error by referring to the cause table 140 when dealing with an error.

[0083] <Modifications of the present invention> The present invention is not limited to the above-described embodiments, and includes various modified examples and equivalent configurations within the spirit of the appended claims. For example, the above-described embodiments have been described in detail to clearly explain the present invention, and the present invention is not necessarily limited to those including all of the configurations described. Furthermore, a part of the configuration of one embodiment may be replaced with the configuration of another embodiment. Furthermore, the configuration of another embodiment may be added to the configuration of one embodiment. Furthermore, a part of the configuration of each embodiment may be added, deleted, or replaced with another configuration.

[0084] Furthermore, each of the aforementioned configurations, functions, processing units, processing means, etc. may be realized in hardware, for example by designing some or all of them as an integrated circuit, or may be realized in software by a processor interpreting and executing a program that realizes each function.

[0085] Information such as programs, tables, and files that realize each function can be stored in a storage device such as a memory, a hard disk, or an SSD (Solid State Drive), or in a recording medium such as an IC card, an SD card, or a DVD.

[0086] In addition, the control lines and information lines shown are those considered necessary for the explanation, and do not necessarily show all the control lines and information lines necessary for implementation. In reality, it can be considered that almost all components are connected to each other. [Explanation of symbols]

[0087] 100:Causal inference device 110: Constraint list 120: Registry 130: Cause table creation section 140:Cause table 150:Causal reasoning part 160: Execution environment

Claims

1. A cause inference device that infers a cause of failure in construction of a system that constructs infrastructure resources in a predetermined execution environment, comprising: The computer includes a computing device that executes a predetermined calculation process and a storage device that is connected to the computing device, a cause table creation unit configured to create a cause table in which errors during the construction are recorded in association with the infrastructure resources, constraints in the construction of the infrastructure resources, and causes of the errors, using construction information of the system and information on an execution environment assumed by the construction information of the system; A cause inference device, characterized in that the calculation device comprises a cause inference unit that refers to the cause table and identifies a cause of an error that occurs when constructing the infrastructure resource.

2. The cause inference device according to claim 1, The cause inference device is characterized in that the cause table creation unit creates a constraint list based on a result of comparing information on a predetermined execution environment with information on the execution environment assumed by the system construction information.

3. The cause inference device according to claim 2, The cause table creation unit creates the cause table by applying constraints in the constraint list to source code that constructs the infrastructure resource, and performing a simulation to construct the execution environment.

4. The cause inference device according to claim 1, The cause table creation unit creating a constraint list based on a result of comparing information on a predetermined execution environment with information on the execution environment assumed by the construction information of the system; A cause inference device characterized by statically analyzing source code that constructs the infrastructure resource and creating the cause table including locations where errors identified by the analysis occur.

5. The cause inference device according to claim 1, The cause table creation unit A cause inference device characterized by identifying locations where errors occur during construction by simulating construction using source code that constructs the infrastructure resource in a specified execution environment, and creating the cause table from the error statement that has occurred and information about the execution environment.

6. The cause inference device according to claim 1, The cause inference unit is Accepts information about the infrastructure resources to be built and the execution environment to be built, Identifying constraints by comparing the received information with source code that can be constructed based on the information on the execution environment and source code that constructs an execution environment without constraints; A cause inference device characterized by searching for records similar to the identified constraint from the infrastructure resource information stored in the cause table and identifying the cause of an error that may occur when creating the infrastructure resource.

7. The cause inference device according to claim 1, The cause inference unit is When construction fails, the system accepts the error details, the infrastructure resource information of the construction target, and the execution environment information of the construction target. Identifying constraints by comparing the received information with source code that can be constructed based on the information on the execution environment and source code that constructs an execution environment without constraints; A cause inference device characterized by searching for records similar to the identified constraint from the infrastructure resource information stored in the cause table and identifying the cause of an error that may occur when creating the infrastructure resource.

8. A cause inference method for inferring a cause of failure in construction of a system that constructs infrastructure resources in a predetermined execution environment, comprising: The computer includes an arithmetic unit that executes a predetermined arithmetic process and a storage device that is connected to the arithmetic unit; The cause inference method includes: a cause table creation step in which the computing device creates a cause table that records errors during the construction in association with the infrastructure resources, constraints in the construction of the infrastructure resources, and causes of the errors, using construction information of the system and information on an execution environment assumed by the construction information of the system; and a cause inference procedure in which the computing device refers to the cause table to identify a cause of an error that occurs when constructing the infrastructure resource.

Images