Towards RSA-based HA configuration in Cloud

Yihan Wu, Ying Zhang, Yingfei Xiong, Xiaodong Zhang, Gang Huang

TL;DR

This paper introduces a framework that leverages Runtime Software Architecture (RSA) to automate and dynamically adjust High Availability (HA) configurations in cloud environments. By abstracting complex HA mechanisms into reusable architectural models, the framework automatically selects and deploys the optimal HA strategy to balance system availability against resource costs.

What Problem Does This Paper Address?

Ensuring High Availability (HA)—the guarantee that a system remains operational and accessible even during failures—is critical for cloud platforms. However, managing HA in modern clouds is incredibly challenging for several reasons:

  1. Complexity across layers: HA mechanisms exist at multiple levels, including the physical machine (PM), virtual machine (VM), and application layers.
  2. Trade-offs: Different mechanisms (like rebooting, hot-sparing, or snapshotting) have vastly different resource costs and recovery times.
  3. Fragile configuration: Traditional HA configuration relies on text-based files that are manual, complex, and highly error-prone.
  4. Dynamic environments: Cloud workloads change constantly. A static HA configuration set during deployment cannot adapt to runtime changes, leading to either wasted resources or insufficient protection.

The authors address these gaps by moving away from static, manual text configurations toward an automated, model-driven approach that adapts to the system's live state.

Methods

The core innovation is an RSA-based HA configuration framework. Instead of interacting directly with low-level cloud APIs or configuration files, the framework operates on a live-synchronized architectural model of the system.

The workflow consists of four main steps, illustrated in the architecture diagram below:

Fig. 3. Process of configuration of cloud with HA styles
  1. Construction of RSA: Using a tool called SM@RT, the framework maintains a bidirectional, causal connection with the running cloud system. Any change in the actual cloud is immediately reflected in the Runtime Software Architecture (RSA) model.
  2. Selection of HA Styles (HAS): The authors abstract concrete HA mechanisms into eight distinct HA Styles (HAS) across four layers (Application, VM, PM, and PM2PM). An automated HA Style Selector evaluates user requirements and live system metrics to choose the best style.
  3. Configuration via Model Merging: The selected HAS (represented as a UML model) is injected into the live RSA model using an automated model-merging process guided by Query/View/Transformation (QVT) languages.
  4. Synchronization: The SM@RT engine automatically translates the changes in the RSA model back into concrete system configurations and actions within the cloud platform.

Datasets

The framework was not evaluated on standard open-source datasets, as it is a system-level infrastructure piece. Instead, the authors implemented and evaluated their prototype on Yan-Cloud, an Infrastructure-as-a-Service (IaaS) platform developed by their lab based on Apache CloudStack.

Key Insights and Ideas

  • HA as an Architectural Style: By treating HA mechanisms (like VM migration or application redundancy) as abstract architectural styles rather than low-level scripts, the system can reason about fault tolerance at a higher level of abstraction.
  • Dynamic Policy Shifting: The paper highlights that the "correct" HA strategy changes over time. For example, if a VM runs only one critical application, Application Redundancy (deploying a backup app instance) is highly cost-effective. However, if that same VM later hosts multiple critical applications, the framework can dynamically revoke the application-level policy and merge a VM Redundancy policy instead, saving overall cloud resources.

Key Results

The authors successfully demonstrated a working prototype on Yan-Cloud. The system was able to dynamically transition between different HA states (e.g., deploying a webProxy to manage active/backup Apache web servers) at runtime based on changing application demands.

The framework successfully optimized the trade-off between:

  • Availability: Measured by the success rate of service requests.
  • Resource Cost: Calculated via CPU and memory consumption.

Note: Detailed quantitative benchmarks and extensive experimental data were omitted from this paper, as the authors noted they were saving those findings for a subsequent publication.

Limitations and Future Work

While the framework proves the viability of model-driven HA management, the authors acknowledge several areas for improvement:

  • Incomplete Classification: The current library only supports eight HA styles. Real-world clouds utilize a wider variety of nuanced fault-tolerance mechanisms that need to be modeled.
  • Early-Stage Selection Algorithm: The algorithm used by the HA Style Selector is still basic. The authors plan to develop a more sophisticated, user-defined optimization algorithm to better handle complex trade-offs.
  • Automation Depth: Further work is required to make the configuration process fully autonomous and to rigorously evaluate its performance overhead in large-scale production environments.

Summary updated

BibTeX
@inproceedings{wu2013towards,
  author = {Yihan Wu and Ying Zhang and Yingfei Xiong and Xiaodong Zhang and Gang Huang},
  title = {{Towards RSA-based HA configuration in Cloud}},
  booktitle = {[email protected]},
  year = {2013},
  url = {https://openreview.net/forum?id=W9p3DW7m86},
}
Figure