container

Description

Venue	Equivalent Concept(s)
	Container Instances for standalone containers, and
	App Services for autoscale containers

A compute resource that combines aspects of compute, networking, and storage capable of running applications. Containers are a powerful way to package an application that simplifies deployment dependencies and empowers the development team to own the application runtime environment.

This feature is under development. We plan on adding support for scalable container services and load balancing on both AWS and Azure as we progress.

Features

Auto-Scale

Feature	AWS	Azure
Automatic
Manual

Configuration

Feature	AWS	Azure
CMD (Command Override)		✔️
CPU Cores		✔️
DNS Configuration
Environment Variables		✔️
GPU
Initializers
Memory		✔️
Port Remapping
Restart Policy
Secrets
Sidecars

Connectivity

Feature	AWS	Azure
Private		✔️
Public		✔️

Repository Access

Feature	AWS	Azure
Private		✔️
Public		✔️

Runtime

Feature	AWS	Azure
Linux		✔️
Windows		✔️

Required Properties

cores (float or integer)

The total number of processing cores available to this container. If you are accustomed to using shares to define compute potential, 1000 shares is roughly equivalent to 1 core.

image (dict)

The properties used to retrieve the container image at creation.

os (string)

The type of operating system the container runs on.

Allowed Values:

• linux

• windows

password (string)

The password used to access a private container registry. The registry must be provided in the path when this is specified. The username must be provided when this is specified.

path (string)

The container image source path. This should be in the form of [<registry>/]<organization>/<repository>[:<tag>]. The registry portion of the path is required if the path requires credentials. If the registry portion is omitted then index.docker.io is assumed. If the tag is omitted then latest is used.

Example(s):

• mcr.microsoft.com/azuredocs/aci-helloworld

• nginxdemos/hello:plain-text

username (string)

The username used to access a private container registry. The registry must be provided in the path when this is specified.

memory (size)

The amount of memory assigned to this container.

provides (⏩ networking.protocol)

Declares networking service flows provided by this container. This typically means that the service is listening for connections and behaving as a server. Any firewall rules will be updated automatically to allow the traffic to enter the container.

scope (string)

Declares the connectivity type of the container. A public container is directly accessible on the internet and does not require a network or subnet. A private container is not directly accessible on the internet, but has one or more dynamically assigned private ip addresses in one or more subnets.

Allowed Values:

• private

• public

Optional Properties

cmd (list or string)

The command(s) that run when the container begins. These commands execute after the ENTRYPOINT command(s) defined in the container image. If the image specifies a default set of CMD to run, this will override it.

environment (dict)

The environment variables used to configure the container.

subnets (⏩ networking.subnet)

Declares one or more subnets that a private-scope container connects to. If the container scope is private, this field is required.

On Azure, a standalone container can only have one subnet.

Common Properties

count (integer)

Indicates how many of this container should exist. When count is specified the name of the given resource will have a hyphen and numeric suffix added automatically, unless the count variable is referenced in the blueprint object name.

depends_on (⏩ any)

This property can be used to declare a dependency from this container to any other object in the blueprint. This is not necessary for dependencies generated normally by the schema.

folder (▶ location.folder)

The folder containing this container. If this is not specified and there is only one folder defined, that folder is used automatically.

name (string)

The name of this container. The name can be different than the blueprint object name. When the name property is not present we apply automatic naming strategies to make resources easier to identify in each venue's management console. When the name property is specified we will use it exactly as specified.

readonly (boolean)

Indicates whether or not this container is read-only. If so, we verify only the existence and correctness of this container to its specification rather than creating or modifying it.

The default value if not specified is false.

tags (dict)

The tags to place on this container. Tags are metadata stored in (key = value, ...) form. Consumers are not allowed to use tags that begin with _tuono as those are reserved.

Discovered Properties

These properties are populated and available in the inventory following a successful apply.

fqdn (string)

A public-scope container's fully-qualified domain name.

id (string)

The venue-specific identifier of this container.

ips (list)

The ip addresses assigned to the container. For a private container these correspond in the same order to each of the subnets declared.

Examples

Define a public container that responds on http:

compute:
  container:
    example-container:
      cores: 0.25
      image:
        os: linux
        path: index.docker.io/nginxdemos/hello:plain-text
      memory: 0.5 GB
      provides: http
      scope: public
      tags:
        wicked: cool
location:
  folder:
    example-folder:
      region: example-region
  region:
    example-region:
      area: west
      country: USA
networking:
  protocol:
    http:
      ports:
        - port: 80
          proto: tcp

A private container that provides redis:

compute:
  container:
    example-redis:
      cores: 1
      image:
        os: linux
        path: redis
      memory: 4 GB
      provides: redis
      scope: private
      subnets:
        - example-isolated
location:
  folder:
    example-folder:
      region: example-region
  region:
    example-region:
      area: west
      country: USA
networking:
  firewall:
    example-firewall:
      rules:
        - description: Allow SSH
          from: anywhere
          protocols: ssh
          to: self
  network:
    example-network:
      range: 10.0.0.0/8
      scope: public
  protocol:
    redis:
      ports:
        - port: 22
          proto: tcp
    ssh:
      ports:
        - port: 6379
          proto: tcp
  subnet:
    example-isolated:
      network: example-network
      range: 10.100.0.0/24
      scope: isolated