Architecture deployment solution generation method, electronic device, storage medium and product

Abstract

This application discloses a method for generating an architecture deployment solution, an electronic device, a storage medium, and a product, relating to the field of architecture deployment technology. The method includes: obtaining key indicators of architecture deployment based on historical architecture deployment data, and generating preset architecture deployment requirements based on the key indicators; for any of the preset architecture deployment requirements, matching a target architecture component deployment solution to the preset architecture deployment requirement from a set of preset architecture component deployment solutions; and configuring the number of components for the target architecture component deployment solution based on the preset architecture deployment requirement to obtain a standard architecture deployment solution. This application solves the technical problem of poor deployment results in current system architecture deployment.

Description

Technical Field

[0001] The present application relates to the field of architecture deployment technology, and in particular to an architecture deployment solution generation method, device, electronic device, storage medium and computer program product. Background Art

[0002] In the area of ​​system architecture deployment, with the rapid development of software technology, enterprises' information-based products are becoming increasingly diversified, and customer needs are also becoming more diverse. Currently, to meet these diverse product demands, business personnel must manually collect data such as customer information and cloud resource configurations when deploying system architectures. This process involves duplication of operations across multiple product sets, resulting in low efficiency. Changes in customer needs or resource configurations require manual re-verification of the plan, resulting in slow response times. Furthermore, existing methods rely on manual experience to match deployment resources, making it difficult to accurately adapt the relationship between user needs and deployment resources, resulting in unreliable deployment plans. Consequently, current system architecture deployment suffers from poor deployment results.

[0003] The above content is only used to assist in understanding the technical solution of this application and does not constitute an admission that the above content is prior art. Summary of the Invention

[0004] The main purpose of this application is to provide a method, device, electronic device, storage medium and computer program product for generating an architecture deployment solution, aiming to solve the technical problem of poor deployment effect in current system architecture deployment.

[0005] To achieve the above objectives, the present application proposes a method for generating an architecture deployment solution, which includes:

[0006] Filtering key indicators of architecture deployment based on historical architecture deployment data, and generating preset architecture deployment requirements based on the key indicators;

[0007] For any one of the preset architecture deployment requirements, matching a target architecture component deployment solution for the preset architecture deployment requirement from a set of preset architecture component deployment solutions;

[0008] Based on the preset architecture deployment requirements, the component quantity is configured for the target architecture component deployment solution to obtain a standard architecture deployment solution.

[0009] In one embodiment, the step of obtaining key indicators of architecture deployment based on historical architecture deployment data includes:

[0010] Standardizing historical architecture deployment data and eliminating outliers in the historical architecture deployment data;

[0011] Calculating the correlation coefficient between each element indicator in the historical architecture deployment data and the preset architecture components;

[0012] The factor indicators whose correlation coefficients are less than the preset correlation threshold are eliminated, and the factor indicators whose correlation coefficients are greater than or equal to the preset correlation threshold are used as the key indicators of the architecture deployment.

[0013] In one embodiment, before the step of matching the preset architecture deployment requirement with the target architecture component deployment solution from the preset architecture component deployment solution set, the step further includes:

[0014] Configuring architecture components for each preset architecture type to obtain candidate architecture combinations;

[0015] Eliminate candidate architecture combinations that do not comply with the version compatibility rules and the hardware configuration constraint matrix from the candidate architecture combinations to obtain a preset architecture component deployment solution set.

[0016] In one embodiment, the step of matching the target architecture component deployment solution to the preset architecture deployment requirement from the preset architecture component deployment solution set includes:

[0017] Extracting historical customer needs associated with the preset architecture deployment needs from the historical architecture deployment data, and determining preset architecture component deployment solutions corresponding to the historical customer needs in the preset architecture component deployment solution set as candidate architecture component deployment solutions;

[0018] In combination with the industry trend requirements in the preset industry trend database, the candidate architecture component deployment solutions that meet the industry trend requirements are screened from the candidate architecture component deployment solutions as the target architecture component deployment solution.

[0019] In one embodiment, the step of configuring the number of components for the target architecture component deployment solution based on the preset architecture deployment requirements includes:

[0020] Determine a quantitative indicator among the key indicators under the preset architecture deployment requirements, and determine a coefficient relationship between the quantitative indicator and each architecture component through a logistic regression algorithm;

[0021] A prediction model between the quantitative indicators and the various architectural components is obtained based on the coefficient relationship, and the corresponding quantity of each architectural component in the target architectural component deployment plan is determined according to the prediction model.

[0022] In one embodiment, after the step of obtaining the standard architecture deployment solution, the method further includes:

[0023] If the user does not input a deployment combination mode, the user requirements input by the user are parsed, and a target architecture deployment solution that meets the user requirements is searched for in each standard architecture deployment solution, wherein each standard architecture deployment solution is obtained by traversing each preset architecture deployment requirement;

[0024] In the case where the user inputs a deployment combination method, a target architecture deployment solution is constructed based on the deployment combination method.

[0025] In one embodiment, the architecture deployment solution generation method further includes:

[0026] generating a user demand list according to the user demand;

[0027] Generate a deployment plan list according to the target architecture deployment plan;

[0028] Generate a server list based on the server configuration in the target architecture deployment plan;

[0029] A deployment plan is generated according to the expected deployment completion time of the target architecture deployment solution.

[0030] In addition, to achieve the above objectives, the present application also proposes an architecture deployment solution generation system, which includes:

[0031] A demand determination module is used to screen and obtain key indicators of architecture deployment based on historical architecture deployment data, and generate preset architecture deployment requirements based on the key indicators;

[0032] a solution matching module, configured to match a target architecture component deployment solution for any one of the preset architecture deployment requirements from a set of preset architecture component deployment solutions;

[0033] A quantity deployment module is used to configure the component quantity for the target architecture component deployment plan based on the preset architecture deployment requirements to obtain a standard architecture deployment plan.

[0034] In addition, to achieve the above-mentioned purpose, the present application also proposes an electronic device, which includes: a memory, a processor, and a computer program stored on the memory and runnable on the processor, wherein the computer program is configured to implement the steps of the architecture deployment solution generation method as described above.

[0035] In addition, to achieve the above-mentioned purpose, the present application also proposes a storage medium, which is a computer-readable storage medium, and a computer program is stored on the storage medium. When the computer program is executed by the processor, the steps of the architecture deployment solution generation method described above are implemented.

[0036] In addition, to achieve the above-mentioned purpose, the present application also provides a computer program product, which includes a computer program, and when the computer program is executed by a processor, it implements the steps of the architecture deployment solution generation method as described above.

[0037] The present application provides a method for generating an architecture deployment plan, which includes: obtaining key indicators of architecture deployment based on historical architecture deployment data, and generating preset architecture deployment requirements based on the key indicators; for any one of the preset architecture deployment requirements, matching the preset architecture deployment requirement with a target architecture component deployment plan from a set of preset architecture component deployment plans; configuring the number of components for the target architecture component deployment plan based on the preset architecture deployment requirement to obtain a standard architecture deployment plan.

[0038] By screening out key indicators that have a significant impact on architecture deployment from a large amount of historical architecture deployment data, this application can quickly and accurately generate multiple preset architecture deployment requirements, providing a rich and reasonable basis for subsequent solution matching, improving the efficiency and quality of demand generation, solving the problem of incomplete and inaccurate manually collected data, and avoiding unreasonable deployment solutions due to missing or incorrect information. By screening out the target architecture component deployment solution that best meets the requirement from the preset architecture component deployment solutions for each preset architecture deployment requirement, the accuracy and efficiency of solution matching are improved, and the appropriate target solution can be quickly found for each preset requirement, reducing manual intervention and the deployment risk caused by manual matching errors, ensuring that the deployment solution is highly consistent with user needs. After determining the target architecture component deployment solution, the architecture deployment solution is quickly generated and dynamically adjusted based on the specific parameters in the preset architecture deployment requirement, which can promptly meet the diverse needs of customers and changes in resource allocation, improve the flexibility and adaptability of the system, ensure that the deployment solution can always meet actual business needs, and improve the deployment effect. Compared with related solutions that rely on business personnel to manually collect user needs and analyze deployment plans, when needs or configurations change, plans need to be manually re-verified. Moreover, due to reliance on manual experience, it is difficult to accurately adapt the relationship between user needs and deployment resources. This solution uses an automated method to analyze historical architecture deployment data, combine architectures, match plans, and analyze quantities, avoiding a large amount of manual operations and greatly improving the efficiency of architecture deployment plan generation. Through automated component quantity configuration, plans can be quickly adjusted according to changes in demand. When customer needs or resource configurations change, plans can be quickly regenerated based on new data and indicators, avoiding the tedious process of manual re-verification and improving response speed. By mining key indicators from historical data, automatically matching plans, and configuring component quantities, the interference of manual experience is reduced, and the relationship between user needs and deployment resources can be more accurately adapted, making the generated plan more scientific and reasonable, and improving the reliability of the deployment plan, thereby effectively solving the problem of poor deployment effect in the current system architecture deployment. BRIEF DESCRIPTION OF THE DRAWINGS

[0039] The accompanying drawings, which are incorporated in and constitute a part of this specification, illustrate embodiments consistent with the present application and, together with the description, serve to explain the principles of the present application.

[0040] In order to more clearly illustrate the embodiments of the present application or the technical solutions in the prior art, the following briefly introduces the drawings required for use in the embodiments or the description of the prior art. Obviously, for ordinary technicians in this field, other drawings can be obtained based on these drawings without any creative work.

[0041] Figure 1 A flowchart of the first embodiment of the method for generating an architecture deployment solution for this application is provided;

[0042] Figure 2 A flowchart of the second embodiment of the method for generating an architecture deployment solution for this application is provided;

[0043] Figure 3 A schematic diagram of a deployment solution generator provided for the architecture deployment solution generation method of this application;

[0044] Figure 4 A schematic diagram of the module structure of the system for generating a deployment solution for an embodiment of the present application;

[0045] Figure 5 This is a schematic diagram of the device structure of the hardware operating environment involved in the architecture deployment solution generation method in the embodiment of the present application.

[0046] The purpose, features and advantages of this application will be further explained in conjunction with the embodiments and with reference to the accompanying drawings. DETAILED DESCRIPTION

[0047] It should be understood that the specific embodiments described herein are merely used to explain the technical solutions of the present application and are not intended to limit the present application.

[0048] In order to better understand the technical solution of the present application, a detailed description will be given below in conjunction with the accompanying drawings and specific implementation methods.

[0049] The main solution of the embodiment of the present application is: based on the historical architecture deployment data screening, the key indicators of the architecture deployment are obtained, and the preset architecture deployment requirements are generated based on the key indicators; for any one of the preset architecture deployment requirements, the target architecture component deployment plan is matched to the preset architecture deployment requirement from the preset architecture component deployment plan set; based on the preset architecture deployment requirement, the number of components is configured for the target architecture component deployment plan to obtain a standard architecture deployment plan.

[0050] In this embodiment, for ease of description, the following description is made with the architecture deployment solution generation system as the execution entity.

[0051] Because existing technologies rely on business personnel to manually collect user needs and analyze deployment plans, plans need to be manually re-verified when needs or configurations change. Moreover, due to reliance on manual experience, it is difficult to accurately adapt the relationship between user needs and deployment resources.

[0052] This application provides a solution that analyzes historical architecture deployment data, combines architectures, matches solutions, and analyzes quantities in an automated manner, thereby avoiding a large amount of manual operations and greatly improving the efficiency of generating architecture deployment solutions. Through automated component quantity configuration, the solution can be quickly adjusted according to changes in demand. When customer demand or resource configuration changes, the solution can be quickly regenerated based on the new data and indicators, avoiding the tedious process of manual re-verification and improving the response speed. By mining key indicators, automatically matching solutions, and configuring component quantities from historical data, the interference of manual experience is reduced, and the relationship between user needs and deployment resources can be more accurately adapted, making the generated solution more scientific and reasonable, and improving the reliability of the deployment solution, thereby effectively solving the problem of poor deployment effect in the current system architecture deployment.

[0053] It should be noted that the execution subject of this embodiment can be a computing service device with data processing, network communication, and program execution functions, such as a tablet computer, personal computer, mobile phone, etc., or an electronic device capable of implementing the above functions, an architecture deployment solution generation system, etc. The following uses the architecture deployment solution generation system as an example to illustrate this embodiment and the following embodiments.

[0054] Based on this, the embodiment of the present application provides a method for generating an architecture deployment solution, referring to Figure 1 , Figure 1 This is a flow chart of the first embodiment of the method for generating an architecture deployment solution of this application.

[0055] In this embodiment, the architecture deployment solution generation method includes steps S01 to S03:

[0056] Step S01: Filter and obtain key indicators of architecture deployment based on historical architecture deployment data, and generate preset architecture deployment requirements based on the key indicators;

[0057] It should be noted that the system first collects historical architecture deployment data. Historical architecture deployment data is a comprehensive information collection accumulated by the system's past completed architecture projects, covering multiple dimensions from basic customer information (such as enterprise size, industry type, user needs, etc.), technical environment data (such as cloud service provider type, server hardware configuration, network bandwidth, etc.), architecture design parameters (such as the adopted deployment architecture, module division, etc.) to actual effect data after deployment (such as system response time, throughput, failure rate, etc.). The pre-processed historical sample data is analyzed using a correlation analysis algorithm. Correlation analysis is a mathematical statistical method used to measure the closeness and direction of the relationship between two or more variables. It aims to explore the relationship between different factors and the effect of architecture deployment. The factors that have a significant impact on the effect of architecture deployment are screened out through the correlation analysis algorithm. As the key indicators of architecture deployment, these indicators can clearly reflect the core requirements and constraints of architecture deployment, and are the key basis for generating reasonable architecture deployment plans. The key indicators also include various indicator parameters. The indicator parameters under each key indicator are arranged and combined to obtain various demand combinations, and the repeated combinations in the demand combinations are eliminated to generate various preset architecture deployment requirements. The preset architecture deployment requirements include non-repeated demand combinations.

[0058] It is understandable that, when faced with diverse architectural components, manual combination is not only inefficient but also prone to missing feasible architectural combination solutions, and is unable to fully cover potential high-quality deployment architectures. Therefore, step S01 is performed. By analyzing historical architectural deployment data, the system can accurately mine the key indicators that have the greatest impact on the architectural deployment effect from massive data, provide a clear direction for subsequent solution generation, ensure that the solution focuses on core requirements, and generate preset architectural deployment requirements based on key indicators in historical data, which is more in line with actual business scenarios and system operation rules, making the requirements more reasonable and accurate, and providing a reliable basis for subsequent solution matching and configuration.

[0059] Step S02: For any one of the preset architecture deployment requirements, a target architecture component deployment solution is matched to the preset architecture deployment requirement from the preset architecture component deployment solution set;

[0060] It should be noted that for each pre-defined architecture deployment requirement, the system uses a matching algorithm (such as a rule-based matching algorithm or a similarity-based matching algorithm) to find the solution that best meets the requirement from the pre-defined architecture component deployment solution set, which serves as the target architecture component deployment solution. The pre-defined architecture component deployment solution set is a collection of multiple architecture component combination solutions, pre-designed and optimized to meet the needs of different types and scales of businesses. The target architecture component deployment solution is the solution matched from the pre-defined architecture component deployment solution set that best meets the specific pre-defined architecture deployment requirement. It specifies the specific architecture components to be used and how they are combined.

[0061] It is understandable that since manual experience is difficult to accurately grasp the complex correlation between user needs and deployment resources, the screened solutions may not meet the key indicator requirements in actual deployment, and the deployment effect is difficult to guarantee. Therefore, step S02 is performed to automatically match solutions from the preset architecture component deployment solutions. This can more accurately find the target architecture component deployment solution that matches the preset architecture deployment requirements, improve the fit between the solution and the requirements, provide strong support for solving the problem of poor deployment effect, ensure that the deployment solution can better meet user needs, and reduce the deployment risk caused by manual matching errors.

[0062] Step S03: configuring the component quantity for the target architecture component deployment solution based on the preset architecture deployment requirements to obtain a standard architecture deployment solution.

[0063] It should be noted that the system configures a reasonable quantity for each component in the target architecture component deployment plan based on the preset architecture deployment requirements, combines the configured component quantity with the target architecture component deployment plan, and generates a standard architecture deployment plan. For example, based on the business concurrency and server performance indicators, the required number of servers is calculated through the capacity planning model; based on the data storage volume and the performance parameters of the storage device, the number and capacity of the storage device are determined. The standard architecture deployment plan clearly defines the type, quantity and configuration parameters of each component in the architecture, and can be directly used for actual system architecture deployment.

[0064] It is understandable that it is difficult for humans to fully consider the impact of factors such as resource utilization and cost budget on the configuration of the architecture quantity, resulting in poor performance of the deployment plan in terms of resource utilization and cost control. Therefore, step S03 is performed to make the standard architecture deployment plan more in line with actual business needs through accurate component quantity configuration, which can effectively solve the problem of poor deployment effect in the current system architecture deployment, ensure that the system can run stably and efficiently, and ensure full utilization of system resources through reasonable component quantity configuration, avoid resource waste or shortage, and improve system performance and efficiency.

[0065] In a feasible implementation, in step S01, the step of obtaining key indicators of architecture deployment based on historical architecture deployment data includes steps A01 to A03:

[0066] Step A01: standardize the historical architecture deployment data and eliminate outliers in the historical architecture deployment data;

[0067] It should be noted that the system uses standardization methods (such as Z-score standardization, Min-Max standardization, etc.) to standardize the various factor indicators in the historical architecture deployment data, converting historical sample data of different dimensions and value ranges into data with the same scale, and uses outlier detection algorithms (such as 3sigma outlier identification, isolation forest, etc.) to detect outliers on the standardized data and exclude the detected outliers.

[0068] Step A02, calculating the correlation coefficient between each factor indicator in the historical architecture deployment data and the preset architecture component;

[0069] It should be noted that the system uses a correlation analysis algorithm to calculate the correlation coefficient between each factor indicator and the preset architecture components. The correlation coefficient is a statistic used to measure the degree of linear correlation between two variables. Among them, factor indicators refer to various data dimensions in historical sample data that can reflect the relevant characteristics of system architecture deployment, including but not limited to the number of users, the computer room they belong to, security hardware requirements, whether it is open source, the number of test environments, product types, health, number of security vulnerabilities, etc. These factor indicators describe the environment and requirements of system architecture deployment from different angles, and are the basis for correlation analysis and determining key indicators. Preset architecture components refer to a variety of system architecture types that can be selected according to customer needs and business scenarios, including but not limited to servers, middleware, databases, operating systems, etc. Different architecture types have different characteristics and applicable scenarios.

[0070] For example, Spearman correlation analysis is used to determine the relationship between the number of users, servers, middleware, and databases in historical sample data. Spearman correlation analysis calculates the correlation coefficient (degree of correlation) between two pairs of data. The calculation formula for the correlation coefficient is:

[0071]

[0072] in, is the independent variable, is the mean value of the independent variable, is the dependent variable, is the average value of the dependent variable. According to the calculation formula of the correlation coefficient, the correlation coefficient can be obtained as shown in Table 1:

[0073] Table 1

[0074]

[0075] In addition, it should be noted that before calculating the correlation coefficient between each factor indicator in the historical architecture deployment data and the preset architecture components, it is also possible to extract the requirement labels in the user requirements (such as "security", "performance", etc.), and extract the data associated with the requirement labels from the structured fields of the historical architecture deployment data as factor indicators. For example, "security" is associated with fields such as "security level" and "vulnerability repair frequency", and "security level" and "vulnerability repair frequency" are used as factor indicators for subsequent correlation coefficient calculations.

[0076] Step A03 , eliminating factor indicators with correlation coefficients less than a preset correlation threshold, and using factor indicators with correlation coefficients greater than or equal to the preset correlation threshold as key indicators of architecture deployment.

[0077] It should be noted that the calculated correlation coefficient is compared with the preset correlation threshold (for example, 0.3), and the factor indicators with a correlation coefficient less than the preset correlation threshold are eliminated, and the factor indicators with a correlation coefficient greater than or equal to the preset correlation threshold are retained. These retained factor indicators are the key indicators of the architecture deployment.

[0078] For example, it can be seen from Table 1 that when 0.3 is used as the preset correlation threshold, the number of users is an important indicator affecting the middleware, database, and server, while the server has no correlation with the middleware.

[0079] Similarly, through correlation coefficient analysis, we can also obtain factor indicators such as the computer room, security hardware requirements, whether it is open source, the number of test environments, and product types. These factor indicators also have an important impact on the architecture deployment, that is, they are also the key indicators of architecture deployment.

[0080] In this embodiment, the data of each factor indicator is converted into data with the same scale through standardization processing, eliminating the influence of the difference in dimension and value range, and after excluding outliers, the distribution of data is more in line with the actual situation, reducing noise interference and improving the quality of data. By calculating the correlation coefficient, the correlation between each factor indicator and the preset architecture component is quantified, so that the degree of correlation between them can be understood intuitively and comprehensively, avoiding the limitations of manual analysis, and ensuring a comprehensive grasp of the relationship between each indicator and the architecture. Based on the correlation coefficient, it is possible to accurately determine which factor indicators have an important impact on the architecture deployment effect, so that these key indicators can be considered as the focus during architecture design, avoiding the interference of redundant indicators, improving the adaptability and performance of the architecture, and avoiding the problem of poor deployment effect due to ignoring key factors.

[0081] In a feasible implementation manner, in step S02, before the step of matching the target architecture component deployment solution to the preset architecture deployment requirement from the preset architecture component deployment solution set, steps A11 to A12 are also included:

[0082] Step A11, configuring architecture components for each preset architecture type to obtain candidate architecture combinations;

[0083] It should be noted that, from the preset architecture database or related storage area, according to the classification standards of the preset architecture type, the information of all architecture components under each preset architecture type is retrieved and extracted. The architecture components are collected and organized in advance based on business needs, technological development and other factors, and include the mainstream architectures in the current architecture deployment plan. Any architecture component is selected from each preset architecture type, and the architecture components under the selected preset architecture types are combined to obtain various architecture combinations. At the same time, the architecture combinations with the same combination of architecture components in each architecture combination are retrieved and eliminated to prevent duplication, and various candidate architecture combinations are obtained.

[0084] Step A12: Eliminate candidate architecture combinations that do not comply with the version compatibility rules and the hardware configuration constraint matrix from the candidate architecture combinations to obtain a preset architecture component deployment solution set.

[0085] It should be noted that the system obtains version compatibility rules between various architectural components. These rules define whether the various architectural components under different architectural types can cooperate and work together. According to these rules, the system selects mutually compatible architectural combinations. At the same time, it obtains the hardware configuration constraint matrix. The configuration constraint matrix describes the requirements of architectural components under different architectural types for hardware resources (such as CPU, memory, storage, etc.). The system will determine the combination scheme of each architectural component under each architectural type that meets the version compatibility rules and the hardware configuration constraint matrix, and obtain a set of preset architectural component deployment schemes.

[0086] In addition, it should be noted that the steps of obtaining version compatibility rules between various architectural components include: obtaining the official documents of each architectural component based on a preset large language model, extracting the functional modules, interface specifications and version update instructions in the official documents, parsing to obtain the initial rules of each architectural component, performing combination tests on each architectural component under each version, recording the system performance of each architectural component under each version in different combinations, adjusting the initial rules according to the system performance, and obtaining version compatibility rules.

[0087] In addition, it should be noted that the steps of obtaining the hardware configuration constraint matrix between each architectural component include: performing performance testing on each architectural component under different hardware configuration environments, analyzing the hardware resource indicators of each architectural component under different hardware configuration environments, and constructing a hardware configuration constraint matrix with each architectural component as a row and hardware resource indicators as a column. Each element in the hardware configuration constraint matrix represents the hardware resource indicator of the corresponding architectural component.

[0088] In addition, it should be noted that, based on comprehensive consideration of version compatibility rules and hardware configuration constraint matrix, the system interactively combines the architectural components under each architecture type, tries different combinations, and evaluates whether each combination meets the version compatibility and hardware configuration requirements, and finally obtains a series of feasible architectural combinations, namely, a set of preset architectural component deployment solutions.

[0089] For example, as shown in Table 2, there are four architecture types, namely, server, middleware, database and operating system. Each architecture type includes various architecture components, among which there are 3 types of servers, 2 types of middleware, 3 types of databases and 3 types of operating systems. The interactive combination of architecture components under each architecture type, such as "first server + second middleware + third database + first operating system", etc., can obtain a total of 54 architecture combinations, that is, the preset architecture component deployment plan includes 54 deployment plans.

[0090] Table 2

[0091]

[0092] In this embodiment, by obtaining the version compatibility rules between each architecture type, the compatibility between different architecture versions can be automatically checked when combining architectures, avoiding system errors caused by version incompatibility, and improving the stability and reliability of the system. When combining architectures, based on the currently available hardware resources and combined with the hardware configuration constraint matrix, the architecture combination that meets the hardware configuration requirements is screened out to ensure that the system can operate normally and perform as expected. By comprehensively considering the version compatibility rules and the hardware configuration constraint matrix, the architecture components under each architecture type are interactively combined, which can systematically explore all possible combinations, effectively avoid unreasonable problems caused by manual combination, and improve the effect of system architecture deployment.

[0093] In a feasible implementation, in step S02, the step of matching the target architecture component deployment solution to the preset architecture deployment requirement from the preset architecture component deployment solution set includes steps A21 to A22:

[0094] Step A21: extracting historical customer needs associated with the preset architecture deployment needs from the historical architecture deployment data, and determining preset architecture component deployment solutions corresponding to the historical customer needs in the preset architecture component deployment solution set as candidate architecture component deployment solutions;

[0095] It should be noted that the system performs in-depth scanning and analysis of stored historical architecture deployment data. Using natural language processing techniques (such as keyword extraction and semantic analysis) and association rule mining algorithms, the system identifies historical customer requirements from the historical architecture deployment data that meet a similarity threshold (e.g., 80%) with the current preset architecture deployment requirements. Historical customer requirements refer to specific requirements regarding system performance, functionality, scale, security, etc. proposed by customers during past system architecture deployments. These requirements cover the characteristics and patterns of architecture deployment requirements of various types of customers, as well as their specific requirements for key indicators. For example, if the preset architecture deployment requirement is for a high-concurrency, large-data-volume e-commerce platform system, the system will identify customer requirements for similar e-commerce platform systems deployed in the past from the historical architecture deployment data, such as requirements for system response time, data storage capacity, and concurrent user processing capabilities. Based on these historical customer requirements, the system matches and searches the preset architecture component deployment solutions. By comparing the historical customer requirements with the applicable demand scenarios of each solution in the preset architecture component deployment solution set, the system identifies the preset architecture component deployment solutions that can meet these historical customer requirements and selects these solutions as candidate architecture component deployment solutions.

[0096] In step A22, based on the industry trend requirements in the preset industry trend database, the candidate architecture component deployment solutions that meet the industry trend requirements are screened as the target architecture component deployment solution.

[0097] It should be noted that the system accesses a preset industry trend database, which stores industry trend information related to system architecture deployment, obtained from industry reports and technical forums. This database identifies development trends in the field of system architecture deployment, such as emerging technology application trends (e.g., the application of artificial intelligence, blockchain, and edge computing in system architecture), and market demand trends (e.g., increasing requirements for system security, scalability, and green energy conservation). These industry trend requirements are then converted into specific quantitative indicators or qualitative requirements. The system then evaluates each candidate architecture component deployment solution obtained in step A21, analyzing whether the components and technologies employed in each solution align with current industry trend requirements. For example, the system examines whether the solution incorporates emerging components and technologies that can improve system performance or meet specific requirements (e.g., large AI models), and whether it meets the latest industry requirements for system security and scalability. The system then selects candidate architecture component deployment solutions that meet these industry trend requirements as the final target architecture component deployment solution.

[0098] For example, as shown in Table 3, the key indicators include the number of users, the computer room they belong to, security hardware requirements, whether it is open source, the number of test environments, and the product type. Each key indicator includes various indicator parameters, among which the number of users includes 4 types, the computer room they belong to includes 2 types, the security hardware requirements include 4 types, whether it is open source includes 2 types, the number of test environments includes 3 types, and the product type includes 2 types, but they are not included in the number of parameters. The interactive combination of indicator parameters under each key indicator can obtain a total of 192 architecture combinations, that is, there are 192 target architecture component deployment plans.

[0099] Table 3

[0100]

[0101] In this embodiment, by extracting historical customer needs associated with preset architecture deployment requirements from historical architecture deployment data and determining the corresponding preset architecture component deployment plan, past successful experiences can be accurately matched with current needs, which helps to improve the accuracy of plan matching and avoid unreasonable deployment plans due to lack of historical experience reference, thereby improving deployment effects. By considering industry trends, it can ensure that the generated target architecture component deployment plan is in line with the development direction of the industry, not only meeting current needs, but also having a certain degree of foresight, and being able to adapt to industry development changes over a longer period of time, reducing the cost of plan adjustment due to industry changes, and improving deployment effects.

[0102] In a feasible implementation, in step S03, the step of configuring the number of components for the target architecture component deployment solution based on the preset architecture deployment requirements includes steps A31 to A32:

[0103] Step A31: determining quantitative indicators among key indicators under the preset architecture deployment requirements, and determining coefficient relationships between the quantitative indicators and the various architecture components using a logistic regression algorithm;

[0104] It should be noted that the system screens each key indicator and selects indicators that can be measured with specific numerical values, namely quantitative indicators, including but not limited to the number of users, the number of test environments, etc. Quantitative variables such as the number of users and the number of test environments will directly affect the number of each type in the deployment architecture combination. Therefore, after the system determines the quantitative indicators, it uses the logistic regression algorithm to determine the relationship between these indicators and each architectural component to predict the number of architectural components required for these indicators. The logistic regression algorithm is a statistical learning method used to solve binary or multi-classification problems. It uses quantitative indicators as independent variables and the number of each architectural component as the dependent variable. Through the calculation and training of the algorithm, the coefficients between each quantitative indicator and each architectural component and the relationship between the constant terms are obtained. These coefficient relationships reflect the degree and direction of the influence of the quantitative indicators on the deployment decisions of each architectural component.

[0105] For example, the coefficient relationship between the number of servers y, the number of users x1, the number of test environments x2, and the constant term is obtained by a logistic regression algorithm, as shown in Table 4:

[0106] Table 4

[0107]

[0108] The significance levels are all less than 0.05, indicating that the results are significant at the horizontal level. Therefore, the calculation results are valid. The constant term corresponds to -0.45, the number of users x1 is 0.02, and the number of test environments x2 is 0.67. Similarly, the number of architectural components such as middleware and databases can be obtained, but we will not elaborate on this here.

[0109] Step A32: obtaining a prediction model between the quantitative indicators and each architectural component based on the coefficient relationship, and determining the corresponding quantity of each architectural component in the target architectural component deployment plan according to the prediction model.

[0110] It should be noted that a prediction model is constructed based on the coefficient relationship between the quantitative indicators obtained in step A31 and each architectural component. The prediction model is a mathematical expression. For example, for the calculation results in Table 4, the constant term corresponds to -0.45, the number of users x1 is 0.02, and the number of test environments x2 is 0.67. The prediction model can be obtained as y=-0.45+0.02x1+0.67x2. The system uses the constructed prediction model to predict the number of each architectural component and rounds the predicted value to obtain the corresponding number of each architectural component.

[0111] For example, Table 5 is a deployment scheme in the standard architecture deployment scheme, wherein the architecture types include servers, networks, operating systems, databases, and middleware, and the architecture components correspondingly include a first server, a second gateway, a third operating system, a second database, and a first middleware. According to the prediction model, 7 first servers are required, 1 second gateway is required, 3 third operating systems are required, 3 second databases are required, and 1 first middleware is required.

[0112] Table 5

[0113]

[0114] In this embodiment, by determining the quantitative indicators in each key indicator, the originally vague and difficult to measure key factors are converted into quantifiable and analyzable data, and the logistic regression algorithm is used to determine the coefficient relationship between the quantitative indicators and each architectural component, which clearly reveals the degree of influence of each quantitative indicator on different architectural components. Based on the obtained coefficient relationship, a prediction model is constructed, which can scientifically predict the reasonable number of each architectural component according to the current quantitative indicator data, greatly shortening the deployment decision-making time and improving deployment efficiency. At the same time, the reasonable allocation of the number of architectures enables full utilization of system resources, reduces resource waste, improves the overall performance and response speed of the system, significantly improves the deployment effect, and solves the problem of poor deployment effect in traditional deployment methods.

[0115] Based on the first embodiment of the present application, in the second embodiment of the present application, the same or similar contents as those in the above embodiment 1 can be referred to the above introduction and will not be described in detail later. Figure 2 In step S03, after obtaining the standard architecture deployment solution, steps S11 to S12 are also included:

[0116] Step S11: If the user does not input a deployment combination, the user requirements input by the user are parsed, and a target architecture deployment solution that meets the user requirements is searched among various standard architecture deployment solutions, wherein each standard architecture deployment solution is obtained by traversing various preset architecture deployment requirements;

[0117] It should be noted that when the system detects that the user has not entered a deployment combination method, it uses natural language processing technology to parse the user requirements entered by the user, extract the requirements corresponding to each architectural component, and search and match among the standard architecture deployment solutions to find a solution that meets the user's requirements, that is, the target architecture deployment solution.

[0118] For example, to help understand the technical concept or technical principle of this application, please refer to Figure 3 , Figure 3A scenario diagram of the deployment plan generator is provided, which includes two modules: M1 and M2. M1 includes specific user needs, among which "purchase product" indicates the product type selected by the user, specifically an investment-return type product. It also limits the number of users to 100, the computer room to a local computer room, no security hardware requirements, one test environment, and the required completion time to June 20, 2025. Users can choose whether to open source, including open source and independent controllable and closed source. Here the user chooses closed source. After considering the above user needs, the target architecture deployment plan will be output in the M2 part, which includes resource selection. Specifically, the system recommends the fourth operating system as the operating system, the fifth database as the database, the seventh middleware as the middleware, and the fifth server as the server.

[0119] In addition, it should be noted that the system can also receive the priority selected by the user and evaluate the cost, security level score and hardware configuration redundancy of each plan in each standard architecture deployment plan, where the priorities include cost-effectiveness priority, security priority and performance priority; when the user selects cost-effectiveness priority, the system will search for a plan in each standard architecture deployment plan that meets the user's needs and has a cost lower than the industry average as the target architecture deployment plan; when the user selects security priority, the system will search for a plan in each standard architecture deployment plan that meets the user's needs and has a security level score higher than the preset level score (for example, 80 points) as the target architecture deployment plan; when the user selects performance priority, the system will search for a plan in each standard architecture deployment plan that meets the user's needs and has a hardware configuration redundancy higher than the preset redundancy threshold (for example, 20%) as the target architecture deployment plan.

[0120] Step S12: When the user inputs a deployment combination mode, a target architecture deployment solution is constructed based on the deployment combination mode.

[0121] It should be noted that when the system detects that the user has entered a deployment combination method, it parses the deployment combination method to determine the user's requirements for the combination form, connection relationship, and resource allocation ratio of each architectural component. Based on the parsed deployment combination method, the system selects the corresponding architectural components from the architectural resource pool, assembles and configures them according to the combination form required by the user, and constructs the target architecture deployment plan.

[0122] In this embodiment, by parsing the user needs input by the user, the system can convert the user's vague, natural language expressions into analyzable and processable data and information. According to the parsed user needs, it can quickly screen and match the existing deployment plans to find the plan that best meets the user needs. This not only improves the speed at which the system responds to user needs, but also ensures that the deployment plan provided to the user is highly consistent with the user needs, avoiding the problem of poor deployment effect due to mismatch of needs, improving user satisfaction and deployment quality, and constructing the target architecture deployment plan based on the deployment combination method input by the user, so that the system can fully meet the user's personalized needs. Users can freely combine different architectures according to their own business characteristics, technical preferences and other factors, which greatly enhances the flexibility and adaptability of the system and effectively improves the overall effect of system architecture deployment.

[0123] In a feasible implementation, the architecture deployment solution generation method further includes steps B01 to B04:

[0124] Step B01, generating a user demand list according to user demand;

[0125] It should be noted that the user requirements list is the result of systematically organizing and recording user requirements. It presents key information of user requirements in a structured manner for subsequent processing and analysis. It records customer information (including but not limited to the customer's detailed name and region) and product information (including but not limited to the product type required by the user, the corresponding requirements of each key indicator, and the recommended architecture deployment plan).

[0126] Step B02: Generate a deployment plan list based on the target architecture deployment plan;

[0127] It should be noted that the deployment plan list records in detail the various architectural components, quantities, software versions, deployment methods, and other information involved in the target architecture deployment plan, covering the deployment combination methods and the predicted corresponding quantities of each architectural component, providing specific guidance for actual deployment operations.

[0128] Step B03: Generate a server list based on the server configuration in the target architecture deployment plan;

[0129] It should be noted that server configuration refers to the hardware and software parameters specified for each server in the target architecture deployment plan. The server list is a summary and record of these server configuration information. It includes the server name, IP address, hardware specifications (such as CPU model, memory size, hard disk capacity), operating system version and other information. It is the server configuration details actually selected by the user.

[0130] Step B04: Generate a deployment plan based on the expected deployment completion time of the target architecture deployment solution.

[0131] It should be noted that the expected deployment completion time is the user's expectation of the time it takes to complete the system architecture deployment. The deployment plan breaks down the entire deployment process into multiple specific tasks based on factors such as the complexity of the target architecture deployment plan, resource availability, and task dependencies, and allocates reasonable time and resources to each task to achieve the goal of the expected deployment completion time.

[0132] In this embodiment, by generating a user requirement list, a clear benchmark is provided for requirement changes. When a user proposes a requirement change, the user can easily find the relevant requirement in the list and clarify the specific content and scope of the change, which helps to better manage requirement changes and improve the flexibility and effectiveness of deployment. By generating a deployment plan list, the user can fully understand the specific content of the deployment plan, ensuring that important information is not missed during the implementation process, and improving the accuracy and completeness of the deployment. By generating a server list, the server configuration information in the target architecture deployment plan is systematically organized, and the user can fully grasp the hardware and software information of the server, ensure compatibility and stability between servers, and reduce system failures caused by configuration problems. A deployment plan is generated according to the expected deployment completion time, and a detailed timetable is formulated for the entire deployment project, which helps the development team to monitor and adjust the deployment progress in real time, ensure that the project can be completed on time, and improve the controllability and efficiency of the deployment.

[0133] It should be noted that the above examples are only used to understand this application and do not constitute a limitation on the method for generating the architecture deployment solution of this application. More simple transformations based on this technical concept are all within the scope of protection of this application.

[0134] This application also provides a system for generating architecture deployment solutions. Please refer to Figure 4 , the architecture deployment solution generation system includes:

[0135] A requirement determination module 10 is configured to filter and obtain key indicators of architecture deployment based on historical architecture deployment data, and generate preset architecture deployment requirements based on the key indicators;

[0136] A solution matching module 20 is configured to match a target architecture component deployment solution from a set of preset architecture component deployment solutions for any one of the preset architecture deployment requirements;

[0137] The quantity deployment module 30 is used to configure the component quantity for the target architecture component deployment plan based on the preset architecture deployment requirements to obtain a standard architecture deployment plan.

[0138] Optionally, the demand determination module 10 is further configured to:

[0139] Standardize historical architecture deployment data and exclude outliers in the historical architecture deployment data;

[0140] Calculate the correlation coefficient between each factor indicator in the historical architecture deployment data and the preset architecture components;

[0141] Eliminate factor indicators with correlation coefficients less than the preset correlation threshold, and use factor indicators with correlation coefficients greater than or equal to the preset correlation threshold as key indicators of architecture deployment.

[0142] Optionally, the solution matching module 20 is further configured to:

[0143] Configuring architecture components for each preset architecture type to obtain candidate architecture combinations;

[0144] Eliminate candidate architecture combinations that do not comply with the version compatibility rules and the hardware configuration constraint matrix from each candidate architecture combination to obtain a set of preset architecture component deployment solutions.

[0145] Optionally, the solution matching module 20 is further configured to:

[0146] Extracting historical customer needs associated with preset architecture deployment needs from historical architecture deployment data, and determining preset architecture component deployment solutions corresponding to the historical customer needs in the preset architecture component deployment solution set as candidate architecture component deployment solutions;

[0147] In combination with the industry trend requirements in the preset industry trend database, the candidate architecture component deployment plans that meet the industry trend requirements are screened as the target architecture component deployment plans.

[0148] Optionally, the quantity deployment module 30 is further configured to:

[0149] Determine the quantitative indicators of each key indicator under the preset architecture deployment requirements, and use the logistic regression algorithm to determine the coefficient relationship between the quantitative indicators and each architecture component;

[0150] Based on the coefficient relationship, a prediction model between the quantitative indicators and each architectural component is obtained, and the corresponding quantity of each architectural component in the target architectural component deployment plan is determined according to the prediction model.

[0151] Optionally, the architecture deployment solution generation system further includes a target solution confirmation module 40, which is configured to:

[0152] If the user does not input a deployment combination method, the user requirements input by the user are parsed, and a target architecture deployment solution that meets the user requirements is searched among various standard architecture deployment solutions, wherein each standard architecture deployment solution is obtained by traversing various preset architecture deployment requirements;

[0153] When the user inputs a deployment combination mode, a target architecture deployment plan is constructed based on the deployment combination mode.

[0154] Optionally, the architecture deployment solution generation system further includes a checklist generation module 50, which is configured to:

[0155] Generate a user requirements list based on user needs;

[0156] Generate a deployment plan list based on the target architecture deployment plan;

[0157] Generate a server list based on the server configuration in the target architecture deployment plan;

[0158] Generate a deployment plan based on the expected deployment completion time for the target architecture deployment scenario.

[0159] The architecture deployment solution generation system provided in this application utilizes the architecture deployment solution generation method described in the aforementioned embodiments to address the technical issue of poor deployment performance in current system architecture deployment. Compared to the prior art, the architecture deployment solution generation system provided in this application offers the same beneficial effects as the architecture deployment solution generation method described in the aforementioned embodiments. Other technical features of the architecture deployment solution generation system are the same as those disclosed in the aforementioned embodiments, and are not further elaborated upon here.

[0160] The present application provides an electronic device, which includes: at least one processor; and a memory communicatively connected to the at least one processor; wherein the memory stores instructions that can be executed by the at least one processor, and the instructions are executed by the at least one processor to enable the at least one processor to execute the architecture deployment solution generation method in the above-mentioned embodiment one.

[0161] Reference below Figure 5 , which shows a schematic diagram of the structure of an electronic device suitable for implementing the embodiments of the present application. The electronic devices in the embodiments of the present application may include, but are not limited to, mobile terminals such as mobile phones, laptop computers, PADs (Portable Application Description: tablet computers), and fixed terminals such as digital TVs and desktop computers. Figure 5 The electronic device shown is merely an example and should not limit the functions and scope of use of the embodiments of the present application.

[0162] like Figure 5As shown, the electronic device may include a processing device 1001 (e.g., a central processing unit, a graphics processing unit, etc.), which can perform various appropriate actions and processes based on programs stored in a read-only memory 1002 or programs loaded from a storage device 1003 into a random access memory 1004. The random access memory 1004 also stores various programs and data required for the operation of the electronic device. The processing device 1001, the read-only memory 1002, and the random access memory 1004 are interconnected via a bus 1005. An input / output interface 1006 is also connected to the bus. Typically, the following systems may be connected to the input / output interface 1006: an input device 1007 including, for example, a touchscreen, touchpad, keyboard, mouse, image sensor, microphone, accelerometer, gyroscope, etc.; an output device 1008 including, for example, a liquid crystal display (LCD), speaker, vibrator, etc.; a storage device 1003 including, for example, a magnetic tape or hard disk; and a communication device 1009. The communication device 1009 may allow the electronic device to communicate with other devices wirelessly or wired to exchange data. Although the figures show electronic devices with various systems, it should be understood that it is not required to implement or have all the systems shown. More or fewer systems may be implemented or have instead.

[0163] In particular, according to the embodiments disclosed in the present application, the processes described above with reference to the flowcharts can be implemented as computer software programs. For example, the embodiments disclosed in the present application include a computer program product comprising a computer program carried on a computer-readable medium, the computer program comprising program code for executing the method shown in the flowchart. In such an embodiment, the computer program can be downloaded and installed from a network via a communication device, or installed from a storage device 1003, or installed from a read-only memory 1002. When the computer program is executed by the processing device 1001, the above-mentioned functions defined in the method of the embodiment disclosed in the present application are performed.

[0164] The electronic device provided in this application, using the architecture deployment solution generation method in the above-mentioned embodiment, can solve the technical problem of poor deployment effects in current system architecture deployment. Compared with the prior art, the beneficial effects of the electronic device provided in this application are the same as those of the architecture deployment solution generation method provided in the above-mentioned embodiment, and the other technical features of the electronic device are the same as those disclosed in the method of the above-mentioned embodiment, and are not further described here.

[0165] It should be understood that the various parts disclosed in this application can be implemented using hardware, software, firmware, or a combination thereof. In the description of the above embodiments, specific features, structures, materials, or characteristics can be combined in any one or more embodiments or examples in a suitable manner.

[0166] The above description is merely a specific embodiment of the present application, but the scope of protection of the present application is not limited thereto. Any changes or substitutions that can be easily conceived by a person skilled in the art within the technical scope disclosed in this application should be included in the scope of protection of the present application. Therefore, the scope of protection of the present application should be based on the scope of protection of the claims.

[0167] The present application provides a computer-readable storage medium having computer-readable program instructions (ie, a computer program) stored thereon, and the computer-readable program instructions are used to execute the architecture deployment solution generation method in the above-mentioned embodiment.

[0168] The computer-readable storage medium provided in this application may be, for example, a USB flash drive, but is not limited to electrical, magnetic, optical, electromagnetic, infrared, or semiconductor systems or devices, or any combination thereof. More specific examples of computer-readable storage media may include, but are not limited to: an electrical connection with one or more wires, a portable computer disk, a hard disk, random access memory (RAM), read-only memory (ROM), erasable programmable read-only memory (EPROM or flash memory), optical fiber, a portable compact disk read-only memory (CD-ROM), an optical storage device, a magnetic storage device, or any suitable combination thereof. In this embodiment, the computer-readable storage medium may be any tangible medium that contains or stores a program that can be used by or in conjunction with an instruction execution system or device. The program code contained on the computer-readable storage medium may be transmitted using any suitable medium, including but not limited to: wires, optical cables, RF (Radio Frequency), etc., or any suitable combination thereof.

[0169] The computer-readable storage medium may be included in the electronic device, or may exist independently without being incorporated into the electronic device.

[0170] The above-mentioned computer-readable storage medium carries one or more programs. When the above-mentioned one or more programs are executed by an electronic device, the architecture deployment solution generation device: obtains key indicators of architecture deployment based on historical architecture deployment data, and generates preset architecture deployment requirements based on each key indicator; for any one of the preset architecture deployment requirements, matches the preset architecture deployment requirement with a target architecture component deployment solution from the preset architecture component deployment solution set; configures the number of components for the target architecture component deployment solution based on the preset architecture deployment requirement to obtain a standard architecture deployment solution.

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

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

[0173] The modules described in the embodiments of the present application may be implemented in software or hardware, wherein the name of a module does not necessarily limit the unit itself.

[0174] The computer-readable storage medium provided in this application stores computer-readable program instructions (i.e., a computer program) for executing the aforementioned method for generating an architecture deployment solution. This computer-readable storage medium can address the technical issue of poor deployment performance in current system architecture deployments. Compared to the prior art, the beneficial effects of the computer-readable storage medium provided in this application are similar to those of the architecture deployment solution generation method provided in the aforementioned embodiments, and are not further elaborated here.

[0175] The present application also provides a computer program product, including a computer program, which implements the steps of the above-mentioned architecture deployment solution generation method when executed by a processor.

[0176] The computer program product provided in this application can solve the technical problem of poor deployment effects in current system architecture deployment. Compared with the prior art, the beneficial effects of the computer program product provided in this application are the same as the beneficial effects of the architecture deployment solution generation method provided in the above embodiment, and will not be repeated here.

[0177] The above description is only part of the embodiments of the present application and does not limit the patent scope of the present application. All equivalent structural transformations made by using the contents of the present application specification and drawings under the technical concept of the present application, or direct / indirect application in other related technical fields are included in the patent protection scope of the present application.

Claims

1. A method for generating an architecture deployment solution, characterized in that: The architecture deployment solution generation method includes: Based on correlation analysis, historical architecture deployment data is screened to obtain key indicators of architecture deployment, and indicator parameters under the key indicators are arranged and combined to obtain requirement combinations, and repeated combinations in the requirement combinations are eliminated to generate preset architecture deployment requirements; For any one of the preset architecture deployment requirements, matching a target architecture component deployment solution for the preset architecture deployment requirement from a set of preset architecture component deployment solutions; Based on the preset architecture deployment requirements, the number of components for each architecture component in the target architecture component deployment solution is configured to obtain a standard architecture deployment solution, wherein the step of configuring the number of components for each architecture component in the target architecture component deployment solution based on the preset architecture deployment requirements includes: Determine a quantitative indicator among the key indicators under the preset architecture deployment requirements, and determine a coefficient relationship between the quantitative indicator and each architecture component through a logistic regression algorithm; Obtaining a prediction model between the quantitative indicator and each of the architecture components based on the coefficient relationship, and determining a corresponding quantity of each of the architecture components in the target architecture component deployment solution according to the prediction model; The step of filtering historical architecture deployment data based on correlation analysis to obtain key indicators of architecture deployment includes: Standardizing historical architecture deployment data and eliminating outliers in the historical architecture deployment data; Calculating the correlation coefficient between each element indicator in the historical architecture deployment data and the preset architecture components; The factor indicators whose correlation coefficients are less than the preset correlation threshold are eliminated, and the factor indicators whose correlation coefficients are greater than or equal to the preset correlation threshold are used as the key indicators of the architecture deployment.

2. The method for generating an architecture deployment solution according to claim 1, wherein: Before the step of matching the target architecture component deployment solution to the preset architecture deployment requirement from the preset architecture component deployment solution set, the following step is also included: Configuring architecture components for each preset architecture type to obtain candidate architecture combinations; Eliminate candidate architecture combinations that do not comply with the version compatibility rules and the hardware configuration constraint matrix from the candidate architecture combinations to obtain a preset architecture component deployment solution set.

3. The method for generating an architecture deployment solution according to claim 1, wherein: The step of matching the target architecture component deployment solution to the preset architecture deployment requirement from the preset architecture component deployment solution set includes: Extracting historical customer needs associated with the preset architecture deployment needs from the historical architecture deployment data, and determining preset architecture component deployment solutions corresponding to the historical customer needs in the preset architecture component deployment solution set as candidate architecture component deployment solutions; In combination with the industry trend requirements in the preset industry trend database, the candidate architecture component deployment solutions that meet the industry trend requirements are screened from the candidate architecture component deployment solutions as the target architecture component deployment solution.

4. The method for generating an architecture deployment solution according to claim 1, wherein: The step of obtaining the standard architecture deployment solution further includes: If the user does not input a deployment combination mode, the user requirements input by the user are parsed, and a target architecture deployment solution that meets the user requirements is searched for in each standard architecture deployment solution, wherein each standard architecture deployment solution is obtained by traversing each preset architecture deployment requirement; In the case where the user inputs a deployment combination method, a target architecture deployment solution is constructed based on the deployment combination method.

5. The method for generating an architecture deployment solution according to claim 4, wherein: The architecture deployment solution generation method further includes: generating a user demand list according to the user demand; Generate a deployment plan list according to the target architecture deployment plan; Generate a server list based on the server configuration in the target architecture deployment plan; A deployment plan is generated according to the expected deployment completion time of the target architecture deployment solution.

6. An electronic device, characterized in that: The device includes: a memory, a processor, and a computer program stored in the memory and executable on the processor, wherein the computer program is configured to implement the steps of the architecture deployment solution generation method according to any one of claims 1 to 5.

7. A storage medium, characterized in that: The storage medium is a computer-readable storage medium, and a computer program is stored on the storage medium. When the computer program is executed by a processor, the steps of the architecture deployment solution generation method according to any one of claims 1 to 5 are implemented.

8. A computer program product, characterized in that The computer program product includes a computer program, and when the computer program is executed by a processor, the steps of the architecture deployment solution generation method according to any one of claims 1 to 5 are implemented.

Images