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