# Modeling and Security in Cloud Ecosystems
## 2 Background  
A _pattern_ is a solution to a recurring problem in a specific context. Software patterns are categorized as analysis [13], design [14], architecture [15], and security patterns [8]. _Abstract patterns_ describe a basic semantic aspect while _Abstract Security patterns_ (ASPs), realize one or more security policies able to control (stop or mitigate) a threat or comply with a security-related regulation or institutional policy [16]. Patterns are described using a template composed of a set of sections.  
A problem section describes a problem and the forces that constrain and define guidelines for its solution, e.g., \"overhead must be reasonable\". Pattern solutions are usually described using modeling languages such as the Unified Modeling Language (UML), maybe combined with formal languages such as the Object Constraint Language (OCL). UML diagrams may include class, sequence, state, and activity diagrams. A set of consequences indicate how the pattern solved the specific problem and what are the advantages and disadvantages of using it; _i.e._, how well the forces were satisfied by the solution. An implementation section provides hints on how to use the pattern in an application. A section on \"known uses\" lists real systems where this solution has been used previously, _i.e._, a pattern is an abstraction of a good practice. A section on related patterns indicates patterns that complement or provide alternative solutions to the one in this pattern. A pattern embodies the knowledge and experience of software developers and can be reused in new applications; carefully-designed patterns implicitly apply good design principles. Patterns are also good for communication between designers and to evaluate and reengineer existing systems. While initially developed for software, patterns can describe hardware, physical entities, and combinations of these. Pattern solutions are suggestions, not plug-ins or software components. A _compound_ pattern is composed of two or more simpler patterns.  
A _Reference Architecture_ (RA) is an abstract software architecture, based on one or more domains, with no implementation aspects [12; 17; 18]. An RA should define the fundamental concepts of a system expressed as ASPs and the interactions among these units. An RA should be reusable, extendable, and configurable; that is, it is a kind of composite pattern for whole architectures and it can be instantiated into a concrete software architecture by adding platform aspects [17]. In addition to class and sequence diagrams, an RA may include a set of use cases (UC), and a set of Roles (R) corresponding to its stakeholders (actors). Types of RAs include those for the technology domain (describe platforms and other design artifacts [18]), application domain (describe different types of applications), and problem domain (similar to domain models, but oriented to software). After adding security patterns to neutralize identified threats in an RA we have a _Security Reference Architecture_ (SRA), and we have just produced a SRA for clouds [9]. We can also add compliance patterns to produce a _Compliance Reference Architecture_[19].  
_Policies_ are high-level guidelines defining how an institution conducts its activities in its business, professional, economic, social, and legal environment. The institution security policies include laws, rules, and practices that regulate how an institution uses, manages and protects resources. _Regulations_ are local or government policies that must be reflected in the implemented system. Industry regulations are called _standards_. Policies, regulations, and standards can be described using UML models.  
We describe the relationships between patterns using a _pattern diagram_[15]. In a pattern diagram rounded rectangles represent patterns and arrows indicate the contribution of a pattern to another, e.g., a Container provides virtual environments to PaaS in Figure 1.  
Figure 1: A cloud ecosystem (showing its latest additions).