Skip to main content

2017 | Buch

Engineering Scalable, Elastic, and Cost-Efficient Cloud Computing Applications

The CloudScale Method

insite
SUCHEN

Über dieses Buch

This book provides an overview of the problems involved in engineering scalable, elastic, and cost-efficient cloud computing services and describes the CloudScale method — a description of rescuing tools and the required steps to exploit these tools. It allows readers to analyze the scalability problem in detail and identify scalability anti-patterns and bottlenecks within an application. With the CloudScale method, software architects can analyze both existing and planned IT services.

The method allows readers to answer questions like:

• With an increasing number of users, can my service still deliver acceptable quality of service?
• What if each user uses the service more intensively? Can my service still handle it with acceptable quality of service?
• What if the number of users suddenly increases? Will my service still be able to handle it?
• Will my service be cost-efficient?

First the book addresses the importance of scalability, elasticity, and cost-efficiency as vital quality-related attributes of modern cloud computing applications. Following a brief overview of CloudScale, cloud computing applications are then introduced in detail and the aspects that need to be captured in models of such applications are discussed. In CloudScale, these aspects are captured in instances of the ScaleDL modeling language. Subsequently, the book describes the forward engineering part of CloudScale, which is applicable when developing a new service. It also outlines the reverse and reengineering parts of CloudScale, which come into play when an existing (legacy) service is modified. Lastly, the book directly focuses on the needs of both business-oriented and technical managers by providing guidance on all steps of implementing CloudScale as well as making decisions during that implementation. The demonstrators and reference projects described serve as a valuable starting point for learning from experience.

This book is meant for all stakeholders interested in delivering scalable, elastic, and cost-efficient cloud computing applications: managers, product owners, software architects and developers alike. With this book, they can both see the overall picture as well as dive into issues of particular interest.

Inhaltsverzeichnis

Frontmatter

Introduction and Overview

Frontmatter
Chapter 1. Introduction
Abstract
When building IT systems today, developers face a set of challenges unknown a few years ago. Systems have to operate in a much more dynamic world, with users coming and going in an unpredictable manner. User counts have exceeded the limit of billions of users, and the Internet of Things will even increase those numbers significantly. Hence, building scalable systems which can cope with their dynamic environment has become a major success factor for most IT service providers. Those systems are run on a vast amount of hardware and software resources offered by cloud providers. Therefore, this chapter gives an introduction into the world of cloud computing applications, the terminology and concepts used in this world, and the challenges developers face when building scalable cloud applications. Afterward, we outline our solution for engineering cloud computing applications on a very high level to give the reader a jump-start into the topic.
This chapter is structured as follows. In Sect. 1.1 we sketch the world of cloud applications and motivate the need for engineering their scalability. For those who have not worked on a cloud system, we outline its characteristics in Sect. 1.2 and define its essential concepts in Sect. 1.3. As this book is about building scalable cloud computing applications, we introduce the most important quality properties (scalability, elasticity, and cost-efficiency) in Sect. 1.4. In Sect. 1.5 we describe what consequences you will face when failing to get the quality of your application right, while Sect. 1.6 explains reasons why developers fail to provide sufficient quality when not following specialized methods. As development efforts and methods need to be managed, Sect. 1.7 describes what it takes to manage scalability, elasticity, and cost-efficiency. Management can be done in two ways, i.e., reactively (cf. Sect. 1.8) or proactively (cf. Sect. 1.9). Once you have understood why you should care about scalability, we sketch our solution approach, the CloudScale method (cf. Sect. 1.10). We explain what it costs to introduce it in Sect. 1.11 and what is required to be successful (cf. Sect. 1.12).
Steffen Becker, Gunnar Brataas, Mariano Cecowski, Darko Huljenić, Sebastian Lehrig, Ivana Stupar
Chapter 2. CloudScale Method Quick View
Abstract
In this chapter, we overview the complete CloudScale method and show how the CloudScale method relates to existing development processes. Our overview is accompanied by a running example termed CloudStore—a simple online bookshop to be operated in a cloud computing environment. In a fictional scenario, we exemplify how a software architect follows the CloudScale method to realize CloudStore. The architect finally realizes CloudStore such that all of its scalability, elasticity, and cost-efficiency requirements are fulfilled. After having exemplified the CloudScale method, additional guidelines for software architects are given in the form of best practices (HowTos) and common pitfalls (HowNotTos). The chapter closes with a discussion on how the CloudScale method can be integrated into existing development processes such as the Unified Process.
This chapter is structured as follows. Section 2.1 overviews the process steps of the CloudScale method, and Sect. 2.2 introduces CloudStore as a running example. Afterward, the fictional scenario starts in which a software architect identifies critical use cases and key scenarios (Sect. 2.3), derives appropriate service-level objectives (SLOs) (Sect. 2.4), creates an architectural model of CloudStore (Sect. 2.5), improves this model based on analyses (Sect. 2.6), implements CloudStore and resolves implementation issues (Sect. 2.7), and deploys and operates CloudStore in a cloud computing environment (Sect. 2.8). Afterward, Sect. 2.9 describes HowTos, and Sect. 2.10, HowNotTos. Finally, the CloudScale method is related to the Unified Process in Sect. 2.11.
Gunnar Brataas, Steffen Becker, Mariano Cecowski, Darko Huljenić, Sebastian Lehrig, Ivana Stupar

Modeling Cloud Computing Applications

Frontmatter
Chapter 3. Cloud Computing Applications
Abstract
Cloud computing focuses on elasticity, i.e., providing constant quality of service independent of workload. For achieving elasticity, cloud computing applications utilize virtualized infrastructures, distributed platforms, and other software-as-a-service offerings. The surge of cloud computing applications responds to the ability of cloud computing environments to only pay for utilized resources while saving upfront costs (e.g., buying and setting up infrastructure) and allowing for dynamic allocation of resources even in public-private hybrid scenarios.This chapter investigates the shift from classical three-tier web applications to such elastic cloud computing applications. After characterizing web applications, we describe cloud computing characteristics and derive how web applications can exploit these characteristics.Our results motivate novel requirements that have to be engineered and modeled, as further described in this chapter.
The remainder of this chapter is structured as follows. Section 3.1 gives a high-level overview of views and aspects important for cloud computing applications. Afterward, Sect. 3.2 details characteristics of web applications, and Sect. 3.3, those of cloud computing. Section 3.4 outlines how web applications can be moved to cloud computing applications by exploiting cloud computing characteristics. Based on these insights, we derive novel requirements for cloud computing applications in Sect. 3.5 and show how to appropriately model cloud computing applications to analyze such requirements in Sect. 3.6. Section 3.7 refines our running example—CloudStore—to a cloud computing application. Subsequently, Sect. 3.8 highlights some hints for modeling such applications.
Mariano Cecowski, Steffen Becker, Sebastian Lehrig
Chapter 4. ScaleDL
Abstract
This chapter describes the family of languages required to analyze the scalability, elasticity, and cost-efficiency of services deployed in the cloud. First, the ScaleDL Overview Model describes the overall structure of a cloud-based architecture. Second, ScaleDL Usage Evolution specifies how load and work vary as a function of time. Third, ScaleDL Architectural Templates save time by reusing best practices. Fourth, the Extended Palladio Component Model is used for modeling software components and their mapping to underlying software services. The first three languages are new in CloudScale, while the fourth, Extended Palladio Component Model, is reused. For each language, we describe the basic concepts before we give an example. Tool support is then outlined. We list our catalog of Architectural Templates.
This chapter is structured as follows: Sect. 4.1 outlines the relation between the ScaleDL languages. For each language, we describe the basic concepts before we give an example. Tool support is also outlined. The ScaleDL Overview Model is described in Sect. 4.2. ScaleDL Usage Evolution is explained in Sect. 4.3. In Sect. 4.4 ScaleDL Architectural Templates are introduced in detail. Section 4.5 describes the Extended Palladio Component Model.
Gunnar Brataas, Steffen Becker, Mariano Cecowski, Vito Čuček, Sebastian Lehrig

The CloudScale Method for Software Architects

Frontmatter
Chapter 5. The CloudScale Method
Abstract
This chapter details the CloudScale method. We describe its high-level process with the most important steps. We look more closely at the CloudScale method from Sect. 2.1 and detail it with respect to the developer roles executing it. We also introduce the two major method use cases. Method use case I is about analyzing a modeled system; method use case II deals with analyzing and migrating an implemented system. All discussions in this chapter are guided by the granularity of the analysis you want to perform, hence; this chapter also introduces granularity as a key concept and discusses how to find the right one.
As granularity is important for all steps of the CloudScale method, it is introduced in Sect. 5.2. As a second basis, our graphical notation is described in Sect. 5.3. The method description starts with an introduction into the CloudScale method roles in Sect. 5.4. As a core section in this chapter, Sect. 5.5 gives a detailed overall overview on the CloudScale method. Afterward, the following sections give details on all method steps: Sect. 5.6 outlines how to identify service-level objectives (SLOs), critical use cases, and their associated key scenarios from business needs; Sect. 5.7 then describes how to transform the SLOs and critical use cases into scalability, elasticity, and cost-efficiency requirements. Afterward, the two main use cases of the CloudScale method are introduced: Sect. 5.8 outlines how to use models to analyze a system’s properties, while Sect. 5.9 sketches how to analyze implemented and executable systems. Finally, Sect. 5.10 briefly describes how to realize and operate the system.
Gunnar Brataas, Steffen Becker
Chapter 6. Analyzing a Modeled System
Abstract
Architectural analysis describes the activity of discovering important system properties—like functional requirements and service-level objectives (SLOs)—using models of the system. The main benefit of such analysis is that software architects can assess their design and what-if scenarios without having to implement each option. For example, architects can easily elaborate alternatives and variants of HowTos. This chapter describes how software architects follow the CloudScale method to model and analyze systems via ScaleDL. The chapter links the CloudScale Method outlined in Chap. 5 with the ScaleDL language described in Chap. 4 For ScaleDL modeling, the most important manual and automated steps are described. For ScaleDL analysis, the usage of the Analyzer tool is detailed. A running example brings the different pieces together and shows how scalability, elasticity, and cost-efficiency can be projected based on a ScaleDL model.
The chapter starts in Sect. 6.1 with detailing the modeling steps in the CloudScale method. We refine the two steps specific for the model-based analysis of a modeled system: the specification of ScaleDL models (Sect. 6.2) and using CloudScale’s Analyzer tool for its analysis (Sect. 6.3). After a detailed description of these steps, we illustrated the whole process based on our running example (Sect. 6.4).
Sebastian Lehrig, Gunnar Brataas, Mariano Cecowski, Vito Čuček
Chapter 7. Analyzing and Migrating an Implemented System
Abstract
While modern systems are often built in a way that respects cloud computing requirements, the majority of existing systems have been built before dynamically allocatable resources became mainstream. Those systems have been designed and implemented for dedicated hardware, often large-scale servers, which had been sized to the maximum workload the systems were expected to face. This approach led to a high amount of wasted resources, which were operated in a stand-by fashion only to deal with seldom high-load situations. Therefore, it is desirable to migrate legacy systems in a way that they can benefit from the cloud computing approach. However, several issues arise. Legacy systems were often built without upfront modeling or the models became outdated over time. Additionally, while there are several tools that analyze legacy systems to detect insufficient coding style or bad designs, almost no tooling exists that spots defects in the systems. This deficiency hinders systems to smoothly operate in cloud computing environments, i.e., these systems have a limited scalability. In CloudScale, we address this issue by dedicated, built-in method support for system evolution, i.e., for migrating legacy systems to cloud computing environments. In this chapter, we outline CloudScale’s evolution support and present tools which help software architects to migrate legacy systems to scalable, cloud computing applications.
Section 7.2 describes the process steps when spotting HowNotTos. Statical detection of HowNotTos is further elaborated in Sect. 7.3, while dynamic detection is discussed in Sect. 7.4. Section 7.5 links HowNotTos with best-practice HowTos. An example is described in Sect. 7.6.
Steffen Becker, Sebastian Lehrig

Making the CloudScale Method Happen

Frontmatter
Chapter 8. The CloudScale Method for Managers
Abstract
Having described the CloudScale method for engineering scalable cloud computing applications in the previous chapters, we explicitly address managers of software development processes in this chapter. It answers questions managers have in mind when considering the CloudScale method: Is it worth implementing the CloudScale method in my organization? What does it take? What are the benefits? What will be the costs? How should I get started? This chapter addresses all these questions and provides answers based on our own experience that we gained when introducing and applying the CloudScale method in practice. In the course of the chapter, we distinguish two types of managers: project managers, who are concerned with managing project teams that implement the business requirements, and technical managers, who manage the actual development efforts and take technical decisions.
The chapter is structured as follows. After a brief introduction (cf. Sect. 8.1), it first addresses project managers. We illustrate key considerations that project managers should be making when applying the CloudScale method (cf. Sect. 8.2). Afterward, we sketch how the CloudScale method interacts with other development processes (cf. Sect. 8.3) and what its pros and cons are (cf. Sect. 8.4). The remainder of the chapter addresses technical managers. First, it sketches a pilot project in Sect. 8.5 to guide the discussion. Using this pilot, in Sect. 8.6, we briefly outline how to set up CloudScale’s IDE, which can be complemented by third-party tools introduced in Sect. 8.7. We apply the CloudScale method on the pilot in Sect. 8.8.
Steffen Becker, Gunnar Brataas, Mariano Cecowski, Darko Huljenić, Sebastian Lehrig, Ivana Stupar
Chapter 9. Case Studies
Abstract
As described in the previous chapters, the CloudScale method lets software architects manage scalability, elasticity, and cost-efficiency throughout the whole system lifecycle. To illustrate its usage, this chapter describes an application of the CloudScale method and its tools on two industrial case studies. The first case study—Ericsson’s Electronic Health Record (EHR) —is an electronic health record software, and the second one—Kantega’s Flyt CMS —is a content management system (CMS). The case studies exemplify scenarios that require an engineering approach to ensure the system is scalable and performs well. The providers of the stated industrial cases are different organizations that follow their own internal development processes. The chapter closes by briefly pointing to complementing case studies that were used to evaluate the CloudScale method, both separately and in the context of the CloudScale method.
The following sections cover the essential steps and tools in the CloudScale method for the Electronic Health Record (EHR) (Sect. 9.1) and Flyt CMS (Sect. 9.2) case studies. Subsequently, the complementing case studies are overviewed (Sect. 9.3).
Darko Huljenić, Ivana Stupar, Mariano Cecowski
Backmatter
Metadaten
Titel
Engineering Scalable, Elastic, and Cost-Efficient Cloud Computing Applications
herausgegeben von
Steffen Becker
Gunnar Brataas
Sebastian Lehrig
Copyright-Jahr
2017
Electronic ISBN
978-3-319-54286-7
Print ISBN
978-3-319-54285-0
DOI
https://doi.org/10.1007/978-3-319-54286-7