pulumi-docker-kotlin/com.pulumi.docker.kotlin/Container

Container

class Container : KotlinCustomResource

Manages the lifecycle of a Docker container.

Example Usage

package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.docker.RemoteImage;
import com.pulumi.docker.RemoteImageArgs;
import com.pulumi.docker.Container;
import com.pulumi.docker.ContainerArgs;
import java.util.List;
import java.util.ArrayList;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;
public class App {
    public static void main(String[] args) {
        Pulumi.run(App::stack);
    }
    public static void stack(Context ctx) {
        var ubuntuRemoteImage = new RemoteImage("ubuntuRemoteImage", RemoteImageArgs.builder()
            .name("ubuntu:precise")
            .build());
        var ubuntuContainer = new Container("ubuntuContainer", ContainerArgs.builder()
            .image(ubuntuRemoteImage.imageId())
            .build());
    }
}

Import

Example Assuming you created a `container` as follows #!/bin/bash docker run --name foo -p8080:80 -d nginx

prints the container ID 9a550c0f0163d39d77222d3efd58701b625d47676c25c686c95b5b92d1cba6fd you provide the definition for the resource as follows terraform resource "docker_container" "foo" { name = "foo" image = "nginx" ports { internal = "80" external = "8080" } } then the import command is as follows #!/bin/bash

$ pulumi import docker:index/container:Container foo 9a550c0f0163d39d77222d3efd58701b625d47676c25c686c95b5b92d1cba6fd

Properties

attach

val attach: Output<Boolean>?

If true attach to the container after its creation and waits the end of its execution. Defaults to false.

bridge

val bridge: Output<String>

The network bridge of the container as read from its NetworkSettings.

capabilities

val capabilities: Output<ContainerCapabilities>?

Add or drop certrain linux capabilities.

cgroupnsMode

val cgroupnsMode: Output<String>?

Cgroup namespace mode to use for the container. Possible values are: private, host.

command

val command: Output<List<String>>

The command to use to start the container. For example, to run /usr/bin/myprogram -f baz.conf set the command to be ["/usr/bin/myprogram","-f","baz.con"].

containerLogs

val containerLogs: Output<String>

The logs of the container if its execution is done (attach must be disabled).

containerReadRefreshTimeoutMilliseconds

val containerReadRefreshTimeoutMilliseconds: Output<Int>?

The total number of milliseconds to wait for the container to reach status 'running'

cpuSet

val cpuSet: Output<String>?

A comma-separated list or hyphen-separated range of CPUs a container can use, e.g. 0-1.

cpuShares

val cpuShares: Output<Int>?

CPU shares (relative weight) for the container.

destroyGraceSeconds

val destroyGraceSeconds: Output<Int>?

If defined will attempt to stop the container before destroying. Container will be destroyed after n seconds or on successful stop.

devices

val devices: Output<List<ContainerDevice>>?

Bind devices to the container.

dns

val dns: Output<List<String>>?

DNS servers to use.

dnsOpts

val dnsOpts: Output<List<String>>?

DNS options used by the DNS provider(s), see resolv.conf documentation for valid list of options.

dnsSearches

val dnsSearches: Output<List<String>>?

DNS search domains that are used when bare unqualified hostnames are used inside of the container.

domainname

val domainname: Output<String>?

Domain name of the container.

entrypoints

val entrypoints: Output<List<String>>

The command to use as the Entrypoint for the container. The Entrypoint allows you to configure a container to run as an executable. For example, to run /usr/bin/myprogram when starting a container, set the entrypoint to be "/usr/bin/myprogra"].

envs

val envs: Output<List<String>>

Environment variables to set in the form of KEY=VALUE, e.g. DEBUG=0

exitCode

val exitCode: Output<Int>

The exit code of the container if its execution is done (must_run must be disabled).

gpus

val gpus: Output<String>?

GPU devices to add to the container. Currently, only the value all is supported. Passing any other value will result in unexpected behavior.

groupAdds

val groupAdds: Output<List<String>>?

Additional groups for the container user

healthcheck

val healthcheck: Output<ContainerHealthcheck>

A test to perform to check that the container is healthy

hostname

val hostname: Output<String>

Hostname of the container.

hosts

val hosts: Output<List<ContainerHost>>?

Additional hosts to add to the container.

val id: Output<String>

image

val image: Output<String>

The ID of the image to back this container. The easiest way to get this value is to use the docker.RemoteImage resource as is shown in the example.

init

val init: Output<Boolean>

Configured whether an init process should be injected for this container. If unset this will default to the dockerd defaults.

ipcMode

val ipcMode: Output<String>

IPC sharing mode for the container. Possible values are: none, private, shareable, container:<name|id> or host.

labels

val labels: Output<List<ContainerLabel>>

User-defined key/value metadata

logDriver

val logDriver: Output<String>

The logging driver to use for the container.

logOpts

val logOpts: Output<Map<String, Any>>?

Key/value pairs to use as options for the logging driver.

logs

val logs: Output<Boolean>?

Save the container logs (attach must be enabled). Defaults to false.

maxRetryCount

val maxRetryCount: Output<Int>?

The maximum amount of times to an attempt a restart when restart is set to 'on-failure'.

memory

val memory: Output<Int>?

The memory limit for the container in MBs.

memorySwap

val memorySwap: Output<Int>?

The total memory limit (memory + swap) for the container in MBs. This setting may compute to -1 after pulumi up if the target host doesn't support memory swap, when that is the case docker will use a soft limitation.

mounts

val mounts: Output<List<ContainerMount>>?

Specification for mounts to be added to containers created as part of the service.

mustRun

val mustRun: Output<Boolean>?

If true, then the Docker container will be kept running. If false, then as long as the container exists, Terraform assumes it is successful. Defaults to true.

name

val name: Output<String>

The name of the container.

networkDatas

val networkDatas: Output<List<ContainerNetworkData>>

The data of the networks the container is connected to.

networkMode

val networkMode: Output<String>?

Network mode of the container.

networksAdvanced

val networksAdvanced: Output<List<ContainerNetworksAdvanced>>?

The networks the container is attached to

pidMode

val pidMode: Output<String>?

he PID (Process) Namespace mode for the container. Either container:<name|id> or host.

ports

val ports: Output<List<ContainerPort>>?

Publish a container's port(s) to the host.

privileged

val privileged: Output<Boolean>?

If true, the container runs in privileged mode.

publishAllPorts

val publishAllPorts: Output<Boolean>?

Publish all ports of the container.

pulumiChildResources

val pulumiChildResources: Set<KotlinResource>

pulumiResourceName

val pulumiResourceName: String

pulumiResourceType

val pulumiResourceType: String

readOnly

val readOnly: Output<Boolean>?

If true, the container will be started as readonly. Defaults to false.

removeVolumes

val removeVolumes: Output<Boolean>?

If true, it will remove anonymous volumes associated with the container. Defaults to true.

restart

val restart: Output<String>?

The restart policy for the container. Must be one of 'no', 'on-failure', 'always', 'unless-stopped'. Defaults to no.

val rm: Output<Boolean>?

If true, then the container will be automatically removed when it exits. Defaults to false.

runtime

val runtime: Output<String>

Runtime to use for the container.

securityOpts

val securityOpts: Output<List<String>>

List of string values to customize labels for MLS systems, such as SELinux. See https://docs.docker.com/engine/reference/run/#security-configuration.

shmSize

val shmSize: Output<Int>

Size of /dev/shm in MBs.

start

val start: Output<Boolean>?

If true, then the Docker container will be started after creation. If false, then the container is only created. Defaults to true.

stdinOpen

val stdinOpen: Output<Boolean>?

If true, keep STDIN open even if not attached (docker run -i). Defaults to false.

stopSignal

val stopSignal: Output<String>

Signal to stop a container (default SIGTERM).

stopTimeout

val stopTimeout: Output<Int>

Timeout (in seconds) to stop a container.

storageOpts

val storageOpts: Output<Map<String, Any>>?

Key/value pairs for the storage driver options, e.g. size: 120G

sysctls

val sysctls: Output<Map<String, Any>>?

A map of kernel parameters (sysctls) to set in the container.

tmpfs

val tmpfs: Output<Map<String, Any>>?

A map of container directories which should be replaced by tmpfs mounts, and their corresponding mount options.

tty

val tty: Output<Boolean>?

If true, allocate a pseudo-tty (docker run -t). Defaults to false.

ulimits

val ulimits: Output<List<ContainerUlimit>>?

Ulimit options to add.

uploads

val uploads: Output<List<ContainerUpload>>?

Specifies files to upload to the container before starting it. Only one of content or content_base64 can be set and at least one of them has to be set.

urn

val urn: Output<String>

user

val user: Output<String>?

User used for run the first process. Format is user or user:group which user and group can be passed literraly or by name.

usernsMode

val usernsMode: Output<String>?

Sets the usernamespace mode for the container when usernamespace remapping option is enabled.

volumes

val volumes: Output<List<ContainerVolume>>?

Spec for mounting volumes in the container.

wait

val wait: Output<Boolean>?

If true, then the Docker container is waited for being healthy state after creation. If false, then the container health state is not checked. Defaults to false.

waitTimeout

val waitTimeout: Output<Int>?

The timeout in seconds to wait the container to be healthy after creation. Defaults to 60.

workingDir

val workingDir: Output<String>?

The working directory for commands to run in.

Container

Example Usage

Import

Example Assuming you created a container as follows #!/bin/bash docker run --name foo -p8080:80 -d nginx

Properties

Example Assuming you created a `container` as follows #!/bin/bash docker run --name foo -p8080:80 -d nginx