CN117742880A - System and method for deploying containerized heterogeneous platform application based on pipeline - Google Patents
System and method for deploying containerized heterogeneous platform application based on pipeline Download PDFInfo
- Publication number
- CN117742880A CN117742880A CN202311504294.7A CN202311504294A CN117742880A CN 117742880 A CN117742880 A CN 117742880A CN 202311504294 A CN202311504294 A CN 202311504294A CN 117742880 A CN117742880 A CN 117742880A
- Authority
- CN
- China
- Prior art keywords
- code
- containerized
- module
- pipeline
- deploying
- Prior art date
- Legal status (The legal status is an assumption and is not a legal conclusion. Google has not performed a legal analysis and makes no representation as to the accuracy of the status listed.)
- Pending
Links
- 238000000034 method Methods 0.000 title claims abstract description 26
- 230000010354 integration Effects 0.000 claims abstract description 34
- 230000008569 process Effects 0.000 claims abstract description 11
- 238000007726 management method Methods 0.000 claims description 61
- 238000010276 construction Methods 0.000 claims description 12
- 230000002085 persistent effect Effects 0.000 claims description 10
- 238000003860 storage Methods 0.000 claims description 10
- 238000007689 inspection Methods 0.000 claims description 3
- 238000012360 testing method Methods 0.000 abstract description 10
- 238000004891 communication Methods 0.000 abstract description 4
- 238000005516 engineering process Methods 0.000 description 16
- 238000011161 development Methods 0.000 description 12
- 241000380131 Ammophila arenaria Species 0.000 description 6
- 230000006870 function Effects 0.000 description 6
- 238000004519 manufacturing process Methods 0.000 description 5
- 238000004806 packaging method and process Methods 0.000 description 5
- 238000010586 diagram Methods 0.000 description 4
- 238000012552 review Methods 0.000 description 4
- 238000012423 maintenance Methods 0.000 description 3
- 238000012544 monitoring process Methods 0.000 description 3
- XQMVBICWFFHDNN-UHFFFAOYSA-N 5-amino-4-chloro-2-phenylpyridazin-3-one;(2-ethoxy-3,3-dimethyl-2h-1-benzofuran-5-yl) methanesulfonate Chemical compound O=C1C(Cl)=C(N)C=NN1C1=CC=CC=C1.C1=C(OS(C)(=O)=O)C=C2C(C)(C)C(OCC)OC2=C1 XQMVBICWFFHDNN-UHFFFAOYSA-N 0.000 description 2
- 230000009286 beneficial effect Effects 0.000 description 2
- 238000012545 processing Methods 0.000 description 2
- 238000005096 rolling process Methods 0.000 description 2
- 230000001960 triggered effect Effects 0.000 description 2
- 238000004458 analytical method Methods 0.000 description 1
- 238000013459 approach Methods 0.000 description 1
- 230000008602 contraction Effects 0.000 description 1
- 230000007547 defect Effects 0.000 description 1
- 230000000694 effects Effects 0.000 description 1
- 230000002708 enhancing effect Effects 0.000 description 1
- 238000009434 installation Methods 0.000 description 1
- 230000007246 mechanism Effects 0.000 description 1
- 238000012986 modification Methods 0.000 description 1
- 230000004048 modification Effects 0.000 description 1
- 238000012536 packaging technology Methods 0.000 description 1
- 238000011084 recovery Methods 0.000 description 1
- 230000002441 reversible effect Effects 0.000 description 1
- 238000006467 substitution reaction Methods 0.000 description 1
- 230000002459 sustained effect Effects 0.000 description 1
- 238000010998 test method Methods 0.000 description 1
- 238000012795 verification Methods 0.000 description 1
Classifications
-
- Y—GENERAL TAGGING OF NEW TECHNOLOGICAL DEVELOPMENTS; GENERAL TAGGING OF CROSS-SECTIONAL TECHNOLOGIES SPANNING OVER SEVERAL SECTIONS OF THE IPC; TECHNICAL SUBJECTS COVERED BY FORMER USPC CROSS-REFERENCE ART COLLECTIONS [XRACs] AND DIGESTS
- Y02—TECHNOLOGIES OR APPLICATIONS FOR MITIGATION OR ADAPTATION AGAINST CLIMATE CHANGE
- Y02D—CLIMATE CHANGE MITIGATION TECHNOLOGIES IN INFORMATION AND COMMUNICATION TECHNOLOGIES [ICT], I.E. INFORMATION AND COMMUNICATION TECHNOLOGIES AIMING AT THE REDUCTION OF THEIR OWN ENERGY USE
- Y02D10/00—Energy efficient computing, e.g. low power processors, power management or thermal management
Landscapes
- Management, Administration, Business Operations System, And Electronic Commerce (AREA)
Abstract
The invention relates to the technical field of computers, in particular to a system and a method for deploying a containerized heterogeneous platform application based on a pipeline, wherein the system comprises heterogeneous containerized clusters, the containerized clusters are deployed in a cloud computing platform, and a code examination module is arranged in the containerized clusters and used for code examination; the code management module is used for code management and control of code versions; the continuous integration module is used for configuring pipeline tasks to process based on the request events pushed by the code management module to generate code products, and pulling mirror units in the code management module to construct configuration codes; and the continuous deployment module is used for deploying the code product and the configuration code into the containerized cluster. The invention reduces the workload of developing, testing and maintaining personnel, fully automatically deploys to various environments, greatly reduces the artificial communication cost and the possibility of misoperation, and improves the working efficiency.
Description
Technical Field
The invention relates to the technical field of computers, in particular to a system and a method for deploying a containerized heterogeneous platform application based on a pipeline.
Background
With the continuous development of cloud computing technology, the cloud computing technology tends to be more stable. Accordingly, on the basis of cloud computing, a cloud native technology is formed by combining a container technology, a micro-service technology and a DevOps technology. Kubernetes has become a standard in the industry as an open-source large-scale orchestration engine. The Kubernetes supports heterogeneous servers of x86 and ARM architectures, and can quickly construct high-performance cloud native application clusters. By means of Yun Yuansheng container packaging technology, the differences among operating systems are shielded, and hybrid deployment and unified management are achieved. With the rise of domestic software, more and more needs to adapt to the created environment in daily projects. Therefore, deploying and adapting to domestic applications is particularly important, but the deployment process is still complicated and complicated.
The current CICD pipeline method does not support either heterogeneous environment or information creation environment or flexible transverse expansion of containerized clusters. The cluster capacity expansion in the prior art is also based on a manual, shutdown and business shutdown mode.
Disclosure of Invention
The invention aims to provide a system for deploying a container heterogeneous platform application based on a pipeline, which solves the technical problems;
the invention also aims to provide a method for deploying the container heterogeneous platform application based on the pipeline, which solves the technical problems.
The technical problems solved by the invention can be realized by adopting the following technical scheme:
a system for deploying containerized heterogeneous platform applications based on a pipeline includes heterogeneous containerized clusters, the containerized cluster is deployed in a cloud computing platform, the containerized cluster is provided with,
a code examination module for code examination;
the code management module is connected with the code examination module and is used for code management and control of code versions;
the continuous integration module is connected with the code management module, processes and generates a code product based on the request event configuration pipeline task pushed by the code management module, and pulls the mirror image unit in the code management module to construct a configuration code;
and the continuous deployment module is connected with the continuous integration module and is used for deploying the code product and the configuration code into the containerized cluster.
Preferably, the containerized cluster is a Kubernetes containerized platform, the containerized cluster comprising a plurality of dynamically adjustable number of nodes, the nodes having adjustable computing resources.
Preferably, the types of the containerized clusters include complex instruction set computer architecture and reduced instruction set computer architecture, and the versions of the containerized clusters include trusted environments and non-trusted environments.
Preferably, the code products are binary files, and each code product is correspondingly provided with a unique number.
Preferably, the persistent integration module uses the number as a mirror label, and the mirror unit constructs the configuration code based on the mirror label.
Preferably, the method further comprises the steps of,
the storage module is connected with the continuous integration module and used for storing and managing the code product;
and the mirror image warehouse is connected with the continuous integration module and used for storing and managing the configuration codes.
Preferably, the storage module adopts a JFrog binary warehouse manager, and the mirror image warehouse adopts a Harbor mirror image warehouse.
Preferably, the cloud computing platform adopts an OpenStack virtual machine, the code examination module adopts a Gerrit server, the code management module adopts a Gitleb warehouse management module, the continuous integration module adopts a Jenkins construction module, and the continuous deployment module adopts an ArgoCD continuous delivery module.
A method for deploying a containerized heterogeneous platform application based on a pipeline is applied to the system for deploying the containerized heterogeneous platform application based on the pipeline, and is characterized by comprising the following steps of,
step S1, submitting a business code to the code examination module, wherein the code examination module performs code examination;
step S2, the code management module carries out code management and version control, and sets the pushed request event;
step S3, the continuous integration module processes the request event configuration pipeline task pushed by the code management module to generate the code product, and pulls the mirror image unit in the code management module to construct the configuration code;
step S4, the persistent deployment module deploys the code product and the configuration code into the containerized cluster.
Preferably, step S2 further includes the code management module setting a pipeline scanning trigger to perform timing execution code inspection, and setting a construction trigger to construct the pipeline task at timing; step S3 further includes storing the code article in a memory module and storing the configuration code in a mirror repository.
The invention has the beneficial effects that: by adopting the technical scheme, the cloud computing technology is adopted to conveniently expand the containerized cluster, the container technology is adopted to conveniently manage the heterogeneous cluster, and the assembly line technology is adopted to connect all the service components in series to form a whole, so that the workload of developing, testing and operation and maintenance personnel is reduced, the system is fully automatically deployed in all environments, the artificial communication cost and the possibility of misoperation are greatly reduced, and the working efficiency is improved.
Drawings
FIG. 1 is a schematic diagram of components of a containerized cluster deployment in an embodiment of the present invention;
FIG. 2 is a system diagram of a pipeline-based deployment of a containerized heterogeneous platform application in an embodiment of the present invention;
FIG. 3 is a schematic diagram of an arrangement flow in an embodiment of the present invention;
FIG. 4 is a schematic diagram illustrating steps of a method for pipeline-based deployment of a containerized heterogeneous platform application in accordance with an embodiment of the present invention.
Detailed Description
The following description of the embodiments of the present invention will be made clearly and completely with reference to the accompanying drawings, in which it is apparent that the embodiments described are only some embodiments of the present invention, but not all embodiments. All other embodiments, which can be made by those skilled in the art based on the embodiments of the invention without making any inventive effort, are intended to be within the scope of the invention.
It should be noted that, without conflict, the embodiments of the present invention and features of the embodiments may be combined with each other.
The invention is further described below with reference to the drawings and specific examples, which are not intended to be limiting.
A system for deploying a containerized heterogeneous platform application based on a pipeline, as shown in fig. 1 and 2, comprises a heterogeneous containerized cluster 6, wherein the containerized cluster 6 is deployed in a cloud computing platform 5, the containerized cluster 6 is provided with,
a code censoring module 1 for code censoring;
the code management module 2 is connected with the code examination module 1 and is used for code management and control of code versions;
the continuous integration module 3 is connected with the code management module 2, processes the pipeline task based on the request event pushed by the code management module 2 to generate a code product, and pulls the mirror image unit in the code management module 2 to construct a configuration code;
a persistent deployment module 4, coupled to the persistent integration module 3, for deploying code artifacts and configuration codes into the containerized cluster 6.
Specifically, the invention provides a system for deploying a containerized heterogeneous platform application based on a pipeline, which realizes code review, code version management, code packaging, product management, mirror image management, application automation deployment, application rolling upgrading and cluster flexible capacity expansion, and realizes code packaging, mirror image packaging and automation deployment to a containerized cluster 6 through a continuous integrated module 3 and a continuous deployment module 4, wherein the containerized cluster 6 is a Kubernetes cluster, the continuous integrated module 3 adopts a Jenkins pipeline, and the continuous deployment module 4 adopts an ArgoCD continuous delivery module. According to the configuration of the Kubernetes heterogeneous clusters in the ArgoCD, an x86 architecture or an arm architecture, a message creation or a non-message creation cluster to be deployed can be automatically selected, the cloud computing platform 5 adopts an OpenStack virtual machine, the Kubernetes cluster is conveniently expanded by adopting an OpenStack cloud computing technology, the heterogeneous clusters are conveniently managed by adopting a Kubernetes container technology, and all service components are connected in series by adopting a pipeline technology to form a whole.
The invention lightens the workload of developing, testing and operating staff, fully automatically deploys to each environment, greatly reduces the artificial communication cost and the possibility of misoperation, improves the working efficiency, uniformly controls the version of the variable written in the code management module 2, ensures that the naming of the variable is clear at a glance, ensures that the developing staff can understand the self-used environment more conveniently, and ensures that the operating staff has better maintainability and retrievability.
In a preferred embodiment, the containerized cluster 6 is a Kubernetes container orchestration platform, the containerized cluster 6 comprising a plurality of dynamically adjustable numbers of nodes, the nodes having adjustable computing resources.
Specifically, the whole system is deployed in an OpenStack virtual machine, and the Kubernetes clusters are managed through a magnum component, including the steps of creating and deleting the Kubernetes clusters, and the Kubernetes clusters are expanded in a transverse and automatic mode. The entire system is deployed in a Kubernetes cluster in which all components run in a container.
Specifically, the invention provides a pipeline integrated flow taking a pipeline as a core, which comprises code examination, continuous integration and continuous delivery, product generation, mirror image construction and automatic expansion and contraction of Pod (HorizontalPodAutoscaler) level by means of container performance expandability. In the scheme, the whole kubernetes cluster is deployed on an OpenStack cloud platform, and when the container cluster reaches a performance bottleneck, the capacity can be longitudinally expanded; the transverse capacity expansion of the Kubernetes cluster can be performed by means of a Magnum component of OpenStack, so that cluster nodes of the Kubernetes are increased; further, a heterogeneous environment refers to an environment consisting of heterogeneous computers, operating systems, software, and networks. In heterogeneous environments, different computers and operating systems may have different hardware architectures, processing capabilities, memory sizes, operating system versions, and the like.
Sustained integration refers to developers frequently merging code into a shared repository, and then verifying the correctness of the code through automated build and test procedures. Thus, the code integration problem can be discovered and solved as early as possible, and code conflicts and errors are reduced. Continuous delivery refers to the automatic deployment of code into a production environment after the code has been continuously integrated. Through an automatic deployment flow, new functions and repaired codes can be rapidly and reliably delivered to users, and manual operation and human errors are reduced.
The goal of continuous integration and continuous delivery (CICD, continuous Integration and Continuous Delivery) is to speed up software development and delivery, improve software quality, and reduce development and operation costs. It can help the team respond to user needs faster, iterating and publishing the software quickly.
CICD pipelines are typically composed of multiple stages, including code management, construction, automated testing, deployment, and the like. Each phase has corresponding tools and tasks, e.g., version control systems, such as Git, build tools, e.g., jenkins, continuous integration and continuous delivery (CICD, continuous Integration and Continuous Delivery) flows. In CICD pipelines, developers can frequently submit codes to a version control system, and through an automatic construction and test process, potential problems are quickly detected and repaired, and once the codes pass all tests, the codes can be automatically deployed into a production environment to realize continuous delivery. Advantages of CICD pipelining include improving development team efficiency, reducing errors and defects, speeding up software delivery, enhancing software quality, etc. It is an important practical method in modern software development, and is widely applied to projects and organizations of various scales.
In a preferred embodiment, the types of containerized cluster 6 include complex instruction set computer architecture and reduced instruction set computer architecture, and the versions of containerized cluster 6 include both trusted and non-trusted environments.
The whole system has heterogeneous architecture including x86 and arm clusters, credit and non-credit clusters. After the user submits the code, the code is automatically deployed into the designated heterogeneous cluster through the whole system. After one configuration is completed, the Jenkins pipeline construction is automatically triggered.
In a preferred embodiment, the code products are binary files, and each code product is correspondingly provided with a unique number.
In a preferred embodiment, the persistent integration module 3 builds the configuration code based on the mirrored tag mirroring unit by numbering as the mirrored tag.
In a preferred embodiment, the method further comprises,
a storage module 7 connected to the persistent integration module 3 for storing management code products;
the mirror warehouse 8 is connected with the persistent integration module 3 and is used for storing management configuration codes.
In a preferred embodiment, the storage module 7 employs a JFrog binary warehouse manager and the mirror warehouse 8 employs a Harbor mirror warehouse.
JFrog binary warehouse manager: JFrog Artifactory is currently only one enterprise-level, high-availability binary product management warehouse which supports all development languages, metadata retrieval of any dimension, forward and reverse dependency analysis across languages, deep recursion and multi-activity remote disaster recovery. The method is used for storing java product data packages, binary files after code compiling and the like.
Harbor mirror warehouse: harbor is a container mirror warehouse open source item designed for enterprise users.
In a preferred embodiment, the cloud computing platform 5 adopts an OpenStack virtual machine, the code inspection module 1 adopts a Gerrit server, the code management module 2 adopts a Gitlab warehouse management module, the continuous integration module 3 adopts a Jenkins construction module, and the continuous deployment module 4 adopts an ArgoCD continuous delivery module.
Specifically, the OpenStack virtual machine is an open-source cloud computing platform 5, which is used for constructing and managing public clouds and private clouds, and provides a series of services including computing, storage, network, identity authentication and the like, so that a user can be helped to quickly construct and manage own cloud platforms, through OpenStack, the user can easily create and manage resources such as virtual machine instances, storage volumes, networks and the like, and can perform elastic expansion and automatic management according to requirements. Meanwhile, openStack also provides rich API interfaces, so that a user can conveniently conduct secondary development and integration.
Specifically, the Kubernetes cluster can be conveniently expanded by adopting the OpenStack cloud computing technology, and new nodes can be quickly created and configured and added into the Kubernetes cluster through the virtual machine management function of the OpenStack, so that the expansion of the cluster is realized.
According to the invention, a container Gerrit is used as a code examination, a Gitlab is used as a code management and version control, jenkins is used as a pipeline execution process, JFrog is used as a code product storage warehouse, harbor is used as a mirror image and configuration code warehouse, and ArgoCD is used as a continuous delivery tool; and with the help of the powerful container orchestration capability of Kubernetes and the OpenStack virtualization capability, a break-through is achieved from infrastructure as a service layer (IaaS) to platform as a service layer (PaaS). The application is not concerned with the underlying operating system or server architecture, and the execution pipeline can be compiled automatically, packed automatically and deployed automatically;
specifically, at the IaaS layer, basic computing resources such as virtual machines, storage, and networks are provided. Users need to manage and configure these resources themselves, including installation and maintenance of operating systems, deployment of applications, etc. This approach allows for more flexibility in controlling and customizing the environment itself for users with a certain technical capability. In the PaaS layer, a complete application development and deployment platform is provided, users do not need to pay attention to the underlying infrastructure, and only need to pay attention to the development and deployment of own application programs, and the PaaS layer can provide a series of development tools, running environments and services, such as databases, message queues, identity authentication and the like, so as to help the users develop and deploy application programs more efficiently.
Gerrit server: gerrit is a free, open source code censoring software that uses web page interfaces. Using a web browser, software programmers on the same team can review each other's modified program code to determine whether it can submit, return or continue modification. It uses Git as the underlying version control system. Gerrit is effectively a Git server that provides a set of entitlement controls for a Git repository hosted on its server, and a foreground page for code review. Its main function is to do code examination.
Gitlab warehouse management module: code management and version control are performed through the GitLab, and a label pushing event is set to trigger Webhook, which is a mechanism for transmitting real-time data to other application programs through the HTTP protocol. It allows an application to push data to a pre-set URL address when a specific event occurs. The Webhook can be used for realizing functions of real-time notification, data synchronization, automatic processing and the like, and the Jenkins pipeline task is triggered through the Webhook; the pipeline scan flip-flop may also be set to perform a timed execution code check, and the build flip-flop is set to build at a timing.
Jenkins construction module: jenkins is an open source software project, is a continuous integration tool based on Java development, is used for monitoring continuous repeated work, and aims to provide an open and easy-to-use software platform so that the software project can be continuously integrated. Jenkins is used to execute Jenkins pipeline in the present patent, and is the most important component in the whole system.
ArgoCD continuous delivery module: argoCD is intended to provide a declarative continuous delivery tool. ArgoCD supports a variety of configuration management tools, expanding the advantages of declarative and Git-based configuration management to speed up application deployment and lifecycle management without affecting security and compliance. ArgoCD is used in the present invention for automated deployment applications to testing and production environments.
In ArgoCD, kubernetes heterogeneous cluster configuration refers to managing multiple different Kubernetes clusters simultaneously in one ArgoCD application. These clusters may be different cloud providers, different geographical locations or different environments, such as development, testing, production.
Through the configuration of the Kubernetes heterogeneous clusters, different Kubernetes clusters can be brought into the control range of the ArgoCD, and application deployment and update in the clusters can be managed uniformly, so that the automation function of the ArgoCD can be used for realizing the deployment, rollback and monitoring of the application across the clusters.
According to the Kubernetes heterogeneous cluster configuration in the ArgoCD, the automatic selection of an x86 architecture or an arm architecture, a traumata or a non-traumata cluster which needs to be deployed can be realized.
A method for deploying a containerized heterogeneous platform application based on a pipeline, which is applied to the system for deploying the containerized heterogeneous platform application based on the pipeline in any one of the embodiments, as shown in fig. 3 and 4, and comprises,
step S1, submitting business codes to a code examination module 1, and performing code examination by the code examination module 1;
step S2, the code management module 2 carries out code management and version control, and sets a push request event;
step S3, the continuous integration module 3 configures pipeline tasks to process according to the request events pushed by the code management module 2 to generate code products, and pulls mirror units in the code management module 2 to construct configuration codes;
in step S4, the persistent deployment module 4 deploys the code artifact and the configuration code into the containerized cluster 6.
In a preferred embodiment, step S2 further includes, the code management module 2 setting a pipeline scan trigger to perform a timing execution code check, and setting a construction trigger to periodically construct pipeline tasks; step S3 further comprises storing the code article in a memory module 7 and storing the configuration code in a mirror repository 8.
Detailed description of the preferred embodiments
Step 1, a developer submits codes to a code examination module 1 through a git;
step 2, the development team leader checks the submitted codes and performs code examination, if the codes are modified or new functions are added (return value is +1), the codes are combined into the code management module 2 after the code examination, if the code return value is-1, the codes are not combined and the developer is notified;
and 3, submitting the codes to a process of automatically verifying the codes by Jenkins while merging the codes, and then returning the result to the code examination module 1 for the development team leader to reference. Rollback code through code review module 1 if Jenkins code automation verification is not passed
And step 4, the code management module 2 triggers Jenkins to perform continuous integration and continuous delivery flow after receiving the merging information of the codes, and executes the self-defined pipeline task.
And 5, customizing a pipeline task, pulling a service code in the code replacing management module 2, packaging the code, releasing the packaged binary files such as Jar package and the like into the JFrog, and forming a product release unique number.
And 6, customizing a pipeline task, pulling a mirror image unit Docker mirror image construction configuration code in the code replacement management module 2, constructing a mirror image of an x86 or arm architecture by taking a unique number as a mirror image label, and pushing the constructed mirror image into a harbor mirror image warehouse.
Step 7, the GitLab warehouse triggers the Webhook through a push event of the fixed branch, and the Webhook triggers the ArgoCD deployment task.
And 8, judging whether to deploy the version to a testing/production environment by a user, if yes, automatically synchronizing the latest container cluster Manifest or Helm Chart configuration file in the GitLab by the ArgoCD, pulling the mirror image in a local Docker warehouse according to the latest Docker mirror image Tag configured in the latest container cluster Manifest or Helm Chart configuration file, and automatically deploying the application according to the configuration of Mainfest or Chart.
Step 9, according to the running environment requirement of the codes, the system can be divided into an x86 architecture and an arm architecture, the version can be divided into a belief-created environment and a non-belief-created environment, and when the custom pipeline is executed, a container mirror image of x86 or arm can be constructed according to the actual requirement and deployed to the belief-created cluster environment and the non-belief-created cluster environment.
Preferably, kubeconfig corresponding to Kubernetes cluster is already configured in ArgoCD, and pipeline can be deployed into heterogeneous clusters only by calling different kubeconfig.
Second embodiment
And step 1, creating at least three Linux virtual machine nodes for deploying the container cluster, and if the container cluster is required to be designated as a credit cluster, the software and the hardware are required to be domesticated, and the domestic safety controllable standard is met. If a heterogeneous node needs to be specified, three additional Linux virtual machine nodes are needed to deploy the Kubernetes of the x86 or arm architecture.
And 2, deploying Gerrit through Helm for code examination. The gitlab is deployed through Helm for code management and version control. And deploying a hardor mirror warehouse through Helm for business mirror version control. Jenkins are deployed through Helm for managing the CICD pipeline. JFrog is deployed through Helm for binary management. Deployment of ArgoCD by Helm for automated deployment of containers
Step 3, creating three warehouses of a business code, a Docker mirror image construction configuration code and a container cluster deployment configuration code kubeconfig in the GitLab warehouse;
step 4, creating a corresponding pipeline in Jenkins, performing code packaging, product management, mirror image management, application automation deployment, application rolling upgrading and starting Webhook service monitoring;
step 5, configuring a Webhook integration of Jenkins in a service code warehouse corresponding to the GitLab, mainly configuring a Webhook address (URL) and a key of a corresponding pipeline in the Jenkins, and creating an event pushing Webhook;
step 6, configuring ArgoCD Webhook integration in a container cluster deployment configuration code warehouse of the GitLab, mainly configuring Webhook address symbols and keys in the ArgoCD, and creating push Webhook;
and 7, configuring container cluster deployment configuration code warehouse information and deployed destination container cluster information of the GitLab in the ArgoCD, creating corresponding Application, synchronizing a container cluster deployment configuration file kubeconfig of the GitLab, and deploying a container mirror image into the destination container cluster.
In summary, the invention has the following beneficial effects: the OpenStack cloud computing technology is adopted to conveniently expand the Kubernetes cluster. The heterogeneous clusters are conveniently managed using Kubernetes container technology. And each service assembly is connected in series by adopting a pipeline technology to form a whole. The workload of developing, testing and operating personnel is reduced, the system is fully automatically deployed to each environment, the artificial communication cost and the possibility of misoperation are greatly reduced, and the working efficiency is improved. The variables are written in the gitlab to be uniformly controlled in version, the naming of the variables is clear at a glance, so that the developer can understand the use environment more conveniently, and the operation and maintenance personnel have better maintainability and retrievability.
The foregoing description is only illustrative of the preferred embodiments of the present invention and is not to be construed as limiting the scope of the invention, and it will be appreciated by those skilled in the art that equivalent substitutions and obvious variations may be made using the description and illustrations of the present invention, and are intended to be included within the scope of the present invention.
Claims (10)
1. A system for deploying a containerized heterogeneous platform application based on a pipeline is characterized by comprising heterogeneous containerized clusters, wherein the containerized clusters are deployed in a cloud computing platform and are provided with a plurality of heterogeneous platform,
a code examination module for code examination;
the code management module is connected with the code examination module and is used for code management and control of code versions;
the continuous integration module is connected with the code management module, processes and generates a code product based on the request event configuration pipeline task pushed by the code management module, and pulls the mirror image unit in the code management module to construct a configuration code;
and the continuous deployment module is connected with the continuous integration module and is used for deploying the code product and the configuration code into the containerized cluster.
2. The system for pipeline-based deployment of a containerized heterogeneous platform application of claim 1, wherein the containerized cluster is a Kubernetes containerized platform, the containerized cluster comprising a plurality of dynamically adjustable number of nodes, the nodes having adjustable computing resources.
3. The system for pipeline-based deployment of a containerized heterogeneous platform application of claim 2, wherein the types of containerized clusters include complex instruction set computer architecture and reduced instruction set computer architecture, and wherein the versions of containerized clusters include both a trusted environment and a non-trusted environment.
4. The system for deploying a containerized heterogeneous platform application based on a pipeline of claim 1, wherein the code artifacts are binary files, and each code artifact is provided with a unique number.
5. The system for pipeline-based deployment of a containerized heterogeneous platform application of claim 4, wherein the persistent integration module constructs the configuration code based on the mirror unit by using the number as a mirror tag.
6. The pipelined deployment of a system for a containerized heterogeneous platform application of claim 1, further comprising,
the storage module is connected with the continuous integration module and used for storing and managing the code product;
and the mirror image warehouse is connected with the continuous integration module and used for storing and managing the configuration codes.
7. The system for pipeline-based deployment of a containerized heterogeneous platform application of claim 1, wherein the storage module employs a JFrog binary warehouse manager and the mirror warehouse employs a Harbor mirror warehouse.
8. The system for deploying a containerized heterogeneous platform application based on a pipeline according to claim 1, wherein the cloud computing platform adopts an OpenStack virtual machine, the code inspection module adopts a Gerrit server, the code management module adopts a Gitlab warehouse management module, the continuous integration module adopts a Jenkins construction module, and the continuous deployment module adopts an ArgoCD continuous delivery module.
9. A method for deploying a containerized heterogeneous platform application based on a pipeline, which is applied to a system for deploying a containerized heterogeneous platform application based on a pipeline according to any one of claims 1-8, and comprises the following steps of,
step S1, submitting a business code to the code examination module, wherein the code examination module performs code examination;
step S2, the code management module carries out code management and version control, and sets the pushed request event;
step S3, the continuous integration module processes the request event configuration pipeline task pushed by the code management module to generate the code product, and pulls the mirror image unit in the code management module to construct the configuration code;
step S4, the persistent deployment module deploys the code product and the configuration code into the containerized cluster.
10. The method for deploying a containerized heterogeneous platform application based on a pipeline of claim 9, wherein step S2 further comprises the code management module setting a pipeline scan trigger to perform a timed execution code check, setting a build trigger to build the pipeline task at a timing; step S3 further includes storing the code article in a memory module and storing the configuration code in a mirror repository.
Priority Applications (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN202311504294.7A CN117742880A (en) | 2023-11-10 | 2023-11-10 | System and method for deploying containerized heterogeneous platform application based on pipeline |
Applications Claiming Priority (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN202311504294.7A CN117742880A (en) | 2023-11-10 | 2023-11-10 | System and method for deploying containerized heterogeneous platform application based on pipeline |
Publications (1)
| Publication Number | Publication Date |
|---|---|
| CN117742880A true CN117742880A (en) | 2024-03-22 |
Family
ID=90258083
Family Applications (1)
| Application Number | Title | Priority Date | Filing Date |
|---|---|---|---|
| CN202311504294.7A Pending CN117742880A (en) | 2023-11-10 | 2023-11-10 | System and method for deploying containerized heterogeneous platform application based on pipeline |
Country Status (1)
| Country | Link |
|---|---|
| CN (1) | CN117742880A (en) |
-
2023
- 2023-11-10 CN CN202311504294.7A patent/CN117742880A/en active Pending
Similar Documents
| Publication | Publication Date | Title |
|---|---|---|
| US11178207B2 (en) | Software version control without affecting a deployed container | |
| CN109062655B (en) | Containerized cloud platform and server | |
| CN107577475B (en) | Software package management method and system of data center cluster system | |
| US9311064B1 (en) | Systems and methods for automated centralized build/merge management | |
| Singh et al. | Comparison of different CI/CD tools integrated with cloud platform | |
| US20150220308A1 (en) | Model-based development | |
| EP3963447B1 (en) | Supervisory device with deployed independent application containers for automation control programs | |
| US8839223B2 (en) | Validation of current states of provisioned software products in a cloud environment | |
| US20150248301A1 (en) | Global feature library useable with continuous delivery | |
| WO2021092502A1 (en) | Just-in-time containers | |
| Strijkers et al. | Toward Executable Scientific Publications. | |
| CN114968406B (en) | Plug-in management method and device, electronic equipment and storage medium | |
| Caballer et al. | A platform to deploy customized scientific virtual infrastructures on the cloud | |
| CN112368678A (en) | Virtual machine container for application programs | |
| CN112596779A (en) | Dual-version-compatible dependency package generation method, device, equipment and storage medium | |
| CN115220863A (en) | Operation and maintenance method and device for container application, computer equipment and storage medium | |
| Mikkelsen et al. | Immutable infrastructure calls for immutable architecture | |
| CN114265595B (en) | Cloud native application development and deployment system and method based on intelligent contracts | |
| CN117742880A (en) | System and method for deploying containerized heterogeneous platform application based on pipeline | |
| EP2988469B1 (en) | A method and apparatus for updating a user interface of one program unit in response to an interaction with a user interface of another program unit | |
| Fortuna et al. | On-premise artificial intelligence as a service for small and medium size setups | |
| CN112231231A (en) | Method, system and device for debugging cloud service | |
| CN110837394A (en) | High-availability configuration version warehouse configuration method, terminal and readable medium | |
| Biener et al. | DevOps for containerized applications | |
| EP4036720B1 (en) | Hash optimized composition cache for isolated execution environments |
Legal Events
| Date | Code | Title | Description |
|---|---|---|---|
| PB01 | Publication | ||
| PB01 | Publication | ||
| SE01 | Entry into force of request for substantive examination | ||
| SE01 | Entry into force of request for substantive examination |