Continuous integration, delivery and deployment method, equipment, medium and product

Abstract

The invention discloses a continuous integration, delivery and deployment method and device, a medium and a product, and relates to the technical field of system monitoring management and financial science and technology, and the method comprises the steps: triggering and starting a continuous integration process when a to-be-integrated code matched with a target source code is detected; by executing a continuous integration process, performing automatic construction and code test operation on the to-be-integrated codes in sequence; after the continuous integration process passes, generating a to-be-deployed container mirror image matched with the to-be-integrated code, and pushing the to-be-deployed container mirror image to a mirror image warehouse; when the agent component detects that the to-be-deployed container mirror image meets the deployment condition, the deployment instruction is automatically sent to the open-source container arrangement cluster, so that the container arrangement cluster pulls the to-be-deployed container mirror image for deployment. The deployment instruction is automatically sent to the container arrangement cluster through the agent component, automation of the deployment process is achieved, delivery efficiency is improved, the application deployment state is monitored through the agent component, the running state is mastered in real time, and the reliability of the system is improved.

Description

Technical Field

[0001] This invention relates to the fields of system monitoring and management and financial technology, and in particular to a method, apparatus, medium and product for continuous integration, delivery and deployment. Background Technology

[0002] Application development and version delivery are core processes in system software development and operation, ensuring that code is transformed into runnable software and smoothly transitions from the development environment to the production environment. With the advancement of digital transformation, higher demands are being placed on the efficiency and quality of this process.

[0003] In existing technologies, application project development and version delivery mainly involve three processes: continuous integration, continuous delivery, and continuous deployment. Continuous integration and continuous delivery are managed at the code repository level, while application version upgrades and iterations are achieved through delivery and deployment. Production manuals and manual operation steps are handed over in document form. However, with the increasing granularity of application service node decomposition, the growth of code repositories, the proliferation of node types, and the increasing complexity of production dependencies, the complexity of managing and maintaining existing processes has significantly increased, leading to higher maintenance costs and reduced efficiency. Summary of the Invention

[0004] This invention provides a method, apparatus, medium, and product for continuous integration, delivery, and deployment to address the problems of high manpower costs, high time costs, low efficiency, and poor reliability in continuous integration, delivery, and deployment.

[0005] According to one aspect of the present invention, a method for continuous integration, delivery, and deployment is provided, executed by a distributed version control system, comprising:

[0006] When at least one piece of code to be integrated that matches the target source code is detected, the continuous integration process is triggered.

[0007] By executing the continuous integration process, automated build and code testing operations are performed sequentially on the code to be integrated;

[0008] After the continuous integration process is completed, a container image to be deployed that matches the code to be integrated is generated and pushed to the image repository;

[0009] When the agent component in the distributed version control system detects that the container image to be deployed pushed to the image repository meets the deployment conditions, it automatically sends a deployment instruction to the open-source container orchestration cluster, so that the container orchestration cluster can pull the container image to be deployed from the image repository for deployment.

[0010] In this system, the agent component in the distributed version control system is used to monitor and manage the deployment status of the application; the open-source container orchestration cluster includes at least one container, in which at least one application runs.

[0011] According to another aspect of the present invention, an apparatus for continuous integration, delivery, and deployment is provided, configured in a distributed version control system, comprising:

[0012] The integration trigger module is used to initiate the continuous integration process when at least one piece of code to be integrated that matches the target source code is detected.

[0013] The test module is used to perform automated build and code testing operations on the code to be integrated sequentially by executing the continuous integration process.

[0014] The container image module is used to generate a container image that matches the code to be integrated and push it to the image repository after the continuous integration process is completed.

[0015] The deployment instruction module is used to automatically send deployment instructions to the open-source container orchestration cluster when the agent component in the distributed version control system detects that the container image to be deployed pushed to the image repository meets the deployment conditions, so that the container orchestration cluster can pull the container image to be deployed from the image repository for deployment.

[0016] In this system, the agent component in the distributed version control system is used to monitor and manage the deployment status of the application; the open-source container orchestration cluster includes at least one container, in which at least one application runs.

[0017] According to another aspect of the present invention, an electronic device is provided, the electronic device comprising:

[0018] At least one processor; and a memory communicatively connected to the at least one processor; wherein the memory stores a computer program executable by the at least one processor, the computer program being executed by the at least one processor to enable the at least one processor to perform the continuous integration, delivery, and deployment method according to any embodiment of the present invention.

[0019] According to another aspect of the present invention, a computer-readable storage medium is provided, the computer-readable storage medium storing computer instructions for causing a processor to execute and implement the continuous integration, delivery, and deployment method described in any embodiment of the present invention.

[0020] According to another aspect of the present invention, a computer program product is also provided, including a computer program that, when executed by a processor, implements the steps of the method as described in any embodiment of the present invention.

[0021] The technical solution of this invention triggers a continuous integration process when at least one piece of code matching the target source code is detected. The continuous integration process sequentially performs automated builds and code testing on the code to be integrated. After the continuous integration process is complete, a container image matching the code to be integrated is generated and pushed to the image repository. When the agent component in the distributed version control system detects that the container image pushed to the image repository meets the deployment conditions, it automatically sends deployment instructions to the open-source container orchestration cluster, allowing the cluster to pull the container image from the image repository for deployment. By running multiple containers in the container orchestration cluster, each running one or more applications, modular deployment and management of the system are achieved, improving system scalability. The agent component automatically sends deployment instructions to the container orchestration cluster, automating the deployment process, reducing labor and time costs, ensuring a tight connection between continuous integration and continuous deployment processes, improving overall delivery efficiency. The agent component monitors the application deployment status, enabling real-time monitoring of application deployment and operational status, facilitating timely problem detection and resolution, and improving system reliability and maintainability.

[0022] It should be understood that the description in this section is not intended to identify key or essential features of the embodiments of the present invention, nor is it intended to limit the scope of the invention. Other features of the invention will become readily apparent from the following description. Attached Figure Description

[0023] To more clearly illustrate the technical solutions in the embodiments of the present invention, the accompanying drawings used in the description of the embodiments will be briefly introduced below. Obviously, the accompanying drawings described below are only some embodiments of the present invention. For those skilled in the art, other drawings can be obtained based on these drawings without creative effort.

[0024] Figure 1 This is a flowchart of a continuous integration, delivery, and deployment method provided according to Embodiment 1 of the present invention;

[0025] Figure 2 This is a flowchart of another method for continuous integration, delivery, and deployment provided according to Embodiment 2 of the present invention;

[0026] Figure 3 This is a schematic diagram of a continuous integration process applicable to an embodiment of the present invention;

[0027] Figure 4 This is a schematic diagram of a delivery and deployment mode applicable to an embodiment of the present invention;

[0028] Figure 5This is a schematic diagram of a one-stop platform applicable to an embodiment of the present invention;

[0029] Figure 6 This is a schematic diagram of the structure of an apparatus for continuous integration, delivery, and deployment according to Embodiment 3 of the present invention;

[0030] Figure 7 This is a schematic diagram of the structure of an electronic device that implements the continuous integration, delivery, and deployment method of the embodiments of the present invention. Detailed Implementation

[0031] To enable those skilled in the art to better understand the present invention, the technical solutions of the present invention will be clearly and completely described below with reference to the accompanying drawings of the embodiments of the present invention. Obviously, the described embodiments are only some embodiments of the present invention, and not all embodiments. Based on the embodiments of the present invention, all other embodiments obtained by those skilled in the art without creative effort should fall within the scope of protection of the present invention.

[0032] It should be noted that the terms "first," "second," etc., in the specification, claims, and accompanying drawings of this invention are used to distinguish similar objects and are not necessarily used to describe a specific order or sequence. It should be understood that such data can be interchanged where appropriate so that the embodiments of the invention described herein can be implemented in orders other than those illustrated or described herein. Furthermore, the terms "comprising" and "having," and any variations thereof, are intended to cover non-exclusive inclusion; for example, a process, method, system, product, or apparatus that comprises a series of steps or units is not necessarily limited to those steps or units explicitly listed, but may include other steps or units not explicitly listed or inherent to such processes, methods, products, or apparatus.

[0033] Example 1

[0034] Figure 1This is a flowchart illustrating a continuous integration, delivery, and deployment method according to Embodiment 1 of the present invention. This embodiment is applicable to continuous integration, delivery of application code, and deployment of applications to a production environment. The method can be executed by a continuous integration, delivery, and deployment device, which can be implemented in hardware and / or software and is generally configured within a distributed version control system. Specifically, a distributed version control system can be understood as a system that allows multiple developers to independently maintain copies of a project in different locations. Each copy contains a complete project history. Developers can develop offline, commit changes to a local repository, and push changes from the local repository to another repository via a network connection for other developers to view. Alternatively, they can retrieve changes from another branch or repository and merge changes from different branches or repositories into the current branch. A branch can be specifically understood as an independent development line within a repository, used to isolate and manage different development paths of code. A repository can be specifically understood as a complete storage unit for a project, including all files, directories, commit history, and branches. The distributed version control system includes multiple network elements, each of which is a node that handles a specific task. For example, the code repository management node is responsible for storing and managing source code, the continuous integration node is responsible for automated building and testing, the image repository node stores container images, and the proxy component node is responsible for listening to and synchronizing configuration changes. These network elements work together to automate the entire process of code submission, building, testing, and deployment.

[0035] Correspondingly, such as Figure 1 As shown, the method includes:

[0036] S110. When at least one piece of code to be integrated that matches the target source code is detected, the continuous integration process is initiated.

[0037] In this embodiment of the invention, the target source code can be specifically understood as: existing application code that serves as the integration target. The code to be integrated can be specifically understood as: newly submitted code by a developer that matches the target source code, or code merged from other branches or repositories. Matching the target source code can be specifically understood as: the code to be integrated and the predetermined target source code in the project having consistency in some aspects or meeting specific conditions, such as the code to be integrated and the target source code belonging to the same project or module, meeting integration conditions (e.g., passing preliminary testing or code review), having the same version number or tag, having a dependency relationship, or having similarity in file system paths or filenames, etc. The continuous integration process can be specifically understood as: a series of automated operations used to integrate code changes periodically or when code changes occur, including operations such as building, running tests, and packaging.

[0038] S120. By executing the continuous integration process, automated build and code testing operations are performed sequentially on the code to be integrated.

[0039] Specifically, by executing a continuous integration process, the code is built automatically to ensure that the code can be compiled or packaged correctly. Then, the successfully built code is tested automatically, which may include unit tests or integration tests, to verify whether the code's functionality and performance meet the requirements.

[0040] S130. After the continuous integration process is completed, a container image to be deployed that matches the code to be integrated is generated and pushed to the image repository.

[0041] In this embodiment of the invention, the container image to be deployed can be specifically understood as: a file used to quickly create and run application instances in a containerized environment, which may include the application and all its dependencies (such as code, runtime environment, and application configuration files), ensuring that the application can run consistently in any environment that supports container technology. The image repository can be specifically understood as: a repository used to store, manage, and distribute container images, which can store different versions of images and provide access control functions, ensuring that only authorized users can push or pull images.

[0042] Specifically, after the code passes the build and test phases of the continuous integration process and verifies its functionality and stability, the code that has passed the tests is packaged into a container image to be deployed, and the generated container image is uploaded to the image repository.

[0043] S140. When the agent component in the distributed version control system detects that the container image to be deployed pushed to the image repository meets the deployment conditions, it automatically sends a deployment instruction to the open-source container orchestration cluster, so that the container orchestration cluster can pull the container image to be deployed from the image repository for deployment.

[0044] In this system, the agent component in the distributed version control system is used to monitor and manage the deployment status of the application; the open-source container orchestration cluster includes at least one container, in which at least one application runs.

[0045] In this embodiment of the invention, the agent component in the distributed version control system can be specifically understood as: a component used to monitor container images to be deployed in the image repository and determine whether they meet the deployment conditions. The open-source container orchestration cluster can be specifically understood as: a system used to manage the creation, deployment, scaling, and management of containers. A container can be specifically understood as: the basic unit running in the container orchestration cluster, with each container running at least one application. The predefined deployment conditions can be specifically understood as: predefined rules or standards used to determine whether the deployment process should be initiated, such as: the image must be successfully pushed to the image repository and be accessible; the image must pass integrity checks such as verification and matching; the image must have specific tags, such as a version number or latest version marker; the image must have a manual or automated approval mark; the image must have a mark indicating compatibility with dependencies between other versions of components or system environments.

[0046] Specifically, a proxy component in the distributed version control system continuously monitors changes in the image repository, such as new image push events. When a new image is detected, the proxy component checks whether predefined deployment conditions are met. If the conditions are met, the proxy component automatically sends a deployment command to the container orchestration cluster, which then pulls the container image to be deployed from the image repository. The proxy component also tracks the deployment status and feeds the results back to the distributed version control system or other management tools.

[0047] The technical solution of this invention triggers a continuous integration process when at least one piece of code matching the target source code is detected. The continuous integration process sequentially performs automated builds and code testing on the code to be integrated. After the continuous integration process is complete, a container image matching the code to be integrated is generated and pushed to the image repository. When the agent component in the distributed version control system detects that the container image pushed to the image repository meets the deployment conditions, it automatically sends deployment instructions to the open-source container orchestration cluster, allowing the cluster to pull the container image from the image repository for deployment. By running multiple containers in the container orchestration cluster, each running one or more applications, modular deployment and management of the system are achieved, improving system scalability. The agent component automatically sends deployment instructions to the container orchestration cluster, automating the deployment process, reducing labor and time costs, ensuring a tight connection between continuous integration and continuous deployment processes, improving overall delivery efficiency. The agent component monitors the application deployment status, enabling real-time monitoring of application deployment and operational status, facilitating timely problem detection and resolution, and improving system reliability and maintainability.

[0048] Furthermore, based on the above embodiments, the method for continuous integration, delivery, and deployment may also include:

[0049] In response to an information query command from the one-stop front-end display platform, when it is determined that the first information queried by the information query command has read permissions, the first information is provided to the one-stop front-end display platform for user display.

[0050] In response to the information writing instruction of the one-stop front-end display platform, when it is determined that the second information to be written by the information writing instruction has write permission, the second information is written to the matching data writing position in the distributed version control system.

[0051] The one-stop platform includes: a global dashboard, platform operation and maintenance management, a development center, a business research center, and a production center.

[0052] In this embodiment of the invention, the one-stop front-end display platform can be specifically understood as: a centralized user interface for displaying and managing various application information, which may include multiple functional units, such as: a global dashboard unit for providing an overall view and key indicators, a platform operation and maintenance management unit for platform operation and maintenance, a development center unit for application development, a business research center unit for business research and application testing, and a production center unit for monitoring and managing the production environment and the running status of applications deployed in the production environment. The first information can be specifically understood as: information queried by the user through the one-stop front-end display platform, such as the application's running status, resource usage, and log information. The second information can be specifically understood as: information that the user wants to write or modify through the one-stop front-end display platform, such as new configuration parameters, updated application code, and changed environment variables.

[0053] Specifically, for information query commands issued by the one-stop front-end display platform, the system checks whether the first piece of information queried by the command has read permissions. If permissions are granted, the information is provided to the one-stop front-end display platform for display to the user; otherwise, a permission-only message is returned, ensuring that the user can only view authorized information. For information write commands issued by the one-stop front-end display platform, the system checks whether the second piece of information to be written has write permissions. If permissions are granted, the information is written to the corresponding data storage location in the distributed version control system; otherwise, a permission-only message is returned, ensuring that only authorized data can be modified or added. By implementing read-write separation permission control in the one-stop front-end display platform, unauthorized access and modification are prevented, protecting data integrity and confidentiality, ensuring information security and accuracy, and improving the overall efficiency of the platform and user experience. The one-stop platform allows users to operate on a centralized interface, reducing the need to switch between different systems, simplifying operation processes, improving work efficiency, and ensuring the stability and reliability of platform operation.

[0054] Example 2

[0055] Figure 2 This is a flowchart of another method for continuous integration, delivery, and deployment provided in Embodiment 2 of the present invention. This embodiment is a refinement of the above embodiment's "executing the continuous integration process to sequentially perform automated build and code testing operations on the code to be integrated," and specifically may include: obtaining, by executing the continuous integration process, a continuous integration configuration file submitted by at least one release unit to the distributed version control system and the code to be integrated that matches the target source code; performing version builds on the continuous integration configuration file and the code to be integrated respectively through an automatic branch inheritance mechanism to obtain a built updated configuration file and a built version file; deploying the built version file to the corresponding environment to perform at least one preset test; and determining that the continuous integration process has passed when all preset tests are passed.

[0056] Correspondingly, such as Figure 2 As shown, the method includes:

[0057] S210. When at least one piece of code to be integrated that matches the target source code is detected, the continuous integration process is initiated.

[0058] S220. By executing the continuous integration process, obtain at least one continuous integration configuration file submitted by the release unit to the distributed version control system and the code to be integrated that matches the target source code.

[0059] In this embodiment of the invention, the release unit can be specifically understood as a submission unit used by the development team or developers to submit changed code. The continuous integration configuration file can be specifically understood as a file used to define the continuous integration process, specifically including configuration information for steps such as building, testing, and deployment.

[0060] Specifically, when a release unit submits code changes to the distributed version control system, the continuous integration process obtains the code to be integrated and the corresponding configuration files that match the target source code to ensure that the changes can be correctly integrated into the project.

[0061] S230. Through the automatic branch inheritance mechanism, the continuous integration configuration file and the code to be integrated are version-built separately to obtain the built updated configuration file and the built version file.

[0062] In this embodiment of the invention, the automatic branch inheritance mechanism can be understood as follows: when the code of a branch is modified and committed, the changed code can be automatically merged into other related branches with inheritance relationships, ensuring that all related branches can obtain the latest code changes in a timely manner, maintaining code consistency and synchronization. At the same time, historical build versions are retained, facilitating issue tracing and version rollback. Version building can be specifically understood as the process of generating a deployable version file for testing or production environments.

[0063] Specifically, by executing the continuous integration process, the continuous integration configuration file and the code to be integrated that matches the target source code are obtained from the distributed version control system. Using the automatic branch inheritance mechanism, the obtained continuous integration configuration file is updated and packaged to generate a deployable updated configuration file. Simultaneously, using the automatic branch inheritance mechanism, the code to be integrated is compiled and packaged to generate a deployable version file.

[0064] S240. Deploy the built version file to the appropriate environment to perform at least one preset test.

[0065] Specifically, the built version files should be deployed to a test environment similar to the production environment to perform at least one pre-set test, such as interface testing (verifying whether the software's interfaces are correct), smoke testing (checking whether the software's basic functions are normal), and access control checkpoints (checking whether the software's key checkpoints meet design requirements), to ensure that the software undergoes quality inspection before entering the production environment.

[0066] S250. When all preset tests are passed, the continuous integration process is deemed successful.

[0067] S260. After the continuous integration process is completed, a container image to be deployed that matches the code to be integrated is generated and pushed to the image repository.

[0068] S270. When the agent component in the distributed version control system detects that the container image to be deployed pushed to the image repository meets the deployment conditions, it automatically sends a deployment instruction to the open-source container orchestration cluster, so that the container orchestration cluster can pull the container image to be deployed from the image repository for deployment.

[0069] In this system, the agent component in the distributed version control system is used to monitor and manage the deployment status of the application; the open-source container orchestration cluster includes at least one container, in which at least one application runs.

[0070] The technical solution of this invention triggers the continuous integration process when at least one piece of code matching the target source code is detected. By executing the continuous integration process, the continuous integration configuration file submitted by the release unit and the code matching the target source code are obtained. Through an automatic branch inheritance mechanism, version builds are performed on the continuous integration configuration file and the code to be integrated, resulting in an updated configuration file and a version file, which are then deployed to the corresponding environment for preset tests. The continuous integration process is considered successful when all preset tests are passed. A container image matching the code to be integrated is generated and pushed to the image repository. When the agent component in the distributed version control system detects that the deployment conditions are met, a deployment command is automatically sent, allowing the container orchestration cluster to pull the container image for deployment. The automatic branch inheritance mechanism for version builds of the continuous integration configuration file and the code to be integrated automates and standardizes version management, improves build consistency, and retains historical build versions for easy issue tracing and version rollback. Testing in a test environment similar to the actual production environment improves the reliability of the build files. Running multiple containers, each running one or more applications, through a container orchestration cluster improves system scalability. By automatically sending deployment commands to the container orchestration cluster through the agent component, the deployment process is automated, improving overall delivery efficiency. The agent component monitors the application deployment status, enabling real-time understanding of the application's deployment and operational status, facilitating timely discovery and resolution of problems, and improving system reliability and maintainability.

[0071] Optionally, based on the above embodiments, generating a container image to be deployed that matches the code to be integrated and pushing it to the image repository may include:

[0072] The built version file is pushed to the image repository as a container image that matches the code to be integrated;

[0073] Update the application update configuration file in the update configuration file to the application configuration library;

[0074] Update the environment update configuration file in the environment repository.

[0075] Specifically, in the continuous integration process, the version file generated after compilation and packaging is the executable version of the application. This executable version is pushed to the image repository as a container image matching the code to be integrated, for storage and management. The application configuration repository is updated with application-related update configuration files (such as application startup parameters, environment variables, and service ports) to adapt to new versions or feature changes. The environment repository is also updated with environment-related update configuration files (such as environment-specific configurations, resource limits, and network settings) to ensure the application runs correctly in the corresponding environment.

[0076] The application configuration repository stores configuration information for multiple versions of the application. The environment repository stores configuration information for multiple versions of different runtime environments (such as development, research (testing), and production environments), ensuring that the application can run correctly in different environments. The application update configuration files in the application configuration repository and the environment update configuration files in the environment repository are matched with the corresponding versions of the container images to be deployed in the image repository, providing the runtime environment and dependencies required for application deployment for the container images to be deployed.

[0077] By pushing the built version file as a container image to be deployed to the image repository, and updating the corresponding update configuration file to the application configuration repository and environment repository, the up-to-date status of the configuration information is ensured. The application configuration repository and environment repository support multi-version control of configuration and historical version rollback, which facilitates the rapid deployment and management of applications in different environments, improves the efficiency and reliability of software delivery, simplifies configuration management, and improves the level of automation in the delivery process.

[0078] Optionally, based on the above embodiments, when the agent component in the distributed version control system detects that the container image to be deployed pushed to the image repository meets the deployment conditions, it automatically sends deployment instructions to the open-source container orchestration cluster, which may include:

[0079] The proxy component monitors file changes in the application configuration repository and environment repository in real time. When a configuration change is detected, an approval process for the configuration change is triggered.

[0080] When the approval process is completed and the proxy component determines that the approval has been approved, it automatically sends an update deployment command to the open-source container orchestration cluster.

[0081] In this embodiment of the invention, the approval process can be specifically understood as: a process of reviewing and approving configuration updates to ensure that these changes meet quality standards, security requirements, and business needs. The approval process can be manual or automated.

[0082] Specifically, the proxy component monitors file changes in both the application configuration repository and the environment repository in real time. When a configuration change is detected, it triggers an approval process for the changes to the application configuration file and the environment configuration file. If the approval process is successful, the proxy component will automatically send an update deployment command to the container orchestration cluster.

[0083] By using proxy components to monitor file changes in the application configuration repository and environment repository in real time, configuration changes and image updates can be processed in a timely manner. By executing an approval process for configuration changes, it is ensured that only approved changes are deployed to the production environment, thus guaranteeing the compliance and security of the changes.

[0084] Furthermore, based on the above embodiments, after triggering the approval process for configuration changes through the proxy component, it may further include:

[0085] When the proxy component determines that the approval has failed based on the result of the approval process, it will use the historical version configuration files in the application configuration library and environment library of the previous version at the time of the detected configuration change as the container version configuration file.

[0086] Monitor the deployment status of each application in the open-source container orchestration cluster in real time through the proxy component;

[0087] When the proxy component determines that the application's deployment status is inconsistent with the container version configuration file, it automatically sends a synchronization deployment command to the open-source container orchestration cluster to deploy the container image corresponding to the container version configuration file.

[0088] Specifically, the proxy component monitors file changes in the application configuration repository and environment repository in real time. When a configuration change is detected, an approval process is triggered. If the approval process fails, the proxy component uses the historical version configuration file from the previous version of the application configuration repository and environment repository at the time the configuration change was detected as the container version configuration file. The system automatically reverts to the corresponding previous stable version configuration to ensure system stability and reliability. Correspondingly, the proxy component continuously monitors the deployment status of each application in the open-source container orchestration cluster and compares the current deployment status with the container version configuration file. If the proxy component detects an inconsistency between the application deployment status and the container version configuration file, it automatically sends a synchronization deployment command to the container orchestration cluster. The container orchestration cluster then deploys the container image corresponding to the container version configuration file according to the synchronization deployment command, thereby ensuring that the application deployment status in the cluster is consistent with the container version configuration file. This automated rollback mechanism ensures that applications can automatically revert to the previous stable version when approval fails, reducing the risk of application failure, minimizing the need for manual intervention, and reducing time and manpower costs. Simultaneously, the proxy component's real-time monitoring function can automatically detect and correct inconsistencies between the application deployment status and the configuration file, ensuring that the application always runs in the expected state, improving application stability and reliability.

[0089] Optionally, based on the above embodiments, the container orchestration cluster is used for incremental deployment based on changes in files in the application configuration repository and environment repository;

[0090] Accordingly, based on the above embodiments, after automatically sending update deployment instructions to the open-source container orchestration cluster through the proxy component, it may further include:

[0091] The proxy component retrieves the current version configuration file corresponding to the container that has been incrementally deployed by the container orchestration cluster from the application configuration repository and environment repository, and uses it as the container version configuration file.

[0092] Monitor the deployment status of each application in the open-source container orchestration cluster in real time through the proxy component;

[0093] When the proxy component determines that the application's deployment status is inconsistent with the container version configuration file, it automatically sends a synchronization deployment instruction to the open-source container orchestration cluster, instructing the container orchestration cluster to continue deploying the container image corresponding to the container version configuration file.

[0094] In this embodiment of the invention, incremental deployment can be specifically understood as: only updating or deploying the parts that have changed, rather than redeploying the entire application, thereby improving deployment efficiency.

[0095] Specifically, the container orchestration cluster pulls container images to be deployed from the image repository and performs incremental deployment based on file changes in the application configuration repository and environment repository. After sending a deployment command to the container orchestration cluster, the agent component retrieves the current version configuration file corresponding to the incrementally deployed container from the application configuration repository and environment repository, using it as the container version configuration file. It monitors the deployment status of each application in real time. If the agent component detects an inconsistency between the application's deployment status and the container version configuration file, it automatically sends a synchronization deployment command to the container orchestration cluster, instructing the cluster to continue deploying the container image corresponding to the container version configuration file to ensure consistency. Through incremental deployment, the system only needs to update the changed parts, improving deployment efficiency. The agent component's real-time monitoring and automatic synchronization functions ensure that applications are always in the expected deployment state, and the automatic synchronization of deployment commands further guarantees the consistency between the application state and the configuration file, enhancing the reliability and stability of application operation.

[0096] Optionally, based on the above embodiments, the one-stop front-end display platform can also integrate an intelligent analysis module based on a pre-trained machine learning model. The model predicts the risk level of changes during the approval process based on historical data and real-time information, assisting or directly contributing to approval decisions, and providing key information such as corresponding optimization suggestions (e.g., adjusting relevant parameters in application or environment configurations), providing data support for operational decisions. Simultaneously, an intelligent recommendation solution button or other triggering mechanism can be embedded in the alarm interface, enabling operations personnel to quickly execute the repair scripts generated by the model and respond to and handle anomalies promptly. Operations personnel's adoption or rejection of model suggestions are added to the training set as new data points. Through continuous model optimization, the accuracy of risk assessment for configuration changes is improved, and the feedback mechanism is adjusted according to business development and operational needs, ensuring that the system always maintains efficient and accurate operational support.

[0097] In a specific example, adjusting the feedback mechanism based on business development and operational needs can be categorized according to the business's development stage: In the initial expansion phase of fintech businesses, business needs often focus more on risk control. Therefore, the feedback mechanism of the approval model should be adjusted to emphasize the collection of risk indicators. For example, model training should focus on how to more accurately identify high-risk indicators or configurations. As the business matures and competition intensifies, the efficiency of the approval process becomes crucial. Therefore, model training should focus on the efficiency of risk assessment and automated approval. In system operation and maintenance scenarios, when encountering peak business periods or changes in operational needs such as the launch of new features, the feedback mechanism will be adjusted to focus on system stability and user experience as the primary objectives. For example, in a bank's mobile application, by capturing the characteristic data of lag, anomalies, and interruptions in user operations in real time, the corresponding configuration data causing these events can be identified, thereby improving the relevance and accuracy of risk assessment in model training during system operation and maintenance.

[0098] To facilitate understanding, the specific application scenarios applicable to the above-described embodiments are described below. In the fintech field, the efficiency and quality of application project development and version delivery are particularly critical. The digital transformation of fintech requires system software development and operation to possess high agility and reliability to adapt to rapidly changing market demands and regulatory environments. As the granularity of fintech application service node decomposition becomes more refined, code repositories increase, node types proliferate, and production dependencies become more complex, the complexity of existing process management and maintenance methods has significantly increased. Traditional management based on code repositories and document-based handover is no longer sufficient to cope with the current complexity, leading to increased maintenance costs and decreased efficiency. The special nature of fintech requires review processes to focus not only on the functionality of the code but also on security, compliance, and stability. This necessitates additional security review steps and compliance checks to ensure that code changes comply with financial regulatory requirements. This places higher demands on the compatibility and smoothness of the review process and continuous integration delivery and deployment process. At the same time, due to the high continuity requirements of financial business, system downtime needs to be minimized, which places higher demands on the speed and reliability of version delivery. To address the aforementioned issues, this invention proposes a method for continuous integration, delivery, and deployment, which mainly comprises three parts: a continuous integration system based on a distributed version control system, a delivery and deployment mode based on a distributed version control system, and a one-stop platform.

[0099] 1. Continuous Integration System Based on Distributed Version Control System

[0100] The definition and parameters of the continuous integration pipeline are stored in the code repository in the form of configuration files. One continuous integration configuration file is stored in the source code repository of each release unit, and when it is needed, it is automatically converted into a continuous integration pipeline by an open-source workflow management tool based on an open-source container orchestration platform.

[0101] Specifically, a pipeline can be understood as connecting multiple processing steps sequentially to form a unified workflow. This can specifically refer to an integration, delivery, or deployment process for a distributed version control system repository or an application. Integration can be understood as building an executable installation package from the source code of one or more distributed version control system repositories. Delivery can be understood as delivering the installation package built during integration to the production environment. Deployment can be understood as executing the installation package on the environment to make it effective. Open-source workflow management tools based on open-source container orchestration platforms can be understood as tools for orchestrating parallel and distributed computing tasks, allowing users to define complex workflows declaratively.

[0102] By using the branching mechanism of continuous integration configuration code and distributed version control system, when the application release cycle is monthly, the new monthly version branch of the application release unit can automatically inherit the configuration of the previous month's branch, thereby enabling the continuous integration pipeline to be automatically reused as a version is created, eliminating the manual configuration work of the pipeline.

[0103] Figure 3 This is a schematic diagram of a continuous integration process applicable to an embodiment of the present invention, as shown below. Figure 3 As shown, the process involves acquiring the source code files and continuous integration configuration files submitted by each code and continuous integration configuration release unit, building a version, and deploying the built version to the corresponding environment for testing. This includes: performing interface testing on the deployed application to ensure normal functionality; conducting smoke tests to quickly verify basic functions and ensure the main functions of the system are normal; and checking key nodes through access control points to ensure that the performance of key nodes meets requirements. Successfully built versions are then used to generate images and pushed to the image repository. The information in the configuration repository is updated to ensure the configuration is up-to-date. The source code files include the application project's source code, the continuous integration configuration files include configuration information defining the continuous integration process, the configuration repository stores the application's configuration information, and configuration updates automatically trigger subsequent delivery processes. The image repository stores the built images for subsequent deployment.

[0104] 2. Delivery and Deployment Model Based on Distributed Version Control System

[0105] The distributed version control system's repository serves as the sole source of application deployment information. Application configuration files and deployment configuration files (describing the final deployment environment information) are maintained in the distributed version control system's repository. An agent component of the distributed version control system is introduced to continuously monitor changes in the application state (i.e., state declarations) in the deployment configuration repository and continuously synchronize the application's described state with the actual state, enabling continuous incremental deployment of the application on cloud nodes.

[0106] Application configuration files can be understood as files that set configuration parameters for the application, define variable reference relationships, and are stored in the repository of a distributed version control system. Deployment configuration files can be understood as files that set runtime environment configuration parameters, reflect application deployment information in different environments, and reflect the relationship between application components and the deployment cluster, and are stored in the repository of a distributed version control system.

[0107] The source code repository, configuration repository, and environment repository are independent of each other. The source code repository is maintained by the application, while the configuration and environment repositories are maintained by a distributed version control system. Developers and configuration administrators can operate them through a front-end interface. The configuration and environment repositories are deployed according to a three-center architecture (development center, testing center, and production center), and use branches and directory structures to manage the configuration information of different versions and environments, ensuring isolation between environments and accurate management of configuration information.

[0108] Leveraging the full packaging of container images and the final-state deployment capabilities of open-source container orchestration platforms, a proxy component of a distributed version control system is introduced to achieve declarative deployment. This proxy component continuously monitors file changes and automatically initiates deployment upon approval. Historical environment changes can be traced directly through the distributed version control system's change logs, facilitating troubleshooting.

[0109] This orchestration approach, based on a visual deployment strategy, allows application containers to be deployed sequentially along with other components according to the orchestration order, such as by campus for production deployment, thus reducing application deployment risks. Here, a campus can be understood as different deployment projects or business modules, such as a mobile banking group, an online banking group, a payment system upgrade group, and a data analysis group.

[0110] Figure 4 This is a schematic diagram illustrating a delivery and deployment mode applicable to an embodiment of the present invention, such as... Figure 4 As shown, developers commit code to the code repository, which triggers a build process, generating an image through continuous integration and pushing it to the image repository. During continuous integration, the deployment configuration file and environment configuration file of the application are retrieved and pushed to the corresponding application configuration repository and environment repository to update the image configuration. A proxy component of the distributed version control system monitors changes to the application configuration repository and environment configuration repository, triggering an approval process.

[0111] Once approval is granted, the proxy component sends deployment instructions to the container orchestration cluster, which then pulls the image from the image repository and performs incremental deployment. The proxy component monitors the deployment status of each application within the open-source container orchestration cluster in real time. It retrieves the current version configuration file corresponding to the container that has undergone incremental deployment from the application configuration repository and environment repository, using this as the container version configuration file. When it determines that the application's deployment status is inconsistent with the container version configuration file, it automatically sends a synchronization deployment instruction to the open-source container orchestration cluster, instructing it to continue deploying the container image corresponding to the container version configuration file.

[0112] When the approval fails, the historical version configuration files in the application configuration library and environment library at the time of the configuration change will be used as the container version configuration file. The deployment status of each application in the open source container orchestration cluster will be monitored in real time through the proxy component. When it is determined that the deployment status of the application is inconsistent with the container version configuration file, a synchronization deployment instruction will be automatically sent to the open source container orchestration cluster to deploy the container image corresponding to the container version configuration file.

[0113] 3. One-stop platform

[0114] The one-stop platform is a portal-based front-end interface based on continuous integration, delivery, and deployment methodologies, covering all stages from development to production, as well as platform operation and management functions. It achieves comprehensive management of application management, environment operation and maintenance, platform operation and maintenance, and multiple environment views. Application management includes the management of source code repositories, configuration repositories, and environment repositories. Environment operation and maintenance includes the default creation of three isolated logical environments for applications: a development center, a business research center, and a production center, used for development, testing, and production respectively; providing cluster management, environment variable operation and maintenance, monitoring dashboards, log dashboards, alarm dashboards, and deployment management functions. Platform operation and maintenance includes infrastructure management, application management, and user management. Comprehensive management of multiple environment views connects the three centers of the distributed version control system, enabling data querying and writing of resource status, variable files, and logs through read / write permission isolation.

[0115] Figure 5 This is a schematic diagram of a one-stop platform applicable to an embodiment of the present invention, as shown below. Figure 5As shown, the one-stop platform includes: a global dashboard (including development and operation metrics, a global resource view, a global alarm view, and a development performance view), platform operation and maintenance management (including infrastructure management, application management, and user management), a development center, a business research center (including environment management, a business research suite, and infrastructure), and a production center unit. Development and operation metrics display key performance indicators related to development and operation, such as change failure rate and service recovery time. The global resource view provides a global view of resource usage. The global alarm view centrally displays alarm information. The development performance view displays data related to development efficiency. Infrastructure management manages the platform's infrastructure. Application management manages applications. User management manages user permissions and accounts. The development center manages application development-related activities. Environment management manages the configuration of different environments. The business research suite can be understood as integrated business research, combining business and R&D to achieve collaborative testing from requirement submission to product delivery, including functions such as environment variable operation and maintenance, log dashboards, and alarm dashboards. Infrastructure can be understood as the basic resources and systems supporting application and platform operation, including cluster management and database management. The production center is used to manage the application's production environment and monitor its production status. A one-stop platform may also include units such as code repository management, pipeline management, version management, and database version management.

[0116] In response to an information query command from the one-stop front-end display platform, if it is determined that the first information queried by the information query command has read permissions, the first information is provided to the one-stop front-end display platform for user display. In response to an information write command from the one-stop front-end display platform, if it is determined that the second information to be written by the information write command has write permissions, the second information is written to the matching data write location in the distributed version control system.

[0117] The continuous integration, delivery, and deployment method proposed in this invention achieves strong consistency among delivery, handover, production deployment, canary deployment, and rollback operations by unifying version information (resource files, etc.), configuration information (variables, etc.), and environment information (different configurations for different environments) in the revision file of a distributed version control system, thus solving the problem of multi-platform fragmentation. Based on a service group-level deployment process, it automatically identifies differences and deploys accordingly, ensuring deployment consistency across functional, R&D, and production environments and avoiding version omissions. Declaratively defining deployment models and resources by application group and storing them as code in the distributed version control system enables multi-version inheritance, historical tracing, and version rollback. This solves problems such as high maintenance costs, difficulty in tracing environmental changes, numerous variables requiring operational attention, and fragmented user experience associated with traditional maintenance methods, improving work efficiency and preventing potential production safety hazards.

[0118] Example 3

[0119] Figure 6 This is a schematic diagram of the structure of an apparatus for continuous integration, delivery, and deployment provided in Embodiment 3 of the present invention. Figure 6 As shown, the device includes: a trigger integration module 610, a build and test module 620, a container image module 630, and a deployment instruction module 640, wherein:

[0120] The integration module 610 is used to trigger the start of the continuous integration process when at least one piece of code to be integrated that matches the target source code is detected.

[0121] The test module 620 is used to perform automated build and code testing operations on the code to be integrated sequentially by executing the continuous integration process.

[0122] The container image module 630 is used to generate a container image to be deployed that matches the code to be integrated and push it to the image repository after the continuous integration process is completed.

[0123] The deployment instruction module 640 is used to automatically send deployment instructions to the open-source container orchestration cluster when the agent component in the distributed version control system detects that the container image to be deployed pushed to the image repository meets the deployment conditions, so that the container orchestration cluster can pull the container image to be deployed from the image repository for deployment.

[0124] In this system, the agent component in the distributed version control system is used to monitor and manage the deployment status of the application; the open-source container orchestration cluster includes at least one container, in which at least one application runs.

[0125] The technical solution of this invention triggers a continuous integration process when at least one piece of code matching the target source code is detected. The continuous integration process sequentially performs automated builds and code testing on the code to be integrated. After the continuous integration process is complete, a container image matching the code to be integrated is generated and pushed to the image repository. When the agent component in the distributed version control system detects that the container image pushed to the image repository meets the deployment conditions, it automatically sends deployment instructions to the open-source container orchestration cluster, allowing the cluster to pull the container image from the image repository for deployment. By running multiple containers in the container orchestration cluster, each running one or more applications, modular deployment and management of the system are achieved, improving system scalability. The agent component automatically sends deployment instructions to the container orchestration cluster, automating the deployment process, reducing labor and time costs, ensuring a tight connection between continuous integration and continuous deployment processes, improving overall delivery efficiency. The agent component monitors the application deployment status, enabling real-time monitoring of application deployment and operational status, facilitating timely problem detection and resolution, and improving system reliability and maintainability.

[0126] Based on the above embodiments, a test module 620 is constructed, specifically for:

[0127] By executing the continuous integration process, obtain at least one continuous integration configuration file submitted by a release unit to the distributed version control system and the code to be integrated that matches the target source code;

[0128] By using the branch automatic inheritance mechanism, version builds are performed on the continuous integration configuration file and the code to be integrated, resulting in the built updated configuration file and the built version file;

[0129] Deploy the built version file to the appropriate environment to perform at least one preset test;

[0130] The continuous integration process is considered successful when all preset tests are passed.

[0131] Based on the above embodiments, the container image module 630 is specifically used for:

[0132] The built version file is pushed to the image repository as a container image that matches the code to be integrated;

[0133] Update the application update configuration file in the update configuration file to the application configuration library;

[0134] Update the environment update configuration file in the environment repository.

[0135] Based on the above embodiments, a deployment instruction module 640 is specifically used for:

[0136] The proxy component monitors file changes in the application configuration repository and environment repository in real time. When a configuration change is detected, an approval process for the configuration change is triggered.

[0137] When the approval process is completed and the proxy component determines that the approval has been approved, it automatically sends an update deployment command to the open-source container orchestration cluster.

[0138] Optionally, based on the above embodiments, the deployment instruction module 640 may include: a failure unit, a first monitoring unit, and a first synchronization unit, wherein:

[0139] The "Failed Unit" is used to, after triggering the approval process for configuration changes through the proxy component, use the historical version configuration files in the application configuration library and environment library of the previous version at the time the configuration change was detected as the container version configuration file when the proxy component determines that the approval has failed based on the result of the approval process.

[0140] The first monitoring unit is used to monitor the deployment status of each application in the open-source container orchestration cluster in real time through the agent component;

[0141] The first synchronization unit is used to automatically send synchronization deployment instructions to the open-source container orchestration cluster when the agent component determines that the deployment status of the application is inconsistent with the container version configuration file, so as to deploy the container image corresponding to the container version configuration file.

[0142] Optionally, based on the above embodiments, the container orchestration cluster is used for incremental deployment based on changes in files in the application configuration repository and environment repository.

[0143] Accordingly, based on the above embodiments, the deployment instruction module 640 may include: an incremental version unit, a second monitoring unit, and a second synchronization unit, wherein:

[0144] Incremental version units are used to retrieve the current version configuration file corresponding to the container that has been incrementally deployed by the container orchestration cluster from the application configuration library and environment library after the update deployment command is automatically sent to the open source container orchestration cluster through the proxy component.

[0145] The second monitoring unit is used to monitor the deployment status of each application in the open-source container orchestration cluster in real time through the agent component.

[0146] The second synchronization unit is used to automatically send a synchronization deployment instruction to the open-source container orchestration cluster when the agent component determines that the deployment status of the application is inconsistent with the container version configuration file, so as to instruct the container orchestration cluster to continue deploying the container image corresponding to the container version configuration file.

[0147] Furthermore, based on the above embodiments, the apparatus for continuous integration, delivery, and deployment may further include:

[0148] The read permission module is used to respond to the information query command of the one-stop front-end display platform. When it is determined that the first information queried by the information query command has read permission, the first information is provided to the one-stop front-end display platform for user display.

[0149] The write permission module is used to respond to the information writing instruction of the one-stop front-end display platform. When it is determined that the second information to be written by the information writing instruction has write permission, the second information is written to the matching data writing position in the distributed version control system.

[0150] The one-stop platform includes: a global dashboard, platform operation and maintenance management, a development center, a business research center, and a production center.

[0151] The continuous integration, delivery, and deployment apparatus provided in the embodiments of the present invention can execute the continuous integration, delivery, and deployment method provided in any embodiment of the present invention, and has the corresponding functional modules and beneficial effects for executing the method.

[0152] The collection, storage, use, processing, transmission, provision, and disclosure of user personal information involved in the technical solution disclosed herein comply with the provisions of relevant laws and regulations and do not violate public order and good morals.

[0153] Example 4

[0154] Figure 7 A schematic diagram of an electronic device 10 that can be used to implement embodiments of the present invention is shown. The electronic device is intended to represent various forms of digital computers, such as laptop computers, desktop computers, workstations, personal digital assistants, servers, blade servers, mainframe computers, and other suitable computers. The electronic device can also represent various forms of mobile devices, such as personal digital processors, cellular phones, smartphones, wearable devices (e.g., helmets, glasses, watches, etc.), and other similar computing devices. The components shown herein, their connections and relationships, and their functions are merely illustrative and are not intended to limit the implementation of the invention described and / or claimed herein.

[0155] like Figure 7As shown, the electronic device 10 includes at least one processor 11 and a memory, such as a read-only memory (ROM) 12 or a random access memory (RAM) 13, communicatively connected to the at least one processor 11. The memory stores computer programs executable by the at least one processor. The processor 11 can perform various appropriate actions and processes based on the computer program stored in the ROM 12 or loaded from storage unit 18 into the RAM 13. The RAM 13 may also store various programs and data required for the operation of the electronic device 10. The processor 11, ROM 12, and RAM 13 are interconnected via a bus 14. An input / output (I / O) interface 15 is also connected to the bus 14.

[0156] Multiple components in electronic device 10 are connected to I / O interface 15, including: input unit 16, such as keyboard, mouse, etc.; output unit 17, such as various types of displays, speakers, etc.; storage unit 18, such as disk, optical disk, etc.; and communication unit 19, such as network card, modem, wireless transceiver, etc. Communication unit 19 allows electronic device 10 to exchange information / data with other devices through computer networks such as the Internet and / or various telecommunications networks.

[0157] Processor 11 can be a variety of general-purpose and / or special-purpose processing components with processing and computing capabilities. Some examples of processor 11 include, but are not limited to, a central processing unit (CPU), a graphics processing unit (GPU), various special-purpose artificial intelligence (AI) computing chips, various processors running machine learning model algorithms, a digital signal processor (DSP), and any suitable processor, controller, microcontroller, etc. Processor 11 performs the various methods and processes described above, such as continuous integration, delivery, and deployment methods, namely:

[0158] When at least one piece of code to be integrated that matches the target source code is detected, the continuous integration process is triggered.

[0159] By executing the continuous integration process, automated build and code testing operations are performed sequentially on the code to be integrated;

[0160] After the continuous integration process is completed, a container image to be deployed that matches the code to be integrated is generated and pushed to the image repository;

[0161] When the agent component in the distributed version control system detects that the container image to be deployed pushed to the image repository meets the deployment conditions, it automatically sends a deployment instruction to the open-source container orchestration cluster, so that the container orchestration cluster can pull the container image to be deployed from the image repository for deployment.

[0162] In this system, the agent component in the distributed version control system is used to monitor and manage the deployment status of the application; the open-source container orchestration cluster includes at least one container, in which at least one application runs.

[0163] In some embodiments, the continuous integration, delivery, and deployment methods may be implemented as a computer program tangibly contained in a computer-readable storage medium, such as storage unit 18. In some embodiments, part or all of the computer program may be loaded and / or installed on electronic device 10 via ROM 12 and / or communication unit 19. When the computer program is loaded into RAM 13 and executed by processor 11, one or more steps of the continuous integration, delivery, and deployment methods described above may be performed. Alternatively, in other embodiments, processor 11 may be configured to perform the continuous integration, delivery, and deployment methods by any other suitable means (e.g., by means of firmware).

[0164] Various embodiments of the systems and techniques described above herein can be implemented in digital electronic circuit systems, integrated circuit systems, field-programmable gate arrays (FPGAs), application-specific integrated circuits (ASICs), application-specific standard products (ASSPs), systems-on-a-chip (SoCs), payload-programmable logic devices (CPLDs), computer hardware, firmware, software, and / or combinations thereof. These various embodiments may include implementations in one or more computer programs that can be executed and / or interpreted on a programmable system including at least one programmable processor, which may be a dedicated or general-purpose programmable processor, capable of receiving data and instructions from a storage system, at least one input device, and at least one output device, and transmitting data and instructions to the storage system, the at least one input device, and the at least one output device.

[0165] Computer programs used to implement the methods of the present invention may be written in any combination of one or more programming languages. These computer programs may be provided to a processor of a general-purpose computer, a special-purpose computer, or other programmable data processing device, such that when executed by the processor, the computer programs cause the functions / operations specified in the flowcharts and / or block diagrams to be performed. The computer programs may be executed entirely on a machine, partially on a machine, or as a standalone software package, partially on a machine and partially on a remote machine, or entirely on a remote machine or server.

[0166] In the context of this invention, a computer-readable storage medium can be a tangible medium that may contain or store a computer program for use by or in conjunction with an instruction execution system, apparatus, or device. A computer-readable storage medium may include, but is not limited to, electronic, magnetic, optical, electromagnetic, infrared, or semiconductor systems, apparatus, or devices, or any suitable combination thereof. Alternatively, a computer-readable storage medium may be a machine-readable signal medium. More specific examples of machine-readable storage media include electrical connections based on one or more wires, portable computer disks, hard disks, random access memory (RAM), read-only memory (ROM), erasable programmable read-only memory (EPROM or flash memory), optical fibers, portable compact disk read-only memory (CD-ROM), optical storage devices, magnetic storage devices, or any suitable combination thereof.

[0167] To provide interaction with a user, the systems and techniques described herein can be implemented on an electronic device having: a display device (e.g., a CRT (cathode ray tube) or LCD (liquid crystal display) monitor) for displaying information to the user; and a keyboard and pointing device (e.g., a mouse or trackball) through which the user provides input to the electronic device. Other types of devices can also be used to provide interaction with the user; for example, feedback provided to the user can be any form of sensory feedback (e.g., visual feedback, auditory feedback, or tactile feedback); and input from the user can be received in any form (including sound input, voice input, or tactile input).

[0168] The systems and technologies described herein can be implemented in computing systems that include backend components (e.g., as data servers), or computing systems that include middleware components (e.g., application servers), or computing systems that include frontend components (e.g., user computers with graphical user interfaces or web browsers through which users can interact with implementations of the systems and technologies described herein), or any combination of such backend, middleware, or frontend components. The components of the system can be interconnected via digital data communication of any form or medium (e.g., communication networks). Examples of communication networks include local area networks (LANs), wide area networks (WANs), blockchain networks, and the Internet.

[0169] A computing system can include clients and servers. Clients and servers are generally located far apart and typically interact through communication networks. The client-server relationship is created by computer programs running on the respective computers and having a client-server relationship with each other. The server can be a cloud server, also known as a cloud computing server or cloud host, which is a hosting product within the cloud computing service system to address the shortcomings of traditional physical hosts and VPS services, such as high management difficulty and weak business scalability.

[0170] It should be understood that the various forms of processes shown above can be used, with steps reordered, added, or deleted. For example, the steps described in this invention can be executed in parallel, sequentially, or in different orders, as long as the desired result of the technical solution of this invention can be achieved, and this is not limited herein.

[0171] The specific embodiments described above do not constitute a limitation on the scope of protection of this invention. Those skilled in the art should understand that various modifications, combinations, sub-combinations, and substitutions can be made according to design requirements and other factors. Any modifications, equivalent substitutions, and improvements made within the spirit and principles of this invention should be included within the scope of protection of this invention.

Claims

1. A method for continuous integration, delivery, and deployment, characterized in that, Executed by a distributed version control system, including: When at least one piece of code to be integrated that matches the target source code is detected, the continuous integration process is triggered. By executing the continuous integration process, automated build and code testing operations are performed sequentially on the code to be integrated; After the continuous integration process is completed, a container image to be deployed that matches the code to be integrated is generated and pushed to the image repository; When the agent component in the distributed version control system detects that the container image to be deployed pushed to the image repository meets the deployment conditions, it automatically sends a deployment instruction to the open-source container orchestration cluster, so that the container orchestration cluster can pull the container image to be deployed from the image repository for deployment. In this system, the agent component in the distributed version control system is used to monitor and manage the deployment status of the application; the open-source container orchestration cluster includes at least one container, in which at least one application runs.

2. The method according to claim 1, characterized in that, By executing the continuous integration process, automated build and code testing operations are performed sequentially on the code to be integrated, including: By executing the continuous integration process, obtain at least one continuous integration configuration file submitted by a release unit to the distributed version control system and the code to be integrated that matches the target source code; By using the branch automatic inheritance mechanism, version builds are performed on the continuous integration configuration file and the code to be integrated, resulting in the built updated configuration file and the built version file; Deploy the built version file to the appropriate environment to perform at least one preset test; The continuous integration process is considered successful when all preset tests are passed.

3. The method according to claim 2, characterized in that, Generate a container image to be deployed that matches the code to be integrated and push it to the image repository, including: The built version file is pushed to the image repository as a container image that matches the code to be integrated; Update the application update configuration file in the update configuration file to the application configuration library; Update the environment update configuration file in the environment repository.

4. The method according to claim 3, characterized in that, When the proxy component in the distributed version control system detects that a container image pushed to the image repository meets the deployment conditions, it automatically sends deployment instructions to the open-source container orchestration cluster, including: The proxy component monitors file changes in the application configuration repository and environment repository in real time. When a configuration change is detected, an approval process for the configuration change is triggered. When the approval process is completed and the proxy component determines that the approval has been approved, it automatically sends an update deployment command to the open-source container orchestration cluster.

5. The method according to claim 4, characterized in that, After triggering the approval process for configuration changes via the proxy component, it also includes: When the proxy component determines that the approval has failed based on the result of the approval process, it will use the historical version configuration files in the application configuration library and environment library of the previous version at the time of the detected configuration change as the container version configuration file. Monitor the deployment status of each application in the open-source container orchestration cluster in real time through the proxy component; When the proxy component determines that the application's deployment status is inconsistent with the container version configuration file, it automatically sends a synchronization deployment command to the open-source container orchestration cluster to deploy the container image corresponding to the container version configuration file.

6. The method according to claim 4, characterized in that, The container orchestration cluster is used for incremental deployment based on changes in files in the application configuration repository and environment repository; Accordingly, after automatically sending update deployment commands to the open-source container orchestration cluster via the proxy component, it also includes: The proxy component retrieves the current version configuration file corresponding to the container that has been incrementally deployed by the container orchestration cluster from the application configuration repository and environment repository, and uses it as the container version configuration file. Monitor the deployment status of each application in the open-source container orchestration cluster in real time through the proxy component; When the proxy component determines that the application's deployment status is inconsistent with the container version configuration file, it automatically sends a synchronization deployment instruction to the open-source container orchestration cluster, instructing the container orchestration cluster to continue deploying the container image corresponding to the container version configuration file.

7. The method according to claim 1, characterized in that, The method further includes: In response to an information query command from the one-stop front-end display platform, when it is determined that the first information queried by the information query command has read permissions, the first information is provided to the one-stop front-end display platform for user display. In response to the information writing instruction of the one-stop front-end display platform, when it is determined that the second information to be written by the information writing instruction has write permission, the second information is written to the matching data writing position in the distributed version control system. The one-stop platform includes: a global dashboard, platform operation and maintenance management, a development center, a business research center, and a production center.

8. An electronic device, characterized in that, The electronic device includes: At least one processor; and A memory communicatively connected to the at least one processor; wherein, The memory stores a computer program that can be executed by the at least one processor to enable the at least one processor to perform the continuous integration, delivery, and deployment method according to any one of claims 1-7.

9. A computer-readable storage medium, characterized in that, The computer-readable storage medium stores computer instructions that, when executed by a processor, implement the continuous integration, delivery, and deployment method of any one of claims 1-7.

10. A computer program product, characterized in that, The computer program product includes a computer program that, when executed by a processor, implements the method of continuous integration, delivery, and deployment according to any one of claims 1-7.

Images