Conference PaperPDF Available

A Pattern-based Semantic Lifting of Cloud and HPC Applications using OWL 2 Meta-modelling

Authors:

Abstract and Figures

Developing and deploying applications across heterogeneous HPC and Cloud infrastructures is a challenging task that requires significant effort and expert knowledge to describe the specifics of the application deployment. Abstraction plays an important role in this domain, since it eliminates any unnecessary details, promotes reusability and interoperability among different standards. In this short paper we present TOSCA-S, our effort to define a conceptually rich OWL 2 meta-model for capturing structural and semantic relationships in Cloud/HPC infrastructures and applications, fostering the management and sharing of information in the form of abstract interconnected RDF knowledge graphs. To this end, we combine the content design pattern of the DOLCE+DnS Ultralite ontology and advanced OWL 2 meta-modelling capabilities (punning) in order to semantically lift the TOSCA meta-model, one of the fastest growing standards in OASIS, and handle the specifics of the standard in a multi-tier manner. The framework is part of the SODALITE platform that aims to provide an optimised, highly resilient heterogeneous execution environment enabling operational transparency between Cloud and HPC infrastructures.
Content may be subject to copyright.
A Pattern-based Semantic Lifting of Cloud and
HPC Applications using OWL 2 Meta-modelling
Georgios Meditskos, Zoe Vasileiou, Anastasios Karakostas, Stefanos Vrochidis and Ioannis Kompatsiaris
Information Technologies Institute, Centre for Research and Technology Hellas, Thessaloniki, Greece
Email: {gmeditsk, zvasilei, akarakos, stefanos, ikom}@iti.gr
Abstract—Developing and deploying applications across het-
erogeneous HPC and Cloud infrastructures is a challenging
task that requires significant effort and expert knowledge to
describe the specifics of the application deployment. Abstraction
plays an important role in this domain, since it eliminates any
unnecessary details, promotes reusability and interoperability
among different standards. In this short paper we present
TOSCA-S, our effort to define a conceptually rich OWL 2
meta-model for capturing structural and semantic relationships
in Cloud/HPC infrastructures and applications, fostering the
management and sharing of information in the form of abstract
interconnected RDF knowledge graphs. To this end, we combine
the content design pattern of the DOLCE+DnS Ultralite ontology
and advanced OWL 2 meta-modelling capabilities (punning) in
order to semantically lift the TOSCA meta-model, one of the
fastest growing standards in OASIS, and handle the specifics of
the standard in a multi-tier manner. The framework is part of the
SODALITE platform that aims to provide an optimised, highly
resilient heterogeneous execution environment enabling opera-
tional transparency between Cloud and HPC infrastructures.
Index Terms—Ontology Design Pattern, OWL 2, Knowledge
graphs, TOSCA, Cloud, HPC
I. INTRODUCTION
The efficient deployment and management of complex
multi-service applications is one of the problems that have
emerged with the cloud revolution. Many cloud resource man-
agement standards have been proposed to cope with different
aspects of interoperability and portability, such as TOSCA1
that is among the most known standards that supports multi-
level application representation and deployment modelling.
In addition, many applications that run on High Performance
Computers (HPC) are part of bigger workflows that run in
the cloud, such as those with extensive big data analytics. In
many cases, the complete workflow of HPC-based applications
is no different from any other Cloud architecture. Therefore,
the automated hybrid deployment and management of HPC
and Cloud applications have the potential to optimize the
performance and foster new development architectures.
In parallel, Semantic Web (SW) technologies hold a great
potential to the software engineering domain [1]. Especially in
cloud computing, several efforts have been made to represent,
query and manage cloud services and resources, capitalising
on Semantic Web standards [2] to: a) Provide a formal stan-
dardised model to describe cloud-related concepts; b) Manage
1https://docs.oasis-open.org/tosca/TOSCA-Simple- Profile-YAML/v1.3/os/
TOSCA-Simple-Profile-YAML-v1.3-os.html
and share information as RDF interconnected resources; and
c) Reuse of sound and complete reasoning tools for knowledge
enrichment and consistency checking [3].
In this short paper, we describe the key concepts behind
TOSCA-S for capturing and interlinking TOSCA-based de-
scriptions for Cloud/HPC infrastructures in the SODALITE
project2. SODALITE targets complex applications and work-
flows that are deployed on heterogeneous environments, such
as virtual machines, containerized HPC clusters, Cloud and
Edge devices, aiming at enabling developers to describe the
application deployment and optimising runtime performance.
In this context, the present work introduces a semantic layer
of abstraction for representing basic and complex aspects of
an application towards improving development, deployment,
and portability. More specifically, TOSCA-S aims to:
Provide modular and reusable ontological components to
handle different levels of abstraction. TOSCA-S follows
the Ontology Design Pattern (ODP) approach [4] to
ensure the provision of modularised ontology fragments,
performing a semantic lifting of TOSCA meta-model to
the Descriptions & Situations pattern (DnS) [5].
Handle meta-modelling where entities may play more
than one role. In TOSCA, nodes, for example, need to
be treated both as classes and individuals. TOSCA-S uses
meta-modelling (punning [6]) to handle the specifics of
TOSCA in a multi-tier manner.
Our contribution can be summarised in the following:
We propose an ODP-based abstraction layer for TOSCA-
compliant descriptions.
We enhance the proposed semantic lifting with meta-
modelling, fostering the reuse and extension of TOSCA
entities in different levels of abstraction.
We demonstrate the use of emerging W3C standards
(e.g. SHACL) for enrichment and validation of TOSCA-
compliant Knowledge Graphs.
The rest of the paper is structured as follows: Section
II presents related work. In Section III we describe the
specifics of TOSCA-S, and in Section IV we elaborate on
the knowledge enrichment and validation capabilities. Section
V presents use cases and preliminary results. Section VI
concludes our work.
2https://www.sodalite.eu/
1
3 BACKGROUND 4
application, we should manually look for a new container providing the software support
needed by both components, and we should re-describe — possibly from scratch — the
orchestration of GUI and API on the newly added container.
Especially in the latter case, our effort would be lower if we were provided with a
support requiring us to describe our application only, and automating all remaining tasks.
More precisely, we should only be required to specify the thicker nodes and dependencies
in Fig. 1. The support should then be able to automatically complete our specification,
and to exploit the obtained specification to automatically orchestrate the deployment
and management of the Thinking application. In this paper, we show a TOSCA-based
solution geared towards providing such a support.
3. Background
3.1. TOSCA
TOSCA (Topology and Orchestration Specification for Cloud Applications [22]) is an
OASIS standard whose main goals are to enable (i) the specification of portable cloud
applications and (ii) the automation of their deployment and management. TOSCA pro-
vides a YAML-based and machine-readable modelling language that permits describing
cloud applications. Obtained specifications can then be processed to automate the de-
ployment and management of the specified applications. We hereby report only those
features of the TOSCA modelling language that are used in this paper3.
Figure 2: The TOSCA metamodel [22].
TOSCA permits specifying a cloud application as a service template, which is in turn
composed by a topology template, and by the types needed to build such a topology
template (Fig. 2). The topology template is essentially a typed directed graph, which
describes the topological structure of a multi-component cloud application. Its nodes
(called node templates) model the application components, while its edges (called rela-
tionship templates) model the relations occurring among such components.
3A more detailed, self-contained introduction to TOSCA can be found in [3, 10].
Fig. 1: TOSCA meta-model.
II. BACKGROU ND A ND RE LATE D WORK
TOSCA [7] is one of the fastest growing standards in
OASIS aiming at the: a) automated application deployment
and management, b) portability of application descriptions and
their management, and c) interoperability and reusability of
components. To achieve this, it provides a conceptual meta-
model that allows the definition of the structure of cloud appli-
cations as a topology graph (Fig. 1). It uses service templates
to describe applications as topology templates, which are
graphs of node templates modelling the components. TOSCA
further provides a type system of node types to describe the
building blocks for constructing a service template, as well
as relationship types to describe possible kinds of relations.
Node types can be derived from existing types (class-level hi-
erarchy), while at the same time, they are treated as objects, by
assigning complex descriptive context (properties, capabilities,
requirements, etc.) in multi-level concept-object hierarchies.
The combination of cloud-related concepts with Semantic
Web technologies has been motivated by the need to foster
advanced interoperability and interlinking [2], [8]. In [9] three
ontologies are proposed (sTOSCA, sOCCI, and sCIMI) to
represent resources described in TOSCA, OCCI, and CIMI.
Open-Multinet (OMN) [10] provides a set of ontologies to
describe cloud and testbed infrastructures. The authors in [11]
proposed a QoS-based approach that utilises cloud computing
ontology for semantic discovery, selection and composition of
services. A template-based approach for policies is proposed
in [12]. The TOSCA ontology [13] captures the structural
aspects of the specification. In [14] the ODE Software Process
Ontology is mapped to the Unified Foundational Ontology
(UFO), which incorporates developments from GFO, DOLCE
and the Ontology of Universals. A pattern-based approach to
describe PaaS offerings is presented in [15]. In [16] cloud
patterns support the development of applications through the
composition of existing services. The detection of software
anomalies, such as bugs or defects, has been also approached
using Semantic Web technologies [3] [17].
In this paper the focus is given on creating conceptually
rich RDF knowledge graphs to capture and validate TOSCA
descriptions. We show the way OWL 2 punning can formally
support the TOSCA meta-model, and the way emerging W3C
standards, such as SHACL, can support validation. We have
Tier 0: TOSCA Meta-model
Abstract Application Deployment Model
Tier 1: Resource Meta-model Tier 2: Application Meta-model
Node Types
Capability
Types
Relationship
Types Custom Node
Types Custom Capability
Types
Custom
Relationship Types
Node Type
Instantiations
Relationship Type
Instantiations
TOSCA Built-ins Resource Expert AppOps Expert
derives_from type
Fig. 2: The modelling layers of TOSCA-S.
chosen DUL as lightweight, easy-to-apply foundational ontol-
ogy having been used in several areas (e.g. the Semantic Sen-
sor Network (SSN) is aligned with DUL). Other approaches
that also reuse DUL, such as [15], can be considered as
complementary, as they can be easily integrated to model
policies and non-functional characteristics.
III. TOSCA-S CONCEPTUAL MODEL
TOSCA-S follows a modular, 3-tier approach (Fig. 2): a)
Tier 0: It contains generic (built-in) types of TOSCA re-
sources, capabilities, properties, etc., b) Tier 1: Reusable node
type definitions, e.g. custom resource types, their capabilities,
etc., and c) Tier 2: Composed cloud applications (topologies),
which are reusable combinations of Tier 1 types.
The basic implementation of DnS in DUL allows
the association of situations (dul:Situation) and de-
scriptions (dul:Description) with domain concepts.
A situation describes the entities of a context and sat-
isfies (dul:satisfies) a description. The description
in turn defines (dul:defines) concepts that classify
(dul:classifies) entities of the situation, describing the
way they should be interpreted. Each concept may have one
or more parameters (dul:hasParameter).
TOSCA-S specialises the core DnS (Fig. 3). Each
TOSCA type (e.g. node) is represented as an Element
(:Element vdul:Situation). Each Element has a
View (:hasContext) that describes its properties, at-
tributes, interfaces, requirements, capabilities, etc. (:View
vdul:Description), each of which has a specifica-
tion (:specification vdul:defines) which involves
one or more Concepts with zero, one or more Parame-
ters. Each concept annotates one Resource (:Resource v
dul:Entity). In Description Logics [18], the core pattern
is defined as:
Element Situation u ∃hasContext
.(View u ∃specification
.(Concept u ∃annotates.Resource
u ∀hasParameter.Parameter))
In the following, we describe key modelling guidelines for
capturing knowledge in different tiers, along with examples.
A. TOSCA Normative Types and Custom Resources
Tiers 0 and 1 capture software components as reusable
building blocks that node templates in Tier 2 can be based on.
As an example, we demonstrate the mapping of the TOSCA
snippet depicted in Fig. 4a to TOSCA-S (Fig. 4b).
Although DockerHost is defined as a class, we use a
hasContext property assertion to assign a view, treating
2
Fig. 3: TOSCA-S meta-model (pink concepts denote TOSCA-
S classes, blue concepts represent domain specialisations).
node_types:
sodalite.nodes.DockerHost:
derived_from: tosca.nodes.SoftwareComponent
properties:
registry_ip:
type: string
required: true
topology_template:
snow-docker-host:
type: sodalite.nodes.DockerHost
properties:
registry_ip: "160.40.50.196"
Element
View
Concept
Parameter
Parameter
Element
View
Concept
(a) TOSCA resource definition (Tier 1).
(b) Mapping on TOSCA-S meta-model.
Fig. 4: TOSCA resource to the TOSCA-S meta-model.
it also as an instance (meta-modelling). In that way, we
are able to link the class with rich descriptive information,
which cannot be otherwise defined using OWL class de-
scriptions. In addition, the registry_ip RDF property
is defined, which acquires additional descriptive informa-
tion (e.g. about its type and that it is a required property)
through the tosca:Property instance (which annotates
registry_ip). By treating resources as first-class citizens,
TOSCA-S allows us to define different interpretations for the
same resources. TOSCA-S treats similarly attributes, capabil-
ities and requirements (not visualised in the example).
B. Node Templates
Node templates in TOSCA represent the components of
applications and constitute the main building blocks (together
with the relationship templates) of topology templates (Tier
2). Consider the node template depicted in Fig. 5a, which
instantiates the TOSCA node type in Fig. 4a. Using TOSCA-S,
we define an Element for the node template that has a View
with a Property annotating registry_ip. The value on
the property is given using a Parameter.
Fig. 4 and Fig. 5 illustrate key modelling capabilities of
TOSCA-S. First, it captures information in a conceptually
uniform manner across tiers: the descriptive context of node
types (Tiers 0 and 1) and node templates (Tier 2) can be
retrieved by traversing hasContext property assertions.
Second, it is in line with the TOSCA multi-level concept-
Element
View
Concept
Parameter
Parameter
Element
View
Concept
Parameter
(a) Node template definition (Tier 2).
(b) Mapping on TOSCA-S meta-model.
Fig. 5: TOSCA node template to TOSCA-S.
6 G. Meditskos et al.
node_types:
sodalite.nodes.DockerHost:
derived_from: tosca.nodes.SoftwareComponent
properties:
registry_ip:
type: string
required: true
topology_template:
snow-docker-host:
type: sodalite.nodes.DockerHost
properties:
registry_ip: "160.40.50.196"
Element
View
Concept
Parameter
Parameter
Element
View
Concept
Parameter
(a) Node template definition (Tier 2).
(b) Mapping on TOSCA-S meta-model.
Fig. 4: Example mapping of a TOSCA node template to TOSCA-S.
is outside the scope of this paper to present all of them. As an example, we
present the SHACL-SPARQL that checks the node type that can be used to sat-
isfy a requirement. The rule checks that the type of the node (type r a node)
assigned for a requirement (r a) in a node template is subsumed by the node
type (r d node) defined in the node definition, i.e. type r a node vr d node.
v:ValidationShape a sh:NodeShape ; sh:targetClass :View ;
sh:sparql [
a sh:SPARQLConstraint ; ...
sh:select """
select ?type_r_a_node ?r_d_node {
$this :requirements [:annotates ?r_a; :hasParameter
[:annotates tosca:node; :objectValue ?r_d_node]] .
?template :hasContext [:requirements
[:annotates ?r_a; :objectValue ?r_a_node]] .
?r_a_node a ?type_r_a_node .
NOT EXISTS {?type_r_a_node rdfs:subClassOf ?r_d_node.}
} """ ;
] .
5 Implementation, Use Cases and Validation
TOSCA-S is implemented in OWL 2 and more specifically, it follows the OWL
2 DL fragment (it is interpreted using the Direct Semantics1) to satisfy the re-
quired expressivity, e.g. meta-modelling. A set of competency questions has been
defined to elicit core modelling requirements from domain experts. In addition,
SPARQL-based competency questions have been used to validate certain parts
of the generated knowledge base (i.e. TOSCA nodes hierarchy). Finally, a set
1https://www.w3.org/TR/owl2-direct-semantics/
Fig. 6: Example SHACL rule.
object hierarchies: starting from concept hierarchies (Tier 0),
classes obtain descriptive context through property assertions.
The concept hierarchy is further extended (Tier 1) and so does
the meta-model space where custom resources as treated as
instances. Finally, Tier 2 contains only instances, closing this
alternation of schema and instance definitions.
IV. KNO WL ED GE ENRICHMENT AND VALIDATION
The TOSCA-S knowledge graphs are amenable to enrich-
ment using: a) native OWL 2 reasoning, and b) custom
reasoning and validation logic.
TOSCA-S enables assertions to be made among domain
classes in the form of views. It is important these views to be
propagated also to the subclasses (subnodes), so as to imple-
ment inheritance of descriptive context. The following OWL
2 property chain axiom propagates views to the subclasses:
rdfs:subClassOf :hasContext v:hasContext
The formal semantics of TOSCA-S also enables the use of a
standard language for topology validation. There are different
levels of validation [19], which is outside the scope of this
paper to present all of them. As an example, we present
in Fig. 6 the SHACL-SPARQL that checks the node type
that can be used to satisfy a requirement. The rule checks
that the type of the node (type_r_a_node) assigned for
a requirement (r_a) in a node template is subsumed by the
node type (r_d_node) defined in the node definition, i.e.
type_r_a_node vr_d_node.
3
TABLE I: Example query response times (secs).
10K 20K 30K 40K
nodes 0.33 0.45 0.7 0.8
props 0.2 0.34 0.44 0.59
attrs 0.22 0.39 0.41 0.65
capabilities 0.35 0.49 0.74 0.98
valid 0.8 1.1 1.2 1.4
V. IMPLEMENTATION, USE CA SE S AN D VALIDATION
TOSCA-S is implemented in OWL 2 and it follows the
OWL 2 DL fragment (it is interpreted using the Direct Seman-
tics3). A set of competency questions has been defined to elicit
core modelling requirements from domain experts. SPARQL-
based competency questions have been used to validate certain
parts of the generated knowledge base (i.e. TOSCA nodes
hierarchy). Finally, a set of RDF unit test cases [20] has
been executed against TOSCA-S endpoints for validating the
underlying logic, e.g. topology validation (Section IV).
The created TOSCA-S graphs to support the SODALITE
use cases4consist of 93 elements with equal number of views,
resulting in RDF graphs with more than 40K triples. TOSCA-
S provides intelligent browsing and reasoning services to
support users with context-aware intellisense, such as node
type auto-completion. In this context, scalable querying and
reasoning are very important for enhanced user experience.
Table I depicts response times for 5 query types (getting nodes,
properties, attributes, capabilities and triggering validation),
executed in different graph sizes in GraphDB5. Despite the rich
conceptual model, the query performance has been positively
assessed by the end users in this preliminary evaluation. The
validation process (Section IV) is the most time consuming
task, as it needs to join requirements and capabilities of
involved nodes, as well as it contains not-exists negation.
VI. CONCLUSIONS
In this short paper we presented the key idea behind
TOSCA-S, our effort to semantically lift key concepts of
TOSCA to facilitate a formal representation of deployment
models as RDF knowledge graphs. Key concepts of our
approach are: a) a pattern-based approach, adapting the DnS
pattern to TOSCA concepts, and b) we take benefit of the
expressiveness of OWL 2, using meta-modelling to structurally
and semantically capture the specifics of TOSCA. We have
also presented knowledge enrichment and validation cases to
support intelligent services in the context of the SODALITE
project. We have also performed a preliminary evaluation
of the query and validation performance, showing that the
framework can be used in real-world use cases.
Currently, TOSCA-S supports the mapping of complete
node type definitions, capabilities, relationships and node tem-
plates. We plan to extend the presented work in the following
directions: a) to support TOSCA policies and workflows, b)
3https://www.w3.org/TR/owl2-direct- semantics/
4https://www.sodalite.eu/use cases
5http://graphdb.ontotext.com/
to support additional TOSCA validation cases and antipattern
detection, c) to enrich the knowledge enrichment capabilities
of the framework, e.g. to suggest deployment optimisations
based on domain knowledge.
ACKNOWLEDGMENT
This work was supported by the EC funded project SO-
DALITE (H2020-825480).
REFERENCES
[1] A. Sheth and A. Ranabahu, “Semantic modeling for cloud computing,
part 2,” IEEE Internet Computing, vol. 14, no. 4, pp. 81–84, 2010.
[2] H. Brabra, A. Mtibaa, L. Sliman, and et al., “Semantic web technologies
in cloud computing: A systematic literature review,” Services Computing,
pp. 744–751, 2016.
[3] H. Brabra, A. Mtibaa, F. Petrillo, and et al., “On semantic detection
of cloud API (anti)patterns,” Information and Software Technology, vol.
107, pp. 65–82, 2019.
[4] T. Tudorache, “Ontology engineering: Current state, challenges, and
future directions,” Semantic Web, vol. 11, no. 1, pp. 125–138, 2019.
[5] A. Gangemi and P. Mika, “Understanding the Semantic Web through
Descriptions and Situations,” in ODBASE03, 2003, pp. 689–706.
[6] B. Motik, “On the properties of metamodeling in OWL,” Journal of
Logic and Computation, vol. 17, no. 4, pp. 617–637, 2007.
[7] OASIS, “TOSCA,” 2017. [Online]. Available: https://www.oasis-open.
org/committees/tosca
[8] O. Adedugbe, E. Benkhelifa, R. Campion, and et al., “Leveraging cloud
computing for the semantic web: review and trends,Soft Computing,
2019.
[9] K. Yongsiriwit, M. Sellami, and W. Gaaloul, “A Semantic Framework
Supporting Cloud Resource Descriptions Interoperability,9th Interna-
tional Conference on Cloud Computing (CLOUD), pp. 585–592, 2017.
[10] A. Willner, M. Giatili, P. Grosso, C. Papagianni, M. Morsey, and
I. Baldin, “Using semantic web technologies to query and manage
information within federated cyber-infrastructures,Data, vol. 2, no. 3,
pp. 1–26, 2017.
[11] K. J. Modi and S. Garg, “A QoS-based approach for cloud-service
matchmaking, selection and composition using the Semantic Web,
Systems and Information Technology, vol. 21, no. 1, pp. 63–89, 2019.
[12] S. Veloudis and I. Paraskakis, “Defining an ontological framework for
modelling policies in cloud,” in Cloud Comp. Technology & Science,
2016, pp. 277–284.
[13] B. Di Martino, A. Esposito, S. Nacchia, S. A. Maisto, and U. Breit-
enb¨
ucher, “An ontology for oasis tosca,” in Web, Artificial Intelligence
and Network Applications, Cham, 2020, pp. 709–719.
[14] G. Guizzardi, R. de Almeida Falbo, and R. S. Guizzardi, “Grounding
software domain ontologies in the unified foundational ontology (ufo):
The case of the ode software process ontology.” in CIbSE, 2008, pp.
127–140.
[15] N. Bassiliades, M. Symeonidis, P. Gouvas, E. Kontopoulos, G. Med-
itskos, and I. Vlahavas, “PaaSport semantic model: An ontology for a
platform-as-a-service semantically interoperable marketplace,” Data and
Know. Engin., vol. 113, pp. 81–115, 2018.
[16] B. Di Martino, G. Cretella, and A. Esposito, “Cloud services composi-
tion through cloud patterns: a semantic-based approach,” Soft. Comput.,
vol. 21, pp. 4557–4570, 2017.
[17] B. B. Duarte, R. A. Falbo, G. Guizzardi, and et al., “Towards an ontology
of software defects, errors and failures,” in Conceptual Modeling, 2018,
pp. 349–362.
[18] F. Baader, D. Calvanese, D. L. McGuinness, D. Nardi, and P. F. Patel-
Schneider, The Description Logic Handbook: Theory, Implementation,
and Applications. Cambridge University Press, 2003.
[19] A. Brogi, A. Di Tommaso, and J. Soldani, “Sommelier: a tool for vali-
dating TOSCA application topologies,” in Communications in Computer
and Information Science, vol. 880, 2018, pp. 1–22.
[20] D. Kontokostas, P. Westphal, S. Auer, S. Hellmann, J. Lehmann,
R. Cornelissen, and A. Zaveri, “Test-driven evaluation of Linked Data
quality,” in International Conference on World Wide Web, 2014, pp.
747–757.
4
ResearchGate has not been able to resolve any citations for this publication.
Article
Full-text available
Semantic and cloud computing technologies have become vital elements for developing and deploying solutions across diverse fields in computing. While they are independent of each other, they can be integrated in diverse ways for developing solutions and this has been significantly explored in recent times. With the migration of web-based data and applications to cloud platforms and the evolution of the web itself from a social, web 2.0 to a semantic, web 3.0 comes as the convergence of both technologies. While several concepts and implementations have been provided regarding interactions between the two technologies from existing research, without an explicit classification of the modes of interaction, it can be quite challenging to articulate the interaction modes; hence, building upon them can be a very daunting task. Hence, this research identifies and describes the modes of interaction between them. Furthermore, a “cloud-driven” interaction mode which focuses on fully maximising cloud computing characteristics and benefits for driving the semantic web is described, providing an approach for evolving the semantic web and delivering automated semantic annotation on a large scale to web applications.
Conference Paper
Full-text available
The rational management of software defects is a fundamental requirement for a mature software industry. Standards, guides and capability models directly emphasize how important it is for an organization to know and to have a well-established history of failures, errors and defects as they occur in software activities. The problem is that each of these reference models employs its own vocabulary to deal with these phenomena, which can lead to a deficiency in the understanding of these notions by software engineers, potential interoperability problems between supporting tools, and, consequently, to a poorer adoption of these standards and tools in practice. We address this problem of the lack of a consensual conceptualization in this area by proposing a reference conceptual model (domain ontology) of Software Defects, Errors and Failures, which takes into account an ecosystem of software artifacts. The ontology is grounded on the Unified Foundational Ontology (UFO) and is based on well-known standards, guides and capability models. We demonstrate how this approach can suitably promote conceptual clarification and terminological harmonization in this area.
Article
Full-text available
PaaS is a Cloud computing service that provides a computing platform to develop, run, and manage applications without the complexity of infrastructure maintenance. SMEs are reluctant to enter the growing PaaS market due to the possibility of being locked in to a certain platform, mostly provided by the market's giants. The PaaSport Marketplace aims to avoid the provider lock-in problem by allowing Platform provider SMEs to roll out semantically interoperable PaaS offerings and Software SMEs to deploy or migrate their applications on the best-matching offering, through a thin, non-intrusive Cloud broker. In this paper, we present the PaaSport semantic model, namely an OWL ontology, extension of the DUL ontology. The ontology is used for semantically representing a) PaaS offering capabilities and b) requirements of applications to be deployed. The ontology has been designed to optimally support a semantic matchmaking and ranking algorithm that recommends the best-matching PaaS offering to the application developer. The DUL ontology offers seamless extensibility, since both PaaS Characteristics and parameters are defined as classes; therefore, extending the ontology with new characteristics and parameters requires the addition of new specialized subclasses of the already existing classes, which is less complicated than adding ontology properties. The PaaSport ontology is evaluated through verification tools, competency questions, human experts, application tasks and query performance tests.
Conference Paper
Full-text available
During the last years we have seen a dramatic increase of new Cloud providers, applications, services, management platforms, data, etc. reaching a level of complexity that implies the necessity of new solutions to deal with such vast, shared and heterogeneous services and resources. Consequently, challenges often related to interoperability, portability, security, discovery, selection, negotiation and description of cloud service and resource may take place. In this sense, Semantic Web Technologies, holding a great potential to cloud computing, have been proven as an efficient means to relive these challenges. This paper examines and explores the role of Semantic Web Technologies in the cloud from a wide variety of literatures. Various approaches, architectures, and frameworks are screened and evaluated based on eight prime research questions. At the end of the review, research opportunities in the form of a roadmap are discussed.
Chapter
To improve cloud portability and interoperability many standards have been proposed in order to facilitate the design, the development and deployment of cloud applications. One of the most used is TOSCA (Topology and Orchestration Specification for Cloud Applications). However since TOSCA helps modeling the structure of an application there are some information regarding the domain of the application that are missing on the standard. We propose to use an ontology representation of that standard to fill the gap between the structural aspect and the domain of the applications.
Article
Context: Open standards are urgently needed for enabling software interoperability in Cloud Computing. Open Cloud Computing Interface (OCCI) provides a set of best design principles to create interoperable REST management APIs. Although OCCI is the only standard addressing the management of any kind of cloud resources, it does not support a range of best principles related to REST design. This often worsens REST API quality by decreasing their understandability and reusability. Objective: We aim at assisting cloud developers to enhance their REST management APIs by providing a compliance evaluation of OCCI and REST best principles and a recommendation support to comply with these principles. Method: First, we leverage patterns and anti-patterns to drive respectively the good and poor practices of OCCI and REST best principles. Then, we propose a semantic-based approach for defining and detecting REST and OCCI (anti)patterns and providing a set of correction recommendations to comply with both REST and OCCI best principles. We validated this approach by applying it on cloud REST APIs and evaluating its accuracy, usefulness and extensibility. Results: We found that our approach accurately detects OCCI and REST(anti)patterns and provides useful recommendations. According to the compliance results, we reveal that there is no widespread adoption of OCCI principles in existing APIs. In contrast, these APIs have reached an acceptable level of maturity regarding REST principles. Conclusion: Our approach provides an effective and extensible technique for defining and detecting OCCI and REST (anti)patterns in Cloud REST APIs. Cloud software developers can benefit from our approach and defined principles to accurately evaluate their APIs from OCCI and REST perspectives. This contributes in designing interoperable, understandable, and reusable Cloud management APIs. Thank to the compliance analysis and the recommendation support, we also contribute to improving these APIs, which make them more straightforward.
Conference Paper
Cloud computing enables enterprises to realise significant cost savings whilst accelerating the development of new innovative applications. Nevertheless, due to security concerns, enterprises are reluctant to migrate their operations to the cloud. In addition, the proliferation of cloud services transforms the enterprise IT environment into a complex ecosystem of collaborating services. One way to tame this complexity and alleviate the security concerns is to rely on policies that regulate the deployment, delivery and governance of cloud services. However, the heterogeneity inherent in such services, coupled with the dynamic nature of cloud environments, hinders the formulation of effective and interoperable policies. This paper proposes a generic framework for the definition and representation of policies that are enforceable across diverse administrative domains and are amenable to automated correctness checks.