Skip to content

Deployment Quality Specification 1.0 Release Candidate

Quick Tip #1

Elements in graphs can be clicked to open their type definition!

Quick Tip #2

You can query deployment qualities for your deployment scenario using vintner utils scenarios!

This document specifies the deployment qualities. The specification is under active development and is not backwards compatible with any previous versions.

Deployment Technologies

Deployment qualities are defined in the context of the following deployment technologies.

Ansible

Ansible is an automation tool that can be used for configuration management, application deployment, and task automation. It allows system administrators and DevOps teams to manage software on servers using SSH, without the need for agents on target nodes. Further, Ansible is capable of managing infrastructure components, such as virtual machines, networks, and storage, and supports a wide range of cloud providers, such as AWS, Azure, Google Cloud and many others. Find out more.

Terraform

Terraform is an infrastructure as code (IaC) tool that allows users to define, provision, and manage cloud infrastructure. Using a declarative configuration language called HashiCorp Configuration Language (HCL), Terraform enables users to define infrastructure components such as virtual machines, networks, and storage in human-readable configuration files. It supports a wide range of cloud providers, including AWS, Azure, Google Cloud, and many others. Find out more.

Kubernetes

Kubernetes is a platform for automating the deployment, scaling, and management of containerized applications, such as Docker Containers. It provides capabilities for running and managing applications in clusters of servers, ensuring high availability, scalability, and efficient resource utilization. Kubernetes allows to define the desired state of their applications using declarative manifests, which specify the configuration, deployment, and management of containerized workloads. Find out more.

Docker Compose

Docker Compose is a tool that enables the definition and running of multi-container applications on a Docker Engine, using a single YAML configuration file. It allows the management of services, networks, and volumes, in a declarative manner. Find out more.

Component "docker.engine"

The following scenarios deploy a node template of node type docker.engine with various hosting stacks, artifacts, deployment technologies, and qualities.

Scenario #1

In this scenario, the node template "component" of node type docker.engine is deployed. The node template is hosted on the node template "host 1" of node type local.machine.

component(docker.engine)host 1(local.machine)host

Ansible supports deploying this scenario under a very high quality.

The Docker engine is hosted on a local machine. Ansible is specialized for installing software components on local targets, while Terraform discourages from being used to manage such scenarios.

Terraform supports deploying this scenario under a very low quality.

Scenario #2

In this scenario, the node template "component" of node type docker.engine is deployed. The node template is hosted on the node template "host 1" of node type remote.machine.

component(docker.engine)host 1(remote.machine)host

Ansible supports deploying this scenario under a very high quality.

The Docker engine is hosted on a remote machine. Ansible is specialized for installing software components on remote targets, while Terraform discourages from being used to manage such scenarios.

Terraform supports deploying this scenario under a very low quality.

Component "gcp.service"

The following scenarios deploy a node template of node type gcp.service with various hosting stacks, artifacts, deployment technologies, and qualities.

Scenario #1

In this scenario, the node template "component" of node type gcp.service is deployed. The scenario does not require a specific hosting.

component(gcp.service)

Ansible supports deploying this scenario under a very low quality.

Terraform supports deploying this scenario under a very high quality.

The GCP service is hosted on GCP. Terraform provides an official provider for GCP. In contrast, the corresponding Ansible module is not maintained and violates community standards.

Component "ingress"

The following scenarios deploy a node template of node type ingress with various hosting stacks, artifacts, deployment technologies, and qualities.

Scenario #1

In this scenario, the node template "component" of node type ingress is deployed. The node template is hosted on the node template "host 1" of node type kubernetes.cluster.

component(ingress)host 1(kubernetes.cluster)host

Ansible supports deploying this scenario under a medium quality.

Kubernetes supports deploying this scenario under a very high quality.

The ingress is hosted on a Kubernetes cluster. Kubernetes provides its own natively integrated deployment technology.

Terraform supports deploying this scenario under a medium quality.

Scenario #2

In this scenario, the node template "component" of node type ingress is deployed. The node template is hosted on the node template "host 1" of node type local.machine.

component(ingress)host 1(local.machine)host

Ansible supports deploying this scenario under a very high quality.

The ingress is hosted on a local machine. Ansible is specialized for installing software components on local targets, while Terraform discourages from being used to manage such scenarios.

Terraform supports deploying this scenario under a very low quality.

Scenario #3

In this scenario, the node template "component" of node type ingress is deployed. The node template is hosted on the node template "host 1" of node type remote.machine.

component(ingress)host 1(remote.machine)host

Ansible supports deploying this scenario under a very high quality.

The ingress is hosted on a remote machine. Ansible is specialized for installing software components on remote targets, while Terraform discourages from being used to manage such scenarios.

Terraform supports deploying this scenario under a very low quality.

Component "mysql.database"

The following scenarios deploy a node template of node type mysql.database with various hosting stacks, artifacts, deployment technologies, and qualities.

Scenario #1

In this scenario, the node template "component" of node type mysql.database is deployed. The node template is hosted on the node template "host 1" of node type mysql.dbms, which is hosted on the node template "host 2" of node type docker.engine, which is hosted on the node template "host 3" of node type local.machine.

component(mysql.database)host 1(mysql.dbms)host 2(docker.engine)host 3(local.machine)hosthosthost

Ansible supports deploying this scenario under a very high quality.

The MySQL database is hosted on a MySQL DBMS on a Docker engine on a local machine. Ansible and Terraform offer declarative modules for managing a MySQL database.

Docker Compose supports deploying this scenario under a very low quality.

One-time use docker container ("fake Kubernetes job") with imperative parts, while other technologies provide declarative modules.

Terraform supports deploying this scenario under a very high quality.

The MySQL database is hosted on a MySQL DBMS on a Docker engine on a local machine. Ansible and Terraform offer declarative modules for managing a MySQL database.

Scenario #2

In this scenario, the node template "component" of node type mysql.database is deployed. The node template is hosted on the node template "host 1" of node type mysql.dbms, which is hosted on the node template "host 2" of node type docker.engine, which is hosted on the node template "host 3" of node type remote.machine.

component(mysql.database)host 1(mysql.dbms)host 2(docker.engine)host 3(remote.machine)hosthosthost

Ansible supports deploying this scenario under a very high quality.

The MySQL database is hosted on a MySQL DBMS on a Docker engine on a remote machine. Ansible and Terraform offer declarative modules for managing a MySQL database. However, in contrast to Terraform, Ansible provides native features to access the MySQL DBMS using SSH.

Docker Compose supports deploying this scenario under a very low quality.

One-time use docker container ("fake Kubernetes job") with imperative parts, while other technologies provide declarative modules.

Terraform supports deploying this scenario under a high quality.

Scenario #3

In this scenario, the node template "component" of node type mysql.database is deployed. The node template is hosted on the node template "host 1" of node type mysql.dbms, which is hosted on the node template "host 2" of node type gcp.cloudsql.

component(mysql.database)host 1(mysql.dbms)host 2(gcp.cloudsql)hosthost

Ansible supports deploying this scenario under a very low quality.

Terraform supports deploying this scenario under a very high quality.

The MySQL database is hosted on a MySQL DBMS on GCP CloudSQL. Terraform provides an official provider for GCP. In contrast, the corresponding Ansible module is not maintained and violates community standards.

Scenario #4

In this scenario, the node template "component" of node type mysql.database is deployed. The node template is hosted on the node template "host 1" of node type mysql.dbms, which is hosted on the node template "host 2" of node type kubernetes.cluster.

component(mysql.database)host 1(mysql.dbms)host 2(kubernetes.cluster)hosthost

Ansible supports deploying this scenario under a very high quality.

The MySQL database is hosted on a MySQL DBMS on a Kubernetes cluster. Ansible and Terraform offer declarative modules for managing a MySQL database. However, in contrast to Terraform, Ansible provides better features to access the MySQL DBMS within the Kubernetes cluster.

Kubernetes supports deploying this scenario under a very low quality.

Kubernetes Job with imperative parts, while declarative other technologies provide declarative modules

Terraform supports deploying this scenario under a low quality.

Scenario #5

In this scenario, the node template "component" of node type mysql.database is deployed. The node template is hosted on the node template "host 1" of node type mysql.dbms, which is hosted on the node template "host 2" of node type local.machine.

component(mysql.database)host 1(mysql.dbms)host 2(local.machine)hosthost

Ansible supports deploying this scenario under a very high quality.

The MySQL database is hosted on a MySQL DBMS on a local machine. Ansible and Terraform offer declarative modules for managing a MySQL database.

Terraform supports deploying this scenario under a very high quality.

The MySQL database is hosted on a MySQL DBMS on a local machine. Ansible and Terraform offer declarative modules for managing a MySQL database.

Scenario #6

In this scenario, the node template "component" of node type mysql.database is deployed. The node template is hosted on the node template "host 1" of node type mysql.dbms, which is hosted on the node template "host 2" of node type remote.machine.

component(mysql.database)host 1(mysql.dbms)host 2(remote.machine)hosthost

Ansible supports deploying this scenario under a very high quality.

The MySQL database is hosted on a MySQL DBMS on a remote machine. Ansible is Terraform offer declarative modules for managing a MySQL database. However, in contrast to Terraform, Ansible provides native features to access the MySQL DBMS using SSH.

Terraform supports deploying this scenario under a medium quality.

Component "mysql.dbms"

The following scenarios deploy a node template of node type mysql.dbms with various hosting stacks, artifacts, deployment technologies, and qualities.

Scenario #1

In this scenario, the node template "component" of node type mysql.dbms is deployed. This node template is implemented by its deployment artifact "artifact" of artifact type dbms.image. The node template is hosted on the node template "host 1" of node type docker.engine, which is hosted on the node template "host 2" of node type local.machine.

component(mysql.dbms)artifact(dbms.image)host 1(docker.engine)host 2(local.machine)hosthost

Ansible supports deploying this scenario under a medium quality.

Docker Compose supports deploying this scenario under a very high quality.

The MySQL DBMS is hosted on a Docker engine on a local machine. Docker Compose is natively integrated into the Docker engine.

Terraform supports deploying this scenario under a medium quality.

Scenario #2

In this scenario, the node template "component" of node type mysql.dbms is deployed. This node template is implemented by its deployment artifact "artifact" of artifact type dbms.image. The node template is hosted on the node template "host 1" of node type docker.engine, which is hosted on the node template "host 2" of node type remote.machine.

component(mysql.dbms)artifact(dbms.image)host 1(docker.engine)host 2(remote.machine)hosthost

Ansible supports deploying this scenario under a medium quality.

Docker Compose supports deploying this scenario under a very high quality.

The MySQL DBMS is hosted on a Docker engine on a remote machine. Docker Compose is natively integrated into the Docker engine.

Terraform supports deploying this scenario under a medium quality.

Scenario #3

In this scenario, the node template "component" of node type mysql.dbms is deployed. This node template is implemented by its deployment artifact "artifact" of artifact type dbms.image. The node template is hosted on the node template "host 1" of node type gcp.cloudsql.

component(mysql.dbms)artifact(dbms.image)host 1(gcp.cloudsql)host

Ansible supports deploying this scenario under a very low quality.

Terraform supports deploying this scenario under a very high quality.

The MySQL DBMS is hosted on GCP CloudSQL. Terraform provides an official provider for GCP. In contrast, the corresponding Ansible module is not maintained and violates community standards.

Scenario #4

In this scenario, the node template "component" of node type mysql.dbms is deployed. This node template is implemented by its deployment artifact "artifact" of artifact type dbms.image. The node template is hosted on the node template "host 1" of node type kubernetes.cluster.

component(mysql.dbms)artifact(dbms.image)host 1(kubernetes.cluster)host

Ansible supports deploying this scenario under a medium quality.

Kubernetes supports deploying this scenario under a very high quality.

The MySQL DBMS is hosted on a Kubernetes cluster. Kubernetes provides its own natively integrated deployment technology.

Terraform supports deploying this scenario under a medium quality.

Scenario #5

In this scenario, the node template "component" of node type mysql.dbms is deployed. This node template is implemented by its deployment artifact "artifact" of artifact type dbms.image. The node template is hosted on the node template "host 1" of node type local.machine.

component(mysql.dbms)artifact(dbms.image)host 1(local.machine)host

Ansible supports deploying this scenario under a very high quality.

The MySQL DBMS is hosted on a local machine. Ansible is specialized for installing software components on local targets, while Terraform discourages from being used to manage such scenarios.

Terraform supports deploying this scenario under a very low quality.

Scenario #6

In this scenario, the node template "component" of node type mysql.dbms is deployed. This node template is implemented by its deployment artifact "artifact" of artifact type dbms.image. The node template is hosted on the node template "host 1" of node type remote.machine.

component(mysql.dbms)artifact(dbms.image)host 1(remote.machine)host

Ansible supports deploying this scenario under a very high quality.

The MySQL DBMS is hosted on a remote machine. Ansible is specialized for installing software components on remote targets, while Terraform discourages from being used to manage such scenarios.

Terraform supports deploying this scenario under a very low quality.

Component "object.storage"

The following scenarios deploy a node template of node type object.storage with various hosting stacks, artifacts, deployment technologies, and qualities.

Scenario #1

In this scenario, the node template "component" of node type object.storage is deployed. The node template is hosted on the node template "host 1" of node type gcp.cloudstorage.

component(object.storage)host 1(gcp.cloudstorage)host

Ansible supports deploying this scenario under a very low quality.

Terraform supports deploying this scenario under a very high quality.

The object storage is hosted on GCP CloudStorage. Terraform provides an official provider for GCP. In contrast, the corresponding Ansible module is not maintained and violates community standards.

Scenario #2

In this scenario, the node template "component" of node type object.storage is deployed. The node template is hosted on the node template "host 1" of node type minio.server, which is hosted on the node template "host 2" of node type docker.engine, which is hosted on the node template "host 3" of node type local.machine.

component(object.storage)host 1(minio.server)host 2(docker.engine)host 3(local.machine)hosthosthost

Ansible supports deploying this scenario under a very high quality.

The object storage is hosted on a MinIO server on a Docker engine on a local machine. Ansible and Terraform offer declarative modules for this scenario.

Docker Compose supports deploying this scenario under a very low quality.

One-time use docker container ("fake Kubernetes job") with imperative parts, while other technologies provide declarative modules.

Terraform supports deploying this scenario under a very high quality.

The object storage is hosted on a MinIO server on a Docker engine on a local machine. Ansible and Terraform offer declarative modules for this scenario.

Scenario #3

In this scenario, the node template "component" of node type object.storage is deployed. The node template is hosted on the node template "host 1" of node type minio.server, which is hosted on the node template "host 2" of node type docker.engine, which is hosted on the node template "host 3" of node type remote.machine.

component(object.storage)host 1(minio.server)host 2(docker.engine)host 3(remote.machine)hosthosthost

Ansible supports deploying this scenario under a very high quality.

The object storage is hosted on a MinIO server on a Docker engine on a remote machine. Ansible and Terraform offer declarative modules for this scenario. However, in contrast to Terraform, Ansible provides native features to access the MySQL DBMS using SSH.

Docker Compose supports deploying this scenario under a very low quality.

One-time use docker container ("fake Kubernetes job") with imperative parts, while other technologies provide declarative modules.

Terraform supports deploying this scenario under a high quality.

Scenario #4

In this scenario, the node template "component" of node type object.storage is deployed. The node template is hosted on the node template "host 1" of node type minio.server, which is hosted on the node template "host 2" of node type kubernetes.cluster.

component(object.storage)host 1(minio.server)host 2(kubernetes.cluster)hosthost

Ansible supports deploying this scenario under a very high quality.

The object storage is hosted on a MinIO server on a Kubernetes cluster. Ansible and Terraform offer declarative modules for this scenario. However, in contrast to Terraform, Ansible provides better features to access the MinIO server within the Kubernetes cluster.

Kubernetes supports deploying this scenario under a very low quality.

Kubernetes Job with imperative parts, while declarative other technologies provide declarative modules

Terraform supports deploying this scenario under a low quality.

Component "redis.server"

The following scenarios deploy a node template of node type redis.server with various hosting stacks, artifacts, deployment technologies, and qualities.

Scenario #1

In this scenario, the node template "component" of node type redis.server is deployed. This node template is implemented by its deployment artifact "artifact" of artifact type cache.image. The node template is hosted on the node template "host 1" of node type docker.engine, which is hosted on the node template "host 2" of node type local.machine.

component(redis.server)artifact(cache.image)host 1(docker.engine)host 2(local.machine)hosthost

Ansible supports deploying this scenario under a medium quality.

Docker Compose supports deploying this scenario under a very high quality.

The redis server is hosted on a Docker engine on a local machine. Docker Compose is natively integrated into the Docker engine.

Terraform supports deploying this scenario under a medium quality.

Scenario #2

In this scenario, the node template "component" of node type redis.server is deployed. This node template is implemented by its deployment artifact "artifact" of artifact type cache.image. The node template is hosted on the node template "host 1" of node type docker.engine, which is hosted on the node template "host 2" of node type remote.machine.

component(redis.server)artifact(cache.image)host 1(docker.engine)host 2(remote.machine)hosthost

Ansible supports deploying this scenario under a medium quality.

Docker Compose supports deploying this scenario under a very high quality.

The redis server is hosted on a Docker engine on a remote machine. Docker Compose is natively integrated into the Docker engine.

Terraform supports deploying this scenario under a medium quality.

Scenario #3

In this scenario, the node template "component" of node type redis.server is deployed. This node template is implemented by its deployment artifact "artifact" of artifact type cache.image. The node template is hosted on the node template "host 1" of node type gcp.memorystore.

component(redis.server)artifact(cache.image)host 1(gcp.memorystore)host

Ansible supports deploying this scenario under a very low quality.

Terraform supports deploying this scenario under a very high quality.

The redis server is hosted on GCP Memorystore. Terraform provides an official provider for GCP. In contrast, the corresponding Ansible module is not maintained and violates community standards.

Scenario #4

In this scenario, the node template "component" of node type redis.server is deployed. This node template is implemented by its deployment artifact "artifact" of artifact type cache.image. The node template is hosted on the node template "host 1" of node type kubernetes.cluster.

component(redis.server)artifact(cache.image)host 1(kubernetes.cluster)host

Ansible supports deploying this scenario under a medium quality.

Kubernetes supports deploying this scenario under a very high quality.

The redis server is hosted on a Kubernetes cluster. Kubernetes provides its own natively integrated deployment technology.

Terraform supports deploying this scenario under a medium quality.

Component "service.component"

The following scenarios deploy a node template of node type service.component with various hosting stacks, artifacts, deployment technologies, and qualities.

Scenario #1

In this scenario, the node template "component" of node type service.component is deployed. This node template is implemented by its deployment artifact "artifact" of artifact type docker.image. The node template is hosted on the node template "host 1" of node type docker.engine, which is hosted on the node template "host 2" of node type local.machine.

component(service.component)artifact(docker.image)host 1(docker.engine)host 2(local.machine)hosthost

Ansible supports deploying this scenario under a medium quality.

Docker Compose supports deploying this scenario under a very high quality.

The service component is hosted on a Docker engine on a local machine. Docker Compose is natively integrated into the Docker engine.

Terraform supports deploying this scenario under a medium quality.

Scenario #2

In this scenario, the node template "component" of node type service.component is deployed. This node template is implemented by its deployment artifact "artifact" of artifact type docker.image. The node template is hosted on the node template "host 1" of node type docker.engine, which is hosted on the node template "host 2" of node type remote.machine.

component(service.component)artifact(docker.image)host 1(docker.engine)host 2(remote.machine)hosthost

Ansible supports deploying this scenario under a medium quality.

Docker Compose supports deploying this scenario under a very high quality.

The service component is hosted on a Docker engine on a remote machine. Docker Compose is natively integrated into the Docker engine.

Terraform supports deploying this scenario under a medium quality.

Scenario #3

In this scenario, the node template "component" of node type service.component is deployed. This node template is implemented by its deployment artifact "artifact" of artifact type docker.image. The node template is hosted on the node template "host 1" of node type gcp.cloudrun.

component(service.component)artifact(docker.image)host 1(gcp.cloudrun)host

Ansible supports deploying this scenario under a very low quality.

Terraform supports deploying this scenario under a very high quality.

The service component is hosted on GCP CloudRun. Terraform provides an official provider for GCP. In contrast, the corresponding Ansible module does not provide resources for GCP CloudRun.

Scenario #4

In this scenario, the node template "component" of node type service.component is deployed. This node template is implemented by its deployment artifact "artifact" of artifact type docker.image. The node template is hosted on the node template "host 1" of node type kubernetes.cluster.

component(service.component)artifact(docker.image)host 1(kubernetes.cluster)host

Ansible supports deploying this scenario under a medium quality.

Kubernetes supports deploying this scenario under a very high quality.

The service component is hosted on a Kubernetes cluster. Kubernetes provides its own natively integrated deployment technology.

Terraform supports deploying this scenario under a medium quality.

Scenario #5

In this scenario, the node template "component" of node type service.component is deployed. This node template is implemented by its deployment artifact "artifact" of artifact type tar.archive. The node template is hosted on an arbitrary hosting stack of arbitrary length, which is hosted on the node template "host 2" of node type local.machine.

component(service.component)artifact(tar.archive)...host 2(local.machine)hosthost

Ansible supports deploying this scenario under a very high quality.

The service component is hosted on a local machine. Ansible is specialized for installing software components on local targets, while Terraform discourages from being used to manage such scenarios.

Terraform supports deploying this scenario under a very low quality.

Scenario #6

In this scenario, the node template "component" of node type service.component is deployed. This node template is implemented by its deployment artifact "artifact" of artifact type tar.archive. The node template is hosted on an arbitrary hosting stack of arbitrary length, which is hosted on the node template "host 2" of node type remote.machine.

component(service.component)artifact(tar.archive)...host 2(remote.machine)hosthost

Ansible supports deploying this scenario under a very high quality.

The service component is hosted on a remote machine. Ansible is specialized for installing software components on remote targets, while Terraform discourages from being used to manage such scenarios.

Terraform supports deploying this scenario under a very low quality.

Scenario #7

In this scenario, the node template "component" of node type service.component is deployed. This node template is implemented by its deployment artifact "artifact" of artifact type zip.archive. The node template is hosted on an arbitrary hosting stack of arbitrary length, which is hosted on the node template "host 2" of node type local.machine.

component(service.component)artifact(zip.archive)...host 2(local.machine)hosthost

Ansible supports deploying this scenario under a very high quality.

The service component is hosted on a local machine. Ansible is specialized for installing software components on local targets, while Terraform discourages from being used to manage such scenarios.

Terraform supports deploying this scenario under a very low quality.

Scenario #8

In this scenario, the node template "component" of node type service.component is deployed. This node template is implemented by its deployment artifact "artifact" of artifact type zip.archive. The node template is hosted on an arbitrary hosting stack of arbitrary length, which is hosted on the node template "host 2" of node type remote.machine.

component(service.component)artifact(zip.archive)...host 2(remote.machine)hosthost

Ansible supports deploying this scenario under a very high quality.

The service component is hosted on a remote machine. Ansible is specialized for installing software components on remote targets, while Terraform discourages from being used to manage such scenarios.

Terraform supports deploying this scenario under a very low quality.

Scenario #9

In this scenario, the node template "component" of node type service.component is deployed. This node template is implemented by its deployment artifact "artifact" of artifact type zip.archive. The node template is hosted on the node template "host 1" of node type gcp.appengine.

component(service.component)artifact(zip.archive)host 1(gcp.appengine)host

Ansible supports deploying this scenario under a very low quality.

Terraform supports deploying this scenario under a very high quality.

The service component is hosted on GCP AppEngine. Terraform provides an official provider for GCP. In contrast, the corresponding Ansible module is not maintained and violates community standards.

Component "software.component"

The following scenarios deploy a node template of node type software.component with various hosting stacks, artifacts, deployment technologies, and qualities.

Scenario #1

In this scenario, the node template "component" of node type software.component is deployed. This node template is implemented by its deployment artifact "artifact" of artifact type apt.package. The node template is hosted on an arbitrary hosting stack of arbitrary length, which is hosted on the node template "host 2" of node type local.machine.

component(software.component)artifact(apt.package)...host 2(local.machine)hosthost

Ansible supports deploying this scenario under a very high quality.

The software component is hosted on a local machine. Ansible is specialized for installing software components on local targets, while Terraform discourages from being used to manage such scenarios.

Terraform supports deploying this scenario under a very low quality.

Scenario #2

In this scenario, the node template "component" of node type software.component is deployed. This node template is implemented by its deployment artifact "artifact" of artifact type apt.package. The node template is hosted on an arbitrary hosting stack of arbitrary length, which is hosted on the node template "host 2" of node type remote.machine.

component(software.component)artifact(apt.package)...host 2(remote.machine)hosthost

Ansible supports deploying this scenario under a very high quality.

The software component is hosted on a remote machine. Ansible is specialized for installing software components on remote targets, while Terraform discourages from being used to manage such scenarios.

Terraform supports deploying this scenario under a very low quality.

Scenario #3

In this scenario, the node template "component" of node type software.component is deployed. This node template is implemented by its deployment artifact "artifact" of artifact type tar.archive. This node template has the management operations: "create", "delete". The node template is hosted on an arbitrary hosting stack of arbitrary length, which is hosted on the node template "host 2" of node type local.machine.

component(software.component)artifact(tar.archive)createdelete...host 2(local.machine)hosthost

Ansible supports deploying this scenario under a very high quality.

The software component is hosted on a local machine. Ansible is specialized for installing software components on local targets, while Terraform discourages from being used to manage such scenarios.

Terraform supports deploying this scenario under a very low quality.

Scenario #4

In this scenario, the node template "component" of node type software.component is deployed. This node template is implemented by its deployment artifact "artifact" of artifact type tar.archive. This node template has the management operations: "create", "delete". The node template is hosted on an arbitrary hosting stack of arbitrary length, which is hosted on the node template "host 2" of node type remote.machine.

component(software.component)artifact(tar.archive)createdelete...host 2(remote.machine)hosthost

Ansible supports deploying this scenario under a very high quality.

The software component is hosted on a remote machine. Ansible is specialized for installing software components on remote targets, while Terraform discourages from being used to manage such scenarios.

Terraform supports deploying this scenario under a very low quality.

Scenario #5

In this scenario, the node template "component" of node type software.component is deployed. This node template is implemented by its deployment artifact "artifact" of artifact type zip.archive. This node template has the management operations: "create", "delete". The node template is hosted on an arbitrary hosting stack of arbitrary length, which is hosted on the node template "host 2" of node type local.machine.

component(software.component)artifact(zip.archive)createdelete...host 2(local.machine)hosthost

Ansible supports deploying this scenario under a very high quality.

The software component is hosted on a local machine. Ansible is specialized for installing software components on local targets, while Terraform discourages from being used to manage such scenarios.

Terraform supports deploying this scenario under a very low quality.

Scenario #6

In this scenario, the node template "component" of node type software.component is deployed. This node template is implemented by its deployment artifact "artifact" of artifact type zip.archive. This node template has the management operations: "create", "delete". The node template is hosted on an arbitrary hosting stack of arbitrary length, which is hosted on the node template "host 2" of node type remote.machine.

component(software.component)artifact(zip.archive)createdelete...host 2(remote.machine)hosthost

Ansible supports deploying this scenario under a very high quality.

The software component is hosted on a remote machine. Ansible is specialized for installing software components on remote targets, while Terraform discourages from being used to manage such scenarios.

Terraform supports deploying this scenario under a very low quality.

Component "virtual.machine"

The following scenarios deploy a node template of node type virtual.machine with various hosting stacks, artifacts, deployment technologies, and qualities.

Scenario #1

In this scenario, the node template "component" of node type virtual.machine is deployed. This node template is implemented by its deployment artifact "artifact" of artifact type machine.image. The node template is hosted on the node template "host 1" of node type openstack.provider.

component(virtual.machine)artifact(machine.image)host 1(openstack.provider)host

Ansible supports deploying this scenario under a medium quality.

Terraform supports deploying this scenario under a very high quality.

The virtual machine is hosted on OpenStack. Terraform is specialized in provisioning infrastructure, while Ansible is specialized for managing software on such infrastructure.

Appendix A "Cards"

This appendix contains the deployment quality cards.

Rule #1

Attribute Value
Number 1
Rules docker.engine::ansible@local.machine
Scenario docker.engine@local.machine
Component docker.engine
Technology ansible
Hosting local.machine
Reason The Docker engine is hosted on a local machine. Ansible is specialized for installing software components on local targets, while Terraform discourages from being used to manage such scenarios.
Quality very high
Weight 1
Topology
component(docker.engine)host 1(local.machine)host

Rule #2

Attribute Value
Number 2
Rules docker.engine::terraform@local.machine
Scenario docker.engine@local.machine
Component docker.engine
Technology terraform
Hosting local.machine
Quality very low
Weight 0
Topology
component(docker.engine)host 1(local.machine)host

Rule #3

Attribute Value
Number 3
Rules docker.engine::ansible@remote.machine
Scenario docker.engine@remote.machine
Component docker.engine
Technology ansible
Hosting remote.machine
Reason The Docker engine is hosted on a remote machine. Ansible is specialized for installing software components on remote targets, while Terraform discourages from being used to manage such scenarios.
Quality very high
Weight 1
Topology
component(docker.engine)host 1(remote.machine)host

Rule #4

Attribute Value
Number 4
Rules docker.engine::terraform@remote.machine
Scenario docker.engine@remote.machine
Component docker.engine
Technology terraform
Hosting remote.machine
Quality very low
Weight 0
Topology
component(docker.engine)host 1(remote.machine)host

Rule #5

Attribute Value
Number 5
Rules gcp.service::ansible
Scenario gcp.service
Component gcp.service
Technology ansible
Quality very low
Weight 0
Topology
component(gcp.service)

Rule #6

Attribute Value
Number 6
Rules gcp.service::terraform
Scenario gcp.service
Component gcp.service
Technology terraform
Reason The GCP service is hosted on GCP. Terraform provides an official provider for GCP. In contrast, the corresponding Ansible module is not maintained and violates community standards.
Quality very high
Weight 1
Topology
component(gcp.service)

Rule #7

Attribute Value
Number 7
Rules ingress::ansible@kubernetes.cluster
Scenario ingress@kubernetes.cluster
Component ingress
Technology ansible
Hosting kubernetes.cluster
Quality medium
Weight 0.5
Topology
component(ingress)host 1(kubernetes.cluster)host

Rule #8

Attribute Value
Number 8
Rules ingress::kubernetes@kubernetes.cluster
Scenario ingress@kubernetes.cluster
Component ingress
Technology kubernetes
Hosting kubernetes.cluster
Reason The ingress is hosted on a Kubernetes cluster. Kubernetes provides its own natively integrated deployment technology.
Quality very high
Weight 1
Topology
component(ingress)host 1(kubernetes.cluster)host

Rule #9

Attribute Value
Number 9
Rules ingress::terraform@kubernetes.cluster
Scenario ingress@kubernetes.cluster
Component ingress
Technology terraform
Hosting kubernetes.cluster
Quality medium
Weight 0.5
Topology
component(ingress)host 1(kubernetes.cluster)host

Rule #10

Attribute Value
Number 10
Rules ingress::ansible@local.machine
Scenario ingress@local.machine
Component ingress
Technology ansible
Hosting local.machine
Reason The ingress is hosted on a local machine. Ansible is specialized for installing software components on local targets, while Terraform discourages from being used to manage such scenarios.
Quality very high
Weight 1
Topology
component(ingress)host 1(local.machine)host

Rule #11

Attribute Value
Number 11
Rules ingress::terraform@local.machine
Scenario ingress@local.machine
Component ingress
Technology terraform
Hosting local.machine
Quality very low
Weight 0
Topology
component(ingress)host 1(local.machine)host

Rule #12

Attribute Value
Number 12
Rules ingress::ansible@remote.machine
Scenario ingress@remote.machine
Component ingress
Technology ansible
Hosting remote.machine
Reason The ingress is hosted on a remote machine. Ansible is specialized for installing software components on remote targets, while Terraform discourages from being used to manage such scenarios.
Quality very high
Weight 1
Topology
component(ingress)host 1(remote.machine)host

Rule #13

Attribute Value
Number 13
Rules ingress::terraform@remote.machine
Scenario ingress@remote.machine
Component ingress
Technology terraform
Hosting remote.machine
Quality very low
Weight 0
Topology
component(ingress)host 1(remote.machine)host

Rule #14

Attribute Value
Number 14
Rules mysql.database::ansible@mysql.dbms->docker.engine->local.machine
Scenario mysql.database@mysql.dbms->docker.engine->local.machine
Component mysql.database
Technology ansible
Hosting mysql.dbms -> docker.engine -> local.machine
Reason The MySQL database is hosted on a MySQL DBMS on a Docker engine on a local machine. Ansible and Terraform offer declarative modules for managing a MySQL database.
Quality very high
Weight 1
Topology
component(mysql.database)host 1(mysql.dbms)host 2(docker.engine)host 3(local.machine)hosthosthost

Rule #15

Attribute Value
Number 15
Rules mysql.database::compose@mysql.dbms->docker.engine->local.machine
Scenario mysql.database@mysql.dbms->docker.engine->local.machine
Component mysql.database
Technology compose
Hosting mysql.dbms -> docker.engine -> local.machine
Reason One-time use docker container ("fake Kubernetes job") with imperative parts, while other technologies provide declarative modules.
Quality very low
Weight 0
Topology
component(mysql.database)host 1(mysql.dbms)host 2(docker.engine)host 3(local.machine)hosthosthost

Rule #16

Attribute Value
Number 16
Rules mysql.database::terraform@mysql.dbms->docker.engine->local.machine
Scenario mysql.database@mysql.dbms->docker.engine->local.machine
Component mysql.database
Technology terraform
Hosting mysql.dbms -> docker.engine -> local.machine
Reason The MySQL database is hosted on a MySQL DBMS on a Docker engine on a local machine. Ansible and Terraform offer declarative modules for managing a MySQL database.
Quality very high
Weight 1
Topology
component(mysql.database)host 1(mysql.dbms)host 2(docker.engine)host 3(local.machine)hosthosthost

Rule #17

Attribute Value
Number 17
Rules mysql.database::ansible@mysql.dbms->docker.engine->remote.machine
Scenario mysql.database@mysql.dbms->docker.engine->remote.machine
Component mysql.database
Technology ansible
Hosting mysql.dbms -> docker.engine -> remote.machine
Reason The MySQL database is hosted on a MySQL DBMS on a Docker engine on a remote machine. Ansible and Terraform offer declarative modules for managing a MySQL database. However, in contrast to Terraform, Ansible provides native features to access the MySQL DBMS using SSH.
Quality very high
Weight 1
Topology
component(mysql.database)host 1(mysql.dbms)host 2(docker.engine)host 3(remote.machine)hosthosthost

Rule #18

Attribute Value
Number 18
Rules mysql.database::compose@mysql.dbms->docker.engine->remote.machine
Scenario mysql.database@mysql.dbms->docker.engine->remote.machine
Component mysql.database
Technology compose
Hosting mysql.dbms -> docker.engine -> remote.machine
Reason One-time use docker container ("fake Kubernetes job") with imperative parts, while other technologies provide declarative modules.
Quality very low
Weight 0
Topology
component(mysql.database)host 1(mysql.dbms)host 2(docker.engine)host 3(remote.machine)hosthosthost

Rule #19

Attribute Value
Number 19
Rules mysql.database::terraform@mysql.dbms->docker.engine->remote.machine
Scenario mysql.database@mysql.dbms->docker.engine->remote.machine
Component mysql.database
Technology terraform
Hosting mysql.dbms -> docker.engine -> remote.machine
Quality high
Weight 0.75
Topology
component(mysql.database)host 1(mysql.dbms)host 2(docker.engine)host 3(remote.machine)hosthosthost

Rule #20

Attribute Value
Number 20
Rules mysql.database::ansible@mysql.dbms->gcp.cloudsql
Scenario mysql.database@mysql.dbms->gcp.cloudsql
Component mysql.database
Technology ansible
Hosting mysql.dbms -> gcp.cloudsql
Quality very low
Weight 0
Topology
component(mysql.database)host 1(mysql.dbms)host 2(gcp.cloudsql)hosthost

Rule #21

Attribute Value
Number 21
Rules mysql.database::terraform@mysql.dbms->gcp.cloudsql
Scenario mysql.database@mysql.dbms->gcp.cloudsql
Component mysql.database
Technology terraform
Hosting mysql.dbms -> gcp.cloudsql
Reason The MySQL database is hosted on a MySQL DBMS on GCP CloudSQL. Terraform provides an official provider for GCP. In contrast, the corresponding Ansible module is not maintained and violates community standards.
Quality very high
Weight 1
Topology
component(mysql.database)host 1(mysql.dbms)host 2(gcp.cloudsql)hosthost

Rule #22

Attribute Value
Number 22
Rules mysql.database::ansible@mysql.dbms->kubernetes.cluster
Scenario mysql.database@mysql.dbms->kubernetes.cluster
Component mysql.database
Technology ansible
Hosting mysql.dbms -> kubernetes.cluster
Reason The MySQL database is hosted on a MySQL DBMS on a Kubernetes cluster. Ansible and Terraform offer declarative modules for managing a MySQL database. However, in contrast to Terraform, Ansible provides better features to access the MySQL DBMS within the Kubernetes cluster.
Quality very high
Weight 1
Topology
component(mysql.database)host 1(mysql.dbms)host 2(kubernetes.cluster)hosthost

Rule #23

Attribute Value
Number 23
Rules mysql.database::kubernetes@mysql.dbms->kubernetes.cluster
Scenario mysql.database@mysql.dbms->kubernetes.cluster
Component mysql.database
Technology kubernetes
Hosting mysql.dbms -> kubernetes.cluster
Reason Kubernetes Job with imperative parts, while declarative other technologies provide declarative modules
Quality very low
Weight 0
Topology
component(mysql.database)host 1(mysql.dbms)host 2(kubernetes.cluster)hosthost

Rule #24

Attribute Value
Number 24
Rules mysql.database::terraform@mysql.dbms->kubernetes.cluster
Scenario mysql.database@mysql.dbms->kubernetes.cluster
Component mysql.database
Technology terraform
Hosting mysql.dbms -> kubernetes.cluster
Quality low
Weight 0.25
Topology
component(mysql.database)host 1(mysql.dbms)host 2(kubernetes.cluster)hosthost

Rule #25

Attribute Value
Number 25
Rules mysql.database::ansible@mysql.dbms->local.machine
Scenario mysql.database@mysql.dbms->local.machine
Component mysql.database
Technology ansible
Hosting mysql.dbms -> local.machine
Reason The MySQL database is hosted on a MySQL DBMS on a local machine. Ansible and Terraform offer declarative modules for managing a MySQL database.
Quality very high
Weight 1
Topology
component(mysql.database)host 1(mysql.dbms)host 2(local.machine)hosthost

Rule #26

Attribute Value
Number 26
Rules mysql.database::terraform@mysql.dbms->local.machine
Scenario mysql.database@mysql.dbms->local.machine
Component mysql.database
Technology terraform
Hosting mysql.dbms -> local.machine
Reason The MySQL database is hosted on a MySQL DBMS on a local machine. Ansible and Terraform offer declarative modules for managing a MySQL database.
Quality very high
Weight 1
Topology
component(mysql.database)host 1(mysql.dbms)host 2(local.machine)hosthost

Rule #27

Attribute Value
Number 27
Rules mysql.database::ansible@mysql.dbms->remote.machine
Scenario mysql.database@mysql.dbms->remote.machine
Component mysql.database
Technology ansible
Hosting mysql.dbms -> remote.machine
Reason The MySQL database is hosted on a MySQL DBMS on a remote machine. Ansible is Terraform offer declarative modules for managing a MySQL database. However, in contrast to Terraform, Ansible provides native features to access the MySQL DBMS using SSH.
Quality very high
Weight 1
Topology
component(mysql.database)host 1(mysql.dbms)host 2(remote.machine)hosthost

Rule #28

Attribute Value
Number 28
Rules mysql.database::terraform@mysql.dbms->remote.machine
Scenario mysql.database@mysql.dbms->remote.machine
Component mysql.database
Technology terraform
Hosting mysql.dbms -> remote.machine
Quality medium
Weight 0.5
Topology
component(mysql.database)host 1(mysql.dbms)host 2(remote.machine)hosthost

Rule #29

Attribute Value
Number 29
Rules mysql.dbms#dbms.image::ansible@docker.engine->local.machine
Scenario mysql.dbms#dbms.image@docker.engine->local.machine
Component mysql.dbms
Artifact dbms.image
Technology ansible
Hosting docker.engine -> local.machine
Quality medium
Weight 0.5
Topology
component(mysql.dbms)artifact(dbms.image)host 1(docker.engine)host 2(local.machine)hosthost

Rule #30

Attribute Value
Number 30
Rules mysql.dbms#dbms.image::compose@docker.engine->local.machine
Scenario mysql.dbms#dbms.image@docker.engine->local.machine
Component mysql.dbms
Artifact dbms.image
Technology compose
Hosting docker.engine -> local.machine
Reason The MySQL DBMS is hosted on a Docker engine on a local machine. Docker Compose is natively integrated into the Docker engine.
Quality very high
Weight 1
Topology
component(mysql.dbms)artifact(dbms.image)host 1(docker.engine)host 2(local.machine)hosthost

Rule #31

Attribute Value
Number 31
Rules mysql.dbms#dbms.image::terraform@docker.engine->local.machine
Scenario mysql.dbms#dbms.image@docker.engine->local.machine
Component mysql.dbms
Artifact dbms.image
Technology terraform
Hosting docker.engine -> local.machine
Quality medium
Weight 0.5
Topology
component(mysql.dbms)artifact(dbms.image)host 1(docker.engine)host 2(local.machine)hosthost

Rule #32

Attribute Value
Number 32
Rules mysql.dbms#dbms.image::ansible@docker.engine->remote.machine
Scenario mysql.dbms#dbms.image@docker.engine->remote.machine
Component mysql.dbms
Artifact dbms.image
Technology ansible
Hosting docker.engine -> remote.machine
Quality medium
Weight 0.5
Topology
component(mysql.dbms)artifact(dbms.image)host 1(docker.engine)host 2(remote.machine)hosthost

Rule #33

Attribute Value
Number 33
Rules mysql.dbms#dbms.image::compose@docker.engine->remote.machine
Scenario mysql.dbms#dbms.image@docker.engine->remote.machine
Component mysql.dbms
Artifact dbms.image
Technology compose
Hosting docker.engine -> remote.machine
Reason The MySQL DBMS is hosted on a Docker engine on a remote machine. Docker Compose is natively integrated into the Docker engine.
Quality very high
Weight 1
Topology
component(mysql.dbms)artifact(dbms.image)host 1(docker.engine)host 2(remote.machine)hosthost

Rule #34

Attribute Value
Number 34
Rules mysql.dbms#dbms.image::terraform@docker.engine->remote.machine
Scenario mysql.dbms#dbms.image@docker.engine->remote.machine
Component mysql.dbms
Artifact dbms.image
Technology terraform
Hosting docker.engine -> remote.machine
Quality medium
Weight 0.5
Topology
component(mysql.dbms)artifact(dbms.image)host 1(docker.engine)host 2(remote.machine)hosthost

Rule #35

Attribute Value
Number 35
Rules mysql.dbms#dbms.image::ansible@gcp.cloudsql
Scenario mysql.dbms#dbms.image@gcp.cloudsql
Component mysql.dbms
Artifact dbms.image
Technology ansible
Hosting gcp.cloudsql
Quality very low
Weight 0
Topology
component(mysql.dbms)artifact(dbms.image)host 1(gcp.cloudsql)host

Rule #36

Attribute Value
Number 36
Rules mysql.dbms#dbms.image::terraform@gcp.cloudsql
Scenario mysql.dbms#dbms.image@gcp.cloudsql
Component mysql.dbms
Artifact dbms.image
Technology terraform
Hosting gcp.cloudsql
Reason The MySQL DBMS is hosted on GCP CloudSQL. Terraform provides an official provider for GCP. In contrast, the corresponding Ansible module is not maintained and violates community standards.
Quality very high
Weight 1
Topology
component(mysql.dbms)artifact(dbms.image)host 1(gcp.cloudsql)host

Rule #37

Attribute Value
Number 37
Rules mysql.dbms#dbms.image::ansible@kubernetes.cluster
Scenario mysql.dbms#dbms.image@kubernetes.cluster
Component mysql.dbms
Artifact dbms.image
Technology ansible
Hosting kubernetes.cluster
Quality medium
Weight 0.5
Topology
component(mysql.dbms)artifact(dbms.image)host 1(kubernetes.cluster)host

Rule #38

Attribute Value
Number 38
Rules mysql.dbms#dbms.image::kubernetes@kubernetes.cluster
Scenario mysql.dbms#dbms.image@kubernetes.cluster
Component mysql.dbms
Artifact dbms.image
Technology kubernetes
Hosting kubernetes.cluster
Reason The MySQL DBMS is hosted on a Kubernetes cluster. Kubernetes provides its own natively integrated deployment technology.
Quality very high
Weight 1
Topology
component(mysql.dbms)artifact(dbms.image)host 1(kubernetes.cluster)host

Rule #39

Attribute Value
Number 39
Rules mysql.dbms#dbms.image::terraform@kubernetes.cluster
Scenario mysql.dbms#dbms.image@kubernetes.cluster
Component mysql.dbms
Artifact dbms.image
Technology terraform
Hosting kubernetes.cluster
Quality medium
Weight 0.5
Topology
component(mysql.dbms)artifact(dbms.image)host 1(kubernetes.cluster)host

Rule #40

Attribute Value
Number 40
Rules mysql.dbms#dbms.image::ansible@local.machine
Scenario mysql.dbms#dbms.image@local.machine
Component mysql.dbms
Artifact dbms.image
Technology ansible
Hosting local.machine
Reason The MySQL DBMS is hosted on a local machine. Ansible is specialized for installing software components on local targets, while Terraform discourages from being used to manage such scenarios.
Quality very high
Weight 1
Topology
component(mysql.dbms)artifact(dbms.image)host 1(local.machine)host

Rule #41

Attribute Value
Number 41
Rules mysql.dbms#dbms.image::terraform@local.machine
Scenario mysql.dbms#dbms.image@local.machine
Component mysql.dbms
Artifact dbms.image
Technology terraform
Hosting local.machine
Quality very low
Weight 0
Topology
component(mysql.dbms)artifact(dbms.image)host 1(local.machine)host

Rule #42

Attribute Value
Number 42
Rules mysql.dbms#dbms.image::ansible@remote.machine
Scenario mysql.dbms#dbms.image@remote.machine
Component mysql.dbms
Artifact dbms.image
Technology ansible
Hosting remote.machine
Reason The MySQL DBMS is hosted on a remote machine. Ansible is specialized for installing software components on remote targets, while Terraform discourages from being used to manage such scenarios.
Quality very high
Weight 1
Topology
component(mysql.dbms)artifact(dbms.image)host 1(remote.machine)host

Rule #43

Attribute Value
Number 43
Rules mysql.dbms#dbms.image::terraform@remote.machine
Scenario mysql.dbms#dbms.image@remote.machine
Component mysql.dbms
Artifact dbms.image
Technology terraform
Hosting remote.machine
Quality very low
Weight 0
Topology
component(mysql.dbms)artifact(dbms.image)host 1(remote.machine)host

Rule #44

Attribute Value
Number 44
Rules object.storage::ansible@gcp.cloudstorage
Scenario object.storage@gcp.cloudstorage
Component object.storage
Technology ansible
Hosting gcp.cloudstorage
Quality very low
Weight 0
Topology
component(object.storage)host 1(gcp.cloudstorage)host

Rule #45

Attribute Value
Number 45
Rules object.storage::terraform@gcp.cloudstorage
Scenario object.storage@gcp.cloudstorage
Component object.storage
Technology terraform
Hosting gcp.cloudstorage
Reason The object storage is hosted on GCP CloudStorage. Terraform provides an official provider for GCP. In contrast, the corresponding Ansible module is not maintained and violates community standards.
Quality very high
Weight 1
Topology
component(object.storage)host 1(gcp.cloudstorage)host

Rule #46

Attribute Value
Number 46
Rules object.storage::ansible@minio.server->docker.engine->local.machine
Scenario object.storage@minio.server->docker.engine->local.machine
Component object.storage
Technology ansible
Hosting minio.server -> docker.engine -> local.machine
Reason The object storage is hosted on a MinIO server on a Docker engine on a local machine. Ansible and Terraform offer declarative modules for this scenario.
Quality very high
Weight 1
Topology
component(object.storage)host 1(minio.server)host 2(docker.engine)host 3(local.machine)hosthosthost

Rule #47

Attribute Value
Number 47
Rules object.storage::compose@minio.server->docker.engine->local.machine
Scenario object.storage@minio.server->docker.engine->local.machine
Component object.storage
Technology compose
Hosting minio.server -> docker.engine -> local.machine
Reason One-time use docker container ("fake Kubernetes job") with imperative parts, while other technologies provide declarative modules.
Quality very low
Weight 0
Topology
component(object.storage)host 1(minio.server)host 2(docker.engine)host 3(local.machine)hosthosthost

Rule #48

Attribute Value
Number 48
Rules object.storage::terraform@minio.server->docker.engine->local.machine
Scenario object.storage@minio.server->docker.engine->local.machine
Component object.storage
Technology terraform
Hosting minio.server -> docker.engine -> local.machine
Reason The object storage is hosted on a MinIO server on a Docker engine on a local machine. Ansible and Terraform offer declarative modules for this scenario.
Quality very high
Weight 1
Topology
component(object.storage)host 1(minio.server)host 2(docker.engine)host 3(local.machine)hosthosthost

Rule #49

Attribute Value
Number 49
Rules object.storage::ansible@minio.server->docker.engine->remote.machine
Scenario object.storage@minio.server->docker.engine->remote.machine
Component object.storage
Technology ansible
Hosting minio.server -> docker.engine -> remote.machine
Reason The object storage is hosted on a MinIO server on a Docker engine on a remote machine. Ansible and Terraform offer declarative modules for this scenario. However, in contrast to Terraform, Ansible provides native features to access the MySQL DBMS using SSH.
Quality very high
Weight 1
Topology
component(object.storage)host 1(minio.server)host 2(docker.engine)host 3(remote.machine)hosthosthost

Rule #50

Attribute Value
Number 50
Rules object.storage::compose@minio.server->docker.engine->remote.machine
Scenario object.storage@minio.server->docker.engine->remote.machine
Component object.storage
Technology compose
Hosting minio.server -> docker.engine -> remote.machine
Reason One-time use docker container ("fake Kubernetes job") with imperative parts, while other technologies provide declarative modules.
Quality very low
Weight 0
Topology
component(object.storage)host 1(minio.server)host 2(docker.engine)host 3(remote.machine)hosthosthost

Rule #51

Attribute Value
Number 51
Rules object.storage::terraform@minio.server->docker.engine->remote.machine
Scenario object.storage@minio.server->docker.engine->remote.machine
Component object.storage
Technology terraform
Hosting minio.server -> docker.engine -> remote.machine
Quality high
Weight 0.75
Topology
component(object.storage)host 1(minio.server)host 2(docker.engine)host 3(remote.machine)hosthosthost

Rule #52

Attribute Value
Number 52
Rules object.storage::ansible@minio.server->kubernetes.cluster
Scenario object.storage@minio.server->kubernetes.cluster
Component object.storage
Technology ansible
Hosting minio.server -> kubernetes.cluster
Reason The object storage is hosted on a MinIO server on a Kubernetes cluster. Ansible and Terraform offer declarative modules for this scenario. However, in contrast to Terraform, Ansible provides better features to access the MinIO server within the Kubernetes cluster.
Quality very high
Weight 1
Topology
component(object.storage)host 1(minio.server)host 2(kubernetes.cluster)hosthost

Rule #53

Attribute Value
Number 53
Rules object.storage::kubernetes@minio.server->kubernetes.cluster
Scenario object.storage@minio.server->kubernetes.cluster
Component object.storage
Technology kubernetes
Hosting minio.server -> kubernetes.cluster
Reason Kubernetes Job with imperative parts, while declarative other technologies provide declarative modules
Quality very low
Weight 0
Topology
component(object.storage)host 1(minio.server)host 2(kubernetes.cluster)hosthost

Rule #54

Attribute Value
Number 54
Rules object.storage::terraform@minio.server->kubernetes.cluster
Scenario object.storage@minio.server->kubernetes.cluster
Component object.storage
Technology terraform
Hosting minio.server -> kubernetes.cluster
Quality low
Weight 0.25
Topology
component(object.storage)host 1(minio.server)host 2(kubernetes.cluster)hosthost

Rule #55

Attribute Value
Number 55
Rules redis.server#cache.image::ansible@docker.engine->local.machine
Scenario redis.server#cache.image@docker.engine->local.machine
Component redis.server
Artifact cache.image
Technology ansible
Hosting docker.engine -> local.machine
Quality medium
Weight 0.5
Topology
component(redis.server)artifact(cache.image)host 1(docker.engine)host 2(local.machine)hosthost

Rule #56

Attribute Value
Number 56
Rules redis.server#cache.image::compose@docker.engine->local.machine
Scenario redis.server#cache.image@docker.engine->local.machine
Component redis.server
Artifact cache.image
Technology compose
Hosting docker.engine -> local.machine
Reason The redis server is hosted on a Docker engine on a local machine. Docker Compose is natively integrated into the Docker engine.
Quality very high
Weight 1
Topology
component(redis.server)artifact(cache.image)host 1(docker.engine)host 2(local.machine)hosthost

Rule #57

Attribute Value
Number 57
Rules redis.server#cache.image::terraform@docker.engine->local.machine
Scenario redis.server#cache.image@docker.engine->local.machine
Component redis.server
Artifact cache.image
Technology terraform
Hosting docker.engine -> local.machine
Quality medium
Weight 0.5
Topology
component(redis.server)artifact(cache.image)host 1(docker.engine)host 2(local.machine)hosthost

Rule #58

Attribute Value
Number 58
Rules redis.server#cache.image::ansible@docker.engine->remote.machine
Scenario redis.server#cache.image@docker.engine->remote.machine
Component redis.server
Artifact cache.image
Technology ansible
Hosting docker.engine -> remote.machine
Quality medium
Weight 0.5
Topology
component(redis.server)artifact(cache.image)host 1(docker.engine)host 2(remote.machine)hosthost

Rule #59

Attribute Value
Number 59
Rules redis.server#cache.image::compose@docker.engine->remote.machine
Scenario redis.server#cache.image@docker.engine->remote.machine
Component redis.server
Artifact cache.image
Technology compose
Hosting docker.engine -> remote.machine
Reason The redis server is hosted on a Docker engine on a remote machine. Docker Compose is natively integrated into the Docker engine.
Quality very high
Weight 1
Topology
component(redis.server)artifact(cache.image)host 1(docker.engine)host 2(remote.machine)hosthost

Rule #60

Attribute Value
Number 60
Rules redis.server#cache.image::terraform@docker.engine->remote.machine
Scenario redis.server#cache.image@docker.engine->remote.machine
Component redis.server
Artifact cache.image
Technology terraform
Hosting docker.engine -> remote.machine
Quality medium
Weight 0.5
Topology
component(redis.server)artifact(cache.image)host 1(docker.engine)host 2(remote.machine)hosthost

Rule #61

Attribute Value
Number 61
Rules redis.server#cache.image::ansible@gcp.memorystore
Scenario redis.server#cache.image@gcp.memorystore
Component redis.server
Artifact cache.image
Technology ansible
Hosting gcp.memorystore
Quality very low
Weight 0
Topology
component(redis.server)artifact(cache.image)host 1(gcp.memorystore)host

Rule #62

Attribute Value
Number 62
Rules redis.server#cache.image::terraform@gcp.memorystore
Scenario redis.server#cache.image@gcp.memorystore
Component redis.server
Artifact cache.image
Technology terraform
Hosting gcp.memorystore
Reason The redis server is hosted on GCP Memorystore. Terraform provides an official provider for GCP. In contrast, the corresponding Ansible module is not maintained and violates community standards.
Quality very high
Weight 1
Topology
component(redis.server)artifact(cache.image)host 1(gcp.memorystore)host

Rule #63

Attribute Value
Number 63
Rules redis.server#cache.image::ansible@kubernetes.cluster
Scenario redis.server#cache.image@kubernetes.cluster
Component redis.server
Artifact cache.image
Technology ansible
Hosting kubernetes.cluster
Quality medium
Weight 0.5
Topology
component(redis.server)artifact(cache.image)host 1(kubernetes.cluster)host

Rule #64

Attribute Value
Number 64
Rules redis.server#cache.image::kubernetes@kubernetes.cluster
Scenario redis.server#cache.image@kubernetes.cluster
Component redis.server
Artifact cache.image
Technology kubernetes
Hosting kubernetes.cluster
Reason The redis server is hosted on a Kubernetes cluster. Kubernetes provides its own natively integrated deployment technology.
Quality very high
Weight 1
Topology
component(redis.server)artifact(cache.image)host 1(kubernetes.cluster)host

Rule #65

Attribute Value
Number 65
Rules redis.server#cache.image::terraform@kubernetes.cluster
Scenario redis.server#cache.image@kubernetes.cluster
Component redis.server
Artifact cache.image
Technology terraform
Hosting kubernetes.cluster
Quality medium
Weight 0.5
Topology
component(redis.server)artifact(cache.image)host 1(kubernetes.cluster)host

Rule #66

Attribute Value
Number 66
Rules service.component#docker.image::ansible@docker.engine->local.machine
Scenario service.component#docker.image@docker.engine->local.machine
Component service.component
Artifact docker.image
Technology ansible
Hosting docker.engine -> local.machine
Quality medium
Weight 0.5
Topology
component(service.component)artifact(docker.image)host 1(docker.engine)host 2(local.machine)hosthost

Rule #67

Attribute Value
Number 67
Rules service.component#docker.image::compose@docker.engine->local.machine
Scenario service.component#docker.image@docker.engine->local.machine
Component service.component
Artifact docker.image
Technology compose
Hosting docker.engine -> local.machine
Reason The service component is hosted on a Docker engine on a local machine. Docker Compose is natively integrated into the Docker engine.
Quality very high
Weight 1
Topology
component(service.component)artifact(docker.image)host 1(docker.engine)host 2(local.machine)hosthost

Rule #68

Attribute Value
Number 68
Rules service.component#docker.image::terraform@docker.engine->local.machine
Scenario service.component#docker.image@docker.engine->local.machine
Component service.component
Artifact docker.image
Technology terraform
Hosting docker.engine -> local.machine
Quality medium
Weight 0.5
Topology
component(service.component)artifact(docker.image)host 1(docker.engine)host 2(local.machine)hosthost

Rule #69

Attribute Value
Number 69
Rules service.component#docker.image::ansible@docker.engine->remote.machine
Scenario service.component#docker.image@docker.engine->remote.machine
Component service.component
Artifact docker.image
Technology ansible
Hosting docker.engine -> remote.machine
Quality medium
Weight 0.5
Topology
component(service.component)artifact(docker.image)host 1(docker.engine)host 2(remote.machine)hosthost

Rule #70

Attribute Value
Number 70
Rules service.component#docker.image::compose@docker.engine->remote.machine
Scenario service.component#docker.image@docker.engine->remote.machine
Component service.component
Artifact docker.image
Technology compose
Hosting docker.engine -> remote.machine
Reason The service component is hosted on a Docker engine on a remote machine. Docker Compose is natively integrated into the Docker engine.
Quality very high
Weight 1
Topology
component(service.component)artifact(docker.image)host 1(docker.engine)host 2(remote.machine)hosthost

Rule #71

Attribute Value
Number 71
Rules service.component#docker.image::terraform@docker.engine->remote.machine
Scenario service.component#docker.image@docker.engine->remote.machine
Component service.component
Artifact docker.image
Technology terraform
Hosting docker.engine -> remote.machine
Quality medium
Weight 0.5
Topology
component(service.component)artifact(docker.image)host 1(docker.engine)host 2(remote.machine)hosthost

Rule #72

Attribute Value
Number 72
Rules service.component#docker.image::ansible@gcp.cloudrun
Scenario service.component#docker.image@gcp.cloudrun
Component service.component
Artifact docker.image
Technology ansible
Hosting gcp.cloudrun
Quality very low
Weight 0
Topology
component(service.component)artifact(docker.image)host 1(gcp.cloudrun)host

Rule #73

Attribute Value
Number 73
Rules service.component#docker.image::terraform@gcp.cloudrun
Scenario service.component#docker.image@gcp.cloudrun
Component service.component
Artifact docker.image
Technology terraform
Hosting gcp.cloudrun
Reason The service component is hosted on GCP CloudRun. Terraform provides an official provider for GCP. In contrast, the corresponding Ansible module does not provide resources for GCP CloudRun.
Quality very high
Weight 1
Topology
component(service.component)artifact(docker.image)host 1(gcp.cloudrun)host

Rule #74

Attribute Value
Number 74
Rules service.component#docker.image::ansible@kubernetes.cluster
Scenario service.component#docker.image@kubernetes.cluster
Component service.component
Artifact docker.image
Technology ansible
Hosting kubernetes.cluster
Quality medium
Weight 0.5
Topology
component(service.component)artifact(docker.image)host 1(kubernetes.cluster)host

Rule #75

Attribute Value
Number 75
Rules service.component#docker.image::kubernetes@kubernetes.cluster
Scenario service.component#docker.image@kubernetes.cluster
Component service.component
Artifact docker.image
Technology kubernetes
Hosting kubernetes.cluster
Reason The service component is hosted on a Kubernetes cluster. Kubernetes provides its own natively integrated deployment technology.
Quality very high
Weight 1
Topology
component(service.component)artifact(docker.image)host 1(kubernetes.cluster)host

Rule #76

Attribute Value
Number 76
Rules service.component#docker.image::terraform@kubernetes.cluster
Scenario service.component#docker.image@kubernetes.cluster
Component service.component
Artifact docker.image
Technology terraform
Hosting kubernetes.cluster
Quality medium
Weight 0.5
Topology
component(service.component)artifact(docker.image)host 1(kubernetes.cluster)host

Rule #77

Attribute Value
Number 77
Rules service.component#tar.archive::ansible@*->local.machine
Scenario service.component#tar.archive@*->local.machine
Component service.component
Artifact tar.archive
Technology ansible
Hosting * -> local.machine
Reason The service component is hosted on a local machine. Ansible is specialized for installing software components on local targets, while Terraform discourages from being used to manage such scenarios.
Quality very high
Weight 1
Topology
component(service.component)artifact(tar.archive)...host 2(local.machine)hosthost

Rule #78

Attribute Value
Number 78
Rules service.component#tar.archive::terraform@*->local.machine
Scenario service.component#tar.archive@*->local.machine
Component service.component
Artifact tar.archive
Technology terraform
Hosting * -> local.machine
Quality very low
Weight 0
Topology
component(service.component)artifact(tar.archive)...host 2(local.machine)hosthost

Rule #79

Attribute Value
Number 79
Rules service.component#tar.archive::ansible@*->remote.machine
Scenario service.component#tar.archive@*->remote.machine
Component service.component
Artifact tar.archive
Technology ansible
Hosting * -> remote.machine
Reason The service component is hosted on a remote machine. Ansible is specialized for installing software components on remote targets, while Terraform discourages from being used to manage such scenarios.
Quality very high
Weight 1
Topology
component(service.component)artifact(tar.archive)...host 2(remote.machine)hosthost

Rule #80

Attribute Value
Number 80
Rules service.component#tar.archive::terraform@*->remote.machine
Scenario service.component#tar.archive@*->remote.machine
Component service.component
Artifact tar.archive
Technology terraform
Hosting * -> remote.machine
Quality very low
Weight 0
Topology
component(service.component)artifact(tar.archive)...host 2(remote.machine)hosthost

Rule #81

Attribute Value
Number 81
Rules service.component#zip.archive::ansible@*->local.machine
Scenario service.component#zip.archive@*->local.machine
Component service.component
Artifact zip.archive
Technology ansible
Hosting * -> local.machine
Reason The service component is hosted on a local machine. Ansible is specialized for installing software components on local targets, while Terraform discourages from being used to manage such scenarios.
Quality very high
Weight 1
Topology
component(service.component)artifact(zip.archive)...host 2(local.machine)hosthost

Rule #82

Attribute Value
Number 82
Rules service.component#zip.archive::terraform@*->local.machine
Scenario service.component#zip.archive@*->local.machine
Component service.component
Artifact zip.archive
Technology terraform
Hosting * -> local.machine
Quality very low
Weight 0
Topology
component(service.component)artifact(zip.archive)...host 2(local.machine)hosthost

Rule #83

Attribute Value
Number 83
Rules service.component#zip.archive::ansible@*->remote.machine
Scenario service.component#zip.archive@*->remote.machine
Component service.component
Artifact zip.archive
Technology ansible
Hosting * -> remote.machine
Reason The service component is hosted on a remote machine. Ansible is specialized for installing software components on remote targets, while Terraform discourages from being used to manage such scenarios.
Quality very high
Weight 1
Topology
component(service.component)artifact(zip.archive)...host 2(remote.machine)hosthost

Rule #84

Attribute Value
Number 84
Rules service.component#zip.archive::terraform@*->remote.machine
Scenario service.component#zip.archive@*->remote.machine
Component service.component
Artifact zip.archive
Technology terraform
Hosting * -> remote.machine
Quality very low
Weight 0
Topology
component(service.component)artifact(zip.archive)...host 2(remote.machine)hosthost

Rule #85

Attribute Value
Number 85
Rules service.component#zip.archive::ansible@gcp.appengine
Scenario service.component#zip.archive@gcp.appengine
Component service.component
Artifact zip.archive
Technology ansible
Hosting gcp.appengine
Quality very low
Weight 0
Topology
component(service.component)artifact(zip.archive)host 1(gcp.appengine)host

Rule #86

Attribute Value
Number 86
Rules service.component#zip.archive::terraform@gcp.appengine
Scenario service.component#zip.archive@gcp.appengine
Component service.component
Artifact zip.archive
Technology terraform
Hosting gcp.appengine
Reason The service component is hosted on GCP AppEngine. Terraform provides an official provider for GCP. In contrast, the corresponding Ansible module is not maintained and violates community standards.
Quality very high
Weight 1
Topology
component(service.component)artifact(zip.archive)host 1(gcp.appengine)host

Rule #87

Attribute Value
Number 87
Rules software.component#apt.package::ansible@*->local.machine
Scenario software.component#apt.package@*->local.machine
Component software.component
Artifact apt.package
Technology ansible
Hosting * -> local.machine
Reason The software component is hosted on a local machine. Ansible is specialized for installing software components on local targets, while Terraform discourages from being used to manage such scenarios.
Quality very high
Weight 1
Topology
component(software.component)artifact(apt.package)...host 2(local.machine)hosthost

Rule #88

Attribute Value
Number 88
Rules software.component#apt.package::terraform@*->local.machine
Scenario software.component#apt.package@*->local.machine
Component software.component
Artifact apt.package
Technology terraform
Hosting * -> local.machine
Quality very low
Weight 0
Topology
component(software.component)artifact(apt.package)...host 2(local.machine)hosthost

Rule #89

Attribute Value
Number 89
Rules software.component#apt.package::ansible@*->remote.machine
Scenario software.component#apt.package@*->remote.machine
Component software.component
Artifact apt.package
Technology ansible
Hosting * -> remote.machine
Reason The software component is hosted on a remote machine. Ansible is specialized for installing software components on remote targets, while Terraform discourages from being used to manage such scenarios.
Quality very high
Weight 1
Topology
component(software.component)artifact(apt.package)...host 2(remote.machine)hosthost

Rule #90

Attribute Value
Number 90
Rules software.component#apt.package::terraform@*->remote.machine
Scenario software.component#apt.package@*->remote.machine
Component software.component
Artifact apt.package
Technology terraform
Hosting * -> remote.machine
Quality very low
Weight 0
Topology
component(software.component)artifact(apt.package)...host 2(remote.machine)hosthost

Rule #91

Attribute Value
Number 91
Rules software.component#tar.archive::ansible@*->local.machine
Scenario software.component#tar.archive@*->local.machine
Component software.component
Artifact tar.archive
Operations create, delete
Technology ansible
Hosting * -> local.machine
Reason The software component is hosted on a local machine. Ansible is specialized for installing software components on local targets, while Terraform discourages from being used to manage such scenarios.
Quality very high
Weight 1
Topology
component(software.component)artifact(tar.archive)createdelete...host 2(local.machine)hosthost

Rule #92

Attribute Value
Number 92
Rules software.component#tar.archive::terraform@*->local.machine
Scenario software.component#tar.archive@*->local.machine
Component software.component
Artifact tar.archive
Operations create, delete
Technology terraform
Hosting * -> local.machine
Quality very low
Weight 0
Topology
component(software.component)artifact(tar.archive)createdelete...host 2(local.machine)hosthost

Rule #93

Attribute Value
Number 93
Rules software.component#tar.archive::ansible@*->remote.machine
Scenario software.component#tar.archive@*->remote.machine
Component software.component
Artifact tar.archive
Operations create, delete
Technology ansible
Hosting * -> remote.machine
Reason The software component is hosted on a remote machine. Ansible is specialized for installing software components on remote targets, while Terraform discourages from being used to manage such scenarios.
Quality very high
Weight 1
Topology
component(software.component)artifact(tar.archive)createdelete...host 2(remote.machine)hosthost

Rule #94

Attribute Value
Number 94
Rules software.component#tar.archive::terraform@*->remote.machine
Scenario software.component#tar.archive@*->remote.machine
Component software.component
Artifact tar.archive
Operations create, delete
Technology terraform
Hosting * -> remote.machine
Quality very low
Weight 0
Topology
component(software.component)artifact(tar.archive)createdelete...host 2(remote.machine)hosthost

Rule #95

Attribute Value
Number 95
Rules software.component#zip.archive::ansible@*->local.machine
Scenario software.component#zip.archive@*->local.machine
Component software.component
Artifact zip.archive
Operations create, delete
Technology ansible
Hosting * -> local.machine
Reason The software component is hosted on a local machine. Ansible is specialized for installing software components on local targets, while Terraform discourages from being used to manage such scenarios.
Quality very high
Weight 1
Topology
component(software.component)artifact(zip.archive)createdelete...host 2(local.machine)hosthost

Rule #96

Attribute Value
Number 96
Rules software.component#zip.archive::terraform@*->local.machine
Scenario software.component#zip.archive@*->local.machine
Component software.component
Artifact zip.archive
Operations create, delete
Technology terraform
Hosting * -> local.machine
Quality very low
Weight 0
Topology
component(software.component)artifact(zip.archive)createdelete...host 2(local.machine)hosthost

Rule #97

Attribute Value
Number 97
Rules software.component#zip.archive::ansible@*->remote.machine
Scenario software.component#zip.archive@*->remote.machine
Component software.component
Artifact zip.archive
Operations create, delete
Technology ansible
Hosting * -> remote.machine
Reason The software component is hosted on a remote machine. Ansible is specialized for installing software components on remote targets, while Terraform discourages from being used to manage such scenarios.
Quality very high
Weight 1
Topology
component(software.component)artifact(zip.archive)createdelete...host 2(remote.machine)hosthost

Rule #98

Attribute Value
Number 98
Rules software.component#zip.archive::terraform@*->remote.machine
Scenario software.component#zip.archive@*->remote.machine
Component software.component
Artifact zip.archive
Operations create, delete
Technology terraform
Hosting * -> remote.machine
Quality very low
Weight 0
Topology
component(software.component)artifact(zip.archive)createdelete...host 2(remote.machine)hosthost

Rule #99

Attribute Value
Number 99
Rules virtual.machine#machine.image::ansible@openstack.provider
Scenario virtual.machine#machine.image@openstack.provider
Component virtual.machine
Artifact machine.image
Technology ansible
Hosting openstack.provider
Quality medium
Weight 0.5
Topology
component(virtual.machine)artifact(machine.image)host 1(openstack.provider)host

Rule #100

Attribute Value
Number 100
Rules virtual.machine#machine.image::terraform@openstack.provider
Scenario virtual.machine#machine.image@openstack.provider
Component virtual.machine
Artifact machine.image
Technology terraform
Hosting openstack.provider
Reason The virtual machine is hosted on OpenStack. Terraform is specialized in provisioning infrastructure, while Ansible is specialized for managing software on such infrastructure.
Quality very high
Weight 1
Topology
component(virtual.machine)artifact(machine.image)host 1(openstack.provider)host

Appendix B "YAML"

This appendix contains the deployment qualities as YAML. The rules are also available as download.

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
- technology: ansible
  component: docker.engine
  hosting:
      - local.machine
  weight: 1
  reason: The Docker engine is hosted on a local machine. Ansible is specialized for installing software components on local targets, while Terraform discourages from being used to manage such scenarios.
- technology: terraform
  component: docker.engine
  hosting:
      - local.machine
  weight: 0
- technology: ansible
  component: docker.engine
  hosting:
      - remote.machine
  weight: 1
  reason: The Docker engine is hosted on a remote machine. Ansible is specialized for installing software components on remote targets, while Terraform discourages from being used to manage such scenarios.
- technology: terraform
  component: docker.engine
  hosting:
      - remote.machine
  weight: 0
- technology: ansible
  component: gcp.service
  hosting: []
  weight: 0
- technology: terraform
  component: gcp.service
  hosting: []
  weight: 1
  reason: The GCP service is hosted on GCP. Terraform provides an official provider for GCP. In contrast, the corresponding Ansible module is not maintained and violates community standards.
- technology: ansible
  component: ingress
  hosting:
      - kubernetes.cluster
  weight: 0.5
- technology: kubernetes
  component: ingress
  hosting:
      - kubernetes.cluster
  weight: 1
  reason: The ingress is hosted on a Kubernetes cluster. Kubernetes provides its own natively integrated deployment technology.
- technology: terraform
  component: ingress
  hosting:
      - kubernetes.cluster
  weight: 0.5
- technology: ansible
  component: ingress
  hosting:
      - local.machine
  weight: 1
  reason: The ingress is hosted on a local machine. Ansible is specialized for installing software components on local targets, while Terraform discourages from being used to manage such scenarios.
- technology: terraform
  component: ingress
  hosting:
      - local.machine
  weight: 0
- technology: ansible
  component: ingress
  hosting:
      - remote.machine
  weight: 1
  reason: The ingress is hosted on a remote machine. Ansible is specialized for installing software components on remote targets, while Terraform discourages from being used to manage such scenarios.
- technology: terraform
  component: ingress
  hosting:
      - remote.machine
  weight: 0
- technology: ansible
  component: mysql.database
  hosting:
      - mysql.dbms
      - docker.engine
      - local.machine
  weight: 1
  reason: The MySQL database is hosted on a MySQL DBMS on a Docker engine on a local machine. Ansible and Terraform offer declarative modules for managing a MySQL database.
- technology: compose
  component: mysql.database
  hosting:
      - mysql.dbms
      - docker.engine
      - local.machine
  weight: 0
  reason: One-time use docker container ("fake Kubernetes job") with imperative parts, while other technologies provide declarative modules.
- technology: terraform
  component: mysql.database
  hosting:
      - mysql.dbms
      - docker.engine
      - local.machine
  weight: 1
  reason: The MySQL database is hosted on a MySQL DBMS on a Docker engine on a local machine. Ansible and Terraform offer declarative modules for managing a MySQL database.
- technology: ansible
  component: mysql.database
  hosting:
      - mysql.dbms
      - docker.engine
      - remote.machine
  weight: 1
  reason: The MySQL database is hosted on a MySQL DBMS on a Docker engine on a remote machine. Ansible and Terraform offer declarative modules for managing a MySQL database. However, in contrast to Terraform, Ansible provides native features to access the MySQL DBMS using SSH.
- technology: compose
  component: mysql.database
  hosting:
      - mysql.dbms
      - docker.engine
      - remote.machine
  weight: 0
  reason: One-time use docker container ("fake Kubernetes job") with imperative parts, while other technologies provide declarative modules.
- technology: terraform
  component: mysql.database
  hosting:
      - mysql.dbms
      - docker.engine
      - remote.machine
  weight: 0.75
- technology: ansible
  component: mysql.database
  hosting:
      - mysql.dbms
      - gcp.cloudsql
  weight: 0
- technology: terraform
  component: mysql.database
  hosting:
      - mysql.dbms
      - gcp.cloudsql
  weight: 1
  reason: The MySQL database is hosted on a MySQL DBMS on GCP CloudSQL. Terraform provides an official provider for GCP. In contrast, the corresponding Ansible module is not maintained and violates community standards.
- technology: ansible
  component: mysql.database
  hosting:
      - mysql.dbms
      - kubernetes.cluster
  weight: 1
  reason: The MySQL database is hosted on a MySQL DBMS on a Kubernetes cluster. Ansible and Terraform offer declarative modules for managing a MySQL database. However, in contrast to Terraform, Ansible provides better features to access the MySQL DBMS within the Kubernetes cluster.
- technology: kubernetes
  component: mysql.database
  hosting:
      - mysql.dbms
      - kubernetes.cluster
  weight: 0
  reason: Kubernetes Job with imperative parts, while declarative other technologies provide declarative modules
- technology: terraform
  component: mysql.database
  hosting:
      - mysql.dbms
      - kubernetes.cluster
  weight: 0.25
- technology: ansible
  component: mysql.database
  hosting:
      - mysql.dbms
      - local.machine
  weight: 1
  reason: The MySQL database is hosted on a MySQL DBMS on a local machine. Ansible and Terraform offer declarative modules for managing a MySQL database.
- technology: terraform
  component: mysql.database
  hosting:
      - mysql.dbms
      - local.machine
  weight: 1
  reason: The MySQL database is hosted on a MySQL DBMS on a local machine. Ansible and Terraform offer declarative modules for managing a MySQL database.
- technology: ansible
  component: mysql.database
  hosting:
      - mysql.dbms
      - remote.machine
  weight: 1
  reason: The MySQL database is hosted on a MySQL DBMS on a remote machine. Ansible is Terraform offer declarative modules for managing a MySQL database. However, in contrast to Terraform, Ansible provides native features to access the MySQL DBMS using SSH.
- technology: terraform
  component: mysql.database
  hosting:
      - mysql.dbms
      - remote.machine
  weight: 0.5
- technology: ansible
  component: mysql.dbms
  artifact: dbms.image
  hosting:
      - docker.engine
      - local.machine
  weight: 0.5
- technology: compose
  component: mysql.dbms
  artifact: dbms.image
  hosting:
      - docker.engine
      - local.machine
  weight: 1
  reason: The MySQL DBMS is hosted on a Docker engine on a local machine. Docker Compose is natively integrated into the Docker engine.
- technology: terraform
  component: mysql.dbms
  artifact: dbms.image
  hosting:
      - docker.engine
      - local.machine
  weight: 0.5
- technology: ansible
  component: mysql.dbms
  artifact: dbms.image
  hosting:
      - docker.engine
      - remote.machine
  weight: 0.5
- technology: compose
  component: mysql.dbms
  artifact: dbms.image
  hosting:
      - docker.engine
      - remote.machine
  weight: 1
  reason: The MySQL DBMS is hosted on a Docker engine on a remote machine. Docker Compose is natively integrated into the Docker engine.
- technology: terraform
  component: mysql.dbms
  artifact: dbms.image
  hosting:
      - docker.engine
      - remote.machine
  weight: 0.5
- technology: ansible
  component: mysql.dbms
  artifact: dbms.image
  hosting:
      - gcp.cloudsql
  weight: 0
- technology: terraform
  component: mysql.dbms
  artifact: dbms.image
  hosting:
      - gcp.cloudsql
  weight: 1
  reason: The MySQL DBMS is hosted on GCP CloudSQL. Terraform provides an official provider for GCP. In contrast, the corresponding Ansible module is not maintained and violates community standards.
- technology: ansible
  component: mysql.dbms
  artifact: dbms.image
  hosting:
      - kubernetes.cluster
  weight: 0.5
- technology: kubernetes
  component: mysql.dbms
  artifact: dbms.image
  hosting:
      - kubernetes.cluster
  weight: 1
  reason: The MySQL DBMS is hosted on a Kubernetes cluster. Kubernetes provides its own natively integrated deployment technology.
- technology: terraform
  component: mysql.dbms
  artifact: dbms.image
  hosting:
      - kubernetes.cluster
  weight: 0.5
- technology: ansible
  component: mysql.dbms
  artifact: dbms.image
  hosting:
      - local.machine
  weight: 1
  reason: The MySQL DBMS is hosted on a local machine. Ansible is specialized for installing software components on local targets, while Terraform discourages from being used to manage such scenarios.
- technology: terraform
  component: mysql.dbms
  artifact: dbms.image
  hosting:
      - local.machine
  weight: 0
- technology: ansible
  component: mysql.dbms
  artifact: dbms.image
  hosting:
      - remote.machine
  weight: 1
  reason: The MySQL DBMS is hosted on a remote machine. Ansible is specialized for installing software components on remote targets, while Terraform discourages from being used to manage such scenarios.
- technology: terraform
  component: mysql.dbms
  artifact: dbms.image
  hosting:
      - remote.machine
  weight: 0
- technology: ansible
  component: object.storage
  hosting:
      - gcp.cloudstorage
  weight: 0
- technology: terraform
  component: object.storage
  hosting:
      - gcp.cloudstorage
  weight: 1
  reason: The object storage is hosted on GCP CloudStorage. Terraform provides an official provider for GCP. In contrast, the corresponding Ansible module is not maintained and violates community standards.
- technology: ansible
  component: object.storage
  hosting:
      - minio.server
      - docker.engine
      - local.machine
  weight: 1
  reason: The object storage is hosted on a MinIO server on a Docker engine on a local machine. Ansible and Terraform offer declarative modules for this scenario.
- technology: compose
  component: object.storage
  hosting:
      - minio.server
      - docker.engine
      - local.machine
  weight: 0
  reason: One-time use docker container ("fake Kubernetes job") with imperative parts, while other technologies provide declarative modules.
- technology: terraform
  component: object.storage
  hosting:
      - minio.server
      - docker.engine
      - local.machine
  weight: 1
  reason: The object storage is hosted on a MinIO server on a Docker engine on a local machine. Ansible and Terraform offer declarative modules for this scenario.
- technology: ansible
  component: object.storage
  hosting:
      - minio.server
      - docker.engine
      - remote.machine
  weight: 1
  reason: The object storage is hosted on a MinIO server on a Docker engine on a remote machine. Ansible and Terraform offer declarative modules for this scenario. However, in contrast to Terraform, Ansible provides native features to access the MySQL DBMS using SSH.
- technology: compose
  component: object.storage
  hosting:
      - minio.server
      - docker.engine
      - remote.machine
  weight: 0
  reason: One-time use docker container ("fake Kubernetes job") with imperative parts, while other technologies provide declarative modules.
- technology: terraform
  component: object.storage
  hosting:
      - minio.server
      - docker.engine
      - remote.machine
  weight: 0.75
- technology: ansible
  component: object.storage
  hosting:
      - minio.server
      - kubernetes.cluster
  weight: 1
  reason: The object storage is hosted on a MinIO server on a Kubernetes cluster. Ansible and Terraform offer declarative modules for this scenario. However, in contrast to Terraform, Ansible provides better features to access the MinIO server within the Kubernetes cluster.
- technology: kubernetes
  component: object.storage
  hosting:
      - minio.server
      - kubernetes.cluster
  weight: 0
  reason: Kubernetes Job with imperative parts, while declarative other technologies provide declarative modules
- technology: terraform
  component: object.storage
  hosting:
      - minio.server
      - kubernetes.cluster
  weight: 0.25
- technology: ansible
  component: redis.server
  artifact: cache.image
  hosting:
      - docker.engine
      - local.machine
  weight: 0.5
- technology: compose
  component: redis.server
  artifact: cache.image
  hosting:
      - docker.engine
      - local.machine
  weight: 1
  reason: The redis server is hosted on a Docker engine on a local machine. Docker Compose is natively integrated into the Docker engine.
- technology: terraform
  component: redis.server
  artifact: cache.image
  hosting:
      - docker.engine
      - local.machine
  weight: 0.5
- technology: ansible
  component: redis.server
  artifact: cache.image
  hosting:
      - docker.engine
      - remote.machine
  weight: 0.5
- technology: compose
  component: redis.server
  artifact: cache.image
  hosting:
      - docker.engine
      - remote.machine
  weight: 1
  reason: The redis server is hosted on a Docker engine on a remote machine. Docker Compose is natively integrated into the Docker engine.
- technology: terraform
  component: redis.server
  artifact: cache.image
  hosting:
      - docker.engine
      - remote.machine
  weight: 0.5
- technology: ansible
  component: redis.server
  artifact: cache.image
  hosting:
      - gcp.memorystore
  weight: 0
- technology: terraform
  component: redis.server
  artifact: cache.image
  hosting:
      - gcp.memorystore
  weight: 1
  reason: The redis server is hosted on GCP Memorystore. Terraform provides an official provider for GCP. In contrast, the corresponding Ansible module is not maintained and violates community standards.
- technology: ansible
  component: redis.server
  artifact: cache.image
  hosting:
      - kubernetes.cluster
  weight: 0.5
- technology: kubernetes
  component: redis.server
  artifact: cache.image
  hosting:
      - kubernetes.cluster
  weight: 1
  reason: The redis server is hosted on a Kubernetes cluster. Kubernetes provides its own natively integrated deployment technology.
- technology: terraform
  component: redis.server
  artifact: cache.image
  hosting:
      - kubernetes.cluster
  weight: 0.5
- technology: ansible
  component: service.component
  artifact: docker.image
  hosting:
      - docker.engine
      - local.machine
  weight: 0.5
- technology: compose
  component: service.component
  artifact: docker.image
  hosting:
      - docker.engine
      - local.machine
  weight: 1
  reason: The service component is hosted on a Docker engine on a local machine. Docker Compose is natively integrated into the Docker engine.
- technology: terraform
  component: service.component
  artifact: docker.image
  hosting:
      - docker.engine
      - local.machine
  weight: 0.5
- technology: ansible
  component: service.component
  artifact: docker.image
  hosting:
      - docker.engine
      - remote.machine
  weight: 0.5
- technology: compose
  component: service.component
  artifact: docker.image
  hosting:
      - docker.engine
      - remote.machine
  weight: 1
  reason: The service component is hosted on a Docker engine on a remote machine. Docker Compose is natively integrated into the Docker engine.
- technology: terraform
  component: service.component
  artifact: docker.image
  hosting:
      - docker.engine
      - remote.machine
  weight: 0.5
- technology: ansible
  component: service.component
  artifact: docker.image
  hosting:
      - gcp.cloudrun
  weight: 0
- technology: terraform
  component: service.component
  artifact: docker.image
  hosting:
      - gcp.cloudrun
  weight: 1
  reason: The service component is hosted on GCP CloudRun. Terraform provides an official provider for GCP. In contrast, the corresponding Ansible module does not provide resources for GCP CloudRun.
- technology: ansible
  component: service.component
  artifact: docker.image
  hosting:
      - kubernetes.cluster
  weight: 0.5
- technology: kubernetes
  component: service.component
  artifact: docker.image
  hosting:
      - kubernetes.cluster
  weight: 1
  reason: The service component is hosted on a Kubernetes cluster. Kubernetes provides its own natively integrated deployment technology.
- technology: terraform
  component: service.component
  artifact: docker.image
  hosting:
      - kubernetes.cluster
  weight: 0.5
- technology: ansible
  component: service.component
  artifact: tar.archive
  hosting:
      - '*'
      - local.machine
  weight: 1
  reason: The service component is hosted on a local machine. Ansible is specialized for installing software components on local targets, while Terraform discourages from being used to manage such scenarios.
- technology: terraform
  component: service.component
  artifact: tar.archive
  hosting:
      - '*'
      - local.machine
  weight: 0
- technology: ansible
  component: service.component
  artifact: tar.archive
  hosting:
      - '*'
      - remote.machine
  weight: 1
  reason: The service component is hosted on a remote machine. Ansible is specialized for installing software components on remote targets, while Terraform discourages from being used to manage such scenarios.
- technology: terraform
  component: service.component
  artifact: tar.archive
  hosting:
      - '*'
      - remote.machine
  weight: 0
- technology: ansible
  component: service.component
  artifact: zip.archive
  hosting:
      - '*'
      - local.machine
  weight: 1
  reason: The service component is hosted on a local machine. Ansible is specialized for installing software components on local targets, while Terraform discourages from being used to manage such scenarios.
- technology: terraform
  component: service.component
  artifact: zip.archive
  hosting:
      - '*'
      - local.machine
  weight: 0
- technology: ansible
  component: service.component
  artifact: zip.archive
  hosting:
      - '*'
      - remote.machine
  weight: 1
  reason: The service component is hosted on a remote machine. Ansible is specialized for installing software components on remote targets, while Terraform discourages from being used to manage such scenarios.
- technology: terraform
  component: service.component
  artifact: zip.archive
  hosting:
      - '*'
      - remote.machine
  weight: 0
- technology: ansible
  component: service.component
  artifact: zip.archive
  hosting:
      - gcp.appengine
  weight: 0
- technology: terraform
  component: service.component
  artifact: zip.archive
  hosting:
      - gcp.appengine
  weight: 1
  reason: The service component is hosted on GCP AppEngine. Terraform provides an official provider for GCP. In contrast, the corresponding Ansible module is not maintained and violates community standards.
- technology: ansible
  component: software.component
  artifact: apt.package
  hosting:
      - '*'
      - local.machine
  weight: 1
  reason: The software component is hosted on a local machine. Ansible is specialized for installing software components on local targets, while Terraform discourages from being used to manage such scenarios.
- technology: terraform
  component: software.component
  artifact: apt.package
  hosting:
      - '*'
      - local.machine
  weight: 0
- technology: ansible
  component: software.component
  artifact: apt.package
  hosting:
      - '*'
      - remote.machine
  weight: 1
  reason: The software component is hosted on a remote machine. Ansible is specialized for installing software components on remote targets, while Terraform discourages from being used to manage such scenarios.
- technology: terraform
  component: software.component
  artifact: apt.package
  hosting:
      - '*'
      - remote.machine
  weight: 0
- technology: ansible
  component: software.component
  artifact: tar.archive
  hosting:
      - '*'
      - local.machine
  weight: 1
  reason: The software component is hosted on a local machine. Ansible is specialized for installing software components on local targets, while Terraform discourages from being used to manage such scenarios.
  operations:
      - create
      - delete
- technology: terraform
  component: software.component
  artifact: tar.archive
  hosting:
      - '*'
      - local.machine
  weight: 0
  operations:
      - create
      - delete
- technology: ansible
  component: software.component
  artifact: tar.archive
  hosting:
      - '*'
      - remote.machine
  weight: 1
  reason: The software component is hosted on a remote machine. Ansible is specialized for installing software components on remote targets, while Terraform discourages from being used to manage such scenarios.
  operations:
      - create
      - delete
- technology: terraform
  component: software.component
  artifact: tar.archive
  hosting:
      - '*'
      - remote.machine
  weight: 0
  operations:
      - create
      - delete
- technology: ansible
  component: software.component
  artifact: zip.archive
  hosting:
      - '*'
      - local.machine
  weight: 1
  reason: The software component is hosted on a local machine. Ansible is specialized for installing software components on local targets, while Terraform discourages from being used to manage such scenarios.
  operations:
      - create
      - delete
- technology: terraform
  component: software.component
  artifact: zip.archive
  hosting:
      - '*'
      - local.machine
  weight: 0
  operations:
      - create
      - delete
- technology: ansible
  component: software.component
  artifact: zip.archive
  hosting:
      - '*'
      - remote.machine
  weight: 1
  reason: The software component is hosted on a remote machine. Ansible is specialized for installing software components on remote targets, while Terraform discourages from being used to manage such scenarios.
  operations:
      - create
      - delete
- technology: terraform
  component: software.component
  artifact: zip.archive
  hosting:
      - '*'
      - remote.machine
  weight: 0
  operations:
      - create
      - delete
- technology: ansible
  component: virtual.machine
  artifact: machine.image
  hosting:
      - openstack.provider
  weight: 0.5
- technology: terraform
  component: virtual.machine
  artifact: machine.image
  hosting:
      - openstack.provider
  weight: 1
  reason: The virtual machine is hosted on OpenStack. Terraform is specialized in provisioning infrastructure, while Ansible is specialized for managing software on such infrastructure.

Reference Implementation

We provide a reference implementation for this specification as part of OpenTOSCA Vintner. OpenTOSCA Vintner is a TOSCA preprocessing and management layer. The project is open-source, licensed under Apache-2.0, and publicly available at GitHub.

Acknowledgments

This specification is developed for the purpose of research by the Institute of Software Engineering (ISTE) and the Institute of Architecture of Application Systems (IAAS) of the University of Stuttgart, Germany. The development is partially funded by the German Federal Ministry for Economic Affairs and Climate Action (BMWK) as part of the Software-Defined Car (SofDCar) project (19S21002).

Correspondence

Please address all correspondence concerning this specification to Miles Stötzner <miles.stoetzner@iste.uni-stuttgart.de, https://miles.stoetzner.de>.

Disclaimer of Warranty

Unless required by applicable law or agreed to in writing, Licensor provides the Work (and each Contributor provides its Contributions) on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied, including, without limitation, any warranties or conditions of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A PARTICULAR PURPOSE. You are solely responsible for determining the appropriateness of using or redistributing the Work and assume any risks associated with Your exercise of permissions under this License.


Last update: July 3, 2025