Method and system for generating declarative deployment packet parameter dynamic form protocol
Through the declarative definition of the CUE language and dynamic form generation, combined with strict parameter verification, the problems of low software deployment efficiency, error prone and insufficient flexibility are solved, and efficient and reliable software deployment is achieved.
Patent Information
- Application Number
- CN202411633964.X
- Authority / Receiving Office
- CN · China
- Patent Type
- Applications(China)
- Current Assignee / Owner
- Filing Date
- 2024-11-15
- Publication Date
- 2025-03-04
AI Technical Summary
Existing software deployment methods are inefficient, error-prone and inadequate in flexibility, especially when parameters are numerous and complex.
By declaratively defining deployment package parameters using CUE language, dynamic forms are automatically generated, and combined with strict parameter verification mechanisms, the generation and verification of dynamic forms are achieved.
Improves the efficiency, flexibility and reliability of software deployment, reduces the tedious process and error risks of manual configuration parameters, and ensures that the software is properly deployed in different environments.
Smart Images
Figure CN119556943A_ABST
Abstract
Description
Technical Field
[0001] The present invention relates to the field of software deployment, and in particular to a method and system for generating a declarative deployment package parameter dynamic form protocol. Background Art
[0002] Software deployment generally uses two methods: manual configuration files and automated deployment tools. The specific methods are:
[0003] (1) Traditional manual configuration file modification method;
[0004] This method is a common method in the field of software deployment.
[0005] Technical measures and composition: Developers or operation and maintenance personnel directly edit the text configuration file, which contains the names of various parameters and their corresponding values, arranged in a specific format. Each parameter has a specific position and syntax requirements in the configuration file.
[0006] Interrelationship: Developers need to accurately understand the format and parameter requirements of the configuration file and manually modify the parameter values. Once a parameter is set incorrectly, the entire software deployment may fail. This method is inefficient and prone to errors, especially when there are many and complex parameters.
[0007] The defects of the traditional method of manually modifying configuration files for software deployment:
[0008] 1.1. Inefficiency: Developers or operation and maintenance personnel need to manually search and edit the parameters in the configuration file one by one. When there are a large number of parameters, this process is very time-consuming.
[0009] 1.2. Error-prone: Since it relies entirely on manual operation, it is prone to input errors, format errors, etc. Moreover, for complex parameter configurations, developers need to accurately remember the format and requirements of each parameter, which increases the risk of errors.
[0010] 1.3. Lack of flexibility: Once the software deployment environment changes, the configuration file needs to be manually modified again, which cannot quickly adapt to different deployment requirements.
[0011] (2) Some existing automated deployment tools;
[0012] There are many automated deployment tools on the market.
[0013] Technical measures and composition: These tools usually provide a graphical interface or command line interface, through which users can enter deployment parameters. The tool will apply these parameters to the deployment process according to preset rules and processes.
[0014] Interrelationship: Parameter configuration is limited to a certain extent by the tools. Although it can improve deployment efficiency to a certain extent, it lacks flexibility when facing complex and changing deployment requirements. These tools usually do not have the ability to dynamically adjust forms according to different deployment scenarios.
[0015] The defects of existing automated deployment tools for software deployment:
[0016] 2.1 Limited flexibility: Although these tools provide a certain degree of automation, parameter configuration is often limited by the tool's preset rules and processes. When encountering special deployment scenarios or changes in requirements, it is difficult to make flexible adjustments.
[0017] 2.2. Insufficient dynamic adjustment capabilities: Dynamic forms cannot usually be automatically generated according to different deployment scenarios and user needs, and real-time parameter adjustment and optimization cannot be achieved.
[0018] 2.3. Limited scalability: New parameter requirements or special deployment requirements may require complex upgrades or reconfigurations of the tool, increasing the complexity and cost of deployment. Summary of the invention
[0019] The purpose of the present invention is to provide a method and system for generating a dynamic form protocol for declarative deployment package parameters, so as to improve the efficiency, flexibility and reliability of software deployment. By using specific technical means, dynamic forms can be automatically generated according to different deployment requirements, which is convenient for users to configure parameters while ensuring the legality and consistency of parameters.
[0020] To solve the above technical problems, the present invention provides a method for generating a declarative deployment package parameter dynamic form protocol, comprising the following steps:
[0021] Get the parameter configuration file;
[0022] Generate dynamic forms based on parameter configuration files;
[0023] Users enter the values of deployment package parameters through dynamic forms;
[0024] Perform parameter validation on the values of the validation deployment package parameters in the dynamic form;
[0025] After the parameters are verified, a deployable software package is generated.
[0026] Preferably, obtaining the parameter configuration file specifically includes the following steps:
[0027] Use CUE language to define various parameters in the deployment package to obtain a parameter configuration file.
[0028] Preferably, the parameter configuration file includes parameter name, type, constraint condition and default value;
[0029] The types of the parameter configuration file include a string type and an integer type.
[0030] Preferably, generating a dynamic form according to the parameter configuration file specifically includes the following steps:
[0031] Read the type and constraints of the parameter configuration file, generate corresponding form fields, and obtain a dynamic form.
[0032] Preferably, the dynamic form is in the form of a web page or a command line interface.
[0033] Preferably, reading the type and constraint conditions of the parameter configuration file, generating corresponding form fields, and obtaining a dynamic form specifically includes the following steps:
[0034] Generate a text input box for string type parameters in the parameter configuration file;
[0035] Generate a numeric input box for integer type parameters in the parameter configuration file;
[0036] Generate input ranges and validation rules based on the constraints of the parameter configuration file.
[0037] Preferably, when the user inputs the value of the deployment package parameter through the dynamic form, the following steps are also included:
[0038] The dynamic form checks the value of the deployment package parameter entered by the user according to the input range;
[0039] If the value of the deployment package parameter entered by the user does not conform to the input range, a modification prompt message is generated and sent to the user, and the user modifies the value of the deployment package parameter according to the prompt message.
[0040] Preferably, performing parameter verification on the value of the verification deployment package parameter in the dynamic form specifically includes the following steps:
[0041] Verify the values of deployment package parameters according to the validation rules;
[0042] If the value of the deployment package parameter entered by the user does not meet the validation rules, an error prompt message is generated and sent to the user, and the user re-enters the value of the deployment package parameter according to the error prompt message.
[0043] Preferably, after the parameter verification is passed, a deployable software package is generated, which specifically includes the following steps:
[0044] After the parameter verification is passed, the value of the deployment package parameter input by the user in the dynamic form is applied to the deployment package to obtain a deployable software package.
[0045] The present invention also provides a system for generating a declarative deployment package parameter dynamic form protocol, comprising:
[0046] Deployment package parameter configuration file module, used to obtain parameter configuration files;
[0047] Dynamic form generation module, used to generate dynamic forms according to parameter configuration files;
[0048] Input module, used by users to input the values of deployment package parameters through dynamic forms;
[0049] The parameter validation module is used to validate the values of the validation deployment package parameters in the dynamic form;
[0050] The deployment package generation module is used to generate a deployable software package after the parameter verification passes.
[0051] Compared with the prior art, the present invention has the following beneficial effects:
[0052] 1. Use CUE language to implement declarative definition: Declaratively define the deployment package parameters through CUE language, clarify the parameter name, type, constraints and default value, etc., and improve the accuracy and readability of parameter definition.
[0053] 2. Automatically generate dynamic forms: According to the deployment package parameters defined by CUE, dynamic forms are automatically generated to facilitate user parameter configuration. The form generation process takes into account different parameter types and constraints to ensure the legitimacy of user input.
[0054] 3. Strict parameter verification mechanism: Use CUE's powerful verification function to strictly verify the parameters entered by the user. Ensure that the parameters meet the constraints defined in the declarative way and reduce deployment failures caused by parameter errors.
[0055] 4. Flexible integration capability: The dynamic form protocol generated by the present invention can be easily integrated with the existing software deployment process. Whether it is a continuous integration / continuous deployment (CI / CD) tool or other deployment systems, it can easily realize the automation of parameter configuration.
[0056] 5. Improve deployment efficiency and reliability: Through automated parameter configuration and strict verification mechanisms, the efficiency and reliability of software deployment are greatly improved. The tedious process and error risk of manual parameter configuration are reduced, ensuring that the software can be correctly deployed in different environments. BRIEF DESCRIPTION OF THE DRAWINGS
[0057] The specific implementation modes of the present invention are further described in detail below with reference to the accompanying drawings.
[0058] Figure 1It is a flowchart of traditional manual configuration file modification;
[0059] Figure 2 It is a flowchart of existing automated deployment tools;
[0060] Figure 3 It is a flow chart of a method for generating a declarative deployment package parameter dynamic form protocol according to the present invention. DETAILED DESCRIPTION
[0061] Many specific details are set forth in the following description to facilitate a full understanding of the present invention. However, the present invention can be implemented in many other ways than those described herein, and those skilled in the art can make similar generalizations without violating the connotation of the present invention, so the present invention is not limited to the specific implementation disclosed below.
[0062] The terms used in one or more embodiments of this specification are only for the purpose of describing specific embodiments, and are not intended to limit one or more embodiments of this specification. The singular forms of "a", "said" and "the" used in one or more embodiments of this specification and the appended claims are also intended to include plural forms, unless the context clearly indicates other meanings. It should also be understood that the term "and / or" used in one or more embodiments of this specification refers to and includes any or all possible combinations of one or more associated listed items.
[0063] It should be understood that although the terms first, second, etc. may be used to describe various information in one or more embodiments of this specification, this information should not be limited to these terms. These terms are only used to distinguish the same type of information from each other. For example, without departing from the scope of one or more embodiments of this specification, the first may also be referred to as the second, and similarly, the second may also be referred to as the first. Depending on the context, the word "if" as used herein may be interpreted as "at the time of" or "when" or "in response to determining".
[0064] The present invention is further described in detail below in conjunction with the accompanying drawings:
[0065] The present invention provides a method for generating a dynamic form protocol for declarative deployment package parameters, which utilizes the powerful functions of the CUE (Converged Universal Expression) language to realize dynamic configuration and management of software deployment parameters. The method defines deployment package parameters declaratively, automatically generates dynamic forms, and combines strict parameter verification and flexible integration mechanisms to improve the efficiency, flexibility and reliability of software deployment.
[0066] The present invention aims to overcome the defects in the existing software deployment method to achieve the following objectives:
[0067] 1. Overcoming the shortcomings of traditional manual configuration file modification methods
[0068] Improve efficiency: Automatically generate dynamic forms to avoid the tedious process of manually editing configuration files one by one, greatly improving the efficiency of software deployment.
[0069] Reduce error rate: Through a strict parameter verification mechanism, the legality and consistency of input parameters are ensured to reduce deployment failures caused by human errors.
[0070] Enhanced flexibility: The form can be dynamically adjusted according to different deployment scenarios and requirements, quickly adapting to various changes without the need to manually modify configuration files frequently.
[0071] 2. Make up for the shortcomings of existing automated deployment tools
[0072] Improve flexibility: Break through the limitations of existing tool parameter configurations and dynamically generate forms based on specific circumstances to meet special deployment scenarios and personalized needs.
[0073] Enhanced dynamic adjustment capabilities: Respond to changes in the deployment environment in real time, automatically adjust form content, and achieve more efficient parameter configuration and software deployment.
[0074] Improve scalability: Easy to integrate and expand, able to adapt to changing technical and business needs, and provide a more reliable and sustainable solution for software deployment.
[0075] The present invention provides a system for generating a declarative deployment package parameter dynamic form protocol, comprising:
[0076] 1. CUE language interpreter: responsible for parsing and executing CUE code to implement declarative definition and constraints on deployment package parameters.
[0077] 2. Deployment package parameter configuration file: written in CUE language, contains information such as the definition, constraints, and default values of various deployment parameters.
[0078] 3. Dynamic form generation module: Automatically generate dynamic forms based on the deployment package parameter configuration file for users to configure parameters.
[0079] 4. Parameter verification module: Verify the parameters input by the user to ensure that the parameters meet the constraints defined by CUE.
[0080] 5. Deployment package generation module: applies the user-configured parameters to the deployment package to generate the final deployable software package.
[0081] The present invention provides a method for generating a dynamic form protocol for declarative deployment package parameters, which aims to provide an efficient and reliable parameter configuration solution for enterprise-level software deployment to meet the software deployment needs of enterprises of different sizes in complex business scenarios, and specifically includes the following steps:
[0082] 1. Edit parameter configuration file
[0083] Use CUE language to define various parameters in the deployment package, including parameter name, type, constraints, and default value, etc. For example, when the authorization prospect is enterprise-level software deployment package deployment, the parameter "server address" type is a string, the constraint is that it must start with "http: / / " or "https: / / ", and the default value is "http: / / localhost".
[0084] 2. Generate dynamic forms
[0085] The dynamic form generation module reads the deployment package parameter configuration file and automatically generates the corresponding form fields according to the parameter type and constraints. For different application scenarios and user needs, the generated dynamic form can be in the form of a web page, a command line interface, or other forms, depending on the application scenario and user needs. For example: a text input box is generated for a string type parameter, a numeric input box is generated for an integer type parameter, and the input range and validation rules are set according to the constraints. When the constraint is that the value must be greater than or equal to 100, a numeric input box is generated and the input range is set to [100, +∞), and the validation rule is whether the value is greater than or equal to 100.
[0086] 3. User Configuration Parameters
[0087] Users enter the values of deployment package parameters through dynamic forms. During the input process, the form will check the legitimacy of the user input in real time according to the validation rules and give corresponding modification prompts.
[0088] For example, when the "server address" entered by the user does not meet the constraint conditions, the prompt message is modified to "the server address must start with 'http: / / ' or 'https: / / '". The user can modify the parameter value according to the actual situation until the deployment requirements are met.
[0089] 4. Parameter Verification
[0090] The parameter verification module verifies the parameters input by the user to ensure that the parameters meet the constraints defined by CUE. If the parameters are illegal, an error message will be given and the user will be asked to re-enter.
[0091] The validation process can include type checking, range checking, format checking, etc., depending on the parameter type and constraints.
[0092] 5. Generate deployment package
[0093] The deployment package generation module applies the user-configured parameters to the deployment package to generate the final deployable software package.
[0094] The build process can include multiple steps such as writing parameter values to configuration files, compiling code, and packaging files, depending on the deployment method and requirements of the software.
[0095] The conditional parameters of the method for generating a declarative deployment package parameter dynamic form protocol of the present invention are:
[0096] CUE language version: ensure that the CUE language version used is compatible with the method of the present invention. Different versions of CUE languages may have differences in syntax and functionality.
[0097] Deployment environment requirements: Depending on the software deployment environment, certain hardware and software requirements may need to be met, such as operating system version, memory size, disk space, etc.
[0098] Parameter constraints: When writing a deployment package parameter configuration file, you need to set reasonable parameter constraints based on actual conditions to ensure the legality and validity of the parameters.
[0099] The coordination and functions of the above components are as follows:
[0100] 1. The coordination between CUE language interpreter and deployment package parameter configuration file;
[0101] The CUE language interpreter reads the deployment package parameter configuration file, parses the CUE code, and obtains the definition and constraints of the parameters. The interpreter verifies and processes the parameters entered by the user based on the definition and constraints of the parameters to ensure that the parameters meet the requirements.
[0102] 2. The dynamic form generation module cooperates with the deployment package parameter configuration file;
[0103] The dynamic form generation module reads the deployment package parameter configuration file and generates corresponding form fields according to the parameter type and constraints.
[0104] The form generation module passes the parameter values entered by the user to the parameter verification module for verification to ensure the legitimacy of the parameters.
[0105] 3. The coordination between the parameter verification module and the deployment package parameter configuration file;
[0106] The parameter validation module validates the parameters entered by the user according to the constraints defined in the deployment package parameter configuration file.
[0107] If the parameters are illegal, the parameter verification module will give an error prompt and ask the user to re-enter the parameters.
[0108] 4. Coordination between the deployment package generation module and user configuration parameters
[0109] The deployment package generation module applies the parameter values configured by the user to the deployment package to generate the final deployable software package.
[0110] The generation module performs corresponding compilation, packaging and other operations according to the software deployment method and requirements to ensure that the software package can run correctly in the target environment.
[0111] Compared with the traditional manual configuration file modification method, the present invention has the following advantages:
[0112] Efficiency is greatly improved: The traditional method requires manual editing of configuration files one by one, which is time-consuming and prone to errors. The present invention uses CUE language to automatically generate dynamic forms, and users only need to configure parameters in the form, which greatly reduces configuration time and improves deployment efficiency. For example, in a deployment scenario with 50 parameters, the traditional method may take several hours to configure and check, while the present invention can complete parameter configuration in a few minutes and ensure accuracy.
[0113] Significantly reduced error rate: Manual configuration files are prone to input errors, format errors and other problems. The present invention uses a strict parameter verification mechanism to ensure that the parameters entered by the user meet the constraints defined by CUE, reducing deployment failures caused by parameter errors. Experiments show that in the same deployment scenario, the error rate of traditional methods may be as high as 10% or more, while the error rate of the present invention can be controlled within 1%.
[0114] Greater flexibility: Traditional methods require manual modification of configuration files when faced with different deployment requirements, which makes it difficult to quickly adapt to changes. The dynamic form of the present invention can be dynamically adjusted according to different deployment scenarios and user needs, and quickly adapt to various changes. For example, when the deployment environment changes, the present invention can automatically adjust the form content, and the user only needs to reconfigure the relevant parameters without manually modifying complex configuration files.
[0115] Compared with some existing automated deployment tools, the present invention has the following advantages:
[0116] Breaking through parameter configuration limitations: The parameter configuration of existing tools is often limited by preset rules and processes, and lacks flexibility. The present invention uses the declarative definition of the CUE language to flexibly define deployment package parameters according to specific circumstances, breaking through the limitations of existing tools. For example, in some special deployment scenarios, existing tools may not be able to meet specific parameter requirements, but the present invention can easily achieve this through custom CUE configuration files.
[0117] Enhanced dynamic adjustment capability: Existing tools usually do not have the ability to dynamically adjust forms according to different deployment scenarios. The present invention can respond to changes in the deployment environment in real time, automatically adjust the form content, and achieve more efficient parameter configuration and software deployment. For example, when the network environment changes, the present invention can automatically adjust network-related parameters to ensure that the software runs normally in the new environment.
[0118] Improve scalability: Existing tools may require complex upgrades or reconfigurations for new parameter requirements or special deployment requirements. The present invention is easy to integrate and expand, and can adapt to changing technical and business requirements. For example, when a new deployment parameter needs to be added, it only needs to be defined declaratively in the CUE configuration file, and the corresponding form fields can be automatically generated without modifying the entire deployment tool.
[0119] The present invention has the following advantages in terms of data security:
[0120] The declarative definition of the CUE language and the strict parameter verification mechanism can ensure the legitimacy and consistency of parameters and reduce security vulnerabilities caused by parameter errors. For example, for parameters involving database connections, strict password rules and access rights can be defined through CUE to improve data security.
[0121] The dynamic form generation process can perform real-time verification and filtering of user input to prevent malicious input and attacks. For example, for the IP address entered by the user, CUE can verify its format and legitimacy to prevent the input of illegal IP addresses.
[0122] The present invention saves network resources:
[0123] The automatically generated dynamic form can display only the necessary parameters according to actual needs, avoiding unnecessary parameter configuration and network transmission, and saving network resources. For example, in a deployment scenario where only the server address and port number need to be configured, the dynamic form will only display these two parameters, and will not display other unnecessary parameters, reducing the amount of data transmitted over the network.
[0124] The efficient deployment method of the present invention can reduce the number of network communications and data transmission during the deployment process, and improve the utilization rate of network resources. For example, by automatically verifying parameters and quickly generating deployment packages, the number of interactions with the server can be reduced, reducing the network load.
[0125] The present invention has the following advantages in terms of data processing speed and accuracy:
[0126] The efficient parsing and verification mechanism of CUE language can quickly process the parameters input by users and improve the data processing speed. Experiments show that when processing a large number of parameter configurations, the processing speed of the present invention is several times or even dozens of times faster than that of traditional methods.
[0127] Strict parameter verification ensures the accuracy of parameters and reduces deployment failures and subsequent data processing errors caused by parameter errors. For example, for parameters involving numerical calculations, precise numerical ranges and precision requirements can be defined through CUE to improve the accuracy of data processing.
[0128] The present invention has the following advantages in terms of manufacturing cost:
[0129] The automatic deployment method of the present invention reduces manual intervention and reduces labor costs. No professional developers are required to modify the configuration files manually, and ordinary users can also configure parameters through dynamic forms, saving labor costs.
[0130] The easy integration and expansion features reduce the cost of software maintenance and upgrades. When new functions or parameters need to be added, they can be automatically generated by simply declaratively defining them in the CUE configuration file, without the need for large-scale modification and testing of the entire deployment tool.
[0131] In order to verify the effect of the present invention, the following tests were carried out:
[0132] 1. Test environment:
[0133] Build a Kubernetes cluster with multiple nodes to simulate the actual software deployment environment.
[0134] The deployment package parameter dynamic form protocol generation tool of the present invention is installed and compared with the existing automated deployment tool.
[0135] 2. Test methods:
[0136] A plurality of software deployment scenarios of different scales and complexities are selected, and deployment is performed using a traditional manual configuration file modification method, an existing automated deployment tool, and the method of the present invention, respectively.
[0137] Record the configuration time, error rate, network resource consumption and other indicators in each deployment scenario, and conduct comparative analysis.
[0138] The parameter verification mechanism of the present invention is stress-tested to simulate different types of erroneous inputs to verify its accuracy and reliability.
[0139] 3. Test results:
[0140] The present invention is significantly superior to traditional manual configuration file modification methods and existing automated deployment tools in terms of configuration time, error rate, network resource saving, etc.
[0141] The parameter verification mechanism demonstrated high accuracy and reliability under stress testing and can effectively prevent incorrect input.
[0142] The above experiments have proved that the present invention has significant effects in improving software deployment efficiency, flexibility, reliability and security.
[0143] In order to better illustrate the technical effect of the present invention, the present invention provides the following specific embodiments to illustrate the above technical process:
[0144] Example 1: Deployment of Nginx Ingress controller in Kubernetes environment;
[0145] Test plan:
[0146] Deploy the Nginx Ingress controller in a 5-node Kubernetes cluster.
[0147] Use CUE language to define deployment package parameters;
[0148] Automatically generate dynamic forms for administrators to configure parameters;
[0149] After strict verification of the parameters, they are applied to Kubernetes deployment;
[0150] Experimental effect data:
[0151] 1. Deployment time comparison:
[0152] Traditional manual configuration takes about 60 minutes on average. With the method of the present invention, it only takes 10 minutes from parameter configuration to deployment completion.
[0153] 2. First deployment success rate:
[0154] The traditional method is prone to parameter errors, and the first deployment success rate is about 70%. However, the present invention achieves a first deployment success rate of 95% through strict parameter verification.
[0155] Example 2: Installation of Prometheus monitoring components in Kubernetes environment;
[0156] Test plan:
[0157] Install Prometheus monitoring components in a medium-sized Kubernetes cluster (10 nodes).
[0158] Define parameters via CUE;
[0159] Experimental effect data:
[0160] 1. Installation time comparison:
[0161] Traditional manual installation of Prometheus monitoring components usually takes 4 to 5 hours. Using the method of the present invention, the installation time is shortened to about 10 minutes.
[0162] 2. Improved data accuracy:
[0163] In the traditional method, due to configuration errors, the data capture may be inaccurate, and the data accuracy rate is about 85%. However, through strict parameter verification, the data accuracy rate of the present invention is increased to 98%.
[0164] Example 3: Deployment of Elasticsearch log collection components in Kubernetes environment;
[0165] Test plan:
[0166] Deploy the Elasticsearch component in a larger Kubernetes cluster (15 nodes).
[0167] Use CUE to define parameters;
[0168] Automatically generate dynamic forms, configure and verify parameters before deploying.
[0169] Experimental effect data:
[0170] 1. Deployment time comparison:
[0171] Traditional manual deployment of the Elasticsearch log collection component may take more than 8 hours. Through the method of the present invention, the deployment time is shortened to about 10 minutes.
[0172] 2. Improved storage efficiency:
[0173] When the traditional method is used, the storage utilization rate is about 60%. After using the present invention, due to the reasonable configuration parameters, the storage utilization rate is increased to 80%.
[0174] In the several embodiments provided by the present invention, it should be understood that the disclosed devices and methods can be implemented in other ways. For example, the device embodiments described above are only schematic, for example, the division of the modules, modules or units is only a logical function division, and there may be other division methods in actual implementation, for example, multiple units, modules or components can be combined or integrated into another device, or some features can be ignored or not executed.
[0175] The units may or may not be physically separated, and the components displayed as units may be one physical unit or multiple physical units, that is, they may be located in one place or distributed in multiple different places. Some or all of the units may be selected according to actual needs to achieve the purpose of the present embodiment.
[0176] In addition, each functional unit in each embodiment of the present invention may be integrated into one processing unit, or each unit may exist physically separately, or two or more units may be integrated into one unit. The above-mentioned integrated unit may be implemented in the form of hardware or in the form of software functional units.
[0177] In particular, according to the embodiments disclosed in the present invention, the process described above with reference to the flowchart can be implemented as a computer software program. For example, the embodiments disclosed in the present invention include a computer program product, which includes a computer program carried on a computer-readable medium, and the computer program includes a program code for executing the method shown in the flowchart. In such an embodiment, the computer program can be downloaded and installed from the network through the communication part, and / or installed from a removable medium. When the computer program is executed by the central processing unit (CPU), the above-mentioned functions defined in the method of the present invention are executed. It should be noted that the above-mentioned computer-readable medium of the present invention can be a computer-readable signal medium or a computer-readable storage medium or any combination of the above two. The computer-readable storage medium can be, for example, but not limited to, a system, device or device of an electrical, magnetic, optical, electromagnetic, infrared segment, or semiconductor, or any combination of the above.
[0178] The flow chart and block diagram in the accompanying drawings illustrate the possible architecture, function and operation of the system, method and computer program product according to various embodiments of the present invention. In this regard, each square box in the flow chart or block diagram can represent a module, a program segment or a part of a code, and the module, the program segment or a part of the code contains one or more executable instructions for realizing the specified logical function. It should also be noted that in some alternative implementations, the functions marked in the square box can also occur in a sequence different from that marked in the accompanying drawings. For example, two square boxes represented in succession can actually be executed substantially in parallel, and they can sometimes be executed in the opposite order, depending on the functions involved. It should also be noted that each square box in the block diagram and / or flow chart, and the combination of the square boxes in the block diagram and / or flow chart can be implemented with a dedicated hardware-based system that performs the specified function or operation, or can be implemented with a combination of dedicated hardware and computer instructions.
[0179] The above is only a specific embodiment of the present invention, but the protection scope of the present invention is not limited thereto. Any changes or substitutions within the technical scope disclosed by the present invention should be included in the protection scope of the present invention. Therefore, the protection scope of the present invention should be based on the protection scope of the claims.
Claims
1. A method for generating a dynamic form protocol for declarative deployment package parameters, characterized in that: The following steps are involved: Get the parameter configuration file; Generate dynamic forms based on parameter configuration files; Users enter the values of deployment package parameters through dynamic forms; Perform parameter validation on the values of the validation deployment package parameters in the dynamic form; After the parameters are verified, a deployable software package is generated.
2. The method for generating a declarative deployment package parameter dynamic form protocol according to claim 1, characterized in that: Obtain the parameter configuration file, which includes the following steps: Use CUE language to define various parameters in the deployment package to obtain a parameter configuration file.
3. The method for generating a dynamic form protocol for declarative deployment package parameters according to claim 2, characterized in that: The parameter configuration file includes parameter name, type, constraint condition and default value; The types of the parameter configuration file include a string type and an integer type.
4. The method for generating a declarative deployment package parameter dynamic form protocol according to claim 3, characterized in that: Generate a dynamic form based on the parameter configuration file, which includes the following steps: Read the type and constraints of the parameter configuration file, generate corresponding form fields, and obtain a dynamic form.
5. The method for generating a declarative deployment package parameter dynamic form protocol according to claim 4, characterized in that: The dynamic form is in the form of a web page or a command line interface.
6. The method for generating a dynamic form protocol for declarative deployment package parameters according to claim 5, characterized in that: Read the type and constraints of the parameter configuration file, generate corresponding form fields, and obtain a dynamic form. The specific steps include: Generate a text input box for string type parameters in the parameter configuration file; Generate a numeric input box for integer type parameters in the parameter configuration file; Generate input ranges and validation rules based on the constraints of the parameter configuration file.
7. The method for generating a dynamic form protocol for declarative deployment package parameters according to claim 6, characterized in that: When the user enters the value of the deployment package parameter through the dynamic form, the following steps are also included: The dynamic form checks the value of the deployment package parameter entered by the user according to the input range; If the value of the deployment package parameter entered by the user does not conform to the input range, a modification prompt message is generated and sent to the user, and the user modifies the value of the deployment package parameter according to the prompt message.
8. The method for generating a declarative deployment package parameter dynamic form protocol according to claim 7, characterized in that: Perform parameter verification on the value of the deployment package parameter in the dynamic form, including the following steps: Verify the values of deployment package parameters according to the validation rules; If the value of the deployment package parameter entered by the user does not meet the validation rules, an error prompt message is generated and sent to the user, and the user re-enters the value of the deployment package parameter according to the error prompt message.
9. The method for generating a declarative deployment package parameter dynamic form protocol according to claim 8, characterized in that: After the parameters are verified, a deployable software package is generated, which includes the following steps: After the parameter verification is passed, the value of the deployment package parameter input by the user in the dynamic form is applied to the deployment package to obtain a deployable software package.
10. A system for generating a declarative deployment package parameter dynamic form protocol, used to implement a method for generating a declarative deployment package parameter dynamic form protocol as described in any one of claims 1 to 9, characterized in that: include: Deployment package parameter configuration file module, used to obtain parameter configuration files; Dynamic form generation module, used to generate dynamic forms according to parameter configuration files; Input module, used by users to input the values of deployment package parameters through dynamic forms; The parameter validation module is used to validate the values of the validation deployment package parameters in the dynamic form; The deployment package generation module is used to generate a deployable software package after the parameter verification passes.