CN112000343B - Method and system for deploying multi-version services in Kubernetes by using Devops - Google Patents
Method and system for deploying multi-version services in Kubernetes by using Devops Download PDFInfo
- Publication number
- CN112000343B CN112000343B CN202010854496.4A CN202010854496A CN112000343B CN 112000343 B CN112000343 B CN 112000343B CN 202010854496 A CN202010854496 A CN 202010854496A CN 112000343 B CN112000343 B CN 112000343B
- Authority
- CN
- China
- Prior art keywords
- configuration
- version
- flow
- devops
- istio
- 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.)
- Active
Links
- 238000000034 method Methods 0.000 title claims abstract description 27
- 230000004048 modification Effects 0.000 claims abstract description 13
- 238000012986 modification Methods 0.000 claims abstract description 13
- 230000008859 change Effects 0.000 claims description 16
- 230000009466 transformation Effects 0.000 claims description 8
- 230000009467 reduction Effects 0.000 claims description 6
- 238000010276 construction Methods 0.000 claims description 5
- 230000000694 effects Effects 0.000 claims description 3
- 238000012360 testing method Methods 0.000 description 8
- 230000006870 function Effects 0.000 description 7
- 238000011161 development Methods 0.000 description 4
- 238000010586 diagram Methods 0.000 description 2
- 230000003993 interaction Effects 0.000 description 2
- 238000004519 manufacturing process Methods 0.000 description 2
- 238000004891 communication Methods 0.000 description 1
- 238000005516 engineering process Methods 0.000 description 1
- 230000003287 optical effect Effects 0.000 description 1
- 230000008569 process Effects 0.000 description 1
- 238000006467 substitution reaction Methods 0.000 description 1
Classifications
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F8/00—Arrangements for software engineering
- G06F8/60—Software deployment
- G06F8/61—Installation
- G06F8/63—Image based installation; Cloning; Build to order
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F8/00—Arrangements for software engineering
- G06F8/60—Software deployment
- G06F8/65—Updates
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F8/00—Arrangements for software engineering
- G06F8/70—Software maintenance or management
- G06F8/71—Version control; Configuration management
Landscapes
- Engineering & Computer Science (AREA)
- Software Systems (AREA)
- General Engineering & Computer Science (AREA)
- Theoretical Computer Science (AREA)
- Physics & Mathematics (AREA)
- General Physics & Mathematics (AREA)
- Computer Security & Cryptography (AREA)
- Stored Programmes (AREA)
- Data Exchanges In Wide-Area Networks (AREA)
Abstract
The invention discloses a method and a system for deploying multi-version services in Kubernetes by using Devops, which belong to the field of cloud computing, and the technical problem to be solved by the invention is how to realize the simultaneous deployment and release of the multi-version services in the Kubernetes, and the adopted technical scheme is as follows: the method is to use Devops components to deploy services into a Kubernetes cluster; when the Devops component is deployed, selecting codes of a plurality of branches to deploy, deploying a plurality of service versions in the same environment, simultaneously using Istio to carry out routing configuration of traffic in a Kubernetes cluster, and selecting corresponding requests to enter corresponding service versions; the method comprises the following steps: configuration modification of Devops component build: the Devops component selects an item and the code address of the item when constructing the item; the Devops component uses Istio to control the flow version when deployed; version configuration changes are made using Devops components. The invention also discloses a system for deploying multi-version services in Kubernetes by using Devops.
Description
Technical Field
The invention relates to the field of cloud computing, in particular to a method and a system for deploying multi-version services in Kubernetes by using Devops.
Background
At present, cloud computing technology is approaching to maturity, applications and services deployed on the cloud are increasing, developers not only deploy published programs on the cloud, but also test environments of the developers are in the cloud under many conditions. In agile development, development teams typically use Devops components to perform deployment and update operations of applications, and in traditional Devops deployment ideas, only one code branch or version can be selected for deployment at a time. If a development team uses multiple branches while developing code, then only one branch can be deployed at a time to perform the test, multiple branches cannot be tested simultaneously, or the developed application wants to perform the AB test, so that the on-line application will have multiple versions, but these scenarios cannot be completed in the prior Devops component.
How to implement the deployment and release of multiple versions of services in Kubernetes at the same time is a problem in the current prior art.
Disclosure of Invention
The technical task of the invention is to provide a method and a system for deploying multi-version services in Kubernetes by using Devops, so as to solve the problem of how to simultaneously deploy and release a plurality of versions of services in Kubernetes.
The technical task of the invention is realized in a manner that a method for deploying multi-version services in Kubernetes by using Devops is realized by deploying services into a Kubernetes cluster by using a Devops component; when the Devops component is deployed, selecting codes of a plurality of branches to deploy, deploying a plurality of service versions in the same environment, simultaneously using Istio to carry out routing configuration of traffic in a Kubernetes cluster, and selecting corresponding requests to enter corresponding service versions; the method comprises the following steps:
configuration modification of Devops component build: the Devops component selects an item and the code address of the item when constructing the item;
the Devops component uses Istio to control the flow version when deployed;
version configuration changes are made using Devops components.
Preferably, the configuration modification of the Devops component comprises deploying one version application and deploying a plurality of version applications; wherein, a version application is deployed specifically as follows:
adding a flow configuration card in the configuration of the Devops component;
adding a plurality of tags into the flow configuration card, wherein the tags are used for distinguishing different deployment versions;
and adding the tag, and adding a corresponding flow rule for judging whether the request can enter the deployment version.
More preferably, the deploying a plurality of version applications is specifically as follows:
adding a flow configuration card in the assembly line, and setting a corresponding tag;
selecting a code branch corresponding to each tag when the pipeline is operated;
after the selection is completed, the pipeline constructs a plurality of branches and deploys a plurality of versions of services at the same time.
More preferably, the flow rule is specifically as follows:
head matching rules: judging the version to which the request with the header information is forwarded according to the header information in the request;
uri matching rule: judging the version of the uri according to different uris;
query parameter matching rules: according to the query parameters in the request url;
flow ratio rule: the flow ratio is set between the different versions.
Preferably, the flow version is controlled by using Istio when the Devops component is deployed, specifically as follows:
when the Istio component is deployed, the Devops component calls an interface of the Kubernetes cluster, and applications of different versions are deployed to the Kubernetes cluster first;
different versions of the same application, the service names are distinguished by adding tag names;
after service deployment, translating the flow configuration rule into corresponding Istio VirtualService configuration according to the flow rule of each tag configuration, updating Istio VirtualService configuration to the flow management side of the Istio component, and issuing the configuration to the gateway of the Istio component and the side card proxy of each pod;
after the configuration is completed, the flow configuration can take effect, access is carried out according to the configured flow rule, and the request is forwarded to the corresponding version application.
Preferably, the version configuration change is as follows:
(1) constant flow tag, configuration modification: updating mirror image firstly, and updating Istio VirtualService configuration;
(2) flow tag increase: the deployment of the service is changed first, and after the deployment is completed, the configuration of Istio VirtualService is updated.
(3) Flow tag reduction: updating Istio VirtualService configuration firstly, and changing service deployment after updating is completed; if this order is not followed, the deployment of service versions is reduced first, which may cause some traffic to be forwarded to the deleted service, resulting in a decrease in system stability.
More preferably, the version configuration change using the Devops component is specifically as follows:
the tag information is set in the Devops component;
compiling and constructing a mirror image;
judging whether to delete tag:
if yes, updating the configuration of Istio VirtualService, and changing the deployment of the service after the updating is completed;
if not, the deployment of the service is changed, and after the deployment is completed, the configuration of Istio VirtualService is updated.
A system for deploying multi-version services in Kubernetes using devots, the system comprising,
the transformation module is used for constructing configuration transformation of the Devops component, and the Devops component selects an item and a code address of the item when constructing the item;
the control module is used for deploying the Devops component and controlling the flow version by using Istio;
and the change module is used for carrying out version configuration change by using the Devops component.
Preferably, the Devops component deploys one version application and deploys multiple versions applications when constructing a project;
wherein, a version application is deployed specifically as follows:
adding a flow configuration card in the configuration of the Devops component;
adding a plurality of tags into the flow configuration card, wherein the tags are used for distinguishing different deployment versions;
adding a corresponding flow rule while adding the tag, wherein the flow rule is used for judging whether the request can enter the deployment version;
the deployment of multiple versions of an application is specifically as follows:
adding a flow configuration card in the assembly line, and setting a corresponding tag;
selecting a code branch corresponding to each tag when the pipeline is operated;
after the selection is completed, the pipeline can construct a plurality of branches, and a plurality of versions of services are deployed at the same time;
the flow rule is specifically as follows:
head matching rules: judging the version to which the request with the specific header information is forwarded according to the header information in the request;
uri matching rule: judging the version of the uri according to different uris;
query parameter matching rules: according to the query parameters in the request url;
flow ratio rule: setting flow ratio between different versions;
the version configuration change condition is as follows:
(1) constant flow tag, configuration modification: updating mirror image firstly, and updating Istio VirtualService configuration;
(2) flow tag increase: the deployment of the service is changed first, and after the deployment is completed, the configuration of Istio VirtualService is updated.
(3) Flow tag reduction: updating Istio VirtualService configuration firstly, and changing service deployment after updating is completed; if this order is not followed, the deployment of service versions is reduced first, which may cause some traffic to be forwarded to the deleted service, resulting in a decrease in system stability.
A computer readable storage medium having stored therein computer executable instructions that when executed by a processor implement a method for deploying multi-version services in Kubernetes using Devops as described above.
The method and the system for deploying the multi-version service in the Kubernetes by using the Devops have the following advantages:
the invention carries out deep combination on the Devops component construction function and the flow management function in the Istio component, so that the Devops component can construct a plurality of versions of service and is deployed into a cluster at the same time, thereby realizing the function of simultaneously releasing a plurality of versions by using the Devops;
secondly, a plurality of versions of back-end services can be deployed in a test environment, so that development and test personnel can conveniently perform test operation;
thirdly, in the production and on-line environment, a plurality of service versions can be deployed, and AB tests can be carried out on users;
and fourthly, controlling the flow routing rule and the flow proportion by fine granularity, and facilitating the flow control.
Drawings
The invention is further described below with reference to the accompanying drawings.
FIG. 1 is a flow diagram of using Istio to control flow versions when Devops components are deployed;
FIG. 2 is a flow diagram of version configuration changes using Devops components.
Detailed Description
The method and system for deploying multi-version services in Kubernetes using devots of the present invention is described in detail below with reference to the accompanying drawings and specific embodiments.
Example 1:
the method for deploying the multi-version service in the Kubernetes by using the Devops comprises the steps of deploying the service into the Kubernetes cluster by using a Devops component; when the Devops component is deployed, selecting codes of a plurality of branches to deploy, deploying a plurality of service versions in the same environment, simultaneously using Istio to carry out routing configuration of traffic in a Kubernetes cluster, and selecting corresponding requests to enter corresponding service versions; the method comprises the following steps:
s1, configuration transformation of Devops component construction: the Devops component selects an item and the code address of the item when constructing the item; configuration modification of Devops component construction includes deploying one version application and deploying multiple versions applications; wherein, a version application is deployed specifically as follows:
s1-101, adding a flow configuration card in the configuration of the Devops component;
s1-102, adding a plurality of tags into a flow configuration card, wherein the tags are used for distinguishing different deployment versions;
s1-103, adding a corresponding flow rule while adding the tag, wherein the flow rule is used for judging whether the request can enter the deployment version.
The deployment of multiple versions of an application is specifically as follows:
s1-201, adding a flow configuration card in a production line, and setting a corresponding tag;
s1-202, selecting code branches corresponding to each tag when a pipeline is operated;
s1-203, after the selection is completed, the pipeline constructs a plurality of branches, and deploys a plurality of versions of services at the same time.
The flow rule specifically includes:
(1) header matching rules: judging which version the request with the header information is forwarded to according to the header information in the request;
(2) uri matching rule: judging which version the uri belongs to according to different uris;
(3) query parameter matching rules: according to the query parameters in the request url; for example http:// www.abc.com/queryuser=test 1, i.e. the user attribute following the url question mark, to determine to which version this request should be specifically directed;
(4) flow ratio rule: setting flow ratio between different versions; for example, 20% of the flow enters tag1, 80% of the flow enters tag2, and the sum of the flow ratios between the different versions is equal to 100%.
S2, controlling a flow version by using Istio when the Devops component is deployed; after the Devops construction is completed, multiple versions need to be deployed in the clusters of the corresponding environments, provided that components related to Istio need to be deployed in the clusters, so that traffic management can be performed. The method comprises the following steps:
s201, when an Istio component is deployed, the Devops component calls an interface of the Kubernetes cluster, and applications of different versions are deployed to the Kubernetes cluster first;
s202, distinguishing service names of different versions of the same application by adding tag names;
s203, after service deployment, translating the flow configuration rule into corresponding Istio VirtualService configuration according to the flow rule configured by each tag, updating Istio VirtualService configuration to the flow management side of the Istio component, and issuing the configuration to the gateway of the Istio component and the side card proxy of each pod;
and S204, after the configuration is completed, the flow configuration can be effective, and the flow configuration is accessed according to the configured flow rule, and the request is forwarded to the corresponding version application.
S3, performing version configuration change by using Devops component: after describing the entire system modification, the interaction process between the components is described herein as both Dubbo and Istio are modified, so the interaction between both systems is changed.
Version configuration change cases are as follows:
(1) constant flow tag, configuration modification: updating mirror image firstly, and updating Istio VirtualService configuration;
(2) flow tag increase: the deployment of the service is changed first, and after the deployment is completed, the configuration of Istio VirtualService is updated.
(3) Flow tag reduction: updating Istio VirtualService configuration firstly, and changing service deployment after updating is completed; if this order is not followed, the deployment of service versions is reduced first, which may cause some traffic to be forwarded to the deleted service, resulting in a decrease in system stability.
As shown in fig. 2, the version configuration change using the Devops component is specifically as follows:
s301, setting tag information in a Devops component;
s302, compiling and constructing a mirror image;
s303, judging whether to prune tag:
(1) if yes, updating the configuration of Istio VirtualService, and changing the deployment of the service after the updating is completed;
(2) if not, the deployment of the service is changed, and after the deployment is completed, the configuration of Istio VirtualService is updated.
Example 2:
the system of the present invention for deploying multi-version services in Kubernetes using devots, the system comprising,
the transformation module is used for constructing configuration transformation of the Devops component, and the Devops component selects an item and a code address of the item when constructing the item; the Devops component deploys one version application and deploys multiple versions of applications when constructing projects;
wherein, a version application is deployed specifically as follows:
adding a flow configuration card in the configuration of the Devops component;
adding a plurality of tags into the flow configuration card, wherein the tags are used for distinguishing different deployment versions;
adding a corresponding flow rule while adding the tag, wherein the flow rule is used for judging whether the request can enter the deployment version;
the deployment of multiple versions of an application is specifically as follows:
adding a flow configuration card in the assembly line, and setting a corresponding tag;
selecting a code branch corresponding to each tag when the pipeline is operated;
after the selection is completed, the pipeline can construct a plurality of branches, and a plurality of versions of services are deployed at the same time;
the flow rule is specifically as follows:
(1) header matching rules: judging the version to which the request with the specific header information is forwarded according to the header information in the request;
(2) uri matching rule: judging the version of the uri according to different uris;
(3) query parameter matching rules: according to the query parameters in the request url;
(4) flow ratio rule: setting flow ratio between different versions;
the control module is used for deploying the Devops component and controlling the flow version by using Istio;
and the change module is used for carrying out version configuration change by using the Devops component.
The version configuration change condition is as follows:
(1) constant flow tag, configuration modification: updating mirror image firstly, and updating Istio VirtualService configuration;
(2) flow tag increase: the deployment of the service is changed first, and after the deployment is completed, the configuration of Istio VirtualService is updated.
(3) Flow tag reduction: updating Istio VirtualService configuration firstly, and changing service deployment after updating is completed; if this order is not followed, the deployment of service versions is reduced first, which may cause some traffic to be forwarded to the deleted service, resulting in a decrease in system stability.
Example 3:
embodiments of the present invention also provide a computer readable storage medium having stored therein a plurality of instructions for loading by a processor, causing the processor to perform the method of any embodiment of the present invention for deploying multi-version services in Kubernetes using Devops. Specifically, a system or apparatus provided with a storage medium on which a software program code realizing the functions of any of the above embodiments is stored, and a computer (or CPU or MPU) of the system or apparatus may be caused to read out and execute the program code stored in the storage medium.
In this case, the program code itself read from the storage medium may realize the functions of any of the above-described embodiments, and thus the program code and the storage medium storing the program code form part of the present invention.
Examples of storage media for providing program code include floppy disks, hard disks, magneto-optical disks, optical disks (e.g., CD-ROM, CD-R, CD-RW, DVD-ROM, methods and systems M, DVD-RW, DVD+RW for DVD-R to deploy multi-version services in KUBERNETES using DEVOPS), magnetic tape, nonvolatile memory cards, and ROM. Alternatively, the program code may be downloaded from a server computer by a communication network.
Further, it should be apparent that the functions of any of the above-described embodiments may be implemented not only by executing the program code read out by the computer, but also by causing an operating system or the like operating on the computer to perform part or all of the actual operations based on the instructions of the program code.
Further, it is understood that the program code read out by the storage medium is written into a memory provided in an expansion board inserted into a computer or into a memory provided in an expansion unit connected to the computer, and then a CPU or the like mounted on the expansion board or the expansion unit is caused to perform part and all of actual operations based on instructions of the program code, thereby realizing the functions of any of the above embodiments.
Finally, it should be noted that: the above embodiments are only for illustrating the technical solution of the present invention, and not for limiting the same; although the invention has been described in detail with reference to the foregoing embodiments, it will be understood by those of ordinary skill in the art that: the technical scheme described in the foregoing embodiments can be modified or some or all of the technical features thereof can be replaced by equivalents; such modifications and substitutions do not depart from the spirit of the invention.
Claims (8)
1. A method for deploying multi-version services in Kubernetes using devots, characterized in that the method is to deploy services into Kubernetes clusters using devots components; when the Devops component is deployed, selecting codes of a plurality of branches to deploy, deploying a plurality of service versions in the same environment, simultaneously using Istio to carry out routing configuration of traffic in a Kubernetes cluster, and selecting corresponding requests to enter corresponding service versions; the method comprises the following steps:
configuration modification of Devops component build: the Devops component selects an item and the code address of the item when constructing the item; the configuration transformation of the Devops component construction comprises the steps of deploying one version application and deploying a plurality of version applications; wherein, a version application is deployed specifically as follows:
adding a flow configuration card in the configuration of the Devops component;
adding a plurality of tags into the flow configuration card, wherein the tags are used for distinguishing different deployment versions;
adding a corresponding flow rule while adding the tag, wherein the flow rule is used for judging whether the request can enter the deployment version;
the Devops component uses Istio to control the flow version when deployed; the method comprises the following steps:
when the Istio component is deployed, the Devops component calls an interface of the Kubernetes cluster, and applications of different versions are deployed to the Kubernetes cluster first;
different versions of the same application, the service names are distinguished by adding tag names;
after service deployment, translating the flow configuration rule into corresponding Istio VirtualService configuration according to the flow rule of each tag configuration, updating Istio VirtualService configuration to the flow management side of the Istio component, and issuing the configuration to the gateway of the Istio component and the side card proxy of each pod;
after the configuration is completed, the flow configuration can take effect, access is carried out according to the configured flow rule, and the request is forwarded to the corresponding version application;
version configuration changes are made using Devops components.
2. The method for deploying multi-version services in Kubernetes using devots according to claim 1, wherein deploying the plurality of version applications is specifically as follows:
adding a flow configuration card in the assembly line, and setting a corresponding tag;
selecting a code branch corresponding to each tag when the pipeline is operated;
after the selection is completed, the pipeline constructs a plurality of branches and deploys a plurality of versions of services at the same time.
3. The method for deploying multi-version services in Kubernetes using devots according to claim 1, wherein the traffic rules are specifically as follows:
head matching rules: judging the version to which the request with the header information is forwarded according to the header information in the request;
uri matching rule: judging the version of the uri according to different uris;
query parameter matching rules: according to the query parameters in the request url;
flow ratio rule: the flow ratio is set between the different versions.
4. The method for deploying multi-version services in Kubernetes using devots according to claim 1, wherein the version configuration change cases are as follows:
(1) constant flow tag, configuration modification: updating mirror image firstly, and updating Istio VirtualService configuration;
(2) flow tag increase: firstly, changing the deployment of the service, and updating the configuration of Istio VirtualService after the deployment is completed;
(3) flow tag reduction: the configuration of Istio VirtualService is updated first, and after the update is completed, the deployment of the service is changed.
5. The method for deploying multi-version services in Kubernetes using devots according to claim 1, wherein the version configuration change using the devots component is specifically as follows:
the tag information is set in the Devops component;
compiling and constructing a mirror image;
judging whether to delete tag:
if yes, updating the configuration of Istio VirtualService, and changing the deployment of the service after the updating is completed;
if not, the deployment of the service is changed, and after the deployment is completed, the configuration of Istio VirtualService is updated.
6. A system for deploying multi-version services in Kubernetes using devots, the system comprising,
the transformation module is used for constructing configuration transformation of the Devops component, and the Devops component selects an item and a code address of the item when constructing the item;
the control module is used for deploying the Devops component and controlling the flow version by using Istio;
the change module is used for carrying out version configuration change by using the Devops component;
the Devops component deploys one version application and deploys a plurality of version applications when constructing projects;
wherein, a version application is deployed specifically as follows:
adding a flow configuration card in the configuration of the Devops component;
adding a plurality of tags into the flow configuration card, wherein the tags are used for distinguishing different deployment versions;
adding a corresponding flow rule while adding the tag, wherein the flow rule is used for judging whether the request can enter the deployment version;
the use of Istio to control traffic versions at the deployment of Devops components is specifically as follows:
when the Istio component is deployed, the Devops component calls an interface of the Kubernetes cluster, and applications of different versions are deployed to the Kubernetes cluster first;
different versions of the same application, the service names are distinguished by adding tag names;
after service deployment, translating the flow configuration rule into corresponding Istio VirtualService configuration according to the flow rule of each tag configuration, updating Istio VirtualService configuration to the flow management side of the Istio component, and issuing the configuration to the gateway of the Istio component and the side card proxy of each pod;
after the configuration is completed, the flow configuration can take effect, access is carried out according to the configured flow rule, and the request is forwarded to the corresponding version application.
7. The system for deploying multi-version services in Kubernetes using devots as defined in claim 6 wherein deploying the plurality of version applications is specifically as follows:
adding a flow configuration card in the assembly line, and setting a corresponding tag;
selecting a code branch corresponding to each tag when the pipeline is operated;
after the selection is completed, the pipeline can construct a plurality of branches, and a plurality of versions of services are deployed at the same time;
the flow rule is specifically as follows:
head matching rules: judging the version to which the request with the specific header information is forwarded according to the header information in the request;
uri matching rule: judging the version of the uri according to different uris;
query parameter matching rules: according to the query parameters in the request url;
flow ratio rule: setting flow ratio between different versions;
the version configuration change condition is as follows:
(1) constant flow tag, configuration modification: updating mirror image firstly, and updating Istio VirtualService configuration;
(2) flow tag increase: firstly, changing the deployment of the service, and updating the configuration of Istio VirtualService after the deployment is completed;
(3) flow tag reduction: the configuration of Istio VirtualService is updated first, and after the update is completed, the deployment of the service is changed.
8. A computer readable storage medium having stored therein computer executable instructions which, when executed by a processor, implement the method of deploying multi-version services in Kubernetes using Devops of any of claims 1 to 5.
Priority Applications (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN202010854496.4A CN112000343B (en) | 2020-08-24 | 2020-08-24 | Method and system for deploying multi-version services in Kubernetes by using Devops |
Applications Claiming Priority (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN202010854496.4A CN112000343B (en) | 2020-08-24 | 2020-08-24 | Method and system for deploying multi-version services in Kubernetes by using Devops |
Publications (2)
| Publication Number | Publication Date |
|---|---|
| CN112000343A CN112000343A (en) | 2020-11-27 |
| CN112000343B true CN112000343B (en) | 2024-02-20 |
Family
ID=73473076
Family Applications (1)
| Application Number | Title | Priority Date | Filing Date |
|---|---|---|---|
| CN202010854496.4A Active CN112000343B (en) | 2020-08-24 | 2020-08-24 | Method and system for deploying multi-version services in Kubernetes by using Devops |
Country Status (1)
| Country | Link |
|---|---|
| CN (1) | CN112000343B (en) |
Families Citing this family (2)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN112910692B (en) * | 2021-01-19 | 2022-08-02 | 中原银行股份有限公司 | Method, system and medium for controlling service grid flow based on micro service gateway |
| CN114205280B (en) * | 2021-11-17 | 2023-03-31 | 广州云擎互动信息技术有限公司 | Application publishing method and flow routing method based on container cloud and service grid |
Citations (5)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| WO2017161338A1 (en) * | 2016-03-18 | 2017-09-21 | TUPL, Inc. | Continuous and automatic distributed application development and deployment |
| CN110262806A (en) * | 2019-06-20 | 2019-09-20 | 杭州泰然鲸数云计算有限公司 | A kind of DevOps system for supporting automation services layout |
| CN110427204A (en) * | 2019-08-08 | 2019-11-08 | 浪潮云信息技术有限公司 | A kind of automation gray scale dissemination method based on container and service grid |
| CN111190584A (en) * | 2019-12-10 | 2020-05-22 | 平安健康保险股份有限公司 | EHIS-DB system version release method and device, computer equipment and storage medium |
| CN111309441A (en) * | 2020-02-19 | 2020-06-19 | 北京中数智汇科技股份有限公司 | Micro-service deployment method for realizing DevOps based on Jenkins |
-
2020
- 2020-08-24 CN CN202010854496.4A patent/CN112000343B/en active Active
Patent Citations (5)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| WO2017161338A1 (en) * | 2016-03-18 | 2017-09-21 | TUPL, Inc. | Continuous and automatic distributed application development and deployment |
| CN110262806A (en) * | 2019-06-20 | 2019-09-20 | 杭州泰然鲸数云计算有限公司 | A kind of DevOps system for supporting automation services layout |
| CN110427204A (en) * | 2019-08-08 | 2019-11-08 | 浪潮云信息技术有限公司 | A kind of automation gray scale dissemination method based on container and service grid |
| CN111190584A (en) * | 2019-12-10 | 2020-05-22 | 平安健康保险股份有限公司 | EHIS-DB system version release method and device, computer equipment and storage medium |
| CN111309441A (en) * | 2020-02-19 | 2020-06-19 | 北京中数智汇科技股份有限公司 | Micro-service deployment method for realizing DevOps based on Jenkins |
Non-Patent Citations (1)
| Title |
|---|
| 基于OpenStack和Kubernetes的双向部署技术研究;杜磊;;电脑知识与技术(第01期);全文 * |
Also Published As
| Publication number | Publication date |
|---|---|
| CN112000343A (en) | 2020-11-27 |
Similar Documents
| Publication | Publication Date | Title |
|---|---|---|
| CN107370786B (en) | General information management system based on micro-service architecture | |
| US8706771B2 (en) | Systems and methods for analyzing and transforming an application from a source installation to a target installation | |
| US8302093B2 (en) | Automated deployment of defined topology in distributed computing environment | |
| US8494996B2 (en) | Creation and revision of network object graph topology for a network performance management system | |
| US20090138293A1 (en) | Solution that automatically recommends design assets when making architectural design decisions for information services | |
| US8127269B2 (en) | Transforming a flow graph model to a structured flow language model | |
| CN105144088A (en) | Association of metadata with source code and applications and services premised thereon | |
| CN112000343B (en) | Method and system for deploying multi-version services in Kubernetes by using Devops | |
| CN115061674A (en) | Business process online arranging method, device and system and readable storage medium | |
| US9542656B2 (en) | Supporting ETL processing in BPEL-based processes | |
| AU2017265144A1 (en) | Information retrieval | |
| CN113641591A (en) | Test case generation method and device and test method and device | |
| CN113568614A (en) | Task issuing method, electronic device and storage medium | |
| CN113535220B (en) | Code packet management method and device | |
| US8539496B1 (en) | Method and apparatus for configuring network systems implementing diverse platforms to perform business tasks | |
| CN117112060A (en) | Component library construction method and device, electronic equipment and storage medium | |
| EP1710698A2 (en) | Generic software requirements analyser | |
| CN112835606B (en) | Gray release method and device, electronic equipment and medium | |
| CN112181407B (en) | Service realization processing method, device, system, electronic equipment and storage medium | |
| CN114817379A (en) | Qunee-based configuration item relation visualization method, system, equipment and medium | |
| CN114756224A (en) | Activity execution method and device | |
| CN112418796A (en) | Sub-process node activation method and device, electronic equipment and storage medium | |
| CN104040537A (en) | Systems and methods of automatic generation and execution of database queries | |
| JP2014164309A (en) | Screen program generation device, screen program generation method therefor, information processing device, and computer program | |
| CN117251500B (en) | Dynamic read-write separation method for database |
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 | ||
| GR01 | Patent grant | ||
| GR01 | Patent grant |