Method, apparatus, and computer program product for heterogeneous graph generation for application of microservices

Abstract

The present disclosure relates to heterogeneous graph generation for application microservices. One embodiment provides a method comprising: receiving information describing an application to be split into a plurality of microservices; utilizing a microservice advisor application to identify application elements of the application; utilizing the microservice advisor application to generate a heterogeneous graph from the application elements, wherein each node within the heterogeneous graph represents an application element and wherein each edge within the heterogeneous graph represents a relationship between two nodes connected by the edge; identifying groups of nodes within the heterogeneous graph that share common attributes based on user input identifying preferences for relationships between nodes; and providing a recommendation from the microservice advisor application for splitting the application into microservices based on the identified groups of nodes, wherein the recommendation includes a plurality of microservices for the application and application elements that should be included within each of the microservices.

Description

Background Technology

[0001] With the increasing prevalence of remote computing or service environments (e.g., remote network environments, cloud computing environments, etc.), more users and entities are moving the hosting of applications and other services to remote service environments. By moving the hosting of applications and other services to remote service environments, users and other entities are able to reduce their reliance on internal resources (e.g., infrastructure, computing resources, human resources, etc.) and reduce other costs associated with applications and other services. Furthermore, because remote service environments typically have significantly more resources than users or entities have locally, particularly computing resources, users or entities can more easily scale applications hosted on remote service environments. Summary of the Invention

[0002] In summary, one aspect of the present invention provides a method comprising: receiving information describing an application to be split into multiple microservices; identifying application elements of the application using a microservices advisor application; generating a heterogeneous graph from the application elements using the microservices advisor application, wherein each node in the heterogeneous graph represents an application element, and wherein each edge in the heterogeneous graph represents a relationship between two nodes connected by the edge; identifying groups of nodes sharing common attributes in the heterogeneous graph based on the edges in the heterogeneous graph using the microservices advisor application and using graph clustering techniques, the common attributes being the importance of relationships between nodes as identified by a user; and providing recommendations from the microservices advisor application for splitting the application into microservices based on the identified groups of nodes, wherein the recommendations include multiple microservices of the application and application elements that should be included in each of the microservices.

[0003] Another aspect of the present invention provides an apparatus comprising: at least one processor; and a computer-readable storage medium having computer-readable program code implemented therewith, the computer-readable program code being executable by the at least one processor; wherein the computer-readable program code is configured to receive information describing an application to be split into multiple microservices; wherein the computer-readable program code is configured to use a microservices advisor application to identify application elements of the application; wherein the computer-readable program code is configured to utilize the microservices advisor application to generate a heterogeneous graph from the application elements, wherein each node in the heterogeneous graph represents an application element, and wherein each edge in the heterogeneous graph represents a relationship between two nodes connected by the edge; wherein the computer-readable program code is configured to utilize the microservices advisor application and a graph clustering technique to identify groups of nodes sharing common attributes within the heterogeneous graph based on the edges within the heterogeneous graph, the common attributes being the importance of relationships between nodes as identified by a user; and wherein the computer-readable program code is configured to provide recommendations from the microservices advisor application based on the identified groups of nodes to split the application into microservices, wherein the recommendations include multiple microservices of the application and application elements that should be included in each of the microservices.

[0004] Another aspect of the present invention provides a computer program product comprising: a computer-readable storage medium having computer-readable program code implemented therewith, the computer-readable program code being executable by a processor; wherein the computer-readable program code is configured to receive information describing an application to be split into multiple microservices; wherein the computer-readable program code is configured to use a microservices advisor application to identify application elements of the application; wherein the computer-readable program code is configured to utilize the microservices advisor application to generate a heterogeneous graph from the application elements, wherein each node in the heterogeneous graph represents an application element, and wherein each edge in the heterogeneous graph represents a relationship between two nodes connected by the edge; wherein the computer-readable program code is configured to utilize the microservices advisor application and a graph clustering technique to identify groups of nodes sharing common attributes within the heterogeneous graph based on the edges within the heterogeneous graph, the common attributes being the importance of relationships between nodes as identified by a user; and wherein the computer-readable program code is configured to provide recommendations from the microservices advisor application based on the identified groups of nodes to split the application into microservices, wherein the recommendations include multiple microservices of the application and application elements that should be included in each of the microservices.

[0005] To better understand exemplary embodiments of the invention and its other and further features and advantages, reference is made to the following description taken in conjunction with the accompanying drawings, and the scope of the claimed embodiments is set forth in the appended claims. Attached Figure Description

[0006] Figure 1 A method for recommending the splitting of an application into microservices using a microservices advisor application is illustrated. This microservices advisor application generates a heterogeneity graph of application elements and then uses the heterogeneity graph to identify groups or communities of application elements.

[0007] Figure 2A An example of a direct association between application elements is shown.

[0008] Figure 2B An example of indirect association between application elements is shown.

[0009] Figure 3 An example overall system architecture is shown that utilizes a microservices advisor application to provide recommendations for breaking down an application into microservices. This microservices advisor application generates a heterogeneity graph of application elements and then uses the heterogeneity graph to identify groups or communities of application elements.

[0010] Figure 4 The computer system is shown. Detailed Implementation

[0011] It will be readily understood that, in addition to the exemplary embodiments described herein, components of embodiments of the invention can be arranged and designed in various different configurations as generally described and illustrated in the accompanying drawings. Therefore, the following more detailed description of embodiments of the invention as illustrated in the drawings is not intended to limit the scope of the claimed embodiments of the invention, but merely to illustrate exemplary embodiments of the invention.

[0012] Throughout this specification, references to "an embodiment" or "an embodiment" (or similar) mean that a particular feature, structure, or characteristic described in connection with that embodiment is included in at least one embodiment of the invention. Therefore, phrases such as "in one embodiment" or "in an embodiment" appearing in various places throughout this specification do not necessarily refer to the same embodiment.

[0013] Furthermore, the described features, structures, or characteristics may be combined in any suitable manner in at least one embodiment. Numerous specific details are provided in the following description to give a thorough understanding of embodiments of the invention. However, those skilled in the art will readily recognize that embodiments of the invention may be practiced without at least one of its specific details, or may be practiced using other methods, components, materials, etc. In other instances, well-known structures, materials, or operations have not been shown or described in detail to avoid obscuring various aspects of the invention.

[0014] The illustrated embodiments of the invention will be best understood by referring to the accompanying drawings. The following description is intended only to illustrate, by way of example and simply, certain selected exemplary embodiments of the invention as claimed herein. It should be noted that the flowcharts and block diagrams in the drawings illustrate the architecture, functionality, and operation of possible implementations of systems, apparatuses, methods, and computer program products according to different embodiments of the invention. In this regard, each block in the flowchart or block diagram may represent a module, segment, or portion of code, which includes at least one executable instruction for implementing a specified logical function.

[0015] It should also be noted that in some alternative embodiments, the functions indicated in the boxes may not occur in the order shown in the figures. For example, depending on the functions involved, two consecutively shown blocks may actually be executed substantially simultaneously, or these blocks may sometimes be executed in reverse order. It should also be noted that each block in the block diagram and / or flowchart, and combinations of blocks in the block diagram and / or flowchart, may be implemented using a dedicated hardware-based system that performs the specified functions or actions, or using a combination of dedicated hardware and computer instructions.

[0016] The following will be referred to in detail Figures 1 to 4 It should be understood that the processes, arrangements, and products illustrated herein can be performed on or based on any suitable computer system or group of computer systems, which may be included by way of illustrative and non-limiting example, such as in Figure 4 The system or server indicated by 12' in the context. According to an exemplary embodiment, regardless of whether it is a server computer, client computer, node computer, or any combination thereof in a distributed network, relative to... Figures 1-3 Most (if not all) of the processing steps, components, and outputs discussed can be processed by the processing unit and system memory (such as...). Figure 4 Those indicated by 16' and 28' respectively are used or performed.

[0017] One problem with moving an application to a remote service environment for hosting is that, while not impossible, moving the entire application to a remote service environment is difficult. Specifically, it's easier to move smaller parts of the application, known as microservices, to a remote service environment, allowing different parts to be hosted on different parts of the remote service environment. This can be beneficial for the optimal use of the remote service environment's resources. Furthermore, the remote service environment is better configured to run smaller parts of the application. Therefore, a single application needs to be broken down or split into smaller modules, parts, or microservices in order to be moved to and efficiently hosted by the remote service environment.

[0018] Another benefit of breaking an application down into multiple microservices (even if it's not hosted or moved to a remote service environment) is that a large, single application is more difficult to manage and scale than multiple smaller microservices. Furthermore, problems arise when using the typical functionality of a single application. For example, if only a portion of the application needs updating, when the application is a single large application, the entire application must be updated, whereas if the application has been broken down into microservices, only one or a few microservices need to be updated.

[0019] The difficulty in breaking down an application into microservices lies in the fact that there are many different technologies for doing so. For example, one user might choose to split the application based on the most used service, while another user might choose to split the same application based on the resource usage of the service. Another technology for splitting applications is based on the functionality of the different parts of the application. The different technologies used to split applications lead to vastly different or overlapping splits between the technologies. Therefore, the choice of how to split the application is highly dependent on the user, and the chosen technology may not ultimately be the best technology for moving the application to a remote service application.

[0020] Therefore, embodiments provide a system and method for providing recommendations on splitting an application into microservices using a microservices advisor application that generates a heterogeneity graph of application elements and subsequently uses the graph to identify groups or communities of application elements. The described system and method are capable of identifying blocks or microservices from a larger application, referred to as a monolithic application, how many microservices should be created, and what functionalities or application elements should be included in each microservice split. Furthermore, the described system and method provide rationale for specific microservice split recommendations.

[0021] This system utilizes a microservices advisor application, which recommends application splitting based on information describing the application to be decomposed into microservices. The microservices advisor application identifies the application elements of the target application. Application elements can include files, objects, tables, holding objects, classes, applications, and any other elements or artifacts that make up the application or are used within the application. The microservices advisor application generates a heterogeneous graph from the application elements, where nodes represent application elements and edges represent relationships between nodes connected by those edges. Graph generation includes identifying direct and indirect relationships between application elements. This graph is heterogeneous because it can identify application elements and relationships from more than just programs; for example, in addition to programs, the system can also identify elements and relationships from objects, tables, and transactions.

[0022] Using the edges identified in the graph, the microservices advisor application can identify groups of nodes that share common attributes. These common attributes can be shared preferences, common domains, common technologies, etc. The advisor application can use graph clustering techniques when identifying groups. Additionally, the system can consider any user constraints or preferences regarding the application elements that should be grouped when identifying groups. For example, a user might identify specific application elements that should be grouped together. Thus, the advisor application will ensure that these elements are grouped together during clustering. Once the node groups (called communities) are identified, the system provides the user with recommendations for splitting the application into microservices. These recommendations not only identify microservices but also the number of microservices and the application elements that should be included in each microservice.

[0023] Such a system offers a technological improvement over current systems that decompose applications into microservices. The described system and method automatically identify how an application should be decomposed into microservices and make recommendations to the user, rather than relying on the user to determine how the application should be decomposed. This automatic identification and recommendation generation is not found in current technologies. When determining the decomposition, the system generates and utilizes a heterogeneity graph that identifies direct and indirect relationships between application elements, affinity between application elements, heterogeneous features outside the application, and dependencies between applications, and also considers any user-provided information regarding importance or other information related to the relationships between application elements. These techniques are not used in current application decomposition techniques. Therefore, the described system provides a more efficient and consistent technique for application decomposition than the techniques found in conventional systems and methods that rely on users manually determining how to decompose applications.

[0024] Figure 1This illustrates a method for providing recommendations on splitting an application into microservices using a microservices advisor application. This advisor generates a heterogeneity graph of application elements and then uses the graph to identify groups or communities of application elements. At 101, the system receives information describing the application to be split into multiple microservices. The application can be a monolithic application, meaning it is a single-tier software application where the user interface and data access code are combined into a single program from a single platform. In other words, the application can run independently and does not need to access other services or microservices to perform its intended functionality. This application is one that the user wants to split into different microservices. For example, the user might want to host the application on a remote service environment, thus requiring the application to be split into smaller chunks or microservices. As another example, the user might simply want to split the application to make it easier to scale, manage, etc. In other words, the user wants to transform the application from a monolithic application into a microservices application.

[0025] In section 102, the microservices advisor application identifies application elements. A microservices advisor application is specifically programmed to acquire application information and generate application breakdown recommendations. A microservices advisor application may include a graphical user interface that allows users to provide input to the application. Microservices applications may include interfaces or special programming that allows the application to interface with other programs, databases, data storage locations, applications, etc., to capture information, perform analysis, generate heterogeneous graphs, and provide output to the user.

[0026] Application elements can include classes, objects, resources, files, holding objects, tables, programs, transactions, and any other elements that are part of the application, accessed by the application, or otherwise connected to the application. To identify application elements, the advisor application can receive application-related information that identifies the application and shows how it works—for example, how different parts of the application interact with other parts, how the application runs, and so on. This information can be, for example, input artifacts that may include the application's source files, the code corresponding to the application, binary source files, etc. Based on the received information, the system can parse the received information and perform analysis to infer additional information about the application. Analysis can also be performed without first parsing the received information. One or more analyses can be performed and may include runtime analysis, data analysis, static code analysis, dependency analysis, log analysis, program analysis, etc.

[0027] Any analysis performed helps the system attempt to understand the received information and the application, and thus understand the elements of the application. For example, the system can parse source code and identify access points, code sections that perform specific functions, multiple classes within the code, operations performed, resources used by the application (e.g., tables, files), code dependencies, etc. As another example, the system can analyze runtime logs to identify the frequency of application service calls, the application service call graph, etc. The system can also identify or infer other information about the application, such as the programming language used to program the application, runtime, resource usage and allocation, etc. The received information and additional information can be used to identify information about the application in order to determine how the application can be broken down into different microservices.

[0028] A single application may include many different modules or sections, each performing different functions. As an example, an e-commerce application may include a customer service section, a product inventory section, a transaction section, and so on. Each of these sections may include its own application elements. Furthermore, some application elements from one section may access, communicate with, or invoke application elements from another section. For example, one section may access holding objects or forms contained within another section. Holding objects are code representing real-world objects. Using the e-commerce example, the real-world object could be a specific customer, and the holding object is the program code representing that specific customer.

[0029] In section 103, the microservices advisor application generates a heterogeneous graph consisting of nodes and edges. Nodes in the graph represent or correspond to application elements. Edges in the graph represent the relationships between application elements connected by the edges. The heterogeneous graph includes all application elements of the application itself, as well as any elements outside the application that are accessed by the application, provide information to it, or otherwise communicate with or call between applications. These are all represented by nodes in the heterogeneous graph.

[0030] Generating heterogeneous graphs can include utilizing neural networks capable of identifying relationships between application elements. Because neural networks are used in the generation of heterogeneous graphs, they learn more about the different application elements and what constitutes the relationships between them. Therefore, neural networks allow microservices advisor applications to become more refined and accurate over time regarding what is considered an application element, what constitutes a relationship, and the types of relationships between application elements.

[0031] Based on application analysis and / or the use of neural networks, microservices advisor applications are able to identify relationships or associations between application elements. These relationships or associations are identified when any of the application elements communicate with or call each other. These communications can span application parts, from the application to elements outside the application, or within a specific application part. The ability of microservices advisor applications to identify relationships or associations between many different application elements, not just between programs, allows the advisor application to generate heterogeneous graphs.

[0032] Furthermore, relationships or associations can be direct or indirect. Application elements with direct relationships / associations are those that communicate directly with each other, for example, if a program application element calls a table application element. Therefore, identifying direct associations includes identifying application elements that communicate with each other. Application elements with indirect relationships / associations are those that communicate with a common application element but do not necessarily communicate with each other. For example, two application elements that both communicate with the same holding object application element will have an indirect relationship. In other words, an indirect association can be identified when a single application element is accessed by more than one other application element. Those application elements that access a single application element will have an indirect association. It should be noted that the same application element can have both direct and indirect relationships with each other. For example, application elements can communicate directly with each other, and both can also communicate with another common application element.

[0033] Figure 2A The direct relationships between application elements in graph 200A are illustrated. Application element 201 communicates directly with application element 202. Both application elements 201 and 202 are represented by nodes within graph 200A. Since application elements 201 and 202 communicate with each other, edge 203 connects these two application elements 201 and 202, indicating the direct association between application elements 201 and 202.

[0034] Figure 2B The indirect relationships between application elements in graph format 200B are illustrated. Application element 204 is represented by a node. Furthermore, application element 207 is represented by a node. Both application elements 204 and 207 communicate with application element 205, which is represented by a node. The communication between application elements 204 and 207 and application element 205 is represented by edge 206. Since application elements 204 and 207 both communicate with the common application element 205, application elements 204 and 207 are identified as having indirect relationships with each other.

[0035] In section 104, the microservices advisor application determines whether node groups can be identified within a heterogeneous graph. Node groups can be referred to as communities or clusters of nodes. To perform grouping, the advisor application can use graph clustering techniques, such as unsupervised clustering algorithms. Typically, unsupervised clustering algorithms work by grouping similar nodes together into a single cluster. Therefore, to identify node groups within a heterogeneous graph, the microservices advisor application identifies nodes that share common attributes (e.g., common preferences, common domains, common technologies, etc.). These common attributes can be identified from different application artifacts. For example, common attributes can be identified based on direct and / or indirect associations identified when the graph was generated. Thus, node groups can be identified based on the direct and / or indirect associations of application elements identified based on edges within the graph.

[0036] Other factors can be used to determine attributes. For example, a consultant application can identify class affinity (CA) between application elements. Affinity identifies whether a class within an application function has some connection or relationship with other classes within other application functions, even if they may not communicate directly with each other. Class affinity can be used to identify attributes. Other factors can include inter-class usage (ICU), path co-occurrence (PCC), transactions (TR), etc. These factors can indicate a connection between application elements and also identify the strength of the relationship between application elements, which can be used to identify attributes.

[0037] When performing clustering, the advisor application can consider user-provided constraints or requirements. For example, the user can indicate specific resource usage requirements, runtime requirements, maximum class or object requirements, maximum module size, etc. As another example, the user can indicate application elements that should be grouped or should never be grouped. As a final example, the user can identify that a set of specific application elements implementing a specific interface can be split, but procedures that update tables should never be split.

[0038] When identifying groups, users can also identify the importance of specific relationships between application elements. For example, users can identify which specific nodes or relationships between nodes are important for them to remain together in a single cluster, or alternatively, for them to remain in separate clusters. Users can also identify weighted importance. For example, users can identify whether one relationship within a graph is more or less important than another. Thus, microservice advisor applications can leverage attention mechanisms to capture the importance of relationships within a graph neural network and cluster nodes in the graph based at least in part on the identified importance. Using provided requirements or constraints, the system can cluster nodes into clusters that meet or conform to the desired requirements or constraints. Thus, advisor applications can utilize various factors, user-provided input, etc., when performing clustering. Clustering can also be performed using machine learning models or neural networks that have been continuously learned from previous clustering.

[0039] If a cluster cannot be identified at point 104, the advisor application can take no action at point 105. The advisor application can also notify the user that a cluster could not be identified. Conversely, if a cluster can be identified at point 104, the advisor application can provide recommendations for breaking down the application into microservices at point 106. When providing recommendations, the system can offer the user an initial recommendation that allows them to make any modifications to the clusters. This provides the user with the opportunity to validate groups or clusters and identify any outliers. This input can then be incorporated into the clusters, which are refined by the advisor application. The final microservice clusters can then be generated and provided or used within the recommendations offered to the user.

[0040] The recommendation identifies how many microservices an application should be broken down into. In other words, the recommendation identifies the number of microservices an application should have. Additionally, the recommendation identifies the application elements within each microservice that should be included in the recommendation. The recommendation is based on clustering and the factors used within those clusters. Therefore, the recommendation is based on information, constraints, and / or requirements provided by the user. The advisor application can also provide rationale for the recommendation. Rationale can include identifying which factors were used in the microservice clustering recommendation or which factors have a higher influence on the microservice clustering recommendation. Rationale allows users to easily identify any changes that should be made to the clustering algorithm or factors used in the clustering.

[0041] Figure 3 The overall system of a microservices advisor application is illustrated. The advisor application obtains information describing the application to be decomposed into microservices. This information can be obtained from a data store 301A, the source code corresponding to the application 301B, etc. The advisor application performs analysis 302, such as static code analysis, runtime data analysis, data analysis, dependency analysis, log analysis, program analysis, etc. Based on the analysis, the advisor application generates a heterogeneous graph with nodes representing application elements and edges representing relationships between application elements. Once the graph is generated, the advisor application clusters groups of nodes into communities based on various factors 303 (e.g., user cases, inter-class usage, path co-occurrence, transactions, class affinity, etc.). The result is a group of nodes based on a heterogeneous graph network 304, called a community. These communities can be sent to user 306 for verification and for the user to identify any outliers. Any user input is merged, and the finalized microservices 305 are output to user 306 as recommendations for decomposing the application into microservices.

[0042] like Figure 4As shown, the computer system / server 12' in compute node 10' is illustrated as a general-purpose computing device. Components of the computer system / server 12' may include, but are not limited to: at least one processor or processing unit 16', system memory 28', and a bus 18' that couples various system components, including system memory 28', to the processor 16'. Bus 18' represents at least one of several types of bus architectures, including a memory bus or memory controller, a peripheral bus, an accelerated graphics port, and a processor or local bus using any of a variety of bus architectures. By way of example and not limitation, such architectures include the Industry Standard Architecture (ISA) bus, the Micro Channel Architecture (MCA) bus, the Enhanced ISA (EISA) bus, the Video Electronics Standards Association (VESA) local bus, and the Peripheral Component Interconnect (PCI) bus.

[0043] Computer system / server 12' typically includes various computer system readable media. Such media can be any available media that can be accessed by computer system / server 12', and includes volatile and non-volatile media, removable and non-removable media.

[0044] System memory 28' may include computer system readable media in the form of volatile memory, such as random access memory (RAM) 30' and / or cache 32'. Computer system / server 12' may also include other removable / non-removable, volatile / non-volatile computer system storage media. By way of example only, storage system 34' may be configured to read from or write to non-removable non-volatile magnetic media (not shown, and generally referred to as "hard disk drives"). Although not shown, disk drives for reading from or writing to removable non-volatile disks (e.g., "floppy disks") and optical disk drives for reading from or writing to removable non-volatile optical disks (e.g., CD-ROMs, DVD-ROMs, or other optical media) may be provided. In this case, each may be connected to bus 18' via at least one data media interface. As will be further described and depicted below, memory 28' may include at least one program product having a set (e.g., at least one) of program modules configured to perform embodiments of the invention.

[0045] A program / utility 40' having a set (at least one) of program modules 42', along with an operating system, at least one application, other program modules, and program data, may be stored in memory 28' (by way of example and not limitation). Each or some combination of the operating system, at least one application, other program modules, and program data may include an implementation of a network environment. Program modules 42' typically perform functions and / or methods as described herein in embodiments of the invention.

[0046] The computer system / server 12' can also communicate with at least one external device 14', such as a keyboard, indicating device, display 24', etc., enabling a user to interact with at least one device; and / or any device that enables the computer system / server 12' to communicate with at least one other computing device (e.g., a network interface card, modem, etc.). This communication can occur via I / O interface 22'. Furthermore, the computer system / server 12' can communicate with at least one network, such as a local area network (LAN), a general wide area network (WAN), and / or a public network (e.g., the Internet), via network adapter 20'. As described, network adapter 20' communicates with other components of the computer system / server 12' via bus 18'. It should be understood that, although not shown, other hardware and / or software components can be used in conjunction with the computer system / server 12'. Examples include, but are not limited to: microcode, device drivers, redundant processing units, external disk drive arrays, RAID systems, tape drives, and data archiving storage systems.

[0047] This disclosure has been presented for purposes of illustration and description, but is not intended to be exhaustive or limiting. Many modifications and variations will be apparent to those skilled in the art. These embodiments have been chosen and described in order to explain the principles and practical applications, and to enable others skilled in the art to understand this disclosure.

[0048] While illustrative embodiments of the invention have been described herein with reference to the accompanying drawings, it should be understood that the embodiments of the invention are not limited to those precise embodiments, and that various other changes and modifications may be made therein by those skilled in the art without departing from the scope or spirit of this disclosure.

[0049] This invention can be a system, method, and / or computer program product. A computer program product may include a computer-readable storage medium having computer-readable program instructions thereon for causing a processor to execute aspects of the invention.

[0050] Computer-readable storage media can be a tangible means for retaining and storing instructions for use by an instruction execution device. Computer-readable storage media can be, for example, but not limited to, electronic storage devices, magnetic storage devices, optical storage devices, electromagnetic storage devices, semiconductor storage devices, or any suitable combination of the foregoing. A non-exhaustive list of more specific examples of computer-readable storage media includes: portable computer disks, hard disks, random access memory (RAM), read-only memory (ROM), erasable programmable read-only memory (EPROM or flash memory), static random access memory (SRAM), portable compact disk read-only memory (CD-ROM), digital universal disk (DVD), memory sticks, floppy disks, mechanical encoding devices such as punch cards or protrusions in slots having instructions recorded thereon, and any suitable combination of the foregoing. As used herein, computer-readable storage media should not be construed as transient signals themselves, such as radio waves or other freely propagating electromagnetic waves, electromagnetic waves propagating through waveguides or other transmission media (e.g., light pulses passing through fiber optic cables), or electrical signals transmitted through wires.

[0051] The computer-readable program instructions described herein can be downloaded from a computer-readable storage medium to a suitable computing / processing device via a network (e.g., the Internet, a local area network, a wide area network, and / or a wireless network), or to an external computer or external storage device. The network may include copper cables, optical fibers, wireless transmissions, routers, firewalls, switches, gateway computers, and / or edge servers. A network adapter card or network interface in each computing / processing device receives the computer-readable program instructions from the network and forwards them to a computer-readable storage medium within the suitable computing / processing device.

[0052] Computer-readable program instructions used to perform the operations of this invention may be assembly instructions, instruction set architecture (ISA) instructions, machine instructions, machine-dependent instructions, microcode, firmware instructions, state setting data, or source code or object code written in any combination of one or more programming languages, including object-oriented programming languages ​​(such as Smalltalk, C++, etc.) and conventional procedural programming languages ​​(such as the "C" programming language or similar programming languages). The computer-readable program instructions may be executed entirely on a user's computer, partially on a user's computer, as a standalone software package, partially on a user's computer and partially on a remote computer, or entirely on a remote computer or server. In the latter case, the remote computer may be connected to the user's computer via any type of network (including a local area network (LAN) or a wide area network (WAN)) or may be connected to an external computer (e.g., via the Internet using an Internet service provider). In some embodiments, electronic circuitry including, for example, programmable logic circuitry, field-programmable gate arrays (FPGAs), or programmable logic arrays (PLAs) may be personalized to execute computer-readable program instructions by utilizing state information from the computer-readable program instructions in order to perform aspects of this invention.

[0053] The present invention will now be described with reference to flowchart illustrations and / or block diagrams of methods, apparatus (systems), and computer program products according to embodiments of the invention. It should be understood that each block of the flowchart illustrations and / or block diagrams, and combinations of blocks in the flowchart illustrations and / or block diagrams, can be implemented by computer-readable program instructions. These computer-readable program instructions can be provided to a processor of a general-purpose computer, special-purpose computer, or other programmable data processing apparatus to produce a machine, such that the instructions, which execute via the processor of the computer or other programmable data processing apparatus, create means for implementing the functions / actions specified in one or more blocks of the flowchart illustrations and / or block diagrams. These computer-readable program instructions can also be stored in a computer-readable storage medium that causes a computer, programmable data processing apparatus, and / or other device to operate in a particular manner, such that the computer-readable storage medium storing the instructions comprises an article of manufacture containing instructions for implementing aspects of the functions / actions specified in one or more blocks of the flowchart illustrations and / or block diagrams.

[0054] Computer-readable program instructions may also be loaded onto a computer, other programmable data processing apparatus, or other device to cause a series of operational steps to be performed on the computer, other programmable apparatus, or other device to produce computer-implemented processing, such that the instructions executed on the computer, other programmable apparatus, or other device perform the functions / actions specified in one or more boxes of a flowchart and / or block diagram.

[0055] The flowcharts and block diagrams in the accompanying drawings illustrate the architecture, functionality, and operation of possible implementations of systems, methods, and computer program products according to various embodiments of the present invention. Each block in a flowchart or block diagram may represent a module, segment, or portion of instructions, including one or more executable instructions for implementing a specified logical function. In some alternative implementations, the functions marked in the blocks may occur in a different order than indicated in the figures. For example, depending on the functions involved, two consecutively shown blocks may actually be executed substantially simultaneously, or these blocks may sometimes be executed in reverse order. It should also be noted that each block in the block diagrams and / or flowcharts, and combinations of blocks in the block diagrams and / or flowcharts, can be implemented using a dedicated hardware-based system that performs the specified function or action or executes a combination of dedicated hardware and computer instructions.

Claims

1. A method for generating heterogeneous graphs for application microservices, comprising: Receive information describing the application that needs to be split into multiple microservices; Use a microservices advisor application to identify the application elements of the application; The microservices advisor application generates a heterogeneous graph from the application elements, wherein the generation includes using a time-varying neural network based on the historical generation of the heterogeneous graph to identify relationships between application elements and the types of relationships between the application elements, wherein each node in the heterogeneous graph represents an application element, and wherein each edge in the heterogeneous graph represents a relationship between two nodes connected by the edge, at least partially identified using the neural network, wherein the application elements include direct elements of the application and indirect elements outside the application and invoked between the applications; Using the microservices advisor application and graph clustering technology, based on the edges in the heterogeneous graph, identify groups of nodes in the heterogeneous graph that share common attributes; as well as Based on the identified group of nodes, the microservices advisor application provides recommendations for breaking down the application into microservices, wherein the recommendations include multiple microservices of the application and application elements that should be included in each of the microservices.

2. The method according to claim 1, wherein, The identification of node groups is performed based on user-provided constraints.

3. The method of claim 1, wherein the generation includes identifying indirect associations between application elements, and wherein identifying node groups is performed in view of the indirect associations.

4. The method according to claim 3, wherein, Identifying indirect associations includes identifying application elements that are accessed by more than one other application element.

5. The method of claim 1, wherein the generation includes identifying direct associations between application elements, and wherein identifying node groups is performed in view of said direct associations.

6. The method according to claim 5, wherein, Identifying direct relationships includes identifying application elements that communicate with each other.

7. The method according to claim 1, wherein, Node group identification is performed based on the affinity between application elements.

8. The method according to claim 1, wherein, The provision includes providing the reasons for the recommendation.

9. The method according to claim 1, wherein, The application elements include elements selected from the following groups: classes, objects, resources, and files.

10. An apparatus for generating heterogeneous graphs for application microservices, comprising: At least one processor; as well as A computer-readable storage medium having computer-readable program code that is implemented therewith and executable by the at least one processor; The computer-readable program code is configured to perform the steps of the method according to any one of claims 1 to 9.

11. A computer program product, comprising: A computer-readable storage medium having computer-readable program code implemented therewith, the computer-readable program code being executable by a processor; The computer-readable program code is configured to receive information describing an application to be split into multiple microservices; The computer-readable program code is configured to use a microservices advisor application to identify application elements of the application; The computer-readable program code is configured to generate a heterogeneous graph from the application elements using the microservices advisor application, wherein the generation includes using a time-varying neural network based on the historical generation of the heterogeneous graph to identify relationships between application elements and the type of relationships between the application elements, wherein each node in the heterogeneous graph represents an application element and wherein each edge in the heterogeneous graph represents a relationship between two nodes connected by the edge, at least partially identified using the neural network, wherein the application elements include direct elements of the application and indirect elements outside the application and invoked between the applications; The computer-readable program code is configured to use the microservices advisor application and graph clustering techniques to identify groups of nodes in the heterogeneous graph that share common attributes, based on the edges in the heterogeneous graph. and The computer-readable program code is configured to provide recommendations from the microservices advisor application for splitting the application into microservices based on the identified node groups, wherein the recommendations include multiple microservices of the application and application elements that should be included in each of the microservices.

12. The computer program product according to claim 11, wherein, The identification of node groups is performed based on user-provided constraints.

13. The computer program product of claim 11, wherein the generation includes identifying indirect associations between application elements, and wherein identifying a group of nodes is performed in view of said indirect associations.

14. The computer program product according to claim 13, wherein, Identifying indirect associations includes identifying application elements that are accessed by more than one other application element.

15. The computer program product of claim 11, wherein the generation includes identifying direct associations between application elements, and wherein identifying a group of nodes is performed in view of said direct associations.

16. The computer program product according to claim 15, wherein, Identifying direct relationships includes identifying application elements that communicate with each other.

17. The computer program product according to claim 11, wherein, Node group identification is performed based on the affinity between application elements.

18. The computer program product according to claim 11, wherein, The provision includes providing the reasons for the recommendation.

Images