Application deployment and management in Infrastructure as a Service (IaaS) Clouds can be a complex and time consuming endeavor, typically requiring manual effort on the users' behalf and relying on vendor-specific, proprietary tools. Existing IaaS tools do not provide users with vendor-neutral mechanisms for describing application configuration, deployment and runtime application preferences, as well as policies that govern automatic resource adaptation. Consequently, the migration of applications between different IaaS providers requires significant re-configuration and re-deployment effort and time, leading to vendor lock-in. With the growing number of IaaS-provider service offerings and the increasing complexity of applications deployed on Clouds, the selection of the most appropriate provider to host an application becomes challenging. While seeking to identify the deployments that suit best their needs, IaaS clients need to overcome vendor lock-in in order to test and/or deploy their applications on multiple IaaS providers. Therefore, it becomes evident that there is a need for application management tools that facilitate the description of applications in a vendor neutral manner, enabling easy application deployment, management, and migration across different providers, thereby preventing vendor-lock in. Many application management frameworks have been developed lately to support Cloud Computing. The majority are proprietary, locking their users to specific providers. Other frameworks which are generic enough and allow management of applications on different infrastructures are predominantly web-based, therefore lacking tight integration to unified application development and team collaboration environments such as Eclipse.
We propose a new Eclipse project, called "Cloud Application Management Framework (CAMF)", that leverages the reliable Eclipse platform for offering extensible graphical tools that enable interoperable description of Cloud applications and facilitate lifecycle management operations in a transparent and vendor-neutral manner. CAMF focuses on three distinct management operations, particularly application description, application deployment and application monitoring. To this end, it adopts the OASIS TOSCA open specification for blueprinting and packaging Cloud Applications. In addition it utilizes open-source tool kits such as Apache® jclouds for portable across-Cloud application deployment, as well as Chef for writing "recipes" that orchestrate application configuration processes upon deployment. Furthermore, CAMF provides the necessary programming interfaces that enable Cloud developers to specify resource adaptation policies and desired actions, as well as various monitoring operations at different levels of an application's structure.
The Cloud Application Management Framework can be promoted/adopted by any Cloud-related party as a tool for configuring, deploying and managing applications on different infrastructures in a vendor-neutral manner. This is beneficial both for resource vendors and end-users; the former can be urged to enhance their existing Cloud operations with additional open standardization and thus achieve great potential in customer base increase; the latter are able to describe the deployment and management lifecycle of their applications with minimal effort (GUI-based), in a way that promotes smoother migration to the Cloud while avoiding vendor lock-in.
Specifically the project aims to provide a Cloud Application management framework that provides the necessary tooling to assist with Cloud application lifecycle management operations. The following are within the project scope:
- Develop the framework within the Eclipse RCP platform.
- Provide graphical tools to facilitate the description of a Cloud application structure (blueprint), its principal components and inter-relationships.
- Utilize the OASIS TOSCA open-specification for encoding such graphical interactions/input to vendor-neutral instructions that define and drive the operational behavior of these applications.
- Provide editing tools for creating open-source Chef "recipes" that automate and streamline the configuration process during application deployment phase.
- Integrate an abstraction library (Apache jclouds) to hide the complexity of interacting with the Cloud provider.
- Provide the necessary programming interfaces for specifying resource adaptation policies and actions, as well as monitoring operations at different levels of an application's structure during runtime phase.
- Provide testing and debugging information in situations where application deployments fail.
Out of scope for the project is:
- Develop a TOSCA processing environment.
- Debug the Cloud application itself.
- Develop an IDE for Chef Ruby recipes.
The project aims to develop and sustain the necessary tooling that will assist Cloud application lifecycle management operations, using open standards and languages, where appropriate. As aforementioned, these operations are classified into three distinct categories: (1) application description, (2) application deployment and (3) application monitoring. CAMF will follow the Eclipse OSGi plug-in based software architecture for each of the aforementioned operations and will inherit the same look-and-feel that Eclipse users are accustomed to. To guarantee the quality of the resulting product, the project will follow designated development cycles with rigorous code reviews, unit tests and release cycles.
The Cloud Application Project
Figure 1 - The Cloud Application Project view.
Similar to other Eclipse frameworks, CAMF organizes all the files related to a Cloud application in a structured hierarchy that utilizes the Eclipse file system (see Figure 1). A Cloud Application project, acts as a placeholder for a single application and any of its runtime dependencies. To this extend it provides containers (folders) for:
- Application Descriptions; containing application structure blueprints described using the TOSCA open specification.
- Application Deployments; containing important historical details (past and current) about application deployments to various IaaS. Among other, these include date/time, the particular IaaS, reference to a particular version of the application description, operational costs, etc.
- Artifacts; containing artifacts required for the deployment and correct operation of the Cloud Application such as executable files and/or third-party libraries, custom virtual machine images, Chef configuration and deployment scripts, SSH keys etc.
- Monitoring Data; containing users' custom monitoring probes. These probes interface with the underlying monitoring system and obtain information that report the runtime health and performance of the application.
Also each project is associated with one or more IaaS-provider profile, that contains important information for interfacing and utilizing/querying the offered resources of each provider. Such information include communication endpoints, authentication credentials, granted permissions and rights, etc. which are manually provided by the user or wizard-imported from a standardized format input file.
Cloud Application Description
Figure 2 - The Cloud Application Management Framework User Interface while describing a 3-Tier Web-based video streaming service.
OASIS TOSCA open standard provides a language for describing the structure of Cloud applications, along with their management operations. The structure of an application presents its principal components and defines any existing relationship among them. Such components are described in TOSCA by means of Nodes and are used to represent specific types of executing entities in a deployment (i.e. an application component can be a Tomcat application server in a 3-tier web application). Each Node can have certain semantics such as: (i) Requirements against its hosting environment, (ii) the Capabilities it offers and (iii) the Policies that govern its execution such as resource security or elasticity. Similarly, as the name suggests Relationships represent the associations among Nodes and have their semantics based on their individual type. TOSCA provides the necessary grammar to describe management aspects of an application by means of lifecycle operations or by more complex Management Plans. For each Node its lifecycle operations can be defined, (i.e deploy or start an instance of the corresponding Node Type).
Nevertheless, compiling TOSCA documents (XML content) manually is cumbersome and quite error-prone endeavor. CAMF's Application Modeling Tool (see Figure 2), enables the compilation of large and complex TOSCA-based application descriptions, simply by following through a users' graphical input. The Application Modeling Tool associates all TOSCA elements with visual elements (available via a Palette view) that are consequently used to model an application schematically. All graphical interactions with available visual elements (drag'n'drop, move, delete, etc.) are translated on the fly into TOSCA XML content by considering the semantics of each underlying utilized element. Inherent compilation complexities are hidden from the user and possible errors that can be introduced via non-valid graphical actions are avoided/minimized using various visual cues and textual warnings. Moreover, continuous checks are performed on the generated TOSCA XML content to assure conformance with the standard. To facilitate the above, CAMF utilizes and improves upon the capabilities provided by the Graphiti graphics framework, for generating state-of-art diagrams for particular domain models.
The Palette View (see Figure 2, right-hand side) acts as a front-end to a Cloud Information System for visually representing all the resources available by one or more IaaS. The Cloud Information System provides a vendor-agnostic model for storing fundamental resource metadata that can be utilized during the application description and deployment processes. Among other these resource metadata include handles to: available public/private VM images and corresponding flavors, available software packages, Chef recipes, application-level and resource-level monitoring probes, etc. Using the jclouds toolkit, metadata are retrieved from each IaaS "marketplace" once during the creation of an IaaS-specific profile (endpoint and credential provision), and are consequently refreshed on intelligently adapted time intervals. In addition, the Palette View can display information about local resources, included/added by the user in Cloud Application Project hierarchy. Finally, to minimize the information displayed and swiftly identify any required component, the Palette includes standard searching and filtering mechanisms.
Cloud Application Deployment
Figure 3 - The Application deployment view, showing the status of the application on Amazon AWS EC2 and an OpenStack-compliant IaaS.
The TOSCA description along with the artifacts realizing all management operations of a particular application are packaged into a single fully self-contained archive, called Cloud Service Archive (CSAR). In case of a TOSCA-compliant provider, CAMF enables the submission of CSARs to a dedicated endpoint so as to be processed and interpreted accordingly by a TOSCA runtime environment, such as the one implemented in OpenTOSCA. According to the specification, Cloud providers that wish to become TOSCA-compliant should provide a Container entity as part of their Cloud architecture (see Figure 4). This entity is responsible to communicate with an IaaS orchestrator to make the necessary IaaS-specific operations to satisfy the respective TOSCA description.
Figure 4 - Exemplary Application Deployment Process at TOSCA-compliant Cloud providers.
In case that a Cloud provider is not yet TOSCA-compliant, CAMF adheres with the standard by providing the necessary abstractions and extension points for the implementation of TOSCA containers at the tools's side. These are jclouds-based connectors for specific IaaS, which can be easily developed following other exemplary implementations, or installed (if available) from a public p2 repository. In such scenarios, the application description generated by the Application Modeling Tool, is consequently parsed locally by the implemented connector responsible to execute IaaS-specific API calls for deployment and runtime configuration of the particular Cloud application.
Cloud Application Monitoring
After deployment, the application developer can interact with the Deployment View (see lower part Figure 3), so as to obtain instantly the deployment status without leaving the Eclipse environment. The Deployment view provides a snapshot of all application deployments grouped per target IaaS. Each deployment is accompanied with provider-specific properties such as component IP addresses, instance IDs, running times etc. A background polling mechanism refreshes the view and tries to always provides the latest information from each IaaS. Finally, c-Eclipse provides interfaces so as to be integrated with existing monitoring systems, enabling thus its users to monitor the performance of their deployed applications from a single environment. Currently, it is fully integrated with the JCatascopia Cloud monitoring system, nevertheless JCatascopia is not a CAMF dependency and thus can be swapped with another Cloud monitoring system.
The proposed Cloud Application Management Framework project is a natural fit for the Eclipse Foundation. Nowadays, in the Cloud computing era CAMF provides the capacity to application developers that currently make use of Eclipse as an IDE, to smoothly migrate their applications to the Cloud. More specifically, it provides them with the capability to deploy their application not only on one, but possibly many candidate IaaS in the quest of seeking the infrastructure and settings that suit best their needs. The well-integrated workbench environment of Eclipse and its accompanied tooling facilitate the inclusion of various, programming language-specific, compiled artifacts (i.e. JAR, WAR) in a Cloud Application description with just a few clicks. Furthermore, developers are able to seamlessly describe, deploy and monitor the runtime behavior of their application, without leaving the Eclipse environment, which are well-accustomed to.
Furthermore, the Eclipse platform and its satellite projects provide huge tooling advantages in the quest of building a Cloud Application Management Framework. For instance the g-Eclipse project (now archived) provides an excellent model for abstracting resources and operations when interacting with large-scale remote distributed systems. The Graphiti and EMF projects provide an extensive graphics and modeling frameworks respectively, that enable rapid development of state-of-the-art diagram editors for domain models, such as the OASIS TOSCA. The SOA platform Winery project allows modeling application structure using TOSCA. Despite providing a Web-based environment without tight connection with the Eclipse workbench, collaboration with the Winery project community and integration among the two tools and their components thereof, is deemed very valuable.
Finally, the Eclipse foundation is proven to creating and sustaining healthy environments for open source projects. It has a significantly large user-base that faithfully utilize the Eclipse platform and its satellite projects on a daily basis, while at the same time actively engaging/contributing in the Eclipse forums. In line with the efforts of the Flux and Orion projects, we aim in fostering and establishing a solid and experienced Cloud computing community in the Eclipse eco-system.
- Amazon AWS SDK (Java) - Apache License, Version 2.0 (details here)
- Apache® jclouds - Apache License, Version 2.0
- Chef - Apache License, Version 2.0 (details here)
- Ruby Programming Language (used in Chef) - Ruby License (details here)
JCatascopia Cloud Monitoring System - Apache License, Version 2.0 (details here)
- JCatascopia is not a dependency for CAMF and can be swapped with another cloud monitoring system.
We plan to grow our community in the following manner:
- By promoting collaboration among existing open-source Cloud Projects. This involves projects under the Eclipse foundation, and US, EU and/or national funded research projects.
- Initiate open discussions with key Eclipse foundation projects like Flux and/or Orion.
- By fostering a Cloud application management tools community within the Eclipse eco-system.
- Provide a rich user and developer documentation for CAMF.
- Full tutorials on the project site.
- Establishing forums and mailing lists.
- Organizing and attending local Eclipse Demo camps.
- Where possible submit articles for EclipseCon.
Some of our longer term plans include