Elastic Highly Available Cloud Computing

High availability and elasticity are two the cloud computing services technical features. Elasticity is a key feature of cloud computing where provisioning of resources is closely tied to the runtime demand. High availability assure that cloud applications are resilient to failures. Existing cloud solutions focus on providing both features at the level of the virtual resource through virtual machines by managing their restart, addition, and removal as needed. These existing solutions map applications to a specific design, which is not suitable for many applications especially virtualized telecommunication applications that are required to meet carrier grade standards. Carrier grade applications typically rely on the underlying platform to manage their availability by monitoring heartbeats, executing recoveries, and attempting repairs to bring the system back to normal. Migrating such applications to the cloud can be particularly challenging, especially if the elasticity policies target the application only, without considering the underlying platform contributing to its high availability (HA). In this thesis, a Network Function Virtualization (NFV) framework is introduced; the challenges and requirements of its use in mobile networks are discussed. In particular, an architecture for NFV framework entities in the virtual environment is proposed. In order to reduce signaling traffic congestion and achieve better performance, a criterion to bundle multiple functions of virtualized evolved packet-core in a single physical device or a group of adjacent devices is proposed. The analysis shows that the proposed grouping can reduce the network control traffic by 70 percent. Moreover, a comprehensive framework for the elasticity of highly available applications that considers the elastic deployment of the platform and the HA placement of the application’s components is proposed. The approach is applied to an internet protocol multimedia subsystem (IMS) application and demonstrate how, within a matter of seconds, the IMS application can be scaled up while maintaining its HA status

A Model Based Framework for Service Availability Management

High availability of services is an important requirement in several domains, including mission critical systems. The Service Availability Forum (SA Forum) is a consortium of telecommunications and computing companies that defines standard middleware solutions for high availability. Availability Management Framework (AMF) manages the high availability of services by coordinating their application components according to redundancy models. To protect these services, AMF requires a configuration, i.e. a representation of the organization of the logical entities composing an application under its control. AMF configuration design is error-prone and tedious if done manually, due to the complexity of the AMF domain. This PhD thesis explores the effective design and analysis of AMF configurations, proposing a model-based management framework that facilitates this process. We propose a domain-specific modeling language that captures AMF domain concepts, relationships, and constraints, facilitating the management of AMF configurations. We define this language by extending UML through its profiling mechanism, capturing the concepts of AMF configurations and the description of the software for which the configuration will be generated. We introduce a new approach for the automatic generation of AMF configurations based on our UML profile using model transformation techniques. This approach consists of a set of transformations from the software description entities into AMF configurations while satisfying the requirements of the services to be provided as well as the constraints of the deployment infrastructure. We also propose a third-party AMF configuration validation approach consisting of syntactical and semantic validations. Syntactical validation checks the well-formedness of third-party configurations by validating them against AMF standard specification requirements captured in our UML profile. Semantic validation focuses on ensuring the runtime protection of services at configuration time (the SI-Protection problem). SI-Protection has combinatorial aspects and results in an NP-hard problem for most redundancy models, which we have tackled by devising a heuristic-based method, overcoming its complexity. We present proofs of concepts by using different available technologies: IBM Rational Software Architect (RSA) for implementing our UML profiles, Eclipse environment for developing a prototype tool for validating third-party configurations, and Atlas Transformation Language (ATL) for developing a prototype implementation of our model-based configuration generation approach

Automatic generation of AMF compliant configurations

Nowadays, the demand for robust, reliable, and dependable telecommunication systems is higher than ever. End users expect services to be delivered with minimal to no interruption especially in cases where the effect of service outage can have catastrophic consequences such as loss of human lives and monetary losses. Examples of such applications include air traffic control and navigation systems, or systems that perform money transfer transactions such as VISA. Systems are considered highly available if they are up and running 99.999% of the time. One solution to sustain such availability is for such systems to be deployed on specific middleware that allow the redundancy of the system components to ensure the availability of services they provide. However, most existing platforms are proprietary and platform dependent. The goal of the Service Availability Forum (SAF) is to develop open specifications that aim to standardize the interface between the applications and the middleware from one side and the middleware and the underlying hardware from the other side. SAF specifications have also been developed to allow highly available applications to be built using commercial off-the-shelf components. A key component of SAF is the Availability Management Framework (AMF), which is the middleware part responsible for managing the redundant resources of applications and therefore enables high availability. AMF, however, requires a certain organization and groupings of those components known as an AMF configuration. Creating AMF configurations manually tends to be very difficult, error prone and sometimes impossible when the number of components forming the application and the cluster hosting the application is considerably high, which is the case for most real-world telecommunication systems. In this thesis, we devise a solution for automatically generating AMF compliant configurations for applications. The proposed solution encompasses two techniques that vary depending on the way AMF entities are handled. We have implemented both approaches and applied one of them to a case study to demonstrate the applicability of our solutio

A new domain specific language for generating and validating middleware configurations for highly available applications

Nowadays, highly available services are becoming a part of our everyday life and the demand for them tends to always increase as we saw in the recent years. However, building highly available systems remains a challenging task for most system integrators who are expected to build reliable systems from none-reliable components. They have to deal with the constant pressure of the money lost in case of unplanned outages and in other cases; the consequences of such outages can threaten the life of humans. Highly available is a characteristic given to a system/service that is available 99.999% of the time. The standard in the industry for achieving such availability with a system is to build it on a specialized middleware. Such middleware will manage the redundancy of the components and will ensure their availability. On the other hand, the majority of those systems are platform-dependent and mostly proprietary. The service availability forum (SAForum) defines open standards for building and maintaining HA systems using the SAForum middleware. Nevertheless, this task remains tedious and error prone due to the complexity of this middleware configuration. In this thesis, we present a solution to automate the generation of description files for HA systems, which enables the automated generation of the middleware configuration of the previous approach. In order to achieve this objective, we propose an approach based on a new domain specific language extending the UML component diagrams, along with a corresponding set of model transformations. We also present our prototype implementation and a case study as a proof of concept verifying the approach

Automated Configuration Design and Analysis for Service High-Availability

The need for highly available services is ever increasing in various domains ranging from mission critical systems to transaction based ones such as online banking. The Service Availability Forum (SAForum) has defined a set of services and related Application Programming Interface (API) specifications to address the growing need of commercial-off-the-shelf high availability solutions. Among these services, the Availability Management Framework (AMF) is the service responsible for managing the high availability of the application services. To achieve this task, an AMF implementation requires a specific logical view of the organization of the application’s services and components, known as an AMF configuration. Any AMF configuration must be compliant to the concepts and constraints defined in the AMF specifications. The process of defining AMF configurations is error prone and requires extensive domain knowledge. Another major issue is being able to analyze the designed AMF configuration to quantify the anticipated service availability. This requires a different set of modeling and analysis skills that system integrators might not necessarily possess. In this dissertation we propose the automation of this process. The premise is to define a generation method within which we embed the domain knowledge and the domain constraints, and by that generating AMF configurations that are valid by construction. We also define an approach for the service availability analysis of AMF configurations. Our method is based on generating an analysis stochastic model that captures the middleware behavior and the application configuration. This model is thereafter solved to quantify the service availability

A Framework for Requirements Decomposition, SLA Management and Dynamic System Reconfiguration

To meet user requirements, systems can be built from Commercial-Off-The-Shelf (COTS) components, potentially from different vendors. However, the gap between the requirements referring to the overall system and the components to build the system from can be large. To close the gap, it is required to decompose the requirements to a level where they can be mapped to components. When the designed system is deployed and ready for operations, its services are sold and pro-vided to customers. One important goal for service providers is to optimize system resource utilization while ensuring the quality of service expressed in the Service Level Agreements (SLAs). For this purpose, the system can be reconfigured dynamically according to the cur-rent workload to satisfy the SLAs while using only necessary resources. To manage the re-configuration of the system at runtime, a set of previously defined patterns called elasticity rules can be used. In elasticity rules, the actions that need to be taken to reconfigure the sys-tem are specified. An elasticity rule is generally invoked by a trigger, which is generated in reaction to a monitoring event. In this thesis, we propose a model-driven management framework which aims at user re-quirements satisfaction, SLA compliance management and enabling dynamic reconfiguration by reusing the design information at runtime. An approach has been developed to derive automatically a valid configuration starting from low level requirements called service configurations. However, the service configurations are far from requirements a user would express. To generate a system configuration from user requirements and alleviate the work of designer, we generate service configurations by de-composing functional user requirements to the level where components can be selected and put together to satisfy the user requirements. We integrated our service configurations gen-erator with the previous configuration generator. In our framework, we reuse the information acquired from system configuration and dimen-sioning to generate elasticity rules offline. We propose a model driven approach to check the compliance of SLAs and generate triggers for invoking applicable elasticity rules when system reconfiguration is required. For handling multiple triggers generated at the same time, we propose a solution to automatically correlate the actions of invoked elasticity rules, when re-quired. The framework consists of a number of metamodels and a set of model transfor-mations. We use the Unified Modeling Language (UML) and its profiling mechanism to de-scribe all the artifacts in the proposed framework. We implement the profiles using Eclipse Modeling Framework (EMF) and Papyrus. To implement the processes, we use the Atlas Transformation Language (ATL). We also use the APIs of the Object Constraint Language (OCL) in the Eclipse environment to develop a tool for checking constraints and generating triggers

Pattern-Based Generation of AMF Configurations

Information Technology service providers aim at attracting customers by providing services that meet a high level of quality. They should not only satisfy functional requirements, but also non-functional requirements. An important non-functional requirement is the level of service availability. Service Availability Forum (SAForum), a consortium of communications and computing companies, has developed a set of services and standard Application Programming Interfaces (APIs) to address the issue of high availability for the Commercial-off-the-shelf (COTS)-based systems and enable portability. Among the services standardized by the SAForum, the Availability Management Framework (AMF) has the important role of ensuring the high availability of an application and its services, by managing the redundant application components deployed on the cluster. To achieve this task, AMF requires a configuration that represents the logical organization of the application components and their services. The design of AMF configurations is a complex and error prone task. Automation of the process is the first step towards improving the quality of such configurations. It also enables exploring different potential solutions for a given set of requirements. An automated approach to generate configurations for applications to deploy on top of the SAForum middleware has been proposed in the context of the MAGIC project. This approach, however, may generate several configurations among which some may not meet the required level of service availability. Therefore, the system designer needs to evaluate the generated configurations using an availability analysis tool to select an appropriate one for deployment. One may want to improve this process by targeting directly in the generation process, the configurations that can guarantee the requested level of service availability. The objective of this thesis is to propose solutions to enhance this configuration generation process and generate configurations that can guarantee the required level of service availability without using advanced analysis tools. For this purpose, we propose configuration design patterns to improve the expected level of service availability and quantitative methods that eliminate some configurations that do not meet the availability requirement. The configuration design patterns improve the expected level of service availability by selecting the best configuration options. The methods estimate service availability for the different possible combinations of software components, which can provide the requested services, taking into account the properties of these components and the behavior of the SAForum middleware. As a proof of concept, we have embedded our proposed solutions into a prototype tool as an eclipse plug-in and validated our work with case studies

Design and Deployment of AMF Configurations in the Cloud

With the ever growing popularity of cloud computing, the trend of deploying applications in the cloud is increasing more than ever. Cloud offers computing resources that can be provisioned as required and scaled according to the workload demand. This feature attracts service providers to deploy their applications in the cloud. As users continue to rely more on the services provided by these applications, it is essential to keep the applications running with minimal service outage. Service Availability Forum (SA Forum) has defined a framework called Availability Management Framework (AMF) which can be used to manage service availability. AMF is agnostic to the services provided by the applications. However, it manages the service availability of applications by orchestrating the redundant entities through a configuration called AMF configuration. The design of AMF configurations for a physical cluster based on the functional and non-functional requirements, such as minimum level of service availability, has been proposed in the literature. In these solutions, the number of physical hosts required to deploy an application is given as input and the resource utilization is not taken into consideration. However, for deploying applications in the cloud the number of physical hosts is not fixed and should vary depending on the workload. Therefore, the issue of minimizing the number of physical hosts while meeting the requested level of service availability arises. In particular, the service availability depends not only on the entities involved in providing the service but also on the interferences caused by the collocation of entities. To minimize these interferences, the collocated entities can be grouped into fault isolation units such as VMs. This in turn may increase the number of resources required. In this thesis, an approach to generate AMF configuration for the cloud is proposed. In this approach, a novel method is used to calculate the number of AMF entities that meets the availability and resource utilization requirements. In addition, a method to estimate service availability is proposed. It aims to predict the availability of service by considering the potential factors that affect availability, including the interferences due to collocation. Furthermore, an approach to deploy AMF applications in the cloud is proposed. As a proof of concept, a prototype that demonstrates the generation and deployment of AMF configurations in an OpenStack cloud has been developed. This prototype includes the existing Monitoring and Elasticity Engine, previously developed in the MAGIC project

Automated AMF Configuration Difference Generation

Many domains require computer clusters to meet clients’ service level expectations. As cluster size increases, component failure becomes more likely. Rapid failure recovery is required to maintain high availability. The SA Forum has created specifications enabling management of multi-vendor solutions. These long-lived systems require tailored upgrade campaigns to keep their configuration up-to-date. Passed works on SA Forum’s Availability Management Framework (AMF) have created an automated AMF configuration generator and upgrade campaign generator. However, to generate an upgrade campaign for an already configured cluster based on a new target configuration, a configuration difference generator is needed. Furthermore, while Distinguished Names (DNs) usually uniquely identify object in a configuration, configuration generators do not guarantee that DNs in the new configuration will match. DN modification is not possible in a system without object replacement, causing service loss. Non-DN based inter-configuration object association is needed to restore old DNs. Our objective is to devise a technique to perform difference generation with limited knowledge of DNs and to find what data is needed to achieve this. To accomplish this, we analyse the AMF configuration model, then propose assumptions in a top down approach based on maintaining service availability during upgrade. We propose a two phase technique that first associates objects in-between configurations and then outputs the differences. We have implemented a tool that implements this technique on the Eclipse Platform and integrates with MAGIC’s Automated Upgrade Campaign Generator. We then present a case study based on the PHASE example