The Network Function Virtualization (NFV) framework is an enabler for the automation of Network Service (NS) management. In the context of NFV, an NS is realized by interconnecting Virtual Network Functions (VNF) using Virtual Links (VL). Availability and continuity are among the important characteristics of an NS. These characteristics depend on the availability of the VNFs and VLs composing the NS, which are usually selected at NS design time. VNFs and VLs utilize the resources of the underlying infrastructure, and their availability (partially) depends on the availability of these resources. To design an NS to fulfill availability and continuity requirements, the availability required from the resources is constrained at design time. However, the characteristics of these resources may change at runtime due to the dynamicity of NFV infrastructure. Thus, impacting the availability of the VNFs and the VLs, which in turn may impact the availability and continuity of the NS. To fulfill these requirements at runtime despite the changes in the infrastructure, the NS should be adapted. In this paper, we propose a framework for the runtime adaptation of NSs that reacts to changes and adapts the NS configuration so that it can fulfill its availability and continuity requirements during the NS lifetime. We also propose a method to develop machine learning models that are used within the framework to determine the required adjustments at runtime. We implemented the proposed framework, the method for developing the machine learning models, a testbed, and NSs to assess the feasibility and validity of our approach through experiments.

Live testing is performed in the production environment. In such environment, test activities have to be orchestrated properly to avoid interferences with normal usage traffic. Conducting live testing activities manually is error prone because of the size and the complexity of the system as well as the required complex orchestration of different tasks. Furthermore, it would be impossible to react to failures and contain them in due time without automation. Live testing requires a high level of automation. This automation comes with several challenges especially in contexts such as cloud and zero touch networks because of the diversity of the software composing them. In this paper we discuss the challenges of automating live testing for cloud systems. We propose an architecture that relies on a modeling framework to decouple the specification of testing activities from the platforms needed to conduct them. We propose a solution for conducting testing activities on a live system according to such a specification.

Configurations play an important role in the behavior and operation of configurable systems. Prior to deployment a configured system is tested in the development environment. However, because of the differences between the development environment and the production environment, the configuration of the system needs to be adapted for the production environment. It is therefore important to re-test the configured system in the production environment. Since the system has already been tested in the development environment one should avoid reapplying all the test cases, it is desirable to reduce the test suite to be used in the production environment as much as possible. This is the goal of the method we propose in this paper. For this, we explore the similarities between the configuration used in the development environment and the configuration for the production environment to eliminate test cases. Indeed, the difference between the two configurations is only at the environment level, i.e. only the configuration parameters that influence the interactions between the system and its environment are changed for the deployment in the production environment. We propose a method that is based on a classification of the configuration parameters (based on their dependency to the environment) and use it to reduce the development time test suite before reapplying it in the production environment.

Kubernetes is an open source platform that hides the complexity of orchestrating containerized microservices while managing their availability. Stateless microservices can be executed in a resilient manner with Kubernetes. However, the same is not true for stateful microservices. Containers are characterized by having an ephemeral state and the state aspect of stateful microservices makes orchestration more complex than what the initial Kubernetes controllers were built for. In this paper, we investigate the current Kubernetes support for stateful microservices and identify the problems. We propose a solution to enrich Kubernetes with a State Controller that allows for state replication and automatic service redirection to the healthy entities through the management of secondary labels. We have conducted experiments under the default configuration of Kubernetes as well as under its most responsive one to evaluate our solution and compare the different architectures from an availability perspective. We also perform a comparative evaluation with OpenSAF, which is a proven solution for enabling high-availability. The results of our investigations show that our solution improves the recovery time of stateful microservices by 55% and even up to 99% in certain cases.

Microservices represent a new architectural style where small and loosely coupled modules can be developed and deployed independently to compose an application. This architectural style brings various benefits such as maintainability and flexibility in scaling and aims at decreasing downtime in case of failure or upgrade. One of the enablers is Kubernetes, an open source platform that provides mechanisms for deploying, maintaining, and scaling containerized applications across a cluster of hosts. Moreover, Kubernetes enables healing through failure recovery actions to improve the availability of applications. As our ultimate goal is to devise architectures to enable high availability (HA) with Kubernetes for microservice based applications, in this paper we examine the availability achievable through Kubernetes under its default configuration. We have conducted a set of experiments which show that the service outage can be significantly higher than expected.

Elasticity is a key feature of cloud systems. It allows service providers to adapt resource provisioning to workload changes without impacting the users. For this purpose, the system is periodically reconfigured according to workload variations using elasticity rules or policies. The challenge is to come up with those elasticity rules that efficiently provision resources to handle the workload variations and meet the quality of service expressed in the Service Level Agreements (SLAs). The definition of such elasticity rules is a challenging task. In this paper, we propose the generation of the elasticity rules automatically at system configuration design time, i.e. offline. We propose a model based approach that generates automatically these elasticity rules using the information acquired from the dimensioning and configuration of the system.

Domain-specific modelling with domain-specific languages (DSL) is rapidly gaining popularity in both research and industry for representing models of a target domain. However for a broader adoption, MDE tools need to provide adequate support for building these DSLs as well as for using the DSLs.

A Virtualized Network Function (VNF) is deployed as a cluster of VMs in the Network Functions Virtualization Infrastructure (NFVI). As in traditional telecom, VNFs are expected to provide the required functions at the requested level of availability. For this, one has to incorporate proper redundancy, and appropriate recovery and coordination mechanisms among the redundant entities. The Service Availability Forum (SA Forum) has standardized such mechanisms into a set of middleware services. Among them, the Availability Management Framework (AMF) has the responsibility of managing the availability of application services based on a configuration, called AMF configuration. We propose the use of AMF to manage the availability of the services provided by VNFs. For this, we map the AMF concepts to the Network Function Virtualization (NFV) domain and propose a method for the generation of AMF configurations for AMF managed VNFs. The approach generates an AMF configuration that meets the required level of availability of the requested service workload while aims at maximizing the resource utilization.

Cloud systems are upgraded regularly to improve their performance, fix bugs, deploy new software versions, etc. Their hosted services, for example, telecommunication services, may have stringent non-functional requirements such that they do not tolerate more than five minutes of downtime in a year regardless whether they are provided by a cloud system or the outage is due to an upgrade. Such services must remain highly available under any circumstance, which imposes availability requirements on the provider cloud system. The dynamicity of the environment is one of the main challenges for maintaining High Availability (HA) in cloud deployments during upgrades. To maintain availability during upgrades, most cloud providers use rolling upgrade, and to avoid any unexpected interference between the upgrade process and the cloud's scaling mechanism, scaling is disabled for the time of the upgrade. In this paper, we propose a novel approach for rolling upgrades applicable to - among others - IaaS cloud systems to address HA. This approach mitigates the interference between the upgrade process, any failure handling and scaling by dynamically adjusting the upgrade process to the changes in the cloud environment. Accordingly, the upgrade process can start/resume only when the system has sufficient resources to perform an upgrade iteration and suspends the process when this is not the case. As a result, scaling does not need to be disabled during upgrades, rather the scaling operations regulate the pace of the upgrade.

Recently, the paradigm of Network Functions Virtualisation (NFV) has emerged for the rapid provisioning and management of network services. It is based on the cloud paradigm and the virtualisation technology. The European Telecommunications Standards Institute (ETSI) has been actively defining the NFV framework, which includes several functional blocks for network service provisioning and management. The interfaces and the roles of these functional blocks are being defined as well as the artifacts they manipulate. However, the workflow defining the relations and dependencies between these different blocks as well as the successive processing of the artifacts throughout this workflow have not been specified. This is the purpose of this paper where we define an NFV standard compliant process for network service design and deployment. The process starts from the tenant network service requirements all the way to the network service deployment.

A system configuration is a set of configuration entities, their relations and the rules the system should obey. At runtime the configuration may be modified to meet new requirements, in response to performance degradations, or due to upgrade. Such modifications should maintain the consistency of the configuration to avoid any malfunction and service outage. Thus there is a need for runtime validation, which checks the modifications against the consistency rules of the system. This runtime validation should not only check the correctness of the modifications w.r.t. The consistency rules but it should also impose a minimal overhead especially in case of real-time and highly available systems. In this paper we introduce a partial validation approach for checking the system configuration consistency at runtime. Our approach is model based and uses UML profiles and OCL constraints.

Cloud computing is a popular paradigm for providing computational services. Cloud computing frameworks offer cost efficiency, better resource utilization and scalability. Availability remains as one of the main challenges for the cloud. Solutions, such as Heat, have been proposed and integrated with cloud controllers like Open Stack. These solutions protect services against application and infrastructure failure. However, the recovery for the application is tied to recovery of the underlying infrastructure, therefore, the service recovery and outage time may be substantial. In this paper we propose an architecture which integrates an existing middleware solution for high availability, OpenSAF, with OpenStack, for the management of the availability of the applications and the infrastructure. We show that in comparison with Heat, the proposed solution improves the service recovery and outage time and offers flexibility in terms of redundancy models and recovery actions.

The design of configurations for high availability management is a complex and error prone task. Automation of the process is a first step towards improving the quality of such configurations and for exploring the different potential solutions for a given set of requirements. An automated approach for configuration generation for applications deployed on top of the Service Availability Forum (SAForum) middleware has been proposed in the literature. This approach, however, may generate several configurations among which some may not meet the required level of service availability. Therefore, these configurations need to be analyzed to select one for the deployment. This is a complex process as many configurations may be generated and considered throughout the process. In this paper, we propose to enhance this configuration generation approach with a method to eliminate early in the generation process some configurations that cannot meet the service availability requirement. The method estimates the 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 behaviour of the SAForum middleware.

Cloud services are becoming one of the most popular means of delivering computational services to users who demand services with higher availability. Virtualization is one of the key enablers of the cloud infrastructure. Availability of the virtual machines along with the availability of the hosted software components are the fundamental ingredients for achieving highly available services in the cloud. There are some availability solutions introduced by virtualization vendors like VMware HA and VMware FT. At the same time the SAForum specifications and OpenSAF as a compliant implementation offer a standard based open solution for service high availability. In this paper, we investigate these solutions for availability through experiments, compare them according to metrics and based on the results propose architectures that combine them to provide highly available applications in virtualized environments.

SUMMARY The need for highly available services is ever increasing in various domains ranging from mission‐critical systems to transaction‐based ones such as banking. The Service Availability Forum has defined a set of services and related 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 by coordinating redundant application components deployed on the AMF cluster. 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. Developing manually such a configuration is a complex error‐prone task that requires extensive domain knowledge. In this paper, we present an approach for the automatic generation of AMF configurations and alleviate the task of configuration designers. One important aspect of the AMF configuration is ranking the service units, when it is required by the redundancy model, for the assignment of the workload by AMF at runtime. Our approach includes a technique for generating these rankings in such a way that guarantees load balancing even after the occurrence of a failure. Copyright © 2012 John Wiley & Sons, Ltd.

In today's information based world the demand on highly available services is ever increasing. Fault tolerant systems are capable of providing the expected services even in the presence of a failure. This is achieved through the redundancy of the service providers, where service assignments i.e. workloads are shifted to redundant healthy service providers when a failure occurs. The assignment and the shift are performed according to a redundancy model. A well-known redundancy model is the N+M where we have N active service providers and M standbys. In case of a failure of an active provider, the services are reassigned to its standbys. Maintaining a balanced workload before and after a failure in the N+M redundancy is a challenging task. Especially when the solution is decided at configuration time, and no runtime information is available. This is exactly the issue we tackle in this paper. We present three different approaches aiming at solving this problem with different priorities of the relevant constraints. Our solutions do not require any runtime information and can maintain a balanced workload even after a failure by anticipating the workload redistribution.

Highly available services are nowadays provided by large and complex systems built from Commercial-Of-The-Shelf (COTS) components. Such systems are deployed on top of standardized middleware services that manage service availability by monitoring the component health and by dynamically shifting workload from a faulty component to a healthy one. This management is achieved through the usage of a configuration model. Characterizing the availability of such systems before deployment is an important question. Indeed, components may be characterized with a failure rate, but this information does not translate directly to service failure/outage which is the first step towards service availability evaluation. In this paper, we propose an approach to derive from the component failure rates the recovery duration and service outage while taking into account the configuration characteristics and middleware service recovery procedures.

The service availability forum (SAF) has defined a set of service API specifications addressing 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 by coordinating redundant application components. 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. Developing manually such a configuration is a complex, error prone, and time consuming task. In this paper, we present an approach for automatic generation of AMF configurations from a set of requirements given by the configuration designer and the description of the software as provided by the vendor. Our approach alleviates the need of configuration designers dealing with a large number of AMF entities and their relations.

The Availability Management Framework (AMF) is a service responsible for managing the availability of services provided by applications that run under its control. Standardized by the Service Availability Forum (SAF), AMF requires for its operations a complete and compliant AMF configuration of the applications to be managed. In this paper, we describe two complementary and integrated tools for AMF configurations generation and validation. Indeed, writing manually an AMF configuration is a tedious and error prone task as a large number of requirements defined in the standard have to be taken into consideration during the process. One solution for ensuring compliance with the standard is the validation of the configurations against all the AMF requirements. For this, we have designed and implemented a domain model for AMF configurations and use it as a basis for an AMF configuration validator. To further ease the task of a configuration designer, we have devised and implemented a method for generating automatically AMF configurations.