CN116594635A - Cloud primary continuous integration and delivery method and device - Google Patents
Cloud primary continuous integration and delivery method and device Download PDFInfo
- Publication number
- CN116594635A CN116594635A CN202310557313.6A CN202310557313A CN116594635A CN 116594635 A CN116594635 A CN 116594635A CN 202310557313 A CN202310557313 A CN 202310557313A CN 116594635 A CN116594635 A CN 116594635A
- Authority
- CN
- China
- Prior art keywords
- code
- test
- codes
- development
- delivery
- 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
- 230000010354 integration Effects 0.000 title claims abstract description 61
- 238000002716 delivery method Methods 0.000 title claims abstract description 12
- 238000012360 testing method Methods 0.000 claims abstract description 141
- 238000012384 transportation and delivery Methods 0.000 claims abstract description 80
- 238000011161 development Methods 0.000 claims abstract description 73
- 238000000034 method Methods 0.000 claims abstract description 52
- 230000008569 process Effects 0.000 claims abstract description 25
- 238000010276 construction Methods 0.000 claims abstract description 23
- 230000004048 modification Effects 0.000 claims abstract description 15
- 238000012986 modification Methods 0.000 claims abstract description 15
- 238000012545 processing Methods 0.000 claims abstract description 8
- 238000004590 computer program Methods 0.000 claims description 13
- 230000006870 function Effects 0.000 claims description 12
- 238000004519 manufacturing process Methods 0.000 claims description 12
- 238000004458 analytical method Methods 0.000 claims description 9
- 238000003860 storage Methods 0.000 claims description 9
- 238000011056 performance test Methods 0.000 claims description 6
- 238000012544 monitoring process Methods 0.000 claims description 5
- 230000003068 static effect Effects 0.000 claims description 5
- 238000011076 safety test Methods 0.000 claims description 4
- 230000003993 interaction Effects 0.000 claims description 3
- 230000008439 repair process Effects 0.000 claims description 3
- 230000008859 change Effects 0.000 claims description 2
- 238000007726 management method Methods 0.000 description 5
- 238000012550 audit Methods 0.000 description 2
- 230000006399 behavior Effects 0.000 description 2
- 230000002085 persistent effect Effects 0.000 description 2
- 238000003908 quality control method Methods 0.000 description 2
- 230000001360 synchronised effect Effects 0.000 description 2
- 235000010254 Jasminum officinale Nutrition 0.000 description 1
- 240000005385 Jasminum sambac Species 0.000 description 1
- 230000009286 beneficial effect Effects 0.000 description 1
- 230000008901 benefit Effects 0.000 description 1
- 235000020289 caffè mocha Nutrition 0.000 description 1
- 238000010586 diagram Methods 0.000 description 1
- 230000000694 effects Effects 0.000 description 1
- 230000007613 environmental effect Effects 0.000 description 1
- 230000036541 health Effects 0.000 description 1
- 230000006872 improvement Effects 0.000 description 1
- 230000007246 mechanism Effects 0.000 description 1
- 238000005457 optimization Methods 0.000 description 1
- 230000004044 response Effects 0.000 description 1
- 238000004904 shortening 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
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F11/00—Error detection; Error correction; Monitoring
- G06F11/36—Preventing errors by testing or debugging software
- G06F11/3668—Software testing
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F11/00—Error detection; Error correction; Monitoring
- G06F11/36—Preventing errors by testing or debugging software
- G06F11/3668—Software testing
- G06F11/3672—Test management
- G06F11/3676—Test management for coverage analysis
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F11/00—Error detection; Error correction; Monitoring
- G06F11/36—Preventing errors by testing or debugging software
- G06F11/3668—Software testing
- G06F11/3672—Test management
- G06F11/3684—Test management for test design, e.g. generating new test cases
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F11/00—Error detection; Error correction; Monitoring
- G06F11/36—Preventing errors by testing or debugging software
- G06F11/3668—Software testing
- G06F11/3672—Test management
- G06F11/3688—Test management for test execution, e.g. scheduling of test suites
-
- 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/70—Software maintenance or management
-
- 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
- Y02P—CLIMATE CHANGE MITIGATION TECHNOLOGIES IN THE PRODUCTION OR PROCESSING OF GOODS
- Y02P90/00—Enabling technologies with a potential contribution to greenhouse gas [GHG] emissions mitigation
- Y02P90/30—Computing systems specially adapted for manufacturing
Landscapes
- Engineering & Computer Science (AREA)
- Theoretical Computer Science (AREA)
- General Engineering & Computer Science (AREA)
- Physics & Mathematics (AREA)
- General Physics & Mathematics (AREA)
- Software Systems (AREA)
- Computer Hardware Design (AREA)
- Quality & Reliability (AREA)
- Stored Programmes (AREA)
Abstract
The application discloses a cloud native continuous integration and delivery method and device, wherein the method is suitable for continuous integration and delivery in a cloud native environment, provides better support and guarantee for cloud native application, and firstly acquires development codes submitted by multiple developers and integrates the development codes into a code warehouse; constructing the combination of the development codes in the code warehouse, and checking the development codes after constructing the combination through unit testing; then, after the test is passed, the test result is fed back to the developer, the mirror image of the combined and constructed development code is sent to a delivery pipeline environment, and the delivery pipeline environment is fed back to a plurality of developers; and finally, acquiring delivery results of modification, integration and construction operation processing of a plurality of developers in a delivery pipeline environment. The development team is helped to deliver the software to the user more quickly and reliably through the delivery pipeline environment, and the technical problems of code integration and lower delivery efficiency in the software development process are solved.
Description
Technical Field
The application relates to the technical field of software development, in particular to a cloud native continuous integration and delivery method and device.
Background
Software development is a process of building a system or a part of a system according to the needs of users, and in order to meet the needs of clients, many enterprises choose to take a lot of time to perform demand analysis before project development, even if the analysis and deployment are performed carefully, problems of uncertainty, such as updating codes, writing new functions, adjusting architecture, expanding capacity of the system, etc., are encountered in the development process.
In conventional software development, code integration is usually required at the end of a project after each person of each developer completes a job, and a conventional integration process usually requires weeks or months. Particularly for complex projects, the efficiency is greatly reduced, the response speed of the change is low, and the whole system needs to be modified to ensure the normal operation of related modules.
Disclosure of Invention
Based on the above, the embodiment of the application provides a cloud native continuous integration and delivery method and device, which are used for solving the technical problem of lower code integration and delivery efficiency in the software development process in the prior art.
In a first aspect, a method for cloud native continuous integration and delivery is provided, the method comprising:
acquiring development codes submitted by a plurality of developers and integrating the development codes into a code warehouse;
constructing the combination of the development codes in the code warehouse, and checking the development codes after constructing the combination through unit testing;
after the test is passed, the test result is fed back to the developer, the mirror image of the combined and constructed development code is sent to a delivery pipeline environment, and the delivery pipeline environment is fed back to a plurality of developers;
acquiring delivery results of modification, integration and construction operation processing of a plurality of developers in the delivery pipeline environment; wherein the developer can perform modification, integration and construction operations in the delivery pipeline environment; when the test passes, the software is automatically deployed into the production environment.
Optionally, the acquiring the development code submitted by the multiple developers and integrating the development code into a code repository includes:
the developer submits the codes to a code warehouse, and the continuous integrated system can acquire the codes from the code warehouse regularly;
combining codes submitted by different developers to ensure that the codes can normally run and solve code conflicts;
and checking the combined codes, wherein the checking items at least comprise code styles and code qualities.
Optionally, the constructing the development codes in the code repository in a combined manner and checking the development codes after the combined construction through unit testing includes:
compiling the code into executable code; performing unit test on the compiled code, and testing the basic function of the code; carrying out static analysis on the codes to find potential problems; and (5) analyzing the test coverage rate of the code to ensure that the code is fully tested.
Optionally, the compiled code performs unit testing, and tests basic functions of the code, including:
writing a test case, wherein the test case covers all basic functions of codes and tests boundary conditions;
running the compiled test cases on codes, and recording test results;
repairing errors in the code by searching for reasons of test failure; after the error is repaired, the test case is operated again, so that the basic function of the code is ensured to be tested correctly;
and (5) analyzing the test coverage rate of the code to ensure that the code is fully tested.
Optionally, the feeding back the test result to the developer, sending the mirror image of the combined and constructed development code to a delivery pipeline environment, and feeding back the delivery pipeline environment to a plurality of developers, including:
deploying the constructed code image into a test environment; carrying out integrated test on codes deployed in a test environment, and testing whether interaction between different modules is normal or not; performing performance test on codes deployed in a test environment, and testing the performance of the codes under high load conditions; and carrying out security test on the code deployed in the test environment to test whether the code has security holes or not.
Optionally, obtaining delivery results of modification, integration, and construction operation processing performed by multiple developers in the delivery pipeline environment includes:
automatically deploying the code passing the test into a production environment; monitoring and log analysis are carried out on codes in a production environment, and problems are found and solved in time; questions in the production environment are fed back to the developer, helping them improve code and flow.
Optionally, the method further comprises:
obtaining improved feedback proposed by a developer in a delivery pipeline environment;
according to the improved feedback of the developer, the continuous integrated system modifies the code, repairs the problem or improves the code;
after modifying the code, the code needs to be reconstructed and tested, so that the correctness and stability of the code are ensured;
after construction and test pass, code is redeployed into a delivery pipeline environment, and integrated test, performance test and safety test are carried out, so that the running stability and performance of the code in different environments are ensured;
and feeding back the test result to the developer, wherein the specific feedback codes run in different environments.
In a second aspect, there is provided a cloud native continuous integration and delivery apparatus, the apparatus comprising:
the acquisition module is used for acquiring development codes submitted by a plurality of developers and integrating the development codes into a code warehouse;
the integrated module is used for carrying out combined construction on the development codes in the code warehouse and checking the combined and constructed development codes through unit testing;
the delivery module is used for feeding back the test result to the developer after the test is passed, sending the mirror image of the combined and constructed development code to a delivery pipeline environment, and feeding back the delivery pipeline environment to a plurality of developers; acquiring delivery results of modification, integration and construction operation processing of a plurality of developers in the delivery pipeline environment; wherein the developer can perform modification, integration and construction operations in the delivery pipeline environment; when the test passes, the software is automatically deployed into the production environment.
In a third aspect, an electronic device is provided, including a memory and a processor, where the memory stores a computer program, and the processor implements the cloud native continuous integration and delivery method according to any one of the first aspects when executing the computer program.
In a fourth aspect, a computer readable storage medium is provided, on which a computer program is stored, which when executed by a processor implements the cloud native continuous integration and delivery method of any of the first aspects above.
In the technical scheme provided by the embodiment of the application, development codes submitted by a plurality of developers are firstly obtained, and the development codes are integrated into a code warehouse; constructing the combination of the development codes in the code warehouse, and checking the development codes after constructing the combination through unit testing; then, after the test is passed, the test result is fed back to the developer, the mirror image of the combined and constructed development code is sent to a delivery pipeline environment, and the delivery pipeline environment is fed back to a plurality of developers; and finally, acquiring delivery results of modification, integration and construction operation processing of a plurality of developers in a delivery pipeline environment. It can be seen that the application has the beneficial effects of solving the technical problems of lower code integration and delivery efficiency in the software development process.
Drawings
In order to more clearly illustrate the embodiments of the present application or the technical solutions in the prior art, the drawings used in the description of the embodiments or the prior art will be briefly described below. It will be apparent to those skilled in the art from this disclosure that the drawings described below are merely exemplary and that other embodiments may be derived from the drawings provided without undue effort.
FIG. 1 is a flowchart of a cloud native continuous integration and delivery process according to an embodiment of the present application;
FIG. 2 is a flowchart of a cloud native continuous integration process provided by an embodiment of the present application;
fig. 3 is a flowchart of a cloud primary persistent delivery process according to an embodiment of the present application.
Detailed Description
The present application will be described in further detail with reference to the drawings and examples, in order to make the objects, technical solutions and advantages of the present application more apparent. It should be understood that the specific embodiments described herein are for purposes of illustration only and are not intended to limit the scope of the application.
In the description of the present application, the terms "comprises," "comprising," and any variations thereof, are intended to cover a non-exclusive inclusion, such that a process, method, system, article, or apparatus that comprises a list of steps or elements is not necessarily limited to those steps or elements but may include other steps or elements not expressly listed but inherent to such process, method, article, or apparatus or steps or elements added based on further optimization of the inventive concept.
Based on cloud native infrastructure throughout the implementation environment of the present application. Because the architecture of the platform is a cloud-native basic mechanism, the informationized application developed by the code-free platform has the application characteristics of cloud-native naturally, and no additional development is needed by a developer. These applications have the following features:
high availability: the application is deployed naturally through the cluster, and single-point faults do not exist;
high expansibility: the application has elastic expansion capacity naturally, and can expand and reduce the volume at any time according to the service requirement;
monitorability: the application has the monitoring capability naturally, and can view the health information of the application in real time, and quickly detect and solve various problems;
continuous evolution: the application uses a micro-service architecture naturally, and each module can be independently developed, tested and deployed, so that the continuous evolution of the system is ensured.
In conventional software development, the integration process typically occurs at the end of the project after each person has completed the work. Whereas the process of integrating the integration typically takes weeks or months. Continuous integration is a practice that places the integration phase early in the development cycle so that code can be built, tested, and integrated on a regular basis. The method is suitable for continuous integration and delivery in a cloud native environment, provides better support and guarantee for cloud native application, and referring to fig. 1, a flowchart of a method for continuous integration and delivery of cloud native, which is provided by the embodiment of the application, is shown, and the method can comprise the following steps:
step 101, acquiring development codes submitted by a plurality of developers and integrating the development codes into a code warehouse.
In this step, it means that multiple developers can write codes for the same product in different environments and different scenes, and integrate the codes into a code warehouse. The method specifically comprises the following steps:
acquiring code submitted by a developer: the developer submits the code to a code repository from which the continuous integration system periodically retrieves the code.
Merging codes: and merging codes submitted by different developers, ensuring that the codes can normally run, and solving code conflict.
Code checking: the combined code is checked, e.g. code style, code quality, etc.
And 102, performing combined construction on the development codes in the code warehouse, and checking the combined and constructed development codes through unit testing.
The code is then built and combined among the CI servers according to the separately written portions and checked by unit testing for execution in the manner desired by the developer for subsequent development by the developer.
In the embodiment of the application, the method for checking the development code after the combination construction through the unit test specifically comprises the following steps:
code compiling: the code is compiled into executable code.
Unit test: and performing unit test on the compiled code, and testing the basic function of the code.
Static code analysis: and carrying out static analysis on the codes to find potential problems.
Test coverage: and (5) analyzing the test coverage rate of the code to ensure that the code is fully tested.
As in fig. 2, a flow chart of the implemented cloud native continuous integration process is presented. The method comprises the steps of configuring source code library information (sourceresponsive) corresponding to development codes, and completing compiling and testing processes of software codes in a continuous integrated server by the development codes.
The CI server specifically refers to a continuous integrated server, and the CIServer automatically completes the compiling and testing process of the software codes. Most developers do this manually. Some even not. The CI server can automatically complete the compiling and testing process according to the set frequency. CIServer will make the work easy and simple. Continuously, the automatic compiling process helps a software development team to reduce project risks, and improves working efficiency and quality of software products. CIServer can help shorten software development, integration, and testing time, thereby shortening delivery time.
In an alternative embodiment of the present application, the compiled code is subjected to unit testing, and the basic functionality of the test code generally includes the following steps:
writing a test case: writing test cases is the first step of unit testing, and the test cases should cover all basic functions of the code and test boundary conditions.
Running test cases: and running the written test cases on codes, and recording test results.
Analyzing the test result: analyzing the test result, searching the reason of test failure, and repairing the error in the code.
Repeating the test: after the error is repaired, the test case is operated again, so that the basic function of the code is ensured to be tested correctly.
Test coverage analysis: and (5) analyzing the test coverage rate of the code to ensure that the code is fully tested.
In practice, unit testing is typically performed in an automated fashion, and a developer may use various test frames and tools to perform unit testing, such as JUnit, testNG, mocha, jasmine. Automated testing can help developers test code faster, reduce the possibility of human error, and improve code quality.
And step 103, after the test is passed, the test result is fed back to the developer, the mirror image of the combined and constructed development code is sent to a delivery pipeline environment, and the delivery pipeline environment is fed back to a plurality of developers.
The method specifically comprises the following steps:
deployment: and deploying the constructed code image into a test environment.
And (3) integration test: and carrying out integrated test on codes deployed in the test environment, and testing whether interaction between different modules is normal or not.
Performance test: performance testing is performed on code deployed in a test environment to test the behavior of the code under high load conditions.
Safety test: and carrying out security test on the code deployed in the test environment to test whether the code has security holes or not.
Step 104, obtaining the delivery result of the modification, integration and construction operation processing of a plurality of developers in the delivery pipeline environment.
As in fig. 3, a cloud primary persistent delivery process flow diagram is presented. In the continuous integration process, only a simple development environment is considered, and the continuous delivery is different from the continuous integration in that the continuous delivery is implemented in a plurality of different environments, and when a developer changes, integrates and constructs codes, the developer needs to perform the same operations of construction, integration, testing and the like in other environments similar to the development environment. This process of deploying to and testing on different environments is referred to as a delivery pipeline environment. The delivery pipeline environment will typically have a development environment, a testing environment, a staging environment, and a production environment. The delivery pipeline environment can also be a deployment pipeline environment, which is used for automatically deploying and testing software, and helps a development team deliver the software to users more quickly and reliably. In this environment, developers can make changes, integration, and construction operations. If the test passes, the software will be automatically deployed into the production environment.
Acquiring delivery results of modification, integration, and build operation processes by multiple developers in a delivery pipeline environment may further comprise:
and (3) obtaining feedback: in a delivery pipeline environment, a developer may find some problems or make some suggestions for improvement, and a continuous integrated system needs to obtain the feedback in time.
Modifying the code: based on developer feedback, the continuous integration system needs to modify the code, fix the problem or improve the code.
Reconstruction and testing: after modifying the code, the continuous integrated system needs to be reconstructed and tested to ensure the correctness and stability of the code.
Redeployment and testing: after construction and test pass, the continuous integrated system needs to redeploy the code into the delivery pipeline environment, and perform integrated test, performance test, safety test and the like, so as to ensure the running stability and performance of the code in different environments.
And (3) feeding back a result: continuous integrated systems require feedback of test results to developers to keep them aware of the code's behavior in different environments in order to continue to improve the code and flow.
These steps can help the development team to respond to feedback quickly, repair problems in time, and improve code quality and team efficiency. In an alternative embodiment of the present application, the above steps may further include:
configuration management: configuration management can ensure that the configuration of all environments is consistent, reducing problems caused by environmental differences.
And (3) quality control: the quality control can ensure that the code quality meets the standard, and reduce the problems caused by the code quality problem.
Automated testing: automated testing can help development teams to test code quickly and accurately, reducing problems caused by human error.
And (3) continuously monitoring: the continuous monitoring can help a development team to discover and solve problems in time, and stability and reliability of the application program are improved.
Security audit: the security audit can help the development team discover and resolve security issues, protecting the security of applications and users.
Automated deployment: the automatic deployment can help a development team to rapidly and accurately deploy the application program, and reduce the problems caused by human errors.
Code branch management: code branch management can help a development team to better manage code, reducing problems caused by code management problems.
The steps are very important links in the cloud native continuous integration and delivery process, and can help a development team deliver high-quality software faster and more accurately.
The embodiment of the application also provides a cloud native continuous integration and delivery device. The device comprises:
the acquisition module is used for acquiring development codes submitted by a plurality of developers and integrating the development codes into a code warehouse;
the integrated module is used for carrying out combined construction on the development codes in the code warehouse and checking the combined and constructed development codes through unit testing;
the delivery module is used for feeding back the test result to the developer after the test is passed, sending the mirror image of the combined and constructed development code to the delivery pipeline environment, and feeding back the delivery pipeline environment to a plurality of developers; the delivery results of the modification, integration, and build operations processes performed by multiple developers in a delivery pipeline environment are obtained.
In an alternative embodiment of the application, the obtaining module includes obtaining development codes obtained by writing codes of the same product by multiple developers in different environments and different scenes.
In an alternative embodiment of the present application, the integration module further includes source code library information corresponding to the configuration development code, and compiles and tests the development code in the continuous integration server.
For specific limitations on the cloud native continuous integration and delivery apparatus, reference may be made to the above limitation on the cloud native continuous integration and delivery method, and no further description is given here. The above-described cloud primary continuous integration and delivery apparatus may be implemented in whole or in part by software, hardware, and combinations thereof. The above modules may be embedded in hardware or may be independent of a processor in the computer device, or may be stored in software in a memory in the computer device, so that the processor may call and execute operations corresponding to the above modules.
In one embodiment, an electronic device is provided, which may be a computer. The electronic device includes a processor, a memory, and a network interface connected by a system bus. Wherein the processor of the device is configured to provide computing and control capabilities. The memory of the device includes a non-volatile storage medium, an internal memory. The non-volatile storage medium stores an operating system, computer programs, and a database. The internal memory provides an environment for the operation of the operating system and computer programs in the non-volatile storage media. The database of the computer device is used for cloud native continuous integration and delivery data. 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 cloud native continuous integration and delivery method.
In one embodiment of the present application, a computer readable storage medium is provided, on which a computer program is stored, which when executed by a processor implements the steps of the cloud native continuous integration and delivery method described above.
The computer readable storage medium provided in this embodiment has similar principles and technical effects to those of the above method embodiment, and will not be described herein.
In the art, all or part of the flow of implementing the methods of the embodiments described above may be accomplished by computer programs to instruct related hardware. The computer program may be stored in a non-volatile computer readable storage medium, which computer program, when executed, may comprise the flow of the embodiments of the methods as described above. Any reference to memory, storage, database, or other medium used in embodiments provided herein may include non-volatile and/or volatile memory. The nonvolatile memory can include Read Only Memory (ROM), programmable ROM (PROM), electrically Programmable ROM (EPROM), electrically Erasable Programmable ROM (EEPROM), or flash memory. Volatile memory can include Random Access Memory (RAM) or external cache memory. By way of illustration and not limitation, RAM exists in a variety of forms such as Static RAM (SRAM), dynamic RAM (DRAM), synchronous DRAM (SDRAM), double Data Rate SDRAM (DDRSDRAM), enhanced SDRAM (ESDRAM), synchronous Link DRAM (SLDRAM), memory bus direct RAM (RDRAM), direct memory bus dynamic RAM (DRDRAM), and memory bus dynamic RAM (RDRAM), among others. These techniques and apparatuses may be used to implement the various embodiment methods described herein to improve the efficiency and stability of execution of a computer program.
The technical features of the above-described embodiments may be arbitrarily combined, and all possible combinations of the technical features in the above-described embodiments are not described for brevity of description, however, as long as there is no contradiction between the combinations of the technical features, they should be considered as the scope of the description.
The above examples illustrate only a few embodiments of the application, which are described in detail and are not to be construed as limiting the scope of the claims. It should be noted that it will be apparent to those skilled in the art that several variations and modifications can be made without departing from the spirit of the application, which are all within the scope of the application. Accordingly, the scope of protection of the present application is to be determined by the appended claims.
Claims (10)
1. A method of cloud native continuous integration and delivery, the method comprising:
acquiring development codes submitted by a plurality of developers and integrating the development codes into a code warehouse;
constructing the combination of the development codes in the code warehouse, and checking the development codes after constructing the combination through unit testing;
after the test is passed, the test result is fed back to the developer, the mirror image of the combined and constructed development code is sent to a delivery pipeline environment, and the delivery pipeline environment is fed back to a plurality of developers;
acquiring delivery results of modification, integration and construction operation processing of a plurality of developers in the delivery pipeline environment; wherein the developer can perform modification, integration and construction operations in the delivery pipeline environment; when the test passes, the software is automatically deployed into the production environment.
2. The method of claim 1, wherein the retrieving development code submitted by a plurality of developers and integrating the development code into a code repository comprises:
the developer submits the codes to a code warehouse, and the continuous integrated system can acquire the codes from the code warehouse regularly;
combining codes submitted by different developers to ensure that the codes can normally run and solve code conflicts;
and checking the combined codes, wherein the checking items at least comprise code styles and code qualities.
3. The method of claim 1, wherein the building the development code in the code repository in combination and checking the built development code by unit testing comprises:
compiling the code into executable code; performing unit test on the compiled code, and testing the basic function of the code; carrying out static analysis on the codes to find potential problems; and (5) analyzing the test coverage rate of the code to ensure that the code is fully tested.
4. A method according to claim 3, wherein the compiled code is subjected to unit testing to test basic functions of the code, comprising:
writing a test case, wherein the test case covers all basic functions of codes and tests boundary conditions;
running the compiled test cases on codes, and recording test results;
repairing errors in the code by searching for reasons of test failure; after the error is repaired, the test case is operated again, so that the basic function of the code is ensured to be tested correctly;
and (5) analyzing the test coverage rate of the code to ensure that the code is fully tested.
5. The method of claim 1, wherein the feeding back test results to a developer and sending a mirror image of the combined and built development code to a delivery pipeline environment and feeding back the delivery pipeline environment to a plurality of developers comprises:
deploying the constructed code image into a test environment; carrying out integrated test on codes deployed in a test environment, and testing whether interaction between different modules is normal or not; performing performance test on codes deployed in a test environment, and testing the performance of the codes under high load conditions; and carrying out security test on the code deployed in the test environment to test whether the code has security holes or not.
6. The method of claim 1, wherein obtaining the delivery results of the change, integration, and build operation processes performed by the plurality of developers in the delivery pipeline environment comprises:
automatically deploying the code passing the test into a production environment; monitoring and log analysis are carried out on codes in a production environment, and problems are found and solved in time; questions in the production environment are fed back to the developer, helping them improve code and flow.
7. The method according to claim 1, wherein the method further comprises:
obtaining improved feedback proposed by a developer in a delivery pipeline environment;
according to the improved feedback of the developer, the continuous integrated system modifies the code, repairs the problem or improves the code;
after modifying the code, the code needs to be reconstructed and tested, so that the correctness and stability of the code are ensured;
after construction and test pass, code is redeployed into a delivery pipeline environment, and integrated test, performance test and safety test are carried out, so that the running stability and performance of the code in different environments are ensured;
and feeding back the test result to the developer, wherein the specific feedback codes run in different environments.
8. A cloud primary continuous integration and delivery apparatus, the apparatus comprising:
the acquisition module is used for acquiring development codes submitted by a plurality of developers and integrating the development codes into a code warehouse;
the integrated module is used for carrying out combined construction on the development codes in the code warehouse and checking the combined and constructed development codes through unit testing;
the delivery module is used for feeding back the test result to the developer after the test is passed, sending the mirror image of the combined and constructed development code to a delivery pipeline environment, and feeding back the delivery pipeline environment to a plurality of developers; acquiring delivery results of modification, integration and construction operation processing of a plurality of developers in the delivery pipeline environment; wherein the developer can perform modification, integration and construction operations in the delivery pipeline environment; when the test passes, the software is automatically deployed into the production environment.
9. An electronic device comprising a memory and a processor, the memory storing a computer program that when executed by the processor implements the cloud native continuous integration and delivery method of any of claims 1-7.
10. A computer readable storage medium, having stored thereon a computer program which, when executed by a processor, implements the cloud native continuous integration and delivery method of any of claims 1 to 7.
Priority Applications (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN202310557313.6A CN116594635A (en) | 2023-05-17 | 2023-05-17 | Cloud primary continuous integration and delivery method and device |
Applications Claiming Priority (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN202310557313.6A CN116594635A (en) | 2023-05-17 | 2023-05-17 | Cloud primary continuous integration and delivery method and device |
Publications (1)
| Publication Number | Publication Date |
|---|---|
| CN116594635A true CN116594635A (en) | 2023-08-15 |
Family
ID=87589250
Family Applications (1)
| Application Number | Title | Priority Date | Filing Date |
|---|---|---|---|
| CN202310557313.6A Pending CN116594635A (en) | 2023-05-17 | 2023-05-17 | Cloud primary continuous integration and delivery method and device |
Country Status (1)
| Country | Link |
|---|---|
| CN (1) | CN116594635A (en) |
Cited By (1)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN116915516A (en) * | 2023-09-14 | 2023-10-20 | 深圳市智慧城市科技发展集团有限公司 | Software cross-cloud delivery method, transfer server, target cloud and storage medium |
-
2023
- 2023-05-17 CN CN202310557313.6A patent/CN116594635A/en active Pending
Cited By (2)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN116915516A (en) * | 2023-09-14 | 2023-10-20 | 深圳市智慧城市科技发展集团有限公司 | Software cross-cloud delivery method, transfer server, target cloud and storage medium |
| CN116915516B (en) * | 2023-09-14 | 2023-12-05 | 深圳市智慧城市科技发展集团有限公司 | Software cross-cloud delivery method, transfer server, target cloud and storage medium |
Similar Documents
| Publication | Publication Date | Title |
|---|---|---|
| US11281570B2 (en) | Software testing method, system, apparatus, device medium, and computer program product | |
| CN110532189B (en) | Continuous integration system, method and device | |
| US11366747B2 (en) | Unified test automation system | |
| US20170372247A1 (en) | Methods, systems, and articles of manufacture for implementing software application development and releases | |
| CN112286779B (en) | Test task processing method and device, storage medium and computer equipment | |
| Swanson et al. | Beyond the rainbow: Self-adaptive failure avoidance in configurable systems | |
| US20180052725A1 (en) | A method for identifying a cause for a failure of a test | |
| US8978015B2 (en) | Self validating applications | |
| US20170083430A1 (en) | Code coverage plugin | |
| CN109902005B (en) | Automatic testing method and system | |
| US10579513B2 (en) | Test run control method and apparatus | |
| CN109840194B (en) | Method and system for detecting configuration file | |
| JP5213671B2 (en) | Test case selection method and selection system | |
| CN109977008B (en) | Method and terminal for making JS code depended on by application program compatible with native library | |
| CN112241360A (en) | Test case generation method, device, equipment and storage medium | |
| CN113791979B (en) | Dynamic debugging method and device for software product, computer equipment and storage medium | |
| CN113742215B (en) | Method and system for automatically configuring and calling test tool to perform test analysis | |
| CN116594635A (en) | Cloud primary continuous integration and delivery method and device | |
| CN114880220A (en) | Development system and method for vehicle automatic driving software | |
| US11163924B2 (en) | Identification of changes in functional behavior and runtime behavior of a system during maintenance cycles | |
| CN106909434B (en) | Method and device for detecting undefined function in executable program | |
| CN113535182B (en) | Project engineering construction method and device, computer equipment and storage medium | |
| US11740895B2 (en) | Generation of software program repair explanations | |
| CN114564385A (en) | Software testing method and device, computer equipment and storage medium | |
| CN113688028A (en) | Code submission method and 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 |