Auto-Scaling Web Applications in Clouds: A Taxonomy and Survey <s> Vertical Scaling-VM Resizing <s> One of the most important goals of data-center management is to reduce cost through efficient use of resources. Virtualization techniques provide the opportunity of carving individual physical servers into multiple virtual containers that can be run and managed separately. A key challenge that comes with virtualization is the simultaneous on-demand provisioning of shared resources to virtual containers and the management of their capacities to meet service quality targets at the least cost. This paper proposes a two-level resource management system with local controllers at the virtual-container level and a global controller at the resource-pool level. Autonomic resource allocation is realized through the interaction of the local and global controllers. A novelty of the controller designs is their use of fuzzy logic to efficiently and robustly deal with the complexity of the virtualized data center and the uncertainties of the dynamically changing workloads. Experimental results obtained through a prototype implementation demonstrate that, for the scenarios under consideration, the proposed resource management system can significantly reduce resource consumption while still achieving application performance targets. <s> BIB001 </s> Auto-Scaling Web Applications in Clouds: A Taxonomy and Survey <s> Vertical Scaling-VM Resizing <s> Data center virtualization allows cost-effective server consolidation which can increase system throughput and reduce power consumption. Resource management of virtualized servers is an important and challenging task, especially when dealing with fluctuating workloads and complex multi-tier server applications. Recent results in control theory-based resource management have shown the potential benefits of adjusting allocations to match changing workloads. This paper presents a new resource management scheme that integrates the Kalman filter into feedback controllers to dynamically allocate CPU resources to virtual machines hosting server applications. The novelty of our approach is the use of the Kalman filter-the optimal filtering technique for state estimation in the sum of squares sense-to track the CPU utilizations and update the allocations accordingly. Our basic controllers continuously detect and self-adapt to unforeseen workload intensity changes. Our more advanced controller self-configures itself to any workload condition without any a priori information. Indicatively, it results in within 4.8% of the performance of workload-aware controllers under high intensity workload changes, and performs equally well under medium intensity traffic. In addition, our controllers are enhanced to deal with multi-tier server applications: by using the pair-wise resource coupling between application components, they provide a 3% on average server performance improvement when facing large unexpected workload increases when compared to controllers with no such resource-coupling mechanism. We evaluate our techniques by controlling a 3-tier Rubis benchmark web site deployed on a prototype Xen-virtualized cluster. <s> BIB002 </s> Auto-Scaling Web Applications in Clouds: A Taxonomy and Survey <s> Vertical Scaling-VM Resizing <s> Virtualized data centers enable sharing of resources among hosted applications. However, it is difficult to satisfy service-level objectives(SLOs) of applications on shared infrastructure, as application workloads and resource consumption patterns change over time. In this paper, we present AutoControl, a resource control system that automatically adapts to dynamic workload changes to achieve application SLOs. AutoControl is a combination of an online model estimator and a novel multi-input, multi-output (MIMO) resource controller. The model estimator captures the complex relationship between application performance and resource allocations, while the MIMO controller allocates the right amount of multiple virtualized resources to achieve application SLOs. Our experimental evaluation with RUBiS and TPC-W benchmarks along with production-trace-driven workloads indicates that AutoControl can detect and mitigate CPU and disk I/O bottlenecks that occur over time and across multiple nodes by allocating each resource accordingly. We also show that AutoControl can be used to provide service differentiation according to the application priorities during resource contention. <s> BIB003 </s> Auto-Scaling Web Applications in Clouds: A Taxonomy and Survey <s> Vertical Scaling-VM Resizing <s> Cloud systems require elastic resource allocation to minimize resource provisioning costs while meeting service level objectives (SLOs). In this paper, we present a novel PRedictive Elastic reSource Scaling (PRESS) scheme for cloud systems. PRESS unobtrusively extracts fine-grained dynamic patterns in application resource demands and adjust their resource allocations automatically. Our approach leverages light-weight signal processing and statistical learning algorithms to achieve online predictions of dynamic application resource requirements. We have implemented the PRESS system on Xen and tested it using RUBiS and an application load trace from Google. Our experiments show that we can achieve good resource prediction accuracy with less than 5% over-estimation error and near zero under-estimation error, and elastic resource scaling can both significantly reduce resource waste and SLO violations. <s> BIB004 </s> Auto-Scaling Web Applications in Clouds: A Taxonomy and Survey <s> Vertical Scaling-VM Resizing <s> Utility computing was a vision stated more than 40 years ago. It refers to the idea that computing resources and services can be delivered, utilized, and paid for as utilities such as water or electricity. The recent emergence of cloud computing is making this vision realizable. Examples of efforts in this area include Infrastructure as a Service (IaaS) providers like Amazon EC2 and Software as a Service (SaaS) providers like Google AppEngine and Microsoft Azure. More recently, there is a growing interest in the use of cloud computing for scientific computing, as evidenced by a large-scale funded project like Magellan, and new workshops. <s> BIB005 </s> Auto-Scaling Web Applications in Clouds: A Taxonomy and Survey <s> Vertical Scaling-VM Resizing <s> Elastic resource scaling lets cloud systems meet application service level objectives (SLOs) with minimum resource provisioning costs. In this paper, we present CloudScale, a system that automates fine-grained elastic resource scaling for multi-tenant cloud computing infrastructures. CloudScale employs online resource demand prediction and prediction error handling to achieve adaptive resource allocation without assuming any prior knowledge about the applications running inside the cloud. CloudScale can resolve scaling conflicts between applications using migration, and integrates dynamic CPU voltage/frequency scaling to achieve energy savings with minimal effect on application SLOs. We have implemented CloudScale on top of Xen and conducted extensive experiments using a set of CPU and memory intensive applications (RUBiS, Hadoop, IBM System S). The results show that CloudScale can achieve significantly higher SLO conformance than other alternatives with low resource and energy cost. CloudScale is non-intrusive and light-weight, and imposes negligible overhead ( <s> BIB006 </s> Auto-Scaling Web Applications in Clouds: A Taxonomy and Survey <s> Vertical Scaling-VM Resizing <s> Elasticity is one of the distinguishing characteristics associated with Cloud computing emergence. It enables cloud resources to auto-scale to cope with workload demand. Multi-instances horizontal scaling is the common scalability architecture in Cloud; however, its current implementation is coarse-grained, while it considers Virtual Machine (VM) as a scaling unit, this implies additional scaling-out overhead and limits it to specific applications. To overcome these limitations, we propose Elastic VM as a fine-grained vertical scaling architecture. Our results proved that Elastic VM architecture implies less consumption of resources, mitigates Service Level Objectives (SLOs) violation, and avoids scaling-up overhead. Furthermore, it scales broader range of applications including databases. <s> BIB007 </s> Auto-Scaling Web Applications in Clouds: A Taxonomy and Survey <s> Vertical Scaling-VM Resizing <s> The elastic scaling of services permits us (1) to meet service provisioning requirements (i.e., not to violate its SLAs), and (2) to efficiently use available resources (i.e., to minimize the cost of running the application). In this paper, we describe a novel online controller design built on top of the Xen hyper visor. The controller facilitates the elastic provisioning of applications using a combination of adapting the resource constraints of VMs and dynamically plugging in new virtual CPUs. We have implemented our design and evaluated our approach using real world workload traces from the RUBiS online auction benchmark. The results show that our controller allows to reduce total CPU time in comparison to statically allocated CPU with of minimum SLA violation rate and provides stable response time for high priority VM, when we apply it to provision prioritized VMs. <s> BIB008 </s> Auto-Scaling Web Applications in Clouds: A Taxonomy and Survey <s> Vertical Scaling-VM Resizing <s> Recent research results in cloud community found that cloud users increasingly force providers to shift from fixed bundle instance types(e.g. Amazon instances) to flexible bundles and shrinked billing cycles. This means that cloud applications can dynamically provision the used amount of resources in a more fine-grained fashion. This observation calls for approaches which are able to automatically implement fine granular VM resource allocation with respect to user-provided SLAs. In this work we propose VScaler, a framework which implements autonomic resource allocation using a novel approach to reinforcement learning. <s> BIB009 </s> Auto-Scaling Web Applications in Clouds: A Taxonomy and Survey <s> Vertical Scaling-VM Resizing <s> Cloud computing has a key requirement for resource configuration in a real-time manner. In such virtualized environments, both virtual machines (VMs) and hosted applications need to be configured on-the-fly to adapt to system dynamics. The interplay between the layers of VMs and applications further complicates the problem of cloud configuration. Independent tuning of each aspect may not lead to optimal system wide performance. In this paper, we propose a framework, namely CoTuner, for coordinated configuration of VMs and resident applications. At the heart of the framework is a model-free hybrid reinforcement learning (RL) approach, which combines the advantages of Simplex method and RL method and is further enhanced by the use of system knowledge guided exploration policies. Experimental results on Xen-based virtualized environments with TPC-W and TPC-C benchmarks demonstrate that CoTuner is able to drive a virtual server cluster into an optimal or near-optimal configuration state on the fly, in response to the change of workload. It improves the systems throughput by more than 30 percent over independent tuning strategies. In comparison with the coordinated tuning strategies based on basic RL or Simplex algorithm, the hybrid RL algorithm gains 25 to 40 percent throughput improvement. <s> BIB010 </s> Auto-Scaling Web Applications in Clouds: A Taxonomy and Survey <s> Vertical Scaling-VM Resizing <s> Applications in virtualized data centers are often subject to Service Level Objectives (SLOs) regarding their performance (e.g., latency or throughput). In order to fulfill these SLOs, it is necessary to allocate sufficient resources of different types (CPU, memory, I/O, etc.) to an application. However, the relationship between the application performance and the resource allocation is complex and depends on multiple factors including application architecture, system configuration, and workload demands. In this paper, we present a model-based approach to ensure that the application performance meets the user-defined SLO efficiently by runtime "vertical scaling" (i.e., adding or removing resources) of individual virtual machines (VMs) running the application. A layered performance model describing the relationship between the resource allocation and the observed application performance is automatically extracted and updated online using resource demand estimation techniques. Such a model is then used in a feedback controller to dynamically adapt the number of virtual CPUs of individual VMs. We have implemented the controller on top of the VMware vSphere platform and evaluated it in a case study using a real-world email and groupware server. The experimental results show that our approach allows the managed application to achieve SLO satisfaction in spite of workload demand variation while avoiding oscillations commonly observed with state-of-the-art threshold-based controllers. <s> BIB011 </s> Auto-Scaling Web Applications in Clouds: A Taxonomy and Survey <s> Vertical Scaling-VM Resizing <s> Growing tenant workload needs and an increasingly competitive market will force cloud providers to operate their data centers at significantly higher utilization levels than seen today. We argue that a key enabler of such cloud ecosystems would be facilities for tenants to engage in fine-grained resource scaling in addition to those offered by current providers. The basic unit of resource scaling exposed by current cloud providers is the canonical interface of virtual machines (VMs) with relatively static resource capacities. This paper describes opportunities and challenges in augmenting this interface to also include fine-grained scaling of CPU and memory within an already procured VM. Qualitative arguments for why this would offer cost benefits for both the provider and its tenants are presented. We focus on the cost-effective operation of a tenant in such an environment via the design of a feedback controller. The efficacy of our ideas is illustrated by implementing a case study in a Memcached tenant workload. Our results are promising and point to an interesting and broad area for further research - e.g., with the real-world workload in our evaluation, up to 50% utility improvement can be achieved by just applying memory scaling, a further 66% improvement can be achieved by coordinating fine-grained CPU and memory scaling. <s> BIB012 </s> Auto-Scaling Web Applications in Clouds: A Taxonomy and Survey <s> Vertical Scaling-VM Resizing <s> Elasticity in the cloud is often achieved by on-demand autoscaling. In such context, the goal is to optimize the Quality of Service (QoS) and cost objectives for the cloud-based services. However, the difficulty lies in the facts that these objectives, e.g., throughput and cost, can be naturally conflicted; and the QoS of cloud-based services often interfere due to the shared infrastructure in cloud. Consequently, dynamic and effective trade-off decision making of autoscaling in the cloud is necessary, yet challenging. In particular, it is even harder to achieve well-compromised trade-offs, where the decision largely improves the majority of the objectives; while causing relatively small degradations to others. In this paper, we present a self-adaptive decision making approach for autoscaling in the cloud. It is capable to adaptively produce autoscaling decisions that lead to well-compromised trade-offs without heavy human intervention. We leverage on ant colony inspired multi-objective optimization for searching and optimizing the trade-offs decisions, the result is then filtered by compromise-dominance, a mechanism that extracts the decisions with balanced improvements in the trade-offs. We experimentally compare our approach to four state-of-the-arts autoscaling approaches: rule, heuristic, randomized and multi-objective genetic algorithm based solutions. The results reveal the effectiveness of our approach over the others, including better quality of trade-offs and significantly smaller violation of the requirements. <s> BIB013
Vertical scaling means removing or adding resources, including CPU, memory, I/O, and network, from or to existing VMs. To dynamically perform these operations, modern hypervisors utilize mechanisms such as CPU sharing and memory ballooning to support CPU and memory hot-plug. However, major cloud providers, such as Amazon, Google, and Microsoft, do not support adjusting resources during runtime. In these platforms, it is essential to shut down the instance first to add resources. Some providers like Centurylink 1 allow users to scale CPU cores without downtime vertically. Profitbricks 2 permits adding both CPU and memory to the VMs dynamically. Vertical scaling is considered not suitable for highly scalable applications due to its limitations. Ideally, the maximum capacity a VM can scale to is the size of the physical host. However, multiple VMs are usually residing on the same physical machine competing for resources, which further confines the potential scaling capability. Though limited, dynamic vertical scaling outperforms horizontal scaling in provisioning time as it can be in effect instantaneously. Besides, some services or components that are difficult to replicate during runtime, such as a database server and stateful application servers, can benefit from vertical scaling. Dawoud et al. BIB007 conducted an experimental study of vertical scaling using the RUBBOS benchmark on both its application server and database, which highlights the advantages of vertical scaling mentioned above. Many auto-scalers have been developed using solely vertical scaling to manage VMs on the same physical host. Some of them only considered scaling CPU resources BIB002 BIB006 BIB011 BIB008 . Some targeted both CPU and memory BIB013 BIB007 BIB004 BIB012 BIB009 BIB005 . Jing et al. BIB001 focused on CPU in the prototype and claimed their method could be extended to other resources. Bu et al. BIB010 proposed an approach that adjusts not only CPU and memory allocation but also application parameters. Padala et al. BIB003 scaled both CPU and disk. These auto-scalers are experimental prototypes designed to be deployed in either private or public clouds. However, they have not been included in any commercial offerings yet.