Containerized application and pipeline deployment method based on ai agent

Abstract

The application discloses a containerized application and pipeline deployment method based on an AI agent, relates to the technical field of artificial intelligence, and comprises the following steps: analyzing project deployment requirements by an AI agent to obtain deployment parameters, and generating a continuous integration script and application deployment configuration; calling the interface of a continuous integration tool and a code repository to create an automated build task; in response to a code submission event, automatically triggering the automated build task, completing image building, and uploading to a preset image repository; subsequently, a container orchestration system pulls a target image from the preset image repository, and automatically deploys an application instance on a target cluster based on the application deployment configuration. By introducing the AI agent, the application realizes full-process automation from project deployment requirement analysis to containerized application deployment, and reduces the manual intervention cost and configuration error risk in the traditional deployment process.

Description

Technical Field

[0001] This application relates to the field of artificial intelligence technology, and in particular to a containerized application and pipeline deployment method based on AI intelligent agents. Background Technology

[0002] In software deployment based on CI / CD (Continuous Integration and Continuous Deployment) pipelines and container orchestration systems, the initial configuration and deployment phases still rely on manually written scripts and configured build parameters, resulting in low efficiency and a high risk of errors during the first deployment. Furthermore, when build and runtime anomalies occur, manual review of logs and reliance on experience for analysis and handling are required, indicating insufficient automated diagnostic and repair capabilities. Therefore, current CI / CD pipeline deployment and container orchestration systems struggle to achieve efficient and automated deployment across the entire process from code submission to containerized application deployment.

[0003] The above content is only used to help understand the technical solution of this application and does not represent an admission that the above content is prior art. Summary of the Invention

[0004] The main purpose of this application is to provide a containerized application and pipeline deployment method based on AI intelligent agents, which aims to solve the technical problem that current CI / CD pipelines and container orchestration systems are difficult to automate.

[0005] To achieve the above objectives, embodiments of this application provide a containerized application and pipeline deployment method based on AI agents, the method comprising:

[0006] In response to the user's input of project deployment requirements, the AI ​​agent parses the project deployment requirements to obtain deployment parameters, and generates corresponding continuous integration scripts and application deployment configurations based on the deployment parameters;

[0007] Call the application programming interface (API) of the continuous integration tool to create an automated build task, and call the API of the code repository to establish an automatic triggering association between code commit events and the automated build task;

[0008] In response to the code commit event, the automated build task is automatically triggered to execute the continuous integration script, complete the construction of the container image, and upload the container image to the preset image repository;

[0009] A deployment command is submitted to the container orchestration system so that the container orchestration system pulls the target container image from the preset image repository and creates and deploys the corresponding application instance in the target cluster of the container orchestration system based on the target container image and the application deployment configuration.

[0010] This application embodiment also provides a containerized application and pipeline deployment device based on AI intelligent agents. The containerized application and pipeline deployment device based on AI intelligent agents includes: a memory, a processor, and a computer program stored in the memory and executable on the processor. The computer program is configured to implement the steps of the containerized application and pipeline deployment method based on AI intelligent agents as described above.

[0011] This application embodiment also provides a storage medium, which is a computer-readable storage medium, and stores a computer program on the storage medium. When the computer program is executed by a processor, it implements the steps of the containerized application and pipelined deployment method based on AI intelligent agents as described above.

[0012] One or more technical solutions proposed in this application have at least the following technical effects:

[0013] This application introduces an AI agent to automatically parse user-inputted project deployment requirements, extract deployment parameters, and generate continuous integration scripts and application deployment configurations based on these parameters. This solves the problems of low efficiency, high configuration error rates, and insufficient standardization caused by the reliance on manually written and maintained CI / CD scripts in traditional containerized deployments. By calling the application programming interface (API) of continuous integration tools and code repositories, automated build tasks are created, and the triggering association between code commit events and build tasks is automatically established. After code commit, the automated build task is automatically triggered to build the container image and upload it to the preset image repository, avoiding delivery delays caused by manual triggering or configuring breakpoints. Furthermore, by submitting deployment commands to the container orchestration system, it drives the system to automatically pull the target container image and create the corresponding application instance in the target cluster, establishing an end-to-end automated link from code change to production deployment. The synergistic effect of these technologies achieves full-process automation of containerized applications from project deployment requirement input to container deployment, significantly improving software delivery efficiency and operational scalability, while also reducing the cost of manual intervention and the risk of configuration errors in traditional deployment processes. Attached Figure Description

[0014] Figure 1 This is a flowchart illustrating the first embodiment of the containerized application and pipelined deployment method based on AI agents involved in the embodiments of this application.

[0015] Figure 2 This is a flowchart illustrating the second embodiment of the containerized application and pipelined deployment method based on AI intelligent agents involved in the embodiments of this application.

[0016] Figure 3This is a flowchart illustrating the third embodiment of the containerized application and pipelined deployment method based on AI agents involved in the embodiments of this application.

[0017] Figure 4 This is a flowchart illustrating the fourth embodiment of the containerized application and pipelined deployment method based on AI agents involved in the embodiments of this application.

[0018] Figure 5 This is a schematic diagram of CI / CD pipeline deployment of the fourth embodiment of the containerized application and pipeline deployment method based on AI intelligent agents involved in the embodiments of this application;

[0019] Figure 6 This is a flowchart illustrating the fifth embodiment of the containerized application and pipelined deployment method based on AI agents involved in the embodiments of this application.

[0020] Figure 7 This is a schematic diagram of the intelligent operation and maintenance of the container orchestration system in the fifth embodiment of the containerized application and pipeline deployment method based on AI intelligent agents involved in the embodiments of this application;

[0021] Figure 8 This is a schematic diagram of the structure of the containerized application and pipeline deployment equipment based on AI intelligent agents involved in the embodiments of this application.

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

[0023] It should be understood that the specific embodiments described herein are merely illustrative of this application and are not intended to limit this application.

[0024] To better understand the technical solution of this application, a detailed description will be provided below in conjunction with the accompanying drawings and specific implementation methods.

[0025] It should be noted that CI / CD (Continuous Integration and Continuous Deployment) is a core engineering practice that supports current software development. Its core goal is to deliver code changes to the production environment quickly and reliably through automated processes.

[0026] Continuous Integration (CI) is a software development practice that requires developers to frequently integrate their code into a shared codebase. Each code commit automatically triggers a build process, including code compilation, unit testing, and integration testing, with the aim of identifying integration issues as early as possible and ensuring the software version is always deliverable.

[0027] Continuous Deployment (CD), building upon continuous integration, automatically deploys code changes through automated testing to production-like or production environments. This enables rapid delivery of software functionality without human intervention, effectively avoiding operational errors and process delays that may be introduced by human intervention.

[0028] In addition, container orchestration systems, as key platforms for managing containerized applications, enable the deployment, scaling, and management of containerized applications through declarative configuration and automated scheduling mechanisms.

[0029] However, the integration of CI / CD and container orchestration systems still faces numerous bottlenecks. Specifically, in the software deployment process based on CI / CD (Continuous Integration and Continuous Deployment) pipelines and container orchestration systems, the initial configuration and first deployment of the pipeline still rely on manually written scripts, manually set build parameters, and debug deployment templates. This results in low efficiency for the first deployment and makes it prone to errors due to human negligence. Furthermore, when anomalies occur during the CI / CD pipeline build phase or the application runtime phase, operations personnel typically need to manually review logs, troubleshoot layer by layer, and rely on personal experience to determine the root cause and perform repair operations. This lack of automated diagnostic and repair capabilities leads to long response times and high recovery costs. Therefore, the overall intelligence level of current CI / CD pipeline deployment and container orchestration systems remains insufficient, making it difficult to achieve efficient and reliable automated deployment throughout the entire process from code submission to containerized application deployment.

[0030] To address the aforementioned issues, this application proposes a containerized application and pipelined deployment method based on AI intelligent agents. By deeply integrating natural language understanding, knowledge reasoning, and automated execution capabilities, it achieves fully automated generation of application deployment processes, constructs intelligent fault diagnosis and repair mechanisms, improves fault handling efficiency, and reduces reliance on human experience for problem troubleshooting. Simultaneously, by optimizing the operation and maintenance processes of the container orchestration system, it achieves intelligent resource management and automated operation and maintenance, significantly reducing manual intervention and improving the speed and stability of application deployment, thereby ensuring the efficient and stable operation of the system.

[0031] Specifically, this application, in response to user-inputted project deployment requirements, uses an AI agent to parse the requirements to obtain deployment parameters, and generates corresponding continuous integration scripts and application deployment configurations based on these parameters; it calls the application programming interface (API) of the continuous integration tool to create automated build tasks, and calls the API of the code repository to establish an automatic triggering association between code commit events and the automated build tasks; in response to the code commit events, it automatically triggers the automated build tasks to execute the continuous integration scripts, completes the construction of container images, and uploads the container images to a preset image repository; it submits deployment instructions to a container orchestration system, so that the container orchestration system pulls the target container image from the preset image repository, and creates and deploys corresponding application instances in the target cluster of the container orchestration system based on the target container image and the application deployment configuration.

[0032] This application introduces an AI agent to automatically parse user-inputted project deployment requirements, extract deployment parameters, and generate continuous integration scripts and application deployment configurations based on these parameters. This solves the problems of low efficiency, high configuration error rates, and insufficient standardization caused by the reliance on manually written and maintained CI / CD scripts in traditional containerized deployments. By calling the application programming interface (API) of continuous integration tools and code repositories, automated build tasks are created, and the triggering association between code commit events and build tasks is automatically established. After code commit, the automated build task is automatically triggered to build the container image and upload it to the preset image repository, avoiding delivery delays caused by manual triggering or configuring breakpoints. Furthermore, by submitting deployment commands to the container orchestration system, it drives the system to automatically pull the target container image and create the corresponding application instance in the target cluster, establishing an end-to-end automated link from code change to production deployment. The synergistic effect of these technologies achieves full-process automation of containerized applications from project deployment requirement input to container deployment, significantly improving software delivery efficiency and operational scalability, while also reducing the cost of manual intervention and the risk of configuration errors in traditional deployment processes.

[0033] It should be noted that the executing entity in this embodiment can be a software system or intelligent operation and maintenance platform deployed in a server environment, such as a continuous integration server, container orchestration management node, operation and maintenance control center, or other server-side devices with data acquisition, data processing, storage, network communication, and program execution functions; or a distributed computing system or AI agent capable of realizing the above-mentioned containerized applications and pipeline deployment. The following uses an AI agent as an example to describe this embodiment and the subsequent embodiments.

[0034] Please refer to the containerized application and pipelined deployment method based on AI agents proposed in the first embodiment of this application. Figure 1The method includes steps S10 to S40:

[0035] Step S10: In response to the user's input of project deployment requirements, the AI ​​agent parses the project deployment requirements to obtain deployment parameters, and generates corresponding continuous integration scripts and application deployment configurations based on the deployment parameters.

[0036] It should be noted that the AI ​​agent is a software entity with natural language processing, knowledge reasoning, and automated execution capabilities. In this application, it specifically refers to an intelligent agent system designed for containerized applications and CI / CD pipeline deployment scenarios. This AI agent integrates a large language model, a domain knowledge base, a script generation engine, and multiple development interfaces. It can connect to mainstream code repositories (hereinafter referred to as code repositories), continuous integration tools, container orchestration systems, Linux server systems, desktop operating systems, and monitoring systems through standardized application programming interfaces, achieving end-to-end intelligent collaboration and automatic control throughout the entire lifecycle of CI / CD pipeline deployment to container orchestration system operation and maintenance.

[0037] Additionally, it's important to note that project deployment requirements refer to application deployment needs described by users in natural language, forms, or structured instructions. These requirements include, but are not limited to, key information such as source code repository address, target deployment environment, development language type, runtime environment dependencies, and resource quotas. Deployment parameters are standardized configuration items extracted from project deployment requirements that can be directly used to configure scripts and deployment processes, such as JDK version, packaging tool type, cluster node address, port number, CPU and memory limits, etc. Continuous integration scripts are executable programs used to automate operations such as code pulling, compilation and packaging, code quality checks, image building, service deployment, and uploading in a CI / CD pipeline, such as Jenkinsfiles, YAML scripts, or shell scripts. Application deployment configurations are configuration files describing the application's runtime parameters in a container orchestration environment, including resource configuration information such as the number of replicas, CPU / memory quotas, service ports, environment variables, and storage volumes.

[0038] As a feasible implementation method, the AI ​​agent can use a natural language processing model based on the Transformer architecture to parse the user's input project deployment requirements. Specifically, the natural language processing model performs semantic understanding and named entity recognition on unstructured text (such as natural language descriptions) to accurately extract key parameters related to deployment, including but not limited to the development language type (such as Java, Python), framework and version number (such as Spring Boot 3.2), build tools (such as Maven, Gradle), target runtime environment (such as Kubernetes cluster), packaging method, resource configuration requirements (such as CPU request volume, memory limit, number of replicas), and network and storage requirements. This transforms ambiguous or semi-structured user intent into structured, executable deployment parameters, providing reliable input for subsequent script generation and automated configuration.

[0039] As another feasible implementation method, users are guided to fill in the project deployment requirements in a structured manner through predefined configuration templates and a visual form engine. Subsequently, the AI ​​agent performs semantic consistency verification, missing parameter inference, and compliance checks on the structured content input by the user (such as verifying the format of the image repository address and whether the resource quota exceeds the cluster capacity). It can also automatically complete the default values ​​or recommend the optimal configuration based on the built-in knowledge base, thereby reducing the input threshold for users while ensuring that the generated deployment parameters are accurate, complete, and in compliance with deployment specifications.

[0040] In the script generation phase, the AI ​​agent automates script generation based on a pre-built standardized script template library. This AI agent predefines service script templates covering mainstream development languages ​​and technology stacks, ensuring consistency and maintainability of generated scripts through unified script style specifications and a standardized variable parameter system. Specifically, the service script templates mainly include two categories: continuous integration script templates define a complete pipeline process including code retrieval, compilation and packaging, code quality checks, image creation, service deployment, and uploading, and allow flexible control over the personalized needs of different projects through parameter variable switches. Application deployment script templates provide standardized deployment solutions for server environments and container orchestration systems, used when deploying application services to servers or container orchestration systems.

[0041] Understandably, traditional deployment processes typically rely on operations personnel manually writing configuration scripts and deployment files, which is inefficient and prone to errors. This step introduces an AI agent with natural language understanding capabilities to automatically convert non-standardized user requirements into standardized, machine-executable continuous integration scripts and application deployment configurations. This avoids configuration errors and environmental discrepancies caused by human error, improves the standardization and success rate of the deployment process, and provides a reliable foundation for building a complete automated CI / CD pipeline.

[0042] Step S20: Call the application interface of the continuous integration tool to create an automated build task, and call the application interface of the code repository to establish an automatic triggering association between the code commit event and the automated build task.

[0043] It's important to note that continuous integration tools (CI) are tools used to automate the building, testing, and packaging of software, such as Jenkins, GitLab CI, and GitHub Actions. Application Programming Interfaces (APIs) are standardized interfaces that enable data interaction and function calls between different software systems. Automated build tasks are standardized workflow tasks executed by CI tools, including steps such as code pulling, compiling and packaging, code quality checks, image creation, and uploading. A code repository is a database system used to store and manage project source code, such as GitLab and GitHub. A code commit event is a system event triggered when local code is uploaded to a code repository; it's the condition for starting an automated build. Automatic trigger association refers to establishing trigger rules between code commit events and automated build tasks, so that the corresponding build task can be automatically started when a code commit event occurs.

[0044] As one possible implementation, step S20 includes steps S210 to S220:

[0045] Step S210: The AI ​​agent generates Webhook configuration parameters containing event types and branch filtering rules based on the code repository address and target branch information included in the project deployment requirements.

[0046] Step S220: Based on the Webhook configuration parameters, call the Webhook management interface of the code repository to complete the creation and configuration of the Webhook, and configure the trigger address of the automated build task as the payload URL of the Webhook to complete the automatic trigger association between the code submission event and the automated build task.

[0047] In this embodiment, after generating the continuous integration script and application deployment configuration, the AI ​​agent creates an automated build task by calling the API interface of the continuous integration tool, and uses the continuous integration script as the task execution logic. Subsequently, based on the code repository address and target branch information specified in the project deployment requirements, the AI ​​agent generates Webhook configuration parameters containing event types and branch filtering rules. Next, the AI ​​agent calls the Webhook management interface provided by the code repository and uses the aforementioned Webhook configuration parameters to complete the creation and configuration of the Webhook. Specifically, this includes setting the trigger address exposed by the automated build task (i.e., the build trigger URL of the continuous integration tool) as the Webhook's payload callback address and enabling a branch-level event filtering strategy to ensure that notifications are only sent to this URL when code is committed to the target branch.

[0048] Throughout the process, from creating automated build tasks to establishing an event listening mechanism, all API calls are automatically orchestrated and executed by the AI ​​agent. This eliminates the need for operations personnel to manually switch between continuous integration tools and the web console of the code repository, copy and paste URLs, or configure filtering rules, significantly improving the efficiency and accuracy of CI / CD pipeline initialization.

[0049] As another feasible implementation, when the AI ​​agent calls the interface to create automated build tasks, it can support a batch creation mode, that is, create associated build tasks for multiple modules of the same project at once, and manage task groups through tags. When establishing automatic trigger associations, in addition to triggering based on code commit events, it can also support the configuration of one or more trigger rules, such as timed triggering (e.g., executing a build every morning at midnight) and branch triggering (triggered only when code is committed to a specific branch).

[0050] Understandably, traditional processes require manual configuration on both the continuous integration tool and the code repository platform to establish a connection, which is cumbersome and prone to overlooking key settings. This step uses an AI agent to programmatically call the standard interfaces of the continuous integration tool and the code repository, effectively avoiding interruptions to the automated process caused by human configuration oversights. It achieves seamless integration from code submission to build task triggering, thereby improving the execution efficiency and reliability of the continuous integration process.

[0051] Step S30: In response to the code commit event, the automated build task is automatically triggered to execute the continuous integration script, complete the construction of the container image, and upload the container image to the preset image repository.

[0052] It's important to note that a container image is a standardized packaged file containing an application and its required operating system, dependencies, configuration files, etc. A default image repository is a repository system used to store and manage container images, supporting image uploading, downloading, version management, and access control, allowing container orchestration systems to pull target container images.

[0053] In this embodiment, when a developer pushes code to the code repository, the code repository's webhook service automatically sends a notification to the continuous integration tool. Upon receiving the notification, the continuous integration tool immediately schedules and executes the corresponding automated build task. This task first pulls the latest committed source code from the code repository, and then, following the process defined in the continuous integration script, sequentially executes steps such as environment setup, dependency installation, code compilation, and unit testing. After passing all testing stages, the continuous integration script executes the image build command, builds a new container image based on the source code and image build files, and generates corresponding version tags for this container image. Finally, the successfully built container image is pushed to a preset image repository for storage via the image push command, providing usable image resources for subsequent deployment processes.

[0054] Understandably, this step automates the entire process from code changes to image generation, ensuring that each code commit produces a standardized, deployable image in a timely manner. This helps reduce differences between development, testing, and production environments, improves the consistency and reliability of build results, effectively supports the implementation of continuous integration, and provides a fundamental guarantee for the rapid iteration and stable delivery of applications.

[0055] Step S40: Submit a deployment command to the container orchestration system so that the container orchestration system pulls the target container image from the preset image repository and creates and deploys the corresponding application instance in the target cluster of the container orchestration system based on the target container image and the application deployment configuration.

[0056] It's important to note that a deployment command is a declarative resource configuration request submitted to the container orchestration system. This includes the image address of the pre-defined image repository, the identifier information of the target image (e.g., image version number), the application deployment configuration, and the target deployment environment. The target cluster refers to a set of server nodes managed by the container orchestration system. These nodes are interconnected via a network to provide runtime resources for application instances. An application instance refers to a specific running instance launched within the target cluster based on a container image.

[0057] In this embodiment, after the container image is successfully uploaded to the preset image repository, the AI ​​agent or continuous integration tool calls the application programming interface (API) of the container orchestration system and submits a deployment command containing the application deployment configuration and the version tag of the newly built container image. Upon receiving the deployment command, the container orchestration system automatically schedules available nodes in the target cluster to pull the specified target container image from the preset image repository according to the resource specifications and deployment policies defined in the application deployment configuration. Subsequently, the target cluster instantiates Pod resources (i.e., application instances) on nodes that meet the resource constraints, and allocates infrastructure resources such as network policies and storage volumes to the application instance according to the requirements in the application deployment configuration, ultimately completing the service instance startup and service registration process. After deployment, the AI ​​agent continuously queries the status interface of the container orchestration system to monitor the Pod's running status in real time, ensuring that the application instance reaches a ready state and has service capabilities.

[0058] Understandably, this step automates the transformation from container images to running services, converting the traditionally complex, manual application deployment process into standardized declarative API calls. Leveraging the automated scheduling and lifecycle management capabilities of container orchestration systems, it effectively avoids issues such as improper node selection and resource configuration errors that may occur during manual deployment, thereby significantly improving deployment efficiency while ensuring application scalability and operational stability.

[0059] This embodiment deeply integrates AI agents into the CI / CD toolchain and container orchestration system, constructing a fully automated software delivery process from deployment requirement analysis to application instance deployment. This solution achieves automatic generation of deployment configurations and reliable creation of the runtime environment without human intervention, effectively overcoming the inefficiency and deployment error risks caused by reliance on manually written scripts and manual configuration in traditional deployment processes, thereby significantly improving overall deployment efficiency.

[0060] Based on the above embodiments of this application, in the second embodiment of this application, the content that is the same as or similar to that in the first embodiment can be referred to the above description, and will not be repeated hereafter. Based on this, please refer to... Figure 2 In the containerized application and pipeline deployment method based on AI intelligent agents, step S10 includes steps S110 to S130:

[0061] Step S110: The AI ​​agent performs semantic analysis on the project deployment requirements and extracts the deployment parameters.

[0062] As a feasible implementation method, the AI ​​agent can use a Transformer-based natural language processing model (such as BERT or GPT) to parse the user-inputted project deployment requirements. Specifically, the user-inputted project deployment requirements are first processed through word segmentation and syntactic analysis. Then, key technical parameters in the project deployment requirements are extracted through named entity recognition. Finally, entity disambiguation and relation reasoning are performed by combining domain-specific knowledge graphs, and a standardized set of deployment parameters is output.

[0063] For example, when a user enters "deploy a microservice application using Spring Boot 2.7 and JDK 17", the AI ​​agent can not only identify the technology stack as Spring Boot and JDK, but also infer the corresponding build tools, default port configurations and typical dependencies based on the knowledge graph.

[0064] Understandably, traditional deployment configuration requires users to provide complete and accurate technical parameters, which demands a high level of expertise and is prone to overlooking key configurations. This step, however, uses semantic analysis to automatically extract and complete deployment parameters from the user's simple natural language description, avoiding configuration errors caused by missing parameters, significantly lowering the user's learning curve and improving the accuracy and completeness of parameter extraction.

[0065] Step S120: Call the preset script template library, which includes continuous integration script templates and application deployment script templates. Each template contains replaceable variables corresponding to the deployment parameters.

[0066] In this embodiment, the AI ​​agent predefines service script templates covering mainstream development languages ​​and technology stacks. These service script templates mainly include two categories: one is continuous integration script templates, which define a complete pipeline process including code retrieval, compilation and packaging, code quality checks, image creation, service deployment, and uploading, and allow flexible control over the personalized needs of different projects through parameter variable switches. The other category is application deployment script templates, used when deploying application services to servers or container orchestration systems.

[0067] As a feasible implementation method, step S120 includes: matching the corresponding continuous integration script template and application deployment script template from the script template library according to the development language type and deployment target environment in the deployment parameters; wherein, the continuous integration script template has a built-in standard process of code retrieval, compilation and packaging, code quality inspection, image creation and image upload, and controls whether to enable personalized build steps through parameter variable switches; the application deployment script template includes server-oriented deployment mode and container orchestration system-oriented deployment mode, and automatically activates the corresponding deployment path according to the deployment target environment.

[0068] It's important to note that parameter variable switches achieve fine-grained control over optional build steps by pre-setting conditional logic within the script template. Specifically, conditional execution statements are set at key process nodes in the continuous integration script template, and their behavior is determined by the values ​​of corresponding variables in the deployment parameters. When user requirements include personalized features—that is, when the deployment parameters specify the need to execute specific personalized steps—the AI ​​agent sets the corresponding variable to an enabled state (e.g., "true"), triggering the execution of the corresponding step; otherwise, it is skipped. This allows for flexible adaptation to the build requirements of different projects without modifying the template structure.

[0069] Understandably, traditional deployment processes require writing or modifying deployment scripts individually for each project, which not only involves repetitive work but also makes it difficult to ensure the standardization and consistency of configurations. This step, by establishing a standardized script template library and combining it with an AI agent to automatically match and populate templates based on the development language and the target deployment environment, helps reduce the workload of repetitive script writing, making the generated scripts closer to the verified standard process. This improves the quality consistency and maintainability of deployment scripts, while significantly increasing script generation efficiency.

[0070] Step S130: Fill the deployment parameters into the replaceable variables corresponding to the continuous integration script template and the application deployment script template to generate the continuous integration script and the application deployment configuration.

[0071] It should be noted that the parameter input process is based on the template engine's structured rendering process, involving multiple stages such as variable parsing, type validation, and content generation. The mapping between deployment parameters and template variables follows strict type matching rules to ensure that numeric, string, and boolean parameters can be correctly parsed and processed.

[0072] In this embodiment, after generating the continuous integration script and application deployment configuration, the AI ​​agent uploads the generated continuous integration script and application deployment configuration to the corresponding code repository or storage for backup through a standardized interface, providing directly callable configuration resources for subsequent automated build and deployment tasks.

[0073] As one possible implementation, step S130 includes steps S1310 to S1340:

[0074] Step S1310: Obtain all replaceable variable identifiers defined in the continuous integration script template and the application deployment script template.

[0075] Step S1320: Match the deployment parameters with the replaceable variable identifiers, and identify the uncovered replaceable variable identifiers as configuration items to be completed.

[0076] Step S1330: For the configuration item to be completed, based on the deployment parameters extracted from the project deployment requirements, and combined with the pre-set technology stack knowledge graph and historical successful deployment case library, the AI ​​agent performs context-aware intelligent reasoning to generate the recommended configuration value corresponding to the configuration item to be completed.

[0077] Step S1340: Integrate the recommended configuration value with the deployment parameters to form a complete deployment parameter mapping, and fill the complete deployment parameter mapping into the replaceable variables corresponding to the continuous integration script template and the application deployment script template.

[0078] It should be noted that replaceable variable identifiers are placeholders declared in the script template using a preset syntax format, used to dynamically inject configuration values ​​before generating the corresponding script. Deployment parameter mapping refers to the correspondence table between deployment parameters and replaceable variable identifiers, ensuring that each replaceable variable receives the correct parameter value.

[0079] In this embodiment, the AI ​​agent parses the syntactic structure of the script template and extracts all replaceable variable identifiers that conform to the placeholder syntax specification. For each replaceable variable identifier, the AI ​​agent first performs a string-based exact match between it and the key name of each parameter field in the deployment parameters. If the match is successful, a mapping relationship is established between the replaceable variable identifier and the corresponding parameter value. If the match is unsuccessful, the AI ​​agent obtains the semantic meaning of the replaceable variable identifier. For example, the variable identifier "mem_limit" corresponds to the semantic tag "memory resource limit," and calculates the semantic similarity based on the semantic tag and the semantic representation of each parameter field in the deployment parameters. When the semantic similarity exceeds a preset semantic similarity threshold, it is determined that the semantic match is successful, and the corresponding mapping is established.

[0080] For replaceable variable identifiers that cannot be mapped even after the matching mechanism, the AI ​​agent identifies them as configuration items to be completed.

[0081] When generating recommended configuration values ​​for configuration items to be completed, the AI ​​agent first queries a pre-built technology stack knowledge graph to obtain default resource configuration rules associated with the technology stack combination involved in the current project (including development language version, application framework type, and container orchestration platform, such as Java 17, Spring Boot 3.x, and Kubernetes). Simultaneously, it retrieves historical deployment records from the historical successful deployment case library where the similarity between the technology stack feature vector and the feature vector corresponding to the current project's technology stack exceeds a preset similarity threshold, extracting the configuration value distribution for the corresponding missing variables. Furthermore, it weights and adjusts the configuration value distribution based on the current deployment target environment type (e.g., production or testing environment), ultimately outputting recommended configuration values ​​adapted to the current project.

[0082] As a feasible implementation method, the AI ​​agent employs a template engine based on an abstract syntax tree for parameter rendering. Specifically, the script template is first parsed into a structured syntax tree, then variable substitution and conditional branching are performed at the syntax tree level, and finally, an executable script file is regenerated. During the deployment parameter input process, multiple verification mechanisms are executed, including parameter value range verification, parameter dependency checks, and compatibility verification with the target environment. For example, when container resource limits are detected in the deployment parameters, the AI ​​agent automatically verifies the rationality of CPU and memory parameters and ensures that the generated configuration conforms to the cluster's resource constraint policies.

[0083] Understandably, the traditional method of manually filling in templates is prone to errors such as incomplete (or incorrect) variable replacements or configuration conflicts due to oversight, affecting the reliability of deployment. This step, through intelligent rendering based on syntax trees and a multi-validation mechanism, can effectively avoid deployment failures caused by parameter errors or configuration conflicts, thereby ensuring that the generated deployment configuration has high accuracy and environmental adaptability, providing a reliable guarantee for subsequent automated processes.

[0084] Based on the above embodiments of this application, in the third embodiment of this application, the same or similar content as the above embodiments can be referred to the above description, and will not be repeated hereafter. Based on this, please refer to... Figure 3 In the containerized application and pipeline deployment method based on AI intelligent agents, step S30 includes steps S310 to S340:

[0085] Step S310: During the execution of the automated build task, the AI ​​agent calls the application programming interface of the continuous integration tool in real time to obtain real-time build logs in order to monitor the build status throughout the process.

[0086] It should be noted that real-time build logs refer to text records dynamically generated and continuously output by continuous integration tools during the execution of automated build tasks. These logs include information such as command execution process, dependency download information, compilation output, test results, and error stacks. Build status, on the other hand, refers to the current stage or result of the automated build task, typically including status indicators such as "in progress," "success," "failure," "timeout," and "interrupted."

[0087] In this embodiment, the AI ​​agent continuously retrieves incremental log content by calling the API provided by the continuous integration tool at preset time intervals (e.g., every 10 seconds) through a polling mechanism or an event-driven webhook subscription method, and then caches and parses it. During this process, the AI ​​agent not only focuses on the final status code of the task but also performs real-time semantic scanning of the log content. By identifying specific keywords, error patterns, or abnormal behavior sequences (e.g., "compilation error," "out of memory," etc.), it determines whether there are potential failure risks. For example, even if the automated build task has not yet been officially marked as failed, if clear compilation errors or missing critical dependencies appear in the logs, the AI ​​agent can trigger the anomaly analysis process in advance, achieving early detection and proactive intervention of faults, thereby shortening the problem response time and avoiding unnecessary waiting.

[0088] Step S320: If the AI ​​agent detects a construction failure event, it performs semantic parsing on the real-time construction log through natural language processing to extract abnormal feature information.

[0089] It should be noted that a build failure event refers to the point in time when the continuous integration tool explicitly marks the build task as a failure, or when the AI ​​agent determines through log analysis that the build task can no longer continue.

[0090] In this embodiment, when a build failure event is detected, the AI ​​agent first preprocesses the collected real-time build logs, including log denoising, format standardization, and semantic segmentation.

[0091] Specifically, during semantic segmentation, continuous log streams are divided into log segments with complete semantics by identifying stack start identifiers and stage separators. Subsequently, semantic analysis is performed on the preprocessed log segments to identify and extract key error entities and exception patterns. For example, when processing logs containing "java.lang.OutOfMemoryError: Java heap space", "OutOfMemoryError" can be identified as the exception type, and "Java heap space" indicates that the faulty component is the JVM heap memory. Combined with possible memory value information in the log, the cause of the exception is attributed to insufficient resources. Finally, the extracted information is used to construct an exception feature vector containing dimensions such as exception type, faulty component, and exception cause.

[0092] Step S330: Match the abnormal feature information with historical abnormal construction cases in the knowledge base, locate the cause of the failure based on the matching result, and generate a corresponding configuration adjustment plan.

[0093] It should be noted that the knowledge base is a structured database containing historical build anomaly cases and their solutions. Each historical build anomaly case contains complete information such as anomaly feature vectors, root cause analysis, remediation solutions, and effect verification.

[0094] In this embodiment, by calculating the similarity between abnormal feature information and each historical build anomaly case, the target build anomaly case most relevant to the current build failure event is found in the knowledge base. Based on the matching results, the root cause recorded in the target build anomaly case is used as the diagnostic conclusion of the current build anomaly event, and the repair solution in the target build anomaly case is used as the basic template for generating the configuration adjustment solution.

[0095] During the process of generating configuration adjustment schemes, the AI ​​agent adaptively adjusts the basic template based on specific parameters of the current build environment. For example, it calculates the adjustment value of memory parameters based on the actual resource usage of the project, or determines the compatible version range based on the dependency tree, thereby forming a precise configuration adjustment scheme that can be executed immediately.

[0096] Step S340: Based on the configuration adjustment scheme, automatically correct the configuration of the automated build task and re-trigger the automated build task until the build is successful.

[0097] It should be noted that automatic correction refers to programmatically modifying the configuration parameters of automated build tasks in continuous integration tools, including key configuration items such as environment variables, dependency versions, and resource limits. Re-triggering refers to restarting the task build process based on the corrected configuration.

[0098] In this embodiment, the AI ​​agent executes a configuration adjustment scheme through the API interface provided by the continuous integration tool. Before performing the correction operation, a configuration snapshot is automatically created and a rollback point is recorded to ensure that the system can quickly revert to its original state if the correction produces unexpected results. During the correction process, the AI ​​agent also verifies the validity and compatibility of various parameters to avoid secondary failures due to configuration conflicts. When the build is retried, the AI ​​agent uses the latest code version and adds a retry flag for process tracking. This embodiment applies the corrected configuration to restart the task build process. If the task build still fails, iterative analysis and adjustments are performed based on the newly generated log information, and the effect data of each correction is continuously recorded to optimize the case quality and matching accuracy in the knowledge base, thereby achieving a self-evolving learning mechanism.

[0099] Based on the above embodiments of this application, in the fourth embodiment of this application, the same or similar content as the above embodiments can be referred to the above description, and will not be repeated hereafter. Based on this, please refer to... Figure 4In the containerized application and pipeline deployment method based on AI intelligent agents, step S40 includes steps S410 to S440:

[0100] Step S410: Based on the application deployment configuration, generate a deployment instruction for the container orchestration system. The deployment instruction includes the image address of the preset image repository, the identification information of the target container image, the identification information of the target cluster, and the configuration parameters of the application instance.

[0101] It's important to note that the default image repository's image address refers to the complete path of the target container image in the image registry, typically including the registry domain name, project namespace, image name, and tags. The target container image's identification information is metadata that identifies a specific image version. The target cluster's identification information is an identifier that specifies the deployment target in a multi-cluster environment; this can be a cluster name, ID, or API Server endpoint. The application instance's configuration parameters are the technical specifications that define the application's runtime behavior, including the number of replicas, CPU / memory quotas, service ports, environment variables, and storage volumes.

[0102] In this embodiment, the AI ​​agent constructs standardized deployment instructions according to the application deployment configuration and the interface specifications of the container orchestration system. These deployment instructions adopt a declarative configuration format, explicitly specifying the complete pull path of the target image, the version identifier, the location information of the target cluster, and all configuration parameters required for application operation.

[0103] Step S420: Send the deployment instruction to the container orchestration system.

[0104] Step S430: After receiving the deployment instruction, the container orchestration system parses the deployment instruction to obtain the image address of the preset image repository and the identification information of the target container image, and pulls the target container image from the preset image repository according to the image address and the identification information.

[0105] In this embodiment, the container orchestration system parses and verifies the received deployment instructions, confirming that their format is standardized and conforms to the cluster's deployment strategy. After successful verification, the container orchestration system uses the parsed image address and identification information as the target and initiates an image pull task from a preset image repository to worker nodes within the cluster. This process is automated by the container orchestration system, including identity authentication with the image repository, layered image downloading, and integrity security verification, ultimately ensuring that the target container image is successfully cached in the target cluster, preparing for the creation of subsequent application instances.

[0106] Step S440: The container orchestration system determines the target cluster based on the identification information of the target cluster, and creates and deploys the corresponding application instance in the target cluster based on the configuration parameters of the target container image and the application instance.

[0107] It's important to note that determining the target cluster involves routing decisions in a multi-cluster environment to ensure that deployment commands are correctly sent to the specified cluster context. Creating and deploying application instances is a comprehensive orchestration process, including multiple subtasks such as resource scheduling, container startup, service registration, and health checks.

[0108] In this embodiment, the container orchestration system routes the deployment task to the specified target cluster based on the target cluster identifier in the deployment command. After receiving the deployment task, the target cluster automatically completes resource scheduling and instance deployment according to the application instance's configuration parameters, including allocating compute nodes, loading the target container image, configuring network and storage resources, and finally starting the application service process. After deployment, the container orchestration system continuously monitors the running status of the application instance and ensures that the instance reaches a ready state through a predefined health check mechanism.

[0109] For example, to help understand the implementation process of the containerized application and pipelined deployment method based on AI agents obtained by combining the above embodiments, please refer to... Figure 5 , Figure 5 A schematic diagram of CI / CD pipeline deployment is provided, illustrating a containerized application and pipeline deployment method based on AI intelligent agents. Specifically:

[0110] First, the user inputs their project deployment requirements via natural language, such as "Deploy a microservice application developed using the Spring Boot framework, with the code located in the main branch of the GitHub repository myorg / user-service, and the target environment being a production cluster." This deployment requirement is received by a large language model agent and subjected to semantic analysis to extract deployment parameters, such as the development language, framework version, code repository address, target branch, and target deployment environment.

[0111] After obtaining the deployment parameters, the AI ​​agent first determines the corresponding continuous integration script template and application deployment script template based on the development language type and target environment in the deployment parameters. Then, based on the replaceable variable identifiers in the templates, it further evaluates the completeness of the deployment parameters, identifying undeclared configuration items to be completed, such as Java runtime version, container resource request values, and health probe paths. Subsequently, based on the deployment parameters extracted from the project deployment requirements, combined with a pre-built technology stack knowledge graph and a historical successful deployment case library, the AI ​​agent performs context-aware intelligent reasoning on the configuration items to be completed, generates recommended configuration values ​​for the items to be completed, integrates the recommended configuration values ​​with the deployment parameters to form a complete deployment parameter mapping, and fills the corresponding replaceable variables in the template with the complete deployment parameter mapping to generate the specific continuous integration script and application deployment configuration.

[0112] Next, the AI ​​agent calls the application programming interface (API) of the continuous integration tool to create an automated build task and uses the generated continuous integration script as the execution logic of the task. At the same time, the AI ​​agent calls the application programming interface of the code repository, and based on the code repository address and target branch information in the deployment parameters, generates Webhook configuration parameters containing event types and branch filtering rules, and configures the trigger address of the automated build task as the payload URL of the Webhook, thereby realizing the automatic trigger configuration between code commit events and automated build tasks.

[0113] When developers push code to the target branch of the code repository, the code repository sends an event notification to the continuous integration tool via a webhook mechanism, triggering the already created automated build task. During the build process, the AI ​​agent calls the continuous integration tool's API in real time to retrieve build logs and monitor the build status throughout. If a build anomaly is detected, natural language processing technology is used to automatically and intelligently analyze the build logs, such as extracting anomaly characteristic information and matching it with historical build anomaly cases in the knowledge base. This helps pinpoint the cause of the failure, generate a configuration adjustment plan, and then automatically correct the configuration parameters of the build task according to the adjustment plan, re-triggering the build until it succeeds and deployment is completed.

[0114] Based on the above embodiments of this application, in the fifth embodiment of this application, the same or similar content as the above embodiments can be referred to the above description, and will not be repeated hereafter. Based on this, please refer to... Figure 6 Following step S40, the containerized application and pipeline deployment method based on AI agents further includes steps S50-S90:

[0115] Step S50: Collect multi-dimensional operational data of the container orchestration system through the monitoring system. The multi-dimensional operational data includes operational status information of the network communication layer, node resource layer, cluster scheduling layer, and application service layer.

[0116] It should be noted that the monitoring system is a distributed data collection and processing tool used to interface with container orchestration systems, servers, and application services. Multidimensional runtime data is a collection of status data covering multidimensional monitoring metrics across the entire runtime chain of containerized applications.

[0117] In this embodiment, the monitoring dimensions of the container orchestration system are mainly carried out at four levels: network communication layer, node resource layer (such as server), cluster scheduling layer, and application service layer.

[0118] Network communication layer data includes basic network performance metrics such as network latency, bandwidth utilization, and throughput; inter-service communication metrics, such as monitoring DNS query failures, inter-service HTTP requests, RPC calls, or other communication protocols; network security metrics, such as monitoring for unauthorized traffic access; and load balancer-related metrics, such as status data on whether traffic distribution is even and whether there is traffic loss.

[0119] The node resource layer data includes the real-time CPU and memory utilization, disk space utilization and I / O performance of each computing node, node health status and the rationality of resource allocation, which are used to identify phenomena such as resource contention.

[0120] Cluster scheduling layer data includes application load status such as Pod running status and the number of Deployment controller replicas, scale indicators such as the total number of cluster nodes and the number of Pods, and control performance indicators such as the response time, call frequency and failure rate of the container orchestration system API service.

[0121] Application service layer data mainly includes key performance indicators such as application service response time, throughput, and request success rate, abnormal patterns and error information in application logs, and service operation events recorded in the container orchestration system, which can provide comprehensive data support for AI agents to perform fault analysis and automated operation and maintenance.

[0122] As one possible implementation, step S50 is followed by steps S51 to S54:

[0123] Step S51: Based on the collected multidimensional runtime data, construct the resource timing sequence of each application instance in the container orchestration system.

[0124] It should be noted that a resource time series is a set of continuous data points arranged in chronological order that reflects the resource usage of an application instance. It typically includes core metrics such as CPU utilization, memory usage, network bandwidth, and storage IOPS.

[0125] Step S52: Based on the resource time series, predict the resource demand trend of the application instance within a future preset time window using a time series prediction model.

[0126] It should be noted that time-series forecasting models are machine learning or neural network models used to infer future resource load based on historical resource usage. Their output is the expected value or confidence interval of resource indicators within a future period (e.g., the next hour). Resource demand trends refer to the expected trajectory of changes in the demand for various resources by application instances over a specific future time period.

[0127] In this embodiment, a deep learning model based on LSTM (Long Short-Term Memory) or Transformer can be used for pre-training. Specifically, firstly, historical resource monitoring data of each application instance in the content orchestration system over a past period (e.g., the past 30 days) is acquired. This historical resource monitoring data includes multi-dimensional indicators such as CPU utilization, memory usage, network throughput, and disk I / O recorded at fixed sampling intervals. Subsequently, the historical resource monitoring data is divided into multiple continuous subsequences using a sliding window mechanism. Each subsequence contains historical resource indicator values ​​at consecutive time points, forming a historical resource time series. Next, the historical resource time series is used as training data input into the model. The model parameters are optimized by minimizing the error between the predicted values ​​and the actual observed values. The loss function can be the mean squared error or the mean absolute error, and the optimization process uses the Adam optimization algorithm.

[0128] During the operation and maintenance phase, the monitoring system continuously collects real-time multi-dimensional operational data from the container orchestration system. Based on this data, the AI ​​agent constructs a current resource time-series sequence and inputs it into a trained time-series prediction model. The model, based on learned resource usage patterns, outputs predicted values ​​or confidence intervals for various resource indicators within a preset future time window. This prediction accurately reflects the dynamic trends of business load changes, providing a quantitative basis for subsequent resource scheduling strategies and enabling a shift from a passive response to a proactive planning-based operation and maintenance model.

[0129] Step S53: Generate a corresponding resource scheduling strategy based on the degree of deviation between the resource demand trend and the current resource configuration.

[0130] In this embodiment, the AI ​​agent quantitatively compares the predicted resource demand trend with the current actual resource configuration, calculating the degree of deviation for each resource dimension (e.g., CPU, memory). Optionally, the degree of deviation can be determined by comprehensively evaluating the deviation between the predicted resource demand and the current resource configuration in both numerical magnitude and duration. For example, if the predicted CPU utilization or memory usage exceeds a preset threshold for the current configuration value for N consecutive time points in the future, a significant positive deviation is determined, and resource expansion operations need to be triggered; conversely, if the predicted value is consistently below the lower limit of the threshold (e.g., 30%), it is considered resource redundancy, and scaling down can be performed to release idle resources.

[0131] The AI ​​agent determines matching scheduling actions from a predefined policy template library based on the type and deviation of resource metrics, thereby generating resource scheduling policies. These policies include horizontal scaling (e.g., adjusting the number of Deployment replicas), vertical resource adjustment (e.g., modifying Pod resource request and limit parameters), Pod migration (scheduling application instances to low-load nodes), and load balancing (adjusting service traffic distribution). Furthermore, all resource scheduling policies are accompanied by rollback trigger rules to ensure operational security and controllability.

[0132] It should be noted that vertical resource adjustment refers to dynamically modifying the computing resource quota requested or limited by a single container (Pod) without changing the number of application instances. Specifically, this includes adjusting parameters such as CPU requests, CPU limits, memory requests, and memory limits.

[0133] Step S54: Call the application programming interface of the container orchestration system to execute the resource scheduling strategy to optimize the resource allocation of the application instance.

[0134] In this embodiment, the AI ​​agent executes the corresponding resource scheduling strategy through the application programming interface provided by the container orchestration system. During execution, application performance metrics and resource usage are monitored in real time to ensure smooth scheduling operations. Simultaneously, execution logs for all scheduling operations are recorded. When anomalies in key performance metrics are detected or a scheduling operation fails, a pre-set rollback process is automatically triggered to restore the system to its pre-operation state, ensuring the safe and controllable resource adjustment process.

[0135] For example, when the AI ​​agent detects a continuous increase in service request traffic and CPU utilization exceeding a preset utilization threshold, it automatically triggers horizontal scaling operations to increase the number of service instance replicas to cope with peak business periods. When high application memory is detected, the AI ​​agent can perform Pod migration or restart operations during off-peak business periods to alleviate or release memory resources and restore service stability. When the overall available resources of the cluster (such as CPU and memory) are detected to be below a safe threshold, the AI ​​agent can automatically increase server resources or generate resource expansion alarms and notify operations personnel to intervene. In addition, when the disk usage of a cluster node is identified to exceed a threshold, the AI ​​agent automatically executes space release strategies such as log archiving, temporary file cleanup, or image garbage collection to release corresponding resources and ensure the normal operation of the node.

[0136] Step S60: The AI ​​agent compares the multi-dimensional operating data with the corresponding alarm threshold in real time to determine whether there is an operating fault.

[0137] It should be noted that the alarm threshold is a predefined boundary value used to distinguish between the normal and abnormal states of various indicator data.

[0138] In this embodiment, the alarm thresholds include a default threshold, an adaptive threshold, and a manually set threshold. The manually set threshold has the highest priority, while the default threshold has the lowest priority. The manually set threshold is directly defined by operations personnel based on business importance, project deployment requirements, or specific scenario needs. The adaptive threshold is dynamically calculated and generated by the AI ​​agent based on historical operational data of the container orchestration system, analyzing its periodic patterns, trend characteristics, and fluctuation range. The default threshold is a general safety value built into the container orchestration system.

[0139] In this embodiment, after the AI ​​agent obtains multi-dimensional operational data from the container orchestration system, it compares any monitoring indicator against an alarm threshold according to a preset priority order. If a manually set threshold exists for the monitoring indicator, it is used first for comparison. If the current monitoring indicator value exceeds the corresponding threshold range, an operational fault is identified. If no manually set threshold exists, it checks for a trained adaptive threshold. If so, the current monitoring indicator value is compared with a dynamic baseline and its confidence interval. If the deviation exceeds the allowable range, it is identified as abnormal. If neither a manually set threshold nor a valid adaptive threshold exists, the default threshold is used for judgment.

[0140] As one possible implementation, steps S601 to S603 are included before step S60:

[0141] Step S601: Obtain the historical time series data sequence of the multidimensional running data within the historical time period.

[0142] Step S602: Identify the periodic patterns and trend characteristics corresponding to different dimensions of operating indicators in the historical time series data sequence through a time series analysis model.

[0143] Step S603: Based on the periodic pattern and the trend characteristics, calculate the normal fluctuation range of each of the operating indicators in different time periods, and use the boundary value of the normal fluctuation range as the adaptive threshold of the corresponding operating indicator.

[0144] In this embodiment, multidimensional operational data within a preset historical time period is first acquired, and a historical time-series data sequence with a complete business cycle is constructed based on this data. Next, a pre-trained time-series analysis model is used to perform pattern recognition analysis on the historical time-series data sequence. It should be noted that this model has been pre-trained using large-scale historical operational data and possesses the ability to identify various periodic patterns and trend characteristics. The time-series analysis model automatically extracts the periodic patterns (e.g., repetitive fluctuations on an hourly, daily, or weekly basis) and long-term evolution trends present in each operational indicator by analyzing the time dependencies between historical data points in the historical time-series data sequence. Based on the identified periodic patterns and trend characteristics, statistical methods are used to determine the normal fluctuation range of each operational indicator within different time periods (e.g., divided by hours), and the boundary value of this normal fluctuation range is set as the adaptive threshold for the corresponding operational indicator.

[0145] Optionally, the adaptive threshold generation process can be triggered after the AI ​​agent completes the initial deployment of the containerized application, or during updates at a preset period. Specifically, after the initial application deployment, the AI ​​agent needs to collect historical operational data of the application over at least one complete business cycle within the container orchestration system, and use a time-series analysis model to initially learn the application's normal operating mode, generating initial adaptive thresholds. During subsequent operations and maintenance, the AI ​​agent can periodically (e.g., weekly or monthly) re-execute the adaptive threshold generation process, using newly added operational data to update its understanding of the application's behavior patterns and recalculate the adaptive thresholds, thereby ensuring that the threshold rules continuously adapt to business evolution and load changes. This mechanism ensures that intelligent monitoring capabilities are available immediately after application deployment, and maintains the accuracy of the threshold rules through periodic self-updating.

[0146] Optionally, the STL (Seasonal and Trend decomposition using Loess) algorithm is applied to historical time-series data sequences to identify the periodic fluctuation patterns and long-term trends of each operational indicator. Based on the periodic and trend components obtained from the decomposition, statistical methods are used to calculate the normal fluctuation range of each operational indicator in different time periods, and the boundary values ​​of this range are set as the corresponding adaptive thresholds, thereby generating threshold rules that can be dynamically adjusted over time. For example, for the CPU utilization indicator, a higher upper limit threshold is set for peak business periods (e.g., working hours), while a lower upper limit threshold is set for off-peak business periods, thus achieving precise adaptation to fluctuations in business load.

[0147] Step S70: If the operational fault is detected, extract the fault feature information corresponding to the operational fault.

[0148] In this embodiment, when an operational fault is detected after comparing alarm thresholds, a correlation analysis is performed on the multi-dimensional operational data related to the fault. Specifically, the AI ​​agent first determines the fault indicators and, based on the topology of the container orchestration system, identifies the related components and derived anomaly indicators affected by the fault indicators. Subsequently, by analyzing the changing patterns of the fault indicators and derived anomaly indicators within the fault time window, temporal features including the anomaly start point, duration, and fluctuation frequency are extracted. Finally, the overall impact level is assessed by comprehensively considering the fault's propagation range and performance degradation. For example, for a fault with excessive CPU utilization, the AI ​​agent not only records its peak value and duration but also simultaneously extracts changes in associated memory usage, restart behavior of related containers, and response latency of upstream and downstream services, thereby constructing a complete fault feature profile describing the fault phenomenon, its impact chain, and its severity.

[0149] Step S80: Match the fault feature information with historical fault cases in the operation and maintenance knowledge base, and generate corresponding automated processing solutions based on the matching results.

[0150] It should be noted that the operations and maintenance knowledge base is a database containing historical failure cases and corresponding solutions. Each historical failure case includes a complete failure context, diagnostic process, and remediation plan. Automated processing solutions are specific remediation operations for specific failure types, including standardized operations such as resource adjustments, configuration changes, and service restarts.

[0151] In this embodiment, the AI ​​agent employs a vector similarity-based matching algorithm to calculate the similarity between the feature vector of the current fault characteristic information and the case vectors of historical fault cases in the operation and maintenance knowledge base. The top K cases with the highest similarity are selected as candidate fault cases. Subsequently, the AI ​​agent performs a multi-dimensional weighted evaluation of the candidate fault cases, comprehensively considering factors such as environment configuration similarity, technology stack matching, and case freshness, to determine the target fault case most relevant to the current fault and pinpoint the specific cause of the fault. Finally, based on the repair plan recorded in the target fault case, the AI ​​agent performs parameter optimization and adaptive modifications according to the specific constraints of the current container orchestration environment to generate a directly executable automated processing solution.

[0152] Step S90: Call the application programming interface of the container orchestration system to execute the automated processing scheme to automatically repair the operational failure.

[0153] It should be noted that calling the application programming interface of the container orchestration system refers to sending control commands to the orchestration system through programming to achieve automated operation of cluster resources and application status.

[0154] In this embodiment, the AI ​​agent executes repair operations through the standard management interface provided by the container orchestration system, establishing a complete operational safety guarantee mechanism during execution. Specifically, a progressive repair strategy is adopted, prioritizing basic operations with minimal impact and low rollback difficulty; if the initial repair fails to resolve the issue, more complex repair steps are then executed step by step according to the automated processing plan. System state snapshots and rollback points are automatically created before all critical operations are executed, ensuring rapid restoration to the pre-operation state in case of unexpected situations during the repair process. Simultaneously, the AI ​​agent continuously monitors the changing trends of various indicators during the repair process, evaluating the repair effect in real time, forming a complete "execution-monitoring-evaluation" closed loop to ensure that operational faults are effectively resolved.

[0155] This embodiment achieves intelligent and automated operation and maintenance (O&M) of containerized applications during the runtime phase by constructing an automated O&M closed loop of "monitoring-diagnosis-repair". This embodiment can perform real-time monitoring and intelligent analysis of the full-stack runtime status of the container orchestration system. When operational failures are detected, it automatically locates the root cause and generates corresponding repair solutions, ultimately executing automated repair operations. This effectively solves the problems of delayed fault response, reliance on manual diagnosis, and high risk of repair operations in traditional O&M models, significantly improving system availability and O&M efficiency, and realizing the transformation from "manual O&M" to "intelligent O&M".

[0156] For example, to help understand the implementation process of the containerized application and pipelined deployment method based on AI agents obtained by combining the above embodiments, please refer to... Figure 7 , Figure 7 A schematic diagram of intelligent operation and maintenance of a container orchestration system based on an AI agent-based containerized application and pipeline deployment method is provided. Specifically:

[0157] After deployment, the AI ​​agent enters the intelligent operation and maintenance phase. Through the collaborative closed loop between the monitoring system, the AI ​​agent, and the container orchestration system, it achieves continuous perception, intelligent diagnosis, and automated repair of the operational status of containerized applications.

[0158] Specifically, the AI ​​agent collects multi-dimensional operational data from each application instance in the container orchestration system in real time by calling the monitoring system's application programming interface (API). This includes request latency and error rate at the network communication layer, CPU and memory usage at the node resource layer, Pod status changes at the cluster scheduling layer, and application service response time, request success rate, and health probe response results at the application service layer. The AI ​​agent then compares this multi-dimensional operational data with preset alarm thresholds for each indicator in real time to determine if any operational faults exist. These alarm thresholds include default thresholds, manually set thresholds, and adaptive thresholds generated based on historical time-series data analysis to improve the accuracy and robustness of alarms.

[0159] When an operational failure is detected, the AI ​​agent extracts the corresponding failure feature information and matches it with historical failure cases in the operations and maintenance knowledge base. Based on the matching results, it generates a corresponding automated handling plan. Subsequently, the AI ​​agent calls the container orchestration system's API to execute the automated handling plan, such as restarting the abnormal Pod, increasing the number of replicas, or isolating the problematic node, thereby achieving automated failure handling.

[0160] Furthermore, the AI ​​agent can intelligently schedule resources for application instances in the container orchestration system based on resource usage trends reported by the monitoring system. For example, if an application instance is found to be under low load for an extended period and its resource utilization is below a preset lower limit, a scaling-down operation will be automatically triggered; conversely, if the application instance is under continuous high load and close to its resource limit, a scaling-up / scaling suggestion will be initiated or an elastic scaling strategy will be directly executed to optimize overall resource utilization.

[0161] In the process of intelligent operation and maintenance, the AI ​​agent, as the core decision-making center, not only receives status input from the monitoring system, but also issues control commands to the container orchestration system, forming a two-way interactive intelligent operation and maintenance closed loop. This effectively realizes the technological evolution from passive alarm to active intervention and from static configuration to dynamic optimization, significantly improving the stability and operation and maintenance efficiency of containerized applications.

[0162] This application provides a containerized application and pipeline deployment device based on AI agents. The containerized application and pipeline deployment device based on AI agents includes: at least one processor; and a memory communicatively connected to the at least one processor; wherein the memory stores instructions that can be executed by the at least one processor, and the instructions are executed by the at least one processor to enable the at least one processor to execute the containerized application and pipeline deployment method based on AI agents in the above embodiment 1.

[0163] The following is for reference. Figure 8 The diagram illustrates a structural schematic of a containerized application and pipelined deployment device based on AI agents suitable for implementing embodiments of this application. The containerized application and pipelined deployment device based on AI agents in the embodiments of this application may include various hardware and software components for implementing containerized application and pipelined deployment methods based on AI agents. Figure 8 The containerized application and pipeline deployment equipment based on AI agents shown are merely examples and should not impose any limitations on the functionality and scope of use of the embodiments of this application.

[0164] like Figure 8 As shown, the containerized application and pipelined deployment device based on AI agents may include a processing device 1001 (e.g., a central processing unit, a graphics processing unit, etc.), which can perform various appropriate actions and processes according to programs stored in read-only memory (ROM) 1002 or programs loaded from storage device 1003 into random access memory (RAM) 1004. The random access memory 1004 also stores various programs and data required for the operation of the containerized application and pipelined deployment device based on AI agents. The processing device 1001, ROM 1002, and RAM 1004 are interconnected via a bus 1005. An input / output (I / O) interface 1006 is also connected to the bus. Typically, the following systems can be connected to I / O interface 1006: input devices 1007 including, for example, touchscreens, touchpads, keyboards, etc.; output devices 1008 including, for example, liquid crystal displays (LCDs), speakers, vibrators, etc.; storage devices 1003 including, for example, magnetic tapes, hard drives, etc.; and communication devices 1009. Communication device 1009 allows containerized applications and pipelined deployment devices based on AI agents to communicate wirelessly or wiredly with other devices to exchange data. Although the figure shows containerized applications and pipelined deployment devices based on AI agents with various systems, it should be understood that it is not required to implement or have all the systems shown. More or fewer systems can be implemented alternatively.

[0165] Specifically, according to the embodiments disclosed in this application, the processes described above with reference to the flowcharts can be implemented as computer software programs. For example, embodiments disclosed in this application include a computer program product comprising a computer program carried on a computer-readable medium, the computer program containing program code for performing the methods shown in the flowcharts. In such embodiments, the computer program can be downloaded and installed from a network via a communication device, or installed from storage device 1003, or installed from read-only memory 1002. When the computer program is executed by processing device 1001, it performs the functions defined in the methods of the embodiments disclosed in this application.

[0166] The containerized application and pipeline deployment device based on AI agents provided in this application, employing the containerized application and pipeline deployment method based on AI agents in the above embodiments, can solve the technical problem that current CI / CD pipelines and container orchestration systems are difficult to automate deployment. Compared with the prior art, the beneficial effects of the containerized application and pipeline deployment device based on AI agents provided in this application are the same as those of the containerized application and pipeline deployment method based on AI agents provided in the above embodiments, and other technical features in this containerized application and pipeline deployment device based on AI agents are the same as those disclosed in the previous embodiment method, and will not be repeated here.

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

[0168] The above description is merely a specific embodiment of this application, but the scope of protection of this application is not limited thereto. Any variations or substitutions that can be easily conceived by those skilled in the art within the scope of the technology disclosed in this application should be included within the scope of protection of this application. Therefore, the scope of protection of this application should be determined by the scope of the claims.

[0169] This application provides a computer-readable storage medium having computer-readable program instructions (i.e., a computer program) stored thereon, which are used to execute the containerized application and pipelined deployment method based on AI agents in the above embodiments.

[0170] The computer-readable storage medium provided in this application may be, for example, a USB flash drive, but is not limited to, electrical, magnetic, optical, electromagnetic, infrared, or semiconductor systems, devices, or any combination thereof. More specific examples of computer-readable storage media may include, but are not limited to: electrical connections having 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 fiber, portable compact disk read-only memory (CD-ROM), optical storage devices, magnetic storage devices, or any suitable combination thereof. In this embodiment, the computer-readable storage medium may be any tangible medium containing or storing a program that can be used by or in conjunction with an instruction execution system, system, or device. The program code contained on the computer-readable storage medium may be transmitted using any suitable medium, including but not limited to: wires, optical cables, radio frequency (RF), etc., or any suitable combination thereof.

[0171] The aforementioned computer-readable storage medium may be included in containerized applications and pipeline deployment devices based on AI agents; or it may exist independently and not assembled into containerized applications and pipeline deployment devices based on AI agents.

[0172] The aforementioned computer-readable storage medium carries one or more programs. When these programs are executed by an AI-based containerized application and pipeline deployment device, the AI-based containerized application and pipeline deployment device: responds to a user-inputted project deployment requirement, parses the project deployment requirement using an AI agent to obtain deployment parameters, and generates a corresponding continuous integration script and application deployment configuration based on the deployment parameters; calls the application programming interface (API) of the continuous integration tool to create an automated build task, and calls the API of the code repository to establish an automatic triggering association between the code commit event and the automated build task; responds to the code commit event, automatically triggers the automated build task to execute the continuous integration script, completes the construction of the container image, and uploads the container image to a preset image repository; submits a deployment instruction to the container orchestration system, so that the container orchestration system pulls the target container image from the preset image repository, and creates and deploys a corresponding application instance in the target cluster of the container orchestration system based on the target container image and the application deployment configuration.

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

[0174] The flowcharts and block diagrams in the accompanying drawings illustrate the architecture, functionality, and operation of possible implementations of systems, methods, and computer program products according to various embodiments of this application. In this regard, each block in a flowchart or block diagram may represent a module, segment, or portion of code containing one or more executable instructions for implementing a specified logical function. It should also be noted that in some alternative implementations, the functions indicated in the blocks may occur in a different order than those indicated in the drawings. For example, two consecutively indicated blocks may actually be executed substantially in parallel, and they may sometimes be executed in reverse order, depending on the functions involved. It should also be noted that each block in the block diagrams and / or flowcharts, and combinations of blocks in the block diagrams and / or flowcharts, may be implemented using a dedicated hardware-based system that performs the specified function or operation, or using a combination of dedicated hardware and computer instructions.

[0175] The modules described in the embodiments of this application can be implemented in software or hardware. The names of the modules do not necessarily limit the functionality of the unit itself.

[0176] The readable storage medium provided in this application is a computer-readable storage medium that stores computer-readable program instructions (i.e., computer programs) for executing the above-described AI agent-based containerized application and pipeline deployment method. This solves the technical problem that current CI / CD pipelines and container orchestration systems struggle to achieve automated deployment. Compared with existing technologies, the beneficial effects of the computer-readable storage medium provided in this application are the same as those of the AI ​​agent-based containerized application and pipeline deployment method provided in the above embodiments, and will not be elaborated upon here.

[0177] This application provides a computer program product, including a computer program that, when executed by a processor, implements the steps of the containerized application and pipelined deployment method based on AI agents as described above.

[0178] The computer program product provided in this application can solve the technical problem that current CI / CD pipelines and container orchestration systems are difficult to automate deployment. Compared with the prior art, the beneficial effects of the computer program product provided in this application are the same as the beneficial effects of the containerized application and pipeline deployment method based on AI agents provided in the above embodiments, and will not be repeated here.

[0179] The above are merely preferred embodiments of this application and do not limit the patent scope of this application. Any equivalent structural or procedural transformations made using the content of this application's specification and drawings, or direct or indirect applications in other related technical fields, are similarly included within the patent scope of this application.

[0180] It should be noted that, in this document, the terms "comprising," "including," or any other variations thereof are intended to cover non-exclusive inclusion, such that a process, method, article, or system that comprises a list of elements includes not only those elements but also other elements not expressly listed, or elements inherent to such a process, method, article, or system. Unless otherwise specified, an element defined by the phrase "comprising one..." does not exclude the presence of other identical elements in the process, method, article, or system that includes that element.

[0181] Through the above description of the embodiments, those skilled in the art can clearly understand that the methods of the above embodiments can be implemented by means of software plus necessary general-purpose hardware platforms. Of course, they can also be implemented by hardware, but in many cases the former is a better implementation method.

[0182] The above are merely preferred embodiments of this application and do not limit the patent scope of this application. Any equivalent structural or procedural transformations made using the content of this application's specification and drawings, or direct or indirect applications in other related technical fields, are similarly included within the patent protection scope of this application.

Claims

1. An AI-agent based containerized application and pipeline deployment method, characterized in that, The containerized application and pipeline deployment method based on an AI agent comprises: In response to a project deployment requirement input by a user, the AI agent analyzes the project deployment requirement to obtain deployment parameters, and generates a corresponding continuous integration script and application deployment configuration based on the deployment parameters; An application programming interface of a continuous integration tool is called to create an automated build task, and an application programming interface of a code repository is called to establish an automatic triggering association between a code submission event and the automated build task; In response to the code submission event, the automated build task is automatically triggered to execute the continuous integration script, complete the construction of a container image, and upload the container image to a preset image repository; A deployment instruction is submitted to a container orchestration system, so that the container orchestration system pulls a target container image from the preset image repository, and creates and deploys a corresponding application instance in a target cluster of the container orchestration system based on the target container image and the application deployment configuration; The step of analyzing the project deployment requirement by the AI agent to obtain deployment parameters in response to a project deployment requirement input by a user comprises: The AI agent performs semantic analysis on the project deployment requirement to extract the deployment parameters; A preset script template library is called, the script template library comprising continuous integration script templates and application deployment script templates, each template containing replaceable variables corresponding to the deployment parameters; The deployment parameters are filled into the replaceable variables corresponding to the continuous integration script templates and the application deployment script templates to generate the continuous integration script and the application deployment configuration; The step of filling the deployment parameters into the replaceable variables corresponding to the continuous integration script templates and the application deployment script templates to generate the continuous integration script and the application deployment configuration comprises: All replaceable variable identifiers defined in the continuous integration script templates and the application deployment script templates are obtained; The deployment parameters are matched with the replaceable variable identifiers to identify the replaceable variable identifiers that are not covered as to-be-completed configuration items; For the to-be-completed configuration items, based on the deployment parameters extracted from the project deployment requirement, the AI agent performs intelligent reasoning with context awareness by combining a preconfigured technology stack knowledge graph and a historical successful deployment case library to generate recommended configuration values corresponding to the to-be-completed configuration items; The recommended configuration values and the deployment parameters are integrated to form complete deployment parameter mappings, and the complete deployment parameter mappings are filled into the replaceable variables corresponding to the continuous integration script templates and the application deployment script templates.

2. The AI-agent based containerized application and pipeline deployment method of claim 1, wherein, The step of calling a preset script template library, the script template library comprising continuous integration script templates and application deployment script templates, each template containing replaceable variables corresponding to the deployment parameters comprises: Based on the development language type and deployment target environment in the deployment parameters, the corresponding continuous integration script template and application deployment script template are matched from the script template library; The continuous integration script template includes a standard process for code retrieval, compilation and packaging, code quality inspection, image creation and image upload, and controls whether to enable personalized build steps through parameter variable switches. The application deployment script template includes a server-oriented deployment mode and a container orchestration system-oriented deployment mode, and automatically activates the corresponding deployment path according to the target deployment environment.

3. The AI-agent based containerized application and pipeline deployment method of claim 1, wherein, The steps of automatically triggering the automated build task to execute the continuous integration script in response to the code commit event, completing the container image build, and uploading the container image to the preset image repository include: During the execution of the automated build task, the AI ​​agent calls the application programming interface of the continuous integration tool in real time to obtain real-time build logs in order to monitor the build status throughout the process. If the AI ​​agent detects a construction failure event, it performs semantic parsing on the real-time construction log through natural language processing to extract abnormal feature information; The abnormal feature information is matched with historical abnormal construction cases in the knowledge base. Based on the matching results, the cause of the failure is located and a corresponding configuration adjustment plan is generated. Based on the configuration adjustment scheme, the configuration of the automated build task is automatically corrected, and the automated build task is retried until the build is successful.

4. The AI-agent based containerized application and pipeline deployment method of claim 1, wherein, Following the step of creating and deploying the corresponding application instance in the target cluster of the container orchestration system based on the target container image and the application deployment configuration, the containerized application and pipeline deployment method based on AI agents further includes: The monitoring system collects multi-dimensional operational data of the container orchestration system, including operational status information of the network communication layer, node resource layer, cluster scheduling layer, and application service layer. The AI ​​agent compares the multi-dimensional operational data with the corresponding alarm thresholds in real time to determine whether there is an operational fault. If the operational fault is detected, the fault feature information corresponding to the operational fault is extracted; The fault feature information is matched with historical fault cases in the operation and maintenance knowledge base, and a corresponding automated processing solution is generated based on the matching results. The application programming interface of the container orchestration system is invoked to execute the automated processing scheme to automatically repair the operational failure.

5. The AI-agent based containerized application and pipeline deployment method of claim 4, wherein, The alarm thresholds include default thresholds, adaptive thresholds, and manually set thresholds. Before the step of comparing the multi-dimensional operational data with the corresponding alarm thresholds in real time using the AI ​​agent to determine whether an operational fault exists, the containerized application and pipeline deployment method based on the AI ​​agent further includes: Obtain the historical time-series data sequence of the multidimensional operational data within the historical time period; By using a time series analysis model, the periodic patterns and trend characteristics corresponding to different dimensions of operating indicators in the historical time series data sequence are identified; Based on the periodic pattern and trend characteristics, the normal fluctuation range of each of the operating indicators in different time periods is calculated, and the boundary value of the normal fluctuation range is used as the adaptive threshold of the corresponding operating indicator.

6. The AI-agent based containerized application and pipeline deployment method of claim 4, wherein, Following the step of collecting multi-dimensional operational data of the container orchestration system through a monitoring system, wherein the multi-dimensional operational data includes operational status information of the network communication layer, node resource layer, cluster scheduling layer, and application service layer, the containerized application and pipeline deployment method based on AI agents further includes: Based on the collected multidimensional runtime data, a resource timing sequence for each application instance in the container orchestration system is constructed. Based on the resource time series, the resource demand trend of the application instance in a future preset time window is predicted by the time series prediction model. Based on the degree of deviation between the resource demand trend and the current resource allocation, a corresponding resource scheduling strategy is generated; The application programming interface of the container orchestration system is invoked to execute the resource scheduling strategy in order to optimize the resource allocation of the application instance.

7. The AI-agent based containerized application and pipeline deployment method of claim 1, wherein, The steps of submitting deployment instructions to the container orchestration system, causing the container orchestration system to pull the target container image from the preset image repository, and creating and deploying the corresponding application instance in the target cluster of the container orchestration system based on the target container image and the application deployment configuration, include: Based on the application deployment configuration, a deployment instruction for the container orchestration system is generated. The deployment instruction includes the image address of the preset image repository, the identification information of the target container image, the identification information of the target cluster, and the configuration parameters of the application instance. The deployment command is sent to the container orchestration system; After receiving the deployment instruction, the container orchestration system parses the deployment instruction to obtain the image address of the preset image repository and the identification information of the target container image, and pulls the target container image from the preset image repository according to the image address and the identification information. The container orchestration system determines the target cluster based on the identification information of the target cluster, and creates and deploys the corresponding application instance in the target cluster based on the configuration parameters of the target container image and the application instance.

8. The AI-agent based containerized application and pipeline deployment method of claim 1, wherein, The step of calling the application programming interface of the code repository to establish an automatic triggering association between the code commit event and the automated build task includes: The AI ​​agent generates Webhook configuration parameters containing event types and branch filtering rules based on the code repository address and target branch information included in the project deployment requirements. Based on the Webhook configuration parameters, the Webhook management interface of the code repository is called to complete the creation and configuration of the Webhook, and the trigger address of the automated build task is configured as the payload URL of the Webhook to complete the automatic trigger association between the code submission event and the automated build task.

Images