Unfurl Cloud Standard Library Types Catalog 

This page documents all the supported TOSCA type definitions found in the Unfurl Cloud Standard Types library. The repository includes both YAML and Python versions of the types documented below.

Abstract resource types 

Core types

class std.generic_types.unfurl_capabilities_Configuration: Bases: Root

class std.generic_types.unfurl_relationships_ConfiguredBy: Bases: Root

class std.generic_types.Configuration

Bases: Root

configuredBy: unfurl_capabilities_Configuration

configures: Configures | None

class std.generic_types.Service

Bases: Root

A resource with one or more endpoints, such as an URL or network port.

portspecs: List[NetworkPortSpec]: Ports the service should be running on.

host: str: domain name or IP address of the endpoint

port: NetworkPortDef

url: str

host_requirement: ConfiguringHostedOn | ServiceHost | None

class std.generic_types.ServiceHost

Bases: Root

Addressable instance that hosts services. It translates the abstract service’s specification so that it can be deployed on an underlying resource, e.g. generating and deploying configuration files.

protocol: str

private_address: str

private_dns: str

public_address: str

public_dns: str | None: Fully qualified domain name.

ports: List[NetworkPortDef]

class std.generic_types.ContainerService

Bases: Service

A service that runs in an OCI container image.

portspecs: List[NetworkPortSpec]: Ports the service should be running on.

environment: EnvironmentVariables | None

container_image: str

container: unfurl_datatypes_DockerContainer | None

health_check_url: str

readiness_estimate: int: Guesstimate when we can expect the deployed app to be ready (in seconds)

public_ports: bool: Whether this service should be exposed to the internet

host: str: domain name or IP address of the endpoint

host_requirement: ConfiguringHostedOn | ContainerHost | None

container_image_source: ContainerImageRepository | None

class std.generic_types.ContainerHost

Bases: ServiceHost

An abstract resource that knows how to host a ContainerService. Implementations may, for example, create a Kubernetes service for the ContainerService or configure a compute host to run the container.

portspecs: List[NetworkPortSpec]

container: unfurl_datatypes_DockerContainer | None

container_image: str

registry_url: str | None

registry_user: str | None

registry_password: str | None

class std.generic_types.PrivateContainerHost

Bases: ContainerHost

Use this subtype of ContainerHost if the container service should be only accessible on the private network.

class std.generic_types.PublicContainerHost

Bases: ContainerHost

Use this subtype of ContainerHost if you want to the container service to be publicly accessible on the Internet.

class std.generic_types.HTTPSProxyContainerHost

Bases: ContainerHost

Use this subtype of ContainerHost if you want the container service to be exposed as HTTPS with a provisioned TLS/SSL certificate.

Concrete resources and services 

Core types

class std.generic_types.VolumeAttachment

Bases: AttachesTo

location: min_length object at 0x7f5193e7ca10>,)]

class std.generic_types.Compute

Bases: ServiceHost

num_cpus: in_range object at 0x7f519155fc90>,)]: Number of CPUs for the server

mem_size: in_range object at 0x7f519278cc90>,)]: Amount of RAM (in MB)

disk_size: in_range object at 0x7f519155f950>,)]: Size of boot disk (in GB)

boot_image: str

portspecs: List[NetworkPortSpec]

public_ports: bool: Whether this instance should be exposed to the internet

name: str

user_data: str

id: str

cloud_init: Configures | CloudInitGenerator | None

volume_attachment: AttachesTo | Volume | None: Create a persistent volume to save container data to. Applications will save data if the instance is deleted.

floating_ip: FloatingIP | None

volume_mount: Root

volume_format: Root

class std.generic_types.BootImage

Bases: Configuration

boot_image: str

class std.generic_types.Volume

Bases: BlockStorage

persistent: bool | None

size: greater_or_equal object at 0x7f5191592e10>,)]

disk_label: str

disk_device: str

class std.generic_types.SMTPServer

Bases: Root

SMTP Mail server for sending mail

host: str

port: NetworkPortDef

user_name: str

authentication: valid_values object at 0x7f51926ba0d0>,)]

password: str

protocol: str | None

starttls_auto: bool

connect(**kw: Any) → Any

class std.generic_types.MySQLDB

Bases: SqlDB

url_scheme: str: URL scheme to use when the database connection URL is generated

class std.generic_types.MariaDBInstance

Bases: MySQLDB, ContainerService

https://github.com/bitnami/bitnami-docker-mariadb

database_type: str

container: unfurl_datatypes_DockerContainer | None

host_requirement: ConfiguringHostedOn | PrivateContainerHost

class std.generic_types.PostgresDB

Bases: SqlDB

database_type: str

url_scheme: str: URL scheme to use when the database connection URL is generated

class std.generic_types.PostgresDBInstance

Bases: PostgresDB, ContainerService

https://github.com/bitnami/bitnami-docker-postgresql

container: unfurl_datatypes_DockerContainer | None

host_requirement: ConfiguringHostedOn | PrivateContainerHost

class std.generic_types.Redis

Bases: SoftwareComponent

username: str | None: Redis user name (use default if omitted)

password: pattern object at 0x7f51915babd0>,)] | None

database_name: str | None: Redis database name (use default if omitted)

port: in_range object at 0x7f51915bb790>,)]

url_scheme: str: URL scheme to use when the Redis connection URL is generated

url: str: If omitted one will be generated from the other settings

software_version: str | None: The Redis version (optional)

endpoints: List[str]

class std.generic_types.GenericRedis

Bases: Redis

host: str: Hostname or IP address

port: in_range object at 0x7f51915c0310>,)]

username: str | None: Redis user name (use default if omitted)

software_version: str | None: The Redis version (optional)

database_name: str | None: Redis database name (use default if omitted)

url_scheme: str: URL scheme to use when the Redis connection URL is generated

url: str: If omitted one will be generated from the other settings

Container Images and Building 

class std.image_sources.ContainerImageSource

Bases: ContainerImageRepository

repository_id: str

repository_tag: str

class std.image_sources.GenericContainerImageRepository: Bases: ContainerImageRepository

class std.image_sources.LocalImageRepoSource: Bases: __LocalImageRepoSource

class std.image_sources.MirroredRepoImageSource

Bases: __LocalImageRepoSource

repository_id: str

remote_git_url: str

git_user: str | None

git_password: str | None

branch: str | None

revision: str | None

class std.image_sources.UnfurlCloudMirroredRepoImageSource: Bases: MirroredRepoImageSource

class std.image_sources.GithubMirroredRepoImageSource

Bases: MirroredRepoImageSource

Build an image from GitHub project

repository_tag: str

github_project: str | None

branch: str | None

Apps 

Core types

class std.generic_types.App

Bases: Root

User-facing application composed of one or more services. It is typically at the root of a deployment.

url: str

class std.generic_types._ContainerAppBase

Bases: App

health_check_url: str

readiness_estimate: int: Guesstimate when we can expect the deployed app to be ready (in seconds)

url: str

container: Configures | ContainerService

class std.generic_types.ContainerApp

Bases: _ContainerAppBase

An App that uses a ContainerService for its main service

container: Configures | ContainerService

class std.generic_types.WebApp

Bases: _ContainerAppBase

An ContainerApp exposed through an https proxy.

subdomain: pattern object at 0x7f519155e610>,)]: Choose a subdomain for your deployment. A subdomain of ‘www’, will be at www.your.domain

url: str

container: Configures | ContainerService

class std.generic_types.SQLWebApp

Bases: WebApp

A web app that uses a SQL database like MySQL or Postgres

db: Configures | SqlDB

Kubernetes 

class unfurl.tosca_plugins.k8s.unfurl_capabilities_Endpoint_K8sCluster

Bases: EndpointAdmin

Capability to connect to a K8sCluster. See unfurl.relationships.ConnectsTo.K8sCluster for the semantics of the “credential” properties.

protocol: str

class unfurl.tosca_plugins.k8s.unfurl_relationships_ConnectsTo_K8sCluster

Bases: ConnectsTo

name: str | None

KUBECONFIG: str | None: Path to an existing Kubernetes config file. If not provided, and no other connection options are provided, and the KUBECONFIG environment variable is not set, the default location will be used (~/.kube/config.json).

context: str | None: The name of a context found in the config file. If not set the current-context will be used.

cluster_ca_certificate: str | None: PEM-encoded root certificates bundle for TLS authentication

cluster_ca_certificate_file: str | None

insecure: bool | None: If true, the server’s certificate will not be checked for validity. This will make your HTTPS connections insecure

token: str | None: Token of your service account.

credential: tosca.datatypes.Credential | None: token_type is either “api_key” or “password” (default is “password”) Its “keys” map can have the following values: “cert_file”: Path to a cert file for the certificate authority “ca_cert”: Path to a client certificate file for TLS “key_file”: Path to a client key file for TLS

namespace: str | None: The default namespace scope to use

api_server: str | None: The address and port of the Kubernetes API server

protocol: str

as_: str | None: Username to impersonate for the operation

as_group: List[str] | None: Groups to impersonate for the operation

check(**kw: Any) → Any

class unfurl.tosca_plugins.k8s.unfurl_nodes__K8sResourceHost: Bases: Root

class unfurl.tosca_plugins.k8s.unfurl_nodes_K8sCluster

Bases: unfurl_nodes__K8sResourceHost

api_server: str: The address and port of the cluster’s API server

host: tosca.capabilities.Container

endpoint: unfurl_capabilities_Endpoint_K8sCluster

check(**kw: Any) → Any

discover(**kw: Any) → Any

class unfurl.tosca_plugins.k8s.unfurl_nodes_K8sRawResource

Bases: Root

definition: object | None: Inline resource definition (string or map)

src: str | None: File path to resource definition

apiResource: Dict[str, Any] | None

name: str

host: tosca.relationships.HostedOn | unfurl_nodes__K8sResourceHost | None

check(**kw: Any) → Any

discover(**kw: Any) → Any

configure(**kw: Any) → Any

delete(**kw: Any) → Any

class unfurl.tosca_plugins.k8s.unfurl_nodes_K8sNamespace

Bases: unfurl_nodes__K8sResourceHost, unfurl_nodes_K8sRawResource

name: pattern object at 0x7f5191582210>,)]

class unfurl.tosca_plugins.k8s.unfurl_nodes_K8sResource

Bases: unfurl_nodes_K8sRawResource

name: str

namespace: str

host: tosca.relationships.HostedOn | unfurl_nodes_K8sNamespace | None

class unfurl.tosca_plugins.k8s.unfurl_nodes_K8sSecretResource

Bases: unfurl_nodes_K8sResource

definition: object | None: Inline resource definition (string or map)

type: str

data: Dict[str, Any] | None

class std.k8s.K8sContainerHost

Bases: ContainerHost

public_dns: str | None: internal only, use PublicK8sContainerHost to expose this service

name: str: name generated by Kompose

namespace: str

private_dns: str

definitions: Dict[str, Dict[str, Any]]

restart(**kw: Any) → Any

configure(**kw: Any) → Any

class std.k8s.PrivateK8sContainerHost: Bases: K8sContainerHost, PrivateContainerHost

class std.k8s.KubernetesIngressController

Bases: Root

annotations: Dict[str, str]: Annotation to add to an Ingress resource that wishes to use this controller. e.g.:

cert-manager.io/issuer: cert-manager.io/cluster-issuer: kubernetes.io/ingress.class: kubernetes.io/ingress.provider:

connect(**kw: Any) → None: Declare no-op connect operation so the user can create an external resource

class std.k8s.PublicK8sContainerHost

Bases: K8sContainerHost, HTTPSProxyContainerHost

Expose service with DNS and an Ingress record

protocol: str

public_dns: str | None: Fully qualified domain name.

ports: List[tosca.datatypes.NetworkPortDef]

ingress: KubernetesIngressController | None: The ingress to use

dns: unfurl_relationships_DNSRecords | unfurl_nodes_DNSZone: DNS provider for domain name configuration

configure(**kw: Any) → Any

Amazon Web Services 

class std.aws.compute.EBSVolumeAttachment

Bases: VolumeAttachment

Attach an EBSVolume to a EC2ComputeInstance

default(**kw: Any) → Any

std.aws.compute.ComputeVolumeAttachment: alias of EBSVolumeAttachment

class std.aws.compute.AWSMetadata

Bases: Root

machine_types: List[Dict[str, Any]]

availability_zone: str

configure(**kw: Any) → Any

class std.aws.compute.AMIBootImage

Bases: BootImage

owner: str

architecture: str

virtualization_type: str

name_regex: str

configure(**kw: Any) → Any

class std.aws.compute.EC2Compute

Bases: Compute

key_name: str | None: Name of your AWS ssh key pair. Set if you want to be able to SSH into this instance.

boot_image: str

use_static_ip: bool: Whether to use a static Elastic IP for this instance. Limit of 5 per region.

machine_type: str

availability_zone: str

volume_attachment: EBSVolumeAttachment | Volume | None: Create a persistent volume to save container data to. Applications will save data if the instance is deleted.

floating_ip: FloatingIP | None

restart(**kw: Any) → Any

default(**kw: Any) → Any

create(**kw: Any) → Any

class std.aws.compute.EBSVolume

Bases: Volume, AWSResource, unfurl_nodes_Installer_Terraform

https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/AmazonEBS.html

name: str: Human-friendly name of the resource

ebs_size: str

availability_zone: str

disk_letter: valid_values object at 0x7f518e569050>,)]

disk_device: str

configure(**kw: Any) → Any

default(**kw: Any) → Any

class std.aws.compute.EC2PublicIP

Bases: FloatingIP

default(**kw: Any) → Any

create(**kw: Any) → Any

std.aws.compute.ComputeInstance: alias of EC2Compute

std.aws.compute.StaticIPAddress: alias of EC2PublicIP

std.aws.compute.ComputeVolume: alias of EBSVolume

class std.aws.db.AWSRDS

Bases: AWSResource, unfurl_nodes_Installer_Terraform, Service

instance_class: str

engine: str: See https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_CreateDBInstance.html for valid values.

database_type: str

deletion_protection: bool

port: NetworkPortDef

host_requirement: ConfiguringHostedOn | ServiceHost | None

create(**kw: Any) → Any

default(**kw: Any) → Any

class std.aws.db.AwsRdsMySQL

Bases: MySQLDB, AWSRDS

engine: str: See https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_CreateDBInstance.html for valid values.

software_version: str | None

database_type: str

portspecs: List[NetworkPortSpec]: Ports the service should be running on.

class std.aws.db.AwsRdsPostgres

Bases: PostgresDB, AWSRDS

engine: str: See https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_CreateDBInstance.html for valid values.

software_version: str | None

database_type: str

portspecs: List[NetworkPortSpec]: Ports the service should be running on.

class std.aws.db.AwsRdsMariaDB

Bases: MySQLDB, AWSRDS

engine: str: See https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_CreateDBInstance.html for valid values.

software_version: str | None

database_type: str

portspecs: List[NetworkPortSpec]: Ports the service should be running on.

class std.aws.db.AWSRedis

Bases: Redis, AWSResource, unfurl_nodes_Installer_Terraform, Service

https://aws.amazon.com/elasticache/redis/

password: pattern object at 0x7f518d952bd0>,)] | None

availability_zone: str

machine_type: str

portspecs: List[NetworkPortSpec]: Ports the service should be running on.

host_requirement: ConfiguringHostedOn | ServiceHost | None

create(**kw: Any) → Any

default(**kw: Any) → Any

class std.dns_services.Route53DNSZone

Bases: unfurl_nodes_DNSZone

Amazon Web Services Route53 DNS provider for domain name configuration

access_key_id: str | None

secret_access_key: str | None

session_token: str | None

provider: Dict[str, Any]: OctoDNS provider configuration

console_url: str

Google Cloud 

class std.gcp.compute.GoogleComputeDiskAttachment

Bases: VolumeAttachment

Attach a GoogleComputeDisk to a GCPComputeInstance

default(**kw: Any) → Any

std.gcp.compute.ComputeVolumeAttachment: alias of GoogleComputeDiskAttachment

class std.gcp.compute.GCPMetadata

Bases: Root

machine_types: List[Dict[str, Any]]

zone: str

configure(**kw: Any) → Any

class std.gcp.compute.GCPBootImage

Bases: BootImage

project: str

family: str

configure(**kw: Any) → Any

class std.gcp.compute.GCPComputeInstance

Bases: Compute

boot_image: str

machine_type: str

zone: str

volume_attachment: GoogleComputeDiskAttachment | Volume | None: Create a persistent volume to save container data to. Applications will save data if the instance is deleted.

floating_ip: FloatingIP

restart(**kw: Any) → Any

default(**kw: Any) → Any

create(**kw: Any) → Any

class std.gcp.compute.UnfurlGoogleCloudServiceAccount

Bases: Root

project_id: str

name: str

configure(**kw: Any) → Any

class std.gcp.compute.GoogleComputeDisk

Bases: Volume, unfurl_nodes_GoogleCloudObject, unfurl_nodes_Installer_Terraform

See https://cloud.google.com/compute/docs/disks/

name: str: Human-friendly name of the resource

disk_size: float

zone: str

disk_device: str

configure(**kw: Any) → Any

default(**kw: Any) → Any

class std.gcp.compute.GCPComputeAddress

Bases: FloatingIP

default(**kw: Any) → Any

create(**kw: Any) → Any

std.gcp.compute.ComputeInstance: alias of GCPComputeInstance

std.gcp.compute.StaticIPAddress: alias of GCPComputeAddress

std.gcp.compute.ComputeVolume: alias of GoogleComputeDisk

class std.gcp.db.GoogleSQLStorage

Bases: unfurl_nodes_GoogleCloudObject, unfurl_nodes_Installer_Terraform, Service

instance_name: str

database_type: str

instance_type: str

deletion_protection: bool

host_requirement: ConfiguringHostedOn | ServiceHost | None

create(**kw: Any) → Any

default(**kw: Any) → Any

class std.gcp.db.GoogleSQLStorageMySQL

Bases: MySQLDB, GoogleSQLStorage

database_type: str

software_version: str | None

portspecs: List[NetworkPortSpec]: Ports the service should be running on.

class std.gcp.db.GoogleSQLStoragePostgres

Bases: PostgresDB, GoogleSQLStorage

database_type: str

software_version: str | None

instance_type: str

portspecs: List[NetworkPortSpec]: Ports the service should be running on.

class std.gcp.db.GoogleRedis

Bases: Redis, unfurl_nodes_GoogleCloudObject, unfurl_nodes_Installer_Terraform, Service

https://cloud.google.com/memorystore/docs/redis#docs

password: pattern object at 0x7f518dd8ed50>,)] | None

memory_size_gb: float

portspecs: List[NetworkPortSpec]: Ports the service should be running on.

host_requirement: ConfiguringHostedOn | ServiceHost | None

create(**kw: Any) → Any

default(**kw: Any) → Any

class std.dns_services.GoogleCloudDNSZone

Bases: unfurl_nodes_DNSZone

Google Cloud DNS provider for domain name configuration

provider: Dict[str, Any]: OctoDNS provider configuration

console_url: str

Azure 

class std.azure.compute.unfurl_datatypes_AzureVMCredentials

Bases: DataType

admin_username: str

admin_password: pattern object at 0x7f518d18e910>)]

public_key: str | None

class std.azure.compute.ConnectsTo_AzureEnvironment

Bases: ConnectsToAzure

resource_group: str: Name of the resource group [(Portal link)](https://learn.microsoft.com/en-us/azure/azure-resource-manager/management/manage-resource-groups-portal)

virtual_network: str: Name of the virtual network [(Portal link)](https://learn.microsoft.com/en-us/azure/virtual-network/network-overview#virtual-network-and-subnets)

subnet: str: Name of the subnet within the virtual network

AZURE_CLIENT_ID: str: Also known as an Application ID or appId. Can be created via [CLI](https://registry.terraform.io/providers/hashicorp/azurerm/latest/docs/guides/service_principal_client_certificate) or through the [Azure portal](https://learn.microsoft.com/azure/active-directory/develop/howto-create-service-principal-portal).

AZURE_TENANT: str: [Find your Azure active directory tenant](https://learn.microsoft.com/en-us/azure/azure-portal/get-subscription-tenant-id#find-your-azure-ad-tenant)

AZURE_SUBSCRIPTION_ID: str: [Find your Azure subscription](https://learn.microsoft.com/en-us/azure/azure-portal/get-subscription-tenant-id#find-your-azure-subscription)

AZURE_SECRET: str | None: For authentication with service principal. [(Portal link)](https://learn.microsoft.com/azure/active-directory/develop/howto-create-service-principal-portal#option-2-create-a-new-application-secret)

credential: Credential | None

class std.azure.compute.AzureBootImage

Bases: BootImage

publisher_name: str

offer: str

sku: str

version: str

boot_image: str

configure(**kw: Any) → Any

class std.azure.compute.AzureCompute

Bases: Compute

boot_image: str

credentials: unfurl_datatypes_AzureVMCredentials

machine_type: str

floating_ip: FloatingIP

restart(**kw: Any) → Any

default(**kw: Any) → Any

create(**kw: Any) → Any

class std.azure.compute.AzurePublicIP

Bases: FloatingIP

name: str

default(**kw: Any) → Any

create(**kw: Any) → Any

std.azure.compute.ComputeInstance: alias of AzureCompute

std.azure.compute.StaticIPAddress: alias of AzurePublicIP

class std.dns_services.AzureDNSZone

Bases: unfurl_nodes_DNSZone

Azure DNS provider for domain name configuration

client_id: str: The Azure Active Directory Application ID (aka client ID)

secret_key: str: Authentication Key Value (secret)

directory_id: str | None: Directory ID (aka Tenant ID)

subscription_id: str | None

resource_group: str | None

provider: Dict[str, Any]: OctoDNS provider configuration

DigitalOcean 

class std.digitalocean.compute.ConnectsTo_DigitalOceanEnvironment

Bases: ConnectsToDigitalOcean

credential: Credential | None

class std.digitalocean.compute.DigitalOceanCompute

Bases: Compute

key_name: str | None: Name of your Digital Ocean ssh key pair. Set if you want to be able to SSH into this instance.

boot_image: str

region: str

droplet_size: str

default(**kw: Any) → Any

create(**kw: Any) → Any

std.digitalocean.compute.ComputeInstance: alias of DigitalOceanCompute

class std.dns_services.DigitalOceanDNSZone

Bases: unfurl_nodes_DNSZone

Digitial Ocean DNS provider for domain name configuration

DIGITALOCEAN_TOKEN: str: An API token for your DigitalOcean account.

provider: Dict[str, Any]: OctoDNS provider configuration

console_url: str

DNS 

class unfurl.configurators.templates.dns.unfurl_datatypes_DNSRecord

Bases: DataType

type: str

value: str | None

values: List[Any] | None

class unfurl.configurators.templates.dns.unfurl_capabilities_DNSZone: Bases: Root

class unfurl.configurators.templates.dns.unfurl_relationships_DNSRecords

Bases: Root

records: Dict[str, unfurl_datatypes_DNSRecord]

class unfurl.configurators.templates.dns.unfurl_nodes_DNSZone

Bases: Root

name: str: Top level part of the DNS name (e.g. example.com)

provider: Dict[str, Any]: OctoDNS provider configuration

records: Dict[str, unfurl_datatypes_DNSRecord]: DNS records to add to the zone

exclusive: bool: Zone exclusively managed by this instance (removes unrecognized records)

default_ttl: int

testing: bool: Is this DNS zone being used for testing? (If set, Let’s Encrypt staging will be used.)

zone: Dict[str, Any]: The records found in the zone

managed_records: Dict[str, Any] | None: The records in the zone that are managed by this instance

resolve: unfurl_capabilities_DNSZone

parent_zone: unfurl_capabilities_DNSZone | None

default(**kw: Any) → Any

class std.dns_services.CloudFlareDNSZone

Bases: unfurl_nodes_DNSZone

CloudFlare DNS provider for domain name configuration

cloudflare_token: str: An API token for your Cloudflare account.

provider: Dict[str, Any]: OctoDNS provider configuration

class std.dns_services.RackspaceDNSZone

Bases: unfurl_nodes_DNSZone

Rackspace DNS provider for domain name configuration

RACKSPACE_USERNAME: str: Username of your Rackspace account.

RACKSPACE_API_KEY: str: An API token for your Rackspace account.

provider: Dict[str, Any]: OctoDNS provider configuration

class std.dns_services.UnfurlUserDNSZone

Bases: unfurl_nodes_DNSZone

Default DNS for Unfurl Cloud users

name: str: DNS name of the zone.

provider: Dict[str, Any]: unused

testing: bool: Is this DNS zone being used for testing? (If set, Let’s Encrypt staging will be used.)

default(**kw: Any) → Any

class std.dns_services.UnfurlCNamedDNSZone

Bases: UnfurlUserDNSZone

Unfurl User DNS with a user-provided alias

name: str: User’s domain for CNAME host

target_subdomain: str: The generated subdomain the user’s CNAME points to

default(**kw: Any) → Any

TOSCA types 

class tosca.nodes

Bases: Namespace

class Root

Bases: NodeType, Install, NodeLifecycleStandard

The TOSCA root node all other TOSCA base node types derive from.

tosca_id: str

tosca_name: str

state: str

feature: capabilities.Node

dependency: Sequence[relationships.DependsOn | nodes.Root | capabilities.Node]

class AbstractStorage

Bases: Root

name: str

size: greater_or_equal object at 0x7f519391e690>,)]

class StorageBlockStorage

Bases: AbstractStorage

volume_id: str | None

snapshot_id: str | None

attachment: capabilities.Attachment

class BlockStorage

Bases: StorageBlockStorage

name: str

class StorageObjectStorage

Bases: AbstractStorage

maxsize: greater_or_equal object at 0x7f5193926750>,)]

storage_endpoint: capabilities.Endpoint

class AbstractCompute

Bases: Root

host: capabilities.Compute

class Compute

Bases: AbstractCompute

private_address: str

public_address: str

networks: Dict[str, datatypes.NetworkNetworkInfo]

ports: Dict[str, datatypes.NetworkPortInfo]

host: capabilities.Compute

binding: capabilities.NetworkBindable

os: capabilities.OperatingSystem

scalable: capabilities.Scalable

endpoint: capabilities.EndpointAdmin

local_storage: Sequence[relationships.AttachesTo | nodes.StorageBlockStorage | capabilities.Attachment]

class SoftwareComponent

Bases: Root

component_version: tosca_version | None: Software component version.

admin_credential: datatypes.Credential | None

host: Sequence[relationships.HostedOn | nodes.Compute | capabilities.Compute]

class DBMS

Bases: SoftwareComponent

port: int | None: The port the DBMS service will listen to for data and requests.

root_password: str | None: The root password for the DBMS service.

host_capability: capabilities.Compute

class Database

Bases: Root

user: str | None: User account name for DB administration

port: int | None: The port the database service will use to listen for incoming data and requests.

name: str | None: The name of the database.

password: str | None: The password for the DB user account

database_endpoint: capabilities.EndpointDatabase

host: relationships.HostedOn | nodes.DBMS | capabilities.Compute

class WebServer

Bases: SoftwareComponent

data_endpoint: capabilities.Endpoint

admin_endpoint: capabilities.EndpointAdmin

host_capability: capabilities.Compute

class WebApplication

Bases: Root

context_root: str | None

app_endpoint: capabilities.Endpoint

host: relationships.HostedOn | nodes.WebServer | capabilities.Compute

class NetworkNetwork

Bases: Root

The TOSCA Network node represents a simple, logical network service.

ip_version: valid_values object at 0x7f5193934350>,)] | None: The IP version of the requested network. Valid values are 4 for ipv4 or 6 for ipv6.

cidr: str | None: The cidr block of the requested network.

start_ip: str | None: The IP address to be used as the start of a pool of addresses within the full IP range derived from the cidr block.

end_ip: str | None: The IP address to be used as the end of a pool of addresses within the full IP range derived from the cidr block.

gateway_ip: str | None: The gateway IP address.

network_name: str | None: An identifier that represents an existing Network instance in the underlying cloud infrastructure or can be used as the name of the newly created network. If network_name is provided and no other properties are provided (with exception of network_id), then an existing network instance will be used. If network_name is provided alongside with more properties then a new network with this name will be created.

network_id: str | None: An identifier that represents an existing Network instance in the underlying cloud infrastructure. This property is mutually exclusive with all other properties except network_name. This can be used alone or together with network_name to identify an existing network.

segmentation_id: str | None: A segmentation identifier in the underlying cloud infrastructure. E.g. VLAN ID, GRE tunnel ID, etc..

network_type: str | None: It specifies the nature of the physical network in the underlying cloud infrastructure. Examples are flat, vlan, gre or vxlan. For flat and vlan types, physical_network should be provided too.

physical_network: str | None: It identifies the physical network on top of which the network is implemented, e.g. physnet1. This property is required if network_type is flat or vlan.

dhcp_enabled: bool | None: Indicates should DHCP service be enabled on the network or not.

link: capabilities.NetworkLinkable

class NetworkPort

Bases: Root

The TOSCA Port node represents a logical entity that associates between Compute and Network normative types. The Port node type effectively represents a single virtual NIC on the Compute node instance.

ip_address: str | None: Allow the user to set a static IP.

order: greater_or_equal object at 0x7f5193943590>,)] | None: The order of the NIC on the compute instance (e.g. eth2).

is_default: bool | None: If is_default=true this port will be used for the default gateway route. Only one port that is associated to single compute node can set as is_default=true.

ip_range_start: str | None: Defines the starting IP of a range to be allocated for the compute instances that are associated with this Port.

ip_range_end: str | None: Defines the ending IP of a range to be allocated for the compute instances that are associated with this Port.

binding: relationships.NetworkBindsTo | nodes.Compute | capabilities.NetworkBindable: Binding requirement expresses the relationship between Port and Compute nodes. Effectively it indicates that the Port will be attached to specific Compute node instance

link: relationships.NetworkLinksTo | nodes.NetworkNetwork | capabilities.NetworkLinkable: Link requirement expresses the relationship between Port and Network nodes. It indicates which network this port will connect to.

class NetworkFloatingIP

Bases: Root

The TOSCA FloatingIP node represents a floating IP that can associate to a Port.

floating_network: str

floating_ip_address: str | None

port_id: str | None

link: relationships.NetworkLinksTo | nodes.NetworkPort | capabilities.NetworkLinkable

class ObjectStorage

Bases: Root

The TOSCA ObjectStorage node represents storage that provides the ability to store data as objects (or BLOBs of data) without consideration for the underlying filesystem or devices

name: str: The logical name of the object store (or container).

size: greater_or_equal object at 0x7f519394d490>,)] | None: The requested initial storage size.

maxsize: greater_or_equal object at 0x7f519394da50>,)] | None: The requested maximum storage size.

storage_endpoint: capabilities.Endpoint

class LoadBalancer

Bases: Root

algorithm: str | None

client: Sequence[capabilities.EndpointPublic]: the Floating (IP) client’s on the public network can connect to

application: Sequence[relationships.RoutesTo | capabilities.Endpoint]: Connection to one or more load balanced applications

class ContainerRuntime

Bases: SoftwareComponent

host_capability: capabilities.Container

scalable: capabilities.Scalable

class ContainerApplication

Bases: Root

host: relationships.HostedOn | nodes.ContainerRuntime | capabilities.Container

storage: capabilities.Storage

network: capabilities.Endpoint

class ContainerRuntimeDocker

Bases: ContainerRuntime

host_capability: capabilities.ContainerDocker

class ContainerApplicationDocker

Bases: ContainerApplication

host: relationships.HostedOn | nodes.ContainerRuntime | capabilities.ContainerDocker

class tosca.capabilities

Bases: Namespace

class Root

Bases: CapabilityType

The TOSCA root Capability Type all other TOSCA base Capability Types derive from.

class Node: Bases: Root

class Container: Bases: Root

class Storage

Bases: Root

name: str | None

class Compute

Bases: Container

name: str | None

num_cpus: greater_or_equal object at 0x7f5193e7d190>,)] | None

cpu_frequency: greater_or_equal object at 0x7f51939086d0>,)] | None

disk_size: greater_or_equal object at 0x7f519390b490>,)] | None

mem_size: greater_or_equal object at 0x7f519390a210>,)] | None

class Endpoint

Bases: Root

protocol: str

port: datatypes.NetworkPortDef | None

secure: bool | None

url_path: str | None

port_name: str | None

network_name: str | None

initiator: valid_values object at 0x7f5193908c50>,)] | None

ports: min_length object at 0x7f5193908990>,)] | None

ip_address: str

class EndpointAdmin

Bases: Endpoint

secure: equal object at 0x7f519390a890>,)] | None

class EndpointPublic

Bases: Endpoint

network_name: equal object at 0x7f5193909a10>,)] | None

floating: bool: Indicates that the public address should be allocated from a pool of floating IPs that are associated with the network.

dns_name: str | None: The optional name to register with DNS

class Scalable

Bases: Root

min_instances: int: This property is used to indicate the minimum number of instances that should be created for the associated TOSCA Node Template by a TOSCA orchestrator.

max_instances: int: This property is used to indicate the maximum number of instances that should be created for the associated TOSCA Node Template by a TOSCA orchestrator.

default_instances: int | None: An optional property that indicates the requested default number of instances that should be the starting number of instances a TOSCA orchestrator should attempt to allocate. The value for this property MUST be in the range between the values set for min_instances and max_instances properties.

class EndpointDatabase: Bases: Endpoint

class Attachment: Bases: Root

class NetworkLinkable

Bases: Root

A node type that includes the Linkable capability indicates that it can be pointed by tosca.relationships.network.LinksTo relationship type, which represents an association relationship between Port and Network node types.

class NetworkBindable

Bases: Root

A node type that includes the Bindable capability indicates that it can be pointed by tosca.relationships.network.BindsTo relationship type, which represents a network association relationship between Port and Compute node types.

class OperatingSystem

Bases: Root

architecture: str | None: The host Operating System (OS) architecture.

type: str | None: The host Operating System (OS) type.

distribution: str | None: The host Operating System (OS) distribution. Examples of valid values for an “type” of “Linux” would include: debian, fedora, rhel and ubuntu.

version: tosca_version | None: The host Operating System version.

class ContainerDocker

Bases: Container

version: List[tosca_version] | None: The Docker version capability.

publish_all: bool | None: Indicates that all ports (ranges) listed in the dockerfile using the EXPOSE keyword be published.

publish_ports: List[datatypes.NetworkPortSpec] | None: List of ports mappings from source (Docker container) to target (host) ports to publish.

expose_ports: List[datatypes.NetworkPortSpec] | None: List of ports mappings from source (Docker container) to expose to other Docker containers (not accessible outside host).

volumes: List[str] | None: The dockerfile VOLUME command which is used to enable access from the Docker container to a directory on the host machine.

class tosca.relationships

Bases: Namespace

class Root

Bases: RelationshipType, RelationshipConfigure

The TOSCA root Relationship Type all other TOSCA base Relationship Types derive from.

tosca_id: str

tosca_name: str

class DependsOn: Bases: Root

class HostedOn: Bases: Root

class ConnectsTo

Bases: Root

credential: datatypes.Credential | None

class AttachesTo

Bases: Root

location: min_length object at 0x7f5193917b50>,)]

device: str | None

class RoutesTo: Bases: ConnectsTo

class NetworkLinksTo: Bases: DependsOn

class NetworkBindsTo: Bases: DependsOn

class tosca.interfaces

Bases: Namespace

class Root

Bases: InterfaceType

The TOSCA root Interface Type all other TOSCA Interface types derive from

class NodeLifecycleStandard

Bases: InterfaceType

create(**kw: Any) → Any: Standard lifecycle create operation.

configure(**kw: Any) → Any: Standard lifecycle configure operation.

start(**kw: Any) → Any: Standard lifecycle start operation.

stop(**kw: Any) → Any: Standard lifecycle stop operation.

delete(**kw: Any) → Any: Standard lifecycle delete operation.

class RelationshipConfigure

Bases: InterfaceType

pre_configure_source(**kw: Any) → Any: Operation to pre-configure the source endpoint.

pre_configure_target(**kw: Any) → Any: Operation to pre-configure the target endpoint.

post_configure_source(**kw: Any) → Any: Operation to post-configure the source endpoint.

post_configure_target(**kw: Any) → Any: Operation to post-configure the target endpoint.

add_target(**kw: Any) → Any: Operation to add a target node.

remove_target(**kw: Any) → Any: Operation to remove a target node.

add_source(**kw: Any) → Any: Operation to notify the target node of a source node which is now available via a relationship.

remove_source(**kw: Any) → Any: Operation to notify the target node of a source node which is no longer available via a relationship.

target_changed(**kw: Any) → Any: Operation to notify source some property or attribute of the target changed

class Install

Bases: Root

check(**kw: Any) → Any: Checks and sets the status and attributes of the instance

discover(**kw: Any) → Any: Discovers current state of the current instance and (possibly) related instances, updates the spec as needed.

revert(**kw: Any) → Any: Restore the instance to the state it was original found in.

connect(**kw: Any) → Any: Connect to a pre-existing resource.

restart(**kw: Any) → Any: Restart the resource.

class tosca.datatypes

Bases: Namespace

class Root

Bases: DataType

The TOSCA root Data Type all other TOSCA base Data Types derive from

class NetworkNetworkInfo

Bases: Root

network_name: str

network_id: str

addresses: List[str]

class NetworkPortInfo

Bases: Root

port_name: str

port_id: str

network_id: str

mac_address: str

addresses: List[str]

class NetworkPortDef: Bases: ValueType, int

class NetworkPortSpec

Bases: Root

protocol: valid_values object at 0x7f51938f8b10>,)]

target: datatypes.NetworkPortDef | None

target_range: in_range object at 0x7f51938f8650>,)] | None

source: datatypes.NetworkPortDef | None

source_range: in_range object at 0x7f51938f9390>,)] | None

class Credential

Bases: Root

protocol: str | None

token_type: str

token: str

keys: Dict[str, str] | None

user: str | None

class Json: Bases: ValueType, str

class Xml: Bases: ValueType, str

class tosca.artifacts

Bases: Namespace

class Root

Bases: ArtifactType

The TOSCA Artifact Type all other TOSCA Artifact Types derive from

class File: Bases: Root

class Deployment

Bases: Root

TOSCA base type for deployment artifacts

class DeploymentImage: Bases: Deployment

class DeploymentImageVM

Bases: DeploymentImage

Virtual Machine (VM) Image

class Implementation

Bases: Root

TOSCA base type for implementation artifacts

class ImplementationBash

Bases: Implementation

Script artifact for the Unix Bash shell

class ImplementationPython

Bases: Implementation

Artifact for the interpreted Python language

class DeploymentImageContainerDocker

Bases: DeploymentImage

Docker container image

class DeploymentImageVMISO

Bases: DeploymentImage

Virtual Machine (VM) image in ISO disk format

class DeploymentImageVMQCOW2

Bases: DeploymentImage

Virtual Machine (VM) image in QCOW v2 standard disk format

class Template

Bases: Root

TOSCA base type for template type artifacts

Unfurl core types 

class unfurl.nodes

Bases: Namespace

class Repository

Bases: Root

Reification of a TOSCA repository. Artifacts listed in the “artifacts” section of this node template will able available in the repository.

repository: str | None: The name of the repository this node instance represent.

url: str | None: The url of this repository

credential: tosca.datatypes.Credential | None: The credential, if present, of the repository this node instance represents.

class LocalRepository

Bases: Repository

Represents the collection of artifacts available to the local operation host.

class ArtifactBuilder

Bases: Root

Creates or builds the given artifact and “uploads” it to the artifact’s repository.

class ArtifactInstaller

Bases: Root

Reification of an artifact that needs to be installed. Node templates of this type are “discovered” when artifacts need to be installed on an operation_host.