A microservice construction method and system

Abstract

This application provides a microservice construction method and system that generates a microservice document to be constructed, which includes a target microservice that needs to be rebuilt. Based on the microservice document to be constructed, it is determined whether each microservice in the pipeline belongs to the target microservice. For microservices that belong to the target microservice, the microservice construction operation is executed; for microservices that do not belong to the target microservice, the microservice construction operation is not executed. This application realizes the selective construction of microservices without modifying the underlying pipeline code, saving construction resources and shortening the microservice construction time.

Description

Technical Field

[0001] This application mainly relates to the field of software development, and in particular to a microservice construction method and system. Background Art

[0002] DevOps is a combination of development and operations. It is a general term for a set of processes, methods and systems that can improve the collaboration between development teams and operations teams and provide continuous development, continuous testing, continuous integration and continuous deployment capabilities throughout the development life cycle of the project.

[0003] Microservices is a software architectural style. Unlike monolithic applications, which have tightly coupled modules, applications using a microservices architecture are composed of multiple loosely coupled microservices. Each microservice is relatively independent and communicates with other microservices through simple interfaces. Microservices can be used to accelerate application development, and microservices architectures built using Java are very common. Currently, large commercial systems are mostly developed using microservices. Java projects using microservices architectures require specialized DevOps pipelines.

[0004] Currently, mainstream DevOps tools such as TFS (Team Foundation Server) and Jenkins can implement pipeline builds for monolithic Java projects, automatically performing automated testing, builds, and deployments with each code submission. These tools don't offer a specific solution for Java projects with microservices architectures. Typically, multiple pipelines can be built, or multiple agents can be created within a single pipeline to achieve a one-click build for all microservices.

[0005] However, the above construction methods have the problem of poor flexibility when applied to Java projects with microservice architecture. Once the pipeline is built, it cannot be changed at will. To modify the microservices to be built, the underlying code of the pipeline needs to be modified one by one. Otherwise, each build can only build all the microservices configured in the pipeline. Even if some microservice codes may not change between two adjacent builds, these microservices will still be built repeatedly, resulting in a waste of construction resources. Multiple builds may also cause pipeline congestion and even affect development efficiency. Summary of the Invention

[0006] In view of this, the present application provides a microservice construction method and system, which realizes the selective construction of microservices and saves construction resources by transforming the pipeline built by the DevOps tool set.

[0007] In one aspect, an embodiment of the present application provides a microservice construction method, the method comprising:

[0008] Generate a microservice document to be built, wherein the microservice document includes a target microservice that needs to be rebuilt;

[0009] Determine whether each microservice on the pipeline belongs to the target microservice according to the microservice document to be built;

[0010] For the microservice belonging to the target microservice, executing a construction job of the microservice;

[0011] For the microservice that does not belong to the target microservice, the construction job of the microservice is not executed.

[0012] Optionally, the method further includes:

[0013] According to a pre-written configuration file, the working mode of the pipeline is determined. The working mode is used to determine the generation method of the microservice document. The working mode includes an active mode and an automatic mode.

[0014] Optionally, generating the microservice document to be built includes:

[0015] In the active mode, reading a microservice list in the configuration file, the microservice list including the microservices to be built;

[0016] Generate the microservice document to be built according to the microservice list.

[0017] Optionally, generating the microservice document to be built includes:

[0018] In the automatic mode, a reference microservice is read, where the reference microservice is a microservice whose code is adjusted before generating the microservice document and after completing the last microservice build operation;

[0019] Generate the microservice document to be built based on the reference microservice.

[0020] Optionally, in the automatic mode, reading the reference microservice includes:

[0021] In the automatic mode, a historical log is read, where the historical log records code adjustments of the microservice before generating the microservice document and after completing the last microservice build operation;

[0022] The reference microservice is determined according to the historical log.

[0023] On the other hand, an embodiment of the present application further provides a microservice construction system, the system comprising a construction master control layer, a construction control layer, and a construction execution layer;

[0024] The construction control layer is used to generate a microservice document to be built, wherein the microservice document includes a target microservice that needs to be rebuilt;

[0025] The build control layer is used to determine whether each microservice on the pipeline belongs to the target microservice based on the microservice document to be built; for the microservice that belongs to the target microservice, control the build execution layer to execute the build job of the microservice; for the microservice that does not belong to the target microservice, control the build execution layer not to execute the build job of the microservice.

[0026] Optionally, the master control layer is further configured to:

[0027] According to a pre-written configuration file, the working mode of the pipeline is determined. The working mode is used to determine the generation method of the microservice document. The working mode includes an active mode and an automatic mode.

[0028] Optionally, the construction of the master control layer includes a microservice document generation program, and the microservice document generation program is used to:

[0029] In the active mode, reading a microservice list in the configuration file, the microservice list including the microservices to be built;

[0030] Generate the microservice document to be built according to the microservice list.

[0031] Optionally, the construction of the master control layer includes a microservice document generation program, and the microservice document generation program is used to:

[0032] In the automatic mode, a reference microservice is read, where the reference microservice is a microservice whose code is adjusted before generating the microservice document and after completing the last microservice build operation;

[0033] Generate the microservice document to be built based on the reference microservice.

[0034] Optionally, the microservice document generation program includes a microservice reading module, and the microservice reading module is used to:

[0035] In the automatic mode, a historical log is read, where the historical log records code adjustments of the microservice before generating the microservice document and after completing the last microservice build operation;

[0036] The reference microservice is determined according to the historical log.

[0037] It can be seen that the embodiments of the present application have the following beneficial effects:

[0038] The present application builds microservices based on pipelines by generating a microservice document to be built, wherein the microservice document includes a target microservice that needs to be rebuilt; based on the microservice document to be built, it is determined whether each microservice on the pipeline belongs to the target microservice, and for the microservices that belong to the target microservice, the corresponding build operation is executed, and for the microservices that do not belong to the target microservice, the corresponding build operation is not executed. The present application determines the microservices that need to be rebuilt from the microservice document to be built, thereby only executing the build operation for the microservices that need to be rebuilt, and not executing the build operation for the microservices that do not need to be rebuilt, thereby achieving selective construction of microservices, and without modifying the underlying pipeline code, saving construction resources and shortening the construction time of microservices. BRIEF DESCRIPTION OF THE DRAWINGS

[0039] In order to more clearly illustrate the embodiments of the present application or the technical solutions in the prior art, the following briefly introduces the drawings required for use in the embodiments or the description of the prior art. Obviously, the drawings described below are some embodiments of the present application. For ordinary technicians in this field, other drawings can be obtained based on these drawings without paying any creative work.

[0040] Figure 1 A flowchart of a microservice construction method provided in an embodiment of the present application;

[0041] Figure 2 A flowchart of microservice construction in active mode provided in an embodiment of the present application;

[0042] Figure 3 A flowchart of microservice construction in automatic mode provided in an embodiment of the present application;

[0043] Figure 4 An architectural diagram of a microservice construction system provided in an embodiment of the present application;

[0044] Figure 5 A specific architecture diagram of a microservice construction system provided in an embodiment of the present application. DETAILED DESCRIPTION

[0045] In order to make the above-mentioned purposes, features and advantages of the present application more obvious and easy to understand, the specific implementation methods of the present application are described in detail below with reference to the accompanying drawings.

[0046] In the following description, many specific details are set forth to facilitate a full understanding of the present application. However, the present application may also be implemented in other ways different from those described herein. Those skilled in the art may make similar generalizations without violating the connotation of the present application. Therefore, the present application is not limited to the specific embodiments disclosed below.

[0047] Currently, mainstream DevOps pipelines are primarily suitable for monolithic projects. When applied to Java projects with microservice architectures, two solutions are typically adopted: a multi-pipeline approach, which deploys multiple pipelines, each corresponding to a microservice; and a multi-agent approach, which establishes multiple agent jobs within a single pipeline, each corresponding to a microservice. Both of these approaches suffer from limited flexibility; once a pipeline is established, it cannot be modified at will. Specifically, with a multi-pipeline approach, all pipelines are automatically called for a build upon each code commit. If microservices need to be built selectively, the underlying code for each pipeline must be modified individually. With a multi-agent approach, all microservices in the pipeline are built upon each code commit. Similarly, if a microservice needs to be built, the pipeline itself must be modified.

[0048] The above solution requires frequent modifications to the pipeline when the microservices to be built change. On the one hand, this consumes manpower and time and lacks flexibility. On the other hand, manual modifications to the pipeline by developers are prone to omissions, which affects the normal execution of the pipeline.

[0049] In the above solution, if the pipeline is not modified, all microservices in the pipeline will be built for each build. Microservices whose codes have not changed between two adjacent builds will still be built repeatedly, which will cause a waste of build resources. At the same time, for large projects, a project often contains dozens of microservices, and a project team may have dozens of developers. The number of code submissions per day may reach dozens or even hundreds. If all microservices are built after each code submission, it will take a long time. If multiple submissions are made in a short period of time, it may cause pipeline congestion and even affect development efficiency.

[0050] To solve the above problems, this application provides a microservice construction method and system. By transforming the pipeline built by the DevOps toolset, the pipeline is made suitable for projects with a microservice architecture, which is conducive to improving the flexibility of building microservices, thereby realizing the selective construction of microservices and saving construction resources.

[0051] For ease of understanding, a microservice construction method and system provided in an embodiment of the present application are described in detail below with reference to the accompanying drawings.

[0052] S101: Generate the microservice document to be built.

[0053] The microservice document includes a target microservice that needs to be rebuilt.

[0054] In an embodiment of the present application, it is first necessary to generate a microservice document to be built, which includes a target microservice that needs to be rebuilt. The target microservice can be a pre-specified microservice that needs to be rebuilt, or it can be a microservice whose code has been modified compared to the last build task, and no limitation is made here. Through the microservice document to be built, the microservice that needs to be rebuilt can be determined, which is conducive to the subsequent selective construction of the microservice. Furthermore, in an embodiment of the present application, the microservice that needs to be built can be changed by simply making the microservice document to be built different, without the need to modify the pipeline, which has high flexibility.

[0055] In a possible implementation, the method further includes:

[0056] According to a pre-written configuration file, the working mode of the pipeline is determined. The working mode is used to determine the generation method of the microservice document. The working mode includes an active mode and an automatic mode.

[0057] The embodiment of the present application is applied to the construction of microservices on the pipeline, and can determine different ways of generating microservice documents according to the different working modes of the pipeline. Among them, the working mode of the pipeline is determined by a pre-written configuration file. Through the configuration file, the working mode of the pipeline during the microservice construction process can be pre-specified or determined according to certain rules; different microservice document generation strategies can be selected under different working modes, which is highly flexible; selecting different working modes only requires modifying the configuration file, making the pipeline easier to manage and more suitable for projects with microservice architecture.

[0058] In one possible implementation, generating the microservice document to be built includes:

[0059] In the active mode, reading a microservice list in the configuration file, the microservice list including the microservices to be built;

[0060] Generate the microservice document to be built according to the microservice list.

[0061] In an embodiment of the present application, the active mode is to determine the working mode of the microservice to be built based on the microservice list. In the active mode, the configuration file may also include a microservice list, and the microservice list includes the microservice to be built. Specifically, the microservice list in the configuration file may be pre-specified or allocated according to a certain rule. According to the microservice list in the configuration file, the microservice to be built is extracted from the microservice list, and then the microservice to be built is sorted according to a preset sorting method to generate the microservice document to be built. In the active mode, if the microservice to be built needs to be modified, it is only necessary to modify the configuration file, which has high flexibility and does not require modification to the pipeline itself, thereby avoiding the inconvenience caused by directly modifying the pipeline and reducing the possibility of errors and omissions.

[0062] In one possible implementation, generating the microservice document to be built includes:

[0063] In the automatic mode, a reference microservice is read, where the reference microservice is a microservice whose code is adjusted before generating the microservice document and after completing the last microservice build operation;

[0064] Generate the microservice document to be built based on the reference microservice.

[0065] In the embodiment of the present application, the automatic mode automatically determines the working mode of the microservice to be built based on the adjustment of the code recorded in the log. In the automatic mode, the microservice document to be built is generated based on the reference microservice. The reference microservice can be a microservice whose code has been adjusted after the last microservice build operation was completed before the microservice document was generated this time, that is, a microservice involved in the code modification. In the automatic mode, the reference microservice is automatically read, and the microservice is selectively built based on the reference microservice, so that the microservice to be built can be adaptively adjusted without modifying the pipeline, and the degree of automation is high. In the automatic mode, microservices whose codes have not been modified can be avoided from being repeatedly built, which is beneficial to saving construction resources and shortening the construction time for large projects.

[0066] In a possible implementation, in the automatic mode, reading the reference microservice includes:

[0067] In the automatic mode, a historical log is read, where the historical log records code adjustments of the microservice before generating the microservice document and after completing the last microservice build operation;

[0068] The reference microservice is determined according to the historical log.

[0069] In an embodiment of the present application, the reference microservice can be read by reading a historical log that records the code adjustments of the microservice before generating the microservice document and after completing the last microservice build operation. Specifically, during the construction of the pipeline, the DevOps toolset can pull code through a remote git repository, and the historical log can be the git log of the most recent build operation. The git log records the directory structure of the program where the code has changed. The directory structure of the program represents the path of the program. According to the directory structure of the program, the microservice where the program is located can be located, thereby automatically identifying the microservice involved in this construction, that is, the reference microservice, and thus adaptively determining the microservice that needs to be built.

[0070] S102: Determine whether each microservice on the pipeline belongs to the target microservice according to the microservice document to be built.

[0071] In an embodiment of the present application, after generating a microservice document, a determination is made as to whether each microservice on the pipeline belongs to the target microservice, i.e., the target microservice that needs to be rebuilt. Specifically, for a multi-agent DevOps pipeline, multiple agent jobs can be deployed on a pipeline, and one to multiple agent jobs can be deployed for each microservice, where agent jobs can include control jobs. Each microservice can be controlled by a control job, and each control job is parallel to the other. By reading the microservice document, each control job independently determines whether the microservice it controls belongs to the target microservice.

[0072] S103: Execute a construction job of the microservice for the microservice belonging to the target microservice.

[0073] In an embodiment of the present application, for a microservice that belongs to a target microservice, the microservice's build job is executed. Specifically, for a multi-agent DevOps pipeline, one to multiple agent jobs can be deployed for each microservice, where the agent job can include a control job and a build job. Specifically, a control job and a build job can be deployed for each microservice. The build jobs and control jobs of different microservices are parallel to each other, and the build job and control job of the same microservice correspond one-to-one and are set as a dependency relationship. Therefore, after the control job corresponding to the microservice determines that the microservice belongs to the target microservice, the build job corresponding to the microservice is executed, and the microservice is automatically built.

[0074] Build jobs can include automated testing, automated building, and automated deployment of microservices. Automated testing can include automated code checking, vulnerability scanning, unit testing, interface testing, and UI testing, with simultaneous reporting of code violations, code vulnerabilities, and test results. Automated building can include compilation, packaging, and configuration replacement, program package generation, and simultaneous reporting of compilation errors. Automated deployment can include deploying application images to the cloud, synchronizing deployment status, and reporting on operational issues.

[0075] S104: For the microservice that does not belong to the target microservice, the construction job of the microservice is not executed.

[0076] In the embodiment of the present application, for microservices that do not belong to the target microservice, the process in S103 will not be triggered, that is, the construction job of the microservice will not be executed, so that only the microservices that need to be built are built, saving construction resources and shortening construction time.

[0077] It should be noted that there is no time sequence relationship between S103 and S104. Specifically, for a pipeline with multiple proxy jobs deployed, generally speaking, the proxy jobs corresponding to each microservice are in parallel and competitive relationship with each other, and the order of priority depends only on the idleness of the proxy pool.

[0078] In one possible implementation, the microservice construction flow chart in active mode can be found in Figure 2 For ease of explanation, each microservice on the pipeline is numbered from microservice 1 to microservice N. In active mode, the microservice construction process can include the following steps:

[0079] After confirming that the working mode is active mode, read the configuration file;

[0080] Generate the microservice document to be built based on the configuration file;

[0081] According to the generated microservice documents, determine whether microservices 1 to N belong to the target microservices;

[0082] For microservices that belong to the target microservice, the build job corresponding to the microservice is executed. For microservices that do not belong to the target microservice, the build job corresponding to the microservice is not executed and the process ends directly.

[0083] In one possible implementation, the microservice construction flow chart in automatic mode can be found in Figure 3 For ease of explanation, each microservice on the pipeline is numbered from microservice 1 to microservice N. In automatic mode, the microservice construction process can include the following steps:

[0084] After determining that the working mode is automatic, read the reference microservice; the reference microservice is a microservice whose code has been adjusted before the microservice document is generated and after the last microservice build operation is completed. The reference microservice is read based on historical logs, which record the code adjustments of the microservice before the microservice document is generated and after the last microservice build operation is completed.

[0085] Generate the microservice documentation to be built based on the reference microservice;

[0086] According to the generated microservice documents, determine whether microservices 1 to N belong to the target microservices;

[0087] For microservices that belong to the target microservice, the build job corresponding to the microservice is executed. For microservices that do not belong to the target microservice, the build job corresponding to the microservice is not executed and the process ends directly.

[0088] The embodiment of the present application is based on the pipeline construction of microservices, by generating a microservice document to be constructed, wherein the microservice document contains microservices that need to be rebuilt; according to the microservice document to be constructed, it is determined whether each microservice on the pipeline belongs to the target microservice, and for the microservices that belong to the target microservice, the corresponding construction operation is executed, and for the microservices that do not belong to the target microservice, the corresponding construction operation is not executed. The present application determines the microservices that need to be rebuilt from the microservice document to be constructed, thereby only executing the construction operation for the microservices that need to be rebuilt, and not executing the construction operation for the microservices that do not need to be rebuilt, thereby realizing the selective construction of microservices, and there is no need to modify the underlying code of the pipeline, which is conducive to improving the flexibility of building microservices, saving construction resources, and shortening the construction time of microservices.

[0089] Based on the above microservice construction method, the present application embodiment also provides a microservice construction system, referring to Figure 4 As shown in FIG, this figure is an architecture diagram of a microservice construction system provided by an embodiment of the present application. The microservice construction system 200 may include: a construction control layer 201, a construction control layer 202, and a construction execution layer 203;

[0090] The construction control layer 201 is used to generate a microservice document to be built, wherein the microservice document includes a target microservice that needs to be rebuilt;

[0091] The build control layer 202 is used to determine whether each microservice on the pipeline belongs to the target microservice based on the microservice document to be built; for the microservice that belongs to the target microservice, control the build execution layer 203 to execute the build job of the microservice; for the microservice that does not belong to the target microservice, control the build execution layer 203 not to execute the build job of the microservice.

[0092] In a possible implementation, the construction of the master control layer 201 is further used to:

[0093] According to a pre-written configuration file, the working mode of the pipeline is determined. The working mode is used to determine the generation method of the microservice document. The working mode includes an active mode and an automatic mode.

[0094] In one possible implementation, the construction master control layer 201 includes a microservice document generation program 2011, which is used to:

[0095] In the active mode, reading a microservice list in the configuration file, the microservice list including the microservices to be built;

[0096] Generate the microservice document to be built according to the microservice list.

[0097] In one possible implementation, the construction master control layer 201 includes a microservice document generation program 2010, and the microservice document generation program 2010 is used to:

[0098] In the automatic mode, a reference microservice is read, where the reference microservice is a microservice whose code is adjusted before generating the microservice document and after completing the last microservice build operation;

[0099] Generate the microservice document to be built based on the reference microservice.

[0100] In one possible implementation, the microservice document generation program 2010 includes a microservice reading module 2011, and the microservice reading module 2011 is used to:

[0101] In the automatic mode, a historical log is read, where the historical log records code adjustments of the microservice before generating the microservice document and after completing the last microservice build operation;

[0102] The reference microservice is determined according to the historical log.

[0103] In one possible implementation, refer to Figure 5As shown, a specific architecture diagram of a microservice construction system provided by an embodiment of the present application, as shown in the figure, the construction control layer 201 includes a microservice document generation program 2010, and the microservice document generation program 2010 includes a microservice reading module; the construction control layer 202 may include control program 1, control program 2,...control program N, which are respectively used to control microservice 1, microservice 2...microservice N on the assembly line; the construction execution layer 203 may include execution programs 1 to N for executing the construction job corresponding to the microservice. When the microservice belongs to the target microservice, the corresponding execution program executes the construction job. When the microservice does not belong to the target microservice, the corresponding execution program does not execute the construction job.

[0104] It should be noted that the various embodiments in this specification are described in a progressive manner, with each embodiment focusing on the differences from other embodiments. Reference can be made to the common and similar parts between the various embodiments. For the systems or devices disclosed in the embodiments, since they correspond to the methods disclosed in the embodiments, the description is relatively simple, and the relevant parts can be referred to the method description.

[0105] It should be understood that in this application, "at least one (item)" means one or more, and "plurality" means two or more. "And / or" is used to describe the association relationship of associated objects, indicating that three relationships may exist. For example, "A and / or B" can mean: only A exists, only B exists, and A and B exist at the same time, where A and B can be singular or plural. The character " / " generally indicates that the previous and next associated objects are in an "or" relationship. "At least one of the following items" or similar expressions refers to any combination of these items, including any combination of single items or plural items. For example, at least one of a, b or c can mean: a, b, c, "a and b", "a and c", "b and c", or "a and b and c", where a, b, c can be single or multiple.

[0106] It should also be noted that, in this document, relational terms such as first and second, etc., are used only to distinguish one entity or operation from another entity or operation, and do not necessarily require or imply any such actual relationship or order between these entities or operations. Moreover, the terms "comprises," "comprising," or any other variations thereof are intended to cover non-exclusive inclusion, such that a process, method, article, or device comprising a series of elements includes not only those elements, but also other elements not explicitly listed, or elements inherent to such process, method, article, or device. In the absence of further limitations, an element defined by the phrase "comprising a ..." does not exclude the presence of additional identical elements in the process, method, article, or device comprising the element.

[0107] The steps of the methods or algorithms described in conjunction with the embodiments disclosed herein may be implemented directly using hardware, a software module executed by a processor, or a combination of the two. The software module may be placed in a random access memory (RAM), internal memory, read-only memory (ROM), electrically programmable ROM, electrically erasable programmable ROM, registers, a hard disk, a removable disk, a CD-ROM, or any other form of storage medium known in the art.

[0108] The above description of the disclosed embodiments is intended to enable one skilled in the art to implement or use the present application. Various modifications to these embodiments will be readily apparent to one skilled in the art, and the general principles defined herein may be implemented in other embodiments without departing from the spirit or scope of the present application. Therefore, the present application is not limited to the embodiments shown herein, but is intended to conform to the widest scope consistent with the principles and novel features disclosed herein.

Claims

1. A microservice construction method, characterized in that: The method comprises: Determine the pipeline's operating mode based on a pre-written configuration file. The operating mode is used to determine how microservice documents are generated. The operating mode includes an active mode and an automatic mode. In the active mode, reading a microservice list in the configuration file, the microservice list including the microservices to be built; In the automatic mode, a reference microservice is read, where the reference microservice is a microservice whose code is adjusted before generating the microservice document and after completing the last microservice build operation; Generate a microservice document to be built according to the microservice list, wherein the microservice document includes a target microservice that needs to be rebuilt; Determine, based on the microservice document to be built, whether each microservice on the pipeline belongs to the target microservice; For the microservice belonging to the target microservice, executing a construction job of the microservice; For the microservice that does not belong to the target microservice, the construction job of the microservice is not executed.

2. The method according to claim 1, characterized in that In the automatic mode, reading the reference microservice includes: In the automatic mode, a historical log is read, where the historical log records code adjustments of the microservice before generating the microservice document and after completing the last microservice build operation; The reference microservice is determined according to the historical log.

3. A microservice construction system, characterized in that: The system includes a construction master control layer, a construction control layer and a construction execution layer; The construction control layer is used to determine the working mode of the pipeline according to the pre-written configuration file. The working mode is used to determine the generation method of the microservice document. The working mode includes active mode and automatic mode; The construction control layer includes a microservice document generation program, which is used to: In the active mode, reading a microservice list in the configuration file, the microservice list including the microservices to be built; In the automatic mode, a reference microservice is read, where the reference microservice is a microservice whose code is adjusted before generating the microservice document and after completing the last microservice build operation; Generate a microservice document to be built based on the reference microservice, wherein the microservice document includes a target microservice that needs to be rebuilt; The construction control layer is used to determine whether each microservice on the pipeline belongs to the target microservice according to the microservice document to be built; For the microservice belonging to the target microservice, controlling the build execution layer to execute a build job of the microservice; For the microservice that does not belong to the target microservice, the build execution layer is controlled not to execute the build job of the microservice.

4. The system according to claim 3, characterized in that The microservice document generation program includes a microservice reading module, which is used to: In the automatic mode, a historical log is read, where the historical log records code adjustments of the microservice before generating the microservice document and after completing the last microservice build operation; The reference microservice is determined according to the historical log.

Images