Amazon Technologies, Inc.

Vivek Chawda

Sophia Yeemei Tsang

Roland Mesde

Samartha Chandrashekar

Sushil Ravoori

Javier Arturo Thiele-Ruiz

Nagaraju Shiramshetti

Sumeet Talwar

Keshav Sethi Attrey

Jiangtao Zhang

Ekanth Sethuramalingam

Sriram Venkatadri

Koushik Rajagopal

Vivek Menon

Shailaja Yadav

Divya Balasubramanian

Daniel John Scholl

Gaurav Gupta

Raviprasad V Mummidi

Raviprasad Venkatesha Murthy Mummidi

Ramu Panayappan

Saket Saurabh

Abdul Jabbar Abdul Rasheed

Mark Fawaz

Maxwell Edward Chapman Nuyens

Sagar Kumar

Nikhil Kumar Jadhav

Emery Jacob Comstock

Nikhilkumar Jadhav

Levente Csaba Tamasi

Kanishk Kaul

Frederick Lee Von Wurden

Nicholas King Bendler

Sreenaath Vasudevan

Sukwon Kim

Swetha Sundar

Pranav Prabhakar Firake

Donghao Wei

Tianyi Luo

Anbuselvan Ramanathan

Aman Bindal

Julian Ozen

Techniques are described for assisting users with the process of modernizing software applications from a source software architectural pattern (e.g., a model—view—controller (MVC) pattern, a multitier architecture, etc.) to a target architectural pattern (e.g., microservices, event-driven architecture, etc.). A decomposition analyzer receives as input artifacts associated with a software application under analysis and an architectural pattern that a user desires to use for a modernized version of the software application. The decomposition analyzer generates, based on the application artifacts, a graph-based model of the software application, where the model includes nodes representing application components (e.g., classes) and edges representing dependency relationships among the components. The decomposition analyzer further uses machine learning techniques and other types of analyses to identify recommended groupings of nodes from the graph-based model for decomposition. These recommendations can be displayed to users in a visualization providing decomposition assessment information.

Guided modernization of software applications using application templates

Techniques are described for identifying resource bottlenecks in decomposing monolithic software applications as part of software modernization processes. An application modernization system constructs a graph model of a software application based on an analysis of application artifacts associated with the software application. The graph model includes nodes representing independent application components, and further includes edges representing identified dependency relationships among the application components. An application modernization system further generates application profile metrics associated with the identified dependencies, and weights derived from the metrics are applied to the nodes and/or the edges of the graph model to generate a weighted graph model that identifies the resource bottlenecks among the application components and the identified dependency relationships. The weighted graph model is transmitted to a computing device for display to a user.

Detection, presentation, and resolution of bottlenecks in monolith decomposition

Techniques are described for automatically identifying monolithic software applications in users' computing environments for software modernization purposes. A monolithic patent application typically refers to a single-tiered application with self-contained functionality designed largely without modularity, although many types of applications can have monolithic characteristics. In many cases, modularity in a software application's design is desirable and thus developers may often seek to decompose monolithic applications into more modular 'microservices' or other subunits when possible. A software modernization system includes a software analysis service that obtains, for one or more software applications undergoing evaluation, a collection of application artifacts, application profiling metrics, and other application profile data. A collection of features is extracted from the application artifacts and metrics and used as input to a ML model trained to determine whether a software application likely is monolithic.

Machine learning-based identification of monolithic software application

Disclosed are various embodiments for anti-pattern detection in extraction and deployment of a microservice. A software modernization service is executed to analyze a computing application to identify various applications. When one or more of the application components are specified to be extracted as an independently deployable subunit, anti-patterns associated with deployment of the independently deployable subunit are determined prior to extraction. Anti-patterns may include increases in execution time, bandwidth, network latency, central processing unit (CPU) usage, and memory usage among other anti-patterns. The independently deployable subunit is selectively deployed separate from the computing application based on the identified anti-patterns.

Anti-pattern detection in extraction and deployment of a microservice

Disclosed are various embodiments for isolated code detection from application code analysis. Various application components may be identified from a source code file or a bytecode file of a computing application. A graph model representative of the computing application is generated having nodes and bridges that connect some nodes to other nodes. The graph model is generated such that at least one of the nodes is an isolated node having less than a threshold number of bridges connecting to other nodes, which is indicative that a corresponding one of the application components can be implemented as an independently deployable component of the computing application.

Isolated code detection from application code analysis

Disclosed are various embodiments for the extraction of isolated nodes during source code refactoring. A graph model representative of a computing application is generated having nodes and bridges that connect some nodes to other nodes. An application component corresponding to a selected one of the nodes may be extracted from the computing application. An independently deployable component of the computing application may be generated and deployed on a network service such that the independently deployable component is accessible through a network-based call.

Automated extraction of isolated nodes during source code refactoring

Disclosed are various embodiments for the refactoring of local calls to network calls during software modernization. First and second application components are identified based on analysis of a computing application. A local call from the first application component to a process of the second application component is identified, and an independently deployable microservice is created from the computing application. The independently deployable subunit comprises the second application component having a network endpoint. The independently deployable microservice is deployed such that the process is accessible to the first application component via the network endpoint. The local call is programmatically refactored into a network call from the first application component to the process of the second application component.

Software modernization refactoring of local calls to network calls

Techniques are described for using graph partitioning techniques to identify refactoring candidates to decompose monolithic software applications as part of software modernization processes. An application modernization system constructs a graph model of a software application based on an analysis of application artifacts associated with the software application. The graph model includes nodes each representing an independent application component and further includes edges representing identified dependency relationships among the application components. An application modernization system further generates application profile metrics associated with the identified dependencies, and weights derived from such metrics are applied to the edges of the graph model. Once a weighted graph model is obtained, a graph partitioning algorithm is applied to identify a plurality of subgraphs each representing a candidate subunit of the application for refactoring.

Using graph partitioning for software decomposition during modernization processes

Disclosed are various embodiments for domain-driven application breakout. Application components are identified based on analysis of a computing application, where the application components are different portions of the computing application. Individual ones of the application components are associated with a category, where the category may include a business domain category. One or more of the application components associated with the category are extracted as an independently deployable subunit, which may include a microservice. The independently deployable subunit is generated for the category using the at least one of the application components and deployed separate from the computing application. A local call in the computing application to the extracted application components is refactored to a network call to the independently deployable subunit.

Domain-driven application breakout

Disclosed are various embodiments for a pricing application. Customer interest in unpurchased items is determined by a browsing history of a customer. A notification is communicated to a merchant of the item soliciting an offer for the item to be communicated to the customer. The offer is then communicated to the customer for redemption.

Personalized product pricing

Techniques for securely migrating servers from customer networks into service provider systems are described. A backup proxy can be deployed in a customer's network and associated with one or more servers in the customer's network and with a server migration service of a service provider system. A customer can identify a server in the customer's network to migrate and the server migration service coordinates the migration with the backup proxy. The backup proxy can be instructed to obtain replication data for the server, obtain an encryption key associated with the customer from a key management service (KMS), encrypt the replication data, and upload the encrypted replication data to the service provider system. The service provider system can obtain the same encryption key used to encrypt the replication data from the KMS and decrypt the uploaded encrypted replication data to generate migrated server resources at the service provider system.

Secure migration of servers from customer networks to service provider systems

Techniques for migrating source code to a virtual compute service are described. The migration of source code is assisted by metadata that identifies portions of the source code&#x2014;for example, one or more classes, methods, functions, subroutines, and so forth&#x2014;desired to be replicated by one or more virtual compute service functions executing in the virtual compute service. One or more virtual compute service functions are created at the virtual compute service that implement the functionality of the identified portions of source code. The identified source code can be refactored to invoke the corresponding virtual compute service function(s) in the virtual compute service using, for example, application programming interface (API) calls sent over a network to the service provider system. In this manner, the external functional behavior of the source code can remain the same while internally taking advantage of the benefits offered by a virtual compute service.

Migrating computer programs to virtual compute services using annotations

A migration system or service may implement event-driven replication for migrating a computing resource from a source network to a destination network. A replication event may be detected to obtain a state of a data volume for a computing resource hosted in a client network. A request to a replication agent hosted in the source network may instruct the replication agent to copy at least some of the data of the data volume and send the data to the destination network. The migration service may generate a state of the data volume from the received data in a format that is operable to host the computing resource in the destination network and store the generated state of the data volume.

Event-driven replication for migrating computing resources

Techniques for self-organizing server migration into service provider systems are described. Connectors can be deployed in a customer network and associated with one or more virtual machine (VM) management servers and also with a server migration service. The customer may indicate what VMs are to be migrated, and the server migration service can dynamically select one or more of the connectors to perform migration operations based on operational or configuration characteristics of the connectors and/or the type of migration job to be performed. The connectors can be auto-scaled to increase or decrease operational capacity, and graceful failovers can be performed to eliminate migration failures resulting from connector failures.

Self-organizing server migration to service provider systems

Techniques for automated application footprint discovery for application migration to containers are described. A snapshot of an application instance can be stored, the snapshot including the application instance and resources used by the application instance at runtime. The application instance can be run in an intermediate virtual machine, the intermediate virtual machine including at least one interceptor. At least one dependency of the application instance can be determined using the at least one interceptor while the application instance executes on the intermediate virtual machine. A template including the at least one dependency can be created and an application environment can be generated using the template.

Growing community of inventors

Albany, CA, United States of America

Vivek Chawda