CN115204136A - Method, device, equipment and medium for simplifying complexity of yaml operation based on DevOps - Google Patents
Method, device, equipment and medium for simplifying complexity of yaml operation based on DevOps Download PDFInfo
- Publication number
- CN115204136A CN115204136A CN202211106800.2A CN202211106800A CN115204136A CN 115204136 A CN115204136 A CN 115204136A CN 202211106800 A CN202211106800 A CN 202211106800A CN 115204136 A CN115204136 A CN 115204136A
- Authority
- CN
- China
- Prior art keywords
- template
- application
- fragment
- crd
- logic
- 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 40
- 230000006870 function Effects 0.000 claims abstract description 26
- 238000004806 packaging method and process Methods 0.000 claims abstract description 6
- 239000012634 fragment Substances 0.000 claims description 74
- 238000003860 storage Methods 0.000 claims description 16
- 230000015654 memory Effects 0.000 claims description 15
- 238000004590 computer program Methods 0.000 claims description 13
- 238000005538 encapsulation Methods 0.000 claims description 3
- 238000010586 diagram Methods 0.000 description 4
- 238000007726 management method Methods 0.000 description 4
- 230000008569 process Effects 0.000 description 4
- 238000004519 manufacturing process Methods 0.000 description 3
- 230000003287 optical effect Effects 0.000 description 3
- 238000004891 communication Methods 0.000 description 2
- 238000013024 troubleshooting Methods 0.000 description 2
- 230000009286 beneficial effect Effects 0.000 description 1
- 238000009826 distribution Methods 0.000 description 1
- 230000000694 effects Effects 0.000 description 1
- 238000005516 engineering process Methods 0.000 description 1
- 230000003993 interaction Effects 0.000 description 1
- 238000012986 modification Methods 0.000 description 1
- 230000004048 modification Effects 0.000 description 1
- 230000001902 propagating effect Effects 0.000 description 1
- 239000004065 semiconductor Substances 0.000 description 1
Images
Classifications
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F40/00—Handling natural language data
- G06F40/10—Text processing
- G06F40/166—Editing, e.g. inserting or deleting
- G06F40/186—Templates
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F8/00—Arrangements for software engineering
- G06F8/30—Creation or generation of source code
- G06F8/31—Programming languages or programming paradigms
- G06F8/313—Logic programming, e.g. PROLOG programming language
-
- 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)
- Theoretical Computer Science (AREA)
- Software Systems (AREA)
- General Engineering & Computer Science (AREA)
- Physics & Mathematics (AREA)
- General Physics & Mathematics (AREA)
- Computer Security & Cryptography (AREA)
- Computing Systems (AREA)
- Health & Medical Sciences (AREA)
- Artificial Intelligence (AREA)
- Audiology, Speech & Language Pathology (AREA)
- Computational Linguistics (AREA)
- General Health & Medical Sciences (AREA)
- Stored Programmes (AREA)
Abstract
The embodiment of the application discloses a method, a device, equipment and a medium for simplifying the complexity of yaml operation based on DevOps, belonging to the technical field of Kubernetes clusters. The method comprises the following steps: acquiring all CRD files in Kubernetes; processing the CRD file to obtain data with different functions, and packaging the data with different functions to generate corresponding logic application; all logical applications are loaded to the kubernets platform to allow the user to define usage. According to the OAM hierarchical concept, a service platform is constructed, a user does not need to pay attention to any infrastructure details, various applications can be obtained only by simple configuration, the complexity of yaml operation is reduced, and user experience is improved.
Description
Technical Field
The invention belongs to the technical field of Kubernetes clusters, and particularly relates to a method, a device, equipment and a medium for simplifying the complexity of yaml operation based on DevOps.
Background
Kubernetes is a container orchestration engine for Google open sources that supports automated deployment, large-scale scalable, application containerization management. When an application is deployed in a kubernets production environment, multiple instances of the application are typically deployed to load balance application requests. For a user, since services involved in deploying an application are complex, problems are prone to occur during deployment, and troubleshooting is difficult.
Disclosure of Invention
To solve the problems of the prior art, the present invention proposes a method, apparatus, device and medium for simplifying complexity of yaml operation based on DevOps. According to the method, a service platform is constructed according to the layering concept of OAM, a user does not need to pay attention to any infrastructure details, and can obtain various applications only by simple configuration, so that the complexity of yaml operation is reduced, and the user experience is improved.
The embodiment of the invention provides the following specific technical scheme:
in a first aspect, there is provided a method of reduced yaml operation complexity based on DevOps, the method comprising:
acquiring all CRD files in Kubernetes;
processing the CRD file to obtain template data with different functions, and packaging the template data with different functions to generate corresponding logic application;
all logical applications are loaded to the kubernets platform to allow the user to define usage.
In some embodiments, the processing the CRD file to obtain template data with different functions and performing encapsulation processing on the template data with different functions to generate the corresponding logic application specifically includes:
abstracting CRD files used by different logic applications to generate a template segment corresponding to each logic application; wherein each template segment corresponds to a function;
combining the template fragments to generate an application template corresponding to each logic application;
and creating a deployment unit based on the application template and generating a corresponding logic application.
In some embodiments, the abstracting the CRD file used by the different logical applications, and the generating the template fragment corresponding to each logical application specifically includes:
creating a template fragment based on the abstracted CRD file;
binding the associated application template for each template fragment;
configuring the template fragments to generate template fragments corresponding to each logic application;
wherein the configuring the template fragment comprises adding metadata to the template fragment.
In some embodiments, the combining the template fragments to generate the application template corresponding to each logical application specifically includes:
creating an application template;
determining an application type of an application template;
a metadata attribute field defining the application template;
and generating the yaml template according to each template fragment corresponding to the application type.
In some embodiments, creating a deployment unit based on an application template specifically includes:
acquiring an application template associated with an application type;
automatically filling metadata attribute fields in the application template;
a deployment unit is created.
In some embodiments, the generating the corresponding logic application specifically includes:
acquiring an application template corresponding to the application type;
determining version information of an application template;
loading metadata attribute fields configured by the application template;
a logical application is created.
In some embodiments, the method further comprises:
based on the received template fragment operation request, carrying out corresponding processing on the template fragment;
wherein the operation request comprises an updating request and an increasing request;
correspondingly, when an update request of the template fragment is received, the corresponding processing of the template fragment comprises updating the metadata in the template fragment;
when an adding request of the template fragment is received, the corresponding processing of the template fragment comprises generating a new template fragment.
In a second aspect, there is provided an apparatus for reducing complexity of yaml operations based on DevOps, the apparatus comprising:
the acquisition module is used for acquiring all CRD files in Kubernets;
the processing module is used for processing the CRD file to obtain template data with different functions and packaging the template data with different functions to generate corresponding logic application;
and the loading module is used for loading all logic applications to the Kubernets platform so as to enable a user to define the use.
In a third aspect, a computer device is provided, comprising a memory, a processor and a computer program stored in the memory and executable on the processor, the processor implementing the method according to the first aspect when executing the computer program.
In a fourth aspect, a computer-readable storage medium is provided, the computer-readable storage medium storing a computer program which, when executed by a processor, implements the method according to the first aspect.
The embodiment of the invention has the following beneficial effects:
1. based on the layering idea of OAM, the CRD file in Kubernets is abstracted and functionally packaged to generate the templates, so that a user can obtain various applications only by combining and simply configuring the templates without paying attention to any infrastructure details, the complexity of the user operation of yaml is reduced, and the user experience is improved;
2. the user can be according to actual demand, and the mode through adding template/update template carries out nimble extension to the fortune dimension characteristic of using, and easy operation has realized the expansion of application ability.
Drawings
In order to more clearly illustrate the technical solutions in the embodiments of the present invention, the drawings needed to be used in the description of the embodiments will be briefly introduced below, and it is obvious that the drawings in the following description are only some embodiments of the present invention, and it is obvious for those skilled in the art to obtain other drawings based on these drawings without creative efforts.
Fig. 1 is an exemplary flow chart of a method of reduced yaml operation complexity based on DevOps according to an embodiment of the present disclosure;
FIG. 2 is an architecture diagram of a device based on DevOps' simplified yaml operational complexity in accordance with an embodiment of the present disclosure;
FIG. 3 is a block diagram of the structure of a DevOps based apparatus for simplified yaml operation complexity according to an embodiment of the present disclosure;
fig. 4 is a schematic structural diagram of a computer device according to an embodiment of the present disclosure.
Detailed Description
In order to make the objects, technical solutions and advantages of the present invention clearer, the technical solutions in the embodiments of the present invention will be clearly and completely described below with reference to the accompanying drawings in the embodiments of the present invention, and it is obvious that the described embodiments are only a part of the embodiments of the present invention, and not all of the embodiments. All other embodiments, which can be derived by a person skilled in the art from the embodiments given herein without making any creative effort, shall fall within the protection scope of the present invention.
As described in the background, kubernets is currently used as a container orchestration engine to support automated deployment, large-scale scalable, application containerization management. When an application is deployed in a kubernets production environment, multiple instances of the application are typically deployed to load balance application requests. For a user, because services involved in deploying the application program are complex, problems are prone to occur during deployment, and troubleshooting is difficult.
In order to solve the problems, the technical scheme is that a CRD file in Kubernets is abstracted and functionally packaged by referring to the layering concept of OAM, and a plurality of templates are generated to be used by a user in a combined mode.
Fig. 1 shows an exemplary flowchart of a method of reduced yaml operation complexity based on DevOps according to an embodiment of the present disclosure, which is detailed as follows:
and step 101, acquiring all CRD files in Kubernets.
CRD, custom Resource definition, is a way for kubernets to improve scalability and let developers customize resources. CRD resources can be dynamically registered in the cluster, and after the registration is finished, a user can create and access the self-defined resource object through kubecect, which is similar to the operation Pod (container group).
And 102, processing the CRD file to obtain template data with different functions, packaging the template data with different functions, and generating corresponding logic application.
In some embodiments, the step 102 may include:
abstracting CRD files used by different logic applications to generate a template segment corresponding to each logic application; wherein each template fragment corresponds to a function;
combining the template fragments to generate an application template corresponding to each logic application;
and creating a deployment unit based on the application template and generating a corresponding logic application.
Before abstracting the CRD file, the method may further include: the logical applications are divided into different types. Exemplary, as divided into: microservice applications, middleware applications, big data applications, and the like. Thus, the CRD file is abstracted by reference. When the CRD file is abstracted, the CRD file can be defined in the template fragment, the template fragment is combined and configured to the application template, and a deployment unit is created to finally realize the creation of the logic application.
On the basis of the above embodiment, abstracting CRD files used by different logical applications, and generating a template fragment corresponding to each logical application specifically includes:
creating a template fragment based on the abstracted CRD file;
binding the associated application template for each template fragment;
configuring the template fragments to generate template fragments corresponding to each logic application;
wherein configuring the template fragment comprises adding metadata to the template fragment.
In this embodiment, the template fragment is a kubernets resource object, such as a fragment of deployment, service, ingress, configmap, secret, which is provided to the application template, and is used by the application template to enhance the extensibility of the application template.
On the basis of the above embodiment, combining the template fragments to generate an application template corresponding to each logical application specifically includes:
creating an application template;
determining an application type of an application template;
a metadata attribute field defining an application template;
and generating the yaml template according to the template fragments corresponding to the application types.
The application template is an encapsulation of Kubernets resource objects, and is used for assembling fragments of the deployyment, service, ingress, configmap and secret template into the application template, and the application template is defined by the model and abstracted for reference of the deployment unit. In addition, by defining metadata management of the template, automatic filling of the parameters can be realized at a deployment unit layer, and input of a user is reduced.
On the basis of the above embodiment, creating a deployment unit based on an application template specifically includes:
acquiring an application template associated with an application type;
automatically filling metadata attribute fields in the application template;
a deployment unit is created.
The deployment unit corresponds to a deployment form in kubernets, and includes resource objects such as deployment, service, ingress, configmap, and secret of kubernets, which are used to describe an application (logical application).
On the basis of the above embodiment, the generating of the corresponding logic application specifically includes:
acquiring an application template corresponding to the application type;
determining version information of an application template;
loading metadata attribute fields configured by the application template;
a logical application is created.
Wherein, an application refers to an externally accessible service, which is used to define the logical form of the application, such as the name of the application, the port number of the application, the domain where the micro-service is located, and the extension field of the application.
After the logic application is loaded to the Kubernets platform, a user can rapidly expand the Kubernets logic application by installing the logic application and configuring the logic application.
The above method for reducing complexity of yaml operation based on DevOps further comprises:
based on the received template fragment operation request, carrying out corresponding processing on the template fragment;
the operation request comprises an updating request and an increasing request;
correspondingly, when an updating request of the template fragment is received, the metadata in the template fragment is updated; when an addition request of a template fragment is received, a new template fragment is generated.
The above-described method of reducing complexity of yaml operations based on DevOps can be applied to the service platform architecture shown in fig. 2. The service platform architecture shown in fig. 2 specifically includes four layers, which are respectively: the system comprises an application logic unit layer, an application deployment unit layer, a service application layer and a template segment layer. According to the method for simplifying the complexity of the yaml operation based on the DevOps, three template segments (Sidecar template, load balancing, elastic scaling) related to the micro-service are exemplarily constructed, a first micro-service template 1 and a second micro-service template 2 are created according to the three template segments, and after the deployment is completed based on the application deployment unit, the application of the micro-service is finally generated.
Through the above architecture layering, the whole service platform is the same as OAM, the application description is thoroughly separated from the details of infrastructure deployment and management application, and high decoupling is realized.
Generally, the method and the system form a business application program by maintaining a template fragment, realize the addition of various application characteristics and the automatic filling of metadata, reduce the complexity of user operation yaml, enable the data to be automatically filled through metadata definition, and improve the user experience.
With continuing reference to fig. 3, as an implementation of the method shown in fig. 1 described above, there is provided an embodiment of a device for reducing complexity of yaml operations based on DevOps, the embodiment of the device corresponding to the embodiment of the method shown in fig. 1, as shown in fig. 3, the device for reducing complexity of yaml operations based on DevOps of the present embodiment comprises:
an obtaining module 301, configured to obtain all CRD files in Kubernetes;
a processing module 302, configured to process the CRD file to obtain template data with different functions and package the template data with different functions, so as to generate a corresponding logic application;
a loading module 303, configured to load all logical applications to the kubernets platform to enable a user to define usage.
In some optional implementations of this embodiment, the processing module 302 is specifically configured to:
abstracting CRD files used by different logic applications to generate a template fragment corresponding to each logic application; wherein each template segment corresponds to a function;
combining the template fragments to generate an application template corresponding to each logic application;
and creating a deployment unit based on the application template and generating a corresponding logic application.
In some optional implementations of this embodiment, the processing module 302 is specifically configured to:
creating a template fragment based on the abstracted CRD file;
binding the associated application template for each template fragment;
configuring the template fragments to generate template fragments corresponding to each logic application;
wherein configuring the template fragment comprises adding metadata to the template fragment.
In some optional implementations of this embodiment, the processing module 302 is specifically configured to:
creating an application template;
determining an application type of an application template;
a metadata attribute field defining an application template;
and generating the yaml template according to each template fragment corresponding to the application type.
In some optional implementations of this embodiment, the processing module 302 is specifically configured to:
acquiring an application template associated with an application type;
automatically filling metadata attribute fields in the application template;
a deployment unit is created.
In some optional implementations of this embodiment, the processing module 302 is specifically configured to:
acquiring an application template corresponding to the application type;
determining version information of an application template;
loading metadata attribute fields configured by the application template;
a logical application is created.
In some optional implementations of this embodiment, the apparatus further includes an updating module 304, configured to:
based on the received template fragment operation request, carrying out corresponding processing on the template fragment;
the operation request comprises an updating request and an increasing request;
correspondingly, when an updating request of the template fragment is received, the corresponding processing of the template fragment comprises updating the metadata in the template fragment;
when a template segment adding request is received, the corresponding processing of the template segment comprises generating a new template segment.
Reference is now made to FIG. 4, which illustrates a schematic block diagram of a computer device suitable for use in implementing embodiments of the present application. The computer device shown in fig. 4 is only an example, and should not bring any limitation to the function and the scope of use of the embodiments of the present application.
The computer device shown in fig. 4 includes a processor, a memory, and a network interface connected by a system bus. Wherein the processor of the computer device is configured to provide computing and control capabilities. The memory of the computer device comprises a nonvolatile storage medium and an internal memory. The non-volatile storage medium stores an operating system, a computer program, and a database. The internal memory provides an environment for the operation of an operating system and computer programs in the non-volatile storage medium. The network interface of the computer device is used for communicating with an external terminal through a network connection. The computer program when executed by a processor implements a method of reducing complexity of yaml operations based on DevOps. The storage may be an internal storage unit such as a hard disk or a memory. The memory may also be an external storage device, such as a plug-in hard disk, smart Media Card (SMC), secure Digital (SD) Card, flash memory Card (Flash Card), or the like. Further, the memory may also include both an internal storage unit and an external storage device. The memory is used for storing computer programs and other programs and data required by the device. The memory may also be used to temporarily store data that has been output or is to be output.
Those skilled in the art will appreciate that fig. 4 is merely an example of a computing device and is not intended to limit a computing device and that it may include more or fewer components than those shown, or some of the components may be combined, or different components, e.g., the computing device may also include input output devices, network access devices, buses, etc.
It should be noted that, for the information interaction, execution process, and other contents between the above devices/units, the specific functions and technical effects thereof based on the same concept as those of the method embodiment of the present application can be specifically referred to the method embodiment portion, and are not described herein again.
It will be apparent to those skilled in the art that, for convenience and brevity of description, only the above-mentioned division of the functional units and modules is illustrated, and in practical applications, the above-mentioned function distribution may be performed by different functional units and modules according to needs, that is, the internal structure of the apparatus is divided into different functional units or modules, so as to perform all or part of the functions described above. Each functional unit and module in the embodiments may be integrated in one processing unit, or each unit may exist alone physically, or two or more units are integrated in one unit, and the integrated unit may be implemented in a form of hardware, or in a form of software functional unit. In addition, specific names of the functional units and modules are only for convenience of distinguishing from each other, and are not used for limiting the protection scope of the present application. For the specific working processes of the units and modules in the system, reference may be made to the corresponding processes in the foregoing method embodiments, which are not described herein again.
The embodiments of the present application further provide a computer-readable storage medium, where a computer program is stored, and when the computer program is executed by a processor, the computer program implements the steps that can be implemented in the above method embodiments.
Portions of the technology may be considered "articles" or "articles of manufacture" in the form of executable code and/or associated data, which may be embodied or carried out by a computer readable medium. Tangible, non-transitory storage media may include memory or storage for use by any computer, processor, or similar device or associated module. For example, various semiconductor memories, tape drives, disk drives, or any similar device capable of providing storage functionality for software.
All or a portion of the software may sometimes communicate over a network, such as the internet or other communication network. Such communication may load software from one computer device or processor to another. Thus, another medium capable of transferring software elements may also be used as a physical connection between local devices, such as optical, electrical, electromagnetic waves, etc., propagating through cables, optical cables, air, etc. The physical medium used for the carrier wave, such as an electrical, wireless connection, or optical cable, etc., can also be considered to be the medium carrying the software. As used herein, unless limited to a tangible "storage" medium, other terms denoting a computer or machine "readable medium" are used to denote a medium that participates in the execution of any instruction by a processor.
The technical features of the above embodiments can be arbitrarily combined, and for the sake of brevity, all possible combinations of the technical features in the above embodiments are not described, but should be considered as the scope of the present specification as long as there is no contradiction between the combinations of the technical features.
The above examples only show some embodiments of the present invention, and the description thereof is more specific and detailed, but not construed as limiting the scope of the invention. It should be noted that, for a person skilled in the art, several variations and modifications can be made without departing from the inventive concept, which falls within the scope of the present invention. Therefore, the protection scope of the present patent shall be subject to the appended claims.
Claims (10)
1. A method for reducing complexity of yaml operations based on DevOps, the method comprising:
acquiring all CRD files in Kubernetes;
processing the CRD file to obtain template data with different functions, and packaging the template data with different functions to generate corresponding logic application;
all logical applications are loaded to the kubernets platform to allow the user to define usage.
2. The method according to claim 1, wherein the processing the CRD file to obtain template data with different functions and performing encapsulation processing on the template data with different functions to generate corresponding logic applications specifically includes:
abstracting CRD files used by different logic applications to generate a template segment corresponding to each logic application; wherein each template fragment corresponds to a function;
combining the template fragments to generate an application template corresponding to each logic application;
and creating a deployment unit based on the application template and generating a corresponding logic application.
3. The method according to claim 2, wherein abstracting CRD files used by different logical applications to generate the template fragment corresponding to each logical application specifically comprises:
creating a template fragment based on the abstracted CRD file;
binding the associated application template for each template fragment;
configuring the template fragments to generate template fragments corresponding to each logic application;
wherein configuring the template fragment comprises adding metadata to the template fragment.
4. The method of claim 3, wherein the combining the template fragments to generate the application template corresponding to each logical application specifically comprises:
creating an application template;
determining an application type of an application template;
a metadata attribute field defining the application template;
and generating the yaml template according to each template fragment corresponding to the application type.
5. The method of claim 4, wherein creating a deployment unit based on an application template specifically comprises:
acquiring an application template associated with an application type;
automatically filling metadata attribute fields in the application template;
a deployment unit is created.
6. The method according to claim 5, wherein the generating the corresponding logical application specifically comprises:
acquiring an application template corresponding to the application type;
determining version information of an application template;
loading metadata attribute fields configured by the application template;
a logical application is created.
7. The method according to any one of claims 2 to 6, further comprising:
based on the received template fragment operation request, carrying out corresponding processing on the template fragment;
wherein the operation request comprises an updating request and an increasing request;
correspondingly, when an update request of the template fragment is received, the corresponding processing of the template fragment comprises updating the metadata in the template fragment;
when an adding request of the template fragment is received, the corresponding processing of the template fragment comprises generating a new template fragment.
8. An apparatus for simplifying complexity of yaml operations based on DevOps, the apparatus comprising:
the acquisition module is used for acquiring all CRD files in Kubernetes;
the processing module is used for processing the CRD file to obtain template data with different functions and packaging the template data with different functions to generate corresponding logic application;
and the loading module is used for loading all logic applications to the Kubernets platform so as to enable a user to define the use.
9. A computer device comprising a memory, a processor and a computer program stored in the memory and executable on the processor, wherein the processor implements the method according to any one of claims 1 to 7 when executing the computer program.
10. A computer-readable storage medium, in which a computer program is stored which, when being executed by a processor, carries out the method according to any one of claims 1 to 7.
Priority Applications (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN202211106800.2A CN115204136A (en) | 2022-09-13 | 2022-09-13 | Method, device, equipment and medium for simplifying complexity of yaml operation based on DevOps |
Applications Claiming Priority (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN202211106800.2A CN115204136A (en) | 2022-09-13 | 2022-09-13 | Method, device, equipment and medium for simplifying complexity of yaml operation based on DevOps |
Publications (1)
| Publication Number | Publication Date |
|---|---|
| CN115204136A true CN115204136A (en) | 2022-10-18 |
Family
ID=83572553
Family Applications (1)
| Application Number | Title | Priority Date | Filing Date |
|---|---|---|---|
| CN202211106800.2A Pending CN115204136A (en) | 2022-09-13 | 2022-09-13 | Method, device, equipment and medium for simplifying complexity of yaml operation based on DevOps |
Country Status (1)
| Country | Link |
|---|---|
| CN (1) | CN115204136A (en) |
Citations (3)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN110221859A (en) * | 2019-06-05 | 2019-09-10 | 软通智慧科技有限公司 | A kind of online management method of the deployment of application, device, equipment and storage medium |
| CN110515628A (en) * | 2019-08-09 | 2019-11-29 | 济南浪潮数据技术有限公司 | Using dispositions method and device |
| CN110768833A (en) * | 2019-10-25 | 2020-02-07 | 北京宝兰德软件股份有限公司 | Application arrangement and deployment method and device based on kubernets |
-
2022
- 2022-09-13 CN CN202211106800.2A patent/CN115204136A/en active Pending
Patent Citations (3)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN110221859A (en) * | 2019-06-05 | 2019-09-10 | 软通智慧科技有限公司 | A kind of online management method of the deployment of application, device, equipment and storage medium |
| CN110515628A (en) * | 2019-08-09 | 2019-11-29 | 济南浪潮数据技术有限公司 | Using dispositions method and device |
| CN110768833A (en) * | 2019-10-25 | 2020-02-07 | 北京宝兰德软件股份有限公司 | Application arrangement and deployment method and device based on kubernets |
Similar Documents
| Publication | Publication Date | Title |
|---|---|---|
| CN107896162B (en) | Deployment method and device of monitoring system, computer equipment and storage medium | |
| CN107959582B (en) | Slice instance management method and device | |
| CN111767143A (en) | Transaction data processing method, device, equipment and system | |
| CN112866333A (en) | Cloud-native-based micro-service scene optimization method, system, device and medium | |
| US10594800B2 (en) | Platform runtime abstraction | |
| CN108572845B (en) | Upgrading method of distributed micro-service cluster and related system | |
| CN108279882B (en) | Framework generation method, device, equipment and computer readable medium | |
| CN108885564B (en) | Resource placement control in network virtualization scenarios | |
| CN104750528A (en) | Management method and device for components in Android program | |
| US20210097476A1 (en) | Container Management Method, Apparatus, and Device | |
| JP7377965B2 (en) | Network resource management methods, systems, network equipment and readable storage media | |
| CN111651219A (en) | Method and equipment for managing multi-module project configuration file | |
| CN112199164A (en) | Method for ensuring container mirror image consistency | |
| CN113190282A (en) | Android operating environment construction method and device | |
| CN116113923A (en) | Container cluster management method and system | |
| CN109343970B (en) | Application program-based operation method and device, electronic equipment and computer medium | |
| JP2024501005A (en) | Management method and device for container clusters | |
| CN116800616A (en) | Management method and related device of virtualized network equipment | |
| CN116755799A (en) | Service arrangement system and method | |
| CN110955415A (en) | Method for adapting projection multi-platform service | |
| CN115204136A (en) | Method, device, equipment and medium for simplifying complexity of yaml operation based on DevOps | |
| CN112162793B (en) | Method, storage medium, electronic device and system for separating structured view services | |
| CN111142972B (en) | Method, apparatus, system, and medium for extending functions of application program | |
| CN114840310A (en) | Container creation method, device, electronic equipment and computer-readable storage medium | |
| CN114625479A (en) | Cloud edge collaborative application management method in edge computing and corresponding device |
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 | ||
| RJ01 | Rejection of invention patent application after publication | ||
| RJ01 | Rejection of invention patent application after publication |
Application publication date: 20221018 |