The state-of-the-art scheduler of containerized cloud services considers load balance as the only criterion; many other important properties, including application performance, are overlooked. In the era of Big Data, however, applications evolve to be increasingly more data-intensive thus perform poorly when deployed on containerized cloud services. To that end, this paper aims to improve today's cloud service by taking application performance into account for the next-generation container schedulers. More specifically, in this work we build and analyze a new model that respects both load balance and application performance. Unlike prior studies, our model abstracts the dilemma between load balance and application performance into a unified optimization problem and then employs a statistical method to efficiently solve it. The most challenging part is that some sub-problems are extremely complex (for example, NP-hard), and heuristic algorithms have to be devised. Last but not least, we implement a system prototype of the proposed scheduling strategy for containerized cloud services. Experimental results show that our system can significantly boost application performance while preserving high load balance.

Docker container images are typically stored in a centralized registry to allow easy sharing of images. However, with the growing popularity of containerized software, the number of images that a registry needs to store and the rate of requests it needs to serve are increasing rapidly. Current registry design requires hosting registry services across multiple loosely connected servers with different roles such as load balancers, proxies, registry servers, and object storage servers. Due to the various individual components, registries are hard to scale and benefits from optimizations such as caching are limited. In this paper we propose, implement, and evaluate BOLT-a new hyperconverged design for container registries. In BOLT, all registry servers are part of a tightly connected cluster and play the same consolidated role: each registry server caches images in its memory, stores images in its local storage, and provides computational resources to process client requests. The design employs a custom consistent hashing function to take advantage of the layered structure and addressing of images and to load balance requests across different servers. Our evaluation using real production workloads shows that BOLT outperforms the conventional registry design significantly and improves latency by an order of magnitude and throughput by up to 5x. Compared to state-of-the-art, BOLT can utilize cache space more efficiently and serve up to 35% more requests from its cache. Furthermore, BOLT scales linearly and recovers from failure recovery without significant performance degradation.

Due to their tight isolation, low overhead, and efficient packaging of the execution environment, Docker containers have become a prominent solution for deploying modern applications. Containers are created from images which are stored in a Docker registry. An image consists of a list of layers which can be shared among images. Docker registries store a large amount of images and with the increasing popularity of Docker, they continue to grow. For example, Docker Hub-a popular public registry-stores more than half a million public images. In this paper, we analyze over 167TB of uncompressed Docker images and evaluate the potential of file-level deduplication in the registry. Our analysis reveals that only 3% of the files in images are unique and Docker's existing layer sharing mechanism is not sufficient to eliminate this profound redundancy. We then present the design of Slimmer-a Docker registry with file deduplication support-and conduct a simulation-based analysis of its performance implications.

Docker containers have become a prominent solution for supporting modern enterprise applications due to the highly desirable features of isolation, low overhead, and efficient packaging of the execution environment. Containers are created from images which are shared between users via a Docker registry. The amount of data Docker registries store is massive; for example, Docker Hub, a popular public registry, stores at least half a million public images. In this paper, we analyze over 167 TB of uncompressed Docker Hub images, characterize them using multiple metrics and evaluate the potential of file-level deduplication in Docker Hub. Our analysis helps to make conscious decisions when designing storage for containers in general and Docker registries in particular. For example, only 3% of the files in images are unique, which means file-level deduplication has a great potential to save storage space for the registry. Our findings can motivate and help improve the design of data reduction, caching, and pulling optimizations for registries.

Container management frameworks, such as Docker, package diverse applications and their complex dependencies in self-contained images, which facilitates application deployment, distribution, and sharing. Currently, Docker employs a shared-nothing storage architecture, i.e. every Docker-enabled host requires its own copy of an image on local storage to create and run containers. This greatly inflates storage utilization, network load, and job completion times in the cluster. In this paper, we investigate the option of storing container images in and serving them from a distributed file system. By sharing images in a distributed storage layer, storage utilization can be reduced and redundant image retrievals from a Docker registry become unnecessary. We introduce Wharf, a middleware to transparently add distributed storage support to Docker. Wharf partitions Docker's runtime state into local and global parts and efficiently synchronizes accesses to the global state. By exploiting the layered structure of Docker images, Wharf minimizes the synchronization overhead. Our experiments show that compared to Docker on local storage, Wharf can speed up image retrievals by up to 12x, has more stable performance, and introduces only a minor overhead when accessing data on distributed storage.

Deployment mechanisms in Cloud environments are becoming more and more attractive to developers that find them easy and convenient to deploy their applications in just few steps. These mechanisms reduced the development cycles from weeks to hours. In this context, elasticity plays an important role in coping with the dynamic nature of these environments. Elasticity mechanisms allow adding or retrieving application instances to deal with the changing number of incoming queries. Determining the optimal number of instances needed in a given horizon is really challenging, since we are dealing with a random number of incoming queries and given that the number of queries fulfilled by a single instance is random as well. Also, there is a trade-off between deploying too many instances and thus paying unnecessary deployment costs and deploying too few of them, and thus paying penalties for not being able to fulfill all in-coming queries on-time. In this paper, we propose a stochastic programming method that determines the optimal number of instances needed in a given planning horizon, putting in mind the uncertain parameters of the problem. In our approach, we learn from the historical behavior of the system to predict the probability distributions of the unknown data, and then formulate a stochastic programming model that optimizes the aforementioned trade-off and outputs the optimal provisioning plan.

Cloud providers offer services at different levels of abstraction from infrastructure to applications. The quality of Cloud services is a key determinant of the overall service level a provider offers to its customers. Service Level Agreements (SLAs) are (1) crucial for Cloud customers to ensure that promised levels of services are met, (2) an important sales instrument and (3) a differentiating factor for providers. Cloud providers and services are often selected more dynamically than in traditional IT services, and as a result, SLAs need to be set up and their monitoring implemented to match the same speed. In this context, managing SLAs is complex: different Cloud providers expose different management interfaces and SLA metrics differ from one provider to another. In this paper, we will analyze how IT service quality has been defined and managed over time, discuss how to manage SLAs in today’s multi-layer, multi-sourced Cloud environments, and what to expect going forward. A particular focus will be made on the rSLA framework that enables fast setup of SLA monitoring in dynamic and heterogeneous Cloud environments. The rSLA framework is made up of three main components: the rSLA language to formally represent SLAs, the rSLA Service, which interprets the SLAs and implements the behavior specified in them, and a set of Xlets-lightweight, dynamically bound adapters to monitoring and controlling interfaces. rSLA has been tested in the context of a real pilot and found to reduce the client on-boarding process from months to weeks.

The quality of Cloud services is a key determinant of the overall service level a provider offers to its customers. Service Level Agreements (SLAs) are crucial for Cloud customers to ensure that promised levels of services are met, and an important sales instrument and a differentiating factor for providers. Cloud providers offer services at different levels of abstraction, from infrastructure to applications. Also, Cloud providers and services are often selected more dynamically than in traditional IT services, and as a result, SLAs need to be set up and monitoring implemented to match this speed. This paper presents the rSLA language for specifying and enforcing SLAs for Cloud services, allowing for dynamic instrumentation of heterogeneous Cloud services and instantaneous deployment of SLA monitoring. This is predicated on formal representations of SLAs in the language. We describe how the rSLA language and its supporting framework as well as underlying SLA execution model enable the fast deployment of custom SLAs in heterogeneous and hybrid Cloud environments.

Service level agreements (SLAs) are considered not only a central tool for managing QoS compliance, but also a differentiating factor between service implementations. In today's application environments with fast instrumentation deployment cycles in hybrid Cloud platforms, managing QoS compliance poses tremendous challenges, including how to deliver solutions that live up to promised QoS properties and preemptively identify provisioning risks before they lead to violations. Current approaches are usually reactive, i.e. the application infrastructure reacts to changes in QoS metrics, with a huge focus on compliance enforcement after violations have occurred. Cloud service provisioning demands a proactive approach to QoS management, with support for robust predictive scaling of service capacity based on multiple metrics, including business goals as well as infrastructure-level and QoS metrics. This paper presents an approach for adaptive service provisioning in the Cloud based on QoS analytics. A major contribution of the approach is the development of an analytics engine for predictive elasticity management of Cloud service provisioning that integrates in-depth mining of SLA compliance history with knowledge of business context, e.g. workload variability, a customer's business goals, application performance, and service operational context. In this work-in-progress report, we describe the proposed framework and discuss possible implementation and deployment scenarios.

Managing service quality in heterogeneous Cloud environments is complex: different providers expose different management interfaces for monitoring and configuration actions that can occur at the infrastructure, platform and application levels. To manage Service Level Agreements (SLAs) in this context, we have developed the rSLA Manager for enabling fast setup of SLA monitoring in dynamic, heterogeneous Cloud environments. In this paper, we demonstrate the use of the rSLA Manager to manage the response time behavior of an image scaling service on the IBM Blue mix platform. We show how the system enables SLA violation reduction by facilitating platform-level adaptation (e.g., adding application instances) and application-level behavior configuration (e.g., changing image scaling quality) based on different service level objectives as well as current application configuration and workload.

The state-of-the-art scheduler of containerized cloud services considers load-balance as the only criterion and neglects many others such as application performance. In the era of Big Data, however, applications have evolved to be highly data-intensive thus perform poorly in existing systems. This particularly holds for Platform-as-a-Service environments that encourage an application model of stateless application instances in containers reading and writing data to services storing states, e.g., key-value stores. To this end, this work strives to improve today's cloud services by incorporating sensitivity to both load-balance and application performance. We built and analyzed theoretical models that respect both dimensions, and unlike prior studies, our model abstracts the dilemma between load-balance and application performance into an optimization problem and employs a statistical method to meet the discrepant requirements. Using heuristic algorithms and approaches we try to solve the abstracted problems. We implemented the proposed approach in Diego (an open-source cloud service scheduler) and demonstrate that it can significantly boost the performance of containerized applications while preserving a relatively high load-balance.

In this paper we present a novel approach to add collaborative autonomic management facilities to component-based applications. We introduce an autonomic container having the needed generic functionalities for autonomic management in dynamic environments. The purpose of this container is to discharge the application developer from the burden of the non-functional facilities of management in order to focus merely on the business of the application. We give an architectural description of an application's components, and encapsulate each component in its own autonomic container. Here in, we described the different relationships that could occur between the different containers and how these relationships allow the collaboration of the containers in order to full-fill a global objective.

The study we have conducted of existing cloud platforms shows that their operating requires the use of specific and proprietary APIs. This PaaS providers' policy is hampering the interactions between different clouds. If appropriate solutions are not considered, this issue would for instance slow down the democratization of clouds federation and cooperation. In this paper, we propose (i) a unified description model that allows the representation of applications independently of the targeted PaaS for their hosting and (ii) a generic PaaS application provisioning and management API (called COAPS API). Our proposed solution applies the separation of concerns principle by separating the provisioning and the management API from the defined description model. We motivate our solution with real use case scenarios and an implementation to show its feasibility.

Cloud computing is a recent paradigm in information technology enabling an economic model for virtual resources provisioning. For this paradigm, service oriented Architecture (SOA) is a pillar block to build applications. To efficiently manage service-based applications in the cloud, monitoring and reconfiguration remain important tasks but it is still a challenge to find a solution that reconciles the scalability, the memory consumption, and the efficiency. In this paper, we propose a framework that adds monitoring and reconfiguration facilities to services of a service-based application and deploys them in the cloud using a scalable micro-container. Unlike the existing initiatives, our framework adds dynamically these facilities to services that were not designed to be monitored or reconfigured. This makes the developers' task easier, letting them focusing on the business of their services instead of the non functional property of monitoring and reconfiguration. Moreover, our framework uses a scalable micro-container for services' deployment in the cloud to be inline with the scalability of this environment. The evaluation that we performed proves the efficiency and the flexibility of our approach for service-based applications in the cloud.

Monitoring and reconfiguration are critical issues in Cloud environments. Monitoring allows to detect violations and specific events, while reconfiguration allows to activate corrective mechanisms or runtime modifications. In this paper we propose an extension for Open Cloud Computing Interface (OCCI) to enable monitoring and reconfiguration. The extension describes the needed elements to manage (i.e., to monitor and reconfigure) cloud resources on demand. The definition entails the introduction of new OCCI Resources, Links and Mixins. We define on the one hand new types needed to monitor metrics based on a previously established SLA. On the other hand we define the needed types to reconfigure our managed resources when needed. The newly added elements are OCCI entities defined as generic Kinds, that are specialized using OCCI Mixins. Using these elements, the user is provided with a monitoring and reconfiguration infrastructure on demand. We propose herein, a real use case based on HTTP rendering showing how to establish and link the described elements of the infrastructure.

Cloud Computing is a new supplement, consumption, and delivery model for IT services based on Internet protocols. It typically involves provisioning of dynamically scalable and often virtualized resources. In this environment, there are several issues related to the inadequacies of hosting platforms and mechanisms to ensure the smooth running of service-based applications (communication protocols, ESB, Service containers, etc.). In particular, architectures and implementations of service containers are not adapted to Cloud environments. In this paper, we present a new service container dedicated to one deployed service that avoids the processing limits of classical services containers. Our approach addresses scalability by reducing memory consumption and response time. The proposed service container is evaluated in several situations against well known services containers within a real Cloud Computing network.