Nabor C. Mendonça

Cloudstep: A step-by-step decision process to support legacy application migration to the cloud

Cloud computing is an emerging computing paradigm whose benefits (such as high scalability, reduced IT costs, self-service on demand, and pay-as-you-go price models) have increasingly attracted the interest of the corporate world. Nevertheless, many organizations have found it difficult to adopt cloud-based solutions, particularly regarding the migration of their existing legacy applications to this new environment. One of the main obstacles faced by those organizations is the lack of a general process to help application developers not only in selecting the cloud models and services best suited for their application, but also in carefully assessing the various risks and benefits involved. To fill this gap, this paper presents Cloudstep, a step-by-step decision process aimed at supporting legacy application migration to the cloud. The process relies on the creation of template-based profiles characterizing the organization, the target legacy application and candidate cloud providers, which are then cross-analyzed to help identify and possibly resolve critical constraints (either technical or non technical) that may hinder migration to the cloud. The use of the process is illustrated through an analysis of key factors influencing the migration of a commercial medical application to different infrastructure-as-a-service cloud providers.

Uni4Cloud: an approach based on open standards for deployment and management of multi-cloud applications

Cloud computing is changing the way applications are being developed, deployed and managed. Application developers can focus on business and functionality and leverage infrastructure clouds (IaaS) to provide them low cost resources (e.g., computation, storage, and networking) that can be controlled based on application needs. However, current IaaS cloud developers have to deal with daunting tasks to configure and deploy their applications in different cloud providers. This paper presents the Uni4Cloud approach that facilitates to model, deploy and configure complex applications in multiple infrastructure clouds. We demonstrate through an enterprise application case study how Uni4Cloud facilitates to deploy components (e.g., application server, database, load balancer) in multiple clouds using a model-based approach that helps to automatically configure and deploy applications independent of IaaS cloud provider. Moreover, the approach is based on cloud computing standards such as the Open Virtualization Format (OVF) and Open Cloud Computing Interface (OCCI) to favor interoperability and to avoid being locked in to specific cloud providers.

A Declarative Environment for Automatic Performance Evaluation in IaaS Clouds

One of the main challenges faced by users of infrastructure-as-a-service (IaaS) clouds is the difficulty to adequately estimate the virtual resources necessary for their applications. Although many cloud providers offer programatic ways to rapidly acquire and release resources, it is important that users have a prior understanding of the impact that each virtual resource type offered by the provider may impose on application performance. This paper presents Cloud Crawler, a new declarative environment aimed at supporting users in describing and automatically executing application performance tests in IaaS clouds. To this end, the environment provides a novel declarative domain-specific language, called Crawl, which supports the description of a variety of performance evaluation scenarios in multiple IaaS clouds, and an extensible Java-based cloud execution engine, called Crawler, which automatically configures, executes and collects the results of each performance evaluation scenario described in Crawl. To illustrate Cloud Crawlers potential benefits, the paper reports on an experimental evaluation of a social network application in two public IaaS cloud providers, in which the proposed environment has successfully been used to investigate the application performance for different virtual machine configurations and under different demand levels.

Interactive Mobile 3D Graphics for on-the-go visualization and walkthroughs

Developing interactive 3D graphics for mobile Java applications is now a reality. Recently, the Mobile 3D Graphics (M3G) API (also known as JSR-184) was proposed to provide an efficient 3D graphics environment suitable for the J2ME platform. However, new services and applications using interactive 3D graphics, which have already achieved reasonable standards on the desktop, do not exist for resource-constrained handheld devices yet. In this work, a generic architecture for visualizing and navigating through 3D worlds in a mobile setting was designed and implemented. In particular, a 3D virtual tour application was developed based on the proposed architecture, where multiple mobile clients using M3G navigate through and interact with each other in a shared 3D space.

Benchmark requirements for microservices architecture research

Microservices have recently emerged as a new architectural style in which distributed applications are broken up into small independently deployable services, each running in its own process and communicating via lightweight mechanisms. However, there is still a lack of repeatable empirical research on the design, development and evaluation of microservices applications. As a first step towards filling this gap, this paper proposes, discusses and illustrates the use of an initial set of requirements that may be useful in selecting a community-owned architecture benchmark to support repeatable microservices research.

A process for separation of crosscutting grid concerns

This paper describes how to explicitly separate crosscutting Grid concerns in a parallel Java application. This process, named GridAspecting, uses a restricted subset of the Java threads model for application decomposition, and aspect-oriented programming for allowing parallel execution of the applications threads as Grid tasks. As a result of the process, all Grid-related code is encapsulated in aspects, thus improving the applications modularity. In addition, by relying on Javas native concurrency abstractions the process simplifies the Grid programming model and makes it possible to test a Grid application even without the Grid.

A LOOSELY COUPLED ASPECT LANGUAGE FOR SOA APPLICATIONS

The aspect-oriented programming (AOP) paradigm offers software developers with powerful modularization abstractions to help them explicitly separate design concerns at the source code level. However, the impact of AOP in the service-oriented architecture (SOA) paradigm has been dwarfed by the fact that existing AOP solutions are tightly coupled to a particular programming language, middleware system or execution platform. Clearly, this not only restricts the implementation choices available to application developers, but it also clashes with the heterogeneous and loosely coupled nature of SOA. This paper presents the Web Service Aspect Language (WSAL) that seamlessly integrates AOP and SOA concepts, thus avoiding the drawbacks of existing solutions. In WSAL, aspects themselves are freely specified, implemented and executed as loosely coupled web services. This characteristic allows WSAL aspects to be easily woven into the message flow exchanged between service consumers and service providers, in a way that is completely independent from any particular implementation technology. This paper also reports on the implementation and preliminary evaluation of a prototype aspect weaver for WSAL, which is based on an existing web intermediary technology.

Performance Inference: A Novel Approach for Planning the Capacity of IaaS Cloud Applications

This work presents a novel approach to support application capacity planning in infrastructure-as-a-service (IaaS) clouds. The approach, called performance inference, relies on the assumption that it is possible to establish a capacity relation between different resource configurations offered by a given IaaS provider, enabling one to infer an applications performance under certain resource configurations and workloads, based upon the applications actual performance as observed for other related resource configurations and workloads. Preliminary evaluation results, obtained from testing the performance of a well-known blogging application (Word Press) in a public IaaS cloud (Amazon EC2), show that the best performance inference strategies can significantly reduce (over 80%) the total number of application deployment scenarios that need to be actually tested in the cloud, with a high (over 98%) inference accuracy.

An Aspect-Oriented Programming Model for Bag-of-Tasks Grid Applications

This paper presents a novel programming model for explicitly separating parallelization and middleware-specific concerns in bag-of-tasks (BoT) grid applications. The model uses Java threads for application decomposition, and aspect-oriented programming to dynamically (and transparently) convert the applications thread objects into independent grid tasks, using the services of a specific grid middleware API. This paper also describes early experimental results showing the models modularity gains and performance overhead, when applied to implement BoT grid applications using OurGrid.

Cloud Detours: A Non-intrusive Approach for Automatic Software Adaptation to the Cloud

A major challenge facing cloud migration is the need to change a legacy (on-premise) application’s source code so that it can better benefit from the inherit cloud computing characteristics, such as resource elasticity and high scalability. When performed manually, those changes are error-prone and may require a great effort from application developers. This paper presents a novel approach to support organizations in automatically adapting their existing software applications to the cloud. The approach is based on the loosely-coupled implementation of non-intrusive code transformations, called cloud detours, which enable the automatic replacement of local services used by an application with similar or functionally-related services available in the cloud. To illustrate the approach, the paper reports on how an initial set of cloud detours, implemented using aspect-oriented programming and a generic cloud library, was used to seamlessly adapt an existing file-based Java application to save application data in a cloud-based storage service.