The TOSCA Simple Profile in YAML specifies a
rendering of TOSCA which aims to provide a more accessible syntax
as well as a more concise and incremental expressiveness of the
TOSCA DSL in order to minimize the learning curve and speed the
adoption of the use of TOSCA to portably describe cloud
applications.
This proposal describes a YAML rendering for
TOSCA. YAML is a human friendly data serialization standard
(http://yaml.org/) with a syntax
much easier to read and edit than XML. As there are a number of
DSLs encoded in YAML, a YAML encoding of the TOSCA DSL makes TOSCA
more accessible by these communities.
This proposal prescribes an isomorphic
rendering in YAML of a subset of the TOSCA v1.0 ensuring that TOSCA
semantics are preserved and can be transformed from XML to YAML or
from YAML to XML. Additionally, in order to streamline the
expression of TOSCA semantics, the YAML rendering is sought to be
more concise and compact through the use of the YAML syntax.
1.2 Summary of key TOSCA concepts [comment?]
The TOSCA metamodel uses the concept of
service templates to describe cloud workloads as a topology
template, which is a graph of node templates modeling the
components a workload is made up of and as relationship templates
modeling the relations between those components. TOSCA further
provides a type system of node types to describe the possible
building blocks for constructing a service template, as well as
relationship type to describe possible kinds of relations. Both
node and relationship types may define lifecycle operations to
implement the behavior an orchestration engine can invoke when
instantiating a service template. For example, a node type for some
software product might provide a ‘create’ operation to
handle the creation of an instance of a component at runtime, or a
‘start’ or ‘stop’ operation to handle a
start or stop event triggered by an orchestration engine. Those
lifecycle operations are backed by implementation artifacts such as
scripts or Chef recipes that implement the actual behavior.
An orchestration engine processing a TOSCA
service template uses the mentioned lifecycle operations to
instantiate single components at runtime, and it uses the
relationship between components to derive the order of component
instantiation. For example, during the instantiation of a two-tier
application that includes a web application that depends on a
database, an orchestration engine would first invoke the
‘create’ operation on the database component to install
and configure the database, and it would then invoke the
‘create’ operation of the web application to install
and configure the application (which includes configuration of the
database connection).
The TOSCA simple profile assumes a number
of base types (node types and relationship types) to be supported
by each compliant environment such as a ‘Compute’ node
type, a ‘Network’ node type or a generic
‘Database’ node type. Furthermore, it is envisioned
that a large number of additional types for use in service
templates will be defined by a community over time. Therefore,
template authors in many cases will not have to define types
themselves but can simply start writing service templates that use
existing types. In addition, the simple profile will provide means
for easily customizing and extending existing types, for example by
providing a customized ‘create’ script for some
software.
Different kinds of processors and
artifacts qualify as implementations of the TOSCA simple profile.
Those that this specification is explicitly mentioning or referring
to fall into the following categories:
·
TOSCA YAML service template: A YAML document artifact containing a
(TOSCA) service template that represents a Cloud application.
·
TOSCA processor: An engine or tool that is capable of parsing and
interpreting a TOSCA YAML service template for a particular
purpose. For example, the purpose could be validation, translation
or visual rendering.
·
TOSCA orchestrator (also called orchestration engine): A TOSCA
processor that interprets a TOSCA YAML service template then
instantiates and deploys the described application in a Cloud.
·
TOSCA generator: A tool that generates a TOSCA YAML service
template. An example of generator is a modeling tool capable of
generating or editing a TOSCA YAML service template (often such a
tool would also be a TOSCA processor).
·
TOSCA archive (or TOSCA Cloud Service Archive, or
“CSAR”): a package artifact that contains a TOSCA YAML
service template and other artifacts usable by a TOSCA orchestrator
to deploy an application.
The above list is not exclusive. The above
definitions should be understood as referring to and implementing
the TOSCA simple profile as described in this document (abbreviated
here as “TOSCA” for simplicity).
The TOSCA language introduces a YAML grammar
for describing ervice templates by means of Topology Templates and
towards enablement of interaction with a TOSCA instance model
perhaps by external APIs or plans. The primary currently is on
design time aspects, i.e. the description of services to ensure
their exchange between Cloud providers, TOSCA Orchestrators and
tooling.
The language provides an extension mechanism
that can be used to extend the definitions with additional
vendor-specific or domain-specific information.
1.5 Notational
Conventions [comment?]
The key words “MUST”, “MUST
NOT”, “REQUIRED”, “SHALL”,
“SHALL NOT”, “SHOULD”, “SHOULD
NOT”, “RECOMMENDED”, “MAY”, and
“OPTIONAL” in this document are to be interpreted as
described in [RFC2119].
1.6 Normative References [comment?]
|
[RFC2119]
|
S. Bradner, Key words for use in RFCs to
Indicate Requirement Levels, http://www.ietf.org/rfc/rfc2119.txt,
IETF RFC 2119, March 1997.
|
|
[TOSCA-1.0]
|
Topology and Orchestration Topology and
Orchestration Specification for Cloud Applications (TOSCA) Version
1.0, an OASIS Standard, 25 November 2013, http://docs.oasis-open.org/tosca/TOSCA/v1.0/os/TOSCA-v1.0-os.pdf
|
|
[YAML-1.2]
|
YAML, Version 1.2, 3rd Edition, Patched at
2009-10-01, Oren Ben-Kiki, Clark Evans, Ingy döt Net http://www.yaml.org/spec/1.2/spec.html
|
|
[YAML-TS-1.1]
|
Timestamp Language-Independent Type for YAML
Version 1.1, Working Draft 2005-01-18, http://yaml.org/type/timestamp.html
|
1.7 Non-Normative References [comment?]
The following terms are used
throughout this specification and have the following definitions
when used in context of this document.
|
Term
|
Definition
|
|
Instance
Model
|
A deployed service is a running instance of a
Service Template. More precisely, the instance is derived by
instantiating the Topology Template of its Service Template, most
often by running a special plan defined for the Service Template,
often referred to as build plan.
|
|
Node Template
|
A Relationship Template specifies the
occurrence of a software component node as part of a Topology
Template. Each Node Template refers to a Node Type that defines the
semantics of the node (e.g., properties, attributes, requirements,
capabilities, interfaces). Node Types are defined separately for
reuse purposes.
|
|
Relationship
Template
|
A Relationship Template specifies the
occurrence of a relationship between nodes in a Topology Template.
Each Relationship Template refers to a Relationship Type that
defines the semantics relationship (e.g., properties, attributes,
interfaces, etc.). Relationship Types are defined separately for
reuse purposes.
|
|
Service
Template
|
A Service Template is typically used to specify the
“topology” (or structure) and
“orchestration” (or invocation of management behavior)
of IT services so that they can be provisioned and managed in
accordance with constraints and policies.
Specifically, TOSCA Service Templates optionally
allow definitions of a TOSCA Topology Template , TOSCA types
(e.g., Node, Relationship, Capability, Artifact, etc.), groupings,
policies and constraints along with any input or output
declarations.
|
|
Topology
Model
|
The term Topology Model is often used synonymously
with the term Topology
Template with the use of “model” being prevalent
when considering a Service Template’s topology definition as
an abstract representation of
an application or service to facilitate understanding of its
functional components and by eliminating unnecessary details.
|
|
Topology
Template
|
A Topology Template defines the structure of a
service in the context of a Service Template. A Topology Template
consists of a set of Node Template and Relationship Template
definitions that together define the topology model of a service as
a (not necessarily connected) directed graph.
The term Topology Template is often used
synonymously with the term Topology
Model. The distinction is that a topology template can be
used to instantiate and orchestrate the model as a reusable pattern and includes all details necessary to
accomplish it.
|
|
|
|
This non-normative section contains
several sections that show how to model applications with TOSCA
Simple Profile using YAML by example starting with a “Hello
World” template up through examples that show complex
composition modeling.
2.1
A “hello world” template for TOSCA Simple Profile in
YAML [comment?]
As mentioned before, the TOSCA simple
profile assumes the existence of a small set of pre-defined,
normative set of node types (e.g., a ‘Compute’ node)
along with other types, which will be introduced through the course
of this document, for creating TOSCA Service Templates. It is
envisioned that many additional node types for building service
templates will be created by communities some may be published as
profiles that build upon the TOSCA Simple Profile specification.
Using the normative TOSCA Compute node type, a very basic
“Hello World” TOSCA template for deploying just a
single server would look as follows:
Example 1 - TOSCA
Simple "Hello World"
|
tosca_definitions_version:
tosca_simple_yaml_1_0
description:
Template for deploying a single server with predefined
properties.
topology_template:
node_templates:
my_server:
type: tosca.nodes.Compute
capabilities:
# Host
container properties
host:
properties:
num_cpus: 1
disk_size: 10 GB
mem_size: 4096 MB
# Guest
Operating System properties
os:
properties:
# host Operating
System image properties
architecture: x86_64
type: linux
distribution:
rhel
version:
6.5
|
The template above contains a very
simple topology template with only a single ‘Compute’
node template that declares some basic values for properties within
two of the several capabilities that are built into the Compute
node type definition. All TOSCA Orchestrators are expected to
know how to instantiate a Compute node since it is normative and
expected to represent a well-known function that is portable across
TOSCA implementations. This expectation is true for all
normative TOSCA Node and Relationship types that are defined in the
Simple Profile specification. This means, with TOSCA’s
approach, that the application developer does not need to provide
any deployment or implementation artifacts that contain code or
logic to orchestrate these common software components. TOSCA
orchestrators simply select or allocate the correct node (resource)
type that fulfils the application topologies requirements using the
properties declared in the node and its capabilities.
In the above example, the
“host”
capability contains properties that allow application developers to
optionally supply the number of CPUs, memory size and disk size
they believe they need when the Compute node is instantiated in
order to run their applications. Similarly, the “os” capability is used to
provide values to indicate what host operating system the Compute
node should have when it is instantiated.
The logical diagram of the “hello
world” Compute node would look as follows:
As you can see, the Compute node also has attributes and
other built-in capabilities, such as Bindable and Endpoint, each with additional
properties that will be discussed in other examples later in this
document. Although the Compute node has no direct properties
apart from those in its capabilities, other TOSCA node type
definitions may have properties that are part of the node type
itself in addition to having Capabilities. TOSCA
orchestration engines are expected to validate all property values
provided in a node template against the property definitions in
their respective node type definitions referenced in the service
template. The tosca_definitions_version keyname in
the TOSCA service template identifies the versioned set of
normative TOSCA type definitions to use for validating those types
defined in the TOSCA Simple Profile including the Compute node
type. Specifically, the value tosca_simple_yaml_1_0 indicates
Simple Profile v1.0.0 definitions would be used for
validation. Other type definitions may be imported from other
service templates using the import keyword discussed later.
2.1.1 Requesting input parameters and providing
output [comment?]
Typically, one would want to allow users
to customize deployments by providing input parameters instead of
using hardcoded values inside a template. In addition, output
values are provided to pass information that perhaps describes the
state of the deployed template to the user who deployed it (such as
the private IP address of the deployed server). A refined service
template with corresponding inputs and outputs sections is shown below.
Example 2 - Template with input and output parameter
sections
|
tosca_definitions_version:
tosca_simple_yaml_1_0
description:
Template for deploying a single server with predefined
properties.
topology_template:
inputs:
cpus:
type: integer
description: Number of CPUs for the
server.
constraints:
- valid_values: [ 1, 2, 4, 8 ]
node_templates:
my_server:
type: tosca.nodes.Compute
capabilities:
# Host
container properties
host:
properties:
# Compute properties
num_cpus:
{ get_input: cpus }
mem_size:
2048 MB
disk_size: 10
GB
outputs:
server_ip:
description: The private IP address of the
provisioned server.
value: { get_attribute: [ my_server,
private_address ] }
|
The inputs and outputs sections are contained in the
topology_template element
of the TOSCA template, meaning that they are scoped to node
templates within the topology template. Input parameters defined in
the inputs section can be assigned to properties of node template
within the containing topology template; output parameters can be
obtained from attributes of node templates within the containing
topology template.
Note that the inputs section of a TOSCA template
allows for defining optional constraints on each input parameter to
restrict possible user input. Further note that TOSCA provides for
a set of intrinsic functions like get_input, get_property or get_attribute to reference elements
within the template or to retrieve runtime values.
2.2 TOSCA template for a simple software
installation [comment?]
Software installations can be modeled in TOSCA
as node templates that get related to the node template for a
server on which the software shall be installed. With a number of
existing software node types (e.g. either created by the TOSCA work
group or a community) template authors can just use those node
types for writing service templates as shown below.
Example 3 - Simple
(MySQL) software installation on a TOSCA Compute node
|
tosca_definitions_version:
tosca_simple_yaml_1_0
description:
Template for deploying a single server with MySQL software on
top.
topology_template:
inputs:
#
omitted here for brevity
node_templates:
mysql:
type: tosca.nodes.DBMS.MySQL
properties:
root_password: { get_input:
my_mysql_rootpw }
port: { get_input: my_mysql_port
}
requirements:
- host: db_server
db_server:
type: tosca.nodes.Compute
capabilities:
# omitted
here for brevity
|
The example above makes use of a node
type tosca.nodes.DBMS.MySQL for the
mysql node template to
install MySQL on a server. This node type allows for setting a
property root_password to
adapt the password of the MySQL root user at deployment. The set of
properties and their schema has been defined in the node type
definition. By means of the get_input function, a value provided by the user
at deployment time is used as value for the root_password property. The same is true for the
port property.
The mysql
node template is related to the db_server node template (of type tosca.nodes.Compute) via the
requirements section to indicate
where MySQL is to be installed. In the TOSCA metamodel, nodes get
related to each other when one node has a requirement against some
feature provided by another node. What kinds of requirements exist
is defined by the respective node type. In case of MySQL, which is
software that needs to be installed or hosted on a compute
resource, the underlying node type named DBMS has a predefined requirement
called host, which needs to be
fulfilled by pointing to a node template of type tosca.nodes.Compute.
The logical relationship between the
mysql node and its host
db_server node would
appear as follows:
Within the requirements section, all entries
simple entries are a map which contains the symbolic name of a
requirement definition as the key and the identifier of the
fulfilling node as the value. The value is essentially the
symbolic name of the other node template; specifically, or the
example above, the host requirement
is fulfilled by referencing the db_server node template. The
underlying TOSCA DBMS
node type already defines a complete requirement definition for the
host requirement of type
Container and assures
that a HostedOn TOSCA
relationship will automatically be created and will only allow a
valid target host node is of type Compute. This approach allows
the template author to simply provide the name of a valid
Compute node (i.e.,
db_server) as the value
for the mysql
node’s host
requirement and not worry about defining anything more complex if
they do not want to.
2.3 Overriding behavior of predefined node
types [comment?]
Node types in TOSCA have associated
implementations that provide the automation (e.g. in the form of
scripts such as Bash, Chef or Python) for the normative lifecycle
operations of a node. For example, the node type implementation for
a MySQL database would associate scripts to TOSCA node operations
like configure,
start, or stop to manage the state of MySQL at
runtime.
Many node types may already come with a
set of operational scripts that contain basic commands that can
manage the state of that specific node. If it is desired, template
authors can provide a custom script for one or more of the
operation defined by a node type in their node template which will
override the default implementation in the type. The
following example shows a mysql node template where the
template author provides their own configure script:
Example 4 - Node
Template overriding its Node Type's "configure" interface
|
tosca_definitions_version:
tosca_simple_yaml_1_0
description:
Template for deploying a single server with MySQL software on
top.
topology_template:
inputs:
#
omitted here for brevity
node_templates:
mysql:
type: tosca.nodes.DBMS.MySQL
properties:
root_password: { get_input:
my_mysql_rootpw }
port: { get_input: my_mysql_port
}
requirements:
- host: db_server
interfaces:
Standard:
configure: scripts/my_own_configure.sh
db_server:
type: tosca.nodes.Compute
capabilities:
# omitted
here for brevity
|
In the example above, the my_own_configure.sh script is
provided for the configure operation of the MySQL node
type’s Standard
lifecycle interface. The path given in the example above (i.e.,
‘scripts/’) is interpreted relative to the template
file, but it would also be possible to provide an absolute URI to
the location of the script.
In other words, operations defined by node
types can be thought of as “hooks” into which
automation can be injected. Typically, node type implementations
provide the automation for those “hooks”. However,
within a template, custom automation can be injected to run in a
hook in the context of the one, specific node template (i.e.
without changing the node type).
2.4 TOSCA template for database content
deployment [comment?]
In the example shown in section 4 the deployment of the MySQL middleware
only, i.e. without actual database content was shown. The following
example shows how such a template can be extended to also contain
the definition of custom database content on-top of the MySQL DBMS
software.
Example 5 -
Template for deploying database content on-top of MySQL DBMS
middleware
|
tosca_definitions_version:
tosca_simple_yaml_1_0
description:
Template for deploying MySQL and database content.
topology_template:
inputs:
#
omitted here for brevity
node_templates:
my_db:
type:
tosca.nodes.Database.MySQL
properties:
name: {
get_input: database_name }
user: {
get_input: database_user }
password: { get_input:
database_password }
port: {
get_input: database_port }
artifacts:
db_content:
file: files/my_db_content.txt
type: tosca.artifacts.File
requirements:
- host:
mysql
interfaces:
Standard:
create:
implementation: db_create.sh
inputs:
# Copy DB file artifact to server’s staging area
db_data: { get_artifact: [ SELF, db_content ] }
mysql:
type: tosca.nodes.DBMS.MySQL
properties:
root_password: { get_input: mysql_rootpw }
port: { get_input: mysql_port
}
requirements:
- host: db_server
db_server:
type: tosca.nodes.Compute
capabilities:
# omitted
here for brevity
|
In the example above, the my_db node template or type
tosca.nodes.Database.MySQL represents
an actual MySQL database instance managed by a MySQL DBMS
installation. The requirements section of the
my_db node template
expresses that the database it represents is to be hosted on a
MySQL DBMS node template named mysql which is also declared in this
template.
In its artifacts section of the
my_db the node template,
there is an artifact definition named db_content which represents a text
file my_db_content.txt which in turn will
be used to add content to the SQL database as part of the
create operation. The
requirements section of the my_db node template
expresses that the database is hosted on a MySQL DBMS represented
by the mysql node.
As you can see above, a script is associated
with the create operation with the name db_create.sh. The TOSCA
Orchestrator sees that this is not a named artifact declared in the
node’s artifact section, but instead a filename for a
normative TOCA implementation artifact script type (i.e.,
tosca.artifacts.Implementation.Bash).
Since this is an implementation type for TOSCA, the orchestrator
will execute the script automatically to create the node on
db_server, but first it
will prepare the local environment with the declared inputs for the
operation. In this case, the orchestrator would see that the
db_data input is using
the get_artifact function
to retrieve the file (my_db_content.txt) which is
associated with the db_content artifact name prior to
executing the db_create.sh script.
The logical diagram for this example would
appear as follows:
Note that while it would be possible to
define one node type and corresponding node templates that
represent both the DBMS middleware and actual database content as
one entity, TOSCA normative node types distinguish between
middleware (container) and application (containee) node types. This
allows on one hand to have better re-use of generic middleware node
types without binding them to content running on top of them, and
on the other hand this allows for better substitutability of, for
example, middleware components like a DBMS during the deployment of
TOSCA models.
2.5 TOSCA template for
a two-tier application [comment?]
The definition of multi-tier applications
in TOSCA is quite similar to the example shown in section 2.2, with
the only difference that multiple software node stacks (i.e., node
templates for middleware and application layer components),
typically hosted on different servers, are defined and related to
each other. The example below defines a web application stack
hosted on the web_server
“compute” resource, and a database software stack
similar to the one shown earlier in section 6 hosted on the
db_server compute resource.
Example 6 - Basic
two-tier application (web application and database server
tiers)
|
tosca_definitions_version:
tosca_simple_yaml_1_0
description:
Template for deploying a two-tier application servers on
two
topology_template:
inputs:
#
Admin user name and password to use with the WordPress
application
wp_admin_username:
type: string
wp_admin_password:
type: string
wp_db_name:
type: string
wp_db_user:
type: string
wp_db_password:
type: string
wp_db_port:
type: integer
mysql_root_password:
type: string
mysql_port:
type: integer
context_root:
type:
string
node_templates:
wordpress:
type: tosca.nodes.WebApplication.WordPress
properties:
context_root: { get_input: context_root }
admin_user: { get_input:
wp_admin_username }
admin_password: { get_input:
wp_admin_password }
db_host: {
get_attribute: [ db_server, private_address ] }
requirements:
- host: apache
-
database_endpoint: wordpress_db
interfaces:
Standard:
inputs:
db_host: { get_attribute: [
db_server, private_address ] }
db_port: { get_property: [ wordpress_db,
port ] }
db_name: { get_property: [ wordpress_db, name ]
}
db_user:
{ get_property: [ wordpress_db, user ] }
db_password:
{ get_property: [ wordpress_db, password ] }
apache:
type:
tosca.nodes.WebServer.Apache
properties:
# omitted
here for brevity
requirements:
- host: web_server
web_server:
type: tosca.nodes.Compute
capabilities:
# omitted
here for brevity
wordpress_db:
type: tosca.nodes.Database.MySQL
properties:
name: {
get_input: wp_db_name }
user: { get_input: wp_db_user
}
password: { get_input:
wp_db_password }
port: { get_input: wp_db_port }
requirements:
- host: mysql
mysql:
type: tosca.nodes.DBMS.MySQL
properties:
root_password: { get_input: mysql_root_password
}
port: { get_input: mysql_port
}
requirements:
- host: db_server
db_server:
type: tosca.nodes.Compute
capabilities:
# omitted
here for brevity
|
The web
application stack consists of the wordpress, the
apache and the web_server node templates. The
wordpress node template represents a custom web application
of type tosca.nodes.WebApplication.WordPress which is hosted
on an Apache web server represented by the apache node
template. This hosting relationship is expressed via the
host entry in the requirements section of the
wordpress node template. The apache node template,
finally, is hosted on the web_server compute node.
The database stack consists of the
wordpress_db, the mysql and the db_server node
templates. The wordpress_db node represents a custom
database of type tosca.nodes.Database.MySQL which is hosted
on a MySQL DBMS represented by the mysql node template. This
node, in turn, is hosted on the db_server compute node.
The wordpress node requires a
connection to the wordpress_db node, since the WordPress
application needs a database to store its data in. This
relationship is established through the database_endpoint entry in the
requirements section of the wordpress node
template’s declared node type. For configuring the WordPress
web application, information about the database to connect to is
required as input to the configure operation. Therefore, the
input parameters are defined and values for them are retrieved from
the properties and attributes of the wordpress_db node via
the get_property and get_attribute functions. In the above
example, these inputs are defined at the interface-level and would
be available to all operations of the Standard interface (i.e., the
tosca.interfaces.node.lifecycle.Standard
interface) within the wordpress node template and not just
the configure
operation.
2.6 Using a custom script to establish a
relationship in a template [comment?]
In previous examples, the template author
did not have to think about explicit relationship types to be used
to link a requirement of a node to another node of a model, nor did
the template author have to think about special logic to establish
those links. For example, the host
requirement in previous examples just pointed to another node
template and based on metadata in the corresponding node type
definition the relationship type to be established is implicitly
given.
In some cases it might be necessary to
provide special processing logic to be executed when establishing
relationships between nodes at runtime. For example, when
connecting the WordPress application from previous examples to the
MySQL database, it might be desired to apply custom configuration
logic in addition to that already implemented in the application
node type. In such a case, it is possible for the template
author to provide a custom script as implementation for an
operation to be executed at runtime as shown in the following
example.
Example 7 –
Providing a custom relationship script to establish a
connection
|
tosca_definitions_version: tosca_simple_yaml_1_0
description: Template
for deploying a two-tier application on two servers.
topology_template:
inputs:
#
omitted here for brevity
node_templates:
wordpress:
type: tosca.nodes.WebApplication.WordPress
properties:
# omitted here for
brevity
requirements:
- host:
apache
- database_endpoint:
node: wordpress_db
relationship:
my_custom_database_connection
wordpress_db:
type: tosca.nodes.Database.MySQL
properties:
# omitted here for
the brevity
requirements:
- host: mysql
relationship_templates:
my_custom_database_connection:
type: ConnectsTo
interfaces:
Configure:
pre_configure_source: scripts/wp_db_configure.sh
# other
resources not shown for this example ...
|
The node type definition for the
wordpress node template
is WordPress which
declares the complete database_endpoint requirement
definition. This database_endpoint declaration
indicates it must be fulfilled by any node template that provides
an Endpoint.Database
Capability Type using a ConnectsTo relationship. The wordpress_db node template’s
underlying MySQL type
definition indeed provides the Endpoint.DatabaseCapability
type. In this example however, no explicit relationship
template is declared; therefore TOSCA orchestrators would
automatically create a ConnectsTo relationship to establish the
link between the wordpress node and the wordpress_db node at runtime.
The ConnectsTo relationship (see 5.6.4) also
provides a default Configure interface with operations
that optionally get executed when the orchestrator establishes the
relationship. In the above example, the author has provided the
custom script wp_db_configure.sh to
be executed for the operation called pre_configure_source. The script file is assumed
to be located relative to the referencing service template such as
a relative directory within the TOSCA Cloud Service Archive (CSAR)
packaging format. This approach allows for conveniently hooking in
custom behavior without having to define a completely new derived
relationship type.
2.7 Using custom
relationship types in a TOSCA template [comment?]
In the previous section it was shown how
custom behavior can be injected by specifying scripts inline in the
requirements section of node templates. When the same custom
behavior is required in many templates, it does make sense to
define a new relationship type that encapsulates the custom
behavior in a re-usable way instead of repeating the same reference
to a script (or even references to multiple scripts) in many
places.
Such a custom relationship type can then
be used in templates as shown in the following example.
Example 8 – A
web application Node Template requiring a custom database
connection type
|
tosca_definitions_version:
tosca_simple_yaml_1_0
description:
Template for deploying a two-tier application on two
servers.
topology_template:
inputs:
#
omitted here for brevity
node_templates:
wordpress:
type: tosca.nodes.WebApplication.WordPress
properties:
# omitted here for
brevity
requirements:
- host:
apache
- database_endpoint:
node: wordpress_db
relationship: my.types.WordpressDbConnection
wordpress_db:
type:
tosca.nodes.Database.MySQL
properties:
# omitted
here for the brevity
requirements:
- host:
mysql
# other
resources not shown here ...
|
In the example above, a special
relationship type my.types.WordpressDbConnection is specified for
establishing the link between the wordpress node and the wordpress_db node through the use of the
relationship (keyword) attribute in
the database reference. It is
assumed, that this special relationship type provides some extra
behavior (e.g., an operation with a script) in addition to what a
generic “connects to” relationship would provide. The
definition of this custom relationship type is shown in the
following section.
2.7.1
Definition of a custom relationship type [comment?]
The following YAML snippet shows the
definition of the custom relationship type used in the previous
section. This type derives from the base “ConnectsTo”
and overrides one operation defined by that base relationship type.
For the pre_configure_source operation
defined in the Configure
interface of the ConnectsTo relationship type, a script
implementation is provided. It is again assumed that the custom
configure script is located at a location relative to the
referencing service template, perhaps provided in some application
packaging format (e.g., the TOSCA Cloud Service Archive (CSAR)
format).
Example 9 -
Defining a custom relationship type
|
tosca_definitions_version:
tosca_simple_yaml_1_0
description:
Definition of custom WordpressDbConnection relationship
type
relationship_types:
my.types.WordpressDbConnection:
derived_from: tosca.relationships.ConnectsTo
interfaces:
Configure:
pre_configure_source: scripts/wp_db_configure.sh
|
In the above
example, the Configure interface is the specified
alias or shorthand name for the TOSCA interface type with the full
name of tosca.interfaces.relationship.Configure
which is defined in the appendix.
2.8 Defining generic
dependencies between nodes in a template [comment?]
In some cases it can be necessary to
define a generic dependency between two nodes in a template to
influence orchestration behavior, i.e. to first have one node
processed before another dependent node gets processed. This can be
done by using the generic dependency requirement which is defined by the
TOSCA Root Node Type and thus
gets inherited by all other node types in TOSCA (see section
5.8.1).
Example 10 - Simple
dependency relationship between two nodes
|
tosca_definitions_version:
tosca_simple_yaml_1_0
description:
Template with a generic dependency between two nodes.
topology_template:
inputs:
#
omitted here for brevity
node_templates:
my_app:
type: my.types.MyApplication
properties:
# omitted here for
brevity
requirements:
-
dependency: some_service
some_service:
type: some.nodetype.SomeService
properties:
# omitted
here for brevity
|
As in previous examples, the relation
that one node depends on another node is expressed in the
requirements section using the
built-in requirement named dependency that exists for all node types in
TOSCA. Even if the creator of the MyApplication node type did not define a specific
requirement for SomeService
(similar to the database
requirement in the example in section 2.6), the template author who
knows that there is a timing dependency and can use the generic
dependency requirement to
express that constraint using the very same syntax as used for all
other references.
2.9 Describing abstract
requirements for nodes and capabilities in a TOSCA
template [comment?]
In TOSCA templates, nodes are either:
·
Concrete: meaning that they have a deployment and/or one or
more implementation artifacts that are declared on the
“create” operation of the node’s Standard
lifecycle interface, or they are
·
Abstract: where the template describes the node type along
with its required capabilities and properties that must be
satisfied.
TOSCA Orchestrators, by default, when finding
an abstract node in TOSCA Service Template during deployment will
attempt to “select” a concrete implementation for the
abstract node type that best matches and fulfills the requirements
and property constraints the template author provided for that
abstract node. The concrete implementation of the node could be
provided by another TOSCA Service Template (perhaps located in a
catalog or repository known to the TOSCA Orchestrator) or by an
existing resource or service available within the target Cloud
Provider’s platform that the TOSCA Orchestrator already has
knowledge of.
TOSCA supports two methods for template
authors to express requirements for an abstract node within a TOSCA
service template.
1. Using a target
node_filter: where a node template can describe a requirement
(relationship) for another node without including it in the
topology. Instead, the node provides a node_filter to describe the
target node type along with its capabilities and property
constrains
2. Using an
abstract node template: that describes the abstract
node’s type along with its property constraints and any
requirements and capabilities it also exports. This first
method you have already seen in examples from previous chapters
where the Compute node is abstract and selectable by the TOSCA
Orchestrator using the supplied Container and OperatingSystem capabilities
property constraints.
These approaches allows architects and
developers to create TOSCA service templates that are composable
and can be reused by allowing flexible matching of one
template’s requirements to another’s capabilities.
Examples of both these approaches are shown below.
2.9.1 Using a node_filter to define
hosting infrastructure requirements for a software [comment?]
Using TOSCA, it is possible to define only
the software components of an application in a template and just
express constrained requirements against the hosting
infrastructure. At deployment time, the provider can then do a late
binding and dynamically allocate or assign the required hosting
infrastructure and place software components on top.
This example shows how a single software
component (i.e., the mysql node template) can define its
host requirements
that the TOSCA Orchestrator and provider will use to select or
allocate an appropriate host Compute node by using matching
criteria provided on a node_filter.
Example 11 - An abstract "host" requirement
using a node filter
|
tosca_definitions_version:
tosca_simple_yaml_1_0
description:
Template with requirements against hosting
infrastructure.
topology_template:
inputs:
#
omitted here for brevity
node_templates:
mysql:
type: tosca.nodes.DBMS.MySQL
properties:
# omitted here for
brevity
requirements:
-
host:
node_filter:
capabilities:
# Constraints for selecting “host” (Container
Capability)
- host:
properties:
-
num_cpus: { in_range: [ 1, 4 ] }
-
mem_size: { greater_or_equal: 2 GB }
# Constraints for selecting “os” (OperatingSystem
Capability)
- os:
properties:
-
architecture: { equal: x86_64 }
-
type: linux
-
distribution: ubuntu
|
In the example above, the
mysql component contains a
host requirement for a
node of type Compute which it
inherits from its parent DBMS node type definition; however, there
is no declaration or reference to any node template of type
Compute. Instead, the
mysql node template
augments the abstract “host” requirement with a
node_filter which
contains additional selection criteria (in the form of property
constraints that the provider must use when selecting or allocating
a host Compute
node.
Some of the constraints shown above
narrow down the boundaries of allowed values for certain properties
such as mem_size or
num_cpus for the
“host”
capability by means of qualifier functions such as greater_or_equal. Other constraints, express
specific values such as for the architecture or distribution properties of the
“os”
capability which will require the provider to find a precise
match.
Note that when no qualifier function is
provided for a property (filter), such as for the distribution property, it is
interpreted to mean the equal operator as shown on the
architecture
property.
2.9.2 Using an
abstract node template to define infrastructure requirements for
software [comment?]
This previous approach works well if
no other component (i.e., another node template) other than
mysql node template wants
to reference the same Compute node the orchestrator would
instantiate. However, perhaps another component wants to also be
deployed on the same host, yet still allow the flexible matching
achieved using a node-filter. The alternative to the above
approach is to create an abstract node template that represents the
Compute node in the
topology as follows:
Example 12 - An abstract Compute node template
with a node filter
|
tosca_definitions_version:
tosca_simple_yaml_1_0
description:
Template with requirements against hosting
infrastructure.
topology_template:
inputs:
# omitted here for
brevity
node_templates:
mysql:
type:
tosca.nodes.DBMS.MySQL
properties:
#
omitted here for brevity
requirements:
- host: mysql_compute
# Abstract node template
(placeholder) to be selected by provider
mysql_compute:
type:
Compute
node_filter:
capabilities:
- host:
properties:
num_cpus:
{ equal: 2 }
mem_size:
{ greater_or_equal: 2 GB }
- os:
properties:
architecture:
{ equal: x86_64 }
type:
linux
distribution: ubuntu
|
As you can see the
resulting mysql_compute node template looks
very much like the “hello
world” template as shown in Chapter 2 (where the
Compute node template was
abstract), but this one also allows the TOSCA orchestrator more
flexibility when “selecting” a host Compute node by providing flexible
constraints for properties like mem_size.
As we proceed, you will see that TOSCA
provides many normative node types like Compute for commonly found services
(e.g., BlockStorage,
WebServer, Network, etc.). When these
TOSCA normative node types are used in your application’s
topology they are always assumed to be “selectable” by
TOSCA Orchestrators which work with target infrastructure providers
to find or allocate the best match for them based upon your
application’s requirements and constraints.
2.9.3 Using a node_filter to define
requirements on a database for an application [comment?]
In the same way requirements can be
defined on the hosting infrastructure (as shown above) for an
application, it is possible to express requirements against
application or middleware components such as a database that is not
defined in the same template. The provider may then allocate a
database by any means, (e.g. using a database-as-a-service
solution).
Example 13 - An abstract database requirement
using a node filter
|
tosca_definitions_version:
tosca_simple_yaml_1_0
description:
Template with a TOSCA Orchestrator selectable database requirement
using a node_filter.
topology_template:
inputs:
#
omitted here for brevity
node_templates:
my_app:
type: my.types.MyApplication
properties:
admin_user: { get_input:
admin_username }
admin_password: { get_input: admin_password
}
db_endpoint_url: { get_property: [SELF, database_endpoint, url_path ] }
requirements:
- database_endpoint:
node: my.types.nodes.MyDatabase
node_filter:
properties:
-
db_version: { greater_or_equal: 5.5 }
|
In the example above, the application
my_app requires a database node of
type MyDatabase which has
a db_version property
value of greater_or_equal
to the value 5.5.
This example also shows how the
get_property intrinsic
function can be used to retrieve the url_path property from the database
node that will be selected by the provider and connected to
my_app at runtime due to
fulfillment of the database_endpoint requirement. To
locate the property, the get_property’s first argument is set
to the keyword SELF which
indicates the property is being referenced from something in the
node itself. The second parameter is the name of the requirement
named database_endpoint which
contains the property are looking for. The last argument is the
name of the property itself (i.e., url_path) which contains the
value we want to retrieve and assign to db_endpoint_url.
The alternative representation, which
includes a node template in the topology for database that is still
selectable by the TOSCA orchestrator for the above example, is as
follows:
Example 14 - An abstract database node
template
|
tosca_definitions_version:
tosca_simple_yaml_1_0
description:
Template with a TOSCA Orchestrator selectable database using node
template.
topology_template:
inputs:
#
omitted here for brevity
node_templates:
my_app:
type: my.types.MyApplication
properties:
admin_user: { get_input:
admin_username }
admin_password: { get_input: admin_password
}
db_endpoint_url: { get_property: [SELF, database_endpoint, url_path ] }
requirements:
- database_endpoint: my_abstract_database
my_abstract_database:
type: my.types.nodes.MyDatabase
properties:
- db_version: { greater_or_equal: 5.5
}
|
2.10 Using node
template substitution for model composition [comment?]
From an application perspective, it is often
not necessary or desired to dive into platform details, but the
platform/runtime for an application is abstracted. In such cases,
the template for an application can use generic representations of
platform components. The details for such platform components, such
as the underlying hosting infrastructure at its configuration, can
then be defined in separate template files that can be used for
substituting the more abstract representations in the application
level template file.
2.10.1 Understanding node template
instantiation through a TOSCA Orchestrator [comment?]
When a topology template is instantiated by a
TOSCA Orchestrator, the orchestrator has to look for realizations
of the single node templates according to the node types specified
for each node template. Such realizations can either be node types
that include the appropriate implementation artifacts and
deployment artifacts that can be used by the orchestrator to bring
to life the real-world resource modeled by a node template.
Alternatively, separate topology templates may be annotated as
being suitable for realizing a node template in the top-level
topology template.
In the latter case, a TOSCA Orchestrator will
use additional substitution mapping information provided as part of
the substituting topology templates to derive how the substituted
part get “wired” into the overall deployment, for
example, how capabilities of a node template in the top-level
topology template get bound to capabilities of node templates in
the substituting topology template.
Thus, in cases where no “normal”
node type implementation is available, or the node type corresponds
to a whole subsystem that cannot be implemented as a single node,
additional topology templates can be used for filling in more
abstract placeholders in top level application templates.
2.10.2
Definition of the top-level service template [comment?]
The following sample defines a web
application web_appconnected to a
databasedb. In this example, the
complete hosting stack for the application is defined within the
same topology template: the web application is hosted on a web
server web_server, which
in turn is installed (hosted) on a compute node server.
The hosting stack for the database
db, in contrast, is not
defined within the same file but only the database is represented
as a node template of type tosca.nodes.Database. The underlying
hosting stack for the database is defined in a separate template
file, which is shown later in this section. Within the current
template, only a number of properties (user, password, name) are assigned to the database
using hardcoded values in this simple example.
Figure 1: Using template substitution to
implement a database tier
When a node template is to be substituted
by another service template, this has to be indicated to an
orchestrator by means of a special “substitutable”
directive. This directive causes, for example, special processing
behavior when validating the left-hand service template in Figure
1. The hosting requirement of the db node template is not bound to any
capability defined within the service template, which would
normally cause a validation error. When the
“substitutable” directive is present, the orchestrator
will however first try to perform substitution of the respective
node template and after that validate if all mandatory requirements
of all nodes in the resulting graph are fulfilled.
Note that in contrast to the use case
described in section 0 (where a database was abstractly referred to
in the requirements
section of a node and the database itself was not represented as a
node template), the approach shown here allows for some additional
modeling capabilities in cases where this is required.
For example, if multiple components shall use the same database (or
any other sub-system of the overall service), this can be expressed
by means of normal relations between node templates, whereas such
modeling would not be possible in requirements sections of disjoint
node templates.
Example 15 - Referencing an abstract database
node template
|
tosca_definitions_version:
tosca_simple_yaml_1_0
topology_template:
description: Template of an application connecting to a
database.
node_templates:
web_app:
type:
tosca.nodes.WebApplication.MyWebApp
requirements:
- host:
web_server
-
database_endpoint: db
web_server:
type:
tosca.nodes.WebServer
requirements:
- host:
server
server:
type:
tosca.nodes.Compute
# details omitted for
brevity
db:
# This node is
abstract (no Deploment or Implemenation artifacts on
create)
# and can be
substituted with a topology provided by another template
# that exports a
Database type’s capabilities.
type: tosca.nodes.Database
properties:
user:
my_db_user
password:
secret
name:
my_db_name
|
2.10.3 Definition of the database stack
in a service template [comment?]
The following sample defines a
template for a database including its complete hosting stack, i.e.
the template includes a database node template, a template
for the database management system (dbms) hosting the database, as well
as a computer node server
on which the DBMS is installed.
This service template can be used
standalone for deploying just a database and its hosting stack. In
the context of the current use case, though, this template can also
substitute the database node template in the previous snippet and
thus fill in the details of how to deploy the database.
In order to enable such a substitution, an
additional metadata section substitution_mappings is added to the
topology template to tell a TOSCA Orchestrator how exactly the
topology template will fit into the context where it gets used. For
example, requirements or capabilities of the node that gets
substituted by the topology template have to be mapped to
requirements or capabilities of internal node templates for allow
for a proper wiring of the resulting overall graph of node
templates.
In short, the substitution_mappings section
provides the following information:
1. It defines what node
templates, i.e. node templates of which type, can be substituted by
the topology template.
2. It defines how capabilities of
the substituted node (or the capabilities defined by the node type
of the substituted node template, respectively) are bound to
capabilities of node templates defined in the topology
template.
3. It defines how requirements of
the substituted node (or the requirements defined by the node type
of the substituted node template, respectively) are bound to
requirements of node templates defined in the topology
template.
Figure 2:
Substitution mappings
The substitution_mappings section in the
sample below denotes that this topology template can be used for
substituting node templates of type tosca.nodes.Database. It further
denotes that the database_endpoint capability of the
substituted node gets fulfilled by the database_endpoint capability of the
database node contained
in the topology template.
Example 16 - Using substitution mappings to
export a database implementation
|
tosca_definitions_version:
tosca_simple_yaml_1_0
topology_template:
description: Template of a database including its hosting
stack.
inputs:
db_user:
type:
string
db_password:
type:
string
# other inputs omitted for
brevity
substitution_mappings:
node_type:
tosca.nodes.Database
capabilities:
database_endpoint: [
database, database_endpoint ]
node_templates:
database:
type:
tosca.nodes.Database
properties:
user: {
get_input: db_user }
# other
properties omitted for brevity
requirements:
- host:
dbms
dbms:
type: tosca.nodes.DBMS
# details omitted for
brevity
server:
type: tosca.nodes.Compute
# details omitted for
brevity
|
Note that the substitution_mappings section does
not define any mappings for requirements of the Database node type,
since all requirements are fulfilled by other nodes templates in
the current topology template. In cases where a requirement of a
substituted node is bound in the top-level service template as well
as in the substituting topology template, a TOSCA Orchestrator
should raise a validation error.
Further note that no mappings for properties
or attributes of the substituted node are defined. Instead, the
inputs and outputs defined by the topology template have to match
the properties and attributes or the substituted node. If there are
more inputs than the substituted node has properties, default
values must be defined for those inputs, since no values can be
assigned through properties in a substitution case.
2.11 Using
node template substitution for chaining subsystems [comment?]
A common use case when providing an end-to-end
service is to define a chain of several subsystems that together
implement the overall service. Those subsystems are typically
defined as separate service templates to (1) keep the complexity of
the end-to-end service template at a manageable level and to (2)
allow for the re-use of the respective subsystem templates in many
different contexts. The type of subsystems may be specific to the
targeted workload, application domain, or custom use case. For
example, a company or a certain industry might define a subsystem
type for company- or industry specific data processing and then use
that subsystem type for various end-user services. In addition,
there might be generic subsystem types like a database subsystem
that are applicable to a wide range of use cases.
2.11.1
Defining the overall subsystem chain [comment?]
Figure 3 shows the chaining of three subsystem
types – a message queuing subsystem, a transaction processing
subsystem, and a databank subsystem – that support, for
example, an online booking application. On the front end, this
chain provides a capability of receiving messages for handling in
the message queuing subsystem. The message queuing subsystem in
turn requires a number of receivers, which in the current example
are two transaction processing subsystems. The two instances of the
transaction processing subsystem might be deployed on two different
hosting infrastructures or datacenters for high-availability
reasons. The transaction processing subsystems finally require a
database subsystem for accessing and storing application specific
data. The database subsystem in the backend does not require any
further component and is therefore the end of the chain in this
example.
Figure 3: Chaining of subsystems in a service
template
All of the node templates in the service
template shown above are abstract and considered substitutable
where each can be treated as their own subsystem; therefore, when
instantiating the overall service, the orchestrator would realize
each substitutable node template using other TOSCA service
templates. These service templates would include more nodes
and relationships that include the details for each subsystem. A
simplified version of a TOSCA service template for the overall
service is given in the following listing.
Example 17 – Declaring a transaction
subsystem as a chain of substitutable node templates
|
tosca_definitions_version:
tosca_simple_yaml_1_0
topology_template:
description: Template of online transaction processing
service.
node_templates:
mq:
type:
example.QueuingSubsystem
properties:
#
properties omitted for brevity
capabilities:
message_queue_endpoint:
# details omitted for brevity
requirements:
-
receiver: trans1
-
receiver: trans2
trans1:
type:
example.TransactionSubsystem
properties:
mq_service_ip: { get_attribute: [ mq, service_ip ] }
receiver_port: 8080
capabilities:
message_receiver:
# details omitted for brevity
requirements:
-
database_endpoint: dbsys
trans2:
type:
example.TransactionSubsystem
properties:
mq_service_ip: { get_attribute: [ mq, service_ip ] }
receiver_port: 8080
capabilities:
message_receiver:
# details omitted for brevity
requirements:
-
database_endpoint: dbsys
dbsys:
type: example.DatabaseSubsystem
properties:
#
properties omitted for brevity
capabilities:
database_endpoint:
# details omitted for brevity
|
As can be seen in the example above, the
subsystems are chained to each other by binding requirements of one
subsystem node template to other subsystem node templates that
provide the respective capabilities. For example, the receiver requirement of the message
queuing subsystem node template mq is bound to transaction processing
subsystem node templates trans1 and trans2.
Subsystems can be parameterized by providing
properties. In the listing above, for example, the IP address of
the message queuing server is provided as property mq_service_ip to the transaction
processing subsystems and the desired port for receiving messages
is specified by means of the receiver_port property.
If attributes of the instantiated subsystems
shall be obtained, this would be possible by using the get_attribute intrinsic function on
the respective subsystem node templates.
2.11.2 Defining a subsystem (node)
type [comment?]
The types of subsystems that are required for
a certain end-to-end service are defined as TOSCA node types as
shown in the following example. Node templates of those node types
can then be used in the end-to-end service template to define
subsystems to be instantiated and chained for establishing the
end-to-end service.
The realization of the defined node type will
be given in the form of a whole separate service template as
outlined in the following section.
Example 18 - Defining a TransactionSubsystem
node type
|
tosca_definitions_version:
tosca_simple_yaml_1_0
node_types:
example.TransactionSubsystem:
properties:
mq_service_ip:
type:
string
receiver_port:
type:
integer
attributes:
receiver_ip:
type:
string
receiver_port:
type:
integer
capabilities:
message_receiver:
tosca.capabilities.Endpoint
requirements:
- database_endpoint:
tosca.capabilities.Endpoint.Database
|
Configuration parameters that shall be allowed
for customizing the instantiation of any subsystem are defined as
properties of the node type. In the current example, those are the
properties mq_service_ip
and receiver_port that
had been used in the end-to-end service template in section
2.11.1.
Observable attributes of the resulting
subsystem instances are defined as attributes of the node type. In
the current case, those are the IP address of the message receiver
as well as the actually allocated port of the message receiver
endpoint.
2.11.3 Defining the details of a
subsystem [comment?]
The details of a subsystem, i.e. the software
components and their hosting infrastructure, are defined as node
templates and relationships in a service template. By means of
substitution mappings that have been introduced in section 2.10.2,
the service template is annotated to indicate to an orchestrator
that it can be used as realization of a node template of certain
type, as well as how characteristics of the node type are mapped to
internal elements of the service template.
Figure 4:
Defining subsystem details in a service template
Figure 1 illustrates how a transaction
processing subsystem as outlined in the previous section could be
defined in a service template. In this example, it simply consists
of a custom application app of type SomeApp that is hosted on a web
server websrv, which in
turn is running on a compute node.
The application named app provides a capability to receive
messages, which is bound to the message_receiver capability of the
substitutable node type. It further requires access to a database,
so the application’s database_endpoint requirement is
mapped to the database_endpoint requirement of the
TransactionSubsystem node
type.
Properties of the TransactionSubsystem node type are
used to customize the instantiation of a subsystem. Those
properties can be mapped to any node template for which the author
of the subsystem service template wants to expose configurability.
In the current example, the application app and the web server
middleware websrv get
configured through properties of the TransactionSubsystem node type. All
properties of that node type are defined as inputs of the service template. The
input parameters in turn get mapped to node templates by means of
get_input function calls
in the respective sections of the service template.
Similarly, attributes of the whole subsystem
can be obtained from attributes of particular node templates. In
the current example, attributes of the web server and the hosting
compute node will be exposed as subsystem attributes. All exposed
attributes that are defined as attributes of the substitutable
TransactionSubsystem node
type are defined as outputs of the subsystem service template.
An outline of the subsystem service
template is shown in the listing below. Note that this service
template could be used for stand-alone deployment of a transaction
processing system as well, i.e. it is not restricted just for use
in substitution scenarios. Only the presence of the substitution_mappings metadata
section in the topology_template enables the service
template for substitution use cases.
Example 19 - Implemention of a
TransactionSubsytem node type using substitution mappings
|
tosca_definitions_version:
tosca_simple_yaml_1_0
topology_template:
description: Template of a database including its hosting
stack.
inputs:
mq_service_ip:
type:
string
description: IP
address of the message queuing server to receive messages
from
receiver_port:
type:
string
description: Port to be used for receiving
messages
# other inputs omitted for
brevity
substitution_mappings:
node_type:
example.TransactionSubsystem
capabilities:
message_receiver: [
app, message_receiver ]
requirements:
database_endpoint: [
app, database ]
node_templates:
app:
type:
example.SomeApp
properties:
#
properties omitted for brevity
capabilities:
message_receiver:
properties:
service_ip: { get_input: mq_service_ip }
# other properties omitted for brevity
requirements:
-
database:
# details omitted for brevity
- host:
websrv
websrv:
type: tosca.nodes.WebServer
properties:
#
properties omitted for brevity
capabilities:
data_endpoint:
properties:
port_name: { get_input: receiver_port }
# other properties omitted for brevity
requirements:
- host:
server
server:
type: tosca.nodes.Compute
# details omitted for
brevity
outputs:
receiver_ip:
description: private IP
address of the message receiver application
value: { get_attribute: [
server, private_address ] }
receiver_port:
description: Port of the
message receiver endpoint
value: { get_attribute: [ app,
app_endpoint, port ] }
|
2.12 Grouping node
templates [comment?]
In designing applications composed of several
interdependent software components (or nodes) it is often desirable
to manage these components as a named group. This can provide
an effective way of associating policies (e.g., scaling, placement,
security or other) that orchestration tools can apply to all the
components of group during deployment or during other lifecycle
stages.
In many realistic scenarios it is
desirable to include scaling capabilities into an application to be
able to react on load variations at runtime. The example below
shows the definition of a scaling web server stack, where a
variable number of servers with apache installed on them can exist,
depending on the load on the servers.
Example 20 - Grouping Node Templates for
possible policy application
|
tosca_definitions_version:
tosca_simple_yaml_1_0
description:
Template for a scaling web server.
topology_template:
inputs:
#
omitted here for brevity
node_templates:
apache:
type: tosca.nodes.WebServer.Apache
properties:
# Details
omitted for brevity
requirements:
- host: server
server:
type: tosca.nodes.Compute
# details
omitted for brevity
groups:
webserver_group:
type:
tosca.groups.Root
members: [ apache, server ]
|
The example first of all uses the
concept of grouping to express which components (node templates)
need to be scaled as a unit – i.e. the compute nodes and the
software on-top of each compute node. This is done by defining the
webserver_group in the
groups section of the template and
by adding both the apache node
template and the server node
template as a member to the group.
Furthermore, a scaling policy is defined
for the group to express that the group as a whole (i.e. pairs of
server node and the apache component installed on top) should scale up
or down under certain conditions.
In cases where no explicit binding between
software components and their hosting compute resources is defined
in a template, but only requirements are defined as has been shown
in section 2.9, a provider could decide to place software
components on the same host if their hosting requirements match, or
to place them onto different hosts.
It is often desired, though, to influence
placement at deployment time to make sure components get
collocation or anti-collocated. This can be expressed via grouping
and policies as shown in the example below.
Example 21 - Grouping nodes for anti-colocation
policy application
|
tosca_definitions_version:
tosca_simple_yaml_1_0
description:
Template hosting requirements and placement policy.
topology_template:
inputs:
#
omitted here for brevity
node_templates:
wordpress_server:
type: tosca.nodes.WebServer
properties:
# omitted here for
brevity
requirements:
-
host:
# Find a Compute node that fulfills these additional filter
reqs.
node_filter:
capabilities:
- host:
properties:
-
mem_size: { greater_or_equal: 512 MB }
- disk_size: { greater_or_equal: 2 GB }
- os:
properties:
-
architecture: x86_64
-
type: linux
mysql:
type: tosca.nodes.DBMS.MySQL
properties:
# omitted
here for brevity
requirements:
- host:
node: tosca.nodes.Compute
node_filter:
capabilities:
- host:
properties:
-
disk_size: { greater_or_equal: 1 GB }
- os:
properties:
-
architecture: x86_64
-
type: linux
groups:
my_co_location_group:
type:
tosca.groups.Root
targets: [ wordpress_server, mysql ]
policies:
-
my_anti_collocation_policy:
type:
my.policies.anticolocateion
targets: [
my_co_location_group ]
# For this example, specific policy
definitions are considered
# domain
specific and are not included here
|
In the example above, both software
components wordpress_server and
mysql have similar hosting
requirements. Therefore, a provider could decide to put both on the
same server as long as both their respective requirements can be
fulfilled. By defining a group of the two components and attaching
an anti-collocation policy to the group it can be made sure,
though, that both components are put onto different hosts at
deployment time.
2.13 Using YAML Macros
to simplify templates [comment?]
The YAML 1.2 specification allows for defining
of aliases which
allow for authoring a block of YAML (or node) once and indicating
it is an “anchor” and then referencing it elsewhere in
the same document as an “alias”. Effectively,
YAML parsers treat this as a “macro” and copy the
anchor block’s code to wherever it is referenced. Use
of this feature is especially helpful when authoring TOSCA Service
Templates where similar definitions and property settings may be
repeated multiple times when describing a multi-tier
application.
For example, an application that has a web
server and database (i.e., a two-tier application) may be described
using two Compute nodes
(one to host the web server and another to host the
database). The author may want both Compute nodes to be
instantiated with similar properties such as operating system,
distribution, version, etc.
To accomplish this, the author would
describe the reusable properties using a named anchor in the
“dsl_definitions” section of the
TOSCA Service Template and reference the anchor name as an alias in
any Compute node
templates where these properties may need to be reused. For
example:
|
tosca_definitions_version:
tosca_simple_yaml_1_0
description:
>
TOSCA simple
profile that just defines a YAML macro for commonly reused
Compute
properties.
dsl_definitions:
my_compute_node_props:
&my_compute_node_props
disk_size: 10 GB
num_cpus: 1
mem_size: 2 GB
topology_template:
node_templates:
my_server:
type: Compute
capabilities:
- host:
properties: *my_compute_node_props
my_database:
type: Compute
capabilities:
- host:
properties: *my_compute_node_props
|
2.14 Passing
information as inputs to Nodes and Relationships [comment?]
It is possible for type and template authors
to declare input variables within an inputs block on interfaces to nodes
or relationships in order to pass along information needed by their
operations (scripts). These declarations can be scoped such
as to make these variable values available to all operations on a
node or relationships interfaces or to individual operations.
TOSCA orchestrators will make these values available as environment
variables within the execution environments in which the scripts
associated with lifecycle operations are run.
2.14.1 Example:
declaring input variables for all operations on a single
interface [comment?]
|
node_templates:
wordpress:
type: tosca.nodes.WebApplication.WordPress
requirements:
...
- database_endpoint:
mysql_database
interfaces:
Standard:
inputs:
wp_db_port: { get_property: [ SELF, database_endpoint, port ]
}
|
2.14.2
Example: declaring input variables for a single operation [comment?]
|
node_templates:
wordpress:
type: tosca.nodes.WebApplication.WordPress
requirements:
...
- database_endpoint:
mysql_database
interfaces:
Standard:
create:
wordpress_install.sh
configure:
implementation:
wordpress_configure.sh
inputs:
wp_db_port: { get_property: [ SELF, database_endpoint, port ]
}
|
In the case where an input variable
name is defined at more than one scope within the same interfaces
section of a node or template definition, the lowest (or innermost)
scoped declaration would override those declared at higher (or more
outer) levels of the definition.
2.14.3 Example: setting output
variables to an attribute [comment?]
|
node_templates:
frontend:
type:
MyTypes.SomeNodeType
attributes:
url: { get_operation_output:
[ SELF, Standard, create, generated_url ] }
interfaces:
Standard:
create:
implementation: scripts/frontend/create.sh
|
In this example, the Standard create operation
exposes / exports an environment variable named “generated_url” attribute which
will be assigned to the WordPress node’s url attribute.
2.14.4 Example: passing output
variables between operations [comment?]
|
node_templates:
frontend:
type: MyTypes.SomeNodeType
interfaces:
Standard:
create:
implementation:
scripts/frontend/create.sh
configure:
implementation:
scripts/frontend/configure.sh
inputs:
data_dir:
{ get_operation_output: [ SELF, Standard, create, data_dir ] }
|
In this example, the Standard lifecycle’s
create operation exposes
/ exports an environment variable named “data_dir” which will be passed
as an input to the Standard lifecycle’s
configure operation.
2.15 Topology Template
Model versus Instance Model [comment?]
A TOSCA service template contains a
topology template, which models the components of an
application, their relationships and dependencies (a.k.a., a
topology model) that get interpreted and instantiated by TOSCA
Orchestrators. The actual node and relationship instances
that are created represent a set of resources distinct from the
template itself, called a topology instance (model). The
direction of this specification is to provide access to the
instances of these resources for management and operational control
by external administrators. This model can also be accessed
by an orchestration engine during deployment – i.e. during
the actual process of instantiating the template in an incremental
fashion, That is, the orchestrator can choose the order of
resources to instantiate (i.e., establishing a partial set of node
and relationship instances) and have the ability, as they are being
created, to access them in order to facilitate instantiating the
remaining resources of the complete topology template.
2.16 Using attributes
implicitly reflected from properties [comment?]
Most entity types in TOSCA (e.g., Node,
Relationship, Requirement and Capability Types) have property definitions which allow
template authors to set the values for as inputs when these
entities are instantiated by an orchestrator. These property
values are considered to reflect the desired state of the entity by
the author. Once instantiated, the actual values for
these properties on the realized (instantiated) entity are
obtainable via attributes on the entity with the same name as the
corresponding property.
In other words, TOSCA orchestrators
will automatically reflect (i.e., make available) any property
defined on an entity making it available as an attribute of the
entity with the same name as the property.
Use of this feature is shown in the example
below where a source node named my_client, of type ClientNode, requires a connection to
another node named my_server of type ServerNode. As you can see, the
ServerNode type defines a
property named notification_port which defines a
dedicated port number which instances of my_client may use to post
asynchronous notifications to it during runtime. In this
case, the TOSCA Simple Profile assures that the notification_port property is
implicitly reflected as an attribute in the my_server node (also with the name
notification_port) when
its node template is instantiated.
|
tosca_definitions_version:
tosca_simple_yaml_1_0
description:
>
TOSCA simple
profile that shows how the (notification_port) property is
reflected as an attribute and can be referenced
elsewhere.
node_types:
ServerNode:
derived_from:
SoftwareComponent
properties:
notification_port:
type:
integer
capabilities:
# omitted here for
brevity
ClientNode:
derived_from:
SoftwareComponent
properties:
# omitted here for
brevity
requirements:
- server:
capability: Endpoint
node: ServerNode
relationship:
ConnectsTo
topology_template:
node_templates:
my_server:
type: ServerNode
properties:
notification_port: 8000
my_client:
type: ClientNode
requirements:
- server:
node: my_server
relationship: my_connection
relationship_templates:
my_connection:
type:
ConnectsTo
interfaces:
Configure:
inputs:
targ_notify_port: {
get_attribute: [ TARGET, notification_port ] }
# other operation definitions omitted
here for brevity
|
Specifically, the above example shows that the
ClientNode type needs the
notification_port value
anytime a node of ServerType is connected to it using
the ConnectsTo
relationship in order to make it available to its Configure operations (scripts). It
does this by using the get_attribute function to retrieve
the notification_port
attribute from the TARGET
node of the ConnectsTo
relationship (which is a node of type ServerNode) and assigning it to an
environment variable named targ_notify_port.
It should be noted that the actual port value
of the notification_port
attribute may or may not be the value 8000 as requested on the property;
therefore, any node that is dependent on knowing its actual
“runtime” value would use the get_attribute function instead of the
get_property
function.
3 TOSCA Simple Profile
definitions in YAML [comment?]
This section is normative and describes
all of the YAML grammar, definitions and block structure for all
keys and mappings that are defined for the TOSCA Version 1.0 Simple
Profile specification that are needed to describe a TOSCA Service
Template (in YAML).
3.1 TOSCA Namespace URI
and alias [comment?]
The following TOSCA Namespace URI
alias and TOSCA Namespace Alias are reserved values which SHALL be
used when identifying the TOSCA Simple Profile version 1.0
specification.
3.1.1 TOSCA Namespace
prefix [comment?]
The following TOSCA Namespace prefix
is a reserved value and SHALL be used to reference the default
TOSCA Namespace URI as declared in TOSCA Service Templates.
|
Namespace Prefix
|
Specification Description
|
|
tosca
|
The reserved TOSCA Simple Profile
Specification prefix that can be associated with the default TOSCA
Namespace URI
|
3.1.2 TOSCA Namespacing in TOSCA
Service Templates [comment?]
In the TOSCA Simple Profile, TOSCA Service
Templates must always have, as the first line of YAML, the keyword
“tosca_definitions_version” with
an associated TOSCA Namespace Alias value. This single line
accomplishes the following:
1. Establishes the TOSCA Simple
Profile Specification version whose grammar MUST be used to parse
and interpret the contents for the remainder of the TOSCA Service
Template.
2. Establishes the default TOSCA
Namespace URI and Namespace Prefix for all types found in the
document that are not explicitly namespaced.
3. Automatically imports (without
the use of an explicit import statement) the normative type
definitions (e.g., Node, Relationship, Capability, Artifact, etc.)
that are associated with the TOSCA Simple Profile Specification the
TOSCA Namespace Alias value identifies.
4. Associates the TOSCA Namespace
URI and Namespace Prefix to the automatically imported TOSCA type
definitions.
3.1.3 Rules to avoid namespace
collisions [comment?]
TOSCA Simple Profiles allows template authors
to declare their own types and templates and assign them simple
names with no apparent namespaces. Since TOSCA Service
Templates can import other service templates to introduce new types
and topologies of templates that can be used to provide concrete
implementations (or substitute) for abstract nodes. Rules are
needed so that TOSCA Orchestrators know how to avoid collisions and
apply their own namespaces when import and nesting occur.
3.1.3.1 Additional Requirements [comment?]
·
Since TOSCA Service Templates can import (or substitute in) other
Service Templates, TOSCA Orchestrators and tooling will encounter
the “tosca_definitions_version”
statement for each imported template. In these cases, the
following additional requirements apply:
o Imported
type definitions with the same Namespace URI, local name and
version SHALL be equivalent.
o If
different values of the “tosca_definitions_version” are
encountered, their corresponding type definitions MUST be uniquely
identifiable using their corresponding Namespace URI using a
different Namespace prefix.
·
Duplicate local names (i.e., within the same Service Template SHALL
be considered an error. These include, but are not limited to
duplicate names found for the following definitions:
o
Repositories (repositories)
o Data Types
(data_types)
o Node Types
(node_types)
o
Relationship Types (relationship_types_
o Capability
Types (capability_types)
o Artifact
Types (artifact_types_
o Interface
Types (interface_types)
·
Duplicate Template names within a Service Template’s Topology
Template SHALL be considered an error. These include, but are
not limited to duplicate names found for the following template
types:
o Node
Templates (node_templates)
o
Relationship Templates (relationship_templates)
o Inputs
(inputs)
o Outputs
(outputs)
o Groups
(groups)
·
Duplicate names for the following keynames within Types or
Templates SHALL be considered an error. These include, but
are not limited to duplicate names found for the following
keynames:
o Properties
(properties)
o Attributes
(attributes)
o Artifacts
(artifacts)
o
Requirements (requirements)
o
Capabilities (capabilities)
o Interfaces
(interfaces)
3.2 Parameter and
property types [comment?]
This clause describes the primitive types that
are used for declaring normative properties, parameters and grammar
elements throughout this specification.
3.2.1 Referenced
YAML Types [comment?]
Many of the types we use in this
profile are built-in types from the YAML 1.2 specification
(i.e., those identified by the “tag:yaml.org,2002”
version tag).
The following table declares the valid
YAML type URIs and aliases that SHALL be used when possible when
defining parameters or properties within TOSCA Service Templates
using this specification:
·
The “string” type is the default type when not
specified on a parameter or property declaration.
·
While YAML supports further type aliases, such as “str”
for “string”, the TOSCA Simple Profile specification
promotes the fully expressed alias name for clarity.
TOSCA supports the concept of
“reuse” of type definitions, as well as template
definitions which could be version and change over time. It
is important to provide a reliable, normative means to represent a
version string which enables the comparison and management of types
and templates over time. Therefore, the TOSCA TC intends to provide
a normative version type (string) for this purpose in future
Working Drafts of this specification.
|
Shorthand Name
|
version
|
|
Type Qualified Name
|
tosca:version
|
TOSCA version strings have the
following grammar:
|
<major_version>.<minor_version>[.<fix_version>[.<qualifier>[-<build_version]
] ]
|
In the above grammar, the pseudo
values that appear in angle brackets have the following
meaning:
·
major_version: is a
required integer value greater than or equal to 0 (zero)
·
minor_version: is a
required integer value greater than or equal to 0 (zero).
·
fix_version: is an
optional integer value greater than or equal to 0 (zero).
·
qualifier: is an optional
string that indicates a named, pre-release version of the
associated code that has been derived from the version of the code
identified by the combination major_version, minor_version and fix_version numbers.
·
build_version: is an
optional integer value greater than or equal to 0 (zero) that can
be used to further qualify different build versions of the code
that has the same qualifer_string.
3.2.2.2 Version Comparison [comment?]
·
When comparing TOSCA versions, all component versions (i.e., major,
minor and fix) are compared in sequence from left to right.
·
TOSCA versions that include the optional qualifier are considered
older than those without a qualifier.
·
TOSCA versions with the same major, minor, and fix versions and
have the same qualifier string, but with different build versions
can be compared based upon the build version.
·
Qualifier strings are considered domain-specific. Therefore,
this specification makes no recommendation on how to compare TOSCA
versions with the same major, minor and fix versions, but with
different qualifiers strings and simply considers them different
named branches derived from the same code.
Example of a version with
|
# basic version
strings
6.1
2.0.1
# version string
with optional qualifier
3.1.0.beta
# version string
with optional qualifier and build version
1.0.0.alpha-10
|
·
[Maven-Version] The TOSCA version
type is compatible with the Apache Maven versioning policy.
3.2.2.5 Additional Requirements [comment?]
·
A version value of zero (i.e., ‘0’, ‘0.0’,
or ‘0.0.0’) SHALL indicate there no version
provided.
·
A version value of zero used with any qualifiers SHALL NOT be
valid.
3.2.3 TOCSA range type [comment?]
The range type can be used to define
numeric ranges with a lower and upper boundary. For example, this
allows for specifying a range of ports to be opened in a
firewall.
|
Shorthand Name
|
range
|
|
Type Qualified Name
|
tosca:range
|
TOSCA range values have the following
grammar:
|
[<lower_bound>, <upper_bound>]
|
In the above grammar, the pseudo
values that appear in angle brackets have the following
meaning:
·
lower_bound: is a
required integer value that denotes the lower boundary of the
range.
·
upper_bound: is a
required integer value that denotes the upper boundary of the
range. This value must be greater than lower_bound.
The following Keywords may be used in
the TOSCA range type:
|
Keyword
|
Applicable Types
|
Description
|
|
UNBOUNDED
|
scalar
|
Used to represent an unbounded upper bounds
(positive) value in a set for a scalar type.
|
Example of a node template property
with a range value:
|
# numeric range
between 1 and 100
a_range_property: [
1, 100 ]
# a property that
has allows any number 0 or greater
num_connections: [
0, UNBOUNDED ]
|
3.2.4 TOSCA list type [comment?]
The list type allows for specifying multiple
values for a parameter of property. For example, if an application
allows for being configured to listen on multiple ports, a list of
ports could be configured using the list data type.
Note that entries in a list for one
property or parameter must be of the same type. The type (for
simple entries) or schema (for complex entries) is defined by the
entry_schema attribute of
the respective property
definition, attribute
definitions, or input or output parameter definitions.
|
Shorthand Name
|
list
|
|
Type Qualified Name
|
tosca:list
|
TOSCA lists are essentially normal
YAML lists with the following grammars:
3.2.4.1.1 Square bracket notation [comment?]
|
[
<list_entry_1>, <list_entry_2>, ... ]
|
3.2.4.1.2 Bulleted (sequenced) list notation [comment?]
|
-
<list_entry_1>
- ...
-
<list_entry_n>
|
In the above grammars, the pseudo
values that appear in angle brackets have the following
meaning:
·
<list_entry_*>:
represents one entry of the list.
3.2.4.2 Declaration Examples [comment?]
3.2.4.2.1 List declaration using a simple type [comment?]
The following example shows a list
declaration with an entry schema based upon a simple integer type
(which has additional constraints):
|
<some_entity>:
...
properties:
listen_ports:
type: list
entry_schema:
description: listen port entry (simple integer type)
type: integer
constraints:
- max_length:
128
|
3.2.4.2.2 List declaration using a complex type [comment?]
The following example shows a list
declaration with an entry schema based upon a complex type:
|
<some_entity>:
...
properties:
products:
type: list
entry_schema:
description: Product information entry (complex type) defined
elsewhere
type:
ProductInfo
|
3.2.4.3 Definition Examples [comment?]
These examples show two notation options for
defining lists:
·
A single-line option which is useful for only short lists with
simple entries.
·
A multi-line option where each list entry is on a separate line;
this option is typically useful or more readable if there is a
large number of entries, or if the entries are complex.
3.2.4.3.1 Square bracket notation [comment?]
|
listen_ports: [ 80,
8080 ]
|
3.2.4.3.2 Bulleted list notation [comment?]
|
listen_ports:
-
80
- 8080
|
3.2.5 TOSCA map type [comment?]
The map type allows for specifying multiple
values for a parameter of property as a map. In contrast to the
list type, where each entry can only be addressed by its index in
the list, entries in a map are named elements that can be addressed
by their keys.
Note that entries in a map for one
property or parameter must be of the same type. The type (for
simple entries) or schema (for complex entries) is defined by the
entry_schema attribute of
the respective property
definition, attribute
definition, or input or output parameter definition.
|
Shorthand Name
|
map
|
|
Type Qualified Name
|
tosca:map
|
TOSCA maps are normal YAML
dictionaries with following grammar:
3.2.5.1.1 Single-line grammar [comment?]
|
{
<entry_key_1>: <entry_value_1>, ...,
<entry_key_n>: <entry_value_n> }
...
<entry_key_n>:
<entry_value_n>
|
3.2.5.1.2 Multi-line grammar [comment?]
|
<entry_key_1>:
<entry_value_1>
...
<entry_key_n>:
<entry_value_n>
|
In the above grammars, the pseudo
values that appear in angle brackets have the following
meaning:
·
entry_key_*: is the
required key for an entry in the map
·
entry_value_*: is the
value of the respective entry in the map
3.2.5.2 Declaration Examples [comment?]
3.2.5.2.1 Map declaration using a simple type [comment?]
The following example shows a map with
an entry schema definition based upon an existing string type
(which has additional constraints):
|
<some_entity>:
...
properties:
emails:
type: map
entry_schema:
description: basic email address
type: string
constraints:
- max_length:
128
|
3.2.5.2.2 Map declaration using a complex type [comment?]
The following example shows a map with
an entry schema definition for contact information:
|
<some_entity>:
...
properties:
contacts:
type: map
entry_schema:
description: simple contact information
type:
ContactInfo
|
3.2.5.3 Definition Examples [comment?]
These examples show two notation
options for defining maps:
·
A single-line option which is useful for only short maps with
simple entries.
·
A multi-line option where each map entry is on a separate line;
this option is typically useful or more readable if there is a
large number of entries, or if the entries are complex.
3.2.5.3.1 Single-line notation [comment?]
|
# notation option
for shorter maps
user_name_to_id_map:
{ user1: 1001, user2: 1002 }
|
3.2.5.3.2 Multi-line notation [comment?]
|
# notation for
longer maps
user_name_to_id_map:
user1:
1001
user2:
1002
|
3.2.6 TOCSA
scalar-unit type [comment?]
The scalar-unit type can be used to define
scalar values along with a unit from the list of recognized units
provided below.
TOSCA scalar-unit typed values have
the following grammar:
In the above grammar, the pseudo
values that appear in angle brackets have the following
meaning:
·
scalar: is a required
scalar value.
·
unit: is a required unit
value. The unit value MUST be type-compatible with the scalar.
3.2.6.2 Additional requirements [comment?]
·
Whitespace: any number of spaces (including
zero or none) SHALL be allowed between the scalar value and the unit value.
·
It SHALL be considered an error if either the scalar or unit
portion is missing on a property or attribute declaration derived
from any scalar-unit type.
·
When performing constraint clause evaluation on values of the
scalar-unit type, both the scalar value portion and unit value
portion SHALL be compared together (i.e., both are treated
as a single value). For example, if we have a property called
storage_size. which is of
type scalar-unit, a valid range constraint would appear as
follows:
o storage_size: in_range [ 4 GB, 20 GB ]
where storage_size’s range would be
evaluated using both the numeric and unit values (combined
together), in this case ‘4 GB’ and ’20
GB’.
3.2.6.3 Concrete Types [comment?]
|
Shorthand Names
|
scalar-unit.size, scalar-unit.size
|
|
Type Qualified Names
|
tosca:scalar-unit.size,
tosca:scalar-unit.time
|
The scalar-unit type grammar is abstract and
has two recognized concrete types in TOSCA:
·
scalar-unit.size – used to define properties that have
scalar values measured in size units.
·
scalar-unit.time – used to define properties that have
scalar values measured in size units.
·
scalar-unit.frequency – used to define properties that
have scalar values measured in units per second.
These types and their allowed unit
values are defined below.
3.2.6.4 scalar-unit.size [comment?]
3.2.6.4.1 Recognized Units [comment?]
|
Unit
|
Usage
|
Description
|
|
B
|
size
|
byte
|
|
kB
|
size
|
kilobyte (1000
bytes)
|
|
KiB
|
size
|
kibibytes (1024
bytes)
|
|
MB
|
size
|
megabyte (1000000
bytes)
|
|
MiB
|
size
|
mebibyte (1048576
bytes)
|
|
GB
|
size
|
gigabyte (1000000000
bytes)
|
|
GiB
|
size
|
gibibytes (1073741824
bytes)
|
|
TB
|
size
|
terabyte (1000000000000
bytes)
|
|
TiB
|
size
|
tebibyte (1099511627776
bytes)
|
|
# Storage size in
Gigabytes
properties:
storage_size:
10 GB
|
3.2.6.5 scalar-unit.time [comment?]
3.2.6.5.1 Recognized Units [comment?]
|
Unit
|
Usage
|
Description
|
|
d
|
time
|
days
|
|
h
|
time
|
hours
|
|
m
|
time
|
minutes
|
|
s
|
time
|
seconds
|
|
ms
|
time
|
milliseconds
|
|
us
|
time
|
microseconds
|
|
ns
|
time
|
nanoseconds
|
|
# Response time in
milliseconds
properties:
respone_time:
10 ms
|
3.2.6.6
scalar-unit.frequency [comment?]
3.2.6.6.1 Recognized Units [comment?]
|
Unit
|
Usage
|
Description
|
|
Hz
|
frequency
|
Hertz, or Hz. equals one cycle per second.
|
|
kHz
|
frequency
|
Kilohertz, or kHz, equals to 1,000 Hertz
|
|
MHz
|
frequency
|
Megahertz, or MHz, equals to 1,000,000 Hertz
or 1,000 kHz
|
|
GHz
|
frequency
|
Gigahertz, or GHz, equals to 1,000,000,000
Hertz, or 1,000,000 kHz, or 1,000 MHz.
|
|
# Processor raw
clock rate
properties:
clock_rate:
2.4 GHz
|
·
The value for Hertz (Hz) is the International Standard Unit (ISU)
as described by the Bureau International des Poids et Mesures
(BIPM) in the “SI Brochure: The
International System of Units (SI) [8th edition, 2006; updated in
2014]”, http://www.bipm.org/en/publications/si-brochure/
3.3
Normative values [comment?]
As components (i.e., nodes) of TOSCA
applications are deployed, instantiated and orchestrated over their
lifecycle using normative lifecycle operations (see section 5.7 for
normative lifecycle definitions) it is important define normative
values for communicating the states of these components normatively
between orchestration and workflow engines and any managers of
these applications.
The following table provides the list
of recognized node states for TOSCA Simple Profile that would be
set by the orchestrator to describe a node instance’s
state:
|
Node State
|
|
Value
|
Transitional
|
Description
|
|
initial
|
no
|
Node is not yet
created. Node only exists as a template
definition.
|
|
creating
|
yes
|
Node is transitioning
from initial
state to created state.
|
|
created
|
no
|
Node software has been
installed.
|
|
configuring
|
yes
|
Node is transitioning
from created
state to configured state.
|
|
configured
|
no
|
Node has been configured
prior to being started.
|
|
starting
|
yes
|
Node is transitioning
from configured
state to started state.
|
|
started
|
no
|
Node is started.
|
|
stopping
|
yes
|
Node is transitioning from
its current state to a configured state.
|
|
deleting
|
yes
|
Node is transitioning from
its current state to one where it is deleted and its state is no
longer tracked by the instance model.
|
|
error
|
no
|
Node is in an error
state.
|
3.3.2 Relationship States [comment?]
Similar to the Node States described
in the previous section, Relationships have state relative to their
(normative) lifecycle operations.
The following table provides the list
of recognized relationship states for TOSCA Simple Profile that
would be set by the orchestrator to describe a node
instance’s state:
|
Node State
|
|
Value
|
Transitional
|
Description
|
|
initial
|
no
|
Relationship is not yet
created. Relationship only exists as a template
definition.
|
·
Additional states will be defined in future versions of the TOSCA
Simple Profile in YAML specification.
There are currently no directive
values defined for this version of the TOSCA Simple Profile.
3.3.4 Network Name aliases [comment?]
The following are recognized values
that may be used as aliases to reference types of networks within
an application model without knowing their actual name (or
identifier) which may be assigned by the underlying Cloud platform
at runtime.
|
Alias value
|
Description
|
|
PRIVATE
|
An alias used to reference
the first private network within a property or attribute of a Node
or Capability which would be assigned to them by the underlying
platform at runtime.
A private network contains
IP addresses and ports typically used to listen for incoming
traffic to an application or service from the Intranet and not
accessible to the public internet.
|
|
PUBLIC
|
An alias used to reference
the first public network within a property or attribute of a Node
or Capability which would be assigned to them by the underlying
platform at runtime.
A public network contains
IP addresses and ports typically used to listen for incoming
traffic to an application or service from the Internet.
|
These aliases would be used in the
tosca.capabilities.Endpoint
Capability type (and types derived from it) within the network_name field for template
authors to use to indicate the type of network the Endpoint is
supposed to be assigned an IP address from.
This section defines all modelable entities
that comprise the TOSCA Version 1.0 Simple Profile specification
along with their keynames, grammar and requirements.
3.4.1 Required Keynames [comment?]
The TOSCA metamodel includes complex types
(e.g., Node Types, Relationship Types, Capability Types, Data
Types, etc.) each of which include their own list of reserved
keynames that are sometimes marked as required. These
types may be used to derive other types. These derived types
(e.g., child types) do not have to provide required keynames as
long as they have been specified in the type they have been derived
from (i.e., their parent type).
3.5
Reusable modeling definitions [comment?]
3.5.1 Description
definition [comment?]
This optional element provides a means include
single or multiline descriptions within a TOSCA Simple Profile
template as a scalar string value.
The following keyname is used to
provide a description within the TOSCA Simple Profile
specification:
Description definitions have the
following grammar:
Simple descriptions are treated as a
single literal that includes the entire contents of the line that
immediately follows the description key:
|
description: This is an example of a single line description (no
folding).
|
The YAML “folded” style
may also be used for multi-line descriptions which
“folds” line breaks as space characters.
|
description: >
This is an
example of a multi-line description using YAML. It permits for
line
breaks for
easier readability...
if
needed. However, (multiple) line breaks are folded into a
single space
character
when processed into a single string value.
|
- Use of “folded” style is
discouraged for the YAML string type apart from when used with the
description keyname.
3.5.2
Constraint clause [comment?]
A constraint clause defines an operation along
with one or more compatible values that can be used to define a
constraint on a property or parameter’s allowed values when
it is defined in a TOSCA Service Template or one of its
entities.
3.5.2.1 Operator
keynames [comment?]
The following is the list of
recognized operators (keynames) when defining constraint
clauses:
|
Operator
|
Type
|
Value Type
|
Description
|
|
equal
|
scalar
|
any
|
Constrains a property or parameter to a value
equal to (‘=’) the value declared.
|
|
greater_than
|
scalar
|
comparable
|
Constrains a property or parameter to a value
greater than (‘>’) the value declared.
|
|
greater_or_equal
|
scalar
|
comparable
|
Constrains a property or parameter to a value
greater than or equal to (‘>=’) the value
declared.
|
|
less_than
|
scalar
|
comparable
|
Constrains a property or parameter to a value
less than (‘<’) the value declared.
|
|
less_or_equal
|
scalar
|
comparable
|
Constrains a property or parameter to a value
less than or equal to (‘<=’) the value declared.
|
|
in_range
|
dual scalar
|
comparable, range
|
Constrains a property or parameter to a value
in range of (inclusive) the two values declared.
Note: subclasses or templates of types that
declare a property with the in_range constraint MAY only
further restrict the range specified by the parent type.
|
|
valid_values
|
list
|
any
|
Constrains a property or parameter to a value
that is in the list of declared values.
|
|
length
|
scalar
|
string,
list, map
|
Constrains the property or parameter to a
value of a given length.
|
|
min_length
|
scalar
|
string,
list, map
|
Constrains the property or parameter to a
value to a minimum length.
|
|
max_length
|
scalar
|
string,
list, map
|
Constrains the property or parameter to a
value to a maximum length.
|
|
pattern
|
regex
|
string
|
Constrains the property or parameter to a
value that is allowed by the provided regular expression.
Note: Future drafts of this specification will detail the
use of regular expressions and reference an appropriate
standardized grammar.
|
3.5.2.1.1 Comparable value
types [comment?]
In the Value Type column above, an
entry of “comparable” includes integer, float, timestamp, string, version, and scalar-unit types while an entry of
“any” refers to any type allowed in the TOSCA
simple profile in YAML.
3.5.2.2 Additional Requirements [comment?]
·
If no operator is present for a simple scalar-value on a constraint
clause, it SHALL be interpreted as being equivalent to
having the “equal” operator provided;
however, the “equal” operator may be used for
clarity when expressing a constraint clause.
·
The “length”
operator SHALL be interpreted mean “size” for
set types (i.e., list, map, etc.).
Constraint clauses have one of the
following grammars:
|
# Scalar
grammar
<operator>:
<scalar_value>
# Dual scalar
grammar
<operator>: [
<scalar_value_1>, <scalar_value_2> ]
# List
grammar
<operator> [
<value_1>, <value_2>, ..., <value_n> ]
# Regular expression
(regex) grammar
pattern:
<regular_expression_value>
|
In the above
grammar, the pseudo values that appear in angle brackets have the
following meaning:
·
operator: represents a
required operator from the specified list shown above (see section
3.5.2.1 “Operator keynames”).
·
scalar_value,
scalar_value_*: represents a required scalar (or atomic
quantity) that can hold only one value at a time. This will
be a value of a primitive type, such as an integer or string that
is allowed by this specification.
·
value_*: represents a
required value of the operator that is not limited to scalars.
·
reqular_expression_value:
represents a regular expression (string) value.
Constraint clauses used on parameter
or property definitions:
|
# equal
equal: 2
#
greater_than
greater_than:
1
#
greater_or_equal
greater_or_equal:
2
#
less_than
less_than:
5
#
less_or_equal
less_or_equal:
4
#
in_range
in_range: [ 1, 4
]
#
valid_values
valid_values: [ 1,
2, 4 ]
# specific length
(in characters)
length:
32
# min_length (in
characters)
min_length:
8
# max_length (in
characters)
max_length:
64
|
3.5.2.5 Additional
Requirements [comment?]
- Values provided by the operands (i.e.,
values and scalar values) SHALL be type-compatible with
their associated operations.
- Future drafts of this specification will
detail the use of regular expressions and reference an appropriate
standardized grammar.
3.5.3 Property Filter definition [comment?]
A property filter definition defines criteria,
using constraint clauses, for selection of a TOSCA entity based
upon it property values.
Property filter definitions have one
of the following grammars:
3.5.3.1.1 Short notation: [comment?]
The following single-line grammar may
be used when only a single constraint is needed on a property:
3.5.3.1.2 Extended notation: [comment?]
The following multi-line grammar may
be used when multiple constraints are needed on a property:
In the above grammars, the pseudo
values that appear in angle brackets have the following
meaning:
·
property_name: represents
the name of property that would be used to select a property
definition with the same name (property_name) on a TOSCA entity
(e.g., a Node Type, Node Template, Capability Type,
etc.).
·
property_constraint_clause_*:
represents constraint clause(s) that would be used to filter
entities based upon the named property’s value(s).
3.5.3.2 Additional Requirements [comment?]
·
Property constraint clauses must be type compatible with the
property definitions (of the same name) as defined on the target
TOSCA entity that the clause would be applied against.
3.5.4
Node Filter definition [comment?]
A node filter definition defines criteria for
selection of a TOSCA Node Template based upon the template’s
property values, capabilities and capability properties.
The following is the list of
recognized keynames for a TOSCA node filter definition:
|
Keyname
|
Required
|
Type
|
Description
|
|
properties
|
no
|
list of
property filter
definition
|
An optional sequenced list of property
filters that would be used to select (filter) matching TOSCA
entities (e.g., Node Template, Node Type, Capability Types, etc.)
based upon their property definitions’ values.
|
|
capabilities
|
no
|
list of capability names or capability type names
|
An optional sequenced list of capability
names or types that would be used to select (filter) matching TOSCA
entities based upon their existence.
|
3.5.4.2 Additional filtering on named Capability
properties [comment?]
Capabilities used as filters often
have their own sets of properties which also can be used to
construct a filter.
|
Keyname
|
Required
|
Type
|
Description
|
|
<capability
name_or_type>
name>:
properties
|
no
|
list of
property filter
definitions
|
An optional sequenced list of property
filters that would be used to select (filter) matching TOSCA
entities (e.g., Node Template, Node Type, Capability Types, etc.)
based upon their capabilities’ property definitions’
values.
|
Node filter definitions have one of
the following grammars:
In the above grammar, the pseudo
values that appear in angle brackets have the following
meaning:
·
property_filter_def_*:
represents a property filter definition that would be used to
select (filter) matching TOSCA entities (e.g., Node Template, Node
Type, Capability Types, etc.) based upon their property
definitions’ values.
·
property_constraint_clause_*:
represents constraint clause(s) that would be used to filter
entities based upon property values.
·
capability_name_or_type_*: represents
the type or name of a capability that would be used to select
(filter) matching TOSCA entities based upon their existence.
·
cap_*_property_def_*:
represents a property filter definition that would be used to
select (filter) matching TOSCA entities (e.g., Node Template, Node
Type, Capability Types, etc.) based upon their capabilities’
property definitions’ values.
3.5.4.4 Additional requirements [comment?]
·
TOSCA orchestrators SHALL search for matching capabilities
listed on a target filter by assuming the capability name is first
a symbolic name and secondly it is a type name (in order to avoid
namespace collisions).
The following example is a filter that would
be used to select a TOSCA Compute node based upon the values
of its defined capabilities. Specifically, this filter would select
Compute nodes that supported a specific range of CPUs (i.e.,
num_cpus value between 1
and 4) and memory size (i.e., mem_size of 2 or greater) from its
declared “host” capability.
|
my_node_template:
# other
details omitted for brevity
requirements:
-
host:
node_filter:
capabilities:
# My “host” Compute node needs these
properties:
- host:
properties:
- num_cpus: { in_range: [ 1, 4 ] }
- mem_size: { greater_or_equal: 512 MB }
|
3.5.5
Repository definition [comment?]
A repository definition defines a named
external repository which contains deployment and implementation
artifacts that are referenced within the TOSCA Service
Template.
The following is the list of
recognized keynames for a TOSCA repository definition:
|
Keyname
|
Required
|
Type
|
Constraints
|
Description
|
|
description
|
no
|
description
|
None
|
The optional description for the
repository.
|
|
url
|
yes
|
string
|
None
|
The required URL or network address used to
access the repository.
|
|
credential
|
no
|
Credential
|
None
|
The optional Credential used to authorize
access to the repository.
|
Repository definitions have one the
following grammars:
3.5.5.2.1 Single-line grammar (no credential): [comment?]
3.5.5.2.2 Multi-line grammar [comment?]
In the above grammar, the pseudo
values that appear in angle brackets have the following
meaning:
·
repository_name:
represents the required symbolic name of the repository as a
string.
·
repository_description:
contains an optional description of the repository.
·
repository_address:
represents the required URL of the repository as a string.
·
authorization_credential:
represents the optional credentials (e.g., user ID and password)
used to authorize access to the repository.
3.5.5.3 Additional Requirements [comment?]
·
None
The following represents a repository
definition:
|
repositories:
my_code_repo:
description: My project’s code repository in
GitHub
url: https://github.com/my-project/
|
3.5.6
Artifact definition [comment?]
An artifact definition defines a named, typed
file that can be associated with Node Type or Node Template and
used by orchestration engine to facilitate deployment and
implementation of interface operations.
The following is the list of
recognized keynames for a TOSCA artifact definition when using the
extended notation:
|
Keyname
|
Required
|
Type
|
Description
|
|
type
|
yes
|
string
|
The required artifact type for the artifact
definition.
|
|
file
|
yes
|
string
|
The required URI string (relative or absolute)
which can be used to locate the artifact’s file.
|
|
repository
|
no
|
string
|
The optional name of the repository definition
which contains the location of the external repository that
contains the artifact. The artifact is expected to be
referenceable by its file URI within the
repository.
|
|
description
|
no
|
description
|
The optional description for the artifact
definition.
|
|
deploy_path
|
no
|
string
|
The file path the associated file would be
deployed into within the target node’s container.
|
Artifact definitions have one of the
following grammars:
3.5.6.2.1 Short notation [comment?]
The following single-line grammar may
be used when the artifact’s type and mime type can be
inferred from the file URI:
3.5.6.2.2 Extended notation: [comment?]
The following multi-line grammar may
be used when the artifact’s definition’s type and mime
type need to be explicitly declared:
In the above grammars, the pseudo
values that appear in angle brackets have the following
meaning:
·
artifact_name: represents
the required symbolic name of the artifact as a string.
·
artifact_description:
represents the optional description for the artifact.
·
artifact_type_name:
represents the required artifact type the artifact
definition is based upon.
·
artifact_file_URI: represents the required URI
string (relative or absolute) which can be used
to locate the artifact’s file.
·
artifact_repository_name: represents the optional name of the repository definition to use to
retrieve the associated artifact (file) from.
·
file_deployement_path:
represents the optional path the artifact_file_URI would be copied
into within the target node’s container.
The following represents an artifact
definition:
|
my_file_artifact:
../my_apps_files/operation_artifact.txt
|
3.5.7 Import
definition [comment?]
An import definition is used within a TOSCA
Service Template to locate and uniquely name another TOSCA Service
Template file which has type and template definitions to be
imported (included) and referenced within the another Service
Template.
The following is the list of
recognized keynames for a TOSCA import definition:
|
Keyname
|
Required
|
Type
|
Constraints
|
Description
|
|
file
|
yes
|
string
|
None
|
The required symbolic name for the imported
file.
|
|
repository
|
no
|
string
|
None
|
The optional symbolic name of the repository
definition where the imported file can be found as a string.
|
|
namespace_uri
|
no
|
string
|
None
|
The optional namespace URI to that will be
applied to type definitions found within the imported file as a
string.
|
|
namespace_prefix
|
no
|
string
|
None
|
The optional namespace prefix (alias) that
will be used to indicate the namespace_uri when forming a
qualified name (i.e., qname) when referencing type definitions from
the imported file.
|
Import definitions have one the
following grammars:
3.5.7.2.1 Single-line grammar: [comment?]
|
<import_name>:
<file_URI>
|
3.5.7.2.2 Multi-line grammar [comment?]
|
<import_name>:
file:
<file_URI>
repository:
<repository_name>
namespace_uri: <definition_namespace_uri>
namespace_prefix: <definition_namespace_prefix>
|
In the above grammar, the pseudo
values that appear in angle brackets have the following
meaning:
·
import_name: represents
the required symbolic name for the imported file as a string.
·
file_uri: contains the
required name (i.e., URI) of the file to be imported as a string.
·
repository_name:
represents the optional symbolic name of the repository definition
where the imported file can be found as a string.
·
namespace_uri: represents
the optional namespace URI to that will be applied to type
definitions found within the imported file as a string.
·
namespace_prefix:
represents the optional namespace prefix (alias) that will be used
to indicate the namespace_uri when forming a
qualified name (i.e., qname) when referencing type definitions from
the imported file as a string.
3.5.7.3 Additional Requirements [comment?]
·
None
The following represents how import
definitions would be used for the imports keyname within a TOSCA
Service Template:
|
imports:
-
some_definition_file: path1/path2/some_defs.yaml
-
another_definition_file:
file:
path1/path2/file2.yaml
repository:
my_service_catalog
namespace_uri:
http://mycompany.com/tosca/1.0/platform
namespace_prefix:
mycompany
|
3.5.8
Property definition [comment?]
A property definition defines a named, typed
value and related data that can be associated with an entity
defined in this specification (e.g., Node Types, Relationship
Types, Capability Types, etc.). Properties are used by
template authors to provide input values to TOSCA entities which
indicate their “desired state” when they are
instantiated. The value of a property can be retrieved using
the get_property function
within TOSCA Service Templates.
3.5.8.1.1 Attribute and Property reflection [comment?]
The actual state of the entity, at any point
in its lifecycle once instantiated, is reflected by Attribute definitions.
TOSCA orchestrators automatically create an attribute for every
declared property (with the same symbolic name) to allow
introspection of both the desired state (property) and actual state
(attribute).
The following is the list of
recognized keynames for a TOSCA property definition:
|
Keyname
|
Required
|
Type
|
Constraints
|
Description
|
|
type
|
yes
|
string
|
None
|
The required data type for the property.
|
|
description
|
no
|
description
|
None
|
The optional description for the property.
|
|
required
|
no
|
boolean
|
default: true
|
An optional key that declares a property as
required (true) or
not (false).
|
|
default
|
no
|
<any>
|
None
|
An optional key that may provide a value to be
used as a default if not provided by another means.
|
|
status
|
no
|
string
|
default: supported
|
The optional status of the property relative
to the specification or implementation. See table below for valid
values.
|
|
constraints
|
no
|
list of
constraint clauses
|
None
|
The optional list of sequenced constraint
clauses for the property.
|
|
entry_schema
|
no
|
string
|
None
|
The optional key that is used to declare the
name of the Datatype
definition for entries of set types such as the TOSCA list or map.
|
3.5.8.3 Status
values [comment?]
The following property status
values are supported:
|
Value
|
Description
|
|
supported
|
Indicates the property is supported.
This is the default value for all property definitions.
|
|
unsupported
|
Indicates the property is not supported.
|
|
experimental
|
Indicates the property is experimental and has
no official standing.
|
|
deprecated
|
Indicates the property has been deprecated by
a new specification version.
|
Named property definitions have the
following grammar:
In the above grammar, the pseudo
values that appear in angle brackets have the following
meaning:
·
property_name: represents
the required symbolic name of the property as a string.
·
property_description:
represents the optional description of the property.
·
property_type: represents
the required data type of the property.
·
property_required:
represents an optional boolean
value (true or false) indicating whether or not the property is
required. If this keyname is not present on a property
definition, then the property SHALL be considered required
(i.e., true) by default.
·
default_value: contains a
type-compatible value that may be used as a default if not provided
by another means.
·
status_value: a string that contains a keyword that
indicates the status of the property relative to the specification
or implementation.
·
property_constraints:
represents the optional sequenced list of one
or more constraint
clauses on the property definition.
·
entry_description:
represents the optional description of the entry
schema.
·
entry_type: represents
the required type name for entries in a list or map
property type.
·
entry_constraints:
represents the optional sequenced list of one
or more constraint
clauses on entries in a list or
map property type.
3.5.8.5 Additional Requirements [comment?]
·
Implementations of the TOSCA Simple Profile SHALL
automatically reflect (i.e., make available) any property defined
on an entity as an attribute of the entity with the same name as
the property.
·
A property SHALL be considered required
by default (i.e., as if the required keyname on the definition is
set to true) unless the
definition’s required keyname is explicitly set to
false.
·
The value provided on a property definition’s default keyname SHALL be type
compatible with the type declared on the definition’s
type keyname.
- Constraints of a property definition
SHALL be type-compatible with the type defined for that
definition.
·
This element directly maps to the PropertiesDefinition element defined
as part of the schema for most type and entities defined in the
TOSCA v1.0 specification.
- In the TOSCA
v1.0 specification constraints are expressed in the XML Schema
definitions of Node Type properties referenced in the PropertiesDefinition element of
NodeType
definitions.
The following represents an example of
a property definition with constraints:
|
properties:
num_cpus:
type: integer
description: Number of CPUs requested for a software
node instance.
default: 1
required: true
constraints:
- valid_values: [ 1, 2, 4, 8 ]
|
3.5.9 Property assignment [comment?]
This section defines the grammar for assigning
values to named properties within TOSCA Node and Relationship
templates that are defined in their corresponding named types.
The TOSCA property assignment has no
keynames.
Property assignments have the
following grammar:
3.5.9.2.1 Short notation: [comment?]
The following single-line grammar may
be used when a simple value assignment is needed:
|
<property_name>: <property_value> | {
<property_value_expression> }
|
In the above grammars, the pseudo
values that appear in angle brackets have the following
meaning:
·
property_name: represents
the name of a property that would be used to select a property
definition with the same name within on a TOSCA entity (e.g., Node
Template, Relationship Template, etc,) which is declared in its
declared type (e.g., a Node Type, Node Template, Capability Type,
etc.).
·
property_value,
property_value_expression: represent
the type-compatible value to assign to the named property.
Property values may be provided as the result from the evaluation
of an expression or a function.
3.5.10
Attribute definition [comment?]
An attribute definition defines a named, typed
value that can be associated with an entity defined in this
specification (e.g., a Node, Relationship or Capability
Type). Specifically, it is used to expose the “actual
state” of some property of a TOSCA entity after it has been
deployed and instantiated (as set by the TOSCA orchestrator).
Attribute values can be retrieved via the get_attribute function from the
instance model and used as values to other entities within TOSCA
Service Templates.
3.5.10.1 Attribute and Property reflection [comment?]
TOSCA orchestrators automatically create
Attribute definitions
for any Property
definitions declared on the same TOSCA entity (e.g., nodes,
node capabilities and relationships) in order to make accessible
the actual (i.e., the current state) value from the running
instance of the entity.
The following is the list of
recognized keynames for a TOSCA attribute definition:
|
Keyname
|
Required
|
Type
|
Constraints
|
Description
|
|
type
|
yes
|
string
|
None
|
The required data type for the attribute.
|
|
description
|
no
|
description
|
None
|
The optional description for the
attribute.
|
|
default
|
no
|
<any>
|
None
|
An optional key that may provide a value to be
used as a default if not provided by another means.
This value SHALL be type compatible with the
type declared by the property definition’s type keyname.
|
|
status
|
no
|
string
|
default: supported
|
The optional status of the attribute relative
to the specification or implementation. See supported
status values
defined under the Property
definition section.
|
|
entry_schema
|
no
|
string
|
None
|
The optional key that is used to declare the
name of the Datatype
definition for entries of set types such as the TOSCA list or map.
|
Attribute definitions have the
following grammar:
In the above grammar, the pseudo
values that appear in angle brackets have the following
meaning:
·
attribute_name:
represents the required symbolic name of the attribute as a
string.
·
attribute_type:
represents the required data type of the attribute.
·
attribute_description:
represents the optional description of the attribute.
·
default_value: contains a
type-compatible value that may be used as a default if not provided
by another means.
·
status_value: contains a
value indicating the attribute’s status relative to the
specification version (e.g., supported, deprecated, etc.).
Supported status
values for this keyname are defined under Property definition.
3.5.10.4 Additional Requirements [comment?]
·
In addition to any explicitly defined attributes on a TOSCA entity
(e.g., Node Type, RelationshipType, etc.), implementations of the
TOSCA Simple Profile MUST automatically reflect (i.e., make
available) any property defined on an entity as an attribute of the
entity with the same name as the property.
·
Values for the default keyname MUST be derived or calculated
from other attribute or operation output values (that reflect the
actual state of the instance of the corresponding resource) and not
hard-coded or derived from a property settings or inputs (i.e.,
desired state).
·
Attribute definitions are very similar to Property definitions; however,
properties of entities reflect an input that carries the template
author’s requested or desired value (i.e., desired state)
which the orchestrator (attempts to) use when instantiating the
entity whereas attributes reflect the actual value (i.e., actual
state) that provides the actual instantiated value.
o For
example, a property can be used to request the IP address of a node
using a property (setting); however, the actual IP address after
the node is instantiated may by different and made available by an
attribute.
The following represents a required
attribute definition:
|
actual_cpus:
type:
integer
description:
Actual number of CPUs allocated to the node instance.
|
3.5.11 Attribute assignment [comment?]
This section defines the grammar for assigning
values to named attributes within TOSCA Node and Relationship
templates which are defined in their corresponding named types.
The TOSCA attribute assignment has no
keynames.
Attribute assignments have the
following grammar:
3.5.11.2.1 Short notation: [comment?]
The following single-line grammar may
be used when a simple value assignment is needed:
|
<attribute_name>: <attribute_value> | {
<attribute_value_expression> }
|
3.5.11.2.2 Extended notation: [comment?]
The following multi-line grammar may
be used when a value assignment requires keys in addition to a
simple value assignment:
|
<attribute_name>:
description:
<attribute_description>
value:
<attribute_value> | { <attribute_value_expression>
}
|
In the above grammars, the pseudo
values that appear in angle brackets have the following
meaning:
·
attribute_name:
represents the name of an attribute that would be used to select an
attribute definition with the same name within on a TOSCA entity
(e.g., Node Template, Relationship Template, etc.) which is
declared (or reflected from a Property definition) in its declared
type (e.g., a Node Type, Node Template, Capability Type,
etc.).
·
attribute_value, attribute_value_expresssion:
represent the type-compatible value to assign to the named
attribute. Attribute values may be provided as the result
from the evaluation of an expression or a function.
·
attribute_description:
represents the optional description of the attribute.
3.5.11.3 Additional requirements [comment?]
·
Attribute values MAY be provided by the underlying
implementation at runtime when requested by the get_attribute
function or it MAY be provided through the evaluation of
expressions and/or functions that derive the values from other
TOSCA attributes (also at runtime).
3.5.12
Parameter definition [comment?]
A parameter definition is essentially a TOSCA
property definition; however, it also allows a value to be assigned
to it (as for a TOSCA property assignment). In addition, in the
case of output parameters, it can optionally inherit the data type
of the value assigned to it rather than have an explicit data type
defined for it.
The TOSCA parameter definition has all
the keynames of a TOSCA Property definition, but in addition
includes the following additional or changed keynames:
|
Keyname
|
Required
|
Type
|
Constraints
|
Description
|
|
type
|
no
|
string
|
None
|
The required data type for the parameter.
Note: This keyname is required for a TOSCA
Property definition, but is not for a TOSCA Parameter
definition.
|
|
value
|
no
|
<any>
|
N/A
|
The type-compatible value to assign to the
named parameter. Parameter values may be provided as the
result from the evaluation of an expression or a function.
|
Named parameter definitions have the
following grammar:
In the above grammar, the pseudo
values that appear in angle brackets have the following
meaning:
·
parameter_name:
represents the required symbolic name of the parameter as a
string.
·
parameter_description:
represents the optional description of the parameter.
·
parameter_type:
represents the optional data type of the parameter. Note,
this keyname is required for a TOSCA Property definition, but is
not for a TOSCA Parameter definition.
·
parameter_value, parameter_value_expresssion:
represent the type-compatible value to assign to the named
parameter. Parameter values may be provided as the result
from the evaluation of an expression or a function.
·
parameter_required:
represents an optional boolean
value (true or false) indicating whether or not the parameter is
required. If this keyname is not present on a parameter
definition, then the property SHALL be considered required
(i.e., true) by default.
·
default_value: contains a
type-compatible value that may be used as a default if not provided
by another means.
·
status_value: a string that contains a keyword that
indicates the status of the parameter relative to the specification
or implementation.
·
parameter_constraints:
represents the optional sequenced list of one
or more constraint
clauses on the parameter definition.
·
entry_description:
represents the optional description of the entry
schema.
·
entry_type: represents
the required type name for entries in a list or map
parameter type.
·
entry_constraints:
represents the optional sequenced list of one
or more constraint
clauses on entries in a list or
map parameter type.
3.5.12.3 Additional Requirements [comment?]
·
A parameter SHALL be considered required
by default (i.e., as if the required keyname on the definition is
set to true) unless the
definition’s required keyname is explicitly set to
false.
·
The value provided on a parameter definition’s default keyname SHALL be type
compatible with the type declared on the definition’s
type keyname.
- Constraints of a parameter definition
SHALL be type-compatible with the type defined for that
definition.
The following represents an example of
an input parameter definition with constraints:
|
inputs:
cpus:
type: integer
description: Number of CPUs for the server.
constraints:
- valid_values: [ 1,
2, 4, 8 ]
|
The following represents an example of
an (untyped) output parameter definition:
|
outputs:
server_ip:
description: The private IP address of the provisioned
server.
value: { get_attribute: [ my_server, private_address ]
}
|
3.5.13
Operation definition [comment?]
An operation definition defines a named
function or procedure that can be bound to an implementation
artifact (e.g., a script).
The following is the list of
recognized keynames for a TOSCA operation definition:
|
Keyname
|
Required
|
Type
|
Description
|
|
description
|
no
|
description
|
The optional description string for the
associated named operation.
|
|
implementation
|
no
|
string
|
The optional implementation artifact name
(e.g., a script file name within a TOSCA CSAR file).
|
|
inputs
|
no
|
list of
property
definitions
|
The optional list of input properties
definitions (i.e., parameter definitions) for operation definitions
that are within TOSCA Node or Relationship Type definitions. This
includes when operation definitions are included as part of a
Requirement definition in a Node Type.
|
|
no
|
list of
property
assignments
|
The optional list of input property
assignments (i.e., parameters assignments) for operation
definitions that are within TOSCA Node or Relationship Template
definitions. This includes when operation definitions are included
as part of a Requirement assignment in a Node Template.
|
The following is the list of
recognized keynames to be used with the implementation keyname within a TOSCA
operation definition:
|
Keyname
|
Required
|
Type
|
Description
|
|
primary
|
no
|
string
|
The optional implementation artifact name
(i.e., the primary script file name within a TOSCA CSAR
file).
|
|
dependencies
|
no
|
list of
string
|
The optional ordered list of one or more
dependent or secondary implementation artifact name which are
referenced by the primary implementation artifact (e.g., a library
the script installs or a secondary script).
|
Operation definitions have the
following grammars:
3.5.13.2.1 Short notation [comment?]
The following single-line grammar may
be used when only an operation’s implementation artifact is
needed:
3.5.13.2.2 Extended notation for use in Type definitions [comment?]
The following multi-line grammar may
be used in Node or Relationship Type definitions when additional
information about the operation is needed:
3.5.13.2.3 Extended notation for use in Template
definitions [comment?]
The following multi-line grammar may
be used in Node or Relationship Template definitions when there are
multiple artifacts that may be needed for the operation to be
implemented:
In the above grammars, the pseudo
values that appear in angle brackets have the following
meaning:
·
operation_name:
represents the required symbolic name of the operation as a
string.
·
operation_description:
represents the optional description string for the
corresponding operation_name.
·
implementation_artifact_name:
represents the optional name (string) of an implementation artifact
definition (defined elsewhere), or the direct name of an
implementation artifact’s relative filename (e.g., a service
template-relative, path-inclusive filename or absolute file
location using a URL).
·
property_definitions:
represents the optional list of property definitions which the
TOSCA orchestrator would make available (i.e., or pass) to the
corresponding implementation artifact during its execution.
·
property_assignments:
represents the optional list of property assignments
for passing parameters to Node or Relationship Template operations
providing values for properties defined in their respective type
definitions.
·
list_of_dependent_artifact_names:
represents the optional ordered list of one or more dependent or
secondary implementation artifact names (as strings) which are
referenced by the primary implementation artifact. TOSCA
orchestrators will copy these files to the same location as the
primary artifact on the target node so as to make them accessible
to the primary implementation artifact when it is executed.
3.5.13.3 Additional requirements [comment?]
·
The default sub-classing behavior for implementations of operations
SHALL be override. That is, implementation artifacts assigned
in subclasses override any defined in its parent class.
·
Template authors MAY provide property assignments on operation
inputs on templates that do not necessarily have a property
definition defined in its corresponding type.
·
Implementation artifact file names (e.g., script filenames) may
include file directory path names that are relative to the TOSCA
service template file itself when packaged within a TOSCA Cloud
Service ARchive (CSAR) file.
3.5.13.4.1 Single-line implementation example [comment?]
|
interfaces:
Standard:
start: scripts/start_server.sh
|
3.5.13.4.2 Multi-line implementation example [comment?]
|
interfaces:
Configure:
pre_configure_source:
implementation:
primary:
scripts/pre_configure_source.sh
dependencies:
- scripts/setup.sh
- binaries/library.rpm
- scripts/register.py
|
3.5.14
Interface definition [comment?]
An interface definition defines a named
interface that can be associated with a Node or Relationship
Type
The following is the list of
recognized keynames for a TOSCA interface definition:
|
Keyname
|
Required
|
Type
|
Description
|
|
inputs
|
no
|
list of
property
definitions
|
The optional list of input property
definitions available to all defined operations for interface
definitions that are within TOSCA Node or Relationship Type
definitions. This includes when interface definitions are included
as part of a Requirement definition in a Node Type.
|
|
no
|
list of
property
assignments
|
The optional list of input property
assignments (i.e., parameters assignments) for interface
definitions that are within TOSCA Node or Relationship Template
definitions. This includes when interface definitions are
referenced as part of a Requirement assignment in a Node
Template.
|
Interface definitions have the
following grammar:
3.5.14.2.1 Extended notation for use in Type definitions [comment?]
The following multi-line grammar may
be used in Node or Relationship Type definitions:
3.5.14.2.2 Extended notation for use in Template
definitions [comment?]
The following multi-line grammar may
be used in Node or Relationship Type definitions:
In the above grammars, the pseudo
values that appear in angle brackets have the following
meaning:
·
interface_definition_name: represents
the required symbolic name of the interface as a string.
·
interface_type_name: represents the required name of the
Interface Type for the interface definition.
·
property_definitions:
represents the optional list of property definitions (i.e.,
parameters) which the TOSCA orchestrator would make available
(i.e., or pass) to all defined operations.
- This
means these properties and their values would be accessible to the
implementation artifacts (e.g., scripts) associated to each
operation during their execution.
·
property_assignments:
represents the optional list of property assignments
for passing parameters to Node or Relationship Template operations
providing values for properties defined in their respective type
definitions.
·
operation_definitions:
represents the required name of one or more operation definitions.
3.6
Type-specific definitions [comment?]
3.6.1
Capability definition [comment?]
A capability definition defines a named, typed
set of data that can be associated with Node Type or Node Template
to describe a transparent capability or feature of the software
component the node describes.
The following is the list of
recognized keynames for a TOSCA capability definition:
|
Keyname
|
Required
|
Type
|
Constraints
|
Description
|
|
type
|
yes
|
string
|
N/A
|
The required name of the Capability Type the
capability definition is based upon.
|
|
description
|
no
|
description
|
N/A
|
The optional description of the Capability
definition.
|
|
properties
|
no
|
list of
property
definitions
|
N/A
|
An optional list of property definitions for
the Capability definition.
|
|
attributes
|
no
|
list of
attribute definitions
|
N/A
|
An optional list of attribute definitions for
the Capability definition.
|
|
valid_source_types
|
no
|
string[]
|
N/A
|
An optional list of one or more valid names of
Node Types that are supported as valid sources of any relationship
established to the declared Capability Type.
|
|
occurrences
|
no
|
range of
integer
|
implied default of [1,UNBOUNDED]
|
The optional minimum and maximum occurrences
for the capability. By default, an exported Capability should allow
at least one relationship to be formed with it with a maximum of
UNBOUNDED relationships.
Note: the keyword UNBOUNDED is also supported to
represent any positive integer.
|
Capability definitions have one of the
following grammars:
3.6.1.2.1 Short notation [comment?]
The following grammar may be used when
only a list of capability definition names needs to be
declared:
3.6.1.2.2 Extended notation [comment?]
The following multi-line grammar may
be used when additional information on the capability definition is
needed:
In the above grammars, the pseudo
values that appear in angle brackets have the following
meaning:
·
capability_definition_name:
represents the symbolic name of the capability as a string.
·
capability_type:
represents the required name of a capability type the capability
definition is based upon.
·
capability_description:
represents the optional description of the capability
definition.
·
property_definitions:
represents the optional list of property definitions for the
capability definition.
·
attribute_definitions:
represents the optional list of attribute definitions for the
capability definition.
·
node_type_names:
represents the optional list of one or more names of Node Types that the Capability
definition supports as valid sources for a successful relationship
to be established to itself.
The following examples show capability
definitions in both simple and full forms:
3.6.1.3.1 Simple notation example [comment?]
|
# Simple notation,
no properties defined or augmented
some_capability:
mytypes.mycapabilities.MyCapabilityTypeName
|
3.6.1.3.2 Full notation
example [comment?]
|
# Full notation,
augmenting properties of the referenced capability type
some_capability:
type:
mytypes.mycapabilities.MyCapabilityTypeName
properties:
limit:
type:
integer
default:
100
|
3.6.1.4 Additional requirements [comment?]
·
Any Node Type (names) provides as values for the valid_source_types keyname SHALL be
type-compatible (i.e., derived from the same parent Node Type) with
any Node Types defined using the same keyname in the parent
Capability Type.
·
Capability symbolic names SHALL be unique; it is an error if a
capability name is found to occur more than once.
-
The
Capability Type, in this example
MyCapabilityTypeName, would be defined elsewhere and have an
integer property named limit.
- This definition directly maps to the
CapabilitiesDefinition of
the Node Type entity as defined in the TOSCA v1.0 specification.
3.6.2
Requirement definition [comment?]
The Requirement definition describes a named
requirement (dependencies) of a TOSCA Node Type or Node template
which needs to be fulfilled by a matching Capability definition
declared by another TOSCA modelable entity. The requirement
definition may itself include the specific name of the fulfilling
entity (explicitly) or provide an abstract type, along with
additional filtering characteristics, that a TOSCA orchestrator can
use to fulfil the capability at runtime (implicitly).
The following is the list of
recognized keynames for a TOSCA requirement definition:
|
Keyname
|
Required
|
Type
|
Constraints
|
Description
|
|
capability
|
yes
|
string
|
N/A
|
The required reserved keyname used that can be
used to provide the name of a valid Capability Type that can
fulfil the requirement.
|
|
node
|
no
|
string
|
N/A
|
The optional reserved keyname used to provide
the name of a valid Node Type
that contains the capability definition that can be used to fulfil
the requirement.
|
|
relationship
|
no
|
string
|
N/A
|
The optional reserved keyname used to provide
the name of a valid Relationship Type to construct
when fulfilling the requirement.
|
|
occurrences
|
no
|
range of
integer
|
implied default of [1,1]
|
The optional minimum and maximum occurrences
for the requirement.
Note: the keyword UNBOUNDED is also supported to
represent any positive integer.
|
3.6.2.1.1 Additional Keynames for multi-line relationship
grammar [comment?]
The Requirement definition contains
the Relationship Type information needed by TOSCA Orchestrators to
construct relationships to other TOSCA nodes with matching
capabilities; however, it is sometimes recognized that additional
properties may need to be passed to the relationship (perhaps for
configuration). In these cases, additional grammar is
provided so that the Node Type may declare additional Property
definitions to be used as inputs to the Relationship Type’s
declared interfaces (or specific operations of those
interfaces).
|
Keyname
|
Required
|
Type
|
Constraints
|
Description
|
|
type
|
yes
|
string
|
N/A
|
The optional reserved keyname used to provide
the name of the Relationship Type for the requirement
definition’s relationship keyname.
|
|
interfaces
|
no
|
list of interface definitions
|
N/A
|
The optional reserved keyname used to
reference declared (named) interface definitions of the
corresponding Relationship Type in order to declare additional
Property definitions for these interfaces or operations of these
interfaces.
|
Requirement definitions have one of
the following grammars:
3.6.2.2.1 Simple grammar (Capability Type only) [comment?]
3.6.2.2.2 Extended grammar (with Node and Relationship
Types) [comment?]
3.6.2.2.3 Extended grammar for declaring Property Definitions
on the relationship’s Interfaces [comment?]
The following additional multi-line
grammar is provided for the relationship keyname in order to
declare new Property definitions for inputs of known Interface
definitions of the declared Relationship Type.
In the above grammars, the pseudo
values that appear in angle brackets have the following
meaning:
·
requirement_name:
represents the required symbolic name of the requirement definition
as a string.
·
capability_type_name:
represents the required name of a Capability type that can be used
to fulfil the requirement.
·
node_type_name:
represents the optional name of a TOSCA Node Type that contains the
Capability Type definition the requirement can be fulfilled
by.
·
relationship_type_name:
represents the optional name of a Relationship Type to be used
to construct a relationship between this requirement definition
(i.e., in the source node) to a matching capability definition (in
a target node).
·
min_occurrences,
max_occurrences: represents the optional minimum and maximum
occurrences of the requirement (i.e., its cardinality).
·
interface_definitions:
represents one or more already declared interface definitions in
the Relationship Type (as declared on the type keyname) allowing for the
declaration of new Property definition for these interfaces or for
specific Operation definitions of these interfaces.
3.6.2.3 Additional Requirements [comment?]
·
Requirement symbolic names SHALL be unique; it is an error if a
requirement name is found to occur more than once.
·
If the occurrences
keyname is not present, then the occurrence of the requirement
SHALL be one and only one; that is a default declaration as
follows would be assumed:
o occurrences: [1,1]
·
This element directly maps to the RequirementsDefinition of the Node
Type entity as defined in the TOSCA v1.0
specification.
·
The requirement symbolic name is used for identification of the
requirement definition only and not relied upon for establishing
any relationships in the topology.
3.6.2.5 Requirement Type definition is a tuple [comment?]
A requirement definition allows type designers
to govern which types are allowed (valid) for fulfillment using
three levels of specificity with only the Capability Type being
required.
1. Node Type (optional)
2. Relationship Type
(optional)
3. Capability Type (required)
The first level allows selection, as
shown in both the simple or complex grammar, simply providing the
node’s type using the node keyname. The second level allows
specification of the relationship type to use when connecting the
requirement to the capability using the relationship keyname. Finally,
the specific named capability type on the target node is provided
using the capability
keyname.
3.6.2.5.1 Property filter [comment?]
In addition to the node, relationship and
capability types, a filter, with the keyname node_filter, may be provided to
constrain the allowed set of potential target nodes based upon
their properties and their capabilities’ properties.
This allows TOSCA orchestrators to help find the “best
fit” when selecting among multiple potential target nodes for
the expressed requirements.
An Artifact Type is a reusable entity that
defines the type of one or more files that are used to define
implementation or deployment artifacts that are referenced by nodes
or relationships on their operations.
The following is the list of
recognized keynames for a TOSCA Artifact Type definition:
|
Keyname
|
Required
|
Type
|
Description
|
|
derived_from
|
no
|
string
|
An optional parent Artifact Type name the
Artifact Type derives from.
|
|
version
|
no
|
version
|
An optional version for the Artifact Type
definition.
|
|
description
|
no
|
description
|
An optional description for the Artifact
Type.
|
|
mime_type
|
no
|
string
|
The required mime type property for the
Artifact Type.
|
|
file_ext
|
no
|
string[]
|
The required file extension property for the
Artifact Type.
|
|
properties
|
no
|
list of
property
definitions
|
An optional list of property definitions for
the Artifact Type.
|
Artifact Types have following
grammar:
In the above grammar, the pseudo
values that appear in angle brackets have the following
meaning:
·
artifact_type_name:
represents the name of the Artifact Type being declared as a
string.
·
parent_artifact_type_name: represents
the name of the Artifact Type this Artifact Type
definition derives from (i.e., its “parent” type).
·
version_number:
represents the optional TOSCA version number for the Artifact Type.
·
artifact_description:
represents the optional description string for the Artifact
Type.
·
mime_type_string:
represents the optional Multipurpose Internet Mail Extensions
(MIME) standard string value that describes the file contents for
this type of Artifact Type as a string.
·
file_extensions:
represents the optional list of one or more recognized file
extensions for this type of artifact type as strings.
·
property_definitions:
represents the optional list of property definitions for the
artifact type.
|
my_artifact_type:
description:
Java Archive artifact type
derived_from:
tosca.artifact.Root
mime_type: application/java-archive
file_ext: [
jar ]
|
3.6.4
Interface Type [comment?]
An Interface Type is a reusable entity
that describes a set of operations that can be used to interact
with or manage a node or relationship in a TOSCA topology.
The following is the list of
recognized keynames for a TOSCA Interface Type definition:
|
Keyname
|
Required
|
Type
|
Description
|
|
version
|
no
|
version
|
An optional version for the Interface Type
definition.
|
|
description
|
no
|
description
|
An optional description for the Interface
Type.
|
|
inputs
|
no
|
list of
property
definitions
|
The optional list of input parameter
definitions.
|
Interface Types have following
grammar:
In the above grammar, the pseudo
values that appear in angle brackets have the following
meaning:
-
interface_type_name: represents the
required name of the interface as a string.
·
version_number:
represents the optional TOSCA version number for the Interface
Type.
·
interface_description:
represents the optional description string for the
Interface Type.
-
property_definitions: represents the
optional list of property
definitions (i.e., parameters) which the TOSCA orchestrator
would make available (i.e., or pass) to all implementation
artifacts for operations declared on the interface during their
execution.
-
operation_definitions: represents the
required list of one or more operation definitions.
The following example shows a custom
interface used to define multiple configure operations.
|
mycompany.mytypes.myinterfaces.MyConfigure:
description:
My custom configure Interface Type
inputs:
mode:
type:
string
pre_configure_service:
description: pre-configure operation for my service
post_configure_service:
description: post-configure operation for my service
|
3.6.4.4 Additional Requirements [comment?]
·
Interface Types MUST NOT include any implementations for
defined operations; that is, the implementation keyname is
invalid.
·
The inputs keyname is
reserved and SHALL NOT be used for an operation
name.
·
The TOSCA Simple Profile specification does not yet provide a means
to derive or extend an Interface Type from another Interface
Type.
A Data Type definition defines the schema for
new named datatypes in TOSCA.
The following is the list of
recognized keynames for a TOSCA Data Type definition:
|
Keyname
|
Required
|
Type
|
Description
|
|
derived_from
|
no
|
string
|
The optional key used when a datatype is
derived from an existing TOSCA Data Type.
|
|
version
|
no
|
version
|
An optional version for the Data Type
definition.
|
|
description
|
no
|
description
|
The optional description for the Data
Type.
|
|
constraints
|
no
|
list of
constraint clauses
|
The optional list of sequenced constraint clauses for the Data
Type.
|
|
properties
|
no
|
list of
property definitions
|
The optional list property definitions
that comprise the schema for a complex Data Type in TOSCA.
|
Data Types have the following grammar:
In the above grammar, the pseudo
values that appear in angle brackets have the following
meaning:
·
data_type_name:
represents the required symbolic name of the Data Type as a
string.
·
version_number:
represents the optional TOSCA version number for the Data Type.
·
datatype_description:
represents the optional description for the Data Type.
·
existing_type_name:
represents the optional name of a valid TOSCA type this new Data
Type would derive from.
·
type_constraints:
represents the optional sequenced list of one
or more type-compatible constraint clauses that
restrict the Data Type.
·
property_definitions:
represents the optional list of one or more property definitions that provide
the schema for the Data Type.
3.6.5.3 Additional Requirements [comment?]
·
A valid datatype definition MUST have either a valid
derived_from declaration
or at least one valid property definition.
·
Any constraint clauses
SHALL be type-compatible with the type declared by the
derived_from keyname.
·
If a properties keyname
is provided, it SHALL contain one or more valid property
definitions.
The following example represents a Data
Type definition based upon an existing string type:
3.6.5.4.1 Defining a complex datatype [comment?]
|
# define a new complex
datatype
mytypes.phonenumber:
description: my phone
number datatype
properties:
countrycode:
type: integer
areacode:
type: integer
number:
type: integer
|
3.6.5.4.2 Defining a datatype derived from an existing
datatype [comment?]
|
# define a new datatype that
derives from existing type and extends it
mytypes.phonenumber.extended:
derived_from:
mytypes.phonenumber
description: custom
phone number type that extends the basic phonenumber
type
properties:
phone_description:
type: string
constraints:
-
max_length: 128
|
3.6.6
Capability Type [comment?]
A Capability Type is a reusable entity
that describes a kind of capability that a Node Type can declare to
expose. Requirements (implicit or explicit) that are declared
as part of one node can be matched to (i.e., fulfilled by) the
Capabilities declared by another node.
The following is the list of
recognized keynames for a TOSCA Capability Type definition:
|
Keyname
|
Required
|
Type
|
Description
|
|
derived_from
|
no
|
string
|
An optional parent capability type name this
new Capability Type derives from.
|
|
version
|
no
|
version
|
An optional version for the Capability Type
definition.
|
|
description
|
no
|
description
|
An optional description for the Capability
Type.
|
|
properties
|
no
|
list of
property definitions
|
An optional list of property definitions for
the Capability Type.
|
|
attributes
|
no
|
list of
attribute definitions
|
An optional list of attribute definitions for
the Capability Type.
|
|
valid_source_types
|
no
|
string[]
|
An optional list of one or more valid names of
Node Types that are supported as valid sources of any relationship
established to the declared Capability Type.
|
Capability Types have following
grammar:
In the above grammar, the pseudo
values that appear in angle brackets have the following
meaning:
·
capability_type_name:
represents the required name of the Capability Type being declared
as a string.
·
parent_capability_type_name:
represents the name of the Capability Type this Capability
Type definition derives from (i.e., its “parent”
type).
·
version_number:
represents the optional TOSCA version number for the Capability
Type.
·
capability_description:
represents the optional description string for the
corresponding capability_type_name.
·
property_definitions:
represents an optional list of property definitions that the
Capability type exports.
·
attribute_definitions:
represents the optional list of attribute definitions for the
Capability Type.
·
node_type_names:
represents the optional list of one or more names of Node Types that the Capability Type
supports as valid sources for a successful relationship to be
established to itself.
|
mycompany.mytypes.myapplication.MyFeature:
derived_from:
tosca.capabilities.Root
description:
a custom feature of my company’s application
properties:
my_feature_setting:
type:
string
my_feature_value:
type:
integer
|
3.6.7 Requirement Type [comment?]
A Requirement Type is a reusable
entity that describes a kind of requirement that a Node Type can
declare to expose. The TOSCA Simple Profile seeks to simplify
the need for declaring specific Requirement Types from nodes and
instead rely upon nodes declaring their features sets using TOSCA
Capability Types along with a named Feature notation.
Currently, there are no use cases in this
TOSCA Simple Profile in YAML specification that utilize an
independently defined Requirement Type. This is a desired
effect as part of the simplification of the TOSCA v1.0
specification.
A Node Type is a reusable entity that defines
the type of one or more Node Templates. As such, a Node Type
defines the structure of observable properties via a Properties
Definition, the Requirements and Capabilities of the node as well
as its supported interfaces.
The following is the list of
recognized keynames for a TOSCA Node Type definition:
|
Keyname
|
Required
|
Definition/Type
|
Description
|
|
derived_from
|
no
|
string
|
An optional parent Node Type name this new
Node Type derives from.
|
|
version
|
no
|
version
|
An optional version for the Node Type
definition.
|
|
description
|
no
|
description
|
An optional description for the Node Type.
|
|
properties
|
no
|
list of
property
definitions
|
An optional list of property definitions for
the Node Type.
|
|
attributes
|
no
|
list of
attribute definitions
|
An optional list of attribute definitions for
the Node Type.
|
|
requirements
|
no
|
list of
requirement definitions
|
An optional sequenced list
of requirement definitions for the Node Type.
|
|
capabilities
|
no
|
list of
capability definitions
|
An optional list of capability definitions for
the Node Type.
|
|
interfaces
|
no
|
list of
interface definitions
|
An optional list of interface definitions
supported by the Node Type.
|
|
artifacts
|
no
|
list of
artifact
definitions
|
An optional list of named artifact definitions
for the Node Type.
|
Node Types have following grammar:
In the above
grammar, the pseudo values that appear in angle brackets have the
following meaning:
·
node_type_name:
represents the required symbolic name of the Node Type being
declared.
·
parent_node_type_name:
represents the name (string) of the
Node Type this Node Type
definition derives from (i.e., its “parent” type).
·
version_number:
represents the optional TOSCA version number for the Node Type.
·
node_type_description:
represents the optional description string for the
corresponding node_type_name.
·
property_definitions:
represents the optional list of property definitions for the Node
Type.
·
attribute_definitions:
represents the optional list of attribute definitions for the
Node Type.
·
requirement_definitions:
represents the optional sequenced list of
requirement definitions
for the Node Type.
·
capability_definitions:
represents the optional list of capability definitions for the
Node Type.
·
interface_definitions:
represents the optional list of one or more interface definitions supported
by the Node Type.
·
artifact_definitions:
represents the optional list of artifact definitions for the Node
Type.
3.6.8.3 Additional Requirements [comment?]
·
Requirements are intentionally expressed as a sequenced list of
TOSCA Requirement
definitions which SHOULD be resolved (processed) in
sequence order by TOSCA Orchestrators. .
3.6.8.4 Best Practices [comment?]
·
It is recommended that all Node Types SHOULD derive directly
(as a parent) or indirectly (as an ancestor) of the TOSCA Root Node
Type (i.e., tosca.nodes.Root) to promote
compatibility and portability. However, it is permitted to
author Node Types that do not do so.
·
TOSCA Orchestrators, having a full view of the complete application
topology template and its resultant dependency graph of nodes and
relationships, MAY prioritize how they instantiate the nodes
and relationships for the application (perhaps in parallel where
possible) to achieve the greatest efficiency
|
my_company.my_types.my_app_node_type:
derived_from:
tosca.nodes.SoftwareComponent
description:
My company’s custom applicaton
properties:
my_app_password:
type:
string
description:
application password
constraints:
-
min_length: 6
-
max_length: 10
attributes:
my_app_port:
type:
integer
description:
application port number
requirements:
-
some_database:
capability: EndPoint.Database
node:
Database
relationship: ConnectsTo
|
3.6.9
Relationship Type [comment?]
A Relationship Type is a reusable entity that
defines the type of one or more relationships between Node Types or
Node Templates.
The following is the list of
recognized keynames for a TOSCA Relationship Type definition:
|
Keyname
|
Required
|
Definition/Type
|
Description
|
|
derived_from
|
no
|
string
|
An optional parent Relationship Type name the
Relationship Type derives from.
|
|
version
|
no
|
version
|
An optional version for the Relationship Type
definition.
|
|
description
|
no
|
description
|
An optional description for the Relationship
Type.
|
|
properties
|
no
|
list of
property
definitions
|
An optional list of property definitions for
the Relationship Type.
|
|
attributes
|
no
|
list of
attribute definitions
|
An optional list of attribute definitions for
the Relationship Type.
|
|
interfaces
|
no
|
list of
interface definitions
|
An optional list of interface definitions
interfaces supported by the Relationship Type.
|
|
valid_target_types
|
no
|
string[]
|
An optional list of one or more names of
Capability Types that are valid targets for this relationship.
|
Relationship Types have following
grammar:
In the above grammar, the pseudo
values that appear in angle brackets have the following
meaning:
·
relationship_type_name:
represents the required symbolic name of the Relationship Type
being declared as a string.
·
parent_relationship_type_name:
represents the name (string) of the
Relationship Type this
Relationship Type definition derives from (i.e., its
“parent” type).
·
relationship_description:
represents the optional description string for the
corresponding relationship_type_name.
·
version_number:
represents the optional TOSCA version number for the Relationship
Type.
·
property_definitions:
represents the optional list of property definitions for the
Relationship Type.
·
attribute_definitions:
represents the optional list of attribute definitions for the
Relationship Type.
·
interface_definitions:
represents the optional list of one or more names of valid interface definitions supported
by the Relationship Type.
·
capability_type_names:
represents one or more names of valid target types for the
relationship (i.e., Capability Types).
3.6.9.3 Best Practices [comment?]
·
For TOSCA application portability, it is recommended that designers
use the normative Relationship types defined in this specification
where possible and derive from them for customization purposes.
·
The TOSCA Root Relationship Type (tosca.relationships.Root) SHOULD be
used to derive new types where possible when defining new
relationships types. This assures that its normative
configuration interface (tosca.interfaces.relationship.Configure)
can be used in a deterministic way by TOSCA orchestrators.
|
mycompanytypes.myrelationships.AppDependency:
derived_from:
tosca.relationships.DependsOn
valid_target_types: [
mycompanytypes.mycapabilities.SomeAppCapability ]
|
A Group Type defines logical grouping types
for nodes, typically for different management purposes. Groups can
effectively be viewed as logical nodes that are not part of the
physical deployment topology of an application, yet can have
capabilities and the ability to attach policies and interfaces that
can be applied (depending on the group type) to its member
nodes.
Conceptually, group definitions allow the
creation of logical “membership” relationships to nodes
in a service template that are not a part of the
application’s explicit requirement dependencies in the
topology template (i.e. those required to actually get the
application deployed and running). Instead, such logical membership
allows for the introduction of things such as group management and
uniform application of policies (i.e., requirements that are also
not bound to the application itself) to the group’s
members.
The following is the list of
recognized keynames for a TOSCA Group Type definition:
|
Keyname
|
Required
|
Type
|
Description
|
|
derived_from
|
no
|
string
|
An optional parent Group Type name the Group
Type derives from.
|
|
version
|
no
|
version
|
An optional version for the Group Type
definition.
|
|
description
|
no
|
description
|
The optional description for the Group
Type.
|
|
properties
|
no
|
list of
property
definitions
|
An optional list of property definitions for
the Group Type.
|
|
targets
|
no
|
string[]
|
An optional list of one or more names of Node
Types that are valid (allowed) as members of the Group
Type.
Note: This can be viewed by TOSCA
Orchestrators as an implied relationship to the target nodes, but
one that does not have operational lifecycle considerations.
For example, if we were to name this as an explicit Relationship
Type we might call this “InvitesTo” (group).
|
|
interfaces
|
no
|
list of
interface definitions
|
An optional list of interface definitions
supported by the Group Type.
|
Group Types have one the following
grammars:
In the above grammar, the pseudo
values that appear in angle brackets have the following
meaning:
·
group_type_name:
represents the required symbolic name of the Group Type being
declared as a string..
·
parent_group_type_name:
represents the name (string) of the
Group Type this Group
Type definition derives from (i.e., its “parent”
type).
·
version_number:
represents the optional TOSCA version number for the Group Type.
·
group_description:
represents the optional description string for the corresponding
group_type_name.
·
property_definitions:
represents the optional list of property definitions for the
Group Type.
·
list_of_valid_target_types:
represents the optional list of TOSCA types (i.e., Node or
Capability Types) that are valid target types for being added to
(i.e., members of) the Group Type.
·
interface_definitions:
represents the optional list of one or more interface definitions supported
by the Group Type.
3.6.10.3 Additional Requirements [comment?]
·
Group definitions SHOULD NOT be used to define or
redefine relationships (dependencies) for an application that can
be expressed using normative TOSCA Relationships within a TOSCA
topology template.
·
The list of values associated with the “members”
keyname MUST only contain types that or homogenous (i.e.,
derive from the same type hierarchy).
The following represents a Group Type
definition:
|
group_types:
mycompany.mytypes.groups.placement:
description: My company’s group type for placing nodes of
type Compute
targets: [ tosca.nodes.Compute ]
|
A Policy Type defines a type of requirement
that affects or governs an application or service’s topology
at some stage of its lifecycle, but is not explicitly part of the
topology itself (i.e., it does not prevent the application or
service from being deployed or run if it did not exist).
The following is the list of
recognized keynames for a TOSCA Policy Type definition:
|
Keyname
|
Required
|
Type
|
Description
|
|
derived_from
|
no
|
string
|
An optional parent Policy Type name the Policy
Type derives from.
|
|
version
|
no
|
version
|
An optional version for the Policy Type
definition.
|
|
description
|
no
|
description
|
The optional description for the Policy
Type.
|
|
properties
|
no
|
list of
property
definitions
|
An optional list of property definitions for
the Policy Type.
|
|
targets
|
no
|
string[]
|
An optional list of valid Node Types or Group
Types the Policy Type can be applied to.
Note: This can be viewed by TOSCA
Orchestrators as an implied relationship to the target nodes, but
one that does not have operational lifecycle considerations.
For example, if we were to name this as an explicit Relationship
Type we might call this “AppliesTo” (node or
group).
|
Policy Types have one the following
grammars:
In the above grammar, the pseudo
values that appear in angle brackets have the following
meaning:
·
policy_type_name:
represents the required symbolic name of the Policy Type being
declared as a string.
·
parent_policy_type_name:
represents the name (string) of the
Policy Type this Policy Type definition derives from (i.e., its
“parent” type).
·
version_number:
represents the optional TOSCA version number for the Policy Type.
·
policy_description:
represents the optional description string for the corresponding
policy_type_name.
·
property_definitions:
represents the optional list of property definitions for the
Policy Type.
·
list_of_valid_target_types:
represents the optional list of TOSCA types (i.e., Group or Node
Types) that are valid targets for this Policy Type.
3.6.11.3 Additional Requirements [comment?]
·
None
The following represents a Policy Type
definition:
|
policy_types:
mycompany.mytypes.policies.placement.Container.Linux:
description: My company’s placement policy for
linux
derived_from: tosca.policies.Root
|
3.7
Template-specific definitions [comment?]
The definitions in this section provide
reusable modeling element grammars that are specific to the Node or
Relationship templates.
3.7.1 Capability assignment [comment?]
A capability assignment allows node template
authors to assign values to properties and attributes for a named
capability definition that is part of a Node Template’s type
definition.
The following is the list of
recognized keynames for a TOSCA capability assignment:
|
Keyname
|
Required
|
Type
|
Description
|
|
properties
|
no
|
list of
property
assignments
|
An optional list of property definitions for
the Capability definition.
|
|
attributes
|
no
|
list of
attribute
assignments
|
An optional list of attribute definitions for
the Capability definition.
|
Capability assignments have one of the
following grammars:
In the above grammars, the pseudo
values that appear in angle brackets have the following
meaning:
·
capability_definition_name: represents the symbolic name of
the capability as a string.
·
property_assignments:
represents the optional list of property assignments
for the capability definition.
·
attribute_assignments:
represents the optional list of attribute
assignments for the capability definition.
The following example shows a
capability assignment:
3.7.1.3.1 Notation example [comment?]
|
node_templates:
some_node_template:
capabilities:
some_capability:
properties:
limit: 100
|
3.7.2 Requirement assignment [comment?]
A Requirement assignment allows template
authors to provide either concrete names of TOSCA templates or
provide abstract selection criteria for providers to use to find
matching TOSCA templates that are used to fulfill a named
requirement’s declared TOSCA Node Type.
The following is the list of
recognized keynames for a TOSCA requirement assignment:
|
Keyname
|
Required
|
Type
|
Description
|
|
capability
|
no
|
string
|
The optional reserved keyname used to provide
the name of either a:
·
Capability definition within a target node template
that can fulfill the requirement.
·
Capability Type that the provider will use to select a
type-compatible target node template to fulfill the
requirement at runtime.
|
|
node
|
no
|
string
|
The optional reserved keyname used to identify
the target node of a relationship. specifically, it is used
to provide either a:
·
Node Template name that can fulfil the target node
requirement.
·
Node Type name that the provider will use to select a
type-compatible node template to fulfil the requirement at
runtime.
|
|
relationship
|
no
|
string
|
The optional reserved keyname used to provide
the name of either a:
·
Relationship Template to use to relate the source
node to the (capability in the) target node when fulfilling
the requirement.
·
Relationship Type that the provider will use to select a
type-compatible relationship template to relate the source
node to the target node at runtime.
|
|
node_filter
|
no
|
node
filter
|
The optional filter definition that TOSCA
orchestrators or providers would use to select a type-compatible
target node that can fulfill the associated abstract
requirement at runtime.
|
The following is the list of
recognized keynames for a TOSCA requirement assignment’s
relationship keyname
which is used when Property assignments need to be provided to
inputs of declared interfaces or their operations:
|
Keyname
|
Required
|
Type
|
Description
|
|
type
|
no
|
string
|
The optional reserved keyname used to provide
the name of the Relationship Type for the requirement
assignment’s relationship keyname.
|
|
properties
|
no
|
list of
interface definitions
|
The optional reserved keyname used to
reference declared (named) interface definitions of the
corresponding Relationship Type in order to provide Property
assignments for these interfaces or operations of these
interfaces.
|
Named requirement assignments have one
of the following grammars:
3.7.2.2.1 Short notation: [comment?]
The following single-line grammar may
be used if only a concrete Node Template for the target node needs
to be declared in the requirement:
This notation is only valid if the
corresponding Requirement definition in the Node Template’s
parent Node Type declares (at a minimum) a valid Capability Type
which can be found in the declared target Node Template. A valid
capability definition always needs to be provided in the
requirement declaration of the source node to identify a
specific capability definition in the target node the
requirement will form a TOSCA relationship with.
3.7.2.2.2 Extended notation: [comment?]
The following grammar would be used if
the requirement assignment needs to provide more information than
just the Node Template name:
3.7.2.2.3 Extended grammar with Property Assignments for the
relationship’s Interfaces [comment?]
The following additional multi-line
grammar is provided for the relationship keyname in order to
provide new Property assignments for inputs of known Interface
definitions of the declared Relationship Type.
Examples of uses for the extended
requirement assignment grammar include:
·
The need to allow runtime selection of the target node based upon
an abstract Node Type rather than a concrete Node Template.
This may include use of the node_filter keyname to provide node and
capability filtering information to find the “best
match” of a concrete Node Template at runtime.
·
The need to further clarify the concrete Relationship Template or
abstract Relationship Type to use when relating the source
node’s requirement to the target node’s capability.
·
The need to further clarify the concrete capability (symbolic) name
or abstract Capability Type in the target node to form a
relationship between.
·
The need to (further) constrain the occurrences of the requirement
in the instance model.
In the above grammars, the pseudo
values that appear in angle brackets have the following
meaning:
·
requirement_name:
represents the symbolic name of a requirement assignment as a
string.
·
node_template_name:
represents the optional name of a Node Template that contains the
capability this requirement will be fulfilled by.
·
relationship_template_name:
represents the optional name of a Relationship Type to be used
when relating the requirement appears to the capability in the
target node.
·
capability_symbolic_name:
represents the optional ordered list of specific, required
capability type or named capability definition within the target
Node Type or Template.
·
node_type_name:
represents the optional name of a TOSCA Node Type the associated
named requirement can be fulfilled by. This must be a type
that is compatible with the Node Type declared on the matching
requirement (same symbolic name) the requirement’s Node
Template is based upon.
·
relationship_type_name:
represents the optional name of a Relationship Type that is
compatible with the Capability Type in the target node.
·
property_assignments:
represents the optional list of property value assignments for the
declared relationship.
·
interface_assignments:
represents the optional list of interface definitions for the
declared relationship used to provide property assignments on
inputs of interfaces and operations.
·
capability_type_name:
represents the optional name of a Capability Type definition within
the target Node Type this requirement needs to form a relationship
with.
·
node_filter_definition:
represents the optional node filter TOSCA
orchestrators would use to fulfill the requirement for selecting a
target node. Note that this SHALL only be valid if the node keyname’s value is a Node
Type and is invalid if it is a Node Template.
3.7.2.3.1 Example 1 – Abstract hosting requirement on a
Node Type [comment?]
A web application node template named
‘my_application_node_template’
of type WebApplication
declares a requirement named ‘host’ that needs to be
fulfilled by any node that derives from the node type WebServer.
In this case, the node
template’s type is WebApplication which already declares
the Relationship Type HostedOn to use to relate to the
target node and the Capability Type of Container to be the specific target
of the requirement in the target node.
3.7.2.3.2 Example 2 - Requirement with Node Template and
a custom Relationship Type [comment?]
This example is similar to the
previous example; however, the requirement named
‘database’
describes a requirement for a connection to a database endpoint
(Endpoint.Database)
Capability Type in a named node template (my_database). However, the connection
requires a custom Relationship Type (my.types.CustomDbConnection’)
declared on the keyname ‘relationship’.
|
# Example of a
(database) requirement that is fulfilled by a node template
named
#
“my_database”, but also requires a custom database
connection relationship
my_application_node_template:
requirements:
-
database:
node:
my_database
capability: Endpoint.Database
relationship: my.types.CustomDbConnection
|
3.7.2.3.3 Example 3 - Requirement for a Compute node with
additional selection criteria (filter) [comment?]
This example
shows how to extend an abstract ‘host’
requirement for a Compute node with a filter definition that further constrains
TOSCA orchestrators to include additional properties and
capabilities on the target node when fulfilling the
requirement.
A Node Template specifies the occurrence of a
manageable software component as part of an application’s
topology model which is defined in a TOSCA Service Template.
A Node template is an instance of a specified Node Type and can
provide customized properties, constraints or operations which
override the defaults provided by its Node Type and its
implementations.
The following is the list of
recognized keynames for a TOSCA Node Template definition:
|
Keyname
|
Required
|
Type
|
Description
|
|
type
|
yes
|
string
|
The required name of the Node Type the Node
Template is based upon.
|
|
description
|
no
|
description
|
An optional description for the Node
Template.
|
|
directives
|
no
|
string[]
|
An optional list of directive values to
provide processing instructions to orchestrators and tooling.
|
|
properties
|
no
|
list of
property
assignments
|
An optional list of property value assignments
for the Node Template.
|
|
attributes
|
no
|
list of
attribute
assignments
|
An optional list of attribute value
assignments for the Node Template.
|
|
requirements
|
no
|
list of
requirement
assignments
|
An optional sequenced list
of requirement assignments for the Node Template.
|
|
capabilities
|
no
|
list of
capability
assignments
|
An optional list of capability assignments for
the Node Template.
|
|
interfaces
|
no
|
list of
interface definitions
|
An optional list of named interface
definitions for the Node Template.
|
|
artifacts
|
no
|
list of
artifact
definitions
|
An optional list of named artifact definitions
for the Node Template.
|
|
node_filter
|
no
|
node
filter
|
The optional filter definition that TOSCA
orchestrators would use to select the correct target node.
This keyname is only valid if the directive has the value of
“selectable” set.
|
|
copy
|
no
|
string
|
The optional (symbolic) name of another node
template to copy into (all keynames and values) and use as a basis
for this node template.
|
In the above grammar, the pseudo
values that appear in angle brackets have the following
meaning:
·
node_template_name:
represents the required symbolic name of the Node Template being
declared.
·
node_type_name:
represents the name of the Node Type the Node Template is based
upon.
·
node_template_description: represents
the optional description
string for Node Template.
·
directives: represents
the optional list of processing instruction keywords (as strings)
for use by tooling and orchestrators.
·
property_assignments:
represents the optional list of property assignments
for the Node Template that provide values for properties defined in
its declared Node Type.
·
attribute_assignments:
represents the optional list of attribute
assignments for the Node Template that provide values for
attributes defined in its declared Node Type.
·
requirement_assignments:
represents the optional sequenced list of
requirement
assignments for the Node Template that allow assignment of
type-compatible capabilities, target nodes, relationships and
target (node filters) for use when fulfilling the requirement at
runtime.
·
capability_assignments:
represents the optional list of capability assignments
for the Node Template that augment those provided by its declared
Node Type.
·
interface_definitions:
represents the optional list of interface definitions for the
Node Template that augment those provided
by its declared Node Type.
·
artifact_definitions:
represents the optional list of artifact definitions for the Node
Template that augment those provided by its declared Node Type.
·
node_filter_definition:
represents the optional node filter TOSCA
orchestrators would use for selecting a matching node template.
·
source_node_template_name: represents
the optional (symbolic) name of another node template to copy into
(all keynames and values) and use as a basis for this node
template.
3.7.3.3 Additional requirements [comment?]
·
The node_filter keyword
(and supporting grammar) SHALL only be valid if the Node
Template has a directive
keyname with the value of “selectable” set.
·
The source node template provided as a value on the copy keyname MUST NOT
itself use the copy
keyname (i.e., it must itself be a complete node template
description and not copied from another node template).
|
node_templates:
mysql:
type: tosca.nodes.DBMS.MySQL
properties:
root_password: { get_input: my_mysql_rootpw
}
port: { get_input: my_mysql_port }
requirements:
- host: db_server
interfaces:
Standard:
configure:
scripts/my_own_configure.sh
|
3.7.4 Relationship Template [comment?]
A Relationship Template specifies the
occurrence of a manageable relationship between node templates as
part of an application’s topology model that is defined in a
TOSCA Service Template. A Relationship template is an
instance of a specified Relationship Type and can provide
customized properties, constraints or operations which override the
defaults provided by its Relationship Type and its
implementations.
The following is the list of
recognized keynames for a TOSCA Relationship Template
definition:
|
Keyname
|
Required
|
Type
|
Description
|
|
type
|
yes
|
string
|
The required name of the Relationship Type the
Relationship Template is based upon.
|
|
description
|
no
|
description
|
An optional description for the Relationship
Template.
|
|
properties
|
no
|
list of
property
assignments
|
An optional list of property assignments for
the Relationship Template.
|
|
attributes
|
no
|
list of
attribute
assignments
|
An optional list of attribute assignments for
the Relationship Template.
|
|
interfaces
|
no
|
list of
interface definitions
|
An optional list of named interface
definitions for the Node Template.
|
|
copy
|
no
|
string
|
The optional (symbolic) name of another
relationship template to copy into (all keynames and values) and
use as a basis for this relationship template.
|
In the above grammar, the pseudo
values that appear in angle brackets have the following
meaning:
·
relationship_template_name:
represents the required symbolic name of the Relationship Template
being declared.
·
relationship_type_name:
represents the name of the Relationship Type the Relationship
Template is based upon.
·
relationship_template_description:
represents the optional description string for the
Relationship Template.
·
property_assignments:
represents the optional list of property assignments
for the Relationship Template that provide values for properties
defined in its declared Relationship Type.
·
attribute_assignments:
represents the optional list of attribute
assignments for the Relationship Template that provide
values for attributes defined in its declared Relationship
Type.
·
interface_definitions:
represents the optional list of interface definitions for the
Relationship Template that augment those provided by its declared
Relationship Type.
·
source_relationship_template_name:
represents the optional (symbolic) name of another relationship
template to copy into (all keynames and values) and use as a basis
for this relationship template.
3.7.4.2 Additional requirements [comment?]
·
The source relationship template provided as a value on the
copy keyname MUST NOT
itself use the copy
keyname (i.e., it must itself be a complete relationship template
description and not copied from another relationship template).
|
relationship_templates:
storage_attachment:
type: AttachesTo
properties:
location:
/my_mount_point
|
3.7.5 Group definition [comment?]
A group definition defines a logical grouping
of node templates, typically for management purposes, but is
separate from the application’s topology template.
The following is the list of
recognized keynames for a TOSCA group definition:
|
Keyname
|
Required
|
Type
|
Description
|
|
type
|
yes
|
string
|
The required name of the group type the group
definition is based upon.
|
|
description
|
no
|
description
|
The optional description for the group
definition.
|
|
properties
|
no
|
list of
property
assignments
|
An optional list of property value assignments
for the group definition.
|
|
targets
|
yes
|
list of string
|
The required list of one or more node template
names that are members of this group definition.
|
|
interfaces
|
no
|
list of
interface definitions
|
An optional list of named interface
definitions for the group definition.
|
Group definitions have one the
following grammars:
In the above grammar, the pseudo
values that appear in angle brackets have the following
meaning:
·
group_name: represents
the required symbolic name of the group as a string.
·
group_type_name:
represents the name of the Group Type the definition is based
upon.
·
group_description:
contains an optional description of the group.
·
property_assignments:
represents the optional list of property assignments
for the group definition that provide values for properties defined
in its declared Group Type.
·
list_of_node_templates:
contains the required list of one or more node template names
(within the same topology template) that are members of this
logical group.
·
interface_definitions:
represents the optional list of interface definitions for the
group definition that augment those provided by its declared Group
Type.
3.7.5.3 Additional Requirements [comment?]
·
Group definitions SHOULD NOT be used to define or
redefine relationships (dependencies) for an application that can
be expressed using normative TOSCA Relationships within a TOSCA
topology template.
The following represents a group
definition:
|
groups:
my_app_placement_group:
type: tosca.groups.Root
description: My application’s logical component grouping for
placement
targets: [ my_web_server, my_sql_database ]
|
3.7.6 Policy
definition [comment?]
A policy definition defines a policy that can
be associated with a TOSCA topology or top-level entity definition
(e.g., group definition, node template, etc.).
The following is the list of
recognized keynames for a TOSCA policy definition:
|
Keyname
|
Required
|
Type
|
Description
|
|
type
|
yes
|
string
|
The required name of the policy type the
policy definition is based upon.
|
|
description
|
no
|
description
|
The optional description for the policy
definition.
|
|
properties
|
no
|
list of
property
assignments
|
An optional list of property value assignments
for the policy definition.
|
|
targets
|
no
|
string[]
|
An optional list of valid Node Templates or
Groups the Policy can be applied to.
|
Policy definitions have one the
following grammars:
In the above grammar, the pseudo
values that appear in angle brackets have the following
meaning:
·
policy_name: represents
the required symbolic name of the policy as a string.
·
policy_type_name:
represents the name of the policy the definition is based upon.
·
policy_description:
contains an optional description of the policy.
·
property_assignments:
represents the optional list of property assignments
for the policy definition that provide values for properties
defined in its declared Policy Type.
·
list_of_policy_targets:
represents the optional list of names of node templates or groups
that the policy is to applied to.
3.7.6.3 Additional Requirements [comment?]
·
None
The following represents a policy
definition:
|
policies:
-
my_compute_placement_policy:
type:
tosca.policies.placement
description: Apply my
placement policy to my application’s servers
targets: [
my_server_1, my_server_2 ]
|
3.8 Topology Template
definition [comment?]
This section defines the topology template of
a cloud application. The main ingredients of the topology template
are node templates representing components of the application and
relationship templates representing links between the components.
These elements are defined in the nested node_templates section and the nested
relationship_templates
sections, respectively. Furthermore, a topology template
allows for defining input parameters, output parameters as well as
grouping of node templates.
The following is the list of
recognized keynames for a TOSCA Topology Template:
|
Keyname
|
Required
|
Type
|
Description
|
|
description
|
no
|
description
|
The optional description for the Topology
Template.
|
|
inputs
|
no
|
list of
parameter definitions
|
An optional list of input parameters (i.e., as
parameter definitions) for the Topology Template.
|
|
node_templates
|
no
|
list of
node
templates
|
An optional list of node template definitions
for the Topology Template.
|
|
relationship_templates
|
no
|
list of
relationship templates
|
An optional list of relationship templates for
the Topology Template.
|
|
groups
|
no
|
list of
group
definitions
|
An optional list of Group definitions whose
members are node templates defined within this same Topology
Template.
|
|
policies
|
no
|
list of
policy
definitions
|
An optional list of Policy definitions for the
Topology Template.
|
|
outputs
|
no
|
list of
parameter definitions
|
An optional list of output parameters (i.e.,
as parameter definitions) for the Topology Template.
|
|
substitution_mappings
|
no
|
N/A
|
An optional declaration that exports the
topology template as an implementation of a Node type.
This also includes the mappings between the
external Node Types named capabilities and requirements to existing
implementations of those capabilities and requirements on Node
templates declared within the topology template.
|
The overall grammar of the
topology_template section
is shown below.–Detailed grammar definitions of the each
sub-sections are provided in subsequent subsections.
|
topology_template:
description:
<template_description>
inputs:
<input_parameter_list>
outputs:
<output_parameter_list>
node_templates: <node_template_list>
relationship_templates:
<relationship_template_list>
groups:
<group_definition_list>
policies:
-
<policy_definition_list>
# Optional
declaration that exports the Topology Template
# as an
implementation of a Node Type.
substitution_mappings:
node_type: <node_type_name>
capabilities:
<map_of_capability_mappings_to_expose>
requirements:
<map_of_requirement_mapping_to_expose>
|
In the above grammar, the pseudo
values that appear in angle brackets have the following
meaning:
·
template_description:
represents the optional description string for Topology
Template.
·
input_parameter_list:
represents the optional list of input parameters (i.e., as property
definitions) for the Topology Template.
·
output_parameter_list:
represents the optional list of output parameters (i.e., as
property definitions) for the Topology Template.
·
group_definition_list:
represents the optional list of group definitions whose members are
node templates that also are defined within this Topology
Template.
·
policy_definition_list:
represents the optional sequenced list of policy definitions for
the Topology Template.
·
node_template_list:
represents the optional list of node template definitions for the
Topology Template.
·
relationship_template_list:
represents the optional list of relationship templates for
the Topology Template.
·
node_type_name:
represents the optional name of a Node Type that the Topology Template
implements as part of the substitution_mappings.
·
map_of_capability_mappings_to_expose:
represents the mappings that expose internal capabilities from node
templates (within the topology template) as capabilities of the
Node Type definition that is declared as part of the substitution_mappings.
·
map_of_requirement_mappings_to_expose:
represents the mappings of link requirements of the Node Type
definition that is declared as part of the substitution_mappings to internal
requirements implementations within node templates (declared within
the topology template).
More detailed explanations for each of the
Topology Template grammar’s keynames appears in the sections
below.
The inputs section provides a means to
define parameters using TOSCA parameter definitions, their allowed
values via constraints and default values within a TOSCA Simple
Profile template. Input parameters defined in the inputs section of a topology template
can be mapped to properties of node templates or relationship
templates within the same topology template and can thus be used
for parameterizing the instantiation of the topology template.
This section defines topology template-level
input parameter section.
·
Inputs here would ideally be mapped to BoundaryDefinitions in TOSCA
v1.0.
·
Treat input parameters as fixed global variables (not settable
within template)
·
If not in input take default (nodes use default)
The grammar of the inputs section is as follows:
This section provides a set of
examples for the single elements of a topology template.
Simple inputs example without any
constraints:
|
inputs:
fooName:
type: string
description: Simple string typed property definition with no
constraints.
default: bar
|
Example of inputs with constraints:
|
inputs:
SiteName:
type: string
description: string typed property definition with
constraints
default: My Site
constraints:
- min_length:
9
|
3.8.2.2 node_templates [comment?]
The node_templates section lists the Node
Templates that describe the (software) components that are used to
compose cloud applications.
The grammar of the node_templates section is a
follows:
Example of node_templates section:
|
node_templates:
my_webapp_node_template:
type: WebApplication
my_database_node_template:
type: Database
|
3.8.2.3 relationship_templates [comment?]
The relationship_templates section lists
the Relationship Templates that describe the relations between
components that are used to compose cloud applications.
Note that in the TOSCA Simple Profile, the
explicit definition of relationship templates as it was required in
TOSCA v1.0 is optional, since relationships between nodes get
implicitly defined by referencing other node templates in the
requirements sections of node templates.
The grammar of the relationship_templates section is as
follows:
Example of relationship_templates section:
|
relationship_templates:
my_connectsto_relationship:
type: tosca.relationships.ConnectsTo
interfaces:
Configure:
inputs:
speed: { get_attribute: [ SOURCE,
connect_speed ] }
|
The outputs section provides a means to
define the output parameters that are available from a TOSCA Simple
Profile service template. It allows for exposing attributes of node
templates or relationship templates within the containing
topology_template to
users of a service.
The grammar of the outputs section is as follows:
Example of the outputs section:
|
outputs:
server_address:
description: The first private IP address for the provisioned
server.
value: { get_attribute: [ HOST, networks, private, addresses, 0 ]
}
|
The groups section allows for grouping
one or more node templates within a TOSCA Service Template and for
assigning special attributes like policies to the group.
The grammar of the groups section is as follows:
The following example shows the
definition of three Compute nodes in the node_templates section of a
topology_template as well
as the grouping of two of the Compute nodes in a group server_group_1.
|
node_templates:
server1:
type: tosca.nodes.Compute
#
more details ...
server2:
type: tosca.nodes.Compute
#
more details ...
server3:
type: tosca.nodes.Compute
#
more details ...
groups:
# server2 and
server3 are part of the same group
-
server_group_1:
type:
tosca.groups.Root
targets: [ server2, server3 ]
|
The policies section allows for declaring
policies that can be applied to entities in the topology
template.
The grammar of the policies section is as follows:
The following example shows the
definition of a placement policy.
|
policies:
-
my_placement_policy:
type: mycompany.mytypes.policy.placement
|
·
The parameters (properties) that are listed as part of the
inputs block can be
mapped to PropertyMappings provided as part of
BoundaryDefinitions as
described by the TOSCA v1.0 specification.
·
The node templates listed as part of the node_templates block can be mapped to
the list of NodeTemplate
definitions provided as part of TopologyTemplate of a ServiceTemplate as described by the
TOSCA v1.0 specification.
·
The relationship templates listed as part of the relationship_templates block can be
mapped to the list of RelationshipTemplate definitions
provided as part of TopologyTemplate of a ServiceTemplate as described by the
TOSCA v1.0 specification.
·
The output parameters that are listed as part of the outputs section of a topology
template can be mapped to PropertyMappings provided as part of
BoundaryDefinitions as
described by the TOSCA v1.0 specification.
o Note,
however, that TOSCA v1.0 does not define a direction (input vs.
output) for those mappings, i.e. TOSCA v1.0 PropertyMappings are underspecified
in that respect and TOSCA Simple Profile’s inputs and outputs provide a more concrete
definition of input and output parameters.
3.9 Service
Template definition [comment?]
A TOSCA Service Template (YAML) document
contains element definitions of building blocks for cloud
application, or complete models of cloud applications. This section
describes the top-level structural elements (TOSCA keynames) along
with their grammars, which are allowed to appear in a TOSCA Service
Template document.
The following is the list of
recognized keynames for a TOSCA Service Template definition:
|
Keyname
|
Required
|
Type
|
Description
|
|
tosca_definitions_version
|
yes
|
string
|
Defines the version of the TOSCA Simple
Profile specification the template (grammar) complies with.
|
|
metadata
|
no
|
map of string
|
Defines a section used to declare additional
metadata information. Domain-specific TOSCA profile
specifications may define keynames that are required for their
implementations.
|
|
description
|
no
|
description
|
Declares a description for this Service
Template and its contents.
|
|
dsl_defintions
|
no
|
N/A
|
Declares optional DSL-specific definitions and
conventions. For example, in YAML, this allows defining
reusable YAML macros (i.e., YAML alias anchors) for use throughout
the TOSCA Service Template.
|
|
repositories
|
no
|
list of
Repository definitions
|
Declares the list of external repositories
which contain artifacts that are referenced in the service template
along with their addresses and necessary credential information
used to connect to them in order to retrieve the artifacts.
|
|
imports
|
no
|
list of
Import
Definitions
|
Declares import statements external TOSCA
Definitions documents. For example, these may be file location or
URIs relative to the service template file within the same TOSCA
CSAR file.
|
|
artifact_types
|
no
|
list of
Artifact
Types
|
This section contains an optional list of
artifact type definitions for use in the service template
|
|
data_types
|
no
|
list of
Data
Types
|
Declares a list of optional TOSCA Data Type
definitions.
|
|
capability_types
|
no
|
list of
Capability Types
|
This section contains an optional list of
capability type definitions for use in the service template.
|
|
interface_types
|
no
|
list of
Interface Types
|
This section contains an optional list of
interface type definitions for use in the service template.
|
|
relationship_types
|
no
|
list of
Relationship Types
|
This section contains a set of relationship
type definitions for use in the service template.
|
|
node_types
|
no
|
list of
Node
Types
|
This section contains a set of node type
definitions for use in the service template.
|
|
group_types
|
no
|
list of
Group
Types
|
This section contains a list of group type
definitions for use in the service template.
|
|
policy_types
|
no
|
list of
Policy
Types
|
This section contains a list of policy type
definitions for use in the service template.
|
|
topology_template
|
no
|
Topology Template definition
|
Defines the topology template of an
application or service, consisting of node templates that represent
the application’s or service’s components, as well as
relationship templates representing relations between the
components.
|
3.9.1.1 Metadata keynames [comment?]
The following is the list of
recognized metadata keynames for a TOSCA Service Template
definition:
|
Keyname
|
Required
|
Type
|
Description
|
|
template_name
|
no
|
string
|
Declares a descriptive name for the
template.
|
|
template_author
|
no
|
string
|
Declares the author(s) or owner of the
template.
|
|
template_version
|
no
|
string
|
Declares the version string for the
template.
|
The overall structure of a TOSCA Service
Template and its top-level key collations using the TOSCA Simple
Profile is shown below:
|
tosca_definitions_version: # Required TOSCA
Definitions version string
# Optional metadata
keyname: value pairs
metadata:
template_name:
# Optional name of this service template
template_author:
# Optional author of this service template
template_version:
# Optional version of this service template
#
Optional list of domain or profile specific metadata
keynames
# Optional
description of the definitions inside the file.
description:
<template_type_description>
dsl_definitions:
# list of
YAML alias anchors (or macros)
repositories:
# list of
external repository definitions which host TOSCA
artifacts
imports:
# ordered
list of import definitions
artifact_types:
# list
of artifact type definitions
data_types:
# list
of datatype definitions
capability_types:
# list
of capability type definitions
# list
of interface type definitions
relationship_types:
# list
of relationship type definitions
node_types:
# list
of node
type definitions
group_types:
# list
of group
type definitions
policy_types:
# list
of policy type definitions
topology_template:
# topology
template definition of the cloud application or service
|
·
TOSCA Service Templates do not have to contain a topology_template
and MAY contain simply type definitions (e.g., Artifact, Interface,
Capability, Node, Relationship Types, etc.) and be imported for use
as type definitions in other TOSCA Service Templates.
3.9.3 Top-level keyname
definitions [comment?]
3.9.3.1
tosca_definitions_version [comment?]
This required element provides a means to
include a reference to the TOSCA Simple Profile specification
within the TOSCA Definitions YAML file. It is an indicator
for the version of the TOSCA grammar that should be used to parse
the remainder of the document.
|
tosca_definitions_version
|
Single-line form:
|
tosca_definitions_version:
<tosca_simple_profile_version>
|
TOSCA Simple Profile version 1.0
specification using the defined namespace alias (see Section
3.1):
|
tosca_definitions_version:
tosca_simple_yaml_1_0
|
TOSCA Simple Profile version 1.0
specification using the fully defined (target) namespace (see
Section 3.1):
This keyname is used to associate
domain-specific metadata with the Service Template. The
metadata keyname allows a declaration of a map of keynames with
string values.
|
metadata:
<map_of_string_values>
|
|
metadata:
creation_date: 2015-04-14
date_updated:
2015-05-01
status:
developmental
|
3.9.3.3 template_name [comment?]
This optional metadata keyname can be used to
declare the name of service template as a single-line string
value.
|
template_name:
<name string>
|
|
template_name: My
service template
|
·
Some service templates are designed to be referenced and reused by
other service templates. Therefore, in these cases, the
template_name value
SHOULD be designed to be used as a unique identifier through the
use of namespacing techniques.
3.9.3.4 template_author [comment?]
This optional metadata keyname can be used to
declare the author(s) of the service template as a single-line
string value.
|
template_author:
<author string>
|
|
template_author: My
service template
|
3.9.3.5 template_version [comment?]
This optional metadata keyname can be used to
declare a domain specific version of the service template as a
single-line string value.
·
Some service templates are designed to be referenced and reused by
other service templates and have a lifecycle of their own.
Therefore, in these cases, a template_version value SHOULD be
included and used in conjunction with a unique template_name value to enable
lifecycle management of the service template and its
contents.
This optional keyname provides a means to
include single or multiline descriptions within a TOSCA Simple
Profile template as a scalar string value.
3.9.3.7 dsl_definitions [comment?]
This optional keyname provides a section to
define macros (e.g., YAML-style macros when using the TOSCA Simple
Profile in YAML specification).
|
dsl_definitions:
ubuntu_image_props: &ubuntu_image_props
architecture:
x86_64
type: linux
distribution:
ubuntu
os_version:
14.04
redhat_image_props: &redhat_image_props
architecture:
x86_64
type: linux
distribution:
rhel
os_version:
6.6
|
3.9.3.8 repositories [comment?]
This optional keyname provides a section to
define external repositories which may contain artifacts or other
TOSCA Service Templates which might be referenced or imported by
the TOSCA Service Template definition.
This optional keyname provides a way to import
a block sequence of one or more TOSCA
Definitions documents. TOSCA Definitions documents can
contain reusable TOSCA type definitions (e.g., Node Types,
Relationship Types, Artifact Types, etc.) defined by other
authors. This mechanism provides an effective way for
companies and organizations to define normative types and/or
describe their software applications for reuse in other TOSCA
Service Templates.
|
# An example import
of definitions files from a location relative to the
# file location of
the service template declaring the import.
imports:
-
some_definitions:
relative_path/my_defns/my_typesdefs_1.yaml
-
more_definitions:
file:
my_defns/my_typesdefs_n.yaml
repository:
my_company_repo
namespace_uri:
http://mycompany.com/ns/tosca/2.0
namespace_prefix:
mycompany
|
3.9.3.10 artifact_types [comment?]
This optional keyname lists the Artifact Types
that are defined by this Service Template.
|
artifact_types:
mycompany.artifacttypes.myFileType:
derived_from: tosca.artifacts.File
|
This optional keyname provides a section to
define new data types in TOSCA.
|
data_types:
# A complex
datatype definition
simple_contactinfo_type:
properties:
name:
type:
string
email:
type:
string
phone:
type:
string
# datatype
definition derived from an existing type
full_contact_info:
derived_from: simple_contact_info
properties:
street_address:
type:
string
city:
type:
string
state:
type:
string
postalcode:
type:
string
|
3.9.3.12
capability_types [comment?]
This optional keyname lists the Capability
Types that provide the reusable type definitions that can be used
to describe features Node Templates or Node Types can declare they
support.
|
capability_types:
mycompany.mytypes.myCustomEndpoint:
derived_from: tosca.capabilities.Endpoint
properties:
# more details
...
mycompany.mytypes.myCustomFeature:
derived_from: tosca.capabilities.Feature
properties:
# more details
...
|
3.9.3.13 interface_types [comment?]
This optional keyname lists the Interface
Types that provide the reusable type definitions that can be used
to describe operations for on TOSCA entieis such as Relationship
Types and Node Types.
|
interface_types:
mycompany.interfaces.service.Signal:
signal_begin_receive:
description: Operation to signal start of some message
processing.
signal_end_receive:
description: Operation to signal end of some message
processed.
|
3.9.3.14 relationship_types [comment?]
This optional keyname lists the Relationship
Types that provide the reusable type definitions that can be used
to describe dependent relationships between Node Templates or Node
Types.
|
relationship_types:
mycompany.mytypes.myCustomClientServerType:
derived_from: tosca.relationships.HostedOn
properties:
# more details ...
mycompany.mytypes.myCustomConnectionType:
derived_from: tosca.relationships.ConnectsTo
properties:
# more details
...
|
This optional keyname lists the Node Types
that provide the reusable type definitions for software components
that Node Templates can be based upon.
|
node_types:
my_webapp_node_type:
derived_from: WebApplication
properties:
my_port:
type:
integer
my_database_node_type:
derived_from: Database
capabilities:
mytypes.myfeatures.transactSQL
|
·
The node types listed as part of the node_types block can be mapped to the
list of NodeType
definitions as described by the TOSCA v1.0 specification.
3.9.3.16
group_types [comment?]
This optional keyname lists the Group Types
that are defined by this Service Template.
|
group_types:
mycompany.mytypes.myScalingGroup:
derived_from: tosca.groups.Root
|
3.9.3.17 policy_types [comment?]
This optional keyname lists the Policy Types
that are defined by this Service Template.
|
policy_types:
mycompany.mytypes.myScalingPolicy:
derived_from: tosca.policies.Scaling
|
This section is normative and includes
functions that are supported for use within a TOSCA Service
Template.
4.1 Reserved Function
Keywords [comment?]
The following keywords MAY be used in some
TOSCA function in place of a TOSCA Node or Relationship Template
name. A TOSCA orchestrator will interpret them at the time
the function would be evaluated at runtime as described in the
table below. Note that some keywords are only valid in the
context of a certain TOSCA entity as also denoted in the table.
|
Keyword
|
Valid Contexts
|
Description
|
|
SELF
|
Node Template or Relationship Template
|
A TOSCA orchestrator will interpret this
keyword as the Node or Relationship Template instance that contains
the function at the time the function is evaluated.
|
|
SOURCE
|
Relationship Template only.
|
A TOSCA orchestrator will interpret this
keyword as the Node Template instance that is at the source end of
the relationship that contains the referencing function.
|
|
TARGET
|
Relationship Template only.
|
A TOSCA orchestrator will interpret this
keyword as the Node Template instance that is at the target end of
the relationship that contains the referencing function.
|
|
HOST
|
Node Template only
|
A TOSCA orchestrator will interpret this
keyword to refer to the all nodes that “host” the node
using this reference (i.e., as identified by its HostedOn
relationship).
Specifically, TOSCA orchestrators that
encounter this keyword when evaluating the get_attribute or get_property functions SHALL
search each node along the “HostedOn” relationship
chain starting at the immediate node that hosts the node where the
function was evaluated (and then that node’s host node, and
so forth) until a match is found or the “HostedOn”
relationship chain ends.
|
4.2 Environment
Variable Conventions [comment?]
4.2.1 Reserved Environment Variable
Names and Usage [comment?]
TOSCA orchestrators utilize certain reserved
keywords in the execution environments that implementation
artifacts for Node or Relationship Templates operations are
executed in. They are used to provide information to these
implementation artifacts such as the results of TOSCA function
evaluation or information about the instance model of the TOSCA
application
The following keywords are reserved
environment variable names in any TOSCA supported execution
environment:
|
Keyword
|
Valid
Contexts
|
Description
|
|
TARGETS
|
Relationship Template
only.
|
· For an
implementation artifact that is executed in the context of a
relationship, this keyword, if present, is used to supply a list of
Node Template instances in a TOSCA application’s instance
model that are currently target of the context
relationship.
· The value of
this environment variable will be a comma-separated list of
identifiers of the single target node instances (i.e., the
tosca_id
attribute of the node).
|
|
TARGET
|
Relationship Template
only.
|
· For an
implementation artifact that is executed in the context of a
relationship, this keyword, if present, identifies a Node Template
instance in a TOSCA application’s instance model that is a
target of the context relationship, and which is being acted upon
in the current operation.
· The value of
this environment variable will be the identifier of the single
target node instance (i.e., the tosca_id attribute of the node).
|
|
SOURCES
|
Relationship Template
only.
|
· For an
implementation artifact that is executed in the context of a
relationship, this keyword, if present, is used to supply a list of
Node Template instances in a TOSCA application’s instance
model that are currently source of the context
relationship.
· The value of
this environment variable will be a comma-separated list of
identifiers of the single source node instances (i.e., the
tosca_id
attribute of the node).
|
|
SOURCE
|
Relationship Template
only.
|
· For an
implementation artifact that is executed in the context of a
relationship, this keyword, if present, identifies a Node Template
instance in a TOSCA application’s instance model that is a
source of the context relationship, and which is being acted upon
in the current operation.
· The value of
this environment variable will be the identifier of the single
source node instance (i.e., the tosca_id attribute of the node).
|
For scripts (or implementation artifacts in
general) that run in the context of relationship operations, select
properties and attributes of both the relationship itself as well
as select properties and attributes of the source and target
node(s) of the relationship can be provided to the environment by
declaring respective operation inputs.
Declared inputs from mapped properties or
attributes of the source or target node (selected via the
SOURCE or TARGET keyword) will be provided to
the environment as variables having the exact same name as the
inputs. In addition, the same values will be provided for the
complete set of source or target nodes, however prefixed with the
ID if the respective nodes. By means of the SOURCES or TARGETS variables holding the
complete set of source or target node IDs, scripts will be able to
iterate over corresponding inputs for each provided ID prefix.
The following example snippet shows an
imaginary relationship definition from a load-balancer node to
worker nodes. A script is defined for the add_target operation of the Configure
interface of the relationship, and the ip_address attribute of the target is
specified as input to the script:
|
node_templates:
load_balancer:
type: some.vendor.LoadBalancer
requirements:
- member:
relationship:
some.vendor.LoadBalancerToMember
interfaces:
Configure:
add_target:
inputs:
member_ip: {
get_attribute: [ TARGET, ip_address ] }
implementation:
scripts/configure_members.py
|
The add_target operation will be invoked,
whenever a new target member is being added to the load-balancer.
With the above inputs declaration, a member_ip environment variable that
will hold the IP address of the target being added will be provided
to the configure_members.py script. In
addition, the IP addresses of all current load-balancer members
will be provided as environment variables with a naming scheme of
<target node
ID>_member_ip. This will allow, for example, scripts that
always just write the complete list of load-balancer members into a
configuration file to do so instead of updating existing list,
which might be more complicated.
Assuming that the TOSCA application
instance includes five load-balancer members, node1 through node5, where node5 is the current target being
added, the following environment variables (plus potentially more
variables) would be provided to the script:
|
# the ID of the
current target and the IDs of all
targets
TARGET=node5
TARGETS=node1,node2,node3,node4,node5
# the input for the
current target and the inputs of all targets
member_ip=10.0.0.5
node1_member_ip=10.0.0.1
node2_member_ip=10.0.0.2
node3_member_ip=10.0.0.3
node4_member_ip=10.0.0.4
node5_member_ip=10.0.0.5
|
With code like shown in the snippet
below, scripts could then iterate of all provided member_ip inputs:
|
#!/usr/bin/python
import os
targets =
os.environ['TARGETS'].split(',')
for t in
targets:
target_ip =
os.environ.get('%s_member_ip' % t)
# do
something with target_ip ...
|
4.2.2 Prefixed vs. Unprefixed TARGET
names [comment?]
The list target node types assigned to the
TARGETS key in an execution environment would have names prefixed
by unique IDs that distinguish different instances of a node in a
running model Future drafts of this specification will show
examples of how these names/IDs will be expressed.
·
Target of interest is always un-prefixed. Prefix is the target
opaque ID. The IDs can be used to find the environment var.
for the corresponding target. Need an example here.
·
If you have one node that contains multiple targets this would also
be used (add or remove target operations would also use this you
would get set of all current targets).
4.3 Intrinsic
functions [comment?]
These functions are supported within the TOSCA
template for manipulation of template data.
The concat function is used to
concatenate two or more string values within a TOSCA service
template.
|
concat:
[<string_value_expressions_*> ]
|
|
Parameter
|
Required
|
Type
|
Description
|
|
<string_value_expressions_*>
|
yes
|
list of
string or
string value
expressions
|
A list of one or more strings (or expressions
that result in a string value) which can be concatenated together
into a single string.
|
|
outputs:
description:
Concatenate the URL for a server from other template
values
server_url:
value:
{ concat: [
'http://',
get_attribute: [ server, public_address ],
':' ,
get_attribute: [ server, port ] ] }
|
The token function is used within a TOSCA
service template on a string to parse out (tokenize) substrings
separated by one or more token characters within a larger
string.
|
token: [
<string_with_tokens>, <string_of_token_chars>,
<substring_index> ]
|
|
Parameter
|
Required
|
Type
|
Description
|
|
string_with_tokens
|
yes
|
string
|
The composite string that contains one or more
substrings separated by token characters.
|
|
string_of_token_chars
|
yes
|
string
|
The string that contains one or more token
characters that separate substrings within the composite
string.
|
|
substring_index
|
yes
|
integer
|
The integer indicates the index of the
substring to return from the composite string. Note that the
first substring is denoted by using the ‘0’ (zero)
integer value.
|
|
outputs:
webserver_port:
description: the port
provided at the end of my server’s endpoint’s IP
address
value: { token: [
get_attribute: [ my_server, data_endpoint, ip_address ],
‘:’,
1 ] }
|
4.4
Property functions [comment?]
These functions are used within a service
template to obtain property values from property definitions
declared elsewhere in the same service template. These
property definitions can appear either directly in the service
template itself (e.g., in the inputs section) or on entities (e.g.,
node or relationship templates) that have been modeled within the
template.
Note that the get_input and get_property functions may only
retrieve the static values of property definitions of a TOSCA
application as defined in the TOSCA Service Template. The
get_attribute function
should be used to retrieve values for attribute definitions (or
property definitions reflected as attribute definitions) from the
runtime instance model of the TOSCA application (as realized by the
TOSCA orchestrator).
The get_input function is used to
retrieve the values of properties declared within the inputs section of a TOSCA Service
Template.
|
get_input:
<input_property_name>
|
|
Parameter
|
Required
|
Type
|
Description
|
|
<input_property_name>
|
yes
|
string
|
The name of the property as defined in the
inputs section of the
service template.
|
|
inputs:
cpus:
type: integer
node_templates:
my_server:
type: tosca.nodes.Compute
capabilities:
host:
properties:
num_cpus: { get_input:
cpus }
|
The get_property function is used to
retrieve property values between modelable entities defined in the
same service template.
|
get_property: [
<modelable_entity_name>, <optional_req_or_cap_name>,
<property_name>, <nested_property_name_or_index_1>,
..., <nested_property_name_or_index_n> ]
|
|
Parameter
|
Required
|
Type
|
Description
|
|
<modelable
entity name> | SELF | SOURCE | TARGET | HOST
|
yes
|
string
|
The required name of a modelable entity (e.g.,
Node Template or Relationship Template name) as declared in the
service template that contains the named property definition the
function will return the value from. See section B.1 for valid
keywords.
|
|
<optional_req_or_cap_name>
|
no
|
string
|
The optional name of the requirement or
capability name within the modelable entity (i.e., the
<modelable_entity_name> which
contains the named property definition the function will return the
value from.
Note: If the property definition
is located in the modelable entity directly, then this parameter
MAY be omitted.
|
|
<property_name>
|
yes
|
string
|
The name of the property definition the
function will return the value from.
|
|
<nested_property_name_or_index_*>
|
no
|
string|
integer
|
Some TOSCA properties are complex (i.e.,
composed as nested structures). These parameters are used to
dereference into the names of these nested structures when
needed.
Some properties represent list types. In these cases, an
index may be provided to reference a specific entry in the list (as
named in the previous parameter) to return.
|
The following example shows how to use
the get_property function with an actual Node Template name:
|
node_templates:
mysql_database:
type: tosca.nodes.Database
properties:
name:
sql_database1
wordpress:
type: tosca.nodes.WebApplication.WordPress
...
interfaces:
Standard:
configure:
inputs:
wp_db_name: { get_property: [ mysql_database, name ] }
|
The following
example shows how to use the get_property function using the SELF
keyword:
|
node_templates:
mysql_database:
type: tosca.nodes.Database
...
capabilities:
database_endpoint:
properties:
port: 3306
wordpress:
type: tosca.nodes.WebApplication.WordPress
requirements:
...
- database_endpoint:
mysql_database
interfaces:
Standard:
create:
wordpress_install.sh
configure:
implementation:
wordpress_configure.sh
inputs:
...
wp_db_port: { get_property: [ SELF, database_endpoint, port ] }
|
The following example shows how to use
the get_property function using the TARGET keyword:
|
relationship_templates:
my_connection:
type:
ConnectsTo
interfaces:
Configure:
inputs:
targets_value: {
get_property: [ TARGET, value ] }
|
4.5 Attribute
functions [comment?]
These functions (attribute functions) are used
within an instance model to obtain attribute values from instances
of nodes and relationships that have been created from an
application model described in a service template. The
instances of nodes or relationships can be referenced by their name
as assigned in the service template or relative to the context
where they are being invoked.
The get_attribute function is used to retrieve the
values of named attributes declared by the referenced node or
relationship template name.
|
get_attribute: [
<modelable_entity_name>, <optional_req_or_cap_name>,
<attribute_name>, <nested_attribute_name_or_index_1>,
..., <nested_attribute_name_or_index_n>,
]
|
|
Parameter
|
Required
|
Type
|
Description
|
|
<modelable
entity name> | SELF | SOURCE | TARGET | HOST
|
yes
|
string
|
The required name of a modelable entity (e.g.,
Node Template or Relationship Template name) as declared in the
service template that contains the named attribute definition the
function will return the value from. See section B.1 for
valid keywords.
|
|
<optional_req_or_cap_name>
|
no
|
string
|
The optional name of the requirement or
capability name within the modelable entity (i.e., the
<modelable_entity_name> which
contains the named attribute definition the function will return
the value from.
Note: If the attribute definition
is located in the modelable entity directly, then this parameter
MAY be omitted.
|
|
<attribute_name>
|
yes
|
string
|
The name of the attribute definition the
function will return the value from.
|
|
<nested_attribute_name_or_index_*>
|
no
|
string|
integer
|
Some TOSCA attributes are complex (i.e.,
composed as nested structures). These parameters are used to
dereference into the names of these nested structures when
needed.
Some attributes represent list types. In these cases, an
index may be provided to reference a specific entry in the list (as
named in the previous parameter) to return.
|
The attribute functions are used in the same
way as the equivalent Property functions described above.
Please see their examples and replace “get_property”
with “get_attribute” function name.
These functions are used to obtain attributes
from instances of node or relationship templates by the names they
were given within the service template that described the
application model (pattern).
- These functions only work when
the orchestrator can resolve to a single node or relationship
instance for the named node or relationship. This essentially
means this is acknowledged to work only when the node or
relationship template being referenced from the service template
has a cardinality of 1 (i.e., there can only be one instance of it
running).
4.6
Operation functions [comment?]
These functions are used within an instance
model to obtain values from interface operations. These can be used
in order to set an attribute of a node instance at runtime or to
pass values from one operation to another.
4.6.1 get_operation_output [comment?]
The get_operation_output function is used to retrieve
the values of variables exposed / exported from an interface
operation.
|
get_operation_output: <modelable_entity_name>,
<interface_name>, <operation_name>,
<output_variable_name>
|
|
Parameter
|
Required
|
Type
|
Description
|
|
<modelable
entity name> | SELF | SOURCE | TARGET
|
yes
|
string
|
The required name of a modelable entity (e.g.,
Node Template or Relationship Template name) as declared in the
service template that implements the named interface and
operation.
|
|
<interface_name>
|
Yes
|
string
|
The required name of the interface which
defines the operation.
|
|
<operation_name>
|
yes
|
string
|
The required name of the operation whose value
we would like to retrieve.
|
|
<output_variable_name>
|
Yes
|
string
|
The required name of the variable that is
exposed / exported by the operation.
|
·
If operation failed, then ignore its outputs. Orchestrators
should allow orchestrators to continue running when possible past
deployment in the lifecycle. For example, if an update fails,
the application should be allowed to continue running and some
other method would be used to alert administrators of the
failure.
4.7 Navigation
functions [comment?]
·
This version of the TOSCA Simple Profile does not define any model
navigation functions.
4.7.1 get_nodes_of_type [comment?]
The get_nodes_of_type function can be used to retrieve
a list of all known instances of nodes of the declared Node
Type.
|
get_nodes_of_type:
<node_type_name>
|
|
Parameter
|
Required
|
Type
|
Description
|
|
<node_type_name>
|
|
