Automatic deployment method, device and equipment based on intelligent scheduling and storage medium

Abstract

According to the automatic deployment method and device based on intelligent scheduling, the equipment and the storage medium provided by the invention, the code file is sent to the version control system through the integrated development environment, so that the version control system checks the code file; receiving an audited code file sent by the version control system; constructing a mirror image file according to the code file passing the auditing; determining a test address of the mirror image file according to a resource use condition; testing the mirror image file at a test address; and starting the container in the target production environment to deploy the mirror image file passing the test. Through automatic code auditing, mirror image construction and resource scheduling, the time and workload of manual operation are remarkably reduced, and the efficiency of the whole deployment process is improved. Moreover, by monitoring the resource use condition of the nodes in real time, the resources can be effectively allocated through intelligent scheduling, and the application is ensured to run in the optimal environment, so that the performance and the response speed of the application are improved.

Description

Technical Field

[0001] The present invention relates to the field of software development technology, and in particular to an automated deployment method, device, equipment and storage medium based on intelligent scheduling. Background Art

[0002] In the modern software development process, as the complexity of applications increases, automated deployment has become an important means to improve development efficiency and reduce error rates. Traditional deployment methods often rely on manual operations and have many problems, such as operation errors, inconsistent environments, and long deployment times. These problems not only affect the work efficiency of the team, but also have a negative impact on the stability of the software and user experience.

[0003] In order to solve these problems, the concepts of continuous integration (CI) and continuous delivery (CD) have been gradually introduced to achieve more efficient software development by automating the build, test and deployment processes. Although some tools and methods have been able to achieve a certain degree of automation, there is still room for optimization in code review, resource scheduling and image management.

[0004] In summary, the problems existing in the prior art need to be solved urgently. Summary of the invention

[0005] The present invention provides an automated deployment method, device, equipment and storage medium based on intelligent scheduling, which are used to solve the defects in the prior art and improve the efficiency of the deployment process.

[0006] The present invention provides an automatic deployment method based on intelligent scheduling, comprising:

[0007] Sending the code file to a version control system through an integrated development environment so that the version control system can review the code file;

[0008] Receiving the reviewed code file sent by the version control system;

[0009] Build the image file based on the reviewed code file;

[0010] Determine the test address of the image file according to resource usage;

[0011] Testing the image file at the test address;

[0012] Start the container in the target production environment to deploy the image file that passed the test.

[0013] According to an automatic deployment method based on intelligent scheduling provided by the present invention, the version control system reviews the code file, specifically including:

[0014] Automatically review the code file using a static code analysis tool to obtain a static review result;

[0015] Receiving manual review results, where the manual review results are obtained through review feedback from reviewers;

[0016] A target audit result of the code file is determined based on the static audit result and the manual audit result.

[0017] According to an automated deployment method based on intelligent scheduling provided by the present invention, the step of building an image file according to the audited code file specifically includes:

[0018] Pull the reviewed code files through the automated server to build the project;

[0019] Compile the reviewed code files to generate executable files;

[0020] performing unit testing on the executable file;

[0021] The executable files that pass the test are packaged to obtain the image file.

[0022] According to an automatic deployment method based on intelligent scheduling provided by the present invention, the step of determining the test address of the image file according to resource usage specifically includes:

[0023] Monitoring resource usage of the node, wherein the resource usage includes the current load of the node, available resources, and network topology;

[0024] According to the resource request of the container required by the image file, a matching test address is determined.

[0025] According to an automatic deployment method based on intelligent scheduling provided by the present invention, the step of testing the image file at the test address includes:

[0026] The automation server is controlled to trigger a container management platform through an API, so that the container management platform downloads and starts the image file at the test address.

[0027] According to an automatic deployment method based on intelligent scheduling provided by the present invention, after the step of starting a container in a target production environment to deploy a tested image file, the method further includes:

[0028] The image file is uploaded to the version control system for semantic version control.

[0029] According to an automatic deployment method based on intelligent scheduling provided by the present invention, after the step of starting a container in a target production environment to deploy a tested image file, the method further includes:

[0030] Obtain user feedback data through log analysis and user behavior tracking, wherein the user feedback data includes application usage, function requests, and user opinions;

[0031] User demand feedback is generated according to the user feedback data.

[0032] The present invention also provides an automatic deployment device based on intelligent scheduling, comprising:

[0033] A code forwarding module, used to send the code file to the version control system through the integrated development environment, so that the version control system can review the code file;

[0034] A code receiving module, used to receive the approved code files sent by the version control system;

[0035] The image building module is used to build image files based on the audited code files;

[0036] A resource scheduling module, used to determine the test address of the image file according to resource usage;

[0037] An image testing module, used for testing the image file at the test address;

[0038] The image deployment module is used to start the container in the target production environment to deploy the image file that has passed the test.

[0039] The present invention also provides an electronic device, comprising a memory, a processor, and a computer program stored in the memory and executable on the processor, wherein when the processor executes the program, an automated deployment method based on intelligent scheduling as described above is implemented.

[0040] The present invention also provides a non-transitory computer-readable storage medium having a computer program stored thereon, and when the computer program is executed by a processor, the automatic deployment method based on intelligent scheduling as described in any one of the above is implemented.

[0041] The present invention also provides a computer program product, including a computer program, which, when executed by a processor, implements any of the above-mentioned automated deployment methods based on intelligent scheduling.

[0042] The automated deployment method, device, equipment and storage medium based on intelligent scheduling provided by the present invention send code files to a version control system through an integrated development environment so that the version control system can review the code files; receive code files that have passed the review sent by the version control system; build image files based on the code files that have passed the review; determine the test address of the image file based on resource usage; test the image file at the test address; start a container in the target production environment to deploy the image file that has passed the test. The present invention significantly reduces the time and workload of manual operations through automated code review, image building and resource scheduling, and improves the efficiency of the entire deployment process. In addition, by real-time monitoring of node resource usage, intelligent scheduling can effectively allocate resources to ensure that the application runs in the optimal environment, thereby improving the performance and response speed of the application. BRIEF DESCRIPTION OF THE DRAWINGS

[0043] In order to more clearly illustrate the technical solutions in the present invention or the prior art, the following briefly introduces the drawings required for use in the embodiments or the description of the prior art. Obviously, the drawings described below are some embodiments of the present invention. For ordinary technicians in this field, other drawings can be obtained based on these drawings without paying creative work.

[0044] Figure 1 It is a flow chart of the automatic deployment method based on intelligent scheduling provided by the present invention;

[0045] Figure 2 It is a structural schematic diagram of an automatic deployment device based on intelligent scheduling provided by the present invention;

[0046] Figure 3 It is a structural schematic diagram of the electronic device provided by the present invention. DETAILED DESCRIPTION

[0047] In order to make the purpose, technical solution and advantages of the present invention clearer, the technical solution of the present invention will be clearly and completely described below in conjunction with the drawings of the present invention. Obviously, the described embodiments are part of the embodiments of the present invention, not all of the embodiments. Based on the embodiments of the present invention, all other embodiments obtained by ordinary technicians in this field without creative work are within the scope of protection of the present invention.

[0048] In order to solve the problems in the prior art, the present invention proposes an automatic deployment method based on intelligent scheduling to improve the efficiency of the deployment process. The automatic deployment method based on intelligent scheduling is described below. Figure 1 As shown, including but not limited to the following steps:

[0049] Step 110: Send the code file to the version control system through the integrated development environment, so that the version control system can review the code file.

[0050] In this step, developers use the integrated development environment (IDE) to select the code files to be submitted and use version control tools (such as Git) to submit the code files to the version control system (such as GitLab, GitHub, etc.). The system will receive the submission request and generate a unique submission record for the code file, recording the developer's information and submission time. This process ensures that the version of the code file is traceable, providing a basis for subsequent review.

[0051] Step 120: Receive the reviewed code file sent by the version control system.

[0052] Once the version control system completes the review of the code files, the system will feedback the review results to the developer. The review process may include static code analysis, unit testing, and manual review. The code files that pass the review will be sent back to the integrated development environment through the version control system, and the developer can view the review results locally and confirm that the code files have passed the review.

[0053] Step 130: Build an image file based on the audited code file.

[0054] In this step, the automation server (such as Jenkins) will automatically pull the code files that have passed the review and execute the build process. This process includes the following sub-steps:

[0055] Compile the code file to generate an executable file.

[0056] Run unit tests to ensure that the generated executable functions as expected.

[0057] Package the tested executable files into image files (such as Docker images) and store them in the image repository for subsequent deployment.

[0058] Step 140: Determine the test address of the image file according to resource usage.

[0059] During this process, the system monitors the resource usage of each node in the cluster, including the current load, available resources, and network topology. Based on the resource requests of the container required by the image file, the system dynamically evaluates and selects a suitable test address. The selection of the test address ensures that the container can run in an environment with sufficient resources and good network connectivity.

[0060] Step 150: Test the image file at the test address.

[0061] After the test address is determined, the automation server triggers the container management platform (such as Rancher) through the API to download and start the image file at the test address. The system automatically runs the preset test cases to verify the functions and performance of the image file and monitor the health status of the container. The test results will be recorded and fed back to the development team for subsequent analysis and correction.

[0062] Step 160: Start the container in the target production environment to deploy the image file that has passed the test.

[0063] The tested image file will be uploaded to the target production environment. In this step, the container management platform starts the container in the production environment according to the configured scheduling strategy. The system automatically adjusts the number of container copies to adapt to actual traffic requirements, and implements monitoring and log analysis to ensure high availability and stability of the application. In addition, the system can store the version information of the image file in the version control system to support subsequent version management and rollback operations.

[0064] As a further optional embodiment, the version control system reviews the code file, specifically including:

[0065] Automatically review the code file using a static code analysis tool to obtain a static review result;

[0066] Receiving manual review results, where the manual review results are obtained through review feedback from reviewers;

[0067] A target audit result of the code file is determined based on the static audit result and the manual audit result.

[0068] In this embodiment, in this step, the version control system integrates static code analysis tools (such as SonarQube, ESLine, etc.) to automatically review the submitted code files. Static analysis tools scan potential problems in the code, including code specifications, complexity, code duplication, potential security vulnerabilities, etc., and generate a static audit report. The report contains a list of problems and corresponding severity levels to help developers identify and fix defects in the code.

[0069] Next, the version control system sends the static audit results to the team member or auditor responsible for code review. The auditor conducts manual review based on the static audit report and code context, supplements the evaluation opinions, and provides feedback on the audit results. Manual review can conduct in-depth analysis on issues that static analysis tools fail to capture, such as logical errors and code readability. The auditor's feedback includes approval, repair suggestions, or reasons for rejection.

[0070] Finally, the system combines the static audit results with the manual audit results to generate the final target audit results. Specifically, the system will make judgments based on the following logic:

[0071] If both the static review results and the manual review results are passed, the code file will be marked as "review passed".

[0072] If the static audit results find serious problems and the manual audit results fail to correct these problems, the code file will be marked as "failed the audit" and the developer will be required to make corresponding repairs.

[0073] If the static review results indicate minor issues, and the manual review results confirm that the code is acceptable, the code file can be marked as "conditionally passed" and the developer needs to address the issues mentioned in subsequent versions.

[0074] By introducing a dual mechanism of static and manual review, the comprehensiveness and accuracy of code review is significantly improved, which helps to ensure code quality and reduce deployment risks, thus providing a solid foundation for subsequent image building and deployment. This method not only improves the collaborative efficiency of the development team, but also promotes continuous improvement and technology accumulation.

[0075] As a further optional embodiment, the step of building an image file according to the audited code file specifically includes:

[0076] Pull the reviewed code files through the automated server to build the project;

[0077] Compile the reviewed code files to generate executable files;

[0078] performing unit testing on the executable file;

[0079] The executable files that pass the test are packaged to obtain the image file.

[0080] In this embodiment, the automation server (such as Jenkins or GitLab CI) automatically pulls the approved code files according to the notification of the version control system. The server will obtain the latest submission from the version control system according to the configured build process and prepare the build environment. During the build process, the server will execute the preset build script to ensure the consistency of the environment and prepare all necessary dependencies.

[0081] Then, the automation server compiles the pulled code files to generate executable files. The specific process includes:

[0082] Use a build tool (such as Maven, Gradle, or Ant) to automatically download the required dependency libraries based on the project's build configuration file.

[0083] Execute the compilation instructions to convert the source code into an executable binary file. This process will generate a compilation log to record the warnings or errors encountered during the compilation process.

[0084] Next, the automation server will perform unit testing on the generated executable file to verify its functionality and performance. The specific operations include:

[0085] Run pre-written unit test cases using a testing framework such as JUnit, pytest, or Mocha.

[0086] Record the test results and generate a test report including passed test cases, failed test cases and their detailed information.

[0087] If the unit tests pass, the system continues to the next steps; if the tests fail, the automation server stops the build process and notifies the developer to fix the problem.

[0088] Finally, the automation server will package the executable files that have passed the unit test into an image file. The specific process includes:

[0089] Use a container build tool (such as Docker) to create a Dockerfile, which describes how to build an image, including the base image, required dependencies, and runtime environment configuration.

[0090] Execute the packaging instructions to package the executable files and other necessary resources (such as configuration files, static files, etc.) into an image.

[0091] Upload the generated image file to an image repository (such as Docker Hub, Harbor, or a private image repository) to provide support for subsequent testing and deployment.

[0092] This embodiment not only improves development efficiency by introducing automated building, compiling, testing, and packaging processes, but also ensures the quality and reliability of image files, laying a solid foundation for subsequent container deployment. This method can significantly reduce human errors and improve the speed and security of software delivery.

[0093] As a further optional embodiment, the step of determining the test address of the image file according to resource usage specifically includes:

[0094] Monitoring resource usage of the node, wherein the resource usage includes the current load of the node, available resources, and network topology;

[0095] According to the resource request of the container required by the image file, a matching test address is determined.

[0096] In this embodiment, the system monitors the resource usage of each node in the cluster in real time through an integrated monitoring tool (such as Prometheus, Grafana or other cloud monitoring solutions). The key indicators monitored include:

[0097] Current load: Monitor the CPU and memory usage of each node to assess its current load.

[0098] Available resources: Record the remaining computing resources on each node (such as the number of CPU cores, memory capacity, disk space, etc.) to ensure that sufficient resources are available when the container starts.

[0099] Network topology: Analyze the network topology and evaluate the network latency and bandwidth between nodes to ensure that the container runs in a suitable network environment.

[0100] The monitoring system will regularly update resource usage data to form a dynamic resource status view to support subsequent steps.

[0101] Next, the system matches the collected node resource usage with the resource request of the required container. The specific process is as follows:

[0102] Each image file defines the required resource requests when it is built, including CPU, memory, and storage requirements.

[0103] The system will compare these requirements with the resource usage of each monitored node to find nodes that meet the requirements.

[0104] Ensure that the selected node can not only meet the resource request of the container, but also consider network latency and availability to optimize the startup and running performance of the container.

[0105] Ultimately, the system will select one or more suitable test addresses for the required image file and generate a corresponding scheduling plan to ensure that the image is tested in an environment with optimal resources.

[0106] As a further optional embodiment, the step of testing the image file at the test address includes:

[0107] The automation server is controlled to trigger a container management platform through an API, so that the container management platform downloads and starts the image file at the test address.

[0108] In this embodiment, the automation server (such as Jenkins or GitLab CI) will interact with the container management platform (such as Kubernetes, Rancher or Docker Swarm) using the RESTful API based on the previously determined test address. The specific operations include:

[0109] The automation server sends a request through the API, indicating the image file to be downloaded and started at the specified test address.

[0110] The API request will include the required container configuration parameters, such as container name, required resources (CPU, memory), environment variables, and network configuration.

[0111] During this process, after receiving the API request from the automation server, the container management platform will perform the following operations:

[0112] Download image: Download the requested image file from the specified image repository. This step includes verifying the integrity and security of the image to ensure that the downloaded image meets the requirements.

[0113] Start the container: After successfully downloading the image, the container management platform will start one or more container instances at the test address. This step includes:

[0114] Creates a container instance and initializes it according to the configuration parameters passed previously.

[0115] Allocate necessary resources and network configuration to ensure that the container can communicate properly with other services.

[0116] Start the application in the container and run the corresponding test script to ensure that the application's functionality and performance meet expectations.

[0117] During the test run, the container management platform will monitor the running status and test results of the container in real time. After the test is completed, the system will generate a detailed test report, including: the number of test cases that passed and failed and the reasons. Performance indicators (such as response time, resource usage, etc.). The health status and log information of the container.

[0118] The test results will be fed back to the automation server through the API, which will record the results and notify the development team for corresponding analysis and repair.

[0119] This embodiment achieves efficient management of containers and automation of the testing process by combining the API trigger mechanism, ensuring that the image file can be tested in a suitable environment. This method not only improves testing efficiency, but also enhances the flexibility and scalability of the system, allowing the development team to respond to changes and perform continuous integration more quickly.

[0120] As a further optional embodiment, after the step of starting the container in the target production environment to deploy the image file that has passed the test, the method further includes:

[0121] The image file is uploaded to the version control system for semantic version control.

[0122] In this embodiment, after successfully deploying the tested image file, the system will upload the relevant information of the image file to the version control system for semantic version control. The specific process is as follows:

[0123] Get image metadata: The automation server obtains metadata related to the deployed image file from the container management platform, including image name, tag, build time, commit SHA, and other important build information. This information helps track the version history and changes of the image.

[0124] Generate version information: Generate version information for the image file according to the principles of semantic version control (such as MAJOR.MINOR.PATCH). When the image is updated, the system will automatically determine and update the version number. For example, if it is a major function update, the major version number will be increased; if a new function is added, the minor version number will be increased; if a minor problem is fixed, the patch version number will be increased.

[0125] Upload image information: Upload the generated image metadata and version information to the version control system in a structured manner (such as JSON format). Record relevant submission information and notes to ensure that team members can easily understand the changes in the image and the reasons behind them.

[0126] Notify team members: Automatically send update reminders to the development team through the notification function of the version control system, informing team members that a new image version has been uploaded and is available for use. The notification can be sent via email, Slack, or other communication tools.

[0127] In the version control system, the system maintains the version history of the image file and supports quick query and rollback. Developers can view the version change record of the image at any time as needed, and can quickly roll back to the previous stable version to ensure the stability of the production environment.

[0128] This embodiment combines image file upload with semantic version control, which not only improves the standardization of version management, but also enhances the team's transparency of image updates. This method helps the development team manage software releases and changes more effectively, while reducing deployment risks caused by version confusion and ensuring the maintainability and traceability of the system.

[0129] As a further optional embodiment, after the step of starting the container in the target production environment to deploy the image file that has passed the test, the method further includes:

[0130] Obtain user feedback data through log analysis and user behavior tracking, wherein the user feedback data includes application usage, function requests, and user opinions;

[0131] User demand feedback is generated according to the user feedback data.

[0132] In this embodiment, the system collects and analyzes user feedback data during the use of the application program to gain a deeper understanding of the application usage. The specific process includes:

[0133] Log collection: The application automatically records key operations and events, including user logins, function usage, error messages, etc. Log data is sent to a centralized log management system (such as ELK Stack or Splunk) for storage and analysis.

[0134] User behavior tracking: Integrate user behavior analysis tools (such as Google Analytics, Mixpanel, or Hotjar) to track user operation paths and interaction behaviors. By analyzing user behavior data, identify the most commonly used functions, user churn rates, and potential usage barriers.

[0135] Get user feedback: Provide user feedback channels, such as in-app feedback forms, surveys, or user communities, to encourage users to share their opinions and suggestions. Collect user reviews of new features, feedback on user experience, and any problems encountered.

[0136] During this process, the system will analyze the collected user feedback data and generate user demand feedback. The specific steps are as follows:

[0137] Data collation and analysis: collate and classify the collected log data and user behavior data to identify high-frequency issues, user requests, and usage trends. Use data analysis tools (such as data mining technology) to extract valuable information from massive data and reveal the real needs of users.

[0138] Generate demand feedback report: Generate a detailed user demand feedback report based on the analysis results, including user usage, priority of feature requests, and summary of user opinions. The report can include data visualization charts so that the team can more intuitively understand the trends and key points of user feedback.

[0139] Feedback is delivered to the development team: The generated user demand feedback report is delivered to the development and product teams through automated channels (such as email and Slack) to help them better adjust and optimize the product in subsequent development plans. Ensure that the team can quickly respond to user needs and feedback to achieve continuous improvement of the product.

[0140] This embodiment effectively collects and analyzes user feedback data to help the development team understand user needs and usage experience in a timely manner, thereby achieving continuous optimization and iteration of the product. This method not only improves user satisfaction, but also provides data support for future function development, ensuring that the product can better adapt to market changes.

[0141] The following is a description of the automatic deployment device based on intelligent scheduling provided by the present invention. Figure 2 As shown, the automatic deployment device based on intelligent scheduling described below and the automatic deployment method based on intelligent scheduling described above can refer to each other.

[0142] An automatic deployment device based on intelligent scheduling, comprising:

[0143] A code forwarding module 210 is used to send the code file to the version control system through the integrated development environment, so that the version control system can review the code file;

[0144] The code receiving module 220 is used to receive the code file that has passed the review and is sent by the version control system;

[0145] An image building module 230 is used to build an image file according to the audited code file;

[0146] A resource scheduling module 240, used to determine the test address of the image file according to resource usage;

[0147] An image testing module 250, configured to test the image file at the test address;

[0148] The image deployment module 260 is used to start a container in a target production environment to deploy the image file that has passed the test.

[0149] Figure 3 An example of a physical structure diagram of an electronic device is shown in FIG. Figure 3 As shown, the electronic device may include: a processor 310, a communications interface 320, a memory 330 and a communication bus 340, wherein the processor 310, the communications interface 320 and the memory 330 communicate with each other through the communication bus 340. The processor 310 may call the logic instructions in the memory 330 to execute the automatic deployment method based on intelligent scheduling, which includes:

[0150] Sending the code file to a version control system through an integrated development environment so that the version control system can review the code file;

[0151] Receiving the reviewed code file sent by the version control system;

[0152] Build the image file based on the reviewed code file;

[0153] Determine the test address of the image file according to resource usage;

[0154] Testing the image file at the test address;

[0155] Start the container in the target production environment to deploy the image file that passed the test.

[0156] In addition, the logic instructions in the above-mentioned memory 330 can be implemented in the form of a software functional unit and can be stored in a computer-readable storage medium when it is sold or used as an independent product. Based on such an understanding, the technical solution of the present invention is essentially or the part that contributes to the prior art or the part of the technical solution can be embodied in the form of a software product, and the computer software product is stored in a storage medium, including a number of instructions to enable a computer device (which can be a personal computer, a server, or a network device, etc.) to perform all or part of the steps of the method described in each embodiment of the present invention. The aforementioned storage medium includes: U disk, mobile hard disk, read-only memory (ROM, Read-Only Memory), random access memory (RAM, Random Access Memory), disk or optical disk and other media that can store program codes.

[0157] On the other hand, the present invention further provides a computer program product, the computer program product includes a computer program, the computer program can be stored on a non-transitory computer-readable storage medium, and when the computer program is executed by a processor, the computer can execute the automatic deployment method based on intelligent scheduling provided by the above methods, the method including:

[0158] Sending the code file to a version control system through an integrated development environment so that the version control system can review the code file;

[0159] Receiving the reviewed code file sent by the version control system;

[0160] Build the image file based on the reviewed code file;

[0161] Determine the test address of the image file according to resource usage;

[0162] Testing the image file at the test address;

[0163] Start the container in the target production environment to deploy the image file that passed the test.

[0164] In another aspect, the present invention further provides a non-transitory computer-readable storage medium having a computer program stored thereon, which is implemented when the computer program is executed by a processor to execute the automatic deployment method based on intelligent scheduling provided by the above methods, the method comprising:

[0165] Sending the code file to a version control system through an integrated development environment so that the version control system can review the code file;

[0166] Receiving the reviewed code file sent by the version control system;

[0167] Build the image file based on the reviewed code file;

[0168] Determine the test address of the image file according to resource usage;

[0169] Testing the image file at the test address;

[0170] Start the container in the target production environment to deploy the image file that passed the test.

[0171] The device embodiments described above are merely illustrative, wherein the units described as separate components may or may not be physically separated, and the components displayed as units may or may not be physical units, that is, they may be located in one place, or they may be distributed on multiple network units. Some or all of the modules may be selected according to actual needs to achieve the purpose of the scheme of this embodiment. Ordinary technicians in this field can understand and implement it without paying creative labor.

[0172] Through the description of the above implementation methods, those skilled in the art can clearly understand that each implementation method can be implemented by means of software plus a necessary general hardware platform, and of course, it can also be implemented by hardware. Based on this understanding, the above technical solution is essentially or the part that contributes to the prior art can be embodied in the form of a software product, and the computer software product can be stored in a computer-readable storage medium, such as ROM / RAM, a disk, an optical disk, etc., including a number of instructions for a computer device (which can be a personal computer, a server, or a network device, etc.) to execute the methods described in each embodiment or some parts of the embodiments.

[0173] Finally, it should be noted that the above embodiments are only used to illustrate the technical solutions of the present invention, rather than to limit it. Although the present invention has been described in detail with reference to the aforementioned embodiments, those skilled in the art should understand that they can still modify the technical solutions described in the aforementioned embodiments, or make equivalent replacements for some of the technical features therein. However, these modifications or replacements do not deviate the essence of the corresponding technical solutions from the spirit and scope of the technical solutions of the embodiments of the present invention.

Claims

1. An automated deployment method based on intelligent scheduling, characterized in that: include: Sending the code file to a version control system through an integrated development environment so that the version control system can review the code file; Receiving the reviewed code file sent by the version control system; Build the image file based on the reviewed code file; Determine the test address of the image file according to resource usage; Testing the image file at the test address; Start the container in the target production environment to deploy the image file that passed the test.

2. The automatic deployment method based on intelligent scheduling according to claim 1 is characterized in that: The version control system reviews the code file, specifically including: Automatically review the code file using a static code analysis tool to obtain a static review result; Receiving manual review results, where the manual review results are obtained through review feedback from reviewers; A target audit result of the code file is determined based on the static audit result and the manual audit result.

3. The automatic deployment method based on intelligent scheduling according to claim 2 is characterized in that: The step of building an image file based on the audited code file specifically includes: Pull the reviewed code files through the automated server to build the project; Compile the reviewed code files to generate executable files; performing unit testing on the executable file; The executable files that pass the test are packaged to obtain the image file.

4. The automatic deployment method based on intelligent scheduling according to claim 3 is characterized in that: The step of determining the test address of the image file according to the resource usage specifically includes: Monitoring resource usage of the node, wherein the resource usage includes the current load of the node, available resources, and network topology; According to the resource request of the container required by the image file, a matching test address is determined.

5. The automatic deployment method based on intelligent scheduling according to claim 4 is characterized in that: The step of testing the image file at the test address includes: The automation server is controlled to trigger a container management platform through an API, so that the container management platform downloads and starts the image file at the test address.

6. The automatic deployment method based on intelligent scheduling according to claim 1 is characterized in that: After the step of starting the container in the target production environment to deploy the image file that has passed the test, the following steps are also included: The image file is uploaded to the version control system for semantic version control.

7. The automatic deployment method based on intelligent scheduling according to claim 1 is characterized in that: After the step of starting the container in the target production environment to deploy the image file that has passed the test, the following steps are also included: Obtain user feedback data through log analysis and user behavior tracking, wherein the user feedback data includes application usage, function requests, and user opinions; User demand feedback is generated according to the user feedback data.

8. An automatic deployment device based on intelligent scheduling, characterized in that: include: A code forwarding module, used to send the code file to the version control system through the integrated development environment, so that the version control system can review the code file; A code receiving module, used to receive the approved code files sent by the version control system; The image building module is used to build image files based on the reviewed code files; A resource scheduling module, used to determine the test address of the image file according to resource usage; An image testing module, used for testing the image file at the test address; The image deployment module is used to start the container in the target production environment to deploy the image file that has passed the test.

9. An electronic device comprising a memory, a processor, and a computer program stored in the memory and executable on the processor, wherein: When the processor executes the program, the automated deployment method based on intelligent scheduling as described in any one of claims 1 to 7 is implemented.

10. A non-transitory computer-readable storage medium having a computer program stored thereon, characterized in that: When the computer program is executed by a processor, the automated deployment method based on intelligent scheduling as described in any one of claims 1 to 7 is implemented.

Images