pulumi-docker 4.6.2__py3-none-any.whl → 4.7.0__py3-none-any.whl
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Potentially problematic release.
This version of pulumi-docker might be problematic. Click here for more details.
- pulumi_docker/__init__.py +2 -0
- pulumi_docker/_enums.py +4 -1
- pulumi_docker/_inputs.py +1519 -1203
- pulumi_docker/config/__init__.py +1 -0
- pulumi_docker/config/__init__.pyi +13 -0
- pulumi_docker/config/outputs.py +18 -17
- pulumi_docker/config/vars.py +17 -0
- pulumi_docker/container.py +795 -746
- pulumi_docker/get_logs.py +42 -41
- pulumi_docker/get_network.py +11 -10
- pulumi_docker/get_plugin.py +16 -15
- pulumi_docker/get_registry_image.py +13 -12
- pulumi_docker/get_registry_image_manifests.py +151 -0
- pulumi_docker/get_remote_image.py +8 -7
- pulumi_docker/image.py +30 -28
- pulumi_docker/network.py +158 -147
- pulumi_docker/outputs.py +931 -691
- pulumi_docker/plugin.py +121 -119
- pulumi_docker/provider.py +124 -47
- pulumi_docker/pulumi-plugin.json +1 -1
- pulumi_docker/registry_image.py +116 -65
- pulumi_docker/remote_image.py +104 -229
- pulumi_docker/secret.py +30 -28
- pulumi_docker/service.py +16 -14
- pulumi_docker/service_config.py +30 -28
- pulumi_docker/tag.py +84 -35
- pulumi_docker/volume.py +51 -49
- {pulumi_docker-4.6.2.dist-info → pulumi_docker-4.7.0.dist-info}/METADATA +4 -4
- pulumi_docker-4.7.0.dist-info/RECORD +33 -0
- {pulumi_docker-4.6.2.dist-info → pulumi_docker-4.7.0.dist-info}/WHEEL +1 -1
- pulumi_docker-4.6.2.dist-info/RECORD +0 -32
- {pulumi_docker-4.6.2.dist-info → pulumi_docker-4.7.0.dist-info}/top_level.txt +0 -0
pulumi_docker/container.py
CHANGED
|
@@ -2,6 +2,7 @@
|
|
|
2
2
|
# *** WARNING: this file was generated by the Pulumi Terraform Bridge (tfgen) Tool. ***
|
|
3
3
|
# *** Do not edit by hand unless you're certain you know what you are doing! ***
|
|
4
4
|
|
|
5
|
+
import builtins
|
|
5
6
|
import copy
|
|
6
7
|
import warnings
|
|
7
8
|
import sys
|
|
@@ -21,131 +22,133 @@ __all__ = ['ContainerArgs', 'Container']
|
|
|
21
22
|
@pulumi.input_type
|
|
22
23
|
class ContainerArgs:
|
|
23
24
|
def __init__(__self__, *,
|
|
24
|
-
image: pulumi.Input[str],
|
|
25
|
-
attach: Optional[pulumi.Input[bool]] = None,
|
|
25
|
+
image: pulumi.Input[builtins.str],
|
|
26
|
+
attach: Optional[pulumi.Input[builtins.bool]] = None,
|
|
26
27
|
capabilities: Optional[pulumi.Input['ContainerCapabilitiesArgs']] = None,
|
|
27
|
-
cgroupns_mode: Optional[pulumi.Input[str]] = None,
|
|
28
|
-
command: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
|
|
29
|
-
container_read_refresh_timeout_milliseconds: Optional[pulumi.Input[int]] = None,
|
|
30
|
-
cpu_set: Optional[pulumi.Input[str]] = None,
|
|
31
|
-
cpu_shares: Optional[pulumi.Input[int]] = None,
|
|
32
|
-
|
|
28
|
+
cgroupns_mode: Optional[pulumi.Input[builtins.str]] = None,
|
|
29
|
+
command: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None,
|
|
30
|
+
container_read_refresh_timeout_milliseconds: Optional[pulumi.Input[builtins.int]] = None,
|
|
31
|
+
cpu_set: Optional[pulumi.Input[builtins.str]] = None,
|
|
32
|
+
cpu_shares: Optional[pulumi.Input[builtins.int]] = None,
|
|
33
|
+
cpus: Optional[pulumi.Input[builtins.str]] = None,
|
|
34
|
+
destroy_grace_seconds: Optional[pulumi.Input[builtins.int]] = None,
|
|
33
35
|
devices: Optional[pulumi.Input[Sequence[pulumi.Input['ContainerDeviceArgs']]]] = None,
|
|
34
|
-
dns: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
|
|
35
|
-
dns_opts: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
|
|
36
|
-
dns_searches: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
|
|
37
|
-
domainname: Optional[pulumi.Input[str]] = None,
|
|
38
|
-
entrypoints: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
|
|
39
|
-
envs: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
|
|
40
|
-
gpus: Optional[pulumi.Input[str]] = None,
|
|
41
|
-
group_adds: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
|
|
36
|
+
dns: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None,
|
|
37
|
+
dns_opts: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None,
|
|
38
|
+
dns_searches: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None,
|
|
39
|
+
domainname: Optional[pulumi.Input[builtins.str]] = None,
|
|
40
|
+
entrypoints: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None,
|
|
41
|
+
envs: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None,
|
|
42
|
+
gpus: Optional[pulumi.Input[builtins.str]] = None,
|
|
43
|
+
group_adds: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None,
|
|
42
44
|
healthcheck: Optional[pulumi.Input['ContainerHealthcheckArgs']] = None,
|
|
43
|
-
hostname: Optional[pulumi.Input[str]] = None,
|
|
45
|
+
hostname: Optional[pulumi.Input[builtins.str]] = None,
|
|
44
46
|
hosts: Optional[pulumi.Input[Sequence[pulumi.Input['ContainerHostArgs']]]] = None,
|
|
45
|
-
init: Optional[pulumi.Input[bool]] = None,
|
|
46
|
-
ipc_mode: Optional[pulumi.Input[str]] = None,
|
|
47
|
+
init: Optional[pulumi.Input[builtins.bool]] = None,
|
|
48
|
+
ipc_mode: Optional[pulumi.Input[builtins.str]] = None,
|
|
47
49
|
labels: Optional[pulumi.Input[Sequence[pulumi.Input['ContainerLabelArgs']]]] = None,
|
|
48
|
-
log_driver: Optional[pulumi.Input[str]] = None,
|
|
49
|
-
log_opts: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None,
|
|
50
|
-
logs: Optional[pulumi.Input[bool]] = None,
|
|
51
|
-
max_retry_count: Optional[pulumi.Input[int]] = None,
|
|
52
|
-
memory: Optional[pulumi.Input[int]] = None,
|
|
53
|
-
memory_swap: Optional[pulumi.Input[int]] = None,
|
|
50
|
+
log_driver: Optional[pulumi.Input[builtins.str]] = None,
|
|
51
|
+
log_opts: Optional[pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]] = None,
|
|
52
|
+
logs: Optional[pulumi.Input[builtins.bool]] = None,
|
|
53
|
+
max_retry_count: Optional[pulumi.Input[builtins.int]] = None,
|
|
54
|
+
memory: Optional[pulumi.Input[builtins.int]] = None,
|
|
55
|
+
memory_swap: Optional[pulumi.Input[builtins.int]] = None,
|
|
54
56
|
mounts: Optional[pulumi.Input[Sequence[pulumi.Input['ContainerMountArgs']]]] = None,
|
|
55
|
-
must_run: Optional[pulumi.Input[bool]] = None,
|
|
56
|
-
name: Optional[pulumi.Input[str]] = None,
|
|
57
|
-
network_mode: Optional[pulumi.Input[str]] = None,
|
|
57
|
+
must_run: Optional[pulumi.Input[builtins.bool]] = None,
|
|
58
|
+
name: Optional[pulumi.Input[builtins.str]] = None,
|
|
59
|
+
network_mode: Optional[pulumi.Input[builtins.str]] = None,
|
|
58
60
|
networks_advanced: Optional[pulumi.Input[Sequence[pulumi.Input['ContainerNetworksAdvancedArgs']]]] = None,
|
|
59
|
-
pid_mode: Optional[pulumi.Input[str]] = None,
|
|
61
|
+
pid_mode: Optional[pulumi.Input[builtins.str]] = None,
|
|
60
62
|
ports: Optional[pulumi.Input[Sequence[pulumi.Input['ContainerPortArgs']]]] = None,
|
|
61
|
-
privileged: Optional[pulumi.Input[bool]] = None,
|
|
62
|
-
publish_all_ports: Optional[pulumi.Input[bool]] = None,
|
|
63
|
-
read_only: Optional[pulumi.Input[bool]] = None,
|
|
64
|
-
remove_volumes: Optional[pulumi.Input[bool]] = None,
|
|
65
|
-
restart: Optional[pulumi.Input[str]] = None,
|
|
66
|
-
rm: Optional[pulumi.Input[bool]] = None,
|
|
67
|
-
runtime: Optional[pulumi.Input[str]] = None,
|
|
68
|
-
security_opts: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
|
|
69
|
-
shm_size: Optional[pulumi.Input[int]] = None,
|
|
70
|
-
start: Optional[pulumi.Input[bool]] = None,
|
|
71
|
-
stdin_open: Optional[pulumi.Input[bool]] = None,
|
|
72
|
-
stop_signal: Optional[pulumi.Input[str]] = None,
|
|
73
|
-
stop_timeout: Optional[pulumi.Input[int]] = None,
|
|
74
|
-
storage_opts: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None,
|
|
75
|
-
sysctls: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None,
|
|
76
|
-
tmpfs: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None,
|
|
77
|
-
tty: Optional[pulumi.Input[bool]] = None,
|
|
63
|
+
privileged: Optional[pulumi.Input[builtins.bool]] = None,
|
|
64
|
+
publish_all_ports: Optional[pulumi.Input[builtins.bool]] = None,
|
|
65
|
+
read_only: Optional[pulumi.Input[builtins.bool]] = None,
|
|
66
|
+
remove_volumes: Optional[pulumi.Input[builtins.bool]] = None,
|
|
67
|
+
restart: Optional[pulumi.Input[builtins.str]] = None,
|
|
68
|
+
rm: Optional[pulumi.Input[builtins.bool]] = None,
|
|
69
|
+
runtime: Optional[pulumi.Input[builtins.str]] = None,
|
|
70
|
+
security_opts: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None,
|
|
71
|
+
shm_size: Optional[pulumi.Input[builtins.int]] = None,
|
|
72
|
+
start: Optional[pulumi.Input[builtins.bool]] = None,
|
|
73
|
+
stdin_open: Optional[pulumi.Input[builtins.bool]] = None,
|
|
74
|
+
stop_signal: Optional[pulumi.Input[builtins.str]] = None,
|
|
75
|
+
stop_timeout: Optional[pulumi.Input[builtins.int]] = None,
|
|
76
|
+
storage_opts: Optional[pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]] = None,
|
|
77
|
+
sysctls: Optional[pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]] = None,
|
|
78
|
+
tmpfs: Optional[pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]] = None,
|
|
79
|
+
tty: Optional[pulumi.Input[builtins.bool]] = None,
|
|
78
80
|
ulimits: Optional[pulumi.Input[Sequence[pulumi.Input['ContainerUlimitArgs']]]] = None,
|
|
79
81
|
uploads: Optional[pulumi.Input[Sequence[pulumi.Input['ContainerUploadArgs']]]] = None,
|
|
80
|
-
user: Optional[pulumi.Input[str]] = None,
|
|
81
|
-
userns_mode: Optional[pulumi.Input[str]] = None,
|
|
82
|
+
user: Optional[pulumi.Input[builtins.str]] = None,
|
|
83
|
+
userns_mode: Optional[pulumi.Input[builtins.str]] = None,
|
|
82
84
|
volumes: Optional[pulumi.Input[Sequence[pulumi.Input['ContainerVolumeArgs']]]] = None,
|
|
83
|
-
wait: Optional[pulumi.Input[bool]] = None,
|
|
84
|
-
wait_timeout: Optional[pulumi.Input[int]] = None,
|
|
85
|
-
working_dir: Optional[pulumi.Input[str]] = None):
|
|
85
|
+
wait: Optional[pulumi.Input[builtins.bool]] = None,
|
|
86
|
+
wait_timeout: Optional[pulumi.Input[builtins.int]] = None,
|
|
87
|
+
working_dir: Optional[pulumi.Input[builtins.str]] = None):
|
|
86
88
|
"""
|
|
87
89
|
The set of arguments for constructing a Container resource.
|
|
88
|
-
:param pulumi.Input[str] image: The ID of the image to back this container. The easiest way to get this value is to use the `RemoteImage` resource as is shown in the example.
|
|
89
|
-
:param pulumi.Input[bool] attach: If `true` attach to the container after its creation and waits the end of its execution. Defaults to `false`.
|
|
90
|
+
:param pulumi.Input[builtins.str] image: The ID of the image to back this container. The easiest way to get this value is to use the `image_id` attribute of the `RemoteImage` resource as is shown in the example.
|
|
91
|
+
:param pulumi.Input[builtins.bool] attach: If `true` attach to the container after its creation and waits the end of its execution. Defaults to `false`.
|
|
90
92
|
:param pulumi.Input['ContainerCapabilitiesArgs'] capabilities: Add or drop certrain linux capabilities.
|
|
91
|
-
:param pulumi.Input[str] cgroupns_mode: Cgroup namespace mode to use for the container. Possible values are: `private`, `host`.
|
|
92
|
-
:param pulumi.Input[Sequence[pulumi.Input[str]]] command: 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.
|
|
93
|
-
:param pulumi.Input[int] container_read_refresh_timeout_milliseconds: The total number of milliseconds to wait for the container to reach status 'running'
|
|
94
|
-
:param pulumi.Input[str] cpu_set: A comma-separated list or hyphen-separated range of CPUs a container can use, e.g. `0-1`.
|
|
95
|
-
:param pulumi.Input[int] cpu_shares: CPU shares (relative weight) for the container.
|
|
96
|
-
:param pulumi.Input[
|
|
93
|
+
:param pulumi.Input[builtins.str] cgroupns_mode: Cgroup namespace mode to use for the container. Possible values are: `private`, `host`.
|
|
94
|
+
:param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] command: 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.conf"]`.
|
|
95
|
+
:param pulumi.Input[builtins.int] container_read_refresh_timeout_milliseconds: The total number of milliseconds to wait for the container to reach status 'running'
|
|
96
|
+
:param pulumi.Input[builtins.str] cpu_set: A comma-separated list or hyphen-separated range of CPUs a container can use, e.g. `0-1`.
|
|
97
|
+
:param pulumi.Input[builtins.int] cpu_shares: CPU shares (relative weight) for the container.
|
|
98
|
+
:param pulumi.Input[builtins.str] cpus: Specify how much of the available CPU resources a container can use. e.g a value of 1.5 means the container is guaranteed at most one and a half of the CPUs
|
|
99
|
+
:param pulumi.Input[builtins.int] destroy_grace_seconds: If defined will attempt to stop the container before destroying. Container will be destroyed after `n` seconds or on successful stop.
|
|
97
100
|
:param pulumi.Input[Sequence[pulumi.Input['ContainerDeviceArgs']]] devices: Bind devices to the container.
|
|
98
|
-
:param pulumi.Input[Sequence[pulumi.Input[str]]] dns: DNS servers to use.
|
|
99
|
-
:param pulumi.Input[Sequence[pulumi.Input[str]]] dns_opts: DNS options used by the DNS provider(s), see `resolv.conf` documentation for valid list of options.
|
|
100
|
-
:param pulumi.Input[Sequence[pulumi.Input[str]]] dns_searches: DNS search domains that are used when bare unqualified hostnames are used inside of the container.
|
|
101
|
-
:param pulumi.Input[str] domainname: Domain name of the container.
|
|
102
|
-
:param pulumi.Input[Sequence[pulumi.Input[str]]] entrypoints: 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/
|
|
103
|
-
:param pulumi.Input[Sequence[pulumi.Input[str]]] envs: Environment variables to set in the form of `KEY=VALUE`, e.g. `DEBUG=0`
|
|
104
|
-
:param pulumi.Input[str] gpus: GPU devices to add to the container. Currently, only the value `all` is supported. Passing any other value will result in unexpected behavior.
|
|
105
|
-
:param pulumi.Input[Sequence[pulumi.Input[str]]] group_adds: Additional groups for the container user
|
|
101
|
+
:param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] dns: DNS servers to use.
|
|
102
|
+
:param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] dns_opts: DNS options used by the DNS provider(s), see `resolv.conf` documentation for valid list of options.
|
|
103
|
+
:param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] dns_searches: DNS search domains that are used when bare unqualified hostnames are used inside of the container.
|
|
104
|
+
:param pulumi.Input[builtins.str] domainname: Domain name of the container.
|
|
105
|
+
:param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] entrypoints: 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/myprogram"]`.
|
|
106
|
+
:param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] envs: Environment variables to set in the form of `KEY=VALUE`, e.g. `DEBUG=0`
|
|
107
|
+
:param pulumi.Input[builtins.str] gpus: GPU devices to add to the container. Currently, only the value `all` is supported. Passing any other value will result in unexpected behavior.
|
|
108
|
+
:param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] group_adds: Additional groups for the container user
|
|
106
109
|
:param pulumi.Input['ContainerHealthcheckArgs'] healthcheck: A test to perform to check that the container is healthy
|
|
107
|
-
:param pulumi.Input[str] hostname: Hostname of the container.
|
|
110
|
+
:param pulumi.Input[builtins.str] hostname: Hostname of the container.
|
|
108
111
|
:param pulumi.Input[Sequence[pulumi.Input['ContainerHostArgs']]] hosts: Additional hosts to add to the container.
|
|
109
|
-
:param pulumi.Input[bool] init: Configured whether an init process should be injected for this container. If unset this will default to the `dockerd` defaults.
|
|
110
|
-
:param pulumi.Input[str] ipc_mode: IPC sharing mode for the container. Possible values are: `none`, `private`, `shareable`, `container:<name|id>` or `host`.
|
|
112
|
+
:param pulumi.Input[builtins.bool] init: Configured whether an init process should be injected for this container. If unset this will default to the `dockerd` defaults.
|
|
113
|
+
:param pulumi.Input[builtins.str] ipc_mode: IPC sharing mode for the container. Possible values are: `none`, `private`, `shareable`, `container:<name|id>` or `host`.
|
|
111
114
|
:param pulumi.Input[Sequence[pulumi.Input['ContainerLabelArgs']]] labels: User-defined key/value metadata
|
|
112
|
-
:param pulumi.Input[str] log_driver: The logging driver to use for the container.
|
|
113
|
-
:param pulumi.Input[Mapping[str, pulumi.Input[str]]] log_opts: Key/value pairs to use as options for the logging driver.
|
|
114
|
-
:param pulumi.Input[bool] logs: Save the container logs (`attach` must be enabled). Defaults to `false`.
|
|
115
|
-
:param pulumi.Input[int] max_retry_count: The maximum amount of times to an attempt a restart when `restart` is set to 'on-failure'.
|
|
116
|
-
:param pulumi.Input[int] memory: The memory limit for the container in MBs.
|
|
117
|
-
:param pulumi.Input[int] memory_swap: 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.
|
|
115
|
+
:param pulumi.Input[builtins.str] log_driver: The logging driver to use for the container.
|
|
116
|
+
:param pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]] log_opts: Key/value pairs to use as options for the logging driver.
|
|
117
|
+
:param pulumi.Input[builtins.bool] logs: Save the container logs (`attach` must be enabled). Defaults to `false`.
|
|
118
|
+
:param pulumi.Input[builtins.int] max_retry_count: The maximum amount of times to an attempt a restart when `restart` is set to 'on-failure'.
|
|
119
|
+
:param pulumi.Input[builtins.int] memory: The memory limit for the container in MBs.
|
|
120
|
+
:param pulumi.Input[builtins.int] memory_swap: 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.
|
|
118
121
|
:param pulumi.Input[Sequence[pulumi.Input['ContainerMountArgs']]] mounts: Specification for mounts to be added to containers created as part of the service.
|
|
119
|
-
:param pulumi.Input[str] name: The name of the container.
|
|
120
|
-
:param pulumi.Input[str] network_mode: Network mode of the container.
|
|
122
|
+
:param pulumi.Input[builtins.str] name: The name of the container.
|
|
123
|
+
:param pulumi.Input[builtins.str] network_mode: Network mode of the container. See https://docs.docker.com/engine/network/ for more information.
|
|
121
124
|
:param pulumi.Input[Sequence[pulumi.Input['ContainerNetworksAdvancedArgs']]] networks_advanced: The networks the container is attached to
|
|
122
|
-
:param pulumi.Input[str] pid_mode: he PID (Process) Namespace mode for the container. Either `container:<name|id>` or `host`.
|
|
125
|
+
:param pulumi.Input[builtins.str] pid_mode: he PID (Process) Namespace mode for the container. Either `container:<name|id>` or `host`.
|
|
123
126
|
:param pulumi.Input[Sequence[pulumi.Input['ContainerPortArgs']]] ports: Publish a container's port(s) to the host.
|
|
124
|
-
:param pulumi.Input[bool] privileged: If `true`, the container runs in privileged mode.
|
|
125
|
-
:param pulumi.Input[bool] publish_all_ports: Publish all ports of the container.
|
|
126
|
-
:param pulumi.Input[bool] read_only: If `true`, the container will be started as readonly. Defaults to `false`.
|
|
127
|
-
:param pulumi.Input[bool] remove_volumes: If `true`, it will remove anonymous volumes associated with the container. Defaults to `true`.
|
|
128
|
-
:param pulumi.Input[str] restart: The restart policy for the container. Must be one of 'no', 'on-failure', 'always', 'unless-stopped'. Defaults to `no`.
|
|
129
|
-
:param pulumi.Input[bool] rm: If `true`, then the container will be automatically removed when it exits. Defaults to `false`.
|
|
130
|
-
:param pulumi.Input[str] runtime: Runtime to use for the container.
|
|
131
|
-
:param pulumi.Input[Sequence[pulumi.Input[str]]] security_opts: List of string values to customize labels for MLS systems, such as SELinux. See https://docs.docker.com/engine/reference/run/#security-configuration.
|
|
132
|
-
:param pulumi.Input[int] shm_size: Size of `/dev/shm` in MBs.
|
|
133
|
-
:param pulumi.Input[bool] start: If `true`, then the Docker container will be started after creation. If `false`, then the container is only created. Defaults to `true`.
|
|
134
|
-
:param pulumi.Input[bool] stdin_open: If `true`, keep STDIN open even if not attached (`docker run -i`). Defaults to `false`.
|
|
135
|
-
:param pulumi.Input[str] stop_signal: Signal to stop a container (default `SIGTERM`).
|
|
136
|
-
:param pulumi.Input[int] stop_timeout: Timeout (in seconds) to stop a container.
|
|
137
|
-
:param pulumi.Input[Mapping[str, pulumi.Input[str]]] storage_opts: Key/value pairs for the storage driver options, e.g. `size`: `120G`
|
|
138
|
-
:param pulumi.Input[Mapping[str, pulumi.Input[str]]] sysctls: A map of kernel parameters (sysctls) to set in the container.
|
|
139
|
-
:param pulumi.Input[Mapping[str, pulumi.Input[str]]] tmpfs: A map of container directories which should be replaced by `tmpfs mounts`, and their corresponding mount options.
|
|
140
|
-
:param pulumi.Input[bool] tty: If `true`, allocate a pseudo-tty (`docker run -t`). Defaults to `false`.
|
|
127
|
+
:param pulumi.Input[builtins.bool] privileged: If `true`, the container runs in privileged mode.
|
|
128
|
+
:param pulumi.Input[builtins.bool] publish_all_ports: Publish all ports of the container.
|
|
129
|
+
:param pulumi.Input[builtins.bool] read_only: If `true`, the container will be started as readonly. Defaults to `false`.
|
|
130
|
+
:param pulumi.Input[builtins.bool] remove_volumes: If `true`, it will remove anonymous volumes associated with the container. Defaults to `true`.
|
|
131
|
+
:param pulumi.Input[builtins.str] restart: The restart policy for the container. Must be one of 'no', 'on-failure', 'always', 'unless-stopped'. Defaults to `no`.
|
|
132
|
+
:param pulumi.Input[builtins.bool] rm: If `true`, then the container will be automatically removed when it exits. Defaults to `false`.
|
|
133
|
+
:param pulumi.Input[builtins.str] runtime: Runtime to use for the container.
|
|
134
|
+
:param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] security_opts: List of string values to customize labels for MLS systems, such as SELinux. See https://docs.docker.com/engine/reference/run/#security-configuration.
|
|
135
|
+
:param pulumi.Input[builtins.int] shm_size: Size of `/dev/shm` in MBs.
|
|
136
|
+
:param pulumi.Input[builtins.bool] start: If `true`, then the Docker container will be started after creation. If `false`, then the container is only created. Defaults to `true`.
|
|
137
|
+
:param pulumi.Input[builtins.bool] stdin_open: If `true`, keep STDIN open even if not attached (`docker run -i`). Defaults to `false`.
|
|
138
|
+
:param pulumi.Input[builtins.str] stop_signal: Signal to stop a container (default `SIGTERM`).
|
|
139
|
+
:param pulumi.Input[builtins.int] stop_timeout: Timeout (in seconds) to stop a container.
|
|
140
|
+
:param pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]] storage_opts: Key/value pairs for the storage driver options, e.g. `size`: `120G`
|
|
141
|
+
:param pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]] sysctls: A map of kernel parameters (sysctls) to set in the container.
|
|
142
|
+
:param pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]] tmpfs: A map of container directories which should be replaced by `tmpfs mounts`, and their corresponding mount options.
|
|
143
|
+
:param pulumi.Input[builtins.bool] tty: If `true`, allocate a pseudo-tty (`docker run -t`). Defaults to `false`.
|
|
141
144
|
:param pulumi.Input[Sequence[pulumi.Input['ContainerUlimitArgs']]] ulimits: Ulimit options to add.
|
|
142
145
|
:param pulumi.Input[Sequence[pulumi.Input['ContainerUploadArgs']]] uploads: 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.
|
|
143
|
-
:param pulumi.Input[str] user: User used for run the first process. Format is `user` or `user:group` which user and group can be passed literraly or by name.
|
|
144
|
-
:param pulumi.Input[str] userns_mode: Sets the usernamespace mode for the container when usernamespace remapping option is enabled.
|
|
146
|
+
:param pulumi.Input[builtins.str] user: User used for run the first process. Format is `user` or `user:group` which user and group can be passed literraly or by name.
|
|
147
|
+
:param pulumi.Input[builtins.str] userns_mode: Sets the usernamespace mode for the container when usernamespace remapping option is enabled.
|
|
145
148
|
:param pulumi.Input[Sequence[pulumi.Input['ContainerVolumeArgs']]] volumes: Spec for mounting volumes in the container.
|
|
146
|
-
:param pulumi.Input[bool] wait: 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`.
|
|
147
|
-
:param pulumi.Input[int] wait_timeout: The timeout in seconds to wait the container to be healthy after creation. Defaults to `60`.
|
|
148
|
-
:param pulumi.Input[str] working_dir: The working directory for commands to run in.
|
|
149
|
+
:param pulumi.Input[builtins.bool] wait: If `true`, then the Docker container is waited for being healthy state after creation. This requires your container to have a healthcheck, otherwise this provider will error. If `false`, then the container health state is not checked. Defaults to `false`.
|
|
150
|
+
:param pulumi.Input[builtins.int] wait_timeout: The timeout in seconds to wait the container to be healthy after creation. Defaults to `60`.
|
|
151
|
+
:param pulumi.Input[builtins.str] working_dir: The working directory for commands to run in.
|
|
149
152
|
"""
|
|
150
153
|
pulumi.set(__self__, "image", image)
|
|
151
154
|
if attach is not None:
|
|
@@ -162,6 +165,8 @@ class ContainerArgs:
|
|
|
162
165
|
pulumi.set(__self__, "cpu_set", cpu_set)
|
|
163
166
|
if cpu_shares is not None:
|
|
164
167
|
pulumi.set(__self__, "cpu_shares", cpu_shares)
|
|
168
|
+
if cpus is not None:
|
|
169
|
+
pulumi.set(__self__, "cpus", cpus)
|
|
165
170
|
if destroy_grace_seconds is not None:
|
|
166
171
|
pulumi.set(__self__, "destroy_grace_seconds", destroy_grace_seconds)
|
|
167
172
|
if devices is not None:
|
|
@@ -273,26 +278,26 @@ class ContainerArgs:
|
|
|
273
278
|
|
|
274
279
|
@property
|
|
275
280
|
@pulumi.getter
|
|
276
|
-
def image(self) -> pulumi.Input[str]:
|
|
281
|
+
def image(self) -> pulumi.Input[builtins.str]:
|
|
277
282
|
"""
|
|
278
|
-
The ID of the image to back this container. The easiest way to get this value is to use the `RemoteImage` resource as is shown in the example.
|
|
283
|
+
The ID of the image to back this container. The easiest way to get this value is to use the `image_id` attribute of the `RemoteImage` resource as is shown in the example.
|
|
279
284
|
"""
|
|
280
285
|
return pulumi.get(self, "image")
|
|
281
286
|
|
|
282
287
|
@image.setter
|
|
283
|
-
def image(self, value: pulumi.Input[str]):
|
|
288
|
+
def image(self, value: pulumi.Input[builtins.str]):
|
|
284
289
|
pulumi.set(self, "image", value)
|
|
285
290
|
|
|
286
291
|
@property
|
|
287
292
|
@pulumi.getter
|
|
288
|
-
def attach(self) -> Optional[pulumi.Input[bool]]:
|
|
293
|
+
def attach(self) -> Optional[pulumi.Input[builtins.bool]]:
|
|
289
294
|
"""
|
|
290
295
|
If `true` attach to the container after its creation and waits the end of its execution. Defaults to `false`.
|
|
291
296
|
"""
|
|
292
297
|
return pulumi.get(self, "attach")
|
|
293
298
|
|
|
294
299
|
@attach.setter
|
|
295
|
-
def attach(self, value: Optional[pulumi.Input[bool]]):
|
|
300
|
+
def attach(self, value: Optional[pulumi.Input[builtins.bool]]):
|
|
296
301
|
pulumi.set(self, "attach", value)
|
|
297
302
|
|
|
298
303
|
@property
|
|
@@ -309,74 +314,86 @@ class ContainerArgs:
|
|
|
309
314
|
|
|
310
315
|
@property
|
|
311
316
|
@pulumi.getter(name="cgroupnsMode")
|
|
312
|
-
def cgroupns_mode(self) -> Optional[pulumi.Input[str]]:
|
|
317
|
+
def cgroupns_mode(self) -> Optional[pulumi.Input[builtins.str]]:
|
|
313
318
|
"""
|
|
314
319
|
Cgroup namespace mode to use for the container. Possible values are: `private`, `host`.
|
|
315
320
|
"""
|
|
316
321
|
return pulumi.get(self, "cgroupns_mode")
|
|
317
322
|
|
|
318
323
|
@cgroupns_mode.setter
|
|
319
|
-
def cgroupns_mode(self, value: Optional[pulumi.Input[str]]):
|
|
324
|
+
def cgroupns_mode(self, value: Optional[pulumi.Input[builtins.str]]):
|
|
320
325
|
pulumi.set(self, "cgroupns_mode", value)
|
|
321
326
|
|
|
322
327
|
@property
|
|
323
328
|
@pulumi.getter
|
|
324
|
-
def command(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
|
|
329
|
+
def command(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]:
|
|
325
330
|
"""
|
|
326
|
-
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.
|
|
331
|
+
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.conf"]`.
|
|
327
332
|
"""
|
|
328
333
|
return pulumi.get(self, "command")
|
|
329
334
|
|
|
330
335
|
@command.setter
|
|
331
|
-
def command(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
|
|
336
|
+
def command(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]):
|
|
332
337
|
pulumi.set(self, "command", value)
|
|
333
338
|
|
|
334
339
|
@property
|
|
335
340
|
@pulumi.getter(name="containerReadRefreshTimeoutMilliseconds")
|
|
336
|
-
def container_read_refresh_timeout_milliseconds(self) -> Optional[pulumi.Input[int]]:
|
|
341
|
+
def container_read_refresh_timeout_milliseconds(self) -> Optional[pulumi.Input[builtins.int]]:
|
|
337
342
|
"""
|
|
338
343
|
The total number of milliseconds to wait for the container to reach status 'running'
|
|
339
344
|
"""
|
|
340
345
|
return pulumi.get(self, "container_read_refresh_timeout_milliseconds")
|
|
341
346
|
|
|
342
347
|
@container_read_refresh_timeout_milliseconds.setter
|
|
343
|
-
def container_read_refresh_timeout_milliseconds(self, value: Optional[pulumi.Input[int]]):
|
|
348
|
+
def container_read_refresh_timeout_milliseconds(self, value: Optional[pulumi.Input[builtins.int]]):
|
|
344
349
|
pulumi.set(self, "container_read_refresh_timeout_milliseconds", value)
|
|
345
350
|
|
|
346
351
|
@property
|
|
347
352
|
@pulumi.getter(name="cpuSet")
|
|
348
|
-
def cpu_set(self) -> Optional[pulumi.Input[str]]:
|
|
353
|
+
def cpu_set(self) -> Optional[pulumi.Input[builtins.str]]:
|
|
349
354
|
"""
|
|
350
355
|
A comma-separated list or hyphen-separated range of CPUs a container can use, e.g. `0-1`.
|
|
351
356
|
"""
|
|
352
357
|
return pulumi.get(self, "cpu_set")
|
|
353
358
|
|
|
354
359
|
@cpu_set.setter
|
|
355
|
-
def cpu_set(self, value: Optional[pulumi.Input[str]]):
|
|
360
|
+
def cpu_set(self, value: Optional[pulumi.Input[builtins.str]]):
|
|
356
361
|
pulumi.set(self, "cpu_set", value)
|
|
357
362
|
|
|
358
363
|
@property
|
|
359
364
|
@pulumi.getter(name="cpuShares")
|
|
360
|
-
def cpu_shares(self) -> Optional[pulumi.Input[int]]:
|
|
365
|
+
def cpu_shares(self) -> Optional[pulumi.Input[builtins.int]]:
|
|
361
366
|
"""
|
|
362
367
|
CPU shares (relative weight) for the container.
|
|
363
368
|
"""
|
|
364
369
|
return pulumi.get(self, "cpu_shares")
|
|
365
370
|
|
|
366
371
|
@cpu_shares.setter
|
|
367
|
-
def cpu_shares(self, value: Optional[pulumi.Input[int]]):
|
|
372
|
+
def cpu_shares(self, value: Optional[pulumi.Input[builtins.int]]):
|
|
368
373
|
pulumi.set(self, "cpu_shares", value)
|
|
369
374
|
|
|
375
|
+
@property
|
|
376
|
+
@pulumi.getter
|
|
377
|
+
def cpus(self) -> Optional[pulumi.Input[builtins.str]]:
|
|
378
|
+
"""
|
|
379
|
+
Specify how much of the available CPU resources a container can use. e.g a value of 1.5 means the container is guaranteed at most one and a half of the CPUs
|
|
380
|
+
"""
|
|
381
|
+
return pulumi.get(self, "cpus")
|
|
382
|
+
|
|
383
|
+
@cpus.setter
|
|
384
|
+
def cpus(self, value: Optional[pulumi.Input[builtins.str]]):
|
|
385
|
+
pulumi.set(self, "cpus", value)
|
|
386
|
+
|
|
370
387
|
@property
|
|
371
388
|
@pulumi.getter(name="destroyGraceSeconds")
|
|
372
|
-
def destroy_grace_seconds(self) -> Optional[pulumi.Input[int]]:
|
|
389
|
+
def destroy_grace_seconds(self) -> Optional[pulumi.Input[builtins.int]]:
|
|
373
390
|
"""
|
|
374
391
|
If defined will attempt to stop the container before destroying. Container will be destroyed after `n` seconds or on successful stop.
|
|
375
392
|
"""
|
|
376
393
|
return pulumi.get(self, "destroy_grace_seconds")
|
|
377
394
|
|
|
378
395
|
@destroy_grace_seconds.setter
|
|
379
|
-
def destroy_grace_seconds(self, value: Optional[pulumi.Input[int]]):
|
|
396
|
+
def destroy_grace_seconds(self, value: Optional[pulumi.Input[builtins.int]]):
|
|
380
397
|
pulumi.set(self, "destroy_grace_seconds", value)
|
|
381
398
|
|
|
382
399
|
@property
|
|
@@ -393,98 +410,98 @@ class ContainerArgs:
|
|
|
393
410
|
|
|
394
411
|
@property
|
|
395
412
|
@pulumi.getter
|
|
396
|
-
def dns(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
|
|
413
|
+
def dns(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]:
|
|
397
414
|
"""
|
|
398
415
|
DNS servers to use.
|
|
399
416
|
"""
|
|
400
417
|
return pulumi.get(self, "dns")
|
|
401
418
|
|
|
402
419
|
@dns.setter
|
|
403
|
-
def dns(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
|
|
420
|
+
def dns(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]):
|
|
404
421
|
pulumi.set(self, "dns", value)
|
|
405
422
|
|
|
406
423
|
@property
|
|
407
424
|
@pulumi.getter(name="dnsOpts")
|
|
408
|
-
def dns_opts(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
|
|
425
|
+
def dns_opts(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]:
|
|
409
426
|
"""
|
|
410
427
|
DNS options used by the DNS provider(s), see `resolv.conf` documentation for valid list of options.
|
|
411
428
|
"""
|
|
412
429
|
return pulumi.get(self, "dns_opts")
|
|
413
430
|
|
|
414
431
|
@dns_opts.setter
|
|
415
|
-
def dns_opts(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
|
|
432
|
+
def dns_opts(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]):
|
|
416
433
|
pulumi.set(self, "dns_opts", value)
|
|
417
434
|
|
|
418
435
|
@property
|
|
419
436
|
@pulumi.getter(name="dnsSearches")
|
|
420
|
-
def dns_searches(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
|
|
437
|
+
def dns_searches(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]:
|
|
421
438
|
"""
|
|
422
439
|
DNS search domains that are used when bare unqualified hostnames are used inside of the container.
|
|
423
440
|
"""
|
|
424
441
|
return pulumi.get(self, "dns_searches")
|
|
425
442
|
|
|
426
443
|
@dns_searches.setter
|
|
427
|
-
def dns_searches(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
|
|
444
|
+
def dns_searches(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]):
|
|
428
445
|
pulumi.set(self, "dns_searches", value)
|
|
429
446
|
|
|
430
447
|
@property
|
|
431
448
|
@pulumi.getter
|
|
432
|
-
def domainname(self) -> Optional[pulumi.Input[str]]:
|
|
449
|
+
def domainname(self) -> Optional[pulumi.Input[builtins.str]]:
|
|
433
450
|
"""
|
|
434
451
|
Domain name of the container.
|
|
435
452
|
"""
|
|
436
453
|
return pulumi.get(self, "domainname")
|
|
437
454
|
|
|
438
455
|
@domainname.setter
|
|
439
|
-
def domainname(self, value: Optional[pulumi.Input[str]]):
|
|
456
|
+
def domainname(self, value: Optional[pulumi.Input[builtins.str]]):
|
|
440
457
|
pulumi.set(self, "domainname", value)
|
|
441
458
|
|
|
442
459
|
@property
|
|
443
460
|
@pulumi.getter
|
|
444
|
-
def entrypoints(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
|
|
461
|
+
def entrypoints(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]:
|
|
445
462
|
"""
|
|
446
|
-
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/
|
|
463
|
+
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/myprogram"]`.
|
|
447
464
|
"""
|
|
448
465
|
return pulumi.get(self, "entrypoints")
|
|
449
466
|
|
|
450
467
|
@entrypoints.setter
|
|
451
|
-
def entrypoints(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
|
|
468
|
+
def entrypoints(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]):
|
|
452
469
|
pulumi.set(self, "entrypoints", value)
|
|
453
470
|
|
|
454
471
|
@property
|
|
455
472
|
@pulumi.getter
|
|
456
|
-
def envs(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
|
|
473
|
+
def envs(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]:
|
|
457
474
|
"""
|
|
458
475
|
Environment variables to set in the form of `KEY=VALUE`, e.g. `DEBUG=0`
|
|
459
476
|
"""
|
|
460
477
|
return pulumi.get(self, "envs")
|
|
461
478
|
|
|
462
479
|
@envs.setter
|
|
463
|
-
def envs(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
|
|
480
|
+
def envs(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]):
|
|
464
481
|
pulumi.set(self, "envs", value)
|
|
465
482
|
|
|
466
483
|
@property
|
|
467
484
|
@pulumi.getter
|
|
468
|
-
def gpus(self) -> Optional[pulumi.Input[str]]:
|
|
485
|
+
def gpus(self) -> Optional[pulumi.Input[builtins.str]]:
|
|
469
486
|
"""
|
|
470
487
|
GPU devices to add to the container. Currently, only the value `all` is supported. Passing any other value will result in unexpected behavior.
|
|
471
488
|
"""
|
|
472
489
|
return pulumi.get(self, "gpus")
|
|
473
490
|
|
|
474
491
|
@gpus.setter
|
|
475
|
-
def gpus(self, value: Optional[pulumi.Input[str]]):
|
|
492
|
+
def gpus(self, value: Optional[pulumi.Input[builtins.str]]):
|
|
476
493
|
pulumi.set(self, "gpus", value)
|
|
477
494
|
|
|
478
495
|
@property
|
|
479
496
|
@pulumi.getter(name="groupAdds")
|
|
480
|
-
def group_adds(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
|
|
497
|
+
def group_adds(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]:
|
|
481
498
|
"""
|
|
482
499
|
Additional groups for the container user
|
|
483
500
|
"""
|
|
484
501
|
return pulumi.get(self, "group_adds")
|
|
485
502
|
|
|
486
503
|
@group_adds.setter
|
|
487
|
-
def group_adds(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
|
|
504
|
+
def group_adds(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]):
|
|
488
505
|
pulumi.set(self, "group_adds", value)
|
|
489
506
|
|
|
490
507
|
@property
|
|
@@ -501,14 +518,14 @@ class ContainerArgs:
|
|
|
501
518
|
|
|
502
519
|
@property
|
|
503
520
|
@pulumi.getter
|
|
504
|
-
def hostname(self) -> Optional[pulumi.Input[str]]:
|
|
521
|
+
def hostname(self) -> Optional[pulumi.Input[builtins.str]]:
|
|
505
522
|
"""
|
|
506
523
|
Hostname of the container.
|
|
507
524
|
"""
|
|
508
525
|
return pulumi.get(self, "hostname")
|
|
509
526
|
|
|
510
527
|
@hostname.setter
|
|
511
|
-
def hostname(self, value: Optional[pulumi.Input[str]]):
|
|
528
|
+
def hostname(self, value: Optional[pulumi.Input[builtins.str]]):
|
|
512
529
|
pulumi.set(self, "hostname", value)
|
|
513
530
|
|
|
514
531
|
@property
|
|
@@ -525,26 +542,26 @@ class ContainerArgs:
|
|
|
525
542
|
|
|
526
543
|
@property
|
|
527
544
|
@pulumi.getter
|
|
528
|
-
def init(self) -> Optional[pulumi.Input[bool]]:
|
|
545
|
+
def init(self) -> Optional[pulumi.Input[builtins.bool]]:
|
|
529
546
|
"""
|
|
530
547
|
Configured whether an init process should be injected for this container. If unset this will default to the `dockerd` defaults.
|
|
531
548
|
"""
|
|
532
549
|
return pulumi.get(self, "init")
|
|
533
550
|
|
|
534
551
|
@init.setter
|
|
535
|
-
def init(self, value: Optional[pulumi.Input[bool]]):
|
|
552
|
+
def init(self, value: Optional[pulumi.Input[builtins.bool]]):
|
|
536
553
|
pulumi.set(self, "init", value)
|
|
537
554
|
|
|
538
555
|
@property
|
|
539
556
|
@pulumi.getter(name="ipcMode")
|
|
540
|
-
def ipc_mode(self) -> Optional[pulumi.Input[str]]:
|
|
557
|
+
def ipc_mode(self) -> Optional[pulumi.Input[builtins.str]]:
|
|
541
558
|
"""
|
|
542
559
|
IPC sharing mode for the container. Possible values are: `none`, `private`, `shareable`, `container:<name|id>` or `host`.
|
|
543
560
|
"""
|
|
544
561
|
return pulumi.get(self, "ipc_mode")
|
|
545
562
|
|
|
546
563
|
@ipc_mode.setter
|
|
547
|
-
def ipc_mode(self, value: Optional[pulumi.Input[str]]):
|
|
564
|
+
def ipc_mode(self, value: Optional[pulumi.Input[builtins.str]]):
|
|
548
565
|
pulumi.set(self, "ipc_mode", value)
|
|
549
566
|
|
|
550
567
|
@property
|
|
@@ -561,74 +578,74 @@ class ContainerArgs:
|
|
|
561
578
|
|
|
562
579
|
@property
|
|
563
580
|
@pulumi.getter(name="logDriver")
|
|
564
|
-
def log_driver(self) -> Optional[pulumi.Input[str]]:
|
|
581
|
+
def log_driver(self) -> Optional[pulumi.Input[builtins.str]]:
|
|
565
582
|
"""
|
|
566
583
|
The logging driver to use for the container.
|
|
567
584
|
"""
|
|
568
585
|
return pulumi.get(self, "log_driver")
|
|
569
586
|
|
|
570
587
|
@log_driver.setter
|
|
571
|
-
def log_driver(self, value: Optional[pulumi.Input[str]]):
|
|
588
|
+
def log_driver(self, value: Optional[pulumi.Input[builtins.str]]):
|
|
572
589
|
pulumi.set(self, "log_driver", value)
|
|
573
590
|
|
|
574
591
|
@property
|
|
575
592
|
@pulumi.getter(name="logOpts")
|
|
576
|
-
def log_opts(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]:
|
|
593
|
+
def log_opts(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]]:
|
|
577
594
|
"""
|
|
578
595
|
Key/value pairs to use as options for the logging driver.
|
|
579
596
|
"""
|
|
580
597
|
return pulumi.get(self, "log_opts")
|
|
581
598
|
|
|
582
599
|
@log_opts.setter
|
|
583
|
-
def log_opts(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]):
|
|
600
|
+
def log_opts(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]]):
|
|
584
601
|
pulumi.set(self, "log_opts", value)
|
|
585
602
|
|
|
586
603
|
@property
|
|
587
604
|
@pulumi.getter
|
|
588
|
-
def logs(self) -> Optional[pulumi.Input[bool]]:
|
|
605
|
+
def logs(self) -> Optional[pulumi.Input[builtins.bool]]:
|
|
589
606
|
"""
|
|
590
607
|
Save the container logs (`attach` must be enabled). Defaults to `false`.
|
|
591
608
|
"""
|
|
592
609
|
return pulumi.get(self, "logs")
|
|
593
610
|
|
|
594
611
|
@logs.setter
|
|
595
|
-
def logs(self, value: Optional[pulumi.Input[bool]]):
|
|
612
|
+
def logs(self, value: Optional[pulumi.Input[builtins.bool]]):
|
|
596
613
|
pulumi.set(self, "logs", value)
|
|
597
614
|
|
|
598
615
|
@property
|
|
599
616
|
@pulumi.getter(name="maxRetryCount")
|
|
600
|
-
def max_retry_count(self) -> Optional[pulumi.Input[int]]:
|
|
617
|
+
def max_retry_count(self) -> Optional[pulumi.Input[builtins.int]]:
|
|
601
618
|
"""
|
|
602
619
|
The maximum amount of times to an attempt a restart when `restart` is set to 'on-failure'.
|
|
603
620
|
"""
|
|
604
621
|
return pulumi.get(self, "max_retry_count")
|
|
605
622
|
|
|
606
623
|
@max_retry_count.setter
|
|
607
|
-
def max_retry_count(self, value: Optional[pulumi.Input[int]]):
|
|
624
|
+
def max_retry_count(self, value: Optional[pulumi.Input[builtins.int]]):
|
|
608
625
|
pulumi.set(self, "max_retry_count", value)
|
|
609
626
|
|
|
610
627
|
@property
|
|
611
628
|
@pulumi.getter
|
|
612
|
-
def memory(self) -> Optional[pulumi.Input[int]]:
|
|
629
|
+
def memory(self) -> Optional[pulumi.Input[builtins.int]]:
|
|
613
630
|
"""
|
|
614
631
|
The memory limit for the container in MBs.
|
|
615
632
|
"""
|
|
616
633
|
return pulumi.get(self, "memory")
|
|
617
634
|
|
|
618
635
|
@memory.setter
|
|
619
|
-
def memory(self, value: Optional[pulumi.Input[int]]):
|
|
636
|
+
def memory(self, value: Optional[pulumi.Input[builtins.int]]):
|
|
620
637
|
pulumi.set(self, "memory", value)
|
|
621
638
|
|
|
622
639
|
@property
|
|
623
640
|
@pulumi.getter(name="memorySwap")
|
|
624
|
-
def memory_swap(self) -> Optional[pulumi.Input[int]]:
|
|
641
|
+
def memory_swap(self) -> Optional[pulumi.Input[builtins.int]]:
|
|
625
642
|
"""
|
|
626
643
|
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.
|
|
627
644
|
"""
|
|
628
645
|
return pulumi.get(self, "memory_swap")
|
|
629
646
|
|
|
630
647
|
@memory_swap.setter
|
|
631
|
-
def memory_swap(self, value: Optional[pulumi.Input[int]]):
|
|
648
|
+
def memory_swap(self, value: Optional[pulumi.Input[builtins.int]]):
|
|
632
649
|
pulumi.set(self, "memory_swap", value)
|
|
633
650
|
|
|
634
651
|
@property
|
|
@@ -645,35 +662,35 @@ class ContainerArgs:
|
|
|
645
662
|
|
|
646
663
|
@property
|
|
647
664
|
@pulumi.getter(name="mustRun")
|
|
648
|
-
def must_run(self) -> Optional[pulumi.Input[bool]]:
|
|
665
|
+
def must_run(self) -> Optional[pulumi.Input[builtins.bool]]:
|
|
649
666
|
return pulumi.get(self, "must_run")
|
|
650
667
|
|
|
651
668
|
@must_run.setter
|
|
652
|
-
def must_run(self, value: Optional[pulumi.Input[bool]]):
|
|
669
|
+
def must_run(self, value: Optional[pulumi.Input[builtins.bool]]):
|
|
653
670
|
pulumi.set(self, "must_run", value)
|
|
654
671
|
|
|
655
672
|
@property
|
|
656
673
|
@pulumi.getter
|
|
657
|
-
def name(self) -> Optional[pulumi.Input[str]]:
|
|
674
|
+
def name(self) -> Optional[pulumi.Input[builtins.str]]:
|
|
658
675
|
"""
|
|
659
676
|
The name of the container.
|
|
660
677
|
"""
|
|
661
678
|
return pulumi.get(self, "name")
|
|
662
679
|
|
|
663
680
|
@name.setter
|
|
664
|
-
def name(self, value: Optional[pulumi.Input[str]]):
|
|
681
|
+
def name(self, value: Optional[pulumi.Input[builtins.str]]):
|
|
665
682
|
pulumi.set(self, "name", value)
|
|
666
683
|
|
|
667
684
|
@property
|
|
668
685
|
@pulumi.getter(name="networkMode")
|
|
669
|
-
def network_mode(self) -> Optional[pulumi.Input[str]]:
|
|
686
|
+
def network_mode(self) -> Optional[pulumi.Input[builtins.str]]:
|
|
670
687
|
"""
|
|
671
|
-
Network mode of the container.
|
|
688
|
+
Network mode of the container. See https://docs.docker.com/engine/network/ for more information.
|
|
672
689
|
"""
|
|
673
690
|
return pulumi.get(self, "network_mode")
|
|
674
691
|
|
|
675
692
|
@network_mode.setter
|
|
676
|
-
def network_mode(self, value: Optional[pulumi.Input[str]]):
|
|
693
|
+
def network_mode(self, value: Optional[pulumi.Input[builtins.str]]):
|
|
677
694
|
pulumi.set(self, "network_mode", value)
|
|
678
695
|
|
|
679
696
|
@property
|
|
@@ -690,14 +707,14 @@ class ContainerArgs:
|
|
|
690
707
|
|
|
691
708
|
@property
|
|
692
709
|
@pulumi.getter(name="pidMode")
|
|
693
|
-
def pid_mode(self) -> Optional[pulumi.Input[str]]:
|
|
710
|
+
def pid_mode(self) -> Optional[pulumi.Input[builtins.str]]:
|
|
694
711
|
"""
|
|
695
712
|
he PID (Process) Namespace mode for the container. Either `container:<name|id>` or `host`.
|
|
696
713
|
"""
|
|
697
714
|
return pulumi.get(self, "pid_mode")
|
|
698
715
|
|
|
699
716
|
@pid_mode.setter
|
|
700
|
-
def pid_mode(self, value: Optional[pulumi.Input[str]]):
|
|
717
|
+
def pid_mode(self, value: Optional[pulumi.Input[builtins.str]]):
|
|
701
718
|
pulumi.set(self, "pid_mode", value)
|
|
702
719
|
|
|
703
720
|
@property
|
|
@@ -714,206 +731,206 @@ class ContainerArgs:
|
|
|
714
731
|
|
|
715
732
|
@property
|
|
716
733
|
@pulumi.getter
|
|
717
|
-
def privileged(self) -> Optional[pulumi.Input[bool]]:
|
|
734
|
+
def privileged(self) -> Optional[pulumi.Input[builtins.bool]]:
|
|
718
735
|
"""
|
|
719
736
|
If `true`, the container runs in privileged mode.
|
|
720
737
|
"""
|
|
721
738
|
return pulumi.get(self, "privileged")
|
|
722
739
|
|
|
723
740
|
@privileged.setter
|
|
724
|
-
def privileged(self, value: Optional[pulumi.Input[bool]]):
|
|
741
|
+
def privileged(self, value: Optional[pulumi.Input[builtins.bool]]):
|
|
725
742
|
pulumi.set(self, "privileged", value)
|
|
726
743
|
|
|
727
744
|
@property
|
|
728
745
|
@pulumi.getter(name="publishAllPorts")
|
|
729
|
-
def publish_all_ports(self) -> Optional[pulumi.Input[bool]]:
|
|
746
|
+
def publish_all_ports(self) -> Optional[pulumi.Input[builtins.bool]]:
|
|
730
747
|
"""
|
|
731
748
|
Publish all ports of the container.
|
|
732
749
|
"""
|
|
733
750
|
return pulumi.get(self, "publish_all_ports")
|
|
734
751
|
|
|
735
752
|
@publish_all_ports.setter
|
|
736
|
-
def publish_all_ports(self, value: Optional[pulumi.Input[bool]]):
|
|
753
|
+
def publish_all_ports(self, value: Optional[pulumi.Input[builtins.bool]]):
|
|
737
754
|
pulumi.set(self, "publish_all_ports", value)
|
|
738
755
|
|
|
739
756
|
@property
|
|
740
757
|
@pulumi.getter(name="readOnly")
|
|
741
|
-
def read_only(self) -> Optional[pulumi.Input[bool]]:
|
|
758
|
+
def read_only(self) -> Optional[pulumi.Input[builtins.bool]]:
|
|
742
759
|
"""
|
|
743
760
|
If `true`, the container will be started as readonly. Defaults to `false`.
|
|
744
761
|
"""
|
|
745
762
|
return pulumi.get(self, "read_only")
|
|
746
763
|
|
|
747
764
|
@read_only.setter
|
|
748
|
-
def read_only(self, value: Optional[pulumi.Input[bool]]):
|
|
765
|
+
def read_only(self, value: Optional[pulumi.Input[builtins.bool]]):
|
|
749
766
|
pulumi.set(self, "read_only", value)
|
|
750
767
|
|
|
751
768
|
@property
|
|
752
769
|
@pulumi.getter(name="removeVolumes")
|
|
753
|
-
def remove_volumes(self) -> Optional[pulumi.Input[bool]]:
|
|
770
|
+
def remove_volumes(self) -> Optional[pulumi.Input[builtins.bool]]:
|
|
754
771
|
"""
|
|
755
772
|
If `true`, it will remove anonymous volumes associated with the container. Defaults to `true`.
|
|
756
773
|
"""
|
|
757
774
|
return pulumi.get(self, "remove_volumes")
|
|
758
775
|
|
|
759
776
|
@remove_volumes.setter
|
|
760
|
-
def remove_volumes(self, value: Optional[pulumi.Input[bool]]):
|
|
777
|
+
def remove_volumes(self, value: Optional[pulumi.Input[builtins.bool]]):
|
|
761
778
|
pulumi.set(self, "remove_volumes", value)
|
|
762
779
|
|
|
763
780
|
@property
|
|
764
781
|
@pulumi.getter
|
|
765
|
-
def restart(self) -> Optional[pulumi.Input[str]]:
|
|
782
|
+
def restart(self) -> Optional[pulumi.Input[builtins.str]]:
|
|
766
783
|
"""
|
|
767
784
|
The restart policy for the container. Must be one of 'no', 'on-failure', 'always', 'unless-stopped'. Defaults to `no`.
|
|
768
785
|
"""
|
|
769
786
|
return pulumi.get(self, "restart")
|
|
770
787
|
|
|
771
788
|
@restart.setter
|
|
772
|
-
def restart(self, value: Optional[pulumi.Input[str]]):
|
|
789
|
+
def restart(self, value: Optional[pulumi.Input[builtins.str]]):
|
|
773
790
|
pulumi.set(self, "restart", value)
|
|
774
791
|
|
|
775
792
|
@property
|
|
776
793
|
@pulumi.getter
|
|
777
|
-
def rm(self) -> Optional[pulumi.Input[bool]]:
|
|
794
|
+
def rm(self) -> Optional[pulumi.Input[builtins.bool]]:
|
|
778
795
|
"""
|
|
779
796
|
If `true`, then the container will be automatically removed when it exits. Defaults to `false`.
|
|
780
797
|
"""
|
|
781
798
|
return pulumi.get(self, "rm")
|
|
782
799
|
|
|
783
800
|
@rm.setter
|
|
784
|
-
def rm(self, value: Optional[pulumi.Input[bool]]):
|
|
801
|
+
def rm(self, value: Optional[pulumi.Input[builtins.bool]]):
|
|
785
802
|
pulumi.set(self, "rm", value)
|
|
786
803
|
|
|
787
804
|
@property
|
|
788
805
|
@pulumi.getter
|
|
789
|
-
def runtime(self) -> Optional[pulumi.Input[str]]:
|
|
806
|
+
def runtime(self) -> Optional[pulumi.Input[builtins.str]]:
|
|
790
807
|
"""
|
|
791
808
|
Runtime to use for the container.
|
|
792
809
|
"""
|
|
793
810
|
return pulumi.get(self, "runtime")
|
|
794
811
|
|
|
795
812
|
@runtime.setter
|
|
796
|
-
def runtime(self, value: Optional[pulumi.Input[str]]):
|
|
813
|
+
def runtime(self, value: Optional[pulumi.Input[builtins.str]]):
|
|
797
814
|
pulumi.set(self, "runtime", value)
|
|
798
815
|
|
|
799
816
|
@property
|
|
800
817
|
@pulumi.getter(name="securityOpts")
|
|
801
|
-
def security_opts(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
|
|
818
|
+
def security_opts(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]:
|
|
802
819
|
"""
|
|
803
820
|
List of string values to customize labels for MLS systems, such as SELinux. See https://docs.docker.com/engine/reference/run/#security-configuration.
|
|
804
821
|
"""
|
|
805
822
|
return pulumi.get(self, "security_opts")
|
|
806
823
|
|
|
807
824
|
@security_opts.setter
|
|
808
|
-
def security_opts(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
|
|
825
|
+
def security_opts(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]):
|
|
809
826
|
pulumi.set(self, "security_opts", value)
|
|
810
827
|
|
|
811
828
|
@property
|
|
812
829
|
@pulumi.getter(name="shmSize")
|
|
813
|
-
def shm_size(self) -> Optional[pulumi.Input[int]]:
|
|
830
|
+
def shm_size(self) -> Optional[pulumi.Input[builtins.int]]:
|
|
814
831
|
"""
|
|
815
832
|
Size of `/dev/shm` in MBs.
|
|
816
833
|
"""
|
|
817
834
|
return pulumi.get(self, "shm_size")
|
|
818
835
|
|
|
819
836
|
@shm_size.setter
|
|
820
|
-
def shm_size(self, value: Optional[pulumi.Input[int]]):
|
|
837
|
+
def shm_size(self, value: Optional[pulumi.Input[builtins.int]]):
|
|
821
838
|
pulumi.set(self, "shm_size", value)
|
|
822
839
|
|
|
823
840
|
@property
|
|
824
841
|
@pulumi.getter
|
|
825
|
-
def start(self) -> Optional[pulumi.Input[bool]]:
|
|
842
|
+
def start(self) -> Optional[pulumi.Input[builtins.bool]]:
|
|
826
843
|
"""
|
|
827
844
|
If `true`, then the Docker container will be started after creation. If `false`, then the container is only created. Defaults to `true`.
|
|
828
845
|
"""
|
|
829
846
|
return pulumi.get(self, "start")
|
|
830
847
|
|
|
831
848
|
@start.setter
|
|
832
|
-
def start(self, value: Optional[pulumi.Input[bool]]):
|
|
849
|
+
def start(self, value: Optional[pulumi.Input[builtins.bool]]):
|
|
833
850
|
pulumi.set(self, "start", value)
|
|
834
851
|
|
|
835
852
|
@property
|
|
836
853
|
@pulumi.getter(name="stdinOpen")
|
|
837
|
-
def stdin_open(self) -> Optional[pulumi.Input[bool]]:
|
|
854
|
+
def stdin_open(self) -> Optional[pulumi.Input[builtins.bool]]:
|
|
838
855
|
"""
|
|
839
856
|
If `true`, keep STDIN open even if not attached (`docker run -i`). Defaults to `false`.
|
|
840
857
|
"""
|
|
841
858
|
return pulumi.get(self, "stdin_open")
|
|
842
859
|
|
|
843
860
|
@stdin_open.setter
|
|
844
|
-
def stdin_open(self, value: Optional[pulumi.Input[bool]]):
|
|
861
|
+
def stdin_open(self, value: Optional[pulumi.Input[builtins.bool]]):
|
|
845
862
|
pulumi.set(self, "stdin_open", value)
|
|
846
863
|
|
|
847
864
|
@property
|
|
848
865
|
@pulumi.getter(name="stopSignal")
|
|
849
|
-
def stop_signal(self) -> Optional[pulumi.Input[str]]:
|
|
866
|
+
def stop_signal(self) -> Optional[pulumi.Input[builtins.str]]:
|
|
850
867
|
"""
|
|
851
868
|
Signal to stop a container (default `SIGTERM`).
|
|
852
869
|
"""
|
|
853
870
|
return pulumi.get(self, "stop_signal")
|
|
854
871
|
|
|
855
872
|
@stop_signal.setter
|
|
856
|
-
def stop_signal(self, value: Optional[pulumi.Input[str]]):
|
|
873
|
+
def stop_signal(self, value: Optional[pulumi.Input[builtins.str]]):
|
|
857
874
|
pulumi.set(self, "stop_signal", value)
|
|
858
875
|
|
|
859
876
|
@property
|
|
860
877
|
@pulumi.getter(name="stopTimeout")
|
|
861
|
-
def stop_timeout(self) -> Optional[pulumi.Input[int]]:
|
|
878
|
+
def stop_timeout(self) -> Optional[pulumi.Input[builtins.int]]:
|
|
862
879
|
"""
|
|
863
880
|
Timeout (in seconds) to stop a container.
|
|
864
881
|
"""
|
|
865
882
|
return pulumi.get(self, "stop_timeout")
|
|
866
883
|
|
|
867
884
|
@stop_timeout.setter
|
|
868
|
-
def stop_timeout(self, value: Optional[pulumi.Input[int]]):
|
|
885
|
+
def stop_timeout(self, value: Optional[pulumi.Input[builtins.int]]):
|
|
869
886
|
pulumi.set(self, "stop_timeout", value)
|
|
870
887
|
|
|
871
888
|
@property
|
|
872
889
|
@pulumi.getter(name="storageOpts")
|
|
873
|
-
def storage_opts(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]:
|
|
890
|
+
def storage_opts(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]]:
|
|
874
891
|
"""
|
|
875
892
|
Key/value pairs for the storage driver options, e.g. `size`: `120G`
|
|
876
893
|
"""
|
|
877
894
|
return pulumi.get(self, "storage_opts")
|
|
878
895
|
|
|
879
896
|
@storage_opts.setter
|
|
880
|
-
def storage_opts(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]):
|
|
897
|
+
def storage_opts(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]]):
|
|
881
898
|
pulumi.set(self, "storage_opts", value)
|
|
882
899
|
|
|
883
900
|
@property
|
|
884
901
|
@pulumi.getter
|
|
885
|
-
def sysctls(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]:
|
|
902
|
+
def sysctls(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]]:
|
|
886
903
|
"""
|
|
887
904
|
A map of kernel parameters (sysctls) to set in the container.
|
|
888
905
|
"""
|
|
889
906
|
return pulumi.get(self, "sysctls")
|
|
890
907
|
|
|
891
908
|
@sysctls.setter
|
|
892
|
-
def sysctls(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]):
|
|
909
|
+
def sysctls(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]]):
|
|
893
910
|
pulumi.set(self, "sysctls", value)
|
|
894
911
|
|
|
895
912
|
@property
|
|
896
913
|
@pulumi.getter
|
|
897
|
-
def tmpfs(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]:
|
|
914
|
+
def tmpfs(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]]:
|
|
898
915
|
"""
|
|
899
916
|
A map of container directories which should be replaced by `tmpfs mounts`, and their corresponding mount options.
|
|
900
917
|
"""
|
|
901
918
|
return pulumi.get(self, "tmpfs")
|
|
902
919
|
|
|
903
920
|
@tmpfs.setter
|
|
904
|
-
def tmpfs(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]):
|
|
921
|
+
def tmpfs(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]]):
|
|
905
922
|
pulumi.set(self, "tmpfs", value)
|
|
906
923
|
|
|
907
924
|
@property
|
|
908
925
|
@pulumi.getter
|
|
909
|
-
def tty(self) -> Optional[pulumi.Input[bool]]:
|
|
926
|
+
def tty(self) -> Optional[pulumi.Input[builtins.bool]]:
|
|
910
927
|
"""
|
|
911
928
|
If `true`, allocate a pseudo-tty (`docker run -t`). Defaults to `false`.
|
|
912
929
|
"""
|
|
913
930
|
return pulumi.get(self, "tty")
|
|
914
931
|
|
|
915
932
|
@tty.setter
|
|
916
|
-
def tty(self, value: Optional[pulumi.Input[bool]]):
|
|
933
|
+
def tty(self, value: Optional[pulumi.Input[builtins.bool]]):
|
|
917
934
|
pulumi.set(self, "tty", value)
|
|
918
935
|
|
|
919
936
|
@property
|
|
@@ -942,26 +959,26 @@ class ContainerArgs:
|
|
|
942
959
|
|
|
943
960
|
@property
|
|
944
961
|
@pulumi.getter
|
|
945
|
-
def user(self) -> Optional[pulumi.Input[str]]:
|
|
962
|
+
def user(self) -> Optional[pulumi.Input[builtins.str]]:
|
|
946
963
|
"""
|
|
947
964
|
User used for run the first process. Format is `user` or `user:group` which user and group can be passed literraly or by name.
|
|
948
965
|
"""
|
|
949
966
|
return pulumi.get(self, "user")
|
|
950
967
|
|
|
951
968
|
@user.setter
|
|
952
|
-
def user(self, value: Optional[pulumi.Input[str]]):
|
|
969
|
+
def user(self, value: Optional[pulumi.Input[builtins.str]]):
|
|
953
970
|
pulumi.set(self, "user", value)
|
|
954
971
|
|
|
955
972
|
@property
|
|
956
973
|
@pulumi.getter(name="usernsMode")
|
|
957
|
-
def userns_mode(self) -> Optional[pulumi.Input[str]]:
|
|
974
|
+
def userns_mode(self) -> Optional[pulumi.Input[builtins.str]]:
|
|
958
975
|
"""
|
|
959
976
|
Sets the usernamespace mode for the container when usernamespace remapping option is enabled.
|
|
960
977
|
"""
|
|
961
978
|
return pulumi.get(self, "userns_mode")
|
|
962
979
|
|
|
963
980
|
@userns_mode.setter
|
|
964
|
-
def userns_mode(self, value: Optional[pulumi.Input[str]]):
|
|
981
|
+
def userns_mode(self, value: Optional[pulumi.Input[builtins.str]]):
|
|
965
982
|
pulumi.set(self, "userns_mode", value)
|
|
966
983
|
|
|
967
984
|
@property
|
|
@@ -978,177 +995,179 @@ class ContainerArgs:
|
|
|
978
995
|
|
|
979
996
|
@property
|
|
980
997
|
@pulumi.getter
|
|
981
|
-
def wait(self) -> Optional[pulumi.Input[bool]]:
|
|
998
|
+
def wait(self) -> Optional[pulumi.Input[builtins.bool]]:
|
|
982
999
|
"""
|
|
983
|
-
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`.
|
|
1000
|
+
If `true`, then the Docker container is waited for being healthy state after creation. This requires your container to have a healthcheck, otherwise this provider will error. If `false`, then the container health state is not checked. Defaults to `false`.
|
|
984
1001
|
"""
|
|
985
1002
|
return pulumi.get(self, "wait")
|
|
986
1003
|
|
|
987
1004
|
@wait.setter
|
|
988
|
-
def wait(self, value: Optional[pulumi.Input[bool]]):
|
|
1005
|
+
def wait(self, value: Optional[pulumi.Input[builtins.bool]]):
|
|
989
1006
|
pulumi.set(self, "wait", value)
|
|
990
1007
|
|
|
991
1008
|
@property
|
|
992
1009
|
@pulumi.getter(name="waitTimeout")
|
|
993
|
-
def wait_timeout(self) -> Optional[pulumi.Input[int]]:
|
|
1010
|
+
def wait_timeout(self) -> Optional[pulumi.Input[builtins.int]]:
|
|
994
1011
|
"""
|
|
995
1012
|
The timeout in seconds to wait the container to be healthy after creation. Defaults to `60`.
|
|
996
1013
|
"""
|
|
997
1014
|
return pulumi.get(self, "wait_timeout")
|
|
998
1015
|
|
|
999
1016
|
@wait_timeout.setter
|
|
1000
|
-
def wait_timeout(self, value: Optional[pulumi.Input[int]]):
|
|
1017
|
+
def wait_timeout(self, value: Optional[pulumi.Input[builtins.int]]):
|
|
1001
1018
|
pulumi.set(self, "wait_timeout", value)
|
|
1002
1019
|
|
|
1003
1020
|
@property
|
|
1004
1021
|
@pulumi.getter(name="workingDir")
|
|
1005
|
-
def working_dir(self) -> Optional[pulumi.Input[str]]:
|
|
1022
|
+
def working_dir(self) -> Optional[pulumi.Input[builtins.str]]:
|
|
1006
1023
|
"""
|
|
1007
1024
|
The working directory for commands to run in.
|
|
1008
1025
|
"""
|
|
1009
1026
|
return pulumi.get(self, "working_dir")
|
|
1010
1027
|
|
|
1011
1028
|
@working_dir.setter
|
|
1012
|
-
def working_dir(self, value: Optional[pulumi.Input[str]]):
|
|
1029
|
+
def working_dir(self, value: Optional[pulumi.Input[builtins.str]]):
|
|
1013
1030
|
pulumi.set(self, "working_dir", value)
|
|
1014
1031
|
|
|
1015
1032
|
|
|
1016
1033
|
@pulumi.input_type
|
|
1017
1034
|
class _ContainerState:
|
|
1018
1035
|
def __init__(__self__, *,
|
|
1019
|
-
attach: Optional[pulumi.Input[bool]] = None,
|
|
1020
|
-
bridge: Optional[pulumi.Input[str]] = None,
|
|
1036
|
+
attach: Optional[pulumi.Input[builtins.bool]] = None,
|
|
1037
|
+
bridge: Optional[pulumi.Input[builtins.str]] = None,
|
|
1021
1038
|
capabilities: Optional[pulumi.Input['ContainerCapabilitiesArgs']] = None,
|
|
1022
|
-
cgroupns_mode: Optional[pulumi.Input[str]] = None,
|
|
1023
|
-
command: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
|
|
1024
|
-
container_logs: Optional[pulumi.Input[str]] = None,
|
|
1025
|
-
container_read_refresh_timeout_milliseconds: Optional[pulumi.Input[int]] = None,
|
|
1026
|
-
cpu_set: Optional[pulumi.Input[str]] = None,
|
|
1027
|
-
cpu_shares: Optional[pulumi.Input[int]] = None,
|
|
1028
|
-
|
|
1039
|
+
cgroupns_mode: Optional[pulumi.Input[builtins.str]] = None,
|
|
1040
|
+
command: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None,
|
|
1041
|
+
container_logs: Optional[pulumi.Input[builtins.str]] = None,
|
|
1042
|
+
container_read_refresh_timeout_milliseconds: Optional[pulumi.Input[builtins.int]] = None,
|
|
1043
|
+
cpu_set: Optional[pulumi.Input[builtins.str]] = None,
|
|
1044
|
+
cpu_shares: Optional[pulumi.Input[builtins.int]] = None,
|
|
1045
|
+
cpus: Optional[pulumi.Input[builtins.str]] = None,
|
|
1046
|
+
destroy_grace_seconds: Optional[pulumi.Input[builtins.int]] = None,
|
|
1029
1047
|
devices: Optional[pulumi.Input[Sequence[pulumi.Input['ContainerDeviceArgs']]]] = None,
|
|
1030
|
-
dns: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
|
|
1031
|
-
dns_opts: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
|
|
1032
|
-
dns_searches: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
|
|
1033
|
-
domainname: Optional[pulumi.Input[str]] = None,
|
|
1034
|
-
entrypoints: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
|
|
1035
|
-
envs: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
|
|
1036
|
-
exit_code: Optional[pulumi.Input[int]] = None,
|
|
1037
|
-
gpus: Optional[pulumi.Input[str]] = None,
|
|
1038
|
-
group_adds: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
|
|
1048
|
+
dns: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None,
|
|
1049
|
+
dns_opts: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None,
|
|
1050
|
+
dns_searches: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None,
|
|
1051
|
+
domainname: Optional[pulumi.Input[builtins.str]] = None,
|
|
1052
|
+
entrypoints: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None,
|
|
1053
|
+
envs: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None,
|
|
1054
|
+
exit_code: Optional[pulumi.Input[builtins.int]] = None,
|
|
1055
|
+
gpus: Optional[pulumi.Input[builtins.str]] = None,
|
|
1056
|
+
group_adds: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None,
|
|
1039
1057
|
healthcheck: Optional[pulumi.Input['ContainerHealthcheckArgs']] = None,
|
|
1040
|
-
hostname: Optional[pulumi.Input[str]] = None,
|
|
1058
|
+
hostname: Optional[pulumi.Input[builtins.str]] = None,
|
|
1041
1059
|
hosts: Optional[pulumi.Input[Sequence[pulumi.Input['ContainerHostArgs']]]] = None,
|
|
1042
|
-
image: Optional[pulumi.Input[str]] = None,
|
|
1043
|
-
init: Optional[pulumi.Input[bool]] = None,
|
|
1044
|
-
ipc_mode: Optional[pulumi.Input[str]] = None,
|
|
1060
|
+
image: Optional[pulumi.Input[builtins.str]] = None,
|
|
1061
|
+
init: Optional[pulumi.Input[builtins.bool]] = None,
|
|
1062
|
+
ipc_mode: Optional[pulumi.Input[builtins.str]] = None,
|
|
1045
1063
|
labels: Optional[pulumi.Input[Sequence[pulumi.Input['ContainerLabelArgs']]]] = None,
|
|
1046
|
-
log_driver: Optional[pulumi.Input[str]] = None,
|
|
1047
|
-
log_opts: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None,
|
|
1048
|
-
logs: Optional[pulumi.Input[bool]] = None,
|
|
1049
|
-
max_retry_count: Optional[pulumi.Input[int]] = None,
|
|
1050
|
-
memory: Optional[pulumi.Input[int]] = None,
|
|
1051
|
-
memory_swap: Optional[pulumi.Input[int]] = None,
|
|
1064
|
+
log_driver: Optional[pulumi.Input[builtins.str]] = None,
|
|
1065
|
+
log_opts: Optional[pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]] = None,
|
|
1066
|
+
logs: Optional[pulumi.Input[builtins.bool]] = None,
|
|
1067
|
+
max_retry_count: Optional[pulumi.Input[builtins.int]] = None,
|
|
1068
|
+
memory: Optional[pulumi.Input[builtins.int]] = None,
|
|
1069
|
+
memory_swap: Optional[pulumi.Input[builtins.int]] = None,
|
|
1052
1070
|
mounts: Optional[pulumi.Input[Sequence[pulumi.Input['ContainerMountArgs']]]] = None,
|
|
1053
|
-
must_run: Optional[pulumi.Input[bool]] = None,
|
|
1054
|
-
name: Optional[pulumi.Input[str]] = None,
|
|
1071
|
+
must_run: Optional[pulumi.Input[builtins.bool]] = None,
|
|
1072
|
+
name: Optional[pulumi.Input[builtins.str]] = None,
|
|
1055
1073
|
network_datas: Optional[pulumi.Input[Sequence[pulumi.Input['ContainerNetworkDataArgs']]]] = None,
|
|
1056
|
-
network_mode: Optional[pulumi.Input[str]] = None,
|
|
1074
|
+
network_mode: Optional[pulumi.Input[builtins.str]] = None,
|
|
1057
1075
|
networks_advanced: Optional[pulumi.Input[Sequence[pulumi.Input['ContainerNetworksAdvancedArgs']]]] = None,
|
|
1058
|
-
pid_mode: Optional[pulumi.Input[str]] = None,
|
|
1076
|
+
pid_mode: Optional[pulumi.Input[builtins.str]] = None,
|
|
1059
1077
|
ports: Optional[pulumi.Input[Sequence[pulumi.Input['ContainerPortArgs']]]] = None,
|
|
1060
|
-
privileged: Optional[pulumi.Input[bool]] = None,
|
|
1061
|
-
publish_all_ports: Optional[pulumi.Input[bool]] = None,
|
|
1062
|
-
read_only: Optional[pulumi.Input[bool]] = None,
|
|
1063
|
-
remove_volumes: Optional[pulumi.Input[bool]] = None,
|
|
1064
|
-
restart: Optional[pulumi.Input[str]] = None,
|
|
1065
|
-
rm: Optional[pulumi.Input[bool]] = None,
|
|
1066
|
-
runtime: Optional[pulumi.Input[str]] = None,
|
|
1067
|
-
security_opts: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
|
|
1068
|
-
shm_size: Optional[pulumi.Input[int]] = None,
|
|
1069
|
-
start: Optional[pulumi.Input[bool]] = None,
|
|
1070
|
-
stdin_open: Optional[pulumi.Input[bool]] = None,
|
|
1071
|
-
stop_signal: Optional[pulumi.Input[str]] = None,
|
|
1072
|
-
stop_timeout: Optional[pulumi.Input[int]] = None,
|
|
1073
|
-
storage_opts: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None,
|
|
1074
|
-
sysctls: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None,
|
|
1075
|
-
tmpfs: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None,
|
|
1076
|
-
tty: Optional[pulumi.Input[bool]] = None,
|
|
1078
|
+
privileged: Optional[pulumi.Input[builtins.bool]] = None,
|
|
1079
|
+
publish_all_ports: Optional[pulumi.Input[builtins.bool]] = None,
|
|
1080
|
+
read_only: Optional[pulumi.Input[builtins.bool]] = None,
|
|
1081
|
+
remove_volumes: Optional[pulumi.Input[builtins.bool]] = None,
|
|
1082
|
+
restart: Optional[pulumi.Input[builtins.str]] = None,
|
|
1083
|
+
rm: Optional[pulumi.Input[builtins.bool]] = None,
|
|
1084
|
+
runtime: Optional[pulumi.Input[builtins.str]] = None,
|
|
1085
|
+
security_opts: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None,
|
|
1086
|
+
shm_size: Optional[pulumi.Input[builtins.int]] = None,
|
|
1087
|
+
start: Optional[pulumi.Input[builtins.bool]] = None,
|
|
1088
|
+
stdin_open: Optional[pulumi.Input[builtins.bool]] = None,
|
|
1089
|
+
stop_signal: Optional[pulumi.Input[builtins.str]] = None,
|
|
1090
|
+
stop_timeout: Optional[pulumi.Input[builtins.int]] = None,
|
|
1091
|
+
storage_opts: Optional[pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]] = None,
|
|
1092
|
+
sysctls: Optional[pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]] = None,
|
|
1093
|
+
tmpfs: Optional[pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]] = None,
|
|
1094
|
+
tty: Optional[pulumi.Input[builtins.bool]] = None,
|
|
1077
1095
|
ulimits: Optional[pulumi.Input[Sequence[pulumi.Input['ContainerUlimitArgs']]]] = None,
|
|
1078
1096
|
uploads: Optional[pulumi.Input[Sequence[pulumi.Input['ContainerUploadArgs']]]] = None,
|
|
1079
|
-
user: Optional[pulumi.Input[str]] = None,
|
|
1080
|
-
userns_mode: Optional[pulumi.Input[str]] = None,
|
|
1097
|
+
user: Optional[pulumi.Input[builtins.str]] = None,
|
|
1098
|
+
userns_mode: Optional[pulumi.Input[builtins.str]] = None,
|
|
1081
1099
|
volumes: Optional[pulumi.Input[Sequence[pulumi.Input['ContainerVolumeArgs']]]] = None,
|
|
1082
|
-
wait: Optional[pulumi.Input[bool]] = None,
|
|
1083
|
-
wait_timeout: Optional[pulumi.Input[int]] = None,
|
|
1084
|
-
working_dir: Optional[pulumi.Input[str]] = None):
|
|
1100
|
+
wait: Optional[pulumi.Input[builtins.bool]] = None,
|
|
1101
|
+
wait_timeout: Optional[pulumi.Input[builtins.int]] = None,
|
|
1102
|
+
working_dir: Optional[pulumi.Input[builtins.str]] = None):
|
|
1085
1103
|
"""
|
|
1086
1104
|
Input properties used for looking up and filtering Container resources.
|
|
1087
|
-
:param pulumi.Input[bool] attach: If `true` attach to the container after its creation and waits the end of its execution. Defaults to `false`.
|
|
1088
|
-
:param pulumi.Input[str] bridge: The network bridge of the container as read from its NetworkSettings.
|
|
1105
|
+
:param pulumi.Input[builtins.bool] attach: If `true` attach to the container after its creation and waits the end of its execution. Defaults to `false`.
|
|
1106
|
+
:param pulumi.Input[builtins.str] bridge: The network bridge of the container as read from its NetworkSettings.
|
|
1089
1107
|
:param pulumi.Input['ContainerCapabilitiesArgs'] capabilities: Add or drop certrain linux capabilities.
|
|
1090
|
-
:param pulumi.Input[str] cgroupns_mode: Cgroup namespace mode to use for the container. Possible values are: `private`, `host`.
|
|
1091
|
-
:param pulumi.Input[Sequence[pulumi.Input[str]]] command: 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.
|
|
1092
|
-
:param pulumi.Input[str] container_logs: The logs of the container if its execution is done (`attach` must be disabled).
|
|
1093
|
-
:param pulumi.Input[int] container_read_refresh_timeout_milliseconds: The total number of milliseconds to wait for the container to reach status 'running'
|
|
1094
|
-
:param pulumi.Input[str] cpu_set: A comma-separated list or hyphen-separated range of CPUs a container can use, e.g. `0-1`.
|
|
1095
|
-
:param pulumi.Input[int] cpu_shares: CPU shares (relative weight) for the container.
|
|
1096
|
-
:param pulumi.Input[
|
|
1108
|
+
:param pulumi.Input[builtins.str] cgroupns_mode: Cgroup namespace mode to use for the container. Possible values are: `private`, `host`.
|
|
1109
|
+
:param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] command: 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.conf"]`.
|
|
1110
|
+
:param pulumi.Input[builtins.str] container_logs: The logs of the container if its execution is done (`attach` must be disabled).
|
|
1111
|
+
:param pulumi.Input[builtins.int] container_read_refresh_timeout_milliseconds: The total number of milliseconds to wait for the container to reach status 'running'
|
|
1112
|
+
:param pulumi.Input[builtins.str] cpu_set: A comma-separated list or hyphen-separated range of CPUs a container can use, e.g. `0-1`.
|
|
1113
|
+
:param pulumi.Input[builtins.int] cpu_shares: CPU shares (relative weight) for the container.
|
|
1114
|
+
:param pulumi.Input[builtins.str] cpus: Specify how much of the available CPU resources a container can use. e.g a value of 1.5 means the container is guaranteed at most one and a half of the CPUs
|
|
1115
|
+
:param pulumi.Input[builtins.int] destroy_grace_seconds: If defined will attempt to stop the container before destroying. Container will be destroyed after `n` seconds or on successful stop.
|
|
1097
1116
|
:param pulumi.Input[Sequence[pulumi.Input['ContainerDeviceArgs']]] devices: Bind devices to the container.
|
|
1098
|
-
:param pulumi.Input[Sequence[pulumi.Input[str]]] dns: DNS servers to use.
|
|
1099
|
-
:param pulumi.Input[Sequence[pulumi.Input[str]]] dns_opts: DNS options used by the DNS provider(s), see `resolv.conf` documentation for valid list of options.
|
|
1100
|
-
:param pulumi.Input[Sequence[pulumi.Input[str]]] dns_searches: DNS search domains that are used when bare unqualified hostnames are used inside of the container.
|
|
1101
|
-
:param pulumi.Input[str] domainname: Domain name of the container.
|
|
1102
|
-
:param pulumi.Input[Sequence[pulumi.Input[str]]] entrypoints: 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/
|
|
1103
|
-
:param pulumi.Input[Sequence[pulumi.Input[str]]] envs: Environment variables to set in the form of `KEY=VALUE`, e.g. `DEBUG=0`
|
|
1104
|
-
:param pulumi.Input[int] exit_code: The exit code of the container if its execution is done (`must_run` must be disabled).
|
|
1105
|
-
:param pulumi.Input[str] gpus: GPU devices to add to the container. Currently, only the value `all` is supported. Passing any other value will result in unexpected behavior.
|
|
1106
|
-
:param pulumi.Input[Sequence[pulumi.Input[str]]] group_adds: Additional groups for the container user
|
|
1117
|
+
:param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] dns: DNS servers to use.
|
|
1118
|
+
:param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] dns_opts: DNS options used by the DNS provider(s), see `resolv.conf` documentation for valid list of options.
|
|
1119
|
+
:param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] dns_searches: DNS search domains that are used when bare unqualified hostnames are used inside of the container.
|
|
1120
|
+
:param pulumi.Input[builtins.str] domainname: Domain name of the container.
|
|
1121
|
+
:param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] entrypoints: 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/myprogram"]`.
|
|
1122
|
+
:param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] envs: Environment variables to set in the form of `KEY=VALUE`, e.g. `DEBUG=0`
|
|
1123
|
+
:param pulumi.Input[builtins.int] exit_code: The exit code of the container if its execution is done (`must_run` must be disabled).
|
|
1124
|
+
:param pulumi.Input[builtins.str] gpus: GPU devices to add to the container. Currently, only the value `all` is supported. Passing any other value will result in unexpected behavior.
|
|
1125
|
+
:param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] group_adds: Additional groups for the container user
|
|
1107
1126
|
:param pulumi.Input['ContainerHealthcheckArgs'] healthcheck: A test to perform to check that the container is healthy
|
|
1108
|
-
:param pulumi.Input[str] hostname: Hostname of the container.
|
|
1127
|
+
:param pulumi.Input[builtins.str] hostname: Hostname of the container.
|
|
1109
1128
|
:param pulumi.Input[Sequence[pulumi.Input['ContainerHostArgs']]] hosts: Additional hosts to add to the container.
|
|
1110
|
-
:param pulumi.Input[str] image: The ID of the image to back this container. The easiest way to get this value is to use the `RemoteImage` resource as is shown in the example.
|
|
1111
|
-
:param pulumi.Input[bool] init: Configured whether an init process should be injected for this container. If unset this will default to the `dockerd` defaults.
|
|
1112
|
-
:param pulumi.Input[str] ipc_mode: IPC sharing mode for the container. Possible values are: `none`, `private`, `shareable`, `container:<name|id>` or `host`.
|
|
1129
|
+
:param pulumi.Input[builtins.str] image: The ID of the image to back this container. The easiest way to get this value is to use the `image_id` attribute of the `RemoteImage` resource as is shown in the example.
|
|
1130
|
+
:param pulumi.Input[builtins.bool] init: Configured whether an init process should be injected for this container. If unset this will default to the `dockerd` defaults.
|
|
1131
|
+
:param pulumi.Input[builtins.str] ipc_mode: IPC sharing mode for the container. Possible values are: `none`, `private`, `shareable`, `container:<name|id>` or `host`.
|
|
1113
1132
|
:param pulumi.Input[Sequence[pulumi.Input['ContainerLabelArgs']]] labels: User-defined key/value metadata
|
|
1114
|
-
:param pulumi.Input[str] log_driver: The logging driver to use for the container.
|
|
1115
|
-
:param pulumi.Input[Mapping[str, pulumi.Input[str]]] log_opts: Key/value pairs to use as options for the logging driver.
|
|
1116
|
-
:param pulumi.Input[bool] logs: Save the container logs (`attach` must be enabled). Defaults to `false`.
|
|
1117
|
-
:param pulumi.Input[int] max_retry_count: The maximum amount of times to an attempt a restart when `restart` is set to 'on-failure'.
|
|
1118
|
-
:param pulumi.Input[int] memory: The memory limit for the container in MBs.
|
|
1119
|
-
:param pulumi.Input[int] memory_swap: 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.
|
|
1133
|
+
:param pulumi.Input[builtins.str] log_driver: The logging driver to use for the container.
|
|
1134
|
+
:param pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]] log_opts: Key/value pairs to use as options for the logging driver.
|
|
1135
|
+
:param pulumi.Input[builtins.bool] logs: Save the container logs (`attach` must be enabled). Defaults to `false`.
|
|
1136
|
+
:param pulumi.Input[builtins.int] max_retry_count: The maximum amount of times to an attempt a restart when `restart` is set to 'on-failure'.
|
|
1137
|
+
:param pulumi.Input[builtins.int] memory: The memory limit for the container in MBs.
|
|
1138
|
+
:param pulumi.Input[builtins.int] memory_swap: 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.
|
|
1120
1139
|
:param pulumi.Input[Sequence[pulumi.Input['ContainerMountArgs']]] mounts: Specification for mounts to be added to containers created as part of the service.
|
|
1121
|
-
:param pulumi.Input[str] name: The name of the container.
|
|
1140
|
+
:param pulumi.Input[builtins.str] name: The name of the container.
|
|
1122
1141
|
:param pulumi.Input[Sequence[pulumi.Input['ContainerNetworkDataArgs']]] network_datas: The data of the networks the container is connected to.
|
|
1123
|
-
:param pulumi.Input[str] network_mode: Network mode of the container.
|
|
1142
|
+
:param pulumi.Input[builtins.str] network_mode: Network mode of the container. See https://docs.docker.com/engine/network/ for more information.
|
|
1124
1143
|
:param pulumi.Input[Sequence[pulumi.Input['ContainerNetworksAdvancedArgs']]] networks_advanced: The networks the container is attached to
|
|
1125
|
-
:param pulumi.Input[str] pid_mode: he PID (Process) Namespace mode for the container. Either `container:<name|id>` or `host`.
|
|
1144
|
+
:param pulumi.Input[builtins.str] pid_mode: he PID (Process) Namespace mode for the container. Either `container:<name|id>` or `host`.
|
|
1126
1145
|
:param pulumi.Input[Sequence[pulumi.Input['ContainerPortArgs']]] ports: Publish a container's port(s) to the host.
|
|
1127
|
-
:param pulumi.Input[bool] privileged: If `true`, the container runs in privileged mode.
|
|
1128
|
-
:param pulumi.Input[bool] publish_all_ports: Publish all ports of the container.
|
|
1129
|
-
:param pulumi.Input[bool] read_only: If `true`, the container will be started as readonly. Defaults to `false`.
|
|
1130
|
-
:param pulumi.Input[bool] remove_volumes: If `true`, it will remove anonymous volumes associated with the container. Defaults to `true`.
|
|
1131
|
-
:param pulumi.Input[str] restart: The restart policy for the container. Must be one of 'no', 'on-failure', 'always', 'unless-stopped'. Defaults to `no`.
|
|
1132
|
-
:param pulumi.Input[bool] rm: If `true`, then the container will be automatically removed when it exits. Defaults to `false`.
|
|
1133
|
-
:param pulumi.Input[str] runtime: Runtime to use for the container.
|
|
1134
|
-
:param pulumi.Input[Sequence[pulumi.Input[str]]] security_opts: List of string values to customize labels for MLS systems, such as SELinux. See https://docs.docker.com/engine/reference/run/#security-configuration.
|
|
1135
|
-
:param pulumi.Input[int] shm_size: Size of `/dev/shm` in MBs.
|
|
1136
|
-
:param pulumi.Input[bool] start: If `true`, then the Docker container will be started after creation. If `false`, then the container is only created. Defaults to `true`.
|
|
1137
|
-
:param pulumi.Input[bool] stdin_open: If `true`, keep STDIN open even if not attached (`docker run -i`). Defaults to `false`.
|
|
1138
|
-
:param pulumi.Input[str] stop_signal: Signal to stop a container (default `SIGTERM`).
|
|
1139
|
-
:param pulumi.Input[int] stop_timeout: Timeout (in seconds) to stop a container.
|
|
1140
|
-
:param pulumi.Input[Mapping[str, pulumi.Input[str]]] storage_opts: Key/value pairs for the storage driver options, e.g. `size`: `120G`
|
|
1141
|
-
:param pulumi.Input[Mapping[str, pulumi.Input[str]]] sysctls: A map of kernel parameters (sysctls) to set in the container.
|
|
1142
|
-
:param pulumi.Input[Mapping[str, pulumi.Input[str]]] tmpfs: A map of container directories which should be replaced by `tmpfs mounts`, and their corresponding mount options.
|
|
1143
|
-
:param pulumi.Input[bool] tty: If `true`, allocate a pseudo-tty (`docker run -t`). Defaults to `false`.
|
|
1146
|
+
:param pulumi.Input[builtins.bool] privileged: If `true`, the container runs in privileged mode.
|
|
1147
|
+
:param pulumi.Input[builtins.bool] publish_all_ports: Publish all ports of the container.
|
|
1148
|
+
:param pulumi.Input[builtins.bool] read_only: If `true`, the container will be started as readonly. Defaults to `false`.
|
|
1149
|
+
:param pulumi.Input[builtins.bool] remove_volumes: If `true`, it will remove anonymous volumes associated with the container. Defaults to `true`.
|
|
1150
|
+
:param pulumi.Input[builtins.str] restart: The restart policy for the container. Must be one of 'no', 'on-failure', 'always', 'unless-stopped'. Defaults to `no`.
|
|
1151
|
+
:param pulumi.Input[builtins.bool] rm: If `true`, then the container will be automatically removed when it exits. Defaults to `false`.
|
|
1152
|
+
:param pulumi.Input[builtins.str] runtime: Runtime to use for the container.
|
|
1153
|
+
:param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] security_opts: List of string values to customize labels for MLS systems, such as SELinux. See https://docs.docker.com/engine/reference/run/#security-configuration.
|
|
1154
|
+
:param pulumi.Input[builtins.int] shm_size: Size of `/dev/shm` in MBs.
|
|
1155
|
+
:param pulumi.Input[builtins.bool] start: If `true`, then the Docker container will be started after creation. If `false`, then the container is only created. Defaults to `true`.
|
|
1156
|
+
:param pulumi.Input[builtins.bool] stdin_open: If `true`, keep STDIN open even if not attached (`docker run -i`). Defaults to `false`.
|
|
1157
|
+
:param pulumi.Input[builtins.str] stop_signal: Signal to stop a container (default `SIGTERM`).
|
|
1158
|
+
:param pulumi.Input[builtins.int] stop_timeout: Timeout (in seconds) to stop a container.
|
|
1159
|
+
:param pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]] storage_opts: Key/value pairs for the storage driver options, e.g. `size`: `120G`
|
|
1160
|
+
:param pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]] sysctls: A map of kernel parameters (sysctls) to set in the container.
|
|
1161
|
+
:param pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]] tmpfs: A map of container directories which should be replaced by `tmpfs mounts`, and their corresponding mount options.
|
|
1162
|
+
:param pulumi.Input[builtins.bool] tty: If `true`, allocate a pseudo-tty (`docker run -t`). Defaults to `false`.
|
|
1144
1163
|
:param pulumi.Input[Sequence[pulumi.Input['ContainerUlimitArgs']]] ulimits: Ulimit options to add.
|
|
1145
1164
|
:param pulumi.Input[Sequence[pulumi.Input['ContainerUploadArgs']]] uploads: 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.
|
|
1146
|
-
:param pulumi.Input[str] user: User used for run the first process. Format is `user` or `user:group` which user and group can be passed literraly or by name.
|
|
1147
|
-
:param pulumi.Input[str] userns_mode: Sets the usernamespace mode for the container when usernamespace remapping option is enabled.
|
|
1165
|
+
:param pulumi.Input[builtins.str] user: User used for run the first process. Format is `user` or `user:group` which user and group can be passed literraly or by name.
|
|
1166
|
+
:param pulumi.Input[builtins.str] userns_mode: Sets the usernamespace mode for the container when usernamespace remapping option is enabled.
|
|
1148
1167
|
:param pulumi.Input[Sequence[pulumi.Input['ContainerVolumeArgs']]] volumes: Spec for mounting volumes in the container.
|
|
1149
|
-
:param pulumi.Input[bool] wait: 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`.
|
|
1150
|
-
:param pulumi.Input[int] wait_timeout: The timeout in seconds to wait the container to be healthy after creation. Defaults to `60`.
|
|
1151
|
-
:param pulumi.Input[str] working_dir: The working directory for commands to run in.
|
|
1168
|
+
:param pulumi.Input[builtins.bool] wait: If `true`, then the Docker container is waited for being healthy state after creation. This requires your container to have a healthcheck, otherwise this provider will error. If `false`, then the container health state is not checked. Defaults to `false`.
|
|
1169
|
+
:param pulumi.Input[builtins.int] wait_timeout: The timeout in seconds to wait the container to be healthy after creation. Defaults to `60`.
|
|
1170
|
+
:param pulumi.Input[builtins.str] working_dir: The working directory for commands to run in.
|
|
1152
1171
|
"""
|
|
1153
1172
|
if attach is not None:
|
|
1154
1173
|
pulumi.set(__self__, "attach", attach)
|
|
@@ -1168,6 +1187,8 @@ class _ContainerState:
|
|
|
1168
1187
|
pulumi.set(__self__, "cpu_set", cpu_set)
|
|
1169
1188
|
if cpu_shares is not None:
|
|
1170
1189
|
pulumi.set(__self__, "cpu_shares", cpu_shares)
|
|
1190
|
+
if cpus is not None:
|
|
1191
|
+
pulumi.set(__self__, "cpus", cpus)
|
|
1171
1192
|
if destroy_grace_seconds is not None:
|
|
1172
1193
|
pulumi.set(__self__, "destroy_grace_seconds", destroy_grace_seconds)
|
|
1173
1194
|
if devices is not None:
|
|
@@ -1285,26 +1306,26 @@ class _ContainerState:
|
|
|
1285
1306
|
|
|
1286
1307
|
@property
|
|
1287
1308
|
@pulumi.getter
|
|
1288
|
-
def attach(self) -> Optional[pulumi.Input[bool]]:
|
|
1309
|
+
def attach(self) -> Optional[pulumi.Input[builtins.bool]]:
|
|
1289
1310
|
"""
|
|
1290
1311
|
If `true` attach to the container after its creation and waits the end of its execution. Defaults to `false`.
|
|
1291
1312
|
"""
|
|
1292
1313
|
return pulumi.get(self, "attach")
|
|
1293
1314
|
|
|
1294
1315
|
@attach.setter
|
|
1295
|
-
def attach(self, value: Optional[pulumi.Input[bool]]):
|
|
1316
|
+
def attach(self, value: Optional[pulumi.Input[builtins.bool]]):
|
|
1296
1317
|
pulumi.set(self, "attach", value)
|
|
1297
1318
|
|
|
1298
1319
|
@property
|
|
1299
1320
|
@pulumi.getter
|
|
1300
|
-
def bridge(self) -> Optional[pulumi.Input[str]]:
|
|
1321
|
+
def bridge(self) -> Optional[pulumi.Input[builtins.str]]:
|
|
1301
1322
|
"""
|
|
1302
1323
|
The network bridge of the container as read from its NetworkSettings.
|
|
1303
1324
|
"""
|
|
1304
1325
|
return pulumi.get(self, "bridge")
|
|
1305
1326
|
|
|
1306
1327
|
@bridge.setter
|
|
1307
|
-
def bridge(self, value: Optional[pulumi.Input[str]]):
|
|
1328
|
+
def bridge(self, value: Optional[pulumi.Input[builtins.str]]):
|
|
1308
1329
|
pulumi.set(self, "bridge", value)
|
|
1309
1330
|
|
|
1310
1331
|
@property
|
|
@@ -1321,86 +1342,98 @@ class _ContainerState:
|
|
|
1321
1342
|
|
|
1322
1343
|
@property
|
|
1323
1344
|
@pulumi.getter(name="cgroupnsMode")
|
|
1324
|
-
def cgroupns_mode(self) -> Optional[pulumi.Input[str]]:
|
|
1345
|
+
def cgroupns_mode(self) -> Optional[pulumi.Input[builtins.str]]:
|
|
1325
1346
|
"""
|
|
1326
1347
|
Cgroup namespace mode to use for the container. Possible values are: `private`, `host`.
|
|
1327
1348
|
"""
|
|
1328
1349
|
return pulumi.get(self, "cgroupns_mode")
|
|
1329
1350
|
|
|
1330
1351
|
@cgroupns_mode.setter
|
|
1331
|
-
def cgroupns_mode(self, value: Optional[pulumi.Input[str]]):
|
|
1352
|
+
def cgroupns_mode(self, value: Optional[pulumi.Input[builtins.str]]):
|
|
1332
1353
|
pulumi.set(self, "cgroupns_mode", value)
|
|
1333
1354
|
|
|
1334
1355
|
@property
|
|
1335
1356
|
@pulumi.getter
|
|
1336
|
-
def command(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
|
|
1357
|
+
def command(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]:
|
|
1337
1358
|
"""
|
|
1338
|
-
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.
|
|
1359
|
+
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.conf"]`.
|
|
1339
1360
|
"""
|
|
1340
1361
|
return pulumi.get(self, "command")
|
|
1341
1362
|
|
|
1342
1363
|
@command.setter
|
|
1343
|
-
def command(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
|
|
1364
|
+
def command(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]):
|
|
1344
1365
|
pulumi.set(self, "command", value)
|
|
1345
1366
|
|
|
1346
1367
|
@property
|
|
1347
1368
|
@pulumi.getter(name="containerLogs")
|
|
1348
|
-
def container_logs(self) -> Optional[pulumi.Input[str]]:
|
|
1369
|
+
def container_logs(self) -> Optional[pulumi.Input[builtins.str]]:
|
|
1349
1370
|
"""
|
|
1350
1371
|
The logs of the container if its execution is done (`attach` must be disabled).
|
|
1351
1372
|
"""
|
|
1352
1373
|
return pulumi.get(self, "container_logs")
|
|
1353
1374
|
|
|
1354
1375
|
@container_logs.setter
|
|
1355
|
-
def container_logs(self, value: Optional[pulumi.Input[str]]):
|
|
1376
|
+
def container_logs(self, value: Optional[pulumi.Input[builtins.str]]):
|
|
1356
1377
|
pulumi.set(self, "container_logs", value)
|
|
1357
1378
|
|
|
1358
1379
|
@property
|
|
1359
1380
|
@pulumi.getter(name="containerReadRefreshTimeoutMilliseconds")
|
|
1360
|
-
def container_read_refresh_timeout_milliseconds(self) -> Optional[pulumi.Input[int]]:
|
|
1381
|
+
def container_read_refresh_timeout_milliseconds(self) -> Optional[pulumi.Input[builtins.int]]:
|
|
1361
1382
|
"""
|
|
1362
1383
|
The total number of milliseconds to wait for the container to reach status 'running'
|
|
1363
1384
|
"""
|
|
1364
1385
|
return pulumi.get(self, "container_read_refresh_timeout_milliseconds")
|
|
1365
1386
|
|
|
1366
1387
|
@container_read_refresh_timeout_milliseconds.setter
|
|
1367
|
-
def container_read_refresh_timeout_milliseconds(self, value: Optional[pulumi.Input[int]]):
|
|
1388
|
+
def container_read_refresh_timeout_milliseconds(self, value: Optional[pulumi.Input[builtins.int]]):
|
|
1368
1389
|
pulumi.set(self, "container_read_refresh_timeout_milliseconds", value)
|
|
1369
1390
|
|
|
1370
1391
|
@property
|
|
1371
1392
|
@pulumi.getter(name="cpuSet")
|
|
1372
|
-
def cpu_set(self) -> Optional[pulumi.Input[str]]:
|
|
1393
|
+
def cpu_set(self) -> Optional[pulumi.Input[builtins.str]]:
|
|
1373
1394
|
"""
|
|
1374
1395
|
A comma-separated list or hyphen-separated range of CPUs a container can use, e.g. `0-1`.
|
|
1375
1396
|
"""
|
|
1376
1397
|
return pulumi.get(self, "cpu_set")
|
|
1377
1398
|
|
|
1378
1399
|
@cpu_set.setter
|
|
1379
|
-
def cpu_set(self, value: Optional[pulumi.Input[str]]):
|
|
1400
|
+
def cpu_set(self, value: Optional[pulumi.Input[builtins.str]]):
|
|
1380
1401
|
pulumi.set(self, "cpu_set", value)
|
|
1381
1402
|
|
|
1382
1403
|
@property
|
|
1383
1404
|
@pulumi.getter(name="cpuShares")
|
|
1384
|
-
def cpu_shares(self) -> Optional[pulumi.Input[int]]:
|
|
1405
|
+
def cpu_shares(self) -> Optional[pulumi.Input[builtins.int]]:
|
|
1385
1406
|
"""
|
|
1386
1407
|
CPU shares (relative weight) for the container.
|
|
1387
1408
|
"""
|
|
1388
1409
|
return pulumi.get(self, "cpu_shares")
|
|
1389
1410
|
|
|
1390
1411
|
@cpu_shares.setter
|
|
1391
|
-
def cpu_shares(self, value: Optional[pulumi.Input[int]]):
|
|
1412
|
+
def cpu_shares(self, value: Optional[pulumi.Input[builtins.int]]):
|
|
1392
1413
|
pulumi.set(self, "cpu_shares", value)
|
|
1393
1414
|
|
|
1415
|
+
@property
|
|
1416
|
+
@pulumi.getter
|
|
1417
|
+
def cpus(self) -> Optional[pulumi.Input[builtins.str]]:
|
|
1418
|
+
"""
|
|
1419
|
+
Specify how much of the available CPU resources a container can use. e.g a value of 1.5 means the container is guaranteed at most one and a half of the CPUs
|
|
1420
|
+
"""
|
|
1421
|
+
return pulumi.get(self, "cpus")
|
|
1422
|
+
|
|
1423
|
+
@cpus.setter
|
|
1424
|
+
def cpus(self, value: Optional[pulumi.Input[builtins.str]]):
|
|
1425
|
+
pulumi.set(self, "cpus", value)
|
|
1426
|
+
|
|
1394
1427
|
@property
|
|
1395
1428
|
@pulumi.getter(name="destroyGraceSeconds")
|
|
1396
|
-
def destroy_grace_seconds(self) -> Optional[pulumi.Input[int]]:
|
|
1429
|
+
def destroy_grace_seconds(self) -> Optional[pulumi.Input[builtins.int]]:
|
|
1397
1430
|
"""
|
|
1398
1431
|
If defined will attempt to stop the container before destroying. Container will be destroyed after `n` seconds or on successful stop.
|
|
1399
1432
|
"""
|
|
1400
1433
|
return pulumi.get(self, "destroy_grace_seconds")
|
|
1401
1434
|
|
|
1402
1435
|
@destroy_grace_seconds.setter
|
|
1403
|
-
def destroy_grace_seconds(self, value: Optional[pulumi.Input[int]]):
|
|
1436
|
+
def destroy_grace_seconds(self, value: Optional[pulumi.Input[builtins.int]]):
|
|
1404
1437
|
pulumi.set(self, "destroy_grace_seconds", value)
|
|
1405
1438
|
|
|
1406
1439
|
@property
|
|
@@ -1417,110 +1450,110 @@ class _ContainerState:
|
|
|
1417
1450
|
|
|
1418
1451
|
@property
|
|
1419
1452
|
@pulumi.getter
|
|
1420
|
-
def dns(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
|
|
1453
|
+
def dns(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]:
|
|
1421
1454
|
"""
|
|
1422
1455
|
DNS servers to use.
|
|
1423
1456
|
"""
|
|
1424
1457
|
return pulumi.get(self, "dns")
|
|
1425
1458
|
|
|
1426
1459
|
@dns.setter
|
|
1427
|
-
def dns(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
|
|
1460
|
+
def dns(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]):
|
|
1428
1461
|
pulumi.set(self, "dns", value)
|
|
1429
1462
|
|
|
1430
1463
|
@property
|
|
1431
1464
|
@pulumi.getter(name="dnsOpts")
|
|
1432
|
-
def dns_opts(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
|
|
1465
|
+
def dns_opts(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]:
|
|
1433
1466
|
"""
|
|
1434
1467
|
DNS options used by the DNS provider(s), see `resolv.conf` documentation for valid list of options.
|
|
1435
1468
|
"""
|
|
1436
1469
|
return pulumi.get(self, "dns_opts")
|
|
1437
1470
|
|
|
1438
1471
|
@dns_opts.setter
|
|
1439
|
-
def dns_opts(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
|
|
1472
|
+
def dns_opts(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]):
|
|
1440
1473
|
pulumi.set(self, "dns_opts", value)
|
|
1441
1474
|
|
|
1442
1475
|
@property
|
|
1443
1476
|
@pulumi.getter(name="dnsSearches")
|
|
1444
|
-
def dns_searches(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
|
|
1477
|
+
def dns_searches(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]:
|
|
1445
1478
|
"""
|
|
1446
1479
|
DNS search domains that are used when bare unqualified hostnames are used inside of the container.
|
|
1447
1480
|
"""
|
|
1448
1481
|
return pulumi.get(self, "dns_searches")
|
|
1449
1482
|
|
|
1450
1483
|
@dns_searches.setter
|
|
1451
|
-
def dns_searches(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
|
|
1484
|
+
def dns_searches(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]):
|
|
1452
1485
|
pulumi.set(self, "dns_searches", value)
|
|
1453
1486
|
|
|
1454
1487
|
@property
|
|
1455
1488
|
@pulumi.getter
|
|
1456
|
-
def domainname(self) -> Optional[pulumi.Input[str]]:
|
|
1489
|
+
def domainname(self) -> Optional[pulumi.Input[builtins.str]]:
|
|
1457
1490
|
"""
|
|
1458
1491
|
Domain name of the container.
|
|
1459
1492
|
"""
|
|
1460
1493
|
return pulumi.get(self, "domainname")
|
|
1461
1494
|
|
|
1462
1495
|
@domainname.setter
|
|
1463
|
-
def domainname(self, value: Optional[pulumi.Input[str]]):
|
|
1496
|
+
def domainname(self, value: Optional[pulumi.Input[builtins.str]]):
|
|
1464
1497
|
pulumi.set(self, "domainname", value)
|
|
1465
1498
|
|
|
1466
1499
|
@property
|
|
1467
1500
|
@pulumi.getter
|
|
1468
|
-
def entrypoints(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
|
|
1501
|
+
def entrypoints(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]:
|
|
1469
1502
|
"""
|
|
1470
|
-
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/
|
|
1503
|
+
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/myprogram"]`.
|
|
1471
1504
|
"""
|
|
1472
1505
|
return pulumi.get(self, "entrypoints")
|
|
1473
1506
|
|
|
1474
1507
|
@entrypoints.setter
|
|
1475
|
-
def entrypoints(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
|
|
1508
|
+
def entrypoints(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]):
|
|
1476
1509
|
pulumi.set(self, "entrypoints", value)
|
|
1477
1510
|
|
|
1478
1511
|
@property
|
|
1479
1512
|
@pulumi.getter
|
|
1480
|
-
def envs(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
|
|
1513
|
+
def envs(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]:
|
|
1481
1514
|
"""
|
|
1482
1515
|
Environment variables to set in the form of `KEY=VALUE`, e.g. `DEBUG=0`
|
|
1483
1516
|
"""
|
|
1484
1517
|
return pulumi.get(self, "envs")
|
|
1485
1518
|
|
|
1486
1519
|
@envs.setter
|
|
1487
|
-
def envs(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
|
|
1520
|
+
def envs(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]):
|
|
1488
1521
|
pulumi.set(self, "envs", value)
|
|
1489
1522
|
|
|
1490
1523
|
@property
|
|
1491
1524
|
@pulumi.getter(name="exitCode")
|
|
1492
|
-
def exit_code(self) -> Optional[pulumi.Input[int]]:
|
|
1525
|
+
def exit_code(self) -> Optional[pulumi.Input[builtins.int]]:
|
|
1493
1526
|
"""
|
|
1494
1527
|
The exit code of the container if its execution is done (`must_run` must be disabled).
|
|
1495
1528
|
"""
|
|
1496
1529
|
return pulumi.get(self, "exit_code")
|
|
1497
1530
|
|
|
1498
1531
|
@exit_code.setter
|
|
1499
|
-
def exit_code(self, value: Optional[pulumi.Input[int]]):
|
|
1532
|
+
def exit_code(self, value: Optional[pulumi.Input[builtins.int]]):
|
|
1500
1533
|
pulumi.set(self, "exit_code", value)
|
|
1501
1534
|
|
|
1502
1535
|
@property
|
|
1503
1536
|
@pulumi.getter
|
|
1504
|
-
def gpus(self) -> Optional[pulumi.Input[str]]:
|
|
1537
|
+
def gpus(self) -> Optional[pulumi.Input[builtins.str]]:
|
|
1505
1538
|
"""
|
|
1506
1539
|
GPU devices to add to the container. Currently, only the value `all` is supported. Passing any other value will result in unexpected behavior.
|
|
1507
1540
|
"""
|
|
1508
1541
|
return pulumi.get(self, "gpus")
|
|
1509
1542
|
|
|
1510
1543
|
@gpus.setter
|
|
1511
|
-
def gpus(self, value: Optional[pulumi.Input[str]]):
|
|
1544
|
+
def gpus(self, value: Optional[pulumi.Input[builtins.str]]):
|
|
1512
1545
|
pulumi.set(self, "gpus", value)
|
|
1513
1546
|
|
|
1514
1547
|
@property
|
|
1515
1548
|
@pulumi.getter(name="groupAdds")
|
|
1516
|
-
def group_adds(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
|
|
1549
|
+
def group_adds(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]:
|
|
1517
1550
|
"""
|
|
1518
1551
|
Additional groups for the container user
|
|
1519
1552
|
"""
|
|
1520
1553
|
return pulumi.get(self, "group_adds")
|
|
1521
1554
|
|
|
1522
1555
|
@group_adds.setter
|
|
1523
|
-
def group_adds(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
|
|
1556
|
+
def group_adds(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]):
|
|
1524
1557
|
pulumi.set(self, "group_adds", value)
|
|
1525
1558
|
|
|
1526
1559
|
@property
|
|
@@ -1537,14 +1570,14 @@ class _ContainerState:
|
|
|
1537
1570
|
|
|
1538
1571
|
@property
|
|
1539
1572
|
@pulumi.getter
|
|
1540
|
-
def hostname(self) -> Optional[pulumi.Input[str]]:
|
|
1573
|
+
def hostname(self) -> Optional[pulumi.Input[builtins.str]]:
|
|
1541
1574
|
"""
|
|
1542
1575
|
Hostname of the container.
|
|
1543
1576
|
"""
|
|
1544
1577
|
return pulumi.get(self, "hostname")
|
|
1545
1578
|
|
|
1546
1579
|
@hostname.setter
|
|
1547
|
-
def hostname(self, value: Optional[pulumi.Input[str]]):
|
|
1580
|
+
def hostname(self, value: Optional[pulumi.Input[builtins.str]]):
|
|
1548
1581
|
pulumi.set(self, "hostname", value)
|
|
1549
1582
|
|
|
1550
1583
|
@property
|
|
@@ -1561,38 +1594,38 @@ class _ContainerState:
|
|
|
1561
1594
|
|
|
1562
1595
|
@property
|
|
1563
1596
|
@pulumi.getter
|
|
1564
|
-
def image(self) -> Optional[pulumi.Input[str]]:
|
|
1597
|
+
def image(self) -> Optional[pulumi.Input[builtins.str]]:
|
|
1565
1598
|
"""
|
|
1566
|
-
The ID of the image to back this container. The easiest way to get this value is to use the `RemoteImage` resource as is shown in the example.
|
|
1599
|
+
The ID of the image to back this container. The easiest way to get this value is to use the `image_id` attribute of the `RemoteImage` resource as is shown in the example.
|
|
1567
1600
|
"""
|
|
1568
1601
|
return pulumi.get(self, "image")
|
|
1569
1602
|
|
|
1570
1603
|
@image.setter
|
|
1571
|
-
def image(self, value: Optional[pulumi.Input[str]]):
|
|
1604
|
+
def image(self, value: Optional[pulumi.Input[builtins.str]]):
|
|
1572
1605
|
pulumi.set(self, "image", value)
|
|
1573
1606
|
|
|
1574
1607
|
@property
|
|
1575
1608
|
@pulumi.getter
|
|
1576
|
-
def init(self) -> Optional[pulumi.Input[bool]]:
|
|
1609
|
+
def init(self) -> Optional[pulumi.Input[builtins.bool]]:
|
|
1577
1610
|
"""
|
|
1578
1611
|
Configured whether an init process should be injected for this container. If unset this will default to the `dockerd` defaults.
|
|
1579
1612
|
"""
|
|
1580
1613
|
return pulumi.get(self, "init")
|
|
1581
1614
|
|
|
1582
1615
|
@init.setter
|
|
1583
|
-
def init(self, value: Optional[pulumi.Input[bool]]):
|
|
1616
|
+
def init(self, value: Optional[pulumi.Input[builtins.bool]]):
|
|
1584
1617
|
pulumi.set(self, "init", value)
|
|
1585
1618
|
|
|
1586
1619
|
@property
|
|
1587
1620
|
@pulumi.getter(name="ipcMode")
|
|
1588
|
-
def ipc_mode(self) -> Optional[pulumi.Input[str]]:
|
|
1621
|
+
def ipc_mode(self) -> Optional[pulumi.Input[builtins.str]]:
|
|
1589
1622
|
"""
|
|
1590
1623
|
IPC sharing mode for the container. Possible values are: `none`, `private`, `shareable`, `container:<name|id>` or `host`.
|
|
1591
1624
|
"""
|
|
1592
1625
|
return pulumi.get(self, "ipc_mode")
|
|
1593
1626
|
|
|
1594
1627
|
@ipc_mode.setter
|
|
1595
|
-
def ipc_mode(self, value: Optional[pulumi.Input[str]]):
|
|
1628
|
+
def ipc_mode(self, value: Optional[pulumi.Input[builtins.str]]):
|
|
1596
1629
|
pulumi.set(self, "ipc_mode", value)
|
|
1597
1630
|
|
|
1598
1631
|
@property
|
|
@@ -1609,74 +1642,74 @@ class _ContainerState:
|
|
|
1609
1642
|
|
|
1610
1643
|
@property
|
|
1611
1644
|
@pulumi.getter(name="logDriver")
|
|
1612
|
-
def log_driver(self) -> Optional[pulumi.Input[str]]:
|
|
1645
|
+
def log_driver(self) -> Optional[pulumi.Input[builtins.str]]:
|
|
1613
1646
|
"""
|
|
1614
1647
|
The logging driver to use for the container.
|
|
1615
1648
|
"""
|
|
1616
1649
|
return pulumi.get(self, "log_driver")
|
|
1617
1650
|
|
|
1618
1651
|
@log_driver.setter
|
|
1619
|
-
def log_driver(self, value: Optional[pulumi.Input[str]]):
|
|
1652
|
+
def log_driver(self, value: Optional[pulumi.Input[builtins.str]]):
|
|
1620
1653
|
pulumi.set(self, "log_driver", value)
|
|
1621
1654
|
|
|
1622
1655
|
@property
|
|
1623
1656
|
@pulumi.getter(name="logOpts")
|
|
1624
|
-
def log_opts(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]:
|
|
1657
|
+
def log_opts(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]]:
|
|
1625
1658
|
"""
|
|
1626
1659
|
Key/value pairs to use as options for the logging driver.
|
|
1627
1660
|
"""
|
|
1628
1661
|
return pulumi.get(self, "log_opts")
|
|
1629
1662
|
|
|
1630
1663
|
@log_opts.setter
|
|
1631
|
-
def log_opts(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]):
|
|
1664
|
+
def log_opts(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]]):
|
|
1632
1665
|
pulumi.set(self, "log_opts", value)
|
|
1633
1666
|
|
|
1634
1667
|
@property
|
|
1635
1668
|
@pulumi.getter
|
|
1636
|
-
def logs(self) -> Optional[pulumi.Input[bool]]:
|
|
1669
|
+
def logs(self) -> Optional[pulumi.Input[builtins.bool]]:
|
|
1637
1670
|
"""
|
|
1638
1671
|
Save the container logs (`attach` must be enabled). Defaults to `false`.
|
|
1639
1672
|
"""
|
|
1640
1673
|
return pulumi.get(self, "logs")
|
|
1641
1674
|
|
|
1642
1675
|
@logs.setter
|
|
1643
|
-
def logs(self, value: Optional[pulumi.Input[bool]]):
|
|
1676
|
+
def logs(self, value: Optional[pulumi.Input[builtins.bool]]):
|
|
1644
1677
|
pulumi.set(self, "logs", value)
|
|
1645
1678
|
|
|
1646
1679
|
@property
|
|
1647
1680
|
@pulumi.getter(name="maxRetryCount")
|
|
1648
|
-
def max_retry_count(self) -> Optional[pulumi.Input[int]]:
|
|
1681
|
+
def max_retry_count(self) -> Optional[pulumi.Input[builtins.int]]:
|
|
1649
1682
|
"""
|
|
1650
1683
|
The maximum amount of times to an attempt a restart when `restart` is set to 'on-failure'.
|
|
1651
1684
|
"""
|
|
1652
1685
|
return pulumi.get(self, "max_retry_count")
|
|
1653
1686
|
|
|
1654
1687
|
@max_retry_count.setter
|
|
1655
|
-
def max_retry_count(self, value: Optional[pulumi.Input[int]]):
|
|
1688
|
+
def max_retry_count(self, value: Optional[pulumi.Input[builtins.int]]):
|
|
1656
1689
|
pulumi.set(self, "max_retry_count", value)
|
|
1657
1690
|
|
|
1658
1691
|
@property
|
|
1659
1692
|
@pulumi.getter
|
|
1660
|
-
def memory(self) -> Optional[pulumi.Input[int]]:
|
|
1693
|
+
def memory(self) -> Optional[pulumi.Input[builtins.int]]:
|
|
1661
1694
|
"""
|
|
1662
1695
|
The memory limit for the container in MBs.
|
|
1663
1696
|
"""
|
|
1664
1697
|
return pulumi.get(self, "memory")
|
|
1665
1698
|
|
|
1666
1699
|
@memory.setter
|
|
1667
|
-
def memory(self, value: Optional[pulumi.Input[int]]):
|
|
1700
|
+
def memory(self, value: Optional[pulumi.Input[builtins.int]]):
|
|
1668
1701
|
pulumi.set(self, "memory", value)
|
|
1669
1702
|
|
|
1670
1703
|
@property
|
|
1671
1704
|
@pulumi.getter(name="memorySwap")
|
|
1672
|
-
def memory_swap(self) -> Optional[pulumi.Input[int]]:
|
|
1705
|
+
def memory_swap(self) -> Optional[pulumi.Input[builtins.int]]:
|
|
1673
1706
|
"""
|
|
1674
1707
|
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.
|
|
1675
1708
|
"""
|
|
1676
1709
|
return pulumi.get(self, "memory_swap")
|
|
1677
1710
|
|
|
1678
1711
|
@memory_swap.setter
|
|
1679
|
-
def memory_swap(self, value: Optional[pulumi.Input[int]]):
|
|
1712
|
+
def memory_swap(self, value: Optional[pulumi.Input[builtins.int]]):
|
|
1680
1713
|
pulumi.set(self, "memory_swap", value)
|
|
1681
1714
|
|
|
1682
1715
|
@property
|
|
@@ -1693,23 +1726,23 @@ class _ContainerState:
|
|
|
1693
1726
|
|
|
1694
1727
|
@property
|
|
1695
1728
|
@pulumi.getter(name="mustRun")
|
|
1696
|
-
def must_run(self) -> Optional[pulumi.Input[bool]]:
|
|
1729
|
+
def must_run(self) -> Optional[pulumi.Input[builtins.bool]]:
|
|
1697
1730
|
return pulumi.get(self, "must_run")
|
|
1698
1731
|
|
|
1699
1732
|
@must_run.setter
|
|
1700
|
-
def must_run(self, value: Optional[pulumi.Input[bool]]):
|
|
1733
|
+
def must_run(self, value: Optional[pulumi.Input[builtins.bool]]):
|
|
1701
1734
|
pulumi.set(self, "must_run", value)
|
|
1702
1735
|
|
|
1703
1736
|
@property
|
|
1704
1737
|
@pulumi.getter
|
|
1705
|
-
def name(self) -> Optional[pulumi.Input[str]]:
|
|
1738
|
+
def name(self) -> Optional[pulumi.Input[builtins.str]]:
|
|
1706
1739
|
"""
|
|
1707
1740
|
The name of the container.
|
|
1708
1741
|
"""
|
|
1709
1742
|
return pulumi.get(self, "name")
|
|
1710
1743
|
|
|
1711
1744
|
@name.setter
|
|
1712
|
-
def name(self, value: Optional[pulumi.Input[str]]):
|
|
1745
|
+
def name(self, value: Optional[pulumi.Input[builtins.str]]):
|
|
1713
1746
|
pulumi.set(self, "name", value)
|
|
1714
1747
|
|
|
1715
1748
|
@property
|
|
@@ -1726,14 +1759,14 @@ class _ContainerState:
|
|
|
1726
1759
|
|
|
1727
1760
|
@property
|
|
1728
1761
|
@pulumi.getter(name="networkMode")
|
|
1729
|
-
def network_mode(self) -> Optional[pulumi.Input[str]]:
|
|
1762
|
+
def network_mode(self) -> Optional[pulumi.Input[builtins.str]]:
|
|
1730
1763
|
"""
|
|
1731
|
-
Network mode of the container.
|
|
1764
|
+
Network mode of the container. See https://docs.docker.com/engine/network/ for more information.
|
|
1732
1765
|
"""
|
|
1733
1766
|
return pulumi.get(self, "network_mode")
|
|
1734
1767
|
|
|
1735
1768
|
@network_mode.setter
|
|
1736
|
-
def network_mode(self, value: Optional[pulumi.Input[str]]):
|
|
1769
|
+
def network_mode(self, value: Optional[pulumi.Input[builtins.str]]):
|
|
1737
1770
|
pulumi.set(self, "network_mode", value)
|
|
1738
1771
|
|
|
1739
1772
|
@property
|
|
@@ -1750,14 +1783,14 @@ class _ContainerState:
|
|
|
1750
1783
|
|
|
1751
1784
|
@property
|
|
1752
1785
|
@pulumi.getter(name="pidMode")
|
|
1753
|
-
def pid_mode(self) -> Optional[pulumi.Input[str]]:
|
|
1786
|
+
def pid_mode(self) -> Optional[pulumi.Input[builtins.str]]:
|
|
1754
1787
|
"""
|
|
1755
1788
|
he PID (Process) Namespace mode for the container. Either `container:<name|id>` or `host`.
|
|
1756
1789
|
"""
|
|
1757
1790
|
return pulumi.get(self, "pid_mode")
|
|
1758
1791
|
|
|
1759
1792
|
@pid_mode.setter
|
|
1760
|
-
def pid_mode(self, value: Optional[pulumi.Input[str]]):
|
|
1793
|
+
def pid_mode(self, value: Optional[pulumi.Input[builtins.str]]):
|
|
1761
1794
|
pulumi.set(self, "pid_mode", value)
|
|
1762
1795
|
|
|
1763
1796
|
@property
|
|
@@ -1774,206 +1807,206 @@ class _ContainerState:
|
|
|
1774
1807
|
|
|
1775
1808
|
@property
|
|
1776
1809
|
@pulumi.getter
|
|
1777
|
-
def privileged(self) -> Optional[pulumi.Input[bool]]:
|
|
1810
|
+
def privileged(self) -> Optional[pulumi.Input[builtins.bool]]:
|
|
1778
1811
|
"""
|
|
1779
1812
|
If `true`, the container runs in privileged mode.
|
|
1780
1813
|
"""
|
|
1781
1814
|
return pulumi.get(self, "privileged")
|
|
1782
1815
|
|
|
1783
1816
|
@privileged.setter
|
|
1784
|
-
def privileged(self, value: Optional[pulumi.Input[bool]]):
|
|
1817
|
+
def privileged(self, value: Optional[pulumi.Input[builtins.bool]]):
|
|
1785
1818
|
pulumi.set(self, "privileged", value)
|
|
1786
1819
|
|
|
1787
1820
|
@property
|
|
1788
1821
|
@pulumi.getter(name="publishAllPorts")
|
|
1789
|
-
def publish_all_ports(self) -> Optional[pulumi.Input[bool]]:
|
|
1822
|
+
def publish_all_ports(self) -> Optional[pulumi.Input[builtins.bool]]:
|
|
1790
1823
|
"""
|
|
1791
1824
|
Publish all ports of the container.
|
|
1792
1825
|
"""
|
|
1793
1826
|
return pulumi.get(self, "publish_all_ports")
|
|
1794
1827
|
|
|
1795
1828
|
@publish_all_ports.setter
|
|
1796
|
-
def publish_all_ports(self, value: Optional[pulumi.Input[bool]]):
|
|
1829
|
+
def publish_all_ports(self, value: Optional[pulumi.Input[builtins.bool]]):
|
|
1797
1830
|
pulumi.set(self, "publish_all_ports", value)
|
|
1798
1831
|
|
|
1799
1832
|
@property
|
|
1800
1833
|
@pulumi.getter(name="readOnly")
|
|
1801
|
-
def read_only(self) -> Optional[pulumi.Input[bool]]:
|
|
1834
|
+
def read_only(self) -> Optional[pulumi.Input[builtins.bool]]:
|
|
1802
1835
|
"""
|
|
1803
1836
|
If `true`, the container will be started as readonly. Defaults to `false`.
|
|
1804
1837
|
"""
|
|
1805
1838
|
return pulumi.get(self, "read_only")
|
|
1806
1839
|
|
|
1807
1840
|
@read_only.setter
|
|
1808
|
-
def read_only(self, value: Optional[pulumi.Input[bool]]):
|
|
1841
|
+
def read_only(self, value: Optional[pulumi.Input[builtins.bool]]):
|
|
1809
1842
|
pulumi.set(self, "read_only", value)
|
|
1810
1843
|
|
|
1811
1844
|
@property
|
|
1812
1845
|
@pulumi.getter(name="removeVolumes")
|
|
1813
|
-
def remove_volumes(self) -> Optional[pulumi.Input[bool]]:
|
|
1846
|
+
def remove_volumes(self) -> Optional[pulumi.Input[builtins.bool]]:
|
|
1814
1847
|
"""
|
|
1815
1848
|
If `true`, it will remove anonymous volumes associated with the container. Defaults to `true`.
|
|
1816
1849
|
"""
|
|
1817
1850
|
return pulumi.get(self, "remove_volumes")
|
|
1818
1851
|
|
|
1819
1852
|
@remove_volumes.setter
|
|
1820
|
-
def remove_volumes(self, value: Optional[pulumi.Input[bool]]):
|
|
1853
|
+
def remove_volumes(self, value: Optional[pulumi.Input[builtins.bool]]):
|
|
1821
1854
|
pulumi.set(self, "remove_volumes", value)
|
|
1822
1855
|
|
|
1823
1856
|
@property
|
|
1824
1857
|
@pulumi.getter
|
|
1825
|
-
def restart(self) -> Optional[pulumi.Input[str]]:
|
|
1858
|
+
def restart(self) -> Optional[pulumi.Input[builtins.str]]:
|
|
1826
1859
|
"""
|
|
1827
1860
|
The restart policy for the container. Must be one of 'no', 'on-failure', 'always', 'unless-stopped'. Defaults to `no`.
|
|
1828
1861
|
"""
|
|
1829
1862
|
return pulumi.get(self, "restart")
|
|
1830
1863
|
|
|
1831
1864
|
@restart.setter
|
|
1832
|
-
def restart(self, value: Optional[pulumi.Input[str]]):
|
|
1865
|
+
def restart(self, value: Optional[pulumi.Input[builtins.str]]):
|
|
1833
1866
|
pulumi.set(self, "restart", value)
|
|
1834
1867
|
|
|
1835
1868
|
@property
|
|
1836
1869
|
@pulumi.getter
|
|
1837
|
-
def rm(self) -> Optional[pulumi.Input[bool]]:
|
|
1870
|
+
def rm(self) -> Optional[pulumi.Input[builtins.bool]]:
|
|
1838
1871
|
"""
|
|
1839
1872
|
If `true`, then the container will be automatically removed when it exits. Defaults to `false`.
|
|
1840
1873
|
"""
|
|
1841
1874
|
return pulumi.get(self, "rm")
|
|
1842
1875
|
|
|
1843
1876
|
@rm.setter
|
|
1844
|
-
def rm(self, value: Optional[pulumi.Input[bool]]):
|
|
1877
|
+
def rm(self, value: Optional[pulumi.Input[builtins.bool]]):
|
|
1845
1878
|
pulumi.set(self, "rm", value)
|
|
1846
1879
|
|
|
1847
1880
|
@property
|
|
1848
1881
|
@pulumi.getter
|
|
1849
|
-
def runtime(self) -> Optional[pulumi.Input[str]]:
|
|
1882
|
+
def runtime(self) -> Optional[pulumi.Input[builtins.str]]:
|
|
1850
1883
|
"""
|
|
1851
1884
|
Runtime to use for the container.
|
|
1852
1885
|
"""
|
|
1853
1886
|
return pulumi.get(self, "runtime")
|
|
1854
1887
|
|
|
1855
1888
|
@runtime.setter
|
|
1856
|
-
def runtime(self, value: Optional[pulumi.Input[str]]):
|
|
1889
|
+
def runtime(self, value: Optional[pulumi.Input[builtins.str]]):
|
|
1857
1890
|
pulumi.set(self, "runtime", value)
|
|
1858
1891
|
|
|
1859
1892
|
@property
|
|
1860
1893
|
@pulumi.getter(name="securityOpts")
|
|
1861
|
-
def security_opts(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
|
|
1894
|
+
def security_opts(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]:
|
|
1862
1895
|
"""
|
|
1863
1896
|
List of string values to customize labels for MLS systems, such as SELinux. See https://docs.docker.com/engine/reference/run/#security-configuration.
|
|
1864
1897
|
"""
|
|
1865
1898
|
return pulumi.get(self, "security_opts")
|
|
1866
1899
|
|
|
1867
1900
|
@security_opts.setter
|
|
1868
|
-
def security_opts(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
|
|
1901
|
+
def security_opts(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]):
|
|
1869
1902
|
pulumi.set(self, "security_opts", value)
|
|
1870
1903
|
|
|
1871
1904
|
@property
|
|
1872
1905
|
@pulumi.getter(name="shmSize")
|
|
1873
|
-
def shm_size(self) -> Optional[pulumi.Input[int]]:
|
|
1906
|
+
def shm_size(self) -> Optional[pulumi.Input[builtins.int]]:
|
|
1874
1907
|
"""
|
|
1875
1908
|
Size of `/dev/shm` in MBs.
|
|
1876
1909
|
"""
|
|
1877
1910
|
return pulumi.get(self, "shm_size")
|
|
1878
1911
|
|
|
1879
1912
|
@shm_size.setter
|
|
1880
|
-
def shm_size(self, value: Optional[pulumi.Input[int]]):
|
|
1913
|
+
def shm_size(self, value: Optional[pulumi.Input[builtins.int]]):
|
|
1881
1914
|
pulumi.set(self, "shm_size", value)
|
|
1882
1915
|
|
|
1883
1916
|
@property
|
|
1884
1917
|
@pulumi.getter
|
|
1885
|
-
def start(self) -> Optional[pulumi.Input[bool]]:
|
|
1918
|
+
def start(self) -> Optional[pulumi.Input[builtins.bool]]:
|
|
1886
1919
|
"""
|
|
1887
1920
|
If `true`, then the Docker container will be started after creation. If `false`, then the container is only created. Defaults to `true`.
|
|
1888
1921
|
"""
|
|
1889
1922
|
return pulumi.get(self, "start")
|
|
1890
1923
|
|
|
1891
1924
|
@start.setter
|
|
1892
|
-
def start(self, value: Optional[pulumi.Input[bool]]):
|
|
1925
|
+
def start(self, value: Optional[pulumi.Input[builtins.bool]]):
|
|
1893
1926
|
pulumi.set(self, "start", value)
|
|
1894
1927
|
|
|
1895
1928
|
@property
|
|
1896
1929
|
@pulumi.getter(name="stdinOpen")
|
|
1897
|
-
def stdin_open(self) -> Optional[pulumi.Input[bool]]:
|
|
1930
|
+
def stdin_open(self) -> Optional[pulumi.Input[builtins.bool]]:
|
|
1898
1931
|
"""
|
|
1899
1932
|
If `true`, keep STDIN open even if not attached (`docker run -i`). Defaults to `false`.
|
|
1900
1933
|
"""
|
|
1901
1934
|
return pulumi.get(self, "stdin_open")
|
|
1902
1935
|
|
|
1903
1936
|
@stdin_open.setter
|
|
1904
|
-
def stdin_open(self, value: Optional[pulumi.Input[bool]]):
|
|
1937
|
+
def stdin_open(self, value: Optional[pulumi.Input[builtins.bool]]):
|
|
1905
1938
|
pulumi.set(self, "stdin_open", value)
|
|
1906
1939
|
|
|
1907
1940
|
@property
|
|
1908
1941
|
@pulumi.getter(name="stopSignal")
|
|
1909
|
-
def stop_signal(self) -> Optional[pulumi.Input[str]]:
|
|
1942
|
+
def stop_signal(self) -> Optional[pulumi.Input[builtins.str]]:
|
|
1910
1943
|
"""
|
|
1911
1944
|
Signal to stop a container (default `SIGTERM`).
|
|
1912
1945
|
"""
|
|
1913
1946
|
return pulumi.get(self, "stop_signal")
|
|
1914
1947
|
|
|
1915
1948
|
@stop_signal.setter
|
|
1916
|
-
def stop_signal(self, value: Optional[pulumi.Input[str]]):
|
|
1949
|
+
def stop_signal(self, value: Optional[pulumi.Input[builtins.str]]):
|
|
1917
1950
|
pulumi.set(self, "stop_signal", value)
|
|
1918
1951
|
|
|
1919
1952
|
@property
|
|
1920
1953
|
@pulumi.getter(name="stopTimeout")
|
|
1921
|
-
def stop_timeout(self) -> Optional[pulumi.Input[int]]:
|
|
1954
|
+
def stop_timeout(self) -> Optional[pulumi.Input[builtins.int]]:
|
|
1922
1955
|
"""
|
|
1923
1956
|
Timeout (in seconds) to stop a container.
|
|
1924
1957
|
"""
|
|
1925
1958
|
return pulumi.get(self, "stop_timeout")
|
|
1926
1959
|
|
|
1927
1960
|
@stop_timeout.setter
|
|
1928
|
-
def stop_timeout(self, value: Optional[pulumi.Input[int]]):
|
|
1961
|
+
def stop_timeout(self, value: Optional[pulumi.Input[builtins.int]]):
|
|
1929
1962
|
pulumi.set(self, "stop_timeout", value)
|
|
1930
1963
|
|
|
1931
1964
|
@property
|
|
1932
1965
|
@pulumi.getter(name="storageOpts")
|
|
1933
|
-
def storage_opts(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]:
|
|
1966
|
+
def storage_opts(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]]:
|
|
1934
1967
|
"""
|
|
1935
1968
|
Key/value pairs for the storage driver options, e.g. `size`: `120G`
|
|
1936
1969
|
"""
|
|
1937
1970
|
return pulumi.get(self, "storage_opts")
|
|
1938
1971
|
|
|
1939
1972
|
@storage_opts.setter
|
|
1940
|
-
def storage_opts(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]):
|
|
1973
|
+
def storage_opts(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]]):
|
|
1941
1974
|
pulumi.set(self, "storage_opts", value)
|
|
1942
1975
|
|
|
1943
1976
|
@property
|
|
1944
1977
|
@pulumi.getter
|
|
1945
|
-
def sysctls(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]:
|
|
1978
|
+
def sysctls(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]]:
|
|
1946
1979
|
"""
|
|
1947
1980
|
A map of kernel parameters (sysctls) to set in the container.
|
|
1948
1981
|
"""
|
|
1949
1982
|
return pulumi.get(self, "sysctls")
|
|
1950
1983
|
|
|
1951
1984
|
@sysctls.setter
|
|
1952
|
-
def sysctls(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]):
|
|
1985
|
+
def sysctls(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]]):
|
|
1953
1986
|
pulumi.set(self, "sysctls", value)
|
|
1954
1987
|
|
|
1955
1988
|
@property
|
|
1956
1989
|
@pulumi.getter
|
|
1957
|
-
def tmpfs(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]:
|
|
1990
|
+
def tmpfs(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]]:
|
|
1958
1991
|
"""
|
|
1959
1992
|
A map of container directories which should be replaced by `tmpfs mounts`, and their corresponding mount options.
|
|
1960
1993
|
"""
|
|
1961
1994
|
return pulumi.get(self, "tmpfs")
|
|
1962
1995
|
|
|
1963
1996
|
@tmpfs.setter
|
|
1964
|
-
def tmpfs(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]):
|
|
1997
|
+
def tmpfs(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]]):
|
|
1965
1998
|
pulumi.set(self, "tmpfs", value)
|
|
1966
1999
|
|
|
1967
2000
|
@property
|
|
1968
2001
|
@pulumi.getter
|
|
1969
|
-
def tty(self) -> Optional[pulumi.Input[bool]]:
|
|
2002
|
+
def tty(self) -> Optional[pulumi.Input[builtins.bool]]:
|
|
1970
2003
|
"""
|
|
1971
2004
|
If `true`, allocate a pseudo-tty (`docker run -t`). Defaults to `false`.
|
|
1972
2005
|
"""
|
|
1973
2006
|
return pulumi.get(self, "tty")
|
|
1974
2007
|
|
|
1975
2008
|
@tty.setter
|
|
1976
|
-
def tty(self, value: Optional[pulumi.Input[bool]]):
|
|
2009
|
+
def tty(self, value: Optional[pulumi.Input[builtins.bool]]):
|
|
1977
2010
|
pulumi.set(self, "tty", value)
|
|
1978
2011
|
|
|
1979
2012
|
@property
|
|
@@ -2002,26 +2035,26 @@ class _ContainerState:
|
|
|
2002
2035
|
|
|
2003
2036
|
@property
|
|
2004
2037
|
@pulumi.getter
|
|
2005
|
-
def user(self) -> Optional[pulumi.Input[str]]:
|
|
2038
|
+
def user(self) -> Optional[pulumi.Input[builtins.str]]:
|
|
2006
2039
|
"""
|
|
2007
2040
|
User used for run the first process. Format is `user` or `user:group` which user and group can be passed literraly or by name.
|
|
2008
2041
|
"""
|
|
2009
2042
|
return pulumi.get(self, "user")
|
|
2010
2043
|
|
|
2011
2044
|
@user.setter
|
|
2012
|
-
def user(self, value: Optional[pulumi.Input[str]]):
|
|
2045
|
+
def user(self, value: Optional[pulumi.Input[builtins.str]]):
|
|
2013
2046
|
pulumi.set(self, "user", value)
|
|
2014
2047
|
|
|
2015
2048
|
@property
|
|
2016
2049
|
@pulumi.getter(name="usernsMode")
|
|
2017
|
-
def userns_mode(self) -> Optional[pulumi.Input[str]]:
|
|
2050
|
+
def userns_mode(self) -> Optional[pulumi.Input[builtins.str]]:
|
|
2018
2051
|
"""
|
|
2019
2052
|
Sets the usernamespace mode for the container when usernamespace remapping option is enabled.
|
|
2020
2053
|
"""
|
|
2021
2054
|
return pulumi.get(self, "userns_mode")
|
|
2022
2055
|
|
|
2023
2056
|
@userns_mode.setter
|
|
2024
|
-
def userns_mode(self, value: Optional[pulumi.Input[str]]):
|
|
2057
|
+
def userns_mode(self, value: Optional[pulumi.Input[builtins.str]]):
|
|
2025
2058
|
pulumi.set(self, "userns_mode", value)
|
|
2026
2059
|
|
|
2027
2060
|
@property
|
|
@@ -2038,108 +2071,110 @@ class _ContainerState:
|
|
|
2038
2071
|
|
|
2039
2072
|
@property
|
|
2040
2073
|
@pulumi.getter
|
|
2041
|
-
def wait(self) -> Optional[pulumi.Input[bool]]:
|
|
2074
|
+
def wait(self) -> Optional[pulumi.Input[builtins.bool]]:
|
|
2042
2075
|
"""
|
|
2043
|
-
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`.
|
|
2076
|
+
If `true`, then the Docker container is waited for being healthy state after creation. This requires your container to have a healthcheck, otherwise this provider will error. If `false`, then the container health state is not checked. Defaults to `false`.
|
|
2044
2077
|
"""
|
|
2045
2078
|
return pulumi.get(self, "wait")
|
|
2046
2079
|
|
|
2047
2080
|
@wait.setter
|
|
2048
|
-
def wait(self, value: Optional[pulumi.Input[bool]]):
|
|
2081
|
+
def wait(self, value: Optional[pulumi.Input[builtins.bool]]):
|
|
2049
2082
|
pulumi.set(self, "wait", value)
|
|
2050
2083
|
|
|
2051
2084
|
@property
|
|
2052
2085
|
@pulumi.getter(name="waitTimeout")
|
|
2053
|
-
def wait_timeout(self) -> Optional[pulumi.Input[int]]:
|
|
2086
|
+
def wait_timeout(self) -> Optional[pulumi.Input[builtins.int]]:
|
|
2054
2087
|
"""
|
|
2055
2088
|
The timeout in seconds to wait the container to be healthy after creation. Defaults to `60`.
|
|
2056
2089
|
"""
|
|
2057
2090
|
return pulumi.get(self, "wait_timeout")
|
|
2058
2091
|
|
|
2059
2092
|
@wait_timeout.setter
|
|
2060
|
-
def wait_timeout(self, value: Optional[pulumi.Input[int]]):
|
|
2093
|
+
def wait_timeout(self, value: Optional[pulumi.Input[builtins.int]]):
|
|
2061
2094
|
pulumi.set(self, "wait_timeout", value)
|
|
2062
2095
|
|
|
2063
2096
|
@property
|
|
2064
2097
|
@pulumi.getter(name="workingDir")
|
|
2065
|
-
def working_dir(self) -> Optional[pulumi.Input[str]]:
|
|
2098
|
+
def working_dir(self) -> Optional[pulumi.Input[builtins.str]]:
|
|
2066
2099
|
"""
|
|
2067
2100
|
The working directory for commands to run in.
|
|
2068
2101
|
"""
|
|
2069
2102
|
return pulumi.get(self, "working_dir")
|
|
2070
2103
|
|
|
2071
2104
|
@working_dir.setter
|
|
2072
|
-
def working_dir(self, value: Optional[pulumi.Input[str]]):
|
|
2105
|
+
def working_dir(self, value: Optional[pulumi.Input[builtins.str]]):
|
|
2073
2106
|
pulumi.set(self, "working_dir", value)
|
|
2074
2107
|
|
|
2075
2108
|
|
|
2109
|
+
@pulumi.type_token("docker:index/container:Container")
|
|
2076
2110
|
class Container(pulumi.CustomResource):
|
|
2077
2111
|
@overload
|
|
2078
2112
|
def __init__(__self__,
|
|
2079
2113
|
resource_name: str,
|
|
2080
2114
|
opts: Optional[pulumi.ResourceOptions] = None,
|
|
2081
|
-
attach: Optional[pulumi.Input[bool]] = None,
|
|
2115
|
+
attach: Optional[pulumi.Input[builtins.bool]] = None,
|
|
2082
2116
|
capabilities: Optional[pulumi.Input[Union['ContainerCapabilitiesArgs', 'ContainerCapabilitiesArgsDict']]] = None,
|
|
2083
|
-
cgroupns_mode: Optional[pulumi.Input[str]] = None,
|
|
2084
|
-
command: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
|
|
2085
|
-
container_read_refresh_timeout_milliseconds: Optional[pulumi.Input[int]] = None,
|
|
2086
|
-
cpu_set: Optional[pulumi.Input[str]] = None,
|
|
2087
|
-
cpu_shares: Optional[pulumi.Input[int]] = None,
|
|
2088
|
-
|
|
2117
|
+
cgroupns_mode: Optional[pulumi.Input[builtins.str]] = None,
|
|
2118
|
+
command: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None,
|
|
2119
|
+
container_read_refresh_timeout_milliseconds: Optional[pulumi.Input[builtins.int]] = None,
|
|
2120
|
+
cpu_set: Optional[pulumi.Input[builtins.str]] = None,
|
|
2121
|
+
cpu_shares: Optional[pulumi.Input[builtins.int]] = None,
|
|
2122
|
+
cpus: Optional[pulumi.Input[builtins.str]] = None,
|
|
2123
|
+
destroy_grace_seconds: Optional[pulumi.Input[builtins.int]] = None,
|
|
2089
2124
|
devices: Optional[pulumi.Input[Sequence[pulumi.Input[Union['ContainerDeviceArgs', 'ContainerDeviceArgsDict']]]]] = None,
|
|
2090
|
-
dns: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
|
|
2091
|
-
dns_opts: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
|
|
2092
|
-
dns_searches: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
|
|
2093
|
-
domainname: Optional[pulumi.Input[str]] = None,
|
|
2094
|
-
entrypoints: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
|
|
2095
|
-
envs: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
|
|
2096
|
-
gpus: Optional[pulumi.Input[str]] = None,
|
|
2097
|
-
group_adds: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
|
|
2125
|
+
dns: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None,
|
|
2126
|
+
dns_opts: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None,
|
|
2127
|
+
dns_searches: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None,
|
|
2128
|
+
domainname: Optional[pulumi.Input[builtins.str]] = None,
|
|
2129
|
+
entrypoints: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None,
|
|
2130
|
+
envs: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None,
|
|
2131
|
+
gpus: Optional[pulumi.Input[builtins.str]] = None,
|
|
2132
|
+
group_adds: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None,
|
|
2098
2133
|
healthcheck: Optional[pulumi.Input[Union['ContainerHealthcheckArgs', 'ContainerHealthcheckArgsDict']]] = None,
|
|
2099
|
-
hostname: Optional[pulumi.Input[str]] = None,
|
|
2134
|
+
hostname: Optional[pulumi.Input[builtins.str]] = None,
|
|
2100
2135
|
hosts: Optional[pulumi.Input[Sequence[pulumi.Input[Union['ContainerHostArgs', 'ContainerHostArgsDict']]]]] = None,
|
|
2101
|
-
image: Optional[pulumi.Input[str]] = None,
|
|
2102
|
-
init: Optional[pulumi.Input[bool]] = None,
|
|
2103
|
-
ipc_mode: Optional[pulumi.Input[str]] = None,
|
|
2136
|
+
image: Optional[pulumi.Input[builtins.str]] = None,
|
|
2137
|
+
init: Optional[pulumi.Input[builtins.bool]] = None,
|
|
2138
|
+
ipc_mode: Optional[pulumi.Input[builtins.str]] = None,
|
|
2104
2139
|
labels: Optional[pulumi.Input[Sequence[pulumi.Input[Union['ContainerLabelArgs', 'ContainerLabelArgsDict']]]]] = None,
|
|
2105
|
-
log_driver: Optional[pulumi.Input[str]] = None,
|
|
2106
|
-
log_opts: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None,
|
|
2107
|
-
logs: Optional[pulumi.Input[bool]] = None,
|
|
2108
|
-
max_retry_count: Optional[pulumi.Input[int]] = None,
|
|
2109
|
-
memory: Optional[pulumi.Input[int]] = None,
|
|
2110
|
-
memory_swap: Optional[pulumi.Input[int]] = None,
|
|
2140
|
+
log_driver: Optional[pulumi.Input[builtins.str]] = None,
|
|
2141
|
+
log_opts: Optional[pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]] = None,
|
|
2142
|
+
logs: Optional[pulumi.Input[builtins.bool]] = None,
|
|
2143
|
+
max_retry_count: Optional[pulumi.Input[builtins.int]] = None,
|
|
2144
|
+
memory: Optional[pulumi.Input[builtins.int]] = None,
|
|
2145
|
+
memory_swap: Optional[pulumi.Input[builtins.int]] = None,
|
|
2111
2146
|
mounts: Optional[pulumi.Input[Sequence[pulumi.Input[Union['ContainerMountArgs', 'ContainerMountArgsDict']]]]] = None,
|
|
2112
|
-
must_run: Optional[pulumi.Input[bool]] = None,
|
|
2113
|
-
name: Optional[pulumi.Input[str]] = None,
|
|
2114
|
-
network_mode: Optional[pulumi.Input[str]] = None,
|
|
2147
|
+
must_run: Optional[pulumi.Input[builtins.bool]] = None,
|
|
2148
|
+
name: Optional[pulumi.Input[builtins.str]] = None,
|
|
2149
|
+
network_mode: Optional[pulumi.Input[builtins.str]] = None,
|
|
2115
2150
|
networks_advanced: Optional[pulumi.Input[Sequence[pulumi.Input[Union['ContainerNetworksAdvancedArgs', 'ContainerNetworksAdvancedArgsDict']]]]] = None,
|
|
2116
|
-
pid_mode: Optional[pulumi.Input[str]] = None,
|
|
2151
|
+
pid_mode: Optional[pulumi.Input[builtins.str]] = None,
|
|
2117
2152
|
ports: Optional[pulumi.Input[Sequence[pulumi.Input[Union['ContainerPortArgs', 'ContainerPortArgsDict']]]]] = None,
|
|
2118
|
-
privileged: Optional[pulumi.Input[bool]] = None,
|
|
2119
|
-
publish_all_ports: Optional[pulumi.Input[bool]] = None,
|
|
2120
|
-
read_only: Optional[pulumi.Input[bool]] = None,
|
|
2121
|
-
remove_volumes: Optional[pulumi.Input[bool]] = None,
|
|
2122
|
-
restart: Optional[pulumi.Input[str]] = None,
|
|
2123
|
-
rm: Optional[pulumi.Input[bool]] = None,
|
|
2124
|
-
runtime: Optional[pulumi.Input[str]] = None,
|
|
2125
|
-
security_opts: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
|
|
2126
|
-
shm_size: Optional[pulumi.Input[int]] = None,
|
|
2127
|
-
start: Optional[pulumi.Input[bool]] = None,
|
|
2128
|
-
stdin_open: Optional[pulumi.Input[bool]] = None,
|
|
2129
|
-
stop_signal: Optional[pulumi.Input[str]] = None,
|
|
2130
|
-
stop_timeout: Optional[pulumi.Input[int]] = None,
|
|
2131
|
-
storage_opts: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None,
|
|
2132
|
-
sysctls: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None,
|
|
2133
|
-
tmpfs: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None,
|
|
2134
|
-
tty: Optional[pulumi.Input[bool]] = None,
|
|
2153
|
+
privileged: Optional[pulumi.Input[builtins.bool]] = None,
|
|
2154
|
+
publish_all_ports: Optional[pulumi.Input[builtins.bool]] = None,
|
|
2155
|
+
read_only: Optional[pulumi.Input[builtins.bool]] = None,
|
|
2156
|
+
remove_volumes: Optional[pulumi.Input[builtins.bool]] = None,
|
|
2157
|
+
restart: Optional[pulumi.Input[builtins.str]] = None,
|
|
2158
|
+
rm: Optional[pulumi.Input[builtins.bool]] = None,
|
|
2159
|
+
runtime: Optional[pulumi.Input[builtins.str]] = None,
|
|
2160
|
+
security_opts: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None,
|
|
2161
|
+
shm_size: Optional[pulumi.Input[builtins.int]] = None,
|
|
2162
|
+
start: Optional[pulumi.Input[builtins.bool]] = None,
|
|
2163
|
+
stdin_open: Optional[pulumi.Input[builtins.bool]] = None,
|
|
2164
|
+
stop_signal: Optional[pulumi.Input[builtins.str]] = None,
|
|
2165
|
+
stop_timeout: Optional[pulumi.Input[builtins.int]] = None,
|
|
2166
|
+
storage_opts: Optional[pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]] = None,
|
|
2167
|
+
sysctls: Optional[pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]] = None,
|
|
2168
|
+
tmpfs: Optional[pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]] = None,
|
|
2169
|
+
tty: Optional[pulumi.Input[builtins.bool]] = None,
|
|
2135
2170
|
ulimits: Optional[pulumi.Input[Sequence[pulumi.Input[Union['ContainerUlimitArgs', 'ContainerUlimitArgsDict']]]]] = None,
|
|
2136
2171
|
uploads: Optional[pulumi.Input[Sequence[pulumi.Input[Union['ContainerUploadArgs', 'ContainerUploadArgsDict']]]]] = None,
|
|
2137
|
-
user: Optional[pulumi.Input[str]] = None,
|
|
2138
|
-
userns_mode: Optional[pulumi.Input[str]] = None,
|
|
2172
|
+
user: Optional[pulumi.Input[builtins.str]] = None,
|
|
2173
|
+
userns_mode: Optional[pulumi.Input[builtins.str]] = None,
|
|
2139
2174
|
volumes: Optional[pulumi.Input[Sequence[pulumi.Input[Union['ContainerVolumeArgs', 'ContainerVolumeArgsDict']]]]] = None,
|
|
2140
|
-
wait: Optional[pulumi.Input[bool]] = None,
|
|
2141
|
-
wait_timeout: Optional[pulumi.Input[int]] = None,
|
|
2142
|
-
working_dir: Optional[pulumi.Input[str]] = None,
|
|
2175
|
+
wait: Optional[pulumi.Input[builtins.bool]] = None,
|
|
2176
|
+
wait_timeout: Optional[pulumi.Input[builtins.int]] = None,
|
|
2177
|
+
working_dir: Optional[pulumi.Input[builtins.str]] = None,
|
|
2143
2178
|
__props__=None):
|
|
2144
2179
|
"""
|
|
2145
2180
|
<!-- Bug: Type and Name are switched -->
|
|
@@ -2203,67 +2238,68 @@ class Container(pulumi.CustomResource):
|
|
|
2203
2238
|
|
|
2204
2239
|
:param str resource_name: The name of the resource.
|
|
2205
2240
|
:param pulumi.ResourceOptions opts: Options for the resource.
|
|
2206
|
-
:param pulumi.Input[bool] attach: If `true` attach to the container after its creation and waits the end of its execution. Defaults to `false`.
|
|
2241
|
+
:param pulumi.Input[builtins.bool] attach: If `true` attach to the container after its creation and waits the end of its execution. Defaults to `false`.
|
|
2207
2242
|
:param pulumi.Input[Union['ContainerCapabilitiesArgs', 'ContainerCapabilitiesArgsDict']] capabilities: Add or drop certrain linux capabilities.
|
|
2208
|
-
:param pulumi.Input[str] cgroupns_mode: Cgroup namespace mode to use for the container. Possible values are: `private`, `host`.
|
|
2209
|
-
:param pulumi.Input[Sequence[pulumi.Input[str]]] command: 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.
|
|
2210
|
-
:param pulumi.Input[int] container_read_refresh_timeout_milliseconds: The total number of milliseconds to wait for the container to reach status 'running'
|
|
2211
|
-
:param pulumi.Input[str] cpu_set: A comma-separated list or hyphen-separated range of CPUs a container can use, e.g. `0-1`.
|
|
2212
|
-
:param pulumi.Input[int] cpu_shares: CPU shares (relative weight) for the container.
|
|
2213
|
-
:param pulumi.Input[
|
|
2243
|
+
:param pulumi.Input[builtins.str] cgroupns_mode: Cgroup namespace mode to use for the container. Possible values are: `private`, `host`.
|
|
2244
|
+
:param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] command: 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.conf"]`.
|
|
2245
|
+
:param pulumi.Input[builtins.int] container_read_refresh_timeout_milliseconds: The total number of milliseconds to wait for the container to reach status 'running'
|
|
2246
|
+
:param pulumi.Input[builtins.str] cpu_set: A comma-separated list or hyphen-separated range of CPUs a container can use, e.g. `0-1`.
|
|
2247
|
+
:param pulumi.Input[builtins.int] cpu_shares: CPU shares (relative weight) for the container.
|
|
2248
|
+
:param pulumi.Input[builtins.str] cpus: Specify how much of the available CPU resources a container can use. e.g a value of 1.5 means the container is guaranteed at most one and a half of the CPUs
|
|
2249
|
+
:param pulumi.Input[builtins.int] destroy_grace_seconds: If defined will attempt to stop the container before destroying. Container will be destroyed after `n` seconds or on successful stop.
|
|
2214
2250
|
:param pulumi.Input[Sequence[pulumi.Input[Union['ContainerDeviceArgs', 'ContainerDeviceArgsDict']]]] devices: Bind devices to the container.
|
|
2215
|
-
:param pulumi.Input[Sequence[pulumi.Input[str]]] dns: DNS servers to use.
|
|
2216
|
-
:param pulumi.Input[Sequence[pulumi.Input[str]]] dns_opts: DNS options used by the DNS provider(s), see `resolv.conf` documentation for valid list of options.
|
|
2217
|
-
:param pulumi.Input[Sequence[pulumi.Input[str]]] dns_searches: DNS search domains that are used when bare unqualified hostnames are used inside of the container.
|
|
2218
|
-
:param pulumi.Input[str] domainname: Domain name of the container.
|
|
2219
|
-
:param pulumi.Input[Sequence[pulumi.Input[str]]] entrypoints: 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/
|
|
2220
|
-
:param pulumi.Input[Sequence[pulumi.Input[str]]] envs: Environment variables to set in the form of `KEY=VALUE`, e.g. `DEBUG=0`
|
|
2221
|
-
:param pulumi.Input[str] gpus: GPU devices to add to the container. Currently, only the value `all` is supported. Passing any other value will result in unexpected behavior.
|
|
2222
|
-
:param pulumi.Input[Sequence[pulumi.Input[str]]] group_adds: Additional groups for the container user
|
|
2251
|
+
:param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] dns: DNS servers to use.
|
|
2252
|
+
:param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] dns_opts: DNS options used by the DNS provider(s), see `resolv.conf` documentation for valid list of options.
|
|
2253
|
+
:param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] dns_searches: DNS search domains that are used when bare unqualified hostnames are used inside of the container.
|
|
2254
|
+
:param pulumi.Input[builtins.str] domainname: Domain name of the container.
|
|
2255
|
+
:param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] entrypoints: 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/myprogram"]`.
|
|
2256
|
+
:param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] envs: Environment variables to set in the form of `KEY=VALUE`, e.g. `DEBUG=0`
|
|
2257
|
+
:param pulumi.Input[builtins.str] gpus: GPU devices to add to the container. Currently, only the value `all` is supported. Passing any other value will result in unexpected behavior.
|
|
2258
|
+
:param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] group_adds: Additional groups for the container user
|
|
2223
2259
|
:param pulumi.Input[Union['ContainerHealthcheckArgs', 'ContainerHealthcheckArgsDict']] healthcheck: A test to perform to check that the container is healthy
|
|
2224
|
-
:param pulumi.Input[str] hostname: Hostname of the container.
|
|
2260
|
+
:param pulumi.Input[builtins.str] hostname: Hostname of the container.
|
|
2225
2261
|
:param pulumi.Input[Sequence[pulumi.Input[Union['ContainerHostArgs', 'ContainerHostArgsDict']]]] hosts: Additional hosts to add to the container.
|
|
2226
|
-
:param pulumi.Input[str] image: The ID of the image to back this container. The easiest way to get this value is to use the `RemoteImage` resource as is shown in the example.
|
|
2227
|
-
:param pulumi.Input[bool] init: Configured whether an init process should be injected for this container. If unset this will default to the `dockerd` defaults.
|
|
2228
|
-
:param pulumi.Input[str] ipc_mode: IPC sharing mode for the container. Possible values are: `none`, `private`, `shareable`, `container:<name|id>` or `host`.
|
|
2262
|
+
:param pulumi.Input[builtins.str] image: The ID of the image to back this container. The easiest way to get this value is to use the `image_id` attribute of the `RemoteImage` resource as is shown in the example.
|
|
2263
|
+
:param pulumi.Input[builtins.bool] init: Configured whether an init process should be injected for this container. If unset this will default to the `dockerd` defaults.
|
|
2264
|
+
:param pulumi.Input[builtins.str] ipc_mode: IPC sharing mode for the container. Possible values are: `none`, `private`, `shareable`, `container:<name|id>` or `host`.
|
|
2229
2265
|
:param pulumi.Input[Sequence[pulumi.Input[Union['ContainerLabelArgs', 'ContainerLabelArgsDict']]]] labels: User-defined key/value metadata
|
|
2230
|
-
:param pulumi.Input[str] log_driver: The logging driver to use for the container.
|
|
2231
|
-
:param pulumi.Input[Mapping[str, pulumi.Input[str]]] log_opts: Key/value pairs to use as options for the logging driver.
|
|
2232
|
-
:param pulumi.Input[bool] logs: Save the container logs (`attach` must be enabled). Defaults to `false`.
|
|
2233
|
-
:param pulumi.Input[int] max_retry_count: The maximum amount of times to an attempt a restart when `restart` is set to 'on-failure'.
|
|
2234
|
-
:param pulumi.Input[int] memory: The memory limit for the container in MBs.
|
|
2235
|
-
:param pulumi.Input[int] memory_swap: 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.
|
|
2266
|
+
:param pulumi.Input[builtins.str] log_driver: The logging driver to use for the container.
|
|
2267
|
+
:param pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]] log_opts: Key/value pairs to use as options for the logging driver.
|
|
2268
|
+
:param pulumi.Input[builtins.bool] logs: Save the container logs (`attach` must be enabled). Defaults to `false`.
|
|
2269
|
+
:param pulumi.Input[builtins.int] max_retry_count: The maximum amount of times to an attempt a restart when `restart` is set to 'on-failure'.
|
|
2270
|
+
:param pulumi.Input[builtins.int] memory: The memory limit for the container in MBs.
|
|
2271
|
+
:param pulumi.Input[builtins.int] memory_swap: 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.
|
|
2236
2272
|
:param pulumi.Input[Sequence[pulumi.Input[Union['ContainerMountArgs', 'ContainerMountArgsDict']]]] mounts: Specification for mounts to be added to containers created as part of the service.
|
|
2237
|
-
:param pulumi.Input[str] name: The name of the container.
|
|
2238
|
-
:param pulumi.Input[str] network_mode: Network mode of the container.
|
|
2273
|
+
:param pulumi.Input[builtins.str] name: The name of the container.
|
|
2274
|
+
:param pulumi.Input[builtins.str] network_mode: Network mode of the container. See https://docs.docker.com/engine/network/ for more information.
|
|
2239
2275
|
:param pulumi.Input[Sequence[pulumi.Input[Union['ContainerNetworksAdvancedArgs', 'ContainerNetworksAdvancedArgsDict']]]] networks_advanced: The networks the container is attached to
|
|
2240
|
-
:param pulumi.Input[str] pid_mode: he PID (Process) Namespace mode for the container. Either `container:<name|id>` or `host`.
|
|
2276
|
+
:param pulumi.Input[builtins.str] pid_mode: he PID (Process) Namespace mode for the container. Either `container:<name|id>` or `host`.
|
|
2241
2277
|
:param pulumi.Input[Sequence[pulumi.Input[Union['ContainerPortArgs', 'ContainerPortArgsDict']]]] ports: Publish a container's port(s) to the host.
|
|
2242
|
-
:param pulumi.Input[bool] privileged: If `true`, the container runs in privileged mode.
|
|
2243
|
-
:param pulumi.Input[bool] publish_all_ports: Publish all ports of the container.
|
|
2244
|
-
:param pulumi.Input[bool] read_only: If `true`, the container will be started as readonly. Defaults to `false`.
|
|
2245
|
-
:param pulumi.Input[bool] remove_volumes: If `true`, it will remove anonymous volumes associated with the container. Defaults to `true`.
|
|
2246
|
-
:param pulumi.Input[str] restart: The restart policy for the container. Must be one of 'no', 'on-failure', 'always', 'unless-stopped'. Defaults to `no`.
|
|
2247
|
-
:param pulumi.Input[bool] rm: If `true`, then the container will be automatically removed when it exits. Defaults to `false`.
|
|
2248
|
-
:param pulumi.Input[str] runtime: Runtime to use for the container.
|
|
2249
|
-
:param pulumi.Input[Sequence[pulumi.Input[str]]] security_opts: List of string values to customize labels for MLS systems, such as SELinux. See https://docs.docker.com/engine/reference/run/#security-configuration.
|
|
2250
|
-
:param pulumi.Input[int] shm_size: Size of `/dev/shm` in MBs.
|
|
2251
|
-
:param pulumi.Input[bool] start: If `true`, then the Docker container will be started after creation. If `false`, then the container is only created. Defaults to `true`.
|
|
2252
|
-
:param pulumi.Input[bool] stdin_open: If `true`, keep STDIN open even if not attached (`docker run -i`). Defaults to `false`.
|
|
2253
|
-
:param pulumi.Input[str] stop_signal: Signal to stop a container (default `SIGTERM`).
|
|
2254
|
-
:param pulumi.Input[int] stop_timeout: Timeout (in seconds) to stop a container.
|
|
2255
|
-
:param pulumi.Input[Mapping[str, pulumi.Input[str]]] storage_opts: Key/value pairs for the storage driver options, e.g. `size`: `120G`
|
|
2256
|
-
:param pulumi.Input[Mapping[str, pulumi.Input[str]]] sysctls: A map of kernel parameters (sysctls) to set in the container.
|
|
2257
|
-
:param pulumi.Input[Mapping[str, pulumi.Input[str]]] tmpfs: A map of container directories which should be replaced by `tmpfs mounts`, and their corresponding mount options.
|
|
2258
|
-
:param pulumi.Input[bool] tty: If `true`, allocate a pseudo-tty (`docker run -t`). Defaults to `false`.
|
|
2278
|
+
:param pulumi.Input[builtins.bool] privileged: If `true`, the container runs in privileged mode.
|
|
2279
|
+
:param pulumi.Input[builtins.bool] publish_all_ports: Publish all ports of the container.
|
|
2280
|
+
:param pulumi.Input[builtins.bool] read_only: If `true`, the container will be started as readonly. Defaults to `false`.
|
|
2281
|
+
:param pulumi.Input[builtins.bool] remove_volumes: If `true`, it will remove anonymous volumes associated with the container. Defaults to `true`.
|
|
2282
|
+
:param pulumi.Input[builtins.str] restart: The restart policy for the container. Must be one of 'no', 'on-failure', 'always', 'unless-stopped'. Defaults to `no`.
|
|
2283
|
+
:param pulumi.Input[builtins.bool] rm: If `true`, then the container will be automatically removed when it exits. Defaults to `false`.
|
|
2284
|
+
:param pulumi.Input[builtins.str] runtime: Runtime to use for the container.
|
|
2285
|
+
:param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] security_opts: List of string values to customize labels for MLS systems, such as SELinux. See https://docs.docker.com/engine/reference/run/#security-configuration.
|
|
2286
|
+
:param pulumi.Input[builtins.int] shm_size: Size of `/dev/shm` in MBs.
|
|
2287
|
+
:param pulumi.Input[builtins.bool] start: If `true`, then the Docker container will be started after creation. If `false`, then the container is only created. Defaults to `true`.
|
|
2288
|
+
:param pulumi.Input[builtins.bool] stdin_open: If `true`, keep STDIN open even if not attached (`docker run -i`). Defaults to `false`.
|
|
2289
|
+
:param pulumi.Input[builtins.str] stop_signal: Signal to stop a container (default `SIGTERM`).
|
|
2290
|
+
:param pulumi.Input[builtins.int] stop_timeout: Timeout (in seconds) to stop a container.
|
|
2291
|
+
:param pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]] storage_opts: Key/value pairs for the storage driver options, e.g. `size`: `120G`
|
|
2292
|
+
:param pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]] sysctls: A map of kernel parameters (sysctls) to set in the container.
|
|
2293
|
+
:param pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]] tmpfs: A map of container directories which should be replaced by `tmpfs mounts`, and their corresponding mount options.
|
|
2294
|
+
:param pulumi.Input[builtins.bool] tty: If `true`, allocate a pseudo-tty (`docker run -t`). Defaults to `false`.
|
|
2259
2295
|
:param pulumi.Input[Sequence[pulumi.Input[Union['ContainerUlimitArgs', 'ContainerUlimitArgsDict']]]] ulimits: Ulimit options to add.
|
|
2260
2296
|
:param pulumi.Input[Sequence[pulumi.Input[Union['ContainerUploadArgs', 'ContainerUploadArgsDict']]]] uploads: 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.
|
|
2261
|
-
:param pulumi.Input[str] user: User used for run the first process. Format is `user` or `user:group` which user and group can be passed literraly or by name.
|
|
2262
|
-
:param pulumi.Input[str] userns_mode: Sets the usernamespace mode for the container when usernamespace remapping option is enabled.
|
|
2297
|
+
:param pulumi.Input[builtins.str] user: User used for run the first process. Format is `user` or `user:group` which user and group can be passed literraly or by name.
|
|
2298
|
+
:param pulumi.Input[builtins.str] userns_mode: Sets the usernamespace mode for the container when usernamespace remapping option is enabled.
|
|
2263
2299
|
:param pulumi.Input[Sequence[pulumi.Input[Union['ContainerVolumeArgs', 'ContainerVolumeArgsDict']]]] volumes: Spec for mounting volumes in the container.
|
|
2264
|
-
:param pulumi.Input[bool] wait: 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`.
|
|
2265
|
-
:param pulumi.Input[int] wait_timeout: The timeout in seconds to wait the container to be healthy after creation. Defaults to `60`.
|
|
2266
|
-
:param pulumi.Input[str] working_dir: The working directory for commands to run in.
|
|
2300
|
+
:param pulumi.Input[builtins.bool] wait: If `true`, then the Docker container is waited for being healthy state after creation. This requires your container to have a healthcheck, otherwise this provider will error. If `false`, then the container health state is not checked. Defaults to `false`.
|
|
2301
|
+
:param pulumi.Input[builtins.int] wait_timeout: The timeout in seconds to wait the container to be healthy after creation. Defaults to `60`.
|
|
2302
|
+
:param pulumi.Input[builtins.str] working_dir: The working directory for commands to run in.
|
|
2267
2303
|
"""
|
|
2268
2304
|
...
|
|
2269
2305
|
@overload
|
|
@@ -2346,68 +2382,69 @@ class Container(pulumi.CustomResource):
|
|
|
2346
2382
|
def _internal_init(__self__,
|
|
2347
2383
|
resource_name: str,
|
|
2348
2384
|
opts: Optional[pulumi.ResourceOptions] = None,
|
|
2349
|
-
attach: Optional[pulumi.Input[bool]] = None,
|
|
2385
|
+
attach: Optional[pulumi.Input[builtins.bool]] = None,
|
|
2350
2386
|
capabilities: Optional[pulumi.Input[Union['ContainerCapabilitiesArgs', 'ContainerCapabilitiesArgsDict']]] = None,
|
|
2351
|
-
cgroupns_mode: Optional[pulumi.Input[str]] = None,
|
|
2352
|
-
command: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
|
|
2353
|
-
container_read_refresh_timeout_milliseconds: Optional[pulumi.Input[int]] = None,
|
|
2354
|
-
cpu_set: Optional[pulumi.Input[str]] = None,
|
|
2355
|
-
cpu_shares: Optional[pulumi.Input[int]] = None,
|
|
2356
|
-
|
|
2387
|
+
cgroupns_mode: Optional[pulumi.Input[builtins.str]] = None,
|
|
2388
|
+
command: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None,
|
|
2389
|
+
container_read_refresh_timeout_milliseconds: Optional[pulumi.Input[builtins.int]] = None,
|
|
2390
|
+
cpu_set: Optional[pulumi.Input[builtins.str]] = None,
|
|
2391
|
+
cpu_shares: Optional[pulumi.Input[builtins.int]] = None,
|
|
2392
|
+
cpus: Optional[pulumi.Input[builtins.str]] = None,
|
|
2393
|
+
destroy_grace_seconds: Optional[pulumi.Input[builtins.int]] = None,
|
|
2357
2394
|
devices: Optional[pulumi.Input[Sequence[pulumi.Input[Union['ContainerDeviceArgs', 'ContainerDeviceArgsDict']]]]] = None,
|
|
2358
|
-
dns: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
|
|
2359
|
-
dns_opts: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
|
|
2360
|
-
dns_searches: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
|
|
2361
|
-
domainname: Optional[pulumi.Input[str]] = None,
|
|
2362
|
-
entrypoints: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
|
|
2363
|
-
envs: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
|
|
2364
|
-
gpus: Optional[pulumi.Input[str]] = None,
|
|
2365
|
-
group_adds: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
|
|
2395
|
+
dns: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None,
|
|
2396
|
+
dns_opts: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None,
|
|
2397
|
+
dns_searches: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None,
|
|
2398
|
+
domainname: Optional[pulumi.Input[builtins.str]] = None,
|
|
2399
|
+
entrypoints: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None,
|
|
2400
|
+
envs: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None,
|
|
2401
|
+
gpus: Optional[pulumi.Input[builtins.str]] = None,
|
|
2402
|
+
group_adds: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None,
|
|
2366
2403
|
healthcheck: Optional[pulumi.Input[Union['ContainerHealthcheckArgs', 'ContainerHealthcheckArgsDict']]] = None,
|
|
2367
|
-
hostname: Optional[pulumi.Input[str]] = None,
|
|
2404
|
+
hostname: Optional[pulumi.Input[builtins.str]] = None,
|
|
2368
2405
|
hosts: Optional[pulumi.Input[Sequence[pulumi.Input[Union['ContainerHostArgs', 'ContainerHostArgsDict']]]]] = None,
|
|
2369
|
-
image: Optional[pulumi.Input[str]] = None,
|
|
2370
|
-
init: Optional[pulumi.Input[bool]] = None,
|
|
2371
|
-
ipc_mode: Optional[pulumi.Input[str]] = None,
|
|
2406
|
+
image: Optional[pulumi.Input[builtins.str]] = None,
|
|
2407
|
+
init: Optional[pulumi.Input[builtins.bool]] = None,
|
|
2408
|
+
ipc_mode: Optional[pulumi.Input[builtins.str]] = None,
|
|
2372
2409
|
labels: Optional[pulumi.Input[Sequence[pulumi.Input[Union['ContainerLabelArgs', 'ContainerLabelArgsDict']]]]] = None,
|
|
2373
|
-
log_driver: Optional[pulumi.Input[str]] = None,
|
|
2374
|
-
log_opts: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None,
|
|
2375
|
-
logs: Optional[pulumi.Input[bool]] = None,
|
|
2376
|
-
max_retry_count: Optional[pulumi.Input[int]] = None,
|
|
2377
|
-
memory: Optional[pulumi.Input[int]] = None,
|
|
2378
|
-
memory_swap: Optional[pulumi.Input[int]] = None,
|
|
2410
|
+
log_driver: Optional[pulumi.Input[builtins.str]] = None,
|
|
2411
|
+
log_opts: Optional[pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]] = None,
|
|
2412
|
+
logs: Optional[pulumi.Input[builtins.bool]] = None,
|
|
2413
|
+
max_retry_count: Optional[pulumi.Input[builtins.int]] = None,
|
|
2414
|
+
memory: Optional[pulumi.Input[builtins.int]] = None,
|
|
2415
|
+
memory_swap: Optional[pulumi.Input[builtins.int]] = None,
|
|
2379
2416
|
mounts: Optional[pulumi.Input[Sequence[pulumi.Input[Union['ContainerMountArgs', 'ContainerMountArgsDict']]]]] = None,
|
|
2380
|
-
must_run: Optional[pulumi.Input[bool]] = None,
|
|
2381
|
-
name: Optional[pulumi.Input[str]] = None,
|
|
2382
|
-
network_mode: Optional[pulumi.Input[str]] = None,
|
|
2417
|
+
must_run: Optional[pulumi.Input[builtins.bool]] = None,
|
|
2418
|
+
name: Optional[pulumi.Input[builtins.str]] = None,
|
|
2419
|
+
network_mode: Optional[pulumi.Input[builtins.str]] = None,
|
|
2383
2420
|
networks_advanced: Optional[pulumi.Input[Sequence[pulumi.Input[Union['ContainerNetworksAdvancedArgs', 'ContainerNetworksAdvancedArgsDict']]]]] = None,
|
|
2384
|
-
pid_mode: Optional[pulumi.Input[str]] = None,
|
|
2421
|
+
pid_mode: Optional[pulumi.Input[builtins.str]] = None,
|
|
2385
2422
|
ports: Optional[pulumi.Input[Sequence[pulumi.Input[Union['ContainerPortArgs', 'ContainerPortArgsDict']]]]] = None,
|
|
2386
|
-
privileged: Optional[pulumi.Input[bool]] = None,
|
|
2387
|
-
publish_all_ports: Optional[pulumi.Input[bool]] = None,
|
|
2388
|
-
read_only: Optional[pulumi.Input[bool]] = None,
|
|
2389
|
-
remove_volumes: Optional[pulumi.Input[bool]] = None,
|
|
2390
|
-
restart: Optional[pulumi.Input[str]] = None,
|
|
2391
|
-
rm: Optional[pulumi.Input[bool]] = None,
|
|
2392
|
-
runtime: Optional[pulumi.Input[str]] = None,
|
|
2393
|
-
security_opts: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
|
|
2394
|
-
shm_size: Optional[pulumi.Input[int]] = None,
|
|
2395
|
-
start: Optional[pulumi.Input[bool]] = None,
|
|
2396
|
-
stdin_open: Optional[pulumi.Input[bool]] = None,
|
|
2397
|
-
stop_signal: Optional[pulumi.Input[str]] = None,
|
|
2398
|
-
stop_timeout: Optional[pulumi.Input[int]] = None,
|
|
2399
|
-
storage_opts: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None,
|
|
2400
|
-
sysctls: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None,
|
|
2401
|
-
tmpfs: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None,
|
|
2402
|
-
tty: Optional[pulumi.Input[bool]] = None,
|
|
2423
|
+
privileged: Optional[pulumi.Input[builtins.bool]] = None,
|
|
2424
|
+
publish_all_ports: Optional[pulumi.Input[builtins.bool]] = None,
|
|
2425
|
+
read_only: Optional[pulumi.Input[builtins.bool]] = None,
|
|
2426
|
+
remove_volumes: Optional[pulumi.Input[builtins.bool]] = None,
|
|
2427
|
+
restart: Optional[pulumi.Input[builtins.str]] = None,
|
|
2428
|
+
rm: Optional[pulumi.Input[builtins.bool]] = None,
|
|
2429
|
+
runtime: Optional[pulumi.Input[builtins.str]] = None,
|
|
2430
|
+
security_opts: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None,
|
|
2431
|
+
shm_size: Optional[pulumi.Input[builtins.int]] = None,
|
|
2432
|
+
start: Optional[pulumi.Input[builtins.bool]] = None,
|
|
2433
|
+
stdin_open: Optional[pulumi.Input[builtins.bool]] = None,
|
|
2434
|
+
stop_signal: Optional[pulumi.Input[builtins.str]] = None,
|
|
2435
|
+
stop_timeout: Optional[pulumi.Input[builtins.int]] = None,
|
|
2436
|
+
storage_opts: Optional[pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]] = None,
|
|
2437
|
+
sysctls: Optional[pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]] = None,
|
|
2438
|
+
tmpfs: Optional[pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]] = None,
|
|
2439
|
+
tty: Optional[pulumi.Input[builtins.bool]] = None,
|
|
2403
2440
|
ulimits: Optional[pulumi.Input[Sequence[pulumi.Input[Union['ContainerUlimitArgs', 'ContainerUlimitArgsDict']]]]] = None,
|
|
2404
2441
|
uploads: Optional[pulumi.Input[Sequence[pulumi.Input[Union['ContainerUploadArgs', 'ContainerUploadArgsDict']]]]] = None,
|
|
2405
|
-
user: Optional[pulumi.Input[str]] = None,
|
|
2406
|
-
userns_mode: Optional[pulumi.Input[str]] = None,
|
|
2442
|
+
user: Optional[pulumi.Input[builtins.str]] = None,
|
|
2443
|
+
userns_mode: Optional[pulumi.Input[builtins.str]] = None,
|
|
2407
2444
|
volumes: Optional[pulumi.Input[Sequence[pulumi.Input[Union['ContainerVolumeArgs', 'ContainerVolumeArgsDict']]]]] = None,
|
|
2408
|
-
wait: Optional[pulumi.Input[bool]] = None,
|
|
2409
|
-
wait_timeout: Optional[pulumi.Input[int]] = None,
|
|
2410
|
-
working_dir: Optional[pulumi.Input[str]] = None,
|
|
2445
|
+
wait: Optional[pulumi.Input[builtins.bool]] = None,
|
|
2446
|
+
wait_timeout: Optional[pulumi.Input[builtins.int]] = None,
|
|
2447
|
+
working_dir: Optional[pulumi.Input[builtins.str]] = None,
|
|
2411
2448
|
__props__=None):
|
|
2412
2449
|
opts = pulumi.ResourceOptions.merge(_utilities.get_resource_opts_defaults(), opts)
|
|
2413
2450
|
if not isinstance(opts, pulumi.ResourceOptions):
|
|
@@ -2424,6 +2461,7 @@ class Container(pulumi.CustomResource):
|
|
|
2424
2461
|
__props__.__dict__["container_read_refresh_timeout_milliseconds"] = container_read_refresh_timeout_milliseconds
|
|
2425
2462
|
__props__.__dict__["cpu_set"] = cpu_set
|
|
2426
2463
|
__props__.__dict__["cpu_shares"] = cpu_shares
|
|
2464
|
+
__props__.__dict__["cpus"] = cpus
|
|
2427
2465
|
__props__.__dict__["destroy_grace_seconds"] = destroy_grace_seconds
|
|
2428
2466
|
__props__.__dict__["devices"] = devices
|
|
2429
2467
|
__props__.__dict__["dns"] = dns
|
|
@@ -2495,72 +2533,73 @@ class Container(pulumi.CustomResource):
|
|
|
2495
2533
|
def get(resource_name: str,
|
|
2496
2534
|
id: pulumi.Input[str],
|
|
2497
2535
|
opts: Optional[pulumi.ResourceOptions] = None,
|
|
2498
|
-
attach: Optional[pulumi.Input[bool]] = None,
|
|
2499
|
-
bridge: Optional[pulumi.Input[str]] = None,
|
|
2536
|
+
attach: Optional[pulumi.Input[builtins.bool]] = None,
|
|
2537
|
+
bridge: Optional[pulumi.Input[builtins.str]] = None,
|
|
2500
2538
|
capabilities: Optional[pulumi.Input[Union['ContainerCapabilitiesArgs', 'ContainerCapabilitiesArgsDict']]] = None,
|
|
2501
|
-
cgroupns_mode: Optional[pulumi.Input[str]] = None,
|
|
2502
|
-
command: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
|
|
2503
|
-
container_logs: Optional[pulumi.Input[str]] = None,
|
|
2504
|
-
container_read_refresh_timeout_milliseconds: Optional[pulumi.Input[int]] = None,
|
|
2505
|
-
cpu_set: Optional[pulumi.Input[str]] = None,
|
|
2506
|
-
cpu_shares: Optional[pulumi.Input[int]] = None,
|
|
2507
|
-
|
|
2539
|
+
cgroupns_mode: Optional[pulumi.Input[builtins.str]] = None,
|
|
2540
|
+
command: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None,
|
|
2541
|
+
container_logs: Optional[pulumi.Input[builtins.str]] = None,
|
|
2542
|
+
container_read_refresh_timeout_milliseconds: Optional[pulumi.Input[builtins.int]] = None,
|
|
2543
|
+
cpu_set: Optional[pulumi.Input[builtins.str]] = None,
|
|
2544
|
+
cpu_shares: Optional[pulumi.Input[builtins.int]] = None,
|
|
2545
|
+
cpus: Optional[pulumi.Input[builtins.str]] = None,
|
|
2546
|
+
destroy_grace_seconds: Optional[pulumi.Input[builtins.int]] = None,
|
|
2508
2547
|
devices: Optional[pulumi.Input[Sequence[pulumi.Input[Union['ContainerDeviceArgs', 'ContainerDeviceArgsDict']]]]] = None,
|
|
2509
|
-
dns: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
|
|
2510
|
-
dns_opts: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
|
|
2511
|
-
dns_searches: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
|
|
2512
|
-
domainname: Optional[pulumi.Input[str]] = None,
|
|
2513
|
-
entrypoints: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
|
|
2514
|
-
envs: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
|
|
2515
|
-
exit_code: Optional[pulumi.Input[int]] = None,
|
|
2516
|
-
gpus: Optional[pulumi.Input[str]] = None,
|
|
2517
|
-
group_adds: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
|
|
2548
|
+
dns: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None,
|
|
2549
|
+
dns_opts: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None,
|
|
2550
|
+
dns_searches: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None,
|
|
2551
|
+
domainname: Optional[pulumi.Input[builtins.str]] = None,
|
|
2552
|
+
entrypoints: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None,
|
|
2553
|
+
envs: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None,
|
|
2554
|
+
exit_code: Optional[pulumi.Input[builtins.int]] = None,
|
|
2555
|
+
gpus: Optional[pulumi.Input[builtins.str]] = None,
|
|
2556
|
+
group_adds: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None,
|
|
2518
2557
|
healthcheck: Optional[pulumi.Input[Union['ContainerHealthcheckArgs', 'ContainerHealthcheckArgsDict']]] = None,
|
|
2519
|
-
hostname: Optional[pulumi.Input[str]] = None,
|
|
2558
|
+
hostname: Optional[pulumi.Input[builtins.str]] = None,
|
|
2520
2559
|
hosts: Optional[pulumi.Input[Sequence[pulumi.Input[Union['ContainerHostArgs', 'ContainerHostArgsDict']]]]] = None,
|
|
2521
|
-
image: Optional[pulumi.Input[str]] = None,
|
|
2522
|
-
init: Optional[pulumi.Input[bool]] = None,
|
|
2523
|
-
ipc_mode: Optional[pulumi.Input[str]] = None,
|
|
2560
|
+
image: Optional[pulumi.Input[builtins.str]] = None,
|
|
2561
|
+
init: Optional[pulumi.Input[builtins.bool]] = None,
|
|
2562
|
+
ipc_mode: Optional[pulumi.Input[builtins.str]] = None,
|
|
2524
2563
|
labels: Optional[pulumi.Input[Sequence[pulumi.Input[Union['ContainerLabelArgs', 'ContainerLabelArgsDict']]]]] = None,
|
|
2525
|
-
log_driver: Optional[pulumi.Input[str]] = None,
|
|
2526
|
-
log_opts: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None,
|
|
2527
|
-
logs: Optional[pulumi.Input[bool]] = None,
|
|
2528
|
-
max_retry_count: Optional[pulumi.Input[int]] = None,
|
|
2529
|
-
memory: Optional[pulumi.Input[int]] = None,
|
|
2530
|
-
memory_swap: Optional[pulumi.Input[int]] = None,
|
|
2564
|
+
log_driver: Optional[pulumi.Input[builtins.str]] = None,
|
|
2565
|
+
log_opts: Optional[pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]] = None,
|
|
2566
|
+
logs: Optional[pulumi.Input[builtins.bool]] = None,
|
|
2567
|
+
max_retry_count: Optional[pulumi.Input[builtins.int]] = None,
|
|
2568
|
+
memory: Optional[pulumi.Input[builtins.int]] = None,
|
|
2569
|
+
memory_swap: Optional[pulumi.Input[builtins.int]] = None,
|
|
2531
2570
|
mounts: Optional[pulumi.Input[Sequence[pulumi.Input[Union['ContainerMountArgs', 'ContainerMountArgsDict']]]]] = None,
|
|
2532
|
-
must_run: Optional[pulumi.Input[bool]] = None,
|
|
2533
|
-
name: Optional[pulumi.Input[str]] = None,
|
|
2571
|
+
must_run: Optional[pulumi.Input[builtins.bool]] = None,
|
|
2572
|
+
name: Optional[pulumi.Input[builtins.str]] = None,
|
|
2534
2573
|
network_datas: Optional[pulumi.Input[Sequence[pulumi.Input[Union['ContainerNetworkDataArgs', 'ContainerNetworkDataArgsDict']]]]] = None,
|
|
2535
|
-
network_mode: Optional[pulumi.Input[str]] = None,
|
|
2574
|
+
network_mode: Optional[pulumi.Input[builtins.str]] = None,
|
|
2536
2575
|
networks_advanced: Optional[pulumi.Input[Sequence[pulumi.Input[Union['ContainerNetworksAdvancedArgs', 'ContainerNetworksAdvancedArgsDict']]]]] = None,
|
|
2537
|
-
pid_mode: Optional[pulumi.Input[str]] = None,
|
|
2576
|
+
pid_mode: Optional[pulumi.Input[builtins.str]] = None,
|
|
2538
2577
|
ports: Optional[pulumi.Input[Sequence[pulumi.Input[Union['ContainerPortArgs', 'ContainerPortArgsDict']]]]] = None,
|
|
2539
|
-
privileged: Optional[pulumi.Input[bool]] = None,
|
|
2540
|
-
publish_all_ports: Optional[pulumi.Input[bool]] = None,
|
|
2541
|
-
read_only: Optional[pulumi.Input[bool]] = None,
|
|
2542
|
-
remove_volumes: Optional[pulumi.Input[bool]] = None,
|
|
2543
|
-
restart: Optional[pulumi.Input[str]] = None,
|
|
2544
|
-
rm: Optional[pulumi.Input[bool]] = None,
|
|
2545
|
-
runtime: Optional[pulumi.Input[str]] = None,
|
|
2546
|
-
security_opts: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
|
|
2547
|
-
shm_size: Optional[pulumi.Input[int]] = None,
|
|
2548
|
-
start: Optional[pulumi.Input[bool]] = None,
|
|
2549
|
-
stdin_open: Optional[pulumi.Input[bool]] = None,
|
|
2550
|
-
stop_signal: Optional[pulumi.Input[str]] = None,
|
|
2551
|
-
stop_timeout: Optional[pulumi.Input[int]] = None,
|
|
2552
|
-
storage_opts: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None,
|
|
2553
|
-
sysctls: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None,
|
|
2554
|
-
tmpfs: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None,
|
|
2555
|
-
tty: Optional[pulumi.Input[bool]] = None,
|
|
2578
|
+
privileged: Optional[pulumi.Input[builtins.bool]] = None,
|
|
2579
|
+
publish_all_ports: Optional[pulumi.Input[builtins.bool]] = None,
|
|
2580
|
+
read_only: Optional[pulumi.Input[builtins.bool]] = None,
|
|
2581
|
+
remove_volumes: Optional[pulumi.Input[builtins.bool]] = None,
|
|
2582
|
+
restart: Optional[pulumi.Input[builtins.str]] = None,
|
|
2583
|
+
rm: Optional[pulumi.Input[builtins.bool]] = None,
|
|
2584
|
+
runtime: Optional[pulumi.Input[builtins.str]] = None,
|
|
2585
|
+
security_opts: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None,
|
|
2586
|
+
shm_size: Optional[pulumi.Input[builtins.int]] = None,
|
|
2587
|
+
start: Optional[pulumi.Input[builtins.bool]] = None,
|
|
2588
|
+
stdin_open: Optional[pulumi.Input[builtins.bool]] = None,
|
|
2589
|
+
stop_signal: Optional[pulumi.Input[builtins.str]] = None,
|
|
2590
|
+
stop_timeout: Optional[pulumi.Input[builtins.int]] = None,
|
|
2591
|
+
storage_opts: Optional[pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]] = None,
|
|
2592
|
+
sysctls: Optional[pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]] = None,
|
|
2593
|
+
tmpfs: Optional[pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]] = None,
|
|
2594
|
+
tty: Optional[pulumi.Input[builtins.bool]] = None,
|
|
2556
2595
|
ulimits: Optional[pulumi.Input[Sequence[pulumi.Input[Union['ContainerUlimitArgs', 'ContainerUlimitArgsDict']]]]] = None,
|
|
2557
2596
|
uploads: Optional[pulumi.Input[Sequence[pulumi.Input[Union['ContainerUploadArgs', 'ContainerUploadArgsDict']]]]] = None,
|
|
2558
|
-
user: Optional[pulumi.Input[str]] = None,
|
|
2559
|
-
userns_mode: Optional[pulumi.Input[str]] = None,
|
|
2597
|
+
user: Optional[pulumi.Input[builtins.str]] = None,
|
|
2598
|
+
userns_mode: Optional[pulumi.Input[builtins.str]] = None,
|
|
2560
2599
|
volumes: Optional[pulumi.Input[Sequence[pulumi.Input[Union['ContainerVolumeArgs', 'ContainerVolumeArgsDict']]]]] = None,
|
|
2561
|
-
wait: Optional[pulumi.Input[bool]] = None,
|
|
2562
|
-
wait_timeout: Optional[pulumi.Input[int]] = None,
|
|
2563
|
-
working_dir: Optional[pulumi.Input[str]] = None) -> 'Container':
|
|
2600
|
+
wait: Optional[pulumi.Input[builtins.bool]] = None,
|
|
2601
|
+
wait_timeout: Optional[pulumi.Input[builtins.int]] = None,
|
|
2602
|
+
working_dir: Optional[pulumi.Input[builtins.str]] = None) -> 'Container':
|
|
2564
2603
|
"""
|
|
2565
2604
|
Get an existing Container resource's state with the given name, id, and optional extra
|
|
2566
2605
|
properties used to qualify the lookup.
|
|
@@ -2568,71 +2607,72 @@ class Container(pulumi.CustomResource):
|
|
|
2568
2607
|
:param str resource_name: The unique name of the resulting resource.
|
|
2569
2608
|
:param pulumi.Input[str] id: The unique provider ID of the resource to lookup.
|
|
2570
2609
|
:param pulumi.ResourceOptions opts: Options for the resource.
|
|
2571
|
-
:param pulumi.Input[bool] attach: If `true` attach to the container after its creation and waits the end of its execution. Defaults to `false`.
|
|
2572
|
-
:param pulumi.Input[str] bridge: The network bridge of the container as read from its NetworkSettings.
|
|
2610
|
+
:param pulumi.Input[builtins.bool] attach: If `true` attach to the container after its creation and waits the end of its execution. Defaults to `false`.
|
|
2611
|
+
:param pulumi.Input[builtins.str] bridge: The network bridge of the container as read from its NetworkSettings.
|
|
2573
2612
|
:param pulumi.Input[Union['ContainerCapabilitiesArgs', 'ContainerCapabilitiesArgsDict']] capabilities: Add or drop certrain linux capabilities.
|
|
2574
|
-
:param pulumi.Input[str] cgroupns_mode: Cgroup namespace mode to use for the container. Possible values are: `private`, `host`.
|
|
2575
|
-
:param pulumi.Input[Sequence[pulumi.Input[str]]] command: 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.
|
|
2576
|
-
:param pulumi.Input[str] container_logs: The logs of the container if its execution is done (`attach` must be disabled).
|
|
2577
|
-
:param pulumi.Input[int] container_read_refresh_timeout_milliseconds: The total number of milliseconds to wait for the container to reach status 'running'
|
|
2578
|
-
:param pulumi.Input[str] cpu_set: A comma-separated list or hyphen-separated range of CPUs a container can use, e.g. `0-1`.
|
|
2579
|
-
:param pulumi.Input[int] cpu_shares: CPU shares (relative weight) for the container.
|
|
2580
|
-
:param pulumi.Input[
|
|
2613
|
+
:param pulumi.Input[builtins.str] cgroupns_mode: Cgroup namespace mode to use for the container. Possible values are: `private`, `host`.
|
|
2614
|
+
:param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] command: 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.conf"]`.
|
|
2615
|
+
:param pulumi.Input[builtins.str] container_logs: The logs of the container if its execution is done (`attach` must be disabled).
|
|
2616
|
+
:param pulumi.Input[builtins.int] container_read_refresh_timeout_milliseconds: The total number of milliseconds to wait for the container to reach status 'running'
|
|
2617
|
+
:param pulumi.Input[builtins.str] cpu_set: A comma-separated list or hyphen-separated range of CPUs a container can use, e.g. `0-1`.
|
|
2618
|
+
:param pulumi.Input[builtins.int] cpu_shares: CPU shares (relative weight) for the container.
|
|
2619
|
+
:param pulumi.Input[builtins.str] cpus: Specify how much of the available CPU resources a container can use. e.g a value of 1.5 means the container is guaranteed at most one and a half of the CPUs
|
|
2620
|
+
:param pulumi.Input[builtins.int] destroy_grace_seconds: If defined will attempt to stop the container before destroying. Container will be destroyed after `n` seconds or on successful stop.
|
|
2581
2621
|
:param pulumi.Input[Sequence[pulumi.Input[Union['ContainerDeviceArgs', 'ContainerDeviceArgsDict']]]] devices: Bind devices to the container.
|
|
2582
|
-
:param pulumi.Input[Sequence[pulumi.Input[str]]] dns: DNS servers to use.
|
|
2583
|
-
:param pulumi.Input[Sequence[pulumi.Input[str]]] dns_opts: DNS options used by the DNS provider(s), see `resolv.conf` documentation for valid list of options.
|
|
2584
|
-
:param pulumi.Input[Sequence[pulumi.Input[str]]] dns_searches: DNS search domains that are used when bare unqualified hostnames are used inside of the container.
|
|
2585
|
-
:param pulumi.Input[str] domainname: Domain name of the container.
|
|
2586
|
-
:param pulumi.Input[Sequence[pulumi.Input[str]]] entrypoints: 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/
|
|
2587
|
-
:param pulumi.Input[Sequence[pulumi.Input[str]]] envs: Environment variables to set in the form of `KEY=VALUE`, e.g. `DEBUG=0`
|
|
2588
|
-
:param pulumi.Input[int] exit_code: The exit code of the container if its execution is done (`must_run` must be disabled).
|
|
2589
|
-
:param pulumi.Input[str] gpus: GPU devices to add to the container. Currently, only the value `all` is supported. Passing any other value will result in unexpected behavior.
|
|
2590
|
-
:param pulumi.Input[Sequence[pulumi.Input[str]]] group_adds: Additional groups for the container user
|
|
2622
|
+
:param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] dns: DNS servers to use.
|
|
2623
|
+
:param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] dns_opts: DNS options used by the DNS provider(s), see `resolv.conf` documentation for valid list of options.
|
|
2624
|
+
:param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] dns_searches: DNS search domains that are used when bare unqualified hostnames are used inside of the container.
|
|
2625
|
+
:param pulumi.Input[builtins.str] domainname: Domain name of the container.
|
|
2626
|
+
:param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] entrypoints: 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/myprogram"]`.
|
|
2627
|
+
:param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] envs: Environment variables to set in the form of `KEY=VALUE`, e.g. `DEBUG=0`
|
|
2628
|
+
:param pulumi.Input[builtins.int] exit_code: The exit code of the container if its execution is done (`must_run` must be disabled).
|
|
2629
|
+
:param pulumi.Input[builtins.str] gpus: GPU devices to add to the container. Currently, only the value `all` is supported. Passing any other value will result in unexpected behavior.
|
|
2630
|
+
:param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] group_adds: Additional groups for the container user
|
|
2591
2631
|
:param pulumi.Input[Union['ContainerHealthcheckArgs', 'ContainerHealthcheckArgsDict']] healthcheck: A test to perform to check that the container is healthy
|
|
2592
|
-
:param pulumi.Input[str] hostname: Hostname of the container.
|
|
2632
|
+
:param pulumi.Input[builtins.str] hostname: Hostname of the container.
|
|
2593
2633
|
:param pulumi.Input[Sequence[pulumi.Input[Union['ContainerHostArgs', 'ContainerHostArgsDict']]]] hosts: Additional hosts to add to the container.
|
|
2594
|
-
:param pulumi.Input[str] image: The ID of the image to back this container. The easiest way to get this value is to use the `RemoteImage` resource as is shown in the example.
|
|
2595
|
-
:param pulumi.Input[bool] init: Configured whether an init process should be injected for this container. If unset this will default to the `dockerd` defaults.
|
|
2596
|
-
:param pulumi.Input[str] ipc_mode: IPC sharing mode for the container. Possible values are: `none`, `private`, `shareable`, `container:<name|id>` or `host`.
|
|
2634
|
+
:param pulumi.Input[builtins.str] image: The ID of the image to back this container. The easiest way to get this value is to use the `image_id` attribute of the `RemoteImage` resource as is shown in the example.
|
|
2635
|
+
:param pulumi.Input[builtins.bool] init: Configured whether an init process should be injected for this container. If unset this will default to the `dockerd` defaults.
|
|
2636
|
+
:param pulumi.Input[builtins.str] ipc_mode: IPC sharing mode for the container. Possible values are: `none`, `private`, `shareable`, `container:<name|id>` or `host`.
|
|
2597
2637
|
:param pulumi.Input[Sequence[pulumi.Input[Union['ContainerLabelArgs', 'ContainerLabelArgsDict']]]] labels: User-defined key/value metadata
|
|
2598
|
-
:param pulumi.Input[str] log_driver: The logging driver to use for the container.
|
|
2599
|
-
:param pulumi.Input[Mapping[str, pulumi.Input[str]]] log_opts: Key/value pairs to use as options for the logging driver.
|
|
2600
|
-
:param pulumi.Input[bool] logs: Save the container logs (`attach` must be enabled). Defaults to `false`.
|
|
2601
|
-
:param pulumi.Input[int] max_retry_count: The maximum amount of times to an attempt a restart when `restart` is set to 'on-failure'.
|
|
2602
|
-
:param pulumi.Input[int] memory: The memory limit for the container in MBs.
|
|
2603
|
-
:param pulumi.Input[int] memory_swap: 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.
|
|
2638
|
+
:param pulumi.Input[builtins.str] log_driver: The logging driver to use for the container.
|
|
2639
|
+
:param pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]] log_opts: Key/value pairs to use as options for the logging driver.
|
|
2640
|
+
:param pulumi.Input[builtins.bool] logs: Save the container logs (`attach` must be enabled). Defaults to `false`.
|
|
2641
|
+
:param pulumi.Input[builtins.int] max_retry_count: The maximum amount of times to an attempt a restart when `restart` is set to 'on-failure'.
|
|
2642
|
+
:param pulumi.Input[builtins.int] memory: The memory limit for the container in MBs.
|
|
2643
|
+
:param pulumi.Input[builtins.int] memory_swap: 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.
|
|
2604
2644
|
:param pulumi.Input[Sequence[pulumi.Input[Union['ContainerMountArgs', 'ContainerMountArgsDict']]]] mounts: Specification for mounts to be added to containers created as part of the service.
|
|
2605
|
-
:param pulumi.Input[str] name: The name of the container.
|
|
2645
|
+
:param pulumi.Input[builtins.str] name: The name of the container.
|
|
2606
2646
|
:param pulumi.Input[Sequence[pulumi.Input[Union['ContainerNetworkDataArgs', 'ContainerNetworkDataArgsDict']]]] network_datas: The data of the networks the container is connected to.
|
|
2607
|
-
:param pulumi.Input[str] network_mode: Network mode of the container.
|
|
2647
|
+
:param pulumi.Input[builtins.str] network_mode: Network mode of the container. See https://docs.docker.com/engine/network/ for more information.
|
|
2608
2648
|
:param pulumi.Input[Sequence[pulumi.Input[Union['ContainerNetworksAdvancedArgs', 'ContainerNetworksAdvancedArgsDict']]]] networks_advanced: The networks the container is attached to
|
|
2609
|
-
:param pulumi.Input[str] pid_mode: he PID (Process) Namespace mode for the container. Either `container:<name|id>` or `host`.
|
|
2649
|
+
:param pulumi.Input[builtins.str] pid_mode: he PID (Process) Namespace mode for the container. Either `container:<name|id>` or `host`.
|
|
2610
2650
|
:param pulumi.Input[Sequence[pulumi.Input[Union['ContainerPortArgs', 'ContainerPortArgsDict']]]] ports: Publish a container's port(s) to the host.
|
|
2611
|
-
:param pulumi.Input[bool] privileged: If `true`, the container runs in privileged mode.
|
|
2612
|
-
:param pulumi.Input[bool] publish_all_ports: Publish all ports of the container.
|
|
2613
|
-
:param pulumi.Input[bool] read_only: If `true`, the container will be started as readonly. Defaults to `false`.
|
|
2614
|
-
:param pulumi.Input[bool] remove_volumes: If `true`, it will remove anonymous volumes associated with the container. Defaults to `true`.
|
|
2615
|
-
:param pulumi.Input[str] restart: The restart policy for the container. Must be one of 'no', 'on-failure', 'always', 'unless-stopped'. Defaults to `no`.
|
|
2616
|
-
:param pulumi.Input[bool] rm: If `true`, then the container will be automatically removed when it exits. Defaults to `false`.
|
|
2617
|
-
:param pulumi.Input[str] runtime: Runtime to use for the container.
|
|
2618
|
-
:param pulumi.Input[Sequence[pulumi.Input[str]]] security_opts: List of string values to customize labels for MLS systems, such as SELinux. See https://docs.docker.com/engine/reference/run/#security-configuration.
|
|
2619
|
-
:param pulumi.Input[int] shm_size: Size of `/dev/shm` in MBs.
|
|
2620
|
-
:param pulumi.Input[bool] start: If `true`, then the Docker container will be started after creation. If `false`, then the container is only created. Defaults to `true`.
|
|
2621
|
-
:param pulumi.Input[bool] stdin_open: If `true`, keep STDIN open even if not attached (`docker run -i`). Defaults to `false`.
|
|
2622
|
-
:param pulumi.Input[str] stop_signal: Signal to stop a container (default `SIGTERM`).
|
|
2623
|
-
:param pulumi.Input[int] stop_timeout: Timeout (in seconds) to stop a container.
|
|
2624
|
-
:param pulumi.Input[Mapping[str, pulumi.Input[str]]] storage_opts: Key/value pairs for the storage driver options, e.g. `size`: `120G`
|
|
2625
|
-
:param pulumi.Input[Mapping[str, pulumi.Input[str]]] sysctls: A map of kernel parameters (sysctls) to set in the container.
|
|
2626
|
-
:param pulumi.Input[Mapping[str, pulumi.Input[str]]] tmpfs: A map of container directories which should be replaced by `tmpfs mounts`, and their corresponding mount options.
|
|
2627
|
-
:param pulumi.Input[bool] tty: If `true`, allocate a pseudo-tty (`docker run -t`). Defaults to `false`.
|
|
2651
|
+
:param pulumi.Input[builtins.bool] privileged: If `true`, the container runs in privileged mode.
|
|
2652
|
+
:param pulumi.Input[builtins.bool] publish_all_ports: Publish all ports of the container.
|
|
2653
|
+
:param pulumi.Input[builtins.bool] read_only: If `true`, the container will be started as readonly. Defaults to `false`.
|
|
2654
|
+
:param pulumi.Input[builtins.bool] remove_volumes: If `true`, it will remove anonymous volumes associated with the container. Defaults to `true`.
|
|
2655
|
+
:param pulumi.Input[builtins.str] restart: The restart policy for the container. Must be one of 'no', 'on-failure', 'always', 'unless-stopped'. Defaults to `no`.
|
|
2656
|
+
:param pulumi.Input[builtins.bool] rm: If `true`, then the container will be automatically removed when it exits. Defaults to `false`.
|
|
2657
|
+
:param pulumi.Input[builtins.str] runtime: Runtime to use for the container.
|
|
2658
|
+
:param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] security_opts: List of string values to customize labels for MLS systems, such as SELinux. See https://docs.docker.com/engine/reference/run/#security-configuration.
|
|
2659
|
+
:param pulumi.Input[builtins.int] shm_size: Size of `/dev/shm` in MBs.
|
|
2660
|
+
:param pulumi.Input[builtins.bool] start: If `true`, then the Docker container will be started after creation. If `false`, then the container is only created. Defaults to `true`.
|
|
2661
|
+
:param pulumi.Input[builtins.bool] stdin_open: If `true`, keep STDIN open even if not attached (`docker run -i`). Defaults to `false`.
|
|
2662
|
+
:param pulumi.Input[builtins.str] stop_signal: Signal to stop a container (default `SIGTERM`).
|
|
2663
|
+
:param pulumi.Input[builtins.int] stop_timeout: Timeout (in seconds) to stop a container.
|
|
2664
|
+
:param pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]] storage_opts: Key/value pairs for the storage driver options, e.g. `size`: `120G`
|
|
2665
|
+
:param pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]] sysctls: A map of kernel parameters (sysctls) to set in the container.
|
|
2666
|
+
:param pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]] tmpfs: A map of container directories which should be replaced by `tmpfs mounts`, and their corresponding mount options.
|
|
2667
|
+
:param pulumi.Input[builtins.bool] tty: If `true`, allocate a pseudo-tty (`docker run -t`). Defaults to `false`.
|
|
2628
2668
|
:param pulumi.Input[Sequence[pulumi.Input[Union['ContainerUlimitArgs', 'ContainerUlimitArgsDict']]]] ulimits: Ulimit options to add.
|
|
2629
2669
|
:param pulumi.Input[Sequence[pulumi.Input[Union['ContainerUploadArgs', 'ContainerUploadArgsDict']]]] uploads: 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.
|
|
2630
|
-
:param pulumi.Input[str] user: User used for run the first process. Format is `user` or `user:group` which user and group can be passed literraly or by name.
|
|
2631
|
-
:param pulumi.Input[str] userns_mode: Sets the usernamespace mode for the container when usernamespace remapping option is enabled.
|
|
2670
|
+
:param pulumi.Input[builtins.str] user: User used for run the first process. Format is `user` or `user:group` which user and group can be passed literraly or by name.
|
|
2671
|
+
:param pulumi.Input[builtins.str] userns_mode: Sets the usernamespace mode for the container when usernamespace remapping option is enabled.
|
|
2632
2672
|
:param pulumi.Input[Sequence[pulumi.Input[Union['ContainerVolumeArgs', 'ContainerVolumeArgsDict']]]] volumes: Spec for mounting volumes in the container.
|
|
2633
|
-
:param pulumi.Input[bool] wait: 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`.
|
|
2634
|
-
:param pulumi.Input[int] wait_timeout: The timeout in seconds to wait the container to be healthy after creation. Defaults to `60`.
|
|
2635
|
-
:param pulumi.Input[str] working_dir: The working directory for commands to run in.
|
|
2673
|
+
:param pulumi.Input[builtins.bool] wait: If `true`, then the Docker container is waited for being healthy state after creation. This requires your container to have a healthcheck, otherwise this provider will error. If `false`, then the container health state is not checked. Defaults to `false`.
|
|
2674
|
+
:param pulumi.Input[builtins.int] wait_timeout: The timeout in seconds to wait the container to be healthy after creation. Defaults to `60`.
|
|
2675
|
+
:param pulumi.Input[builtins.str] working_dir: The working directory for commands to run in.
|
|
2636
2676
|
"""
|
|
2637
2677
|
opts = pulumi.ResourceOptions.merge(opts, pulumi.ResourceOptions(id=id))
|
|
2638
2678
|
|
|
@@ -2647,6 +2687,7 @@ class Container(pulumi.CustomResource):
|
|
|
2647
2687
|
__props__.__dict__["container_read_refresh_timeout_milliseconds"] = container_read_refresh_timeout_milliseconds
|
|
2648
2688
|
__props__.__dict__["cpu_set"] = cpu_set
|
|
2649
2689
|
__props__.__dict__["cpu_shares"] = cpu_shares
|
|
2690
|
+
__props__.__dict__["cpus"] = cpus
|
|
2650
2691
|
__props__.__dict__["destroy_grace_seconds"] = destroy_grace_seconds
|
|
2651
2692
|
__props__.__dict__["devices"] = devices
|
|
2652
2693
|
__props__.__dict__["dns"] = dns
|
|
@@ -2708,7 +2749,7 @@ class Container(pulumi.CustomResource):
|
|
|
2708
2749
|
|
|
2709
2750
|
@property
|
|
2710
2751
|
@pulumi.getter
|
|
2711
|
-
def attach(self) -> pulumi.Output[Optional[bool]]:
|
|
2752
|
+
def attach(self) -> pulumi.Output[Optional[builtins.bool]]:
|
|
2712
2753
|
"""
|
|
2713
2754
|
If `true` attach to the container after its creation and waits the end of its execution. Defaults to `false`.
|
|
2714
2755
|
"""
|
|
@@ -2716,7 +2757,7 @@ class Container(pulumi.CustomResource):
|
|
|
2716
2757
|
|
|
2717
2758
|
@property
|
|
2718
2759
|
@pulumi.getter
|
|
2719
|
-
def bridge(self) -> pulumi.Output[str]:
|
|
2760
|
+
def bridge(self) -> pulumi.Output[builtins.str]:
|
|
2720
2761
|
"""
|
|
2721
2762
|
The network bridge of the container as read from its NetworkSettings.
|
|
2722
2763
|
"""
|
|
@@ -2732,7 +2773,7 @@ class Container(pulumi.CustomResource):
|
|
|
2732
2773
|
|
|
2733
2774
|
@property
|
|
2734
2775
|
@pulumi.getter(name="cgroupnsMode")
|
|
2735
|
-
def cgroupns_mode(self) -> pulumi.Output[Optional[str]]:
|
|
2776
|
+
def cgroupns_mode(self) -> pulumi.Output[Optional[builtins.str]]:
|
|
2736
2777
|
"""
|
|
2737
2778
|
Cgroup namespace mode to use for the container. Possible values are: `private`, `host`.
|
|
2738
2779
|
"""
|
|
@@ -2740,15 +2781,15 @@ class Container(pulumi.CustomResource):
|
|
|
2740
2781
|
|
|
2741
2782
|
@property
|
|
2742
2783
|
@pulumi.getter
|
|
2743
|
-
def command(self) -> pulumi.Output[Sequence[str]]:
|
|
2784
|
+
def command(self) -> pulumi.Output[Sequence[builtins.str]]:
|
|
2744
2785
|
"""
|
|
2745
|
-
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.
|
|
2786
|
+
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.conf"]`.
|
|
2746
2787
|
"""
|
|
2747
2788
|
return pulumi.get(self, "command")
|
|
2748
2789
|
|
|
2749
2790
|
@property
|
|
2750
2791
|
@pulumi.getter(name="containerLogs")
|
|
2751
|
-
def container_logs(self) -> pulumi.Output[str]:
|
|
2792
|
+
def container_logs(self) -> pulumi.Output[builtins.str]:
|
|
2752
2793
|
"""
|
|
2753
2794
|
The logs of the container if its execution is done (`attach` must be disabled).
|
|
2754
2795
|
"""
|
|
@@ -2756,7 +2797,7 @@ class Container(pulumi.CustomResource):
|
|
|
2756
2797
|
|
|
2757
2798
|
@property
|
|
2758
2799
|
@pulumi.getter(name="containerReadRefreshTimeoutMilliseconds")
|
|
2759
|
-
def container_read_refresh_timeout_milliseconds(self) -> pulumi.Output[Optional[int]]:
|
|
2800
|
+
def container_read_refresh_timeout_milliseconds(self) -> pulumi.Output[Optional[builtins.int]]:
|
|
2760
2801
|
"""
|
|
2761
2802
|
The total number of milliseconds to wait for the container to reach status 'running'
|
|
2762
2803
|
"""
|
|
@@ -2764,7 +2805,7 @@ class Container(pulumi.CustomResource):
|
|
|
2764
2805
|
|
|
2765
2806
|
@property
|
|
2766
2807
|
@pulumi.getter(name="cpuSet")
|
|
2767
|
-
def cpu_set(self) -> pulumi.Output[Optional[str]]:
|
|
2808
|
+
def cpu_set(self) -> pulumi.Output[Optional[builtins.str]]:
|
|
2768
2809
|
"""
|
|
2769
2810
|
A comma-separated list or hyphen-separated range of CPUs a container can use, e.g. `0-1`.
|
|
2770
2811
|
"""
|
|
@@ -2772,15 +2813,23 @@ class Container(pulumi.CustomResource):
|
|
|
2772
2813
|
|
|
2773
2814
|
@property
|
|
2774
2815
|
@pulumi.getter(name="cpuShares")
|
|
2775
|
-
def cpu_shares(self) -> pulumi.Output[Optional[int]]:
|
|
2816
|
+
def cpu_shares(self) -> pulumi.Output[Optional[builtins.int]]:
|
|
2776
2817
|
"""
|
|
2777
2818
|
CPU shares (relative weight) for the container.
|
|
2778
2819
|
"""
|
|
2779
2820
|
return pulumi.get(self, "cpu_shares")
|
|
2780
2821
|
|
|
2822
|
+
@property
|
|
2823
|
+
@pulumi.getter
|
|
2824
|
+
def cpus(self) -> pulumi.Output[Optional[builtins.str]]:
|
|
2825
|
+
"""
|
|
2826
|
+
Specify how much of the available CPU resources a container can use. e.g a value of 1.5 means the container is guaranteed at most one and a half of the CPUs
|
|
2827
|
+
"""
|
|
2828
|
+
return pulumi.get(self, "cpus")
|
|
2829
|
+
|
|
2781
2830
|
@property
|
|
2782
2831
|
@pulumi.getter(name="destroyGraceSeconds")
|
|
2783
|
-
def destroy_grace_seconds(self) -> pulumi.Output[Optional[int]]:
|
|
2832
|
+
def destroy_grace_seconds(self) -> pulumi.Output[Optional[builtins.int]]:
|
|
2784
2833
|
"""
|
|
2785
2834
|
If defined will attempt to stop the container before destroying. Container will be destroyed after `n` seconds or on successful stop.
|
|
2786
2835
|
"""
|
|
@@ -2796,7 +2845,7 @@ class Container(pulumi.CustomResource):
|
|
|
2796
2845
|
|
|
2797
2846
|
@property
|
|
2798
2847
|
@pulumi.getter
|
|
2799
|
-
def dns(self) -> pulumi.Output[Optional[Sequence[str]]]:
|
|
2848
|
+
def dns(self) -> pulumi.Output[Optional[Sequence[builtins.str]]]:
|
|
2800
2849
|
"""
|
|
2801
2850
|
DNS servers to use.
|
|
2802
2851
|
"""
|
|
@@ -2804,7 +2853,7 @@ class Container(pulumi.CustomResource):
|
|
|
2804
2853
|
|
|
2805
2854
|
@property
|
|
2806
2855
|
@pulumi.getter(name="dnsOpts")
|
|
2807
|
-
def dns_opts(self) -> pulumi.Output[Optional[Sequence[str]]]:
|
|
2856
|
+
def dns_opts(self) -> pulumi.Output[Optional[Sequence[builtins.str]]]:
|
|
2808
2857
|
"""
|
|
2809
2858
|
DNS options used by the DNS provider(s), see `resolv.conf` documentation for valid list of options.
|
|
2810
2859
|
"""
|
|
@@ -2812,7 +2861,7 @@ class Container(pulumi.CustomResource):
|
|
|
2812
2861
|
|
|
2813
2862
|
@property
|
|
2814
2863
|
@pulumi.getter(name="dnsSearches")
|
|
2815
|
-
def dns_searches(self) -> pulumi.Output[Optional[Sequence[str]]]:
|
|
2864
|
+
def dns_searches(self) -> pulumi.Output[Optional[Sequence[builtins.str]]]:
|
|
2816
2865
|
"""
|
|
2817
2866
|
DNS search domains that are used when bare unqualified hostnames are used inside of the container.
|
|
2818
2867
|
"""
|
|
@@ -2820,7 +2869,7 @@ class Container(pulumi.CustomResource):
|
|
|
2820
2869
|
|
|
2821
2870
|
@property
|
|
2822
2871
|
@pulumi.getter
|
|
2823
|
-
def domainname(self) -> pulumi.Output[Optional[str]]:
|
|
2872
|
+
def domainname(self) -> pulumi.Output[Optional[builtins.str]]:
|
|
2824
2873
|
"""
|
|
2825
2874
|
Domain name of the container.
|
|
2826
2875
|
"""
|
|
@@ -2828,15 +2877,15 @@ class Container(pulumi.CustomResource):
|
|
|
2828
2877
|
|
|
2829
2878
|
@property
|
|
2830
2879
|
@pulumi.getter
|
|
2831
|
-
def entrypoints(self) -> pulumi.Output[Sequence[str]]:
|
|
2880
|
+
def entrypoints(self) -> pulumi.Output[Sequence[builtins.str]]:
|
|
2832
2881
|
"""
|
|
2833
|
-
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/
|
|
2882
|
+
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/myprogram"]`.
|
|
2834
2883
|
"""
|
|
2835
2884
|
return pulumi.get(self, "entrypoints")
|
|
2836
2885
|
|
|
2837
2886
|
@property
|
|
2838
2887
|
@pulumi.getter
|
|
2839
|
-
def envs(self) -> pulumi.Output[Sequence[str]]:
|
|
2888
|
+
def envs(self) -> pulumi.Output[Sequence[builtins.str]]:
|
|
2840
2889
|
"""
|
|
2841
2890
|
Environment variables to set in the form of `KEY=VALUE`, e.g. `DEBUG=0`
|
|
2842
2891
|
"""
|
|
@@ -2844,7 +2893,7 @@ class Container(pulumi.CustomResource):
|
|
|
2844
2893
|
|
|
2845
2894
|
@property
|
|
2846
2895
|
@pulumi.getter(name="exitCode")
|
|
2847
|
-
def exit_code(self) -> pulumi.Output[int]:
|
|
2896
|
+
def exit_code(self) -> pulumi.Output[builtins.int]:
|
|
2848
2897
|
"""
|
|
2849
2898
|
The exit code of the container if its execution is done (`must_run` must be disabled).
|
|
2850
2899
|
"""
|
|
@@ -2852,7 +2901,7 @@ class Container(pulumi.CustomResource):
|
|
|
2852
2901
|
|
|
2853
2902
|
@property
|
|
2854
2903
|
@pulumi.getter
|
|
2855
|
-
def gpus(self) -> pulumi.Output[Optional[str]]:
|
|
2904
|
+
def gpus(self) -> pulumi.Output[Optional[builtins.str]]:
|
|
2856
2905
|
"""
|
|
2857
2906
|
GPU devices to add to the container. Currently, only the value `all` is supported. Passing any other value will result in unexpected behavior.
|
|
2858
2907
|
"""
|
|
@@ -2860,7 +2909,7 @@ class Container(pulumi.CustomResource):
|
|
|
2860
2909
|
|
|
2861
2910
|
@property
|
|
2862
2911
|
@pulumi.getter(name="groupAdds")
|
|
2863
|
-
def group_adds(self) -> pulumi.Output[Optional[Sequence[str]]]:
|
|
2912
|
+
def group_adds(self) -> pulumi.Output[Optional[Sequence[builtins.str]]]:
|
|
2864
2913
|
"""
|
|
2865
2914
|
Additional groups for the container user
|
|
2866
2915
|
"""
|
|
@@ -2876,7 +2925,7 @@ class Container(pulumi.CustomResource):
|
|
|
2876
2925
|
|
|
2877
2926
|
@property
|
|
2878
2927
|
@pulumi.getter
|
|
2879
|
-
def hostname(self) -> pulumi.Output[str]:
|
|
2928
|
+
def hostname(self) -> pulumi.Output[builtins.str]:
|
|
2880
2929
|
"""
|
|
2881
2930
|
Hostname of the container.
|
|
2882
2931
|
"""
|
|
@@ -2892,15 +2941,15 @@ class Container(pulumi.CustomResource):
|
|
|
2892
2941
|
|
|
2893
2942
|
@property
|
|
2894
2943
|
@pulumi.getter
|
|
2895
|
-
def image(self) -> pulumi.Output[str]:
|
|
2944
|
+
def image(self) -> pulumi.Output[builtins.str]:
|
|
2896
2945
|
"""
|
|
2897
|
-
The ID of the image to back this container. The easiest way to get this value is to use the `RemoteImage` resource as is shown in the example.
|
|
2946
|
+
The ID of the image to back this container. The easiest way to get this value is to use the `image_id` attribute of the `RemoteImage` resource as is shown in the example.
|
|
2898
2947
|
"""
|
|
2899
2948
|
return pulumi.get(self, "image")
|
|
2900
2949
|
|
|
2901
2950
|
@property
|
|
2902
2951
|
@pulumi.getter
|
|
2903
|
-
def init(self) -> pulumi.Output[bool]:
|
|
2952
|
+
def init(self) -> pulumi.Output[builtins.bool]:
|
|
2904
2953
|
"""
|
|
2905
2954
|
Configured whether an init process should be injected for this container. If unset this will default to the `dockerd` defaults.
|
|
2906
2955
|
"""
|
|
@@ -2908,7 +2957,7 @@ class Container(pulumi.CustomResource):
|
|
|
2908
2957
|
|
|
2909
2958
|
@property
|
|
2910
2959
|
@pulumi.getter(name="ipcMode")
|
|
2911
|
-
def ipc_mode(self) -> pulumi.Output[str]:
|
|
2960
|
+
def ipc_mode(self) -> pulumi.Output[builtins.str]:
|
|
2912
2961
|
"""
|
|
2913
2962
|
IPC sharing mode for the container. Possible values are: `none`, `private`, `shareable`, `container:<name|id>` or `host`.
|
|
2914
2963
|
"""
|
|
@@ -2924,7 +2973,7 @@ class Container(pulumi.CustomResource):
|
|
|
2924
2973
|
|
|
2925
2974
|
@property
|
|
2926
2975
|
@pulumi.getter(name="logDriver")
|
|
2927
|
-
def log_driver(self) -> pulumi.Output[str]:
|
|
2976
|
+
def log_driver(self) -> pulumi.Output[builtins.str]:
|
|
2928
2977
|
"""
|
|
2929
2978
|
The logging driver to use for the container.
|
|
2930
2979
|
"""
|
|
@@ -2932,7 +2981,7 @@ class Container(pulumi.CustomResource):
|
|
|
2932
2981
|
|
|
2933
2982
|
@property
|
|
2934
2983
|
@pulumi.getter(name="logOpts")
|
|
2935
|
-
def log_opts(self) -> pulumi.Output[Optional[Mapping[str, str]]]:
|
|
2984
|
+
def log_opts(self) -> pulumi.Output[Optional[Mapping[str, builtins.str]]]:
|
|
2936
2985
|
"""
|
|
2937
2986
|
Key/value pairs to use as options for the logging driver.
|
|
2938
2987
|
"""
|
|
@@ -2940,7 +2989,7 @@ class Container(pulumi.CustomResource):
|
|
|
2940
2989
|
|
|
2941
2990
|
@property
|
|
2942
2991
|
@pulumi.getter
|
|
2943
|
-
def logs(self) -> pulumi.Output[Optional[bool]]:
|
|
2992
|
+
def logs(self) -> pulumi.Output[Optional[builtins.bool]]:
|
|
2944
2993
|
"""
|
|
2945
2994
|
Save the container logs (`attach` must be enabled). Defaults to `false`.
|
|
2946
2995
|
"""
|
|
@@ -2948,7 +2997,7 @@ class Container(pulumi.CustomResource):
|
|
|
2948
2997
|
|
|
2949
2998
|
@property
|
|
2950
2999
|
@pulumi.getter(name="maxRetryCount")
|
|
2951
|
-
def max_retry_count(self) -> pulumi.Output[Optional[int]]:
|
|
3000
|
+
def max_retry_count(self) -> pulumi.Output[Optional[builtins.int]]:
|
|
2952
3001
|
"""
|
|
2953
3002
|
The maximum amount of times to an attempt a restart when `restart` is set to 'on-failure'.
|
|
2954
3003
|
"""
|
|
@@ -2956,7 +3005,7 @@ class Container(pulumi.CustomResource):
|
|
|
2956
3005
|
|
|
2957
3006
|
@property
|
|
2958
3007
|
@pulumi.getter
|
|
2959
|
-
def memory(self) -> pulumi.Output[Optional[int]]:
|
|
3008
|
+
def memory(self) -> pulumi.Output[Optional[builtins.int]]:
|
|
2960
3009
|
"""
|
|
2961
3010
|
The memory limit for the container in MBs.
|
|
2962
3011
|
"""
|
|
@@ -2964,7 +3013,7 @@ class Container(pulumi.CustomResource):
|
|
|
2964
3013
|
|
|
2965
3014
|
@property
|
|
2966
3015
|
@pulumi.getter(name="memorySwap")
|
|
2967
|
-
def memory_swap(self) -> pulumi.Output[Optional[int]]:
|
|
3016
|
+
def memory_swap(self) -> pulumi.Output[Optional[builtins.int]]:
|
|
2968
3017
|
"""
|
|
2969
3018
|
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.
|
|
2970
3019
|
"""
|
|
@@ -2980,12 +3029,12 @@ class Container(pulumi.CustomResource):
|
|
|
2980
3029
|
|
|
2981
3030
|
@property
|
|
2982
3031
|
@pulumi.getter(name="mustRun")
|
|
2983
|
-
def must_run(self) -> pulumi.Output[Optional[bool]]:
|
|
3032
|
+
def must_run(self) -> pulumi.Output[Optional[builtins.bool]]:
|
|
2984
3033
|
return pulumi.get(self, "must_run")
|
|
2985
3034
|
|
|
2986
3035
|
@property
|
|
2987
3036
|
@pulumi.getter
|
|
2988
|
-
def name(self) -> pulumi.Output[str]:
|
|
3037
|
+
def name(self) -> pulumi.Output[builtins.str]:
|
|
2989
3038
|
"""
|
|
2990
3039
|
The name of the container.
|
|
2991
3040
|
"""
|
|
@@ -3001,9 +3050,9 @@ class Container(pulumi.CustomResource):
|
|
|
3001
3050
|
|
|
3002
3051
|
@property
|
|
3003
3052
|
@pulumi.getter(name="networkMode")
|
|
3004
|
-
def network_mode(self) -> pulumi.Output[Optional[str]]:
|
|
3053
|
+
def network_mode(self) -> pulumi.Output[Optional[builtins.str]]:
|
|
3005
3054
|
"""
|
|
3006
|
-
Network mode of the container.
|
|
3055
|
+
Network mode of the container. See https://docs.docker.com/engine/network/ for more information.
|
|
3007
3056
|
"""
|
|
3008
3057
|
return pulumi.get(self, "network_mode")
|
|
3009
3058
|
|
|
@@ -3017,7 +3066,7 @@ class Container(pulumi.CustomResource):
|
|
|
3017
3066
|
|
|
3018
3067
|
@property
|
|
3019
3068
|
@pulumi.getter(name="pidMode")
|
|
3020
|
-
def pid_mode(self) -> pulumi.Output[Optional[str]]:
|
|
3069
|
+
def pid_mode(self) -> pulumi.Output[Optional[builtins.str]]:
|
|
3021
3070
|
"""
|
|
3022
3071
|
he PID (Process) Namespace mode for the container. Either `container:<name|id>` or `host`.
|
|
3023
3072
|
"""
|
|
@@ -3033,7 +3082,7 @@ class Container(pulumi.CustomResource):
|
|
|
3033
3082
|
|
|
3034
3083
|
@property
|
|
3035
3084
|
@pulumi.getter
|
|
3036
|
-
def privileged(self) -> pulumi.Output[Optional[bool]]:
|
|
3085
|
+
def privileged(self) -> pulumi.Output[Optional[builtins.bool]]:
|
|
3037
3086
|
"""
|
|
3038
3087
|
If `true`, the container runs in privileged mode.
|
|
3039
3088
|
"""
|
|
@@ -3041,7 +3090,7 @@ class Container(pulumi.CustomResource):
|
|
|
3041
3090
|
|
|
3042
3091
|
@property
|
|
3043
3092
|
@pulumi.getter(name="publishAllPorts")
|
|
3044
|
-
def publish_all_ports(self) -> pulumi.Output[Optional[bool]]:
|
|
3093
|
+
def publish_all_ports(self) -> pulumi.Output[Optional[builtins.bool]]:
|
|
3045
3094
|
"""
|
|
3046
3095
|
Publish all ports of the container.
|
|
3047
3096
|
"""
|
|
@@ -3049,7 +3098,7 @@ class Container(pulumi.CustomResource):
|
|
|
3049
3098
|
|
|
3050
3099
|
@property
|
|
3051
3100
|
@pulumi.getter(name="readOnly")
|
|
3052
|
-
def read_only(self) -> pulumi.Output[Optional[bool]]:
|
|
3101
|
+
def read_only(self) -> pulumi.Output[Optional[builtins.bool]]:
|
|
3053
3102
|
"""
|
|
3054
3103
|
If `true`, the container will be started as readonly. Defaults to `false`.
|
|
3055
3104
|
"""
|
|
@@ -3057,7 +3106,7 @@ class Container(pulumi.CustomResource):
|
|
|
3057
3106
|
|
|
3058
3107
|
@property
|
|
3059
3108
|
@pulumi.getter(name="removeVolumes")
|
|
3060
|
-
def remove_volumes(self) -> pulumi.Output[Optional[bool]]:
|
|
3109
|
+
def remove_volumes(self) -> pulumi.Output[Optional[builtins.bool]]:
|
|
3061
3110
|
"""
|
|
3062
3111
|
If `true`, it will remove anonymous volumes associated with the container. Defaults to `true`.
|
|
3063
3112
|
"""
|
|
@@ -3065,7 +3114,7 @@ class Container(pulumi.CustomResource):
|
|
|
3065
3114
|
|
|
3066
3115
|
@property
|
|
3067
3116
|
@pulumi.getter
|
|
3068
|
-
def restart(self) -> pulumi.Output[Optional[str]]:
|
|
3117
|
+
def restart(self) -> pulumi.Output[Optional[builtins.str]]:
|
|
3069
3118
|
"""
|
|
3070
3119
|
The restart policy for the container. Must be one of 'no', 'on-failure', 'always', 'unless-stopped'. Defaults to `no`.
|
|
3071
3120
|
"""
|
|
@@ -3073,7 +3122,7 @@ class Container(pulumi.CustomResource):
|
|
|
3073
3122
|
|
|
3074
3123
|
@property
|
|
3075
3124
|
@pulumi.getter
|
|
3076
|
-
def rm(self) -> pulumi.Output[Optional[bool]]:
|
|
3125
|
+
def rm(self) -> pulumi.Output[Optional[builtins.bool]]:
|
|
3077
3126
|
"""
|
|
3078
3127
|
If `true`, then the container will be automatically removed when it exits. Defaults to `false`.
|
|
3079
3128
|
"""
|
|
@@ -3081,7 +3130,7 @@ class Container(pulumi.CustomResource):
|
|
|
3081
3130
|
|
|
3082
3131
|
@property
|
|
3083
3132
|
@pulumi.getter
|
|
3084
|
-
def runtime(self) -> pulumi.Output[str]:
|
|
3133
|
+
def runtime(self) -> pulumi.Output[builtins.str]:
|
|
3085
3134
|
"""
|
|
3086
3135
|
Runtime to use for the container.
|
|
3087
3136
|
"""
|
|
@@ -3089,7 +3138,7 @@ class Container(pulumi.CustomResource):
|
|
|
3089
3138
|
|
|
3090
3139
|
@property
|
|
3091
3140
|
@pulumi.getter(name="securityOpts")
|
|
3092
|
-
def security_opts(self) -> pulumi.Output[Sequence[str]]:
|
|
3141
|
+
def security_opts(self) -> pulumi.Output[Sequence[builtins.str]]:
|
|
3093
3142
|
"""
|
|
3094
3143
|
List of string values to customize labels for MLS systems, such as SELinux. See https://docs.docker.com/engine/reference/run/#security-configuration.
|
|
3095
3144
|
"""
|
|
@@ -3097,7 +3146,7 @@ class Container(pulumi.CustomResource):
|
|
|
3097
3146
|
|
|
3098
3147
|
@property
|
|
3099
3148
|
@pulumi.getter(name="shmSize")
|
|
3100
|
-
def shm_size(self) -> pulumi.Output[int]:
|
|
3149
|
+
def shm_size(self) -> pulumi.Output[builtins.int]:
|
|
3101
3150
|
"""
|
|
3102
3151
|
Size of `/dev/shm` in MBs.
|
|
3103
3152
|
"""
|
|
@@ -3105,7 +3154,7 @@ class Container(pulumi.CustomResource):
|
|
|
3105
3154
|
|
|
3106
3155
|
@property
|
|
3107
3156
|
@pulumi.getter
|
|
3108
|
-
def start(self) -> pulumi.Output[Optional[bool]]:
|
|
3157
|
+
def start(self) -> pulumi.Output[Optional[builtins.bool]]:
|
|
3109
3158
|
"""
|
|
3110
3159
|
If `true`, then the Docker container will be started after creation. If `false`, then the container is only created. Defaults to `true`.
|
|
3111
3160
|
"""
|
|
@@ -3113,7 +3162,7 @@ class Container(pulumi.CustomResource):
|
|
|
3113
3162
|
|
|
3114
3163
|
@property
|
|
3115
3164
|
@pulumi.getter(name="stdinOpen")
|
|
3116
|
-
def stdin_open(self) -> pulumi.Output[Optional[bool]]:
|
|
3165
|
+
def stdin_open(self) -> pulumi.Output[Optional[builtins.bool]]:
|
|
3117
3166
|
"""
|
|
3118
3167
|
If `true`, keep STDIN open even if not attached (`docker run -i`). Defaults to `false`.
|
|
3119
3168
|
"""
|
|
@@ -3121,7 +3170,7 @@ class Container(pulumi.CustomResource):
|
|
|
3121
3170
|
|
|
3122
3171
|
@property
|
|
3123
3172
|
@pulumi.getter(name="stopSignal")
|
|
3124
|
-
def stop_signal(self) -> pulumi.Output[str]:
|
|
3173
|
+
def stop_signal(self) -> pulumi.Output[builtins.str]:
|
|
3125
3174
|
"""
|
|
3126
3175
|
Signal to stop a container (default `SIGTERM`).
|
|
3127
3176
|
"""
|
|
@@ -3129,7 +3178,7 @@ class Container(pulumi.CustomResource):
|
|
|
3129
3178
|
|
|
3130
3179
|
@property
|
|
3131
3180
|
@pulumi.getter(name="stopTimeout")
|
|
3132
|
-
def stop_timeout(self) -> pulumi.Output[int]:
|
|
3181
|
+
def stop_timeout(self) -> pulumi.Output[builtins.int]:
|
|
3133
3182
|
"""
|
|
3134
3183
|
Timeout (in seconds) to stop a container.
|
|
3135
3184
|
"""
|
|
@@ -3137,7 +3186,7 @@ class Container(pulumi.CustomResource):
|
|
|
3137
3186
|
|
|
3138
3187
|
@property
|
|
3139
3188
|
@pulumi.getter(name="storageOpts")
|
|
3140
|
-
def storage_opts(self) -> pulumi.Output[Optional[Mapping[str, str]]]:
|
|
3189
|
+
def storage_opts(self) -> pulumi.Output[Optional[Mapping[str, builtins.str]]]:
|
|
3141
3190
|
"""
|
|
3142
3191
|
Key/value pairs for the storage driver options, e.g. `size`: `120G`
|
|
3143
3192
|
"""
|
|
@@ -3145,7 +3194,7 @@ class Container(pulumi.CustomResource):
|
|
|
3145
3194
|
|
|
3146
3195
|
@property
|
|
3147
3196
|
@pulumi.getter
|
|
3148
|
-
def sysctls(self) -> pulumi.Output[Optional[Mapping[str, str]]]:
|
|
3197
|
+
def sysctls(self) -> pulumi.Output[Optional[Mapping[str, builtins.str]]]:
|
|
3149
3198
|
"""
|
|
3150
3199
|
A map of kernel parameters (sysctls) to set in the container.
|
|
3151
3200
|
"""
|
|
@@ -3153,7 +3202,7 @@ class Container(pulumi.CustomResource):
|
|
|
3153
3202
|
|
|
3154
3203
|
@property
|
|
3155
3204
|
@pulumi.getter
|
|
3156
|
-
def tmpfs(self) -> pulumi.Output[Optional[Mapping[str, str]]]:
|
|
3205
|
+
def tmpfs(self) -> pulumi.Output[Optional[Mapping[str, builtins.str]]]:
|
|
3157
3206
|
"""
|
|
3158
3207
|
A map of container directories which should be replaced by `tmpfs mounts`, and their corresponding mount options.
|
|
3159
3208
|
"""
|
|
@@ -3161,7 +3210,7 @@ class Container(pulumi.CustomResource):
|
|
|
3161
3210
|
|
|
3162
3211
|
@property
|
|
3163
3212
|
@pulumi.getter
|
|
3164
|
-
def tty(self) -> pulumi.Output[Optional[bool]]:
|
|
3213
|
+
def tty(self) -> pulumi.Output[Optional[builtins.bool]]:
|
|
3165
3214
|
"""
|
|
3166
3215
|
If `true`, allocate a pseudo-tty (`docker run -t`). Defaults to `false`.
|
|
3167
3216
|
"""
|
|
@@ -3185,7 +3234,7 @@ class Container(pulumi.CustomResource):
|
|
|
3185
3234
|
|
|
3186
3235
|
@property
|
|
3187
3236
|
@pulumi.getter
|
|
3188
|
-
def user(self) -> pulumi.Output[Optional[str]]:
|
|
3237
|
+
def user(self) -> pulumi.Output[Optional[builtins.str]]:
|
|
3189
3238
|
"""
|
|
3190
3239
|
User used for run the first process. Format is `user` or `user:group` which user and group can be passed literraly or by name.
|
|
3191
3240
|
"""
|
|
@@ -3193,7 +3242,7 @@ class Container(pulumi.CustomResource):
|
|
|
3193
3242
|
|
|
3194
3243
|
@property
|
|
3195
3244
|
@pulumi.getter(name="usernsMode")
|
|
3196
|
-
def userns_mode(self) -> pulumi.Output[Optional[str]]:
|
|
3245
|
+
def userns_mode(self) -> pulumi.Output[Optional[builtins.str]]:
|
|
3197
3246
|
"""
|
|
3198
3247
|
Sets the usernamespace mode for the container when usernamespace remapping option is enabled.
|
|
3199
3248
|
"""
|
|
@@ -3209,15 +3258,15 @@ class Container(pulumi.CustomResource):
|
|
|
3209
3258
|
|
|
3210
3259
|
@property
|
|
3211
3260
|
@pulumi.getter
|
|
3212
|
-
def wait(self) -> pulumi.Output[Optional[bool]]:
|
|
3261
|
+
def wait(self) -> pulumi.Output[Optional[builtins.bool]]:
|
|
3213
3262
|
"""
|
|
3214
|
-
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`.
|
|
3263
|
+
If `true`, then the Docker container is waited for being healthy state after creation. This requires your container to have a healthcheck, otherwise this provider will error. If `false`, then the container health state is not checked. Defaults to `false`.
|
|
3215
3264
|
"""
|
|
3216
3265
|
return pulumi.get(self, "wait")
|
|
3217
3266
|
|
|
3218
3267
|
@property
|
|
3219
3268
|
@pulumi.getter(name="waitTimeout")
|
|
3220
|
-
def wait_timeout(self) -> pulumi.Output[Optional[int]]:
|
|
3269
|
+
def wait_timeout(self) -> pulumi.Output[Optional[builtins.int]]:
|
|
3221
3270
|
"""
|
|
3222
3271
|
The timeout in seconds to wait the container to be healthy after creation. Defaults to `60`.
|
|
3223
3272
|
"""
|
|
@@ -3225,7 +3274,7 @@ class Container(pulumi.CustomResource):
|
|
|
3225
3274
|
|
|
3226
3275
|
@property
|
|
3227
3276
|
@pulumi.getter(name="workingDir")
|
|
3228
|
-
def working_dir(self) -> pulumi.Output[Optional[str]]:
|
|
3277
|
+
def working_dir(self) -> pulumi.Output[Optional[builtins.str]]:
|
|
3229
3278
|
"""
|
|
3230
3279
|
The working directory for commands to run in.
|
|
3231
3280
|
"""
|