pulumi-docker 4.6.0b2__py3-none-any.whl → 4.6.1__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 +0 -11
- pulumi_docker/_inputs.py +1500 -43
- pulumi_docker/_utilities.py +41 -5
- pulumi_docker/config/__init__.pyi +11 -8
- pulumi_docker/config/outputs.py +7 -2
- pulumi_docker/config/vars.py +11 -8
- pulumi_docker/container.py +186 -201
- pulumi_docker/get_logs.py +34 -5
- pulumi_docker/get_network.py +19 -6
- pulumi_docker/get_plugin.py +35 -11
- pulumi_docker/get_registry_image.py +24 -13
- pulumi_docker/get_remote_image.py +22 -5
- pulumi_docker/image.py +64 -54
- pulumi_docker/network.py +69 -64
- pulumi_docker/outputs.py +14 -9
- pulumi_docker/plugin.py +17 -44
- pulumi_docker/provider.py +30 -32
- pulumi_docker/pulumi-plugin.json +2 -1
- pulumi_docker/registry_image.py +19 -46
- pulumi_docker/remote_image.py +107 -48
- pulumi_docker/secret.py +12 -7
- pulumi_docker/service.py +101 -110
- pulumi_docker/service_config.py +31 -26
- pulumi_docker/tag.py +5 -0
- pulumi_docker/volume.py +50 -45
- {pulumi_docker-4.6.0b2.dist-info → pulumi_docker-4.6.1.dist-info}/METADATA +7 -6
- pulumi_docker-4.6.1.dist-info/RECORD +32 -0
- {pulumi_docker-4.6.0b2.dist-info → pulumi_docker-4.6.1.dist-info}/WHEEL +1 -1
- pulumi_docker/buildx/__init__.py +0 -11
- pulumi_docker/buildx/_enums.py +0 -84
- pulumi_docker/buildx/_inputs.py +0 -2638
- pulumi_docker/buildx/image.py +0 -1638
- pulumi_docker/buildx/outputs.py +0 -2366
- pulumi_docker-4.6.0b2.dist-info/RECORD +0 -37
- {pulumi_docker-4.6.0b2.dist-info → pulumi_docker-4.6.1.dist-info}/top_level.txt +0 -0
pulumi_docker/_inputs.py
CHANGED
|
@@ -4,77 +4,159 @@
|
|
|
4
4
|
|
|
5
5
|
import copy
|
|
6
6
|
import warnings
|
|
7
|
+
import sys
|
|
7
8
|
import pulumi
|
|
8
9
|
import pulumi.runtime
|
|
9
10
|
from typing import Any, Mapping, Optional, Sequence, Union, overload
|
|
11
|
+
if sys.version_info >= (3, 11):
|
|
12
|
+
from typing import NotRequired, TypedDict, TypeAlias
|
|
13
|
+
else:
|
|
14
|
+
from typing_extensions import NotRequired, TypedDict, TypeAlias
|
|
10
15
|
from . import _utilities
|
|
11
16
|
from ._enums import *
|
|
12
17
|
|
|
13
18
|
__all__ = [
|
|
14
19
|
'ContainerCapabilitiesArgs',
|
|
20
|
+
'ContainerCapabilitiesArgsDict',
|
|
15
21
|
'ContainerDeviceArgs',
|
|
22
|
+
'ContainerDeviceArgsDict',
|
|
16
23
|
'ContainerHealthcheckArgs',
|
|
24
|
+
'ContainerHealthcheckArgsDict',
|
|
17
25
|
'ContainerHostArgs',
|
|
26
|
+
'ContainerHostArgsDict',
|
|
18
27
|
'ContainerLabelArgs',
|
|
28
|
+
'ContainerLabelArgsDict',
|
|
19
29
|
'ContainerMountArgs',
|
|
30
|
+
'ContainerMountArgsDict',
|
|
20
31
|
'ContainerMountBindOptionsArgs',
|
|
32
|
+
'ContainerMountBindOptionsArgsDict',
|
|
21
33
|
'ContainerMountTmpfsOptionsArgs',
|
|
34
|
+
'ContainerMountTmpfsOptionsArgsDict',
|
|
22
35
|
'ContainerMountVolumeOptionsArgs',
|
|
36
|
+
'ContainerMountVolumeOptionsArgsDict',
|
|
23
37
|
'ContainerMountVolumeOptionsLabelArgs',
|
|
38
|
+
'ContainerMountVolumeOptionsLabelArgsDict',
|
|
24
39
|
'ContainerNetworkDataArgs',
|
|
40
|
+
'ContainerNetworkDataArgsDict',
|
|
25
41
|
'ContainerNetworksAdvancedArgs',
|
|
42
|
+
'ContainerNetworksAdvancedArgsDict',
|
|
26
43
|
'ContainerPortArgs',
|
|
44
|
+
'ContainerPortArgsDict',
|
|
27
45
|
'ContainerUlimitArgs',
|
|
46
|
+
'ContainerUlimitArgsDict',
|
|
28
47
|
'ContainerUploadArgs',
|
|
48
|
+
'ContainerUploadArgsDict',
|
|
29
49
|
'ContainerVolumeArgs',
|
|
50
|
+
'ContainerVolumeArgsDict',
|
|
30
51
|
'NetworkIpamConfigArgs',
|
|
52
|
+
'NetworkIpamConfigArgsDict',
|
|
31
53
|
'NetworkLabelArgs',
|
|
54
|
+
'NetworkLabelArgsDict',
|
|
32
55
|
'PluginGrantPermissionArgs',
|
|
56
|
+
'PluginGrantPermissionArgsDict',
|
|
33
57
|
'ProviderRegistryAuthArgs',
|
|
58
|
+
'ProviderRegistryAuthArgsDict',
|
|
34
59
|
'RemoteImageBuildArgs',
|
|
60
|
+
'RemoteImageBuildArgsDict',
|
|
35
61
|
'RemoteImageBuildAuthConfigArgs',
|
|
62
|
+
'RemoteImageBuildAuthConfigArgsDict',
|
|
36
63
|
'RemoteImageBuildUlimitArgs',
|
|
64
|
+
'RemoteImageBuildUlimitArgsDict',
|
|
37
65
|
'SecretLabelArgs',
|
|
66
|
+
'SecretLabelArgsDict',
|
|
38
67
|
'ServiceAuthArgs',
|
|
68
|
+
'ServiceAuthArgsDict',
|
|
39
69
|
'ServiceConvergeConfigArgs',
|
|
70
|
+
'ServiceConvergeConfigArgsDict',
|
|
40
71
|
'ServiceEndpointSpecArgs',
|
|
72
|
+
'ServiceEndpointSpecArgsDict',
|
|
41
73
|
'ServiceEndpointSpecPortArgs',
|
|
74
|
+
'ServiceEndpointSpecPortArgsDict',
|
|
42
75
|
'ServiceLabelArgs',
|
|
76
|
+
'ServiceLabelArgsDict',
|
|
43
77
|
'ServiceModeArgs',
|
|
78
|
+
'ServiceModeArgsDict',
|
|
44
79
|
'ServiceModeReplicatedArgs',
|
|
80
|
+
'ServiceModeReplicatedArgsDict',
|
|
45
81
|
'ServiceRollbackConfigArgs',
|
|
82
|
+
'ServiceRollbackConfigArgsDict',
|
|
46
83
|
'ServiceTaskSpecArgs',
|
|
84
|
+
'ServiceTaskSpecArgsDict',
|
|
47
85
|
'ServiceTaskSpecContainerSpecArgs',
|
|
86
|
+
'ServiceTaskSpecContainerSpecArgsDict',
|
|
48
87
|
'ServiceTaskSpecContainerSpecConfigArgs',
|
|
88
|
+
'ServiceTaskSpecContainerSpecConfigArgsDict',
|
|
49
89
|
'ServiceTaskSpecContainerSpecDnsConfigArgs',
|
|
90
|
+
'ServiceTaskSpecContainerSpecDnsConfigArgsDict',
|
|
50
91
|
'ServiceTaskSpecContainerSpecHealthcheckArgs',
|
|
92
|
+
'ServiceTaskSpecContainerSpecHealthcheckArgsDict',
|
|
51
93
|
'ServiceTaskSpecContainerSpecHostArgs',
|
|
94
|
+
'ServiceTaskSpecContainerSpecHostArgsDict',
|
|
52
95
|
'ServiceTaskSpecContainerSpecLabelArgs',
|
|
96
|
+
'ServiceTaskSpecContainerSpecLabelArgsDict',
|
|
53
97
|
'ServiceTaskSpecContainerSpecMountArgs',
|
|
98
|
+
'ServiceTaskSpecContainerSpecMountArgsDict',
|
|
54
99
|
'ServiceTaskSpecContainerSpecMountBindOptionsArgs',
|
|
100
|
+
'ServiceTaskSpecContainerSpecMountBindOptionsArgsDict',
|
|
55
101
|
'ServiceTaskSpecContainerSpecMountTmpfsOptionsArgs',
|
|
102
|
+
'ServiceTaskSpecContainerSpecMountTmpfsOptionsArgsDict',
|
|
56
103
|
'ServiceTaskSpecContainerSpecMountVolumeOptionsArgs',
|
|
104
|
+
'ServiceTaskSpecContainerSpecMountVolumeOptionsArgsDict',
|
|
57
105
|
'ServiceTaskSpecContainerSpecMountVolumeOptionsLabelArgs',
|
|
106
|
+
'ServiceTaskSpecContainerSpecMountVolumeOptionsLabelArgsDict',
|
|
58
107
|
'ServiceTaskSpecContainerSpecPrivilegesArgs',
|
|
108
|
+
'ServiceTaskSpecContainerSpecPrivilegesArgsDict',
|
|
59
109
|
'ServiceTaskSpecContainerSpecPrivilegesCredentialSpecArgs',
|
|
110
|
+
'ServiceTaskSpecContainerSpecPrivilegesCredentialSpecArgsDict',
|
|
60
111
|
'ServiceTaskSpecContainerSpecPrivilegesSeLinuxContextArgs',
|
|
112
|
+
'ServiceTaskSpecContainerSpecPrivilegesSeLinuxContextArgsDict',
|
|
61
113
|
'ServiceTaskSpecContainerSpecSecretArgs',
|
|
114
|
+
'ServiceTaskSpecContainerSpecSecretArgsDict',
|
|
62
115
|
'ServiceTaskSpecLogDriverArgs',
|
|
116
|
+
'ServiceTaskSpecLogDriverArgsDict',
|
|
63
117
|
'ServiceTaskSpecNetworksAdvancedArgs',
|
|
118
|
+
'ServiceTaskSpecNetworksAdvancedArgsDict',
|
|
64
119
|
'ServiceTaskSpecPlacementArgs',
|
|
120
|
+
'ServiceTaskSpecPlacementArgsDict',
|
|
65
121
|
'ServiceTaskSpecPlacementPlatformArgs',
|
|
122
|
+
'ServiceTaskSpecPlacementPlatformArgsDict',
|
|
66
123
|
'ServiceTaskSpecResourcesArgs',
|
|
124
|
+
'ServiceTaskSpecResourcesArgsDict',
|
|
67
125
|
'ServiceTaskSpecResourcesLimitsArgs',
|
|
126
|
+
'ServiceTaskSpecResourcesLimitsArgsDict',
|
|
68
127
|
'ServiceTaskSpecResourcesReservationArgs',
|
|
128
|
+
'ServiceTaskSpecResourcesReservationArgsDict',
|
|
69
129
|
'ServiceTaskSpecResourcesReservationGenericResourcesArgs',
|
|
130
|
+
'ServiceTaskSpecResourcesReservationGenericResourcesArgsDict',
|
|
70
131
|
'ServiceTaskSpecRestartPolicyArgs',
|
|
132
|
+
'ServiceTaskSpecRestartPolicyArgsDict',
|
|
71
133
|
'ServiceUpdateConfigArgs',
|
|
134
|
+
'ServiceUpdateConfigArgsDict',
|
|
72
135
|
'VolumeLabelArgs',
|
|
136
|
+
'VolumeLabelArgsDict',
|
|
73
137
|
'CacheFromArgs',
|
|
138
|
+
'CacheFromArgsDict',
|
|
74
139
|
'DockerBuildArgs',
|
|
140
|
+
'DockerBuildArgsDict',
|
|
75
141
|
'RegistryArgs',
|
|
142
|
+
'RegistryArgsDict',
|
|
76
143
|
]
|
|
77
144
|
|
|
145
|
+
MYPY = False
|
|
146
|
+
|
|
147
|
+
if not MYPY:
|
|
148
|
+
class ContainerCapabilitiesArgsDict(TypedDict):
|
|
149
|
+
adds: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
|
|
150
|
+
"""
|
|
151
|
+
List of linux capabilities to add.
|
|
152
|
+
"""
|
|
153
|
+
drops: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
|
|
154
|
+
"""
|
|
155
|
+
List of linux capabilities to drop.
|
|
156
|
+
"""
|
|
157
|
+
elif False:
|
|
158
|
+
ContainerCapabilitiesArgsDict: TypeAlias = Mapping[str, Any]
|
|
159
|
+
|
|
78
160
|
@pulumi.input_type
|
|
79
161
|
class ContainerCapabilitiesArgs:
|
|
80
162
|
def __init__(__self__, *,
|
|
@@ -114,6 +196,23 @@ class ContainerCapabilitiesArgs:
|
|
|
114
196
|
pulumi.set(self, "drops", value)
|
|
115
197
|
|
|
116
198
|
|
|
199
|
+
if not MYPY:
|
|
200
|
+
class ContainerDeviceArgsDict(TypedDict):
|
|
201
|
+
host_path: pulumi.Input[str]
|
|
202
|
+
"""
|
|
203
|
+
The path on the host where the device is located.
|
|
204
|
+
"""
|
|
205
|
+
container_path: NotRequired[pulumi.Input[str]]
|
|
206
|
+
"""
|
|
207
|
+
The path in the container where the device will be bound.
|
|
208
|
+
"""
|
|
209
|
+
permissions: NotRequired[pulumi.Input[str]]
|
|
210
|
+
"""
|
|
211
|
+
The cgroup permissions given to the container to access the device. Defaults to `rwm`.
|
|
212
|
+
"""
|
|
213
|
+
elif False:
|
|
214
|
+
ContainerDeviceArgsDict: TypeAlias = Mapping[str, Any]
|
|
215
|
+
|
|
117
216
|
@pulumi.input_type
|
|
118
217
|
class ContainerDeviceArgs:
|
|
119
218
|
def __init__(__self__, *,
|
|
@@ -168,6 +267,31 @@ class ContainerDeviceArgs:
|
|
|
168
267
|
pulumi.set(self, "permissions", value)
|
|
169
268
|
|
|
170
269
|
|
|
270
|
+
if not MYPY:
|
|
271
|
+
class ContainerHealthcheckArgsDict(TypedDict):
|
|
272
|
+
tests: pulumi.Input[Sequence[pulumi.Input[str]]]
|
|
273
|
+
"""
|
|
274
|
+
Command to run to check health. For example, to run `curl -f localhost/health` set the command to be `["CMD", "curl", "-f", "localhost/health"]`.
|
|
275
|
+
"""
|
|
276
|
+
interval: NotRequired[pulumi.Input[str]]
|
|
277
|
+
"""
|
|
278
|
+
Time between running the check (ms|s|m|h). Defaults to `0s`.
|
|
279
|
+
"""
|
|
280
|
+
retries: NotRequired[pulumi.Input[int]]
|
|
281
|
+
"""
|
|
282
|
+
Consecutive failures needed to report unhealthy. Defaults to `0`.
|
|
283
|
+
"""
|
|
284
|
+
start_period: NotRequired[pulumi.Input[str]]
|
|
285
|
+
"""
|
|
286
|
+
Start period for the container to initialize before counting retries towards unstable (ms|s|m|h). Defaults to `0s`.
|
|
287
|
+
"""
|
|
288
|
+
timeout: NotRequired[pulumi.Input[str]]
|
|
289
|
+
"""
|
|
290
|
+
Maximum time to allow one check to run (ms|s|m|h). Defaults to `0s`.
|
|
291
|
+
"""
|
|
292
|
+
elif False:
|
|
293
|
+
ContainerHealthcheckArgsDict: TypeAlias = Mapping[str, Any]
|
|
294
|
+
|
|
171
295
|
@pulumi.input_type
|
|
172
296
|
class ContainerHealthcheckArgs:
|
|
173
297
|
def __init__(__self__, *,
|
|
@@ -254,6 +378,19 @@ class ContainerHealthcheckArgs:
|
|
|
254
378
|
pulumi.set(self, "timeout", value)
|
|
255
379
|
|
|
256
380
|
|
|
381
|
+
if not MYPY:
|
|
382
|
+
class ContainerHostArgsDict(TypedDict):
|
|
383
|
+
host: pulumi.Input[str]
|
|
384
|
+
"""
|
|
385
|
+
Hostname to add
|
|
386
|
+
"""
|
|
387
|
+
ip: pulumi.Input[str]
|
|
388
|
+
"""
|
|
389
|
+
IP address this hostname should resolve to.
|
|
390
|
+
"""
|
|
391
|
+
elif False:
|
|
392
|
+
ContainerHostArgsDict: TypeAlias = Mapping[str, Any]
|
|
393
|
+
|
|
257
394
|
@pulumi.input_type
|
|
258
395
|
class ContainerHostArgs:
|
|
259
396
|
def __init__(__self__, *,
|
|
@@ -291,6 +428,19 @@ class ContainerHostArgs:
|
|
|
291
428
|
pulumi.set(self, "ip", value)
|
|
292
429
|
|
|
293
430
|
|
|
431
|
+
if not MYPY:
|
|
432
|
+
class ContainerLabelArgsDict(TypedDict):
|
|
433
|
+
label: pulumi.Input[str]
|
|
434
|
+
"""
|
|
435
|
+
Name of the label
|
|
436
|
+
"""
|
|
437
|
+
value: pulumi.Input[str]
|
|
438
|
+
"""
|
|
439
|
+
Value of the label
|
|
440
|
+
"""
|
|
441
|
+
elif False:
|
|
442
|
+
ContainerLabelArgsDict: TypeAlias = Mapping[str, Any]
|
|
443
|
+
|
|
294
444
|
@pulumi.input_type
|
|
295
445
|
class ContainerLabelArgs:
|
|
296
446
|
def __init__(__self__, *,
|
|
@@ -328,6 +478,39 @@ class ContainerLabelArgs:
|
|
|
328
478
|
pulumi.set(self, "value", value)
|
|
329
479
|
|
|
330
480
|
|
|
481
|
+
if not MYPY:
|
|
482
|
+
class ContainerMountArgsDict(TypedDict):
|
|
483
|
+
target: pulumi.Input[str]
|
|
484
|
+
"""
|
|
485
|
+
Container path
|
|
486
|
+
"""
|
|
487
|
+
type: pulumi.Input[str]
|
|
488
|
+
"""
|
|
489
|
+
The mount type
|
|
490
|
+
"""
|
|
491
|
+
bind_options: NotRequired[pulumi.Input['ContainerMountBindOptionsArgsDict']]
|
|
492
|
+
"""
|
|
493
|
+
Optional configuration for the bind type.
|
|
494
|
+
"""
|
|
495
|
+
read_only: NotRequired[pulumi.Input[bool]]
|
|
496
|
+
"""
|
|
497
|
+
Whether the mount should be read-only.
|
|
498
|
+
"""
|
|
499
|
+
source: NotRequired[pulumi.Input[str]]
|
|
500
|
+
"""
|
|
501
|
+
Mount source (e.g. a volume name, a host path).
|
|
502
|
+
"""
|
|
503
|
+
tmpfs_options: NotRequired[pulumi.Input['ContainerMountTmpfsOptionsArgsDict']]
|
|
504
|
+
"""
|
|
505
|
+
Optional configuration for the tmpfs type.
|
|
506
|
+
"""
|
|
507
|
+
volume_options: NotRequired[pulumi.Input['ContainerMountVolumeOptionsArgsDict']]
|
|
508
|
+
"""
|
|
509
|
+
Optional configuration for the volume type.
|
|
510
|
+
"""
|
|
511
|
+
elif False:
|
|
512
|
+
ContainerMountArgsDict: TypeAlias = Mapping[str, Any]
|
|
513
|
+
|
|
331
514
|
@pulumi.input_type
|
|
332
515
|
class ContainerMountArgs:
|
|
333
516
|
def __init__(__self__, *,
|
|
@@ -445,6 +628,15 @@ class ContainerMountArgs:
|
|
|
445
628
|
pulumi.set(self, "volume_options", value)
|
|
446
629
|
|
|
447
630
|
|
|
631
|
+
if not MYPY:
|
|
632
|
+
class ContainerMountBindOptionsArgsDict(TypedDict):
|
|
633
|
+
propagation: NotRequired[pulumi.Input[str]]
|
|
634
|
+
"""
|
|
635
|
+
A propagation mode with the value.
|
|
636
|
+
"""
|
|
637
|
+
elif False:
|
|
638
|
+
ContainerMountBindOptionsArgsDict: TypeAlias = Mapping[str, Any]
|
|
639
|
+
|
|
448
640
|
@pulumi.input_type
|
|
449
641
|
class ContainerMountBindOptionsArgs:
|
|
450
642
|
def __init__(__self__, *,
|
|
@@ -468,6 +660,19 @@ class ContainerMountBindOptionsArgs:
|
|
|
468
660
|
pulumi.set(self, "propagation", value)
|
|
469
661
|
|
|
470
662
|
|
|
663
|
+
if not MYPY:
|
|
664
|
+
class ContainerMountTmpfsOptionsArgsDict(TypedDict):
|
|
665
|
+
mode: NotRequired[pulumi.Input[int]]
|
|
666
|
+
"""
|
|
667
|
+
The permission mode for the tmpfs mount in an integer.
|
|
668
|
+
"""
|
|
669
|
+
size_bytes: NotRequired[pulumi.Input[int]]
|
|
670
|
+
"""
|
|
671
|
+
The size for the tmpfs mount in bytes.
|
|
672
|
+
"""
|
|
673
|
+
elif False:
|
|
674
|
+
ContainerMountTmpfsOptionsArgsDict: TypeAlias = Mapping[str, Any]
|
|
675
|
+
|
|
471
676
|
@pulumi.input_type
|
|
472
677
|
class ContainerMountTmpfsOptionsArgs:
|
|
473
678
|
def __init__(__self__, *,
|
|
@@ -507,6 +712,27 @@ class ContainerMountTmpfsOptionsArgs:
|
|
|
507
712
|
pulumi.set(self, "size_bytes", value)
|
|
508
713
|
|
|
509
714
|
|
|
715
|
+
if not MYPY:
|
|
716
|
+
class ContainerMountVolumeOptionsArgsDict(TypedDict):
|
|
717
|
+
driver_name: NotRequired[pulumi.Input[str]]
|
|
718
|
+
"""
|
|
719
|
+
Name of the driver to use to create the volume.
|
|
720
|
+
"""
|
|
721
|
+
driver_options: NotRequired[pulumi.Input[Mapping[str, pulumi.Input[str]]]]
|
|
722
|
+
"""
|
|
723
|
+
key/value map of driver specific options.
|
|
724
|
+
"""
|
|
725
|
+
labels: NotRequired[pulumi.Input[Sequence[pulumi.Input['ContainerMountVolumeOptionsLabelArgsDict']]]]
|
|
726
|
+
"""
|
|
727
|
+
User-defined key/value metadata.
|
|
728
|
+
"""
|
|
729
|
+
no_copy: NotRequired[pulumi.Input[bool]]
|
|
730
|
+
"""
|
|
731
|
+
Populate volume with data from the target.
|
|
732
|
+
"""
|
|
733
|
+
elif False:
|
|
734
|
+
ContainerMountVolumeOptionsArgsDict: TypeAlias = Mapping[str, Any]
|
|
735
|
+
|
|
510
736
|
@pulumi.input_type
|
|
511
737
|
class ContainerMountVolumeOptionsArgs:
|
|
512
738
|
def __init__(__self__, *,
|
|
@@ -578,6 +804,19 @@ class ContainerMountVolumeOptionsArgs:
|
|
|
578
804
|
pulumi.set(self, "no_copy", value)
|
|
579
805
|
|
|
580
806
|
|
|
807
|
+
if not MYPY:
|
|
808
|
+
class ContainerMountVolumeOptionsLabelArgsDict(TypedDict):
|
|
809
|
+
label: pulumi.Input[str]
|
|
810
|
+
"""
|
|
811
|
+
Name of the label
|
|
812
|
+
"""
|
|
813
|
+
value: pulumi.Input[str]
|
|
814
|
+
"""
|
|
815
|
+
Value of the label
|
|
816
|
+
"""
|
|
817
|
+
elif False:
|
|
818
|
+
ContainerMountVolumeOptionsLabelArgsDict: TypeAlias = Mapping[str, Any]
|
|
819
|
+
|
|
581
820
|
@pulumi.input_type
|
|
582
821
|
class ContainerMountVolumeOptionsLabelArgs:
|
|
583
822
|
def __init__(__self__, *,
|
|
@@ -615,6 +854,43 @@ class ContainerMountVolumeOptionsLabelArgs:
|
|
|
615
854
|
pulumi.set(self, "value", value)
|
|
616
855
|
|
|
617
856
|
|
|
857
|
+
if not MYPY:
|
|
858
|
+
class ContainerNetworkDataArgsDict(TypedDict):
|
|
859
|
+
gateway: NotRequired[pulumi.Input[str]]
|
|
860
|
+
"""
|
|
861
|
+
The network gateway of the container.
|
|
862
|
+
"""
|
|
863
|
+
global_ipv6_address: NotRequired[pulumi.Input[str]]
|
|
864
|
+
"""
|
|
865
|
+
The IPV6 address of the container.
|
|
866
|
+
"""
|
|
867
|
+
global_ipv6_prefix_length: NotRequired[pulumi.Input[int]]
|
|
868
|
+
"""
|
|
869
|
+
The IPV6 prefix length address of the container.
|
|
870
|
+
"""
|
|
871
|
+
ip_address: NotRequired[pulumi.Input[str]]
|
|
872
|
+
"""
|
|
873
|
+
The IP address of the container.
|
|
874
|
+
"""
|
|
875
|
+
ip_prefix_length: NotRequired[pulumi.Input[int]]
|
|
876
|
+
"""
|
|
877
|
+
The IP prefix length of the container.
|
|
878
|
+
"""
|
|
879
|
+
ipv6_gateway: NotRequired[pulumi.Input[str]]
|
|
880
|
+
"""
|
|
881
|
+
The IPV6 gateway of the container.
|
|
882
|
+
"""
|
|
883
|
+
mac_address: NotRequired[pulumi.Input[str]]
|
|
884
|
+
"""
|
|
885
|
+
The MAC address of the container.
|
|
886
|
+
"""
|
|
887
|
+
network_name: NotRequired[pulumi.Input[str]]
|
|
888
|
+
"""
|
|
889
|
+
The name of the network
|
|
890
|
+
"""
|
|
891
|
+
elif False:
|
|
892
|
+
ContainerNetworkDataArgsDict: TypeAlias = Mapping[str, Any]
|
|
893
|
+
|
|
618
894
|
@pulumi.input_type
|
|
619
895
|
class ContainerNetworkDataArgs:
|
|
620
896
|
def __init__(__self__, *,
|
|
@@ -750,6 +1026,27 @@ class ContainerNetworkDataArgs:
|
|
|
750
1026
|
pulumi.set(self, "network_name", value)
|
|
751
1027
|
|
|
752
1028
|
|
|
1029
|
+
if not MYPY:
|
|
1030
|
+
class ContainerNetworksAdvancedArgsDict(TypedDict):
|
|
1031
|
+
name: pulumi.Input[str]
|
|
1032
|
+
"""
|
|
1033
|
+
The name or id of the network to use. You can use `name` or `id` attribute from a `Network` resource.
|
|
1034
|
+
"""
|
|
1035
|
+
aliases: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
|
|
1036
|
+
"""
|
|
1037
|
+
The network aliases of the container in the specific network.
|
|
1038
|
+
"""
|
|
1039
|
+
ipv4_address: NotRequired[pulumi.Input[str]]
|
|
1040
|
+
"""
|
|
1041
|
+
The IPV4 address of the container in the specific network.
|
|
1042
|
+
"""
|
|
1043
|
+
ipv6_address: NotRequired[pulumi.Input[str]]
|
|
1044
|
+
"""
|
|
1045
|
+
The IPV6 address of the container in the specific network.
|
|
1046
|
+
"""
|
|
1047
|
+
elif False:
|
|
1048
|
+
ContainerNetworksAdvancedArgsDict: TypeAlias = Mapping[str, Any]
|
|
1049
|
+
|
|
753
1050
|
@pulumi.input_type
|
|
754
1051
|
class ContainerNetworksAdvancedArgs:
|
|
755
1052
|
def __init__(__self__, *,
|
|
@@ -820,6 +1117,27 @@ class ContainerNetworksAdvancedArgs:
|
|
|
820
1117
|
pulumi.set(self, "ipv6_address", value)
|
|
821
1118
|
|
|
822
1119
|
|
|
1120
|
+
if not MYPY:
|
|
1121
|
+
class ContainerPortArgsDict(TypedDict):
|
|
1122
|
+
internal: pulumi.Input[int]
|
|
1123
|
+
"""
|
|
1124
|
+
Port within the container.
|
|
1125
|
+
"""
|
|
1126
|
+
external: NotRequired[pulumi.Input[int]]
|
|
1127
|
+
"""
|
|
1128
|
+
Port exposed out of the container. If not given a free random port `>= 32768` will be used.
|
|
1129
|
+
"""
|
|
1130
|
+
ip: NotRequired[pulumi.Input[str]]
|
|
1131
|
+
"""
|
|
1132
|
+
IP address/mask that can access this port. Defaults to `0.0.0.0`.
|
|
1133
|
+
"""
|
|
1134
|
+
protocol: NotRequired[pulumi.Input[str]]
|
|
1135
|
+
"""
|
|
1136
|
+
Protocol that can be used over this port. Defaults to `tcp`.
|
|
1137
|
+
"""
|
|
1138
|
+
elif False:
|
|
1139
|
+
ContainerPortArgsDict: TypeAlias = Mapping[str, Any]
|
|
1140
|
+
|
|
823
1141
|
@pulumi.input_type
|
|
824
1142
|
class ContainerPortArgs:
|
|
825
1143
|
def __init__(__self__, *,
|
|
@@ -890,6 +1208,23 @@ class ContainerPortArgs:
|
|
|
890
1208
|
pulumi.set(self, "protocol", value)
|
|
891
1209
|
|
|
892
1210
|
|
|
1211
|
+
if not MYPY:
|
|
1212
|
+
class ContainerUlimitArgsDict(TypedDict):
|
|
1213
|
+
hard: pulumi.Input[int]
|
|
1214
|
+
"""
|
|
1215
|
+
The hard limit
|
|
1216
|
+
"""
|
|
1217
|
+
name: pulumi.Input[str]
|
|
1218
|
+
"""
|
|
1219
|
+
The name of the ulimit
|
|
1220
|
+
"""
|
|
1221
|
+
soft: pulumi.Input[int]
|
|
1222
|
+
"""
|
|
1223
|
+
The soft limit
|
|
1224
|
+
"""
|
|
1225
|
+
elif False:
|
|
1226
|
+
ContainerUlimitArgsDict: TypeAlias = Mapping[str, Any]
|
|
1227
|
+
|
|
893
1228
|
@pulumi.input_type
|
|
894
1229
|
class ContainerUlimitArgs:
|
|
895
1230
|
def __init__(__self__, *,
|
|
@@ -942,6 +1277,35 @@ class ContainerUlimitArgs:
|
|
|
942
1277
|
pulumi.set(self, "soft", value)
|
|
943
1278
|
|
|
944
1279
|
|
|
1280
|
+
if not MYPY:
|
|
1281
|
+
class ContainerUploadArgsDict(TypedDict):
|
|
1282
|
+
file: pulumi.Input[str]
|
|
1283
|
+
"""
|
|
1284
|
+
Path to the file in the container where is upload goes to
|
|
1285
|
+
"""
|
|
1286
|
+
content: NotRequired[pulumi.Input[str]]
|
|
1287
|
+
"""
|
|
1288
|
+
Literal string value to use as the object content, which will be uploaded as UTF-8-encoded text. Conflicts with `content_base64` & `source`
|
|
1289
|
+
"""
|
|
1290
|
+
content_base64: NotRequired[pulumi.Input[str]]
|
|
1291
|
+
"""
|
|
1292
|
+
Base64-encoded data that will be decoded and uploaded as raw bytes for the object content. This allows safely uploading non-UTF8 binary data, but is recommended only for larger binary content such as the result of the `base64encode` interpolation function. See here for the reason. Conflicts with `content` & `source`
|
|
1293
|
+
"""
|
|
1294
|
+
executable: NotRequired[pulumi.Input[bool]]
|
|
1295
|
+
"""
|
|
1296
|
+
If `true`, the file will be uploaded with user executable permission. Defaults to `false`.
|
|
1297
|
+
"""
|
|
1298
|
+
source: NotRequired[pulumi.Input[str]]
|
|
1299
|
+
"""
|
|
1300
|
+
A filename that references a file which will be uploaded as the object content. This allows for large file uploads that do not get stored in state. Conflicts with `content` & `content_base64`
|
|
1301
|
+
"""
|
|
1302
|
+
source_hash: NotRequired[pulumi.Input[str]]
|
|
1303
|
+
"""
|
|
1304
|
+
If using `source`, this will force an update if the file content has updated but the filename has not.
|
|
1305
|
+
"""
|
|
1306
|
+
elif False:
|
|
1307
|
+
ContainerUploadArgsDict: TypeAlias = Mapping[str, Any]
|
|
1308
|
+
|
|
945
1309
|
@pulumi.input_type
|
|
946
1310
|
class ContainerUploadArgs:
|
|
947
1311
|
def __init__(__self__, *,
|
|
@@ -1044,6 +1408,31 @@ class ContainerUploadArgs:
|
|
|
1044
1408
|
pulumi.set(self, "source_hash", value)
|
|
1045
1409
|
|
|
1046
1410
|
|
|
1411
|
+
if not MYPY:
|
|
1412
|
+
class ContainerVolumeArgsDict(TypedDict):
|
|
1413
|
+
container_path: NotRequired[pulumi.Input[str]]
|
|
1414
|
+
"""
|
|
1415
|
+
The path in the container where the volume will be mounted.
|
|
1416
|
+
"""
|
|
1417
|
+
from_container: NotRequired[pulumi.Input[str]]
|
|
1418
|
+
"""
|
|
1419
|
+
The container where the volume is coming from.
|
|
1420
|
+
"""
|
|
1421
|
+
host_path: NotRequired[pulumi.Input[str]]
|
|
1422
|
+
"""
|
|
1423
|
+
The path on the host where the volume is coming from.
|
|
1424
|
+
"""
|
|
1425
|
+
read_only: NotRequired[pulumi.Input[bool]]
|
|
1426
|
+
"""
|
|
1427
|
+
If `true`, this volume will be readonly. Defaults to `false`.
|
|
1428
|
+
"""
|
|
1429
|
+
volume_name: NotRequired[pulumi.Input[str]]
|
|
1430
|
+
"""
|
|
1431
|
+
The name of the docker volume which should be mounted.
|
|
1432
|
+
"""
|
|
1433
|
+
elif False:
|
|
1434
|
+
ContainerVolumeArgsDict: TypeAlias = Mapping[str, Any]
|
|
1435
|
+
|
|
1047
1436
|
@pulumi.input_type
|
|
1048
1437
|
class ContainerVolumeArgs:
|
|
1049
1438
|
def __init__(__self__, *,
|
|
@@ -1131,15 +1520,36 @@ class ContainerVolumeArgs:
|
|
|
1131
1520
|
pulumi.set(self, "volume_name", value)
|
|
1132
1521
|
|
|
1133
1522
|
|
|
1523
|
+
if not MYPY:
|
|
1524
|
+
class NetworkIpamConfigArgsDict(TypedDict):
|
|
1525
|
+
aux_address: NotRequired[pulumi.Input[Mapping[str, pulumi.Input[str]]]]
|
|
1526
|
+
"""
|
|
1527
|
+
Auxiliary IPv4 or IPv6 addresses used by Network driver
|
|
1528
|
+
"""
|
|
1529
|
+
gateway: NotRequired[pulumi.Input[str]]
|
|
1530
|
+
"""
|
|
1531
|
+
The IP address of the gateway
|
|
1532
|
+
"""
|
|
1533
|
+
ip_range: NotRequired[pulumi.Input[str]]
|
|
1534
|
+
"""
|
|
1535
|
+
The ip range in CIDR form
|
|
1536
|
+
"""
|
|
1537
|
+
subnet: NotRequired[pulumi.Input[str]]
|
|
1538
|
+
"""
|
|
1539
|
+
The subnet in CIDR form
|
|
1540
|
+
"""
|
|
1541
|
+
elif False:
|
|
1542
|
+
NetworkIpamConfigArgsDict: TypeAlias = Mapping[str, Any]
|
|
1543
|
+
|
|
1134
1544
|
@pulumi.input_type
|
|
1135
1545
|
class NetworkIpamConfigArgs:
|
|
1136
1546
|
def __init__(__self__, *,
|
|
1137
|
-
aux_address: Optional[pulumi.Input[Mapping[str,
|
|
1547
|
+
aux_address: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None,
|
|
1138
1548
|
gateway: Optional[pulumi.Input[str]] = None,
|
|
1139
1549
|
ip_range: Optional[pulumi.Input[str]] = None,
|
|
1140
1550
|
subnet: Optional[pulumi.Input[str]] = None):
|
|
1141
1551
|
"""
|
|
1142
|
-
:param pulumi.Input[Mapping[str,
|
|
1552
|
+
:param pulumi.Input[Mapping[str, pulumi.Input[str]]] aux_address: Auxiliary IPv4 or IPv6 addresses used by Network driver
|
|
1143
1553
|
:param pulumi.Input[str] gateway: The IP address of the gateway
|
|
1144
1554
|
:param pulumi.Input[str] ip_range: The ip range in CIDR form
|
|
1145
1555
|
:param pulumi.Input[str] subnet: The subnet in CIDR form
|
|
@@ -1155,14 +1565,14 @@ class NetworkIpamConfigArgs:
|
|
|
1155
1565
|
|
|
1156
1566
|
@property
|
|
1157
1567
|
@pulumi.getter(name="auxAddress")
|
|
1158
|
-
def aux_address(self) -> Optional[pulumi.Input[Mapping[str,
|
|
1568
|
+
def aux_address(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]:
|
|
1159
1569
|
"""
|
|
1160
1570
|
Auxiliary IPv4 or IPv6 addresses used by Network driver
|
|
1161
1571
|
"""
|
|
1162
1572
|
return pulumi.get(self, "aux_address")
|
|
1163
1573
|
|
|
1164
1574
|
@aux_address.setter
|
|
1165
|
-
def aux_address(self, value: Optional[pulumi.Input[Mapping[str,
|
|
1575
|
+
def aux_address(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]):
|
|
1166
1576
|
pulumi.set(self, "aux_address", value)
|
|
1167
1577
|
|
|
1168
1578
|
@property
|
|
@@ -1202,6 +1612,19 @@ class NetworkIpamConfigArgs:
|
|
|
1202
1612
|
pulumi.set(self, "subnet", value)
|
|
1203
1613
|
|
|
1204
1614
|
|
|
1615
|
+
if not MYPY:
|
|
1616
|
+
class NetworkLabelArgsDict(TypedDict):
|
|
1617
|
+
label: pulumi.Input[str]
|
|
1618
|
+
"""
|
|
1619
|
+
Name of the label
|
|
1620
|
+
"""
|
|
1621
|
+
value: pulumi.Input[str]
|
|
1622
|
+
"""
|
|
1623
|
+
Value of the label
|
|
1624
|
+
"""
|
|
1625
|
+
elif False:
|
|
1626
|
+
NetworkLabelArgsDict: TypeAlias = Mapping[str, Any]
|
|
1627
|
+
|
|
1205
1628
|
@pulumi.input_type
|
|
1206
1629
|
class NetworkLabelArgs:
|
|
1207
1630
|
def __init__(__self__, *,
|
|
@@ -1239,6 +1662,19 @@ class NetworkLabelArgs:
|
|
|
1239
1662
|
pulumi.set(self, "value", value)
|
|
1240
1663
|
|
|
1241
1664
|
|
|
1665
|
+
if not MYPY:
|
|
1666
|
+
class PluginGrantPermissionArgsDict(TypedDict):
|
|
1667
|
+
name: pulumi.Input[str]
|
|
1668
|
+
"""
|
|
1669
|
+
The name of the permission
|
|
1670
|
+
"""
|
|
1671
|
+
values: pulumi.Input[Sequence[pulumi.Input[str]]]
|
|
1672
|
+
"""
|
|
1673
|
+
The value of the permission
|
|
1674
|
+
"""
|
|
1675
|
+
elif False:
|
|
1676
|
+
PluginGrantPermissionArgsDict: TypeAlias = Mapping[str, Any]
|
|
1677
|
+
|
|
1242
1678
|
@pulumi.input_type
|
|
1243
1679
|
class PluginGrantPermissionArgs:
|
|
1244
1680
|
def __init__(__self__, *,
|
|
@@ -1276,6 +1712,32 @@ class PluginGrantPermissionArgs:
|
|
|
1276
1712
|
pulumi.set(self, "values", value)
|
|
1277
1713
|
|
|
1278
1714
|
|
|
1715
|
+
if not MYPY:
|
|
1716
|
+
class ProviderRegistryAuthArgsDict(TypedDict):
|
|
1717
|
+
address: pulumi.Input[str]
|
|
1718
|
+
"""
|
|
1719
|
+
Address of the registry
|
|
1720
|
+
"""
|
|
1721
|
+
auth_disabled: NotRequired[pulumi.Input[bool]]
|
|
1722
|
+
config_file: NotRequired[pulumi.Input[str]]
|
|
1723
|
+
"""
|
|
1724
|
+
Path to docker json file for registry auth. Defaults to `~/.docker/config.json`. If `DOCKER_CONFIG` is set, the value of `DOCKER_CONFIG` is used as the path. `config_file` has predencen over all other options.
|
|
1725
|
+
"""
|
|
1726
|
+
config_file_content: NotRequired[pulumi.Input[str]]
|
|
1727
|
+
"""
|
|
1728
|
+
Plain content of the docker json file for registry auth. `config_file_content` has precedence over username/password.
|
|
1729
|
+
"""
|
|
1730
|
+
password: NotRequired[pulumi.Input[str]]
|
|
1731
|
+
"""
|
|
1732
|
+
Password for the registry. Defaults to `DOCKER_REGISTRY_PASS` env variable if set.
|
|
1733
|
+
"""
|
|
1734
|
+
username: NotRequired[pulumi.Input[str]]
|
|
1735
|
+
"""
|
|
1736
|
+
Username for the registry. Defaults to `DOCKER_REGISTRY_USER` env variable if set.
|
|
1737
|
+
"""
|
|
1738
|
+
elif False:
|
|
1739
|
+
ProviderRegistryAuthArgsDict: TypeAlias = Mapping[str, Any]
|
|
1740
|
+
|
|
1279
1741
|
@pulumi.input_type
|
|
1280
1742
|
class ProviderRegistryAuthArgs:
|
|
1281
1743
|
def __init__(__self__, *,
|
|
@@ -1286,7 +1748,7 @@ class ProviderRegistryAuthArgs:
|
|
|
1286
1748
|
password: Optional[pulumi.Input[str]] = None,
|
|
1287
1749
|
username: Optional[pulumi.Input[str]] = None):
|
|
1288
1750
|
"""
|
|
1289
|
-
:param pulumi.Input[str] address: Address of the registry
|
|
1751
|
+
:param pulumi.Input[str] address: Address of the registry
|
|
1290
1752
|
:param pulumi.Input[str] config_file: Path to docker json file for registry auth. Defaults to `~/.docker/config.json`. If `DOCKER_CONFIG` is set, the value of `DOCKER_CONFIG` is used as the path. `config_file` has predencen over all other options.
|
|
1291
1753
|
:param pulumi.Input[str] config_file_content: Plain content of the docker json file for registry auth. `config_file_content` has precedence over username/password.
|
|
1292
1754
|
:param pulumi.Input[str] password: Password for the registry. Defaults to `DOCKER_REGISTRY_PASS` env variable if set.
|
|
@@ -1308,7 +1770,7 @@ class ProviderRegistryAuthArgs:
|
|
|
1308
1770
|
@pulumi.getter
|
|
1309
1771
|
def address(self) -> pulumi.Input[str]:
|
|
1310
1772
|
"""
|
|
1311
|
-
Address of the registry
|
|
1773
|
+
Address of the registry
|
|
1312
1774
|
"""
|
|
1313
1775
|
return pulumi.get(self, "address")
|
|
1314
1776
|
|
|
@@ -1374,23 +1836,168 @@ class ProviderRegistryAuthArgs:
|
|
|
1374
1836
|
pulumi.set(self, "username", value)
|
|
1375
1837
|
|
|
1376
1838
|
|
|
1377
|
-
|
|
1378
|
-
class
|
|
1379
|
-
|
|
1380
|
-
|
|
1381
|
-
|
|
1382
|
-
|
|
1383
|
-
|
|
1384
|
-
|
|
1385
|
-
|
|
1386
|
-
|
|
1387
|
-
|
|
1388
|
-
|
|
1389
|
-
|
|
1390
|
-
|
|
1391
|
-
|
|
1392
|
-
|
|
1393
|
-
|
|
1839
|
+
if not MYPY:
|
|
1840
|
+
class RemoteImageBuildArgsDict(TypedDict):
|
|
1841
|
+
context: pulumi.Input[str]
|
|
1842
|
+
"""
|
|
1843
|
+
Value to specify the build context. Currently, only a `PATH` context is supported. You can use the helper function '${path.cwd}/context-dir'. Please see https://docs.docker.com/build/building/context/ for more information about build contexts.
|
|
1844
|
+
"""
|
|
1845
|
+
auth_configs: NotRequired[pulumi.Input[Sequence[pulumi.Input['RemoteImageBuildAuthConfigArgsDict']]]]
|
|
1846
|
+
"""
|
|
1847
|
+
The configuration for the authentication
|
|
1848
|
+
"""
|
|
1849
|
+
build_arg: NotRequired[pulumi.Input[Mapping[str, pulumi.Input[str]]]]
|
|
1850
|
+
"""
|
|
1851
|
+
Set build-time variables
|
|
1852
|
+
"""
|
|
1853
|
+
build_args: NotRequired[pulumi.Input[Mapping[str, pulumi.Input[str]]]]
|
|
1854
|
+
"""
|
|
1855
|
+
Pairs for build-time variables in the form TODO
|
|
1856
|
+
"""
|
|
1857
|
+
build_id: NotRequired[pulumi.Input[str]]
|
|
1858
|
+
"""
|
|
1859
|
+
BuildID is an optional identifier that can be passed together with the build request. The same identifier can be used to gracefully cancel the build with the cancel request.
|
|
1860
|
+
"""
|
|
1861
|
+
cache_froms: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
|
|
1862
|
+
"""
|
|
1863
|
+
Images to consider as cache sources
|
|
1864
|
+
"""
|
|
1865
|
+
cgroup_parent: NotRequired[pulumi.Input[str]]
|
|
1866
|
+
"""
|
|
1867
|
+
Optional parent cgroup for the container
|
|
1868
|
+
"""
|
|
1869
|
+
cpu_period: NotRequired[pulumi.Input[int]]
|
|
1870
|
+
"""
|
|
1871
|
+
The length of a CPU period in microseconds
|
|
1872
|
+
"""
|
|
1873
|
+
cpu_quota: NotRequired[pulumi.Input[int]]
|
|
1874
|
+
"""
|
|
1875
|
+
Microseconds of CPU time that the container can get in a CPU period
|
|
1876
|
+
"""
|
|
1877
|
+
cpu_set_cpus: NotRequired[pulumi.Input[str]]
|
|
1878
|
+
"""
|
|
1879
|
+
CPUs in which to allow execution (e.g., `0-3`, `0`, `1`)
|
|
1880
|
+
"""
|
|
1881
|
+
cpu_set_mems: NotRequired[pulumi.Input[str]]
|
|
1882
|
+
"""
|
|
1883
|
+
MEMs in which to allow execution (`0-3`, `0`, `1`)
|
|
1884
|
+
"""
|
|
1885
|
+
cpu_shares: NotRequired[pulumi.Input[int]]
|
|
1886
|
+
"""
|
|
1887
|
+
CPU shares (relative weight)
|
|
1888
|
+
"""
|
|
1889
|
+
dockerfile: NotRequired[pulumi.Input[str]]
|
|
1890
|
+
"""
|
|
1891
|
+
Name of the Dockerfile. Defaults to `Dockerfile`.
|
|
1892
|
+
"""
|
|
1893
|
+
extra_hosts: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
|
|
1894
|
+
"""
|
|
1895
|
+
A list of hostnames/IP mappings to add to the container’s /etc/hosts file. Specified in the form ["hostname:IP"]
|
|
1896
|
+
"""
|
|
1897
|
+
force_remove: NotRequired[pulumi.Input[bool]]
|
|
1898
|
+
"""
|
|
1899
|
+
Always remove intermediate containers
|
|
1900
|
+
"""
|
|
1901
|
+
isolation: NotRequired[pulumi.Input[str]]
|
|
1902
|
+
"""
|
|
1903
|
+
Isolation represents the isolation technology of a container. The supported values are
|
|
1904
|
+
"""
|
|
1905
|
+
label: NotRequired[pulumi.Input[Mapping[str, pulumi.Input[str]]]]
|
|
1906
|
+
"""
|
|
1907
|
+
Set metadata for an image
|
|
1908
|
+
"""
|
|
1909
|
+
labels: NotRequired[pulumi.Input[Mapping[str, pulumi.Input[str]]]]
|
|
1910
|
+
"""
|
|
1911
|
+
User-defined key/value metadata
|
|
1912
|
+
"""
|
|
1913
|
+
memory: NotRequired[pulumi.Input[int]]
|
|
1914
|
+
"""
|
|
1915
|
+
Set memory limit for build
|
|
1916
|
+
"""
|
|
1917
|
+
memory_swap: NotRequired[pulumi.Input[int]]
|
|
1918
|
+
"""
|
|
1919
|
+
Total memory (memory + swap), -1 to enable unlimited swap
|
|
1920
|
+
"""
|
|
1921
|
+
network_mode: NotRequired[pulumi.Input[str]]
|
|
1922
|
+
"""
|
|
1923
|
+
Set the networking mode for the RUN instructions during build
|
|
1924
|
+
"""
|
|
1925
|
+
no_cache: NotRequired[pulumi.Input[bool]]
|
|
1926
|
+
"""
|
|
1927
|
+
Do not use the cache when building the image
|
|
1928
|
+
"""
|
|
1929
|
+
platform: NotRequired[pulumi.Input[str]]
|
|
1930
|
+
"""
|
|
1931
|
+
Set platform if server is multi-platform capable
|
|
1932
|
+
"""
|
|
1933
|
+
pull_parent: NotRequired[pulumi.Input[bool]]
|
|
1934
|
+
"""
|
|
1935
|
+
Attempt to pull the image even if an older image exists locally
|
|
1936
|
+
"""
|
|
1937
|
+
remote_context: NotRequired[pulumi.Input[str]]
|
|
1938
|
+
"""
|
|
1939
|
+
A Git repository URI or HTTP/HTTPS context URI
|
|
1940
|
+
"""
|
|
1941
|
+
remove: NotRequired[pulumi.Input[bool]]
|
|
1942
|
+
"""
|
|
1943
|
+
Remove intermediate containers after a successful build. Defaults to `true`.
|
|
1944
|
+
"""
|
|
1945
|
+
security_opts: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
|
|
1946
|
+
"""
|
|
1947
|
+
The security options
|
|
1948
|
+
"""
|
|
1949
|
+
session_id: NotRequired[pulumi.Input[str]]
|
|
1950
|
+
"""
|
|
1951
|
+
Set an ID for the build session
|
|
1952
|
+
"""
|
|
1953
|
+
shm_size: NotRequired[pulumi.Input[int]]
|
|
1954
|
+
"""
|
|
1955
|
+
Size of /dev/shm in bytes. The size must be greater than 0
|
|
1956
|
+
"""
|
|
1957
|
+
squash: NotRequired[pulumi.Input[bool]]
|
|
1958
|
+
"""
|
|
1959
|
+
If true the new layers are squashed into a new image with a single new layer
|
|
1960
|
+
"""
|
|
1961
|
+
suppress_output: NotRequired[pulumi.Input[bool]]
|
|
1962
|
+
"""
|
|
1963
|
+
Suppress the build output and print image ID on success
|
|
1964
|
+
"""
|
|
1965
|
+
tags: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
|
|
1966
|
+
"""
|
|
1967
|
+
Name and optionally a tag in the 'name:tag' format
|
|
1968
|
+
"""
|
|
1969
|
+
target: NotRequired[pulumi.Input[str]]
|
|
1970
|
+
"""
|
|
1971
|
+
Set the target build stage to build
|
|
1972
|
+
"""
|
|
1973
|
+
ulimits: NotRequired[pulumi.Input[Sequence[pulumi.Input['RemoteImageBuildUlimitArgsDict']]]]
|
|
1974
|
+
"""
|
|
1975
|
+
Configuration for ulimits
|
|
1976
|
+
"""
|
|
1977
|
+
version: NotRequired[pulumi.Input[str]]
|
|
1978
|
+
"""
|
|
1979
|
+
Version of the underlying builder to use
|
|
1980
|
+
"""
|
|
1981
|
+
elif False:
|
|
1982
|
+
RemoteImageBuildArgsDict: TypeAlias = Mapping[str, Any]
|
|
1983
|
+
|
|
1984
|
+
@pulumi.input_type
|
|
1985
|
+
class RemoteImageBuildArgs:
|
|
1986
|
+
def __init__(__self__, *,
|
|
1987
|
+
context: pulumi.Input[str],
|
|
1988
|
+
auth_configs: Optional[pulumi.Input[Sequence[pulumi.Input['RemoteImageBuildAuthConfigArgs']]]] = None,
|
|
1989
|
+
build_arg: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None,
|
|
1990
|
+
build_args: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None,
|
|
1991
|
+
build_id: Optional[pulumi.Input[str]] = None,
|
|
1992
|
+
cache_froms: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
|
|
1993
|
+
cgroup_parent: Optional[pulumi.Input[str]] = None,
|
|
1994
|
+
cpu_period: Optional[pulumi.Input[int]] = None,
|
|
1995
|
+
cpu_quota: Optional[pulumi.Input[int]] = None,
|
|
1996
|
+
cpu_set_cpus: Optional[pulumi.Input[str]] = None,
|
|
1997
|
+
cpu_set_mems: Optional[pulumi.Input[str]] = None,
|
|
1998
|
+
cpu_shares: Optional[pulumi.Input[int]] = None,
|
|
1999
|
+
dockerfile: Optional[pulumi.Input[str]] = None,
|
|
2000
|
+
extra_hosts: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
|
|
1394
2001
|
force_remove: Optional[pulumi.Input[bool]] = None,
|
|
1395
2002
|
isolation: Optional[pulumi.Input[str]] = None,
|
|
1396
2003
|
label: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None,
|
|
@@ -1940,6 +2547,43 @@ class RemoteImageBuildArgs:
|
|
|
1940
2547
|
pulumi.set(self, "version", value)
|
|
1941
2548
|
|
|
1942
2549
|
|
|
2550
|
+
if not MYPY:
|
|
2551
|
+
class RemoteImageBuildAuthConfigArgsDict(TypedDict):
|
|
2552
|
+
host_name: pulumi.Input[str]
|
|
2553
|
+
"""
|
|
2554
|
+
hostname of the registry
|
|
2555
|
+
"""
|
|
2556
|
+
auth: NotRequired[pulumi.Input[str]]
|
|
2557
|
+
"""
|
|
2558
|
+
the auth token
|
|
2559
|
+
"""
|
|
2560
|
+
email: NotRequired[pulumi.Input[str]]
|
|
2561
|
+
"""
|
|
2562
|
+
the user emal
|
|
2563
|
+
"""
|
|
2564
|
+
identity_token: NotRequired[pulumi.Input[str]]
|
|
2565
|
+
"""
|
|
2566
|
+
the identity token
|
|
2567
|
+
"""
|
|
2568
|
+
password: NotRequired[pulumi.Input[str]]
|
|
2569
|
+
"""
|
|
2570
|
+
the registry password
|
|
2571
|
+
"""
|
|
2572
|
+
registry_token: NotRequired[pulumi.Input[str]]
|
|
2573
|
+
"""
|
|
2574
|
+
the registry token
|
|
2575
|
+
"""
|
|
2576
|
+
server_address: NotRequired[pulumi.Input[str]]
|
|
2577
|
+
"""
|
|
2578
|
+
the server address
|
|
2579
|
+
"""
|
|
2580
|
+
user_name: NotRequired[pulumi.Input[str]]
|
|
2581
|
+
"""
|
|
2582
|
+
the registry user name
|
|
2583
|
+
"""
|
|
2584
|
+
elif False:
|
|
2585
|
+
RemoteImageBuildAuthConfigArgsDict: TypeAlias = Mapping[str, Any]
|
|
2586
|
+
|
|
1943
2587
|
@pulumi.input_type
|
|
1944
2588
|
class RemoteImageBuildAuthConfigArgs:
|
|
1945
2589
|
def __init__(__self__, *,
|
|
@@ -2074,6 +2718,23 @@ class RemoteImageBuildAuthConfigArgs:
|
|
|
2074
2718
|
pulumi.set(self, "user_name", value)
|
|
2075
2719
|
|
|
2076
2720
|
|
|
2721
|
+
if not MYPY:
|
|
2722
|
+
class RemoteImageBuildUlimitArgsDict(TypedDict):
|
|
2723
|
+
hard: pulumi.Input[int]
|
|
2724
|
+
"""
|
|
2725
|
+
soft limit
|
|
2726
|
+
"""
|
|
2727
|
+
name: pulumi.Input[str]
|
|
2728
|
+
"""
|
|
2729
|
+
type of ulimit, e.g. `nofile`
|
|
2730
|
+
"""
|
|
2731
|
+
soft: pulumi.Input[int]
|
|
2732
|
+
"""
|
|
2733
|
+
hard limit
|
|
2734
|
+
"""
|
|
2735
|
+
elif False:
|
|
2736
|
+
RemoteImageBuildUlimitArgsDict: TypeAlias = Mapping[str, Any]
|
|
2737
|
+
|
|
2077
2738
|
@pulumi.input_type
|
|
2078
2739
|
class RemoteImageBuildUlimitArgs:
|
|
2079
2740
|
def __init__(__self__, *,
|
|
@@ -2126,6 +2787,19 @@ class RemoteImageBuildUlimitArgs:
|
|
|
2126
2787
|
pulumi.set(self, "soft", value)
|
|
2127
2788
|
|
|
2128
2789
|
|
|
2790
|
+
if not MYPY:
|
|
2791
|
+
class SecretLabelArgsDict(TypedDict):
|
|
2792
|
+
label: pulumi.Input[str]
|
|
2793
|
+
"""
|
|
2794
|
+
Name of the label
|
|
2795
|
+
"""
|
|
2796
|
+
value: pulumi.Input[str]
|
|
2797
|
+
"""
|
|
2798
|
+
Value of the label
|
|
2799
|
+
"""
|
|
2800
|
+
elif False:
|
|
2801
|
+
SecretLabelArgsDict: TypeAlias = Mapping[str, Any]
|
|
2802
|
+
|
|
2129
2803
|
@pulumi.input_type
|
|
2130
2804
|
class SecretLabelArgs:
|
|
2131
2805
|
def __init__(__self__, *,
|
|
@@ -2163,6 +2837,23 @@ class SecretLabelArgs:
|
|
|
2163
2837
|
pulumi.set(self, "value", value)
|
|
2164
2838
|
|
|
2165
2839
|
|
|
2840
|
+
if not MYPY:
|
|
2841
|
+
class ServiceAuthArgsDict(TypedDict):
|
|
2842
|
+
server_address: pulumi.Input[str]
|
|
2843
|
+
"""
|
|
2844
|
+
The address of the server for the authentication
|
|
2845
|
+
"""
|
|
2846
|
+
password: NotRequired[pulumi.Input[str]]
|
|
2847
|
+
"""
|
|
2848
|
+
The password
|
|
2849
|
+
"""
|
|
2850
|
+
username: NotRequired[pulumi.Input[str]]
|
|
2851
|
+
"""
|
|
2852
|
+
The username
|
|
2853
|
+
"""
|
|
2854
|
+
elif False:
|
|
2855
|
+
ServiceAuthArgsDict: TypeAlias = Mapping[str, Any]
|
|
2856
|
+
|
|
2166
2857
|
@pulumi.input_type
|
|
2167
2858
|
class ServiceAuthArgs:
|
|
2168
2859
|
def __init__(__self__, *,
|
|
@@ -2217,6 +2908,19 @@ class ServiceAuthArgs:
|
|
|
2217
2908
|
pulumi.set(self, "username", value)
|
|
2218
2909
|
|
|
2219
2910
|
|
|
2911
|
+
if not MYPY:
|
|
2912
|
+
class ServiceConvergeConfigArgsDict(TypedDict):
|
|
2913
|
+
delay: NotRequired[pulumi.Input[str]]
|
|
2914
|
+
"""
|
|
2915
|
+
The interval to check if the desired state is reached `(ms|s)`. Defaults to `7s`.
|
|
2916
|
+
"""
|
|
2917
|
+
timeout: NotRequired[pulumi.Input[str]]
|
|
2918
|
+
"""
|
|
2919
|
+
The timeout of the service to reach the desired state `(s|m)`. Defaults to `3m`
|
|
2920
|
+
"""
|
|
2921
|
+
elif False:
|
|
2922
|
+
ServiceConvergeConfigArgsDict: TypeAlias = Mapping[str, Any]
|
|
2923
|
+
|
|
2220
2924
|
@pulumi.input_type
|
|
2221
2925
|
class ServiceConvergeConfigArgs:
|
|
2222
2926
|
def __init__(__self__, *,
|
|
@@ -2256,6 +2960,19 @@ class ServiceConvergeConfigArgs:
|
|
|
2256
2960
|
pulumi.set(self, "timeout", value)
|
|
2257
2961
|
|
|
2258
2962
|
|
|
2963
|
+
if not MYPY:
|
|
2964
|
+
class ServiceEndpointSpecArgsDict(TypedDict):
|
|
2965
|
+
mode: NotRequired[pulumi.Input[str]]
|
|
2966
|
+
"""
|
|
2967
|
+
The mode of resolution to use for internal load balancing between tasks
|
|
2968
|
+
"""
|
|
2969
|
+
ports: NotRequired[pulumi.Input[Sequence[pulumi.Input['ServiceEndpointSpecPortArgsDict']]]]
|
|
2970
|
+
"""
|
|
2971
|
+
List of exposed ports that this service is accessible on from the outside. Ports can only be provided if 'vip' resolution mode is used
|
|
2972
|
+
"""
|
|
2973
|
+
elif False:
|
|
2974
|
+
ServiceEndpointSpecArgsDict: TypeAlias = Mapping[str, Any]
|
|
2975
|
+
|
|
2259
2976
|
@pulumi.input_type
|
|
2260
2977
|
class ServiceEndpointSpecArgs:
|
|
2261
2978
|
def __init__(__self__, *,
|
|
@@ -2295,6 +3012,31 @@ class ServiceEndpointSpecArgs:
|
|
|
2295
3012
|
pulumi.set(self, "ports", value)
|
|
2296
3013
|
|
|
2297
3014
|
|
|
3015
|
+
if not MYPY:
|
|
3016
|
+
class ServiceEndpointSpecPortArgsDict(TypedDict):
|
|
3017
|
+
target_port: pulumi.Input[int]
|
|
3018
|
+
"""
|
|
3019
|
+
The port inside the container
|
|
3020
|
+
"""
|
|
3021
|
+
name: NotRequired[pulumi.Input[str]]
|
|
3022
|
+
"""
|
|
3023
|
+
A random name for the port
|
|
3024
|
+
"""
|
|
3025
|
+
protocol: NotRequired[pulumi.Input[str]]
|
|
3026
|
+
"""
|
|
3027
|
+
Rrepresents the protocol of a port: `tcp`, `udp` or `sctp`. Defaults to `tcp`.
|
|
3028
|
+
"""
|
|
3029
|
+
publish_mode: NotRequired[pulumi.Input[str]]
|
|
3030
|
+
"""
|
|
3031
|
+
Represents the mode in which the port is to be published: 'ingress' or 'host'. Defaults to `ingress`.
|
|
3032
|
+
"""
|
|
3033
|
+
published_port: NotRequired[pulumi.Input[int]]
|
|
3034
|
+
"""
|
|
3035
|
+
The port on the swarm hosts
|
|
3036
|
+
"""
|
|
3037
|
+
elif False:
|
|
3038
|
+
ServiceEndpointSpecPortArgsDict: TypeAlias = Mapping[str, Any]
|
|
3039
|
+
|
|
2298
3040
|
@pulumi.input_type
|
|
2299
3041
|
class ServiceEndpointSpecPortArgs:
|
|
2300
3042
|
def __init__(__self__, *,
|
|
@@ -2381,6 +3123,19 @@ class ServiceEndpointSpecPortArgs:
|
|
|
2381
3123
|
pulumi.set(self, "published_port", value)
|
|
2382
3124
|
|
|
2383
3125
|
|
|
3126
|
+
if not MYPY:
|
|
3127
|
+
class ServiceLabelArgsDict(TypedDict):
|
|
3128
|
+
label: pulumi.Input[str]
|
|
3129
|
+
"""
|
|
3130
|
+
Name of the label
|
|
3131
|
+
"""
|
|
3132
|
+
value: pulumi.Input[str]
|
|
3133
|
+
"""
|
|
3134
|
+
Value of the label
|
|
3135
|
+
"""
|
|
3136
|
+
elif False:
|
|
3137
|
+
ServiceLabelArgsDict: TypeAlias = Mapping[str, Any]
|
|
3138
|
+
|
|
2384
3139
|
@pulumi.input_type
|
|
2385
3140
|
class ServiceLabelArgs:
|
|
2386
3141
|
def __init__(__self__, *,
|
|
@@ -2418,6 +3173,19 @@ class ServiceLabelArgs:
|
|
|
2418
3173
|
pulumi.set(self, "value", value)
|
|
2419
3174
|
|
|
2420
3175
|
|
|
3176
|
+
if not MYPY:
|
|
3177
|
+
class ServiceModeArgsDict(TypedDict):
|
|
3178
|
+
global_: NotRequired[pulumi.Input[bool]]
|
|
3179
|
+
"""
|
|
3180
|
+
When `true`, tasks will run on every worker node. Conflicts with `replicated`
|
|
3181
|
+
"""
|
|
3182
|
+
replicated: NotRequired[pulumi.Input['ServiceModeReplicatedArgsDict']]
|
|
3183
|
+
"""
|
|
3184
|
+
The replicated service mode
|
|
3185
|
+
"""
|
|
3186
|
+
elif False:
|
|
3187
|
+
ServiceModeArgsDict: TypeAlias = Mapping[str, Any]
|
|
3188
|
+
|
|
2421
3189
|
@pulumi.input_type
|
|
2422
3190
|
class ServiceModeArgs:
|
|
2423
3191
|
def __init__(__self__, *,
|
|
@@ -2457,6 +3225,15 @@ class ServiceModeArgs:
|
|
|
2457
3225
|
pulumi.set(self, "replicated", value)
|
|
2458
3226
|
|
|
2459
3227
|
|
|
3228
|
+
if not MYPY:
|
|
3229
|
+
class ServiceModeReplicatedArgsDict(TypedDict):
|
|
3230
|
+
replicas: NotRequired[pulumi.Input[int]]
|
|
3231
|
+
"""
|
|
3232
|
+
The amount of replicas of the service. Defaults to `1`
|
|
3233
|
+
"""
|
|
3234
|
+
elif False:
|
|
3235
|
+
ServiceModeReplicatedArgsDict: TypeAlias = Mapping[str, Any]
|
|
3236
|
+
|
|
2460
3237
|
@pulumi.input_type
|
|
2461
3238
|
class ServiceModeReplicatedArgs:
|
|
2462
3239
|
def __init__(__self__, *,
|
|
@@ -2480,6 +3257,35 @@ class ServiceModeReplicatedArgs:
|
|
|
2480
3257
|
pulumi.set(self, "replicas", value)
|
|
2481
3258
|
|
|
2482
3259
|
|
|
3260
|
+
if not MYPY:
|
|
3261
|
+
class ServiceRollbackConfigArgsDict(TypedDict):
|
|
3262
|
+
delay: NotRequired[pulumi.Input[str]]
|
|
3263
|
+
"""
|
|
3264
|
+
Delay between task rollbacks (ns|us|ms|s|m|h). Defaults to `0s`.
|
|
3265
|
+
"""
|
|
3266
|
+
failure_action: NotRequired[pulumi.Input[str]]
|
|
3267
|
+
"""
|
|
3268
|
+
Action on rollback failure: pause | continue. Defaults to `pause`.
|
|
3269
|
+
"""
|
|
3270
|
+
max_failure_ratio: NotRequired[pulumi.Input[str]]
|
|
3271
|
+
"""
|
|
3272
|
+
Failure rate to tolerate during a rollback. Defaults to `0.0`.
|
|
3273
|
+
"""
|
|
3274
|
+
monitor: NotRequired[pulumi.Input[str]]
|
|
3275
|
+
"""
|
|
3276
|
+
Duration after each task rollback to monitor for failure (ns|us|ms|s|m|h). Defaults to `5s`.
|
|
3277
|
+
"""
|
|
3278
|
+
order: NotRequired[pulumi.Input[str]]
|
|
3279
|
+
"""
|
|
3280
|
+
Rollback order: either 'stop-first' or 'start-first'. Defaults to `stop-first`.
|
|
3281
|
+
"""
|
|
3282
|
+
parallelism: NotRequired[pulumi.Input[int]]
|
|
3283
|
+
"""
|
|
3284
|
+
Maximum number of tasks to be rollbacked in one iteration. Defaults to `1`
|
|
3285
|
+
"""
|
|
3286
|
+
elif False:
|
|
3287
|
+
ServiceRollbackConfigArgsDict: TypeAlias = Mapping[str, Any]
|
|
3288
|
+
|
|
2483
3289
|
@pulumi.input_type
|
|
2484
3290
|
class ServiceRollbackConfigArgs:
|
|
2485
3291
|
def __init__(__self__, *,
|
|
@@ -2583,6 +3389,43 @@ class ServiceRollbackConfigArgs:
|
|
|
2583
3389
|
pulumi.set(self, "parallelism", value)
|
|
2584
3390
|
|
|
2585
3391
|
|
|
3392
|
+
if not MYPY:
|
|
3393
|
+
class ServiceTaskSpecArgsDict(TypedDict):
|
|
3394
|
+
container_spec: pulumi.Input['ServiceTaskSpecContainerSpecArgsDict']
|
|
3395
|
+
"""
|
|
3396
|
+
The spec for each container
|
|
3397
|
+
"""
|
|
3398
|
+
force_update: NotRequired[pulumi.Input[int]]
|
|
3399
|
+
"""
|
|
3400
|
+
A counter that triggers an update even if no relevant parameters have been changed. See the [spec](https://github.com/docker/swarmkit/blob/master/api/specs.proto#L126).
|
|
3401
|
+
"""
|
|
3402
|
+
log_driver: NotRequired[pulumi.Input['ServiceTaskSpecLogDriverArgsDict']]
|
|
3403
|
+
"""
|
|
3404
|
+
Specifies the log driver to use for tasks created from this spec. If not present, the default one for the swarm will be used, finally falling back to the engine default if not specified
|
|
3405
|
+
"""
|
|
3406
|
+
networks_advanceds: NotRequired[pulumi.Input[Sequence[pulumi.Input['ServiceTaskSpecNetworksAdvancedArgsDict']]]]
|
|
3407
|
+
"""
|
|
3408
|
+
The networks the container is attached to
|
|
3409
|
+
"""
|
|
3410
|
+
placement: NotRequired[pulumi.Input['ServiceTaskSpecPlacementArgsDict']]
|
|
3411
|
+
"""
|
|
3412
|
+
The placement preferences
|
|
3413
|
+
"""
|
|
3414
|
+
resources: NotRequired[pulumi.Input['ServiceTaskSpecResourcesArgsDict']]
|
|
3415
|
+
"""
|
|
3416
|
+
Resource requirements which apply to each individual container created as part of the service
|
|
3417
|
+
"""
|
|
3418
|
+
restart_policy: NotRequired[pulumi.Input['ServiceTaskSpecRestartPolicyArgsDict']]
|
|
3419
|
+
"""
|
|
3420
|
+
Specification for the restart policy which applies to containers created as part of this service.
|
|
3421
|
+
"""
|
|
3422
|
+
runtime: NotRequired[pulumi.Input[str]]
|
|
3423
|
+
"""
|
|
3424
|
+
Runtime is the type of runtime specified for the task executor. See the [types](https://github.com/moby/moby/blob/master/api/types/swarm/runtime.go).
|
|
3425
|
+
"""
|
|
3426
|
+
elif False:
|
|
3427
|
+
ServiceTaskSpecArgsDict: TypeAlias = Mapping[str, Any]
|
|
3428
|
+
|
|
2586
3429
|
@pulumi.input_type
|
|
2587
3430
|
class ServiceTaskSpecArgs:
|
|
2588
3431
|
def __init__(__self__, *,
|
|
@@ -2717,6 +3560,95 @@ class ServiceTaskSpecArgs:
|
|
|
2717
3560
|
pulumi.set(self, "runtime", value)
|
|
2718
3561
|
|
|
2719
3562
|
|
|
3563
|
+
if not MYPY:
|
|
3564
|
+
class ServiceTaskSpecContainerSpecArgsDict(TypedDict):
|
|
3565
|
+
image: pulumi.Input[str]
|
|
3566
|
+
"""
|
|
3567
|
+
The image name to use for the containers of the service, like `nginx:1.17.6`. Also use the data-source or resource of `RemoteImage` with the `repo_digest` or `RegistryImage` with the `name` attribute for this, as shown in the examples.
|
|
3568
|
+
"""
|
|
3569
|
+
args: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
|
|
3570
|
+
"""
|
|
3571
|
+
Arguments to the command
|
|
3572
|
+
"""
|
|
3573
|
+
commands: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
|
|
3574
|
+
"""
|
|
3575
|
+
The command/entrypoint to be run in the image. According to the [docker cli](https://github.com/docker/cli/blob/v20.10.7/cli/command/service/opts.go#L705) the override of the entrypoint is also passed to the `command` property and there is no `entrypoint` attribute in the `ContainerSpec` of the service.
|
|
3576
|
+
"""
|
|
3577
|
+
configs: NotRequired[pulumi.Input[Sequence[pulumi.Input['ServiceTaskSpecContainerSpecConfigArgsDict']]]]
|
|
3578
|
+
"""
|
|
3579
|
+
References to zero or more configs that will be exposed to the service
|
|
3580
|
+
"""
|
|
3581
|
+
dir: NotRequired[pulumi.Input[str]]
|
|
3582
|
+
"""
|
|
3583
|
+
The working directory for commands to run in
|
|
3584
|
+
"""
|
|
3585
|
+
dns_config: NotRequired[pulumi.Input['ServiceTaskSpecContainerSpecDnsConfigArgsDict']]
|
|
3586
|
+
"""
|
|
3587
|
+
Specification for DNS related configurations in resolver configuration file (`resolv.conf`)
|
|
3588
|
+
"""
|
|
3589
|
+
env: NotRequired[pulumi.Input[Mapping[str, pulumi.Input[str]]]]
|
|
3590
|
+
"""
|
|
3591
|
+
A list of environment variables in the form VAR="value"
|
|
3592
|
+
"""
|
|
3593
|
+
groups: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
|
|
3594
|
+
"""
|
|
3595
|
+
A list of additional groups that the container process will run as
|
|
3596
|
+
"""
|
|
3597
|
+
healthcheck: NotRequired[pulumi.Input['ServiceTaskSpecContainerSpecHealthcheckArgsDict']]
|
|
3598
|
+
"""
|
|
3599
|
+
A test to perform to check that the container is healthy
|
|
3600
|
+
"""
|
|
3601
|
+
hostname: NotRequired[pulumi.Input[str]]
|
|
3602
|
+
"""
|
|
3603
|
+
The hostname to use for the container, as a valid RFC 1123 hostname
|
|
3604
|
+
"""
|
|
3605
|
+
hosts: NotRequired[pulumi.Input[Sequence[pulumi.Input['ServiceTaskSpecContainerSpecHostArgsDict']]]]
|
|
3606
|
+
"""
|
|
3607
|
+
A list of hostname/IP mappings to add to the container's hosts file
|
|
3608
|
+
"""
|
|
3609
|
+
isolation: NotRequired[pulumi.Input[str]]
|
|
3610
|
+
"""
|
|
3611
|
+
Isolation technology of the containers running the service. (Windows only). Defaults to `default`.
|
|
3612
|
+
"""
|
|
3613
|
+
labels: NotRequired[pulumi.Input[Sequence[pulumi.Input['ServiceTaskSpecContainerSpecLabelArgsDict']]]]
|
|
3614
|
+
"""
|
|
3615
|
+
User-defined key/value metadata
|
|
3616
|
+
"""
|
|
3617
|
+
mounts: NotRequired[pulumi.Input[Sequence[pulumi.Input['ServiceTaskSpecContainerSpecMountArgsDict']]]]
|
|
3618
|
+
"""
|
|
3619
|
+
Specification for mounts to be added to containers created as part of the service
|
|
3620
|
+
"""
|
|
3621
|
+
privileges: NotRequired[pulumi.Input['ServiceTaskSpecContainerSpecPrivilegesArgsDict']]
|
|
3622
|
+
"""
|
|
3623
|
+
Security options for the container
|
|
3624
|
+
"""
|
|
3625
|
+
read_only: NotRequired[pulumi.Input[bool]]
|
|
3626
|
+
"""
|
|
3627
|
+
Mount the container's root filesystem as read only
|
|
3628
|
+
"""
|
|
3629
|
+
secrets: NotRequired[pulumi.Input[Sequence[pulumi.Input['ServiceTaskSpecContainerSpecSecretArgsDict']]]]
|
|
3630
|
+
"""
|
|
3631
|
+
References to zero or more secrets that will be exposed to the service
|
|
3632
|
+
"""
|
|
3633
|
+
stop_grace_period: NotRequired[pulumi.Input[str]]
|
|
3634
|
+
"""
|
|
3635
|
+
Amount of time to wait for the container to terminate before forcefully removing it (ms|s|m|h). If not specified or '0s' the destroy will not check if all tasks/containers of the service terminate.
|
|
3636
|
+
"""
|
|
3637
|
+
stop_signal: NotRequired[pulumi.Input[str]]
|
|
3638
|
+
"""
|
|
3639
|
+
Signal to stop the container
|
|
3640
|
+
"""
|
|
3641
|
+
sysctl: NotRequired[pulumi.Input[Mapping[str, pulumi.Input[str]]]]
|
|
3642
|
+
"""
|
|
3643
|
+
Sysctls config (Linux only)
|
|
3644
|
+
"""
|
|
3645
|
+
user: NotRequired[pulumi.Input[str]]
|
|
3646
|
+
"""
|
|
3647
|
+
The user inside the container
|
|
3648
|
+
"""
|
|
3649
|
+
elif False:
|
|
3650
|
+
ServiceTaskSpecContainerSpecArgsDict: TypeAlias = Mapping[str, Any]
|
|
3651
|
+
|
|
2720
3652
|
@pulumi.input_type
|
|
2721
3653
|
class ServiceTaskSpecContainerSpecArgs:
|
|
2722
3654
|
def __init__(__self__, *,
|
|
@@ -2739,7 +3671,7 @@ class ServiceTaskSpecContainerSpecArgs:
|
|
|
2739
3671
|
secrets: Optional[pulumi.Input[Sequence[pulumi.Input['ServiceTaskSpecContainerSpecSecretArgs']]]] = None,
|
|
2740
3672
|
stop_grace_period: Optional[pulumi.Input[str]] = None,
|
|
2741
3673
|
stop_signal: Optional[pulumi.Input[str]] = None,
|
|
2742
|
-
sysctl: Optional[pulumi.Input[Mapping[str,
|
|
3674
|
+
sysctl: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None,
|
|
2743
3675
|
user: Optional[pulumi.Input[str]] = None):
|
|
2744
3676
|
"""
|
|
2745
3677
|
:param pulumi.Input[str] image: The image name to use for the containers of the service, like `nginx:1.17.6`. Also use the data-source or resource of `RemoteImage` with the `repo_digest` or `RegistryImage` with the `name` attribute for this, as shown in the examples.
|
|
@@ -2761,7 +3693,7 @@ class ServiceTaskSpecContainerSpecArgs:
|
|
|
2761
3693
|
:param pulumi.Input[Sequence[pulumi.Input['ServiceTaskSpecContainerSpecSecretArgs']]] secrets: References to zero or more secrets that will be exposed to the service
|
|
2762
3694
|
:param pulumi.Input[str] stop_grace_period: Amount of time to wait for the container to terminate before forcefully removing it (ms|s|m|h). If not specified or '0s' the destroy will not check if all tasks/containers of the service terminate.
|
|
2763
3695
|
:param pulumi.Input[str] stop_signal: Signal to stop the container
|
|
2764
|
-
:param pulumi.Input[Mapping[str,
|
|
3696
|
+
:param pulumi.Input[Mapping[str, pulumi.Input[str]]] sysctl: Sysctls config (Linux only)
|
|
2765
3697
|
:param pulumi.Input[str] user: The user inside the container
|
|
2766
3698
|
"""
|
|
2767
3699
|
pulumi.set(__self__, "image", image)
|
|
@@ -3036,14 +3968,14 @@ class ServiceTaskSpecContainerSpecArgs:
|
|
|
3036
3968
|
|
|
3037
3969
|
@property
|
|
3038
3970
|
@pulumi.getter
|
|
3039
|
-
def sysctl(self) -> Optional[pulumi.Input[Mapping[str,
|
|
3971
|
+
def sysctl(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]:
|
|
3040
3972
|
"""
|
|
3041
3973
|
Sysctls config (Linux only)
|
|
3042
3974
|
"""
|
|
3043
3975
|
return pulumi.get(self, "sysctl")
|
|
3044
3976
|
|
|
3045
3977
|
@sysctl.setter
|
|
3046
|
-
def sysctl(self, value: Optional[pulumi.Input[Mapping[str,
|
|
3978
|
+
def sysctl(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]):
|
|
3047
3979
|
pulumi.set(self, "sysctl", value)
|
|
3048
3980
|
|
|
3049
3981
|
@property
|
|
@@ -3059,6 +3991,35 @@ class ServiceTaskSpecContainerSpecArgs:
|
|
|
3059
3991
|
pulumi.set(self, "user", value)
|
|
3060
3992
|
|
|
3061
3993
|
|
|
3994
|
+
if not MYPY:
|
|
3995
|
+
class ServiceTaskSpecContainerSpecConfigArgsDict(TypedDict):
|
|
3996
|
+
config_id: pulumi.Input[str]
|
|
3997
|
+
"""
|
|
3998
|
+
ID of the specific config that we're referencing
|
|
3999
|
+
"""
|
|
4000
|
+
file_name: pulumi.Input[str]
|
|
4001
|
+
"""
|
|
4002
|
+
Represents the final filename in the filesystem
|
|
4003
|
+
"""
|
|
4004
|
+
config_name: NotRequired[pulumi.Input[str]]
|
|
4005
|
+
"""
|
|
4006
|
+
Name of the config that this references, but this is just provided for lookup/display purposes. The config in the reference will be identified by its ID
|
|
4007
|
+
"""
|
|
4008
|
+
file_gid: NotRequired[pulumi.Input[str]]
|
|
4009
|
+
"""
|
|
4010
|
+
Represents the file GID. Defaults to `0`.
|
|
4011
|
+
"""
|
|
4012
|
+
file_mode: NotRequired[pulumi.Input[int]]
|
|
4013
|
+
"""
|
|
4014
|
+
Represents represents the FileMode of the file. Defaults to `0o444`.
|
|
4015
|
+
"""
|
|
4016
|
+
file_uid: NotRequired[pulumi.Input[str]]
|
|
4017
|
+
"""
|
|
4018
|
+
Represents the file UID. Defaults to `0`.
|
|
4019
|
+
"""
|
|
4020
|
+
elif False:
|
|
4021
|
+
ServiceTaskSpecContainerSpecConfigArgsDict: TypeAlias = Mapping[str, Any]
|
|
4022
|
+
|
|
3062
4023
|
@pulumi.input_type
|
|
3063
4024
|
class ServiceTaskSpecContainerSpecConfigArgs:
|
|
3064
4025
|
def __init__(__self__, *,
|
|
@@ -3160,6 +4121,23 @@ class ServiceTaskSpecContainerSpecConfigArgs:
|
|
|
3160
4121
|
pulumi.set(self, "file_uid", value)
|
|
3161
4122
|
|
|
3162
4123
|
|
|
4124
|
+
if not MYPY:
|
|
4125
|
+
class ServiceTaskSpecContainerSpecDnsConfigArgsDict(TypedDict):
|
|
4126
|
+
nameservers: pulumi.Input[Sequence[pulumi.Input[str]]]
|
|
4127
|
+
"""
|
|
4128
|
+
The IP addresses of the name servers
|
|
4129
|
+
"""
|
|
4130
|
+
options: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
|
|
4131
|
+
"""
|
|
4132
|
+
A list of internal resolver variables to be modified (e.g., `debug`, `ndots:3`, etc.)
|
|
4133
|
+
"""
|
|
4134
|
+
searches: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
|
|
4135
|
+
"""
|
|
4136
|
+
A search list for host-name lookup
|
|
4137
|
+
"""
|
|
4138
|
+
elif False:
|
|
4139
|
+
ServiceTaskSpecContainerSpecDnsConfigArgsDict: TypeAlias = Mapping[str, Any]
|
|
4140
|
+
|
|
3163
4141
|
@pulumi.input_type
|
|
3164
4142
|
class ServiceTaskSpecContainerSpecDnsConfigArgs:
|
|
3165
4143
|
def __init__(__self__, *,
|
|
@@ -3214,6 +4192,31 @@ class ServiceTaskSpecContainerSpecDnsConfigArgs:
|
|
|
3214
4192
|
pulumi.set(self, "searches", value)
|
|
3215
4193
|
|
|
3216
4194
|
|
|
4195
|
+
if not MYPY:
|
|
4196
|
+
class ServiceTaskSpecContainerSpecHealthcheckArgsDict(TypedDict):
|
|
4197
|
+
tests: pulumi.Input[Sequence[pulumi.Input[str]]]
|
|
4198
|
+
"""
|
|
4199
|
+
The test to perform as list
|
|
4200
|
+
"""
|
|
4201
|
+
interval: NotRequired[pulumi.Input[str]]
|
|
4202
|
+
"""
|
|
4203
|
+
Time between running the check (ms|s|m|h). Defaults to `0s`.
|
|
4204
|
+
"""
|
|
4205
|
+
retries: NotRequired[pulumi.Input[int]]
|
|
4206
|
+
"""
|
|
4207
|
+
Consecutive failures needed to report unhealthy. Defaults to `0`
|
|
4208
|
+
"""
|
|
4209
|
+
start_period: NotRequired[pulumi.Input[str]]
|
|
4210
|
+
"""
|
|
4211
|
+
Start period for the container to initialize before counting retries towards unstable (ms|s|m|h). Defaults to `0s`.
|
|
4212
|
+
"""
|
|
4213
|
+
timeout: NotRequired[pulumi.Input[str]]
|
|
4214
|
+
"""
|
|
4215
|
+
Maximum time to allow one check to run (ms|s|m|h). Defaults to `0s`.
|
|
4216
|
+
"""
|
|
4217
|
+
elif False:
|
|
4218
|
+
ServiceTaskSpecContainerSpecHealthcheckArgsDict: TypeAlias = Mapping[str, Any]
|
|
4219
|
+
|
|
3217
4220
|
@pulumi.input_type
|
|
3218
4221
|
class ServiceTaskSpecContainerSpecHealthcheckArgs:
|
|
3219
4222
|
def __init__(__self__, *,
|
|
@@ -3300,6 +4303,19 @@ class ServiceTaskSpecContainerSpecHealthcheckArgs:
|
|
|
3300
4303
|
pulumi.set(self, "timeout", value)
|
|
3301
4304
|
|
|
3302
4305
|
|
|
4306
|
+
if not MYPY:
|
|
4307
|
+
class ServiceTaskSpecContainerSpecHostArgsDict(TypedDict):
|
|
4308
|
+
host: pulumi.Input[str]
|
|
4309
|
+
"""
|
|
4310
|
+
The name of the host
|
|
4311
|
+
"""
|
|
4312
|
+
ip: pulumi.Input[str]
|
|
4313
|
+
"""
|
|
4314
|
+
The ip of the host
|
|
4315
|
+
"""
|
|
4316
|
+
elif False:
|
|
4317
|
+
ServiceTaskSpecContainerSpecHostArgsDict: TypeAlias = Mapping[str, Any]
|
|
4318
|
+
|
|
3303
4319
|
@pulumi.input_type
|
|
3304
4320
|
class ServiceTaskSpecContainerSpecHostArgs:
|
|
3305
4321
|
def __init__(__self__, *,
|
|
@@ -3337,6 +4353,19 @@ class ServiceTaskSpecContainerSpecHostArgs:
|
|
|
3337
4353
|
pulumi.set(self, "ip", value)
|
|
3338
4354
|
|
|
3339
4355
|
|
|
4356
|
+
if not MYPY:
|
|
4357
|
+
class ServiceTaskSpecContainerSpecLabelArgsDict(TypedDict):
|
|
4358
|
+
label: pulumi.Input[str]
|
|
4359
|
+
"""
|
|
4360
|
+
Name of the label
|
|
4361
|
+
"""
|
|
4362
|
+
value: pulumi.Input[str]
|
|
4363
|
+
"""
|
|
4364
|
+
Value of the label
|
|
4365
|
+
"""
|
|
4366
|
+
elif False:
|
|
4367
|
+
ServiceTaskSpecContainerSpecLabelArgsDict: TypeAlias = Mapping[str, Any]
|
|
4368
|
+
|
|
3340
4369
|
@pulumi.input_type
|
|
3341
4370
|
class ServiceTaskSpecContainerSpecLabelArgs:
|
|
3342
4371
|
def __init__(__self__, *,
|
|
@@ -3355,24 +4384,57 @@ class ServiceTaskSpecContainerSpecLabelArgs:
|
|
|
3355
4384
|
"""
|
|
3356
4385
|
Name of the label
|
|
3357
4386
|
"""
|
|
3358
|
-
return pulumi.get(self, "label")
|
|
3359
|
-
|
|
3360
|
-
@label.setter
|
|
3361
|
-
def label(self, value: pulumi.Input[str]):
|
|
3362
|
-
pulumi.set(self, "label", value)
|
|
3363
|
-
|
|
3364
|
-
@property
|
|
3365
|
-
@pulumi.getter
|
|
3366
|
-
def value(self) -> pulumi.Input[str]:
|
|
4387
|
+
return pulumi.get(self, "label")
|
|
4388
|
+
|
|
4389
|
+
@label.setter
|
|
4390
|
+
def label(self, value: pulumi.Input[str]):
|
|
4391
|
+
pulumi.set(self, "label", value)
|
|
4392
|
+
|
|
4393
|
+
@property
|
|
4394
|
+
@pulumi.getter
|
|
4395
|
+
def value(self) -> pulumi.Input[str]:
|
|
4396
|
+
"""
|
|
4397
|
+
Value of the label
|
|
4398
|
+
"""
|
|
4399
|
+
return pulumi.get(self, "value")
|
|
4400
|
+
|
|
4401
|
+
@value.setter
|
|
4402
|
+
def value(self, value: pulumi.Input[str]):
|
|
4403
|
+
pulumi.set(self, "value", value)
|
|
4404
|
+
|
|
4405
|
+
|
|
4406
|
+
if not MYPY:
|
|
4407
|
+
class ServiceTaskSpecContainerSpecMountArgsDict(TypedDict):
|
|
4408
|
+
target: pulumi.Input[str]
|
|
4409
|
+
"""
|
|
4410
|
+
Container path
|
|
4411
|
+
"""
|
|
4412
|
+
type: pulumi.Input[str]
|
|
4413
|
+
"""
|
|
4414
|
+
The mount type
|
|
4415
|
+
"""
|
|
4416
|
+
bind_options: NotRequired[pulumi.Input['ServiceTaskSpecContainerSpecMountBindOptionsArgsDict']]
|
|
4417
|
+
"""
|
|
4418
|
+
Optional configuration for the bind type
|
|
4419
|
+
"""
|
|
4420
|
+
read_only: NotRequired[pulumi.Input[bool]]
|
|
4421
|
+
"""
|
|
4422
|
+
Whether the mount should be read-only
|
|
4423
|
+
"""
|
|
4424
|
+
source: NotRequired[pulumi.Input[str]]
|
|
4425
|
+
"""
|
|
4426
|
+
Mount source (e.g. a volume name, a host path)
|
|
4427
|
+
"""
|
|
4428
|
+
tmpfs_options: NotRequired[pulumi.Input['ServiceTaskSpecContainerSpecMountTmpfsOptionsArgsDict']]
|
|
4429
|
+
"""
|
|
4430
|
+
Optional configuration for the tmpfs type
|
|
4431
|
+
"""
|
|
4432
|
+
volume_options: NotRequired[pulumi.Input['ServiceTaskSpecContainerSpecMountVolumeOptionsArgsDict']]
|
|
3367
4433
|
"""
|
|
3368
|
-
|
|
4434
|
+
Optional configuration for the volume type
|
|
3369
4435
|
"""
|
|
3370
|
-
|
|
3371
|
-
|
|
3372
|
-
@value.setter
|
|
3373
|
-
def value(self, value: pulumi.Input[str]):
|
|
3374
|
-
pulumi.set(self, "value", value)
|
|
3375
|
-
|
|
4436
|
+
elif False:
|
|
4437
|
+
ServiceTaskSpecContainerSpecMountArgsDict: TypeAlias = Mapping[str, Any]
|
|
3376
4438
|
|
|
3377
4439
|
@pulumi.input_type
|
|
3378
4440
|
class ServiceTaskSpecContainerSpecMountArgs:
|
|
@@ -3491,6 +4553,15 @@ class ServiceTaskSpecContainerSpecMountArgs:
|
|
|
3491
4553
|
pulumi.set(self, "volume_options", value)
|
|
3492
4554
|
|
|
3493
4555
|
|
|
4556
|
+
if not MYPY:
|
|
4557
|
+
class ServiceTaskSpecContainerSpecMountBindOptionsArgsDict(TypedDict):
|
|
4558
|
+
propagation: NotRequired[pulumi.Input[str]]
|
|
4559
|
+
"""
|
|
4560
|
+
Bind propagation refers to whether or not mounts created within a given bind-mount or named volume can be propagated to replicas of that mount. See the [docs](https://docs.docker.com/storage/bind-mounts/#configure-bind-propagation) for details. Defaults to `rprivate`
|
|
4561
|
+
"""
|
|
4562
|
+
elif False:
|
|
4563
|
+
ServiceTaskSpecContainerSpecMountBindOptionsArgsDict: TypeAlias = Mapping[str, Any]
|
|
4564
|
+
|
|
3494
4565
|
@pulumi.input_type
|
|
3495
4566
|
class ServiceTaskSpecContainerSpecMountBindOptionsArgs:
|
|
3496
4567
|
def __init__(__self__, *,
|
|
@@ -3514,6 +4585,19 @@ class ServiceTaskSpecContainerSpecMountBindOptionsArgs:
|
|
|
3514
4585
|
pulumi.set(self, "propagation", value)
|
|
3515
4586
|
|
|
3516
4587
|
|
|
4588
|
+
if not MYPY:
|
|
4589
|
+
class ServiceTaskSpecContainerSpecMountTmpfsOptionsArgsDict(TypedDict):
|
|
4590
|
+
mode: NotRequired[pulumi.Input[int]]
|
|
4591
|
+
"""
|
|
4592
|
+
The permission mode for the tmpfs mount in an integer
|
|
4593
|
+
"""
|
|
4594
|
+
size_bytes: NotRequired[pulumi.Input[int]]
|
|
4595
|
+
"""
|
|
4596
|
+
The size for the tmpfs mount in bytes
|
|
4597
|
+
"""
|
|
4598
|
+
elif False:
|
|
4599
|
+
ServiceTaskSpecContainerSpecMountTmpfsOptionsArgsDict: TypeAlias = Mapping[str, Any]
|
|
4600
|
+
|
|
3517
4601
|
@pulumi.input_type
|
|
3518
4602
|
class ServiceTaskSpecContainerSpecMountTmpfsOptionsArgs:
|
|
3519
4603
|
def __init__(__self__, *,
|
|
@@ -3553,6 +4637,27 @@ class ServiceTaskSpecContainerSpecMountTmpfsOptionsArgs:
|
|
|
3553
4637
|
pulumi.set(self, "size_bytes", value)
|
|
3554
4638
|
|
|
3555
4639
|
|
|
4640
|
+
if not MYPY:
|
|
4641
|
+
class ServiceTaskSpecContainerSpecMountVolumeOptionsArgsDict(TypedDict):
|
|
4642
|
+
driver_name: NotRequired[pulumi.Input[str]]
|
|
4643
|
+
"""
|
|
4644
|
+
Name of the driver to use to create the volume
|
|
4645
|
+
"""
|
|
4646
|
+
driver_options: NotRequired[pulumi.Input[Mapping[str, pulumi.Input[str]]]]
|
|
4647
|
+
"""
|
|
4648
|
+
key/value map of driver specific options
|
|
4649
|
+
"""
|
|
4650
|
+
labels: NotRequired[pulumi.Input[Sequence[pulumi.Input['ServiceTaskSpecContainerSpecMountVolumeOptionsLabelArgsDict']]]]
|
|
4651
|
+
"""
|
|
4652
|
+
User-defined key/value metadata
|
|
4653
|
+
"""
|
|
4654
|
+
no_copy: NotRequired[pulumi.Input[bool]]
|
|
4655
|
+
"""
|
|
4656
|
+
Populate volume with data from the target
|
|
4657
|
+
"""
|
|
4658
|
+
elif False:
|
|
4659
|
+
ServiceTaskSpecContainerSpecMountVolumeOptionsArgsDict: TypeAlias = Mapping[str, Any]
|
|
4660
|
+
|
|
3556
4661
|
@pulumi.input_type
|
|
3557
4662
|
class ServiceTaskSpecContainerSpecMountVolumeOptionsArgs:
|
|
3558
4663
|
def __init__(__self__, *,
|
|
@@ -3624,6 +4729,19 @@ class ServiceTaskSpecContainerSpecMountVolumeOptionsArgs:
|
|
|
3624
4729
|
pulumi.set(self, "no_copy", value)
|
|
3625
4730
|
|
|
3626
4731
|
|
|
4732
|
+
if not MYPY:
|
|
4733
|
+
class ServiceTaskSpecContainerSpecMountVolumeOptionsLabelArgsDict(TypedDict):
|
|
4734
|
+
label: pulumi.Input[str]
|
|
4735
|
+
"""
|
|
4736
|
+
Name of the label
|
|
4737
|
+
"""
|
|
4738
|
+
value: pulumi.Input[str]
|
|
4739
|
+
"""
|
|
4740
|
+
Value of the label
|
|
4741
|
+
"""
|
|
4742
|
+
elif False:
|
|
4743
|
+
ServiceTaskSpecContainerSpecMountVolumeOptionsLabelArgsDict: TypeAlias = Mapping[str, Any]
|
|
4744
|
+
|
|
3627
4745
|
@pulumi.input_type
|
|
3628
4746
|
class ServiceTaskSpecContainerSpecMountVolumeOptionsLabelArgs:
|
|
3629
4747
|
def __init__(__self__, *,
|
|
@@ -3661,6 +4779,19 @@ class ServiceTaskSpecContainerSpecMountVolumeOptionsLabelArgs:
|
|
|
3661
4779
|
pulumi.set(self, "value", value)
|
|
3662
4780
|
|
|
3663
4781
|
|
|
4782
|
+
if not MYPY:
|
|
4783
|
+
class ServiceTaskSpecContainerSpecPrivilegesArgsDict(TypedDict):
|
|
4784
|
+
credential_spec: NotRequired[pulumi.Input['ServiceTaskSpecContainerSpecPrivilegesCredentialSpecArgsDict']]
|
|
4785
|
+
"""
|
|
4786
|
+
CredentialSpec for managed service account (Windows only)
|
|
4787
|
+
"""
|
|
4788
|
+
se_linux_context: NotRequired[pulumi.Input['ServiceTaskSpecContainerSpecPrivilegesSeLinuxContextArgsDict']]
|
|
4789
|
+
"""
|
|
4790
|
+
SELinux labels of the container
|
|
4791
|
+
"""
|
|
4792
|
+
elif False:
|
|
4793
|
+
ServiceTaskSpecContainerSpecPrivilegesArgsDict: TypeAlias = Mapping[str, Any]
|
|
4794
|
+
|
|
3664
4795
|
@pulumi.input_type
|
|
3665
4796
|
class ServiceTaskSpecContainerSpecPrivilegesArgs:
|
|
3666
4797
|
def __init__(__self__, *,
|
|
@@ -3700,6 +4831,19 @@ class ServiceTaskSpecContainerSpecPrivilegesArgs:
|
|
|
3700
4831
|
pulumi.set(self, "se_linux_context", value)
|
|
3701
4832
|
|
|
3702
4833
|
|
|
4834
|
+
if not MYPY:
|
|
4835
|
+
class ServiceTaskSpecContainerSpecPrivilegesCredentialSpecArgsDict(TypedDict):
|
|
4836
|
+
file: NotRequired[pulumi.Input[str]]
|
|
4837
|
+
"""
|
|
4838
|
+
Load credential spec from this file
|
|
4839
|
+
"""
|
|
4840
|
+
registry: NotRequired[pulumi.Input[str]]
|
|
4841
|
+
"""
|
|
4842
|
+
Load credential spec from this value in the Windows registry
|
|
4843
|
+
"""
|
|
4844
|
+
elif False:
|
|
4845
|
+
ServiceTaskSpecContainerSpecPrivilegesCredentialSpecArgsDict: TypeAlias = Mapping[str, Any]
|
|
4846
|
+
|
|
3703
4847
|
@pulumi.input_type
|
|
3704
4848
|
class ServiceTaskSpecContainerSpecPrivilegesCredentialSpecArgs:
|
|
3705
4849
|
def __init__(__self__, *,
|
|
@@ -3739,6 +4883,31 @@ class ServiceTaskSpecContainerSpecPrivilegesCredentialSpecArgs:
|
|
|
3739
4883
|
pulumi.set(self, "registry", value)
|
|
3740
4884
|
|
|
3741
4885
|
|
|
4886
|
+
if not MYPY:
|
|
4887
|
+
class ServiceTaskSpecContainerSpecPrivilegesSeLinuxContextArgsDict(TypedDict):
|
|
4888
|
+
disable: NotRequired[pulumi.Input[bool]]
|
|
4889
|
+
"""
|
|
4890
|
+
Disable SELinux
|
|
4891
|
+
"""
|
|
4892
|
+
level: NotRequired[pulumi.Input[str]]
|
|
4893
|
+
"""
|
|
4894
|
+
SELinux level label
|
|
4895
|
+
"""
|
|
4896
|
+
role: NotRequired[pulumi.Input[str]]
|
|
4897
|
+
"""
|
|
4898
|
+
SELinux role label
|
|
4899
|
+
"""
|
|
4900
|
+
type: NotRequired[pulumi.Input[str]]
|
|
4901
|
+
"""
|
|
4902
|
+
SELinux type label
|
|
4903
|
+
"""
|
|
4904
|
+
user: NotRequired[pulumi.Input[str]]
|
|
4905
|
+
"""
|
|
4906
|
+
SELinux user label
|
|
4907
|
+
"""
|
|
4908
|
+
elif False:
|
|
4909
|
+
ServiceTaskSpecContainerSpecPrivilegesSeLinuxContextArgsDict: TypeAlias = Mapping[str, Any]
|
|
4910
|
+
|
|
3742
4911
|
@pulumi.input_type
|
|
3743
4912
|
class ServiceTaskSpecContainerSpecPrivilegesSeLinuxContextArgs:
|
|
3744
4913
|
def __init__(__self__, *,
|
|
@@ -3826,6 +4995,35 @@ class ServiceTaskSpecContainerSpecPrivilegesSeLinuxContextArgs:
|
|
|
3826
4995
|
pulumi.set(self, "user", value)
|
|
3827
4996
|
|
|
3828
4997
|
|
|
4998
|
+
if not MYPY:
|
|
4999
|
+
class ServiceTaskSpecContainerSpecSecretArgsDict(TypedDict):
|
|
5000
|
+
file_name: pulumi.Input[str]
|
|
5001
|
+
"""
|
|
5002
|
+
Represents the final filename in the filesystem
|
|
5003
|
+
"""
|
|
5004
|
+
secret_id: pulumi.Input[str]
|
|
5005
|
+
"""
|
|
5006
|
+
ID of the specific secret that we're referencing
|
|
5007
|
+
"""
|
|
5008
|
+
file_gid: NotRequired[pulumi.Input[str]]
|
|
5009
|
+
"""
|
|
5010
|
+
Represents the file GID. Defaults to `0`
|
|
5011
|
+
"""
|
|
5012
|
+
file_mode: NotRequired[pulumi.Input[int]]
|
|
5013
|
+
"""
|
|
5014
|
+
Represents represents the FileMode of the file. Defaults to `0o444`
|
|
5015
|
+
"""
|
|
5016
|
+
file_uid: NotRequired[pulumi.Input[str]]
|
|
5017
|
+
"""
|
|
5018
|
+
Represents the file UID. Defaults to `0`
|
|
5019
|
+
"""
|
|
5020
|
+
secret_name: NotRequired[pulumi.Input[str]]
|
|
5021
|
+
"""
|
|
5022
|
+
Name of the secret that this references, but this is just provided for lookup/display purposes. The config in the reference will be identified by its ID
|
|
5023
|
+
"""
|
|
5024
|
+
elif False:
|
|
5025
|
+
ServiceTaskSpecContainerSpecSecretArgsDict: TypeAlias = Mapping[str, Any]
|
|
5026
|
+
|
|
3829
5027
|
@pulumi.input_type
|
|
3830
5028
|
class ServiceTaskSpecContainerSpecSecretArgs:
|
|
3831
5029
|
def __init__(__self__, *,
|
|
@@ -3927,6 +5125,19 @@ class ServiceTaskSpecContainerSpecSecretArgs:
|
|
|
3927
5125
|
pulumi.set(self, "secret_name", value)
|
|
3928
5126
|
|
|
3929
5127
|
|
|
5128
|
+
if not MYPY:
|
|
5129
|
+
class ServiceTaskSpecLogDriverArgsDict(TypedDict):
|
|
5130
|
+
name: pulumi.Input[str]
|
|
5131
|
+
"""
|
|
5132
|
+
The logging driver to use
|
|
5133
|
+
"""
|
|
5134
|
+
options: NotRequired[pulumi.Input[Mapping[str, pulumi.Input[str]]]]
|
|
5135
|
+
"""
|
|
5136
|
+
The options for the logging driver
|
|
5137
|
+
"""
|
|
5138
|
+
elif False:
|
|
5139
|
+
ServiceTaskSpecLogDriverArgsDict: TypeAlias = Mapping[str, Any]
|
|
5140
|
+
|
|
3930
5141
|
@pulumi.input_type
|
|
3931
5142
|
class ServiceTaskSpecLogDriverArgs:
|
|
3932
5143
|
def __init__(__self__, *,
|
|
@@ -3965,6 +5176,23 @@ class ServiceTaskSpecLogDriverArgs:
|
|
|
3965
5176
|
pulumi.set(self, "options", value)
|
|
3966
5177
|
|
|
3967
5178
|
|
|
5179
|
+
if not MYPY:
|
|
5180
|
+
class ServiceTaskSpecNetworksAdvancedArgsDict(TypedDict):
|
|
5181
|
+
name: pulumi.Input[str]
|
|
5182
|
+
"""
|
|
5183
|
+
The name/id of the network.
|
|
5184
|
+
"""
|
|
5185
|
+
aliases: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
|
|
5186
|
+
"""
|
|
5187
|
+
The network aliases of the container in the specific network.
|
|
5188
|
+
"""
|
|
5189
|
+
driver_opts: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
|
|
5190
|
+
"""
|
|
5191
|
+
An array of driver options for the network, e.g. `opts1=value`
|
|
5192
|
+
"""
|
|
5193
|
+
elif False:
|
|
5194
|
+
ServiceTaskSpecNetworksAdvancedArgsDict: TypeAlias = Mapping[str, Any]
|
|
5195
|
+
|
|
3968
5196
|
@pulumi.input_type
|
|
3969
5197
|
class ServiceTaskSpecNetworksAdvancedArgs:
|
|
3970
5198
|
def __init__(__self__, *,
|
|
@@ -4019,6 +5247,27 @@ class ServiceTaskSpecNetworksAdvancedArgs:
|
|
|
4019
5247
|
pulumi.set(self, "driver_opts", value)
|
|
4020
5248
|
|
|
4021
5249
|
|
|
5250
|
+
if not MYPY:
|
|
5251
|
+
class ServiceTaskSpecPlacementArgsDict(TypedDict):
|
|
5252
|
+
constraints: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
|
|
5253
|
+
"""
|
|
5254
|
+
An array of constraints. e.g.: `node.role==manager`
|
|
5255
|
+
"""
|
|
5256
|
+
max_replicas: NotRequired[pulumi.Input[int]]
|
|
5257
|
+
"""
|
|
5258
|
+
Maximum number of replicas for per node (default value is `0`, which is unlimited)
|
|
5259
|
+
"""
|
|
5260
|
+
platforms: NotRequired[pulumi.Input[Sequence[pulumi.Input['ServiceTaskSpecPlacementPlatformArgsDict']]]]
|
|
5261
|
+
"""
|
|
5262
|
+
Platforms stores all the platforms that the service's image can run on
|
|
5263
|
+
"""
|
|
5264
|
+
prefs: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
|
|
5265
|
+
"""
|
|
5266
|
+
Preferences provide a way to make the scheduler aware of factors such as topology. They are provided in order from highest to lowest precedence, e.g.: `spread=node.role.manager`
|
|
5267
|
+
"""
|
|
5268
|
+
elif False:
|
|
5269
|
+
ServiceTaskSpecPlacementArgsDict: TypeAlias = Mapping[str, Any]
|
|
5270
|
+
|
|
4022
5271
|
@pulumi.input_type
|
|
4023
5272
|
class ServiceTaskSpecPlacementArgs:
|
|
4024
5273
|
def __init__(__self__, *,
|
|
@@ -4090,6 +5339,19 @@ class ServiceTaskSpecPlacementArgs:
|
|
|
4090
5339
|
pulumi.set(self, "prefs", value)
|
|
4091
5340
|
|
|
4092
5341
|
|
|
5342
|
+
if not MYPY:
|
|
5343
|
+
class ServiceTaskSpecPlacementPlatformArgsDict(TypedDict):
|
|
5344
|
+
architecture: pulumi.Input[str]
|
|
5345
|
+
"""
|
|
5346
|
+
The architecture, e.g. `amd64`
|
|
5347
|
+
"""
|
|
5348
|
+
os: pulumi.Input[str]
|
|
5349
|
+
"""
|
|
5350
|
+
The operation system, e.g. `linux`
|
|
5351
|
+
"""
|
|
5352
|
+
elif False:
|
|
5353
|
+
ServiceTaskSpecPlacementPlatformArgsDict: TypeAlias = Mapping[str, Any]
|
|
5354
|
+
|
|
4093
5355
|
@pulumi.input_type
|
|
4094
5356
|
class ServiceTaskSpecPlacementPlatformArgs:
|
|
4095
5357
|
def __init__(__self__, *,
|
|
@@ -4127,6 +5389,19 @@ class ServiceTaskSpecPlacementPlatformArgs:
|
|
|
4127
5389
|
pulumi.set(self, "os", value)
|
|
4128
5390
|
|
|
4129
5391
|
|
|
5392
|
+
if not MYPY:
|
|
5393
|
+
class ServiceTaskSpecResourcesArgsDict(TypedDict):
|
|
5394
|
+
limits: NotRequired[pulumi.Input['ServiceTaskSpecResourcesLimitsArgsDict']]
|
|
5395
|
+
"""
|
|
5396
|
+
Describes the resources which can be advertised by a node and requested by a task
|
|
5397
|
+
"""
|
|
5398
|
+
reservation: NotRequired[pulumi.Input['ServiceTaskSpecResourcesReservationArgsDict']]
|
|
5399
|
+
"""
|
|
5400
|
+
An object describing the resources which can be advertised by a node and requested by a task
|
|
5401
|
+
"""
|
|
5402
|
+
elif False:
|
|
5403
|
+
ServiceTaskSpecResourcesArgsDict: TypeAlias = Mapping[str, Any]
|
|
5404
|
+
|
|
4130
5405
|
@pulumi.input_type
|
|
4131
5406
|
class ServiceTaskSpecResourcesArgs:
|
|
4132
5407
|
def __init__(__self__, *,
|
|
@@ -4166,6 +5441,19 @@ class ServiceTaskSpecResourcesArgs:
|
|
|
4166
5441
|
pulumi.set(self, "reservation", value)
|
|
4167
5442
|
|
|
4168
5443
|
|
|
5444
|
+
if not MYPY:
|
|
5445
|
+
class ServiceTaskSpecResourcesLimitsArgsDict(TypedDict):
|
|
5446
|
+
memory_bytes: NotRequired[pulumi.Input[int]]
|
|
5447
|
+
"""
|
|
5448
|
+
The amounf of memory in bytes the container allocates
|
|
5449
|
+
"""
|
|
5450
|
+
nano_cpus: NotRequired[pulumi.Input[int]]
|
|
5451
|
+
"""
|
|
5452
|
+
CPU shares in units of `1/1e9` (or `10^-9`) of the CPU. Should be at least `1000000`
|
|
5453
|
+
"""
|
|
5454
|
+
elif False:
|
|
5455
|
+
ServiceTaskSpecResourcesLimitsArgsDict: TypeAlias = Mapping[str, Any]
|
|
5456
|
+
|
|
4169
5457
|
@pulumi.input_type
|
|
4170
5458
|
class ServiceTaskSpecResourcesLimitsArgs:
|
|
4171
5459
|
def __init__(__self__, *,
|
|
@@ -4205,6 +5493,23 @@ class ServiceTaskSpecResourcesLimitsArgs:
|
|
|
4205
5493
|
pulumi.set(self, "nano_cpus", value)
|
|
4206
5494
|
|
|
4207
5495
|
|
|
5496
|
+
if not MYPY:
|
|
5497
|
+
class ServiceTaskSpecResourcesReservationArgsDict(TypedDict):
|
|
5498
|
+
generic_resources: NotRequired[pulumi.Input['ServiceTaskSpecResourcesReservationGenericResourcesArgsDict']]
|
|
5499
|
+
"""
|
|
5500
|
+
User-defined resources can be either Integer resources (e.g, `SSD=3`) or String resources (e.g, GPU=UUID1)
|
|
5501
|
+
"""
|
|
5502
|
+
memory_bytes: NotRequired[pulumi.Input[int]]
|
|
5503
|
+
"""
|
|
5504
|
+
The amounf of memory in bytes the container allocates
|
|
5505
|
+
"""
|
|
5506
|
+
nano_cpus: NotRequired[pulumi.Input[int]]
|
|
5507
|
+
"""
|
|
5508
|
+
CPU shares in units of 1/1e9 (or 10^-9) of the CPU. Should be at least `1000000`
|
|
5509
|
+
"""
|
|
5510
|
+
elif False:
|
|
5511
|
+
ServiceTaskSpecResourcesReservationArgsDict: TypeAlias = Mapping[str, Any]
|
|
5512
|
+
|
|
4208
5513
|
@pulumi.input_type
|
|
4209
5514
|
class ServiceTaskSpecResourcesReservationArgs:
|
|
4210
5515
|
def __init__(__self__, *,
|
|
@@ -4260,6 +5565,19 @@ class ServiceTaskSpecResourcesReservationArgs:
|
|
|
4260
5565
|
pulumi.set(self, "nano_cpus", value)
|
|
4261
5566
|
|
|
4262
5567
|
|
|
5568
|
+
if not MYPY:
|
|
5569
|
+
class ServiceTaskSpecResourcesReservationGenericResourcesArgsDict(TypedDict):
|
|
5570
|
+
discrete_resources_specs: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
|
|
5571
|
+
"""
|
|
5572
|
+
The Integer resources
|
|
5573
|
+
"""
|
|
5574
|
+
named_resources_specs: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
|
|
5575
|
+
"""
|
|
5576
|
+
The String resources
|
|
5577
|
+
"""
|
|
5578
|
+
elif False:
|
|
5579
|
+
ServiceTaskSpecResourcesReservationGenericResourcesArgsDict: TypeAlias = Mapping[str, Any]
|
|
5580
|
+
|
|
4263
5581
|
@pulumi.input_type
|
|
4264
5582
|
class ServiceTaskSpecResourcesReservationGenericResourcesArgs:
|
|
4265
5583
|
def __init__(__self__, *,
|
|
@@ -4299,6 +5617,27 @@ class ServiceTaskSpecResourcesReservationGenericResourcesArgs:
|
|
|
4299
5617
|
pulumi.set(self, "named_resources_specs", value)
|
|
4300
5618
|
|
|
4301
5619
|
|
|
5620
|
+
if not MYPY:
|
|
5621
|
+
class ServiceTaskSpecRestartPolicyArgsDict(TypedDict):
|
|
5622
|
+
condition: NotRequired[pulumi.Input[str]]
|
|
5623
|
+
"""
|
|
5624
|
+
Condition for restart
|
|
5625
|
+
"""
|
|
5626
|
+
delay: NotRequired[pulumi.Input[str]]
|
|
5627
|
+
"""
|
|
5628
|
+
Delay between restart attempts (ms|s|m|h)
|
|
5629
|
+
"""
|
|
5630
|
+
max_attempts: NotRequired[pulumi.Input[int]]
|
|
5631
|
+
"""
|
|
5632
|
+
Maximum attempts to restart a given container before giving up (default value is `0`, which is ignored)
|
|
5633
|
+
"""
|
|
5634
|
+
window: NotRequired[pulumi.Input[str]]
|
|
5635
|
+
"""
|
|
5636
|
+
The time window used to evaluate the restart policy (default value is `0`, which is unbounded) (ms|s|m|h)
|
|
5637
|
+
"""
|
|
5638
|
+
elif False:
|
|
5639
|
+
ServiceTaskSpecRestartPolicyArgsDict: TypeAlias = Mapping[str, Any]
|
|
5640
|
+
|
|
4302
5641
|
@pulumi.input_type
|
|
4303
5642
|
class ServiceTaskSpecRestartPolicyArgs:
|
|
4304
5643
|
def __init__(__self__, *,
|
|
@@ -4370,6 +5709,35 @@ class ServiceTaskSpecRestartPolicyArgs:
|
|
|
4370
5709
|
pulumi.set(self, "window", value)
|
|
4371
5710
|
|
|
4372
5711
|
|
|
5712
|
+
if not MYPY:
|
|
5713
|
+
class ServiceUpdateConfigArgsDict(TypedDict):
|
|
5714
|
+
delay: NotRequired[pulumi.Input[str]]
|
|
5715
|
+
"""
|
|
5716
|
+
Delay between task updates `(ns|us|ms|s|m|h)`. Defaults to `0s`.
|
|
5717
|
+
"""
|
|
5718
|
+
failure_action: NotRequired[pulumi.Input[str]]
|
|
5719
|
+
"""
|
|
5720
|
+
Action on update failure: `pause`, `continue` or `rollback`. Defaults to `pause`.
|
|
5721
|
+
"""
|
|
5722
|
+
max_failure_ratio: NotRequired[pulumi.Input[str]]
|
|
5723
|
+
"""
|
|
5724
|
+
Failure rate to tolerate during an update. Defaults to `0.0`.
|
|
5725
|
+
"""
|
|
5726
|
+
monitor: NotRequired[pulumi.Input[str]]
|
|
5727
|
+
"""
|
|
5728
|
+
Duration after each task update to monitor for failure (ns|us|ms|s|m|h). Defaults to `5s`.
|
|
5729
|
+
"""
|
|
5730
|
+
order: NotRequired[pulumi.Input[str]]
|
|
5731
|
+
"""
|
|
5732
|
+
Update order: either 'stop-first' or 'start-first'. Defaults to `stop-first`.
|
|
5733
|
+
"""
|
|
5734
|
+
parallelism: NotRequired[pulumi.Input[int]]
|
|
5735
|
+
"""
|
|
5736
|
+
Maximum number of tasks to be updated in one iteration. Defaults to `1`
|
|
5737
|
+
"""
|
|
5738
|
+
elif False:
|
|
5739
|
+
ServiceUpdateConfigArgsDict: TypeAlias = Mapping[str, Any]
|
|
5740
|
+
|
|
4373
5741
|
@pulumi.input_type
|
|
4374
5742
|
class ServiceUpdateConfigArgs:
|
|
4375
5743
|
def __init__(__self__, *,
|
|
@@ -4473,6 +5841,19 @@ class ServiceUpdateConfigArgs:
|
|
|
4473
5841
|
pulumi.set(self, "parallelism", value)
|
|
4474
5842
|
|
|
4475
5843
|
|
|
5844
|
+
if not MYPY:
|
|
5845
|
+
class VolumeLabelArgsDict(TypedDict):
|
|
5846
|
+
label: pulumi.Input[str]
|
|
5847
|
+
"""
|
|
5848
|
+
Name of the label
|
|
5849
|
+
"""
|
|
5850
|
+
value: pulumi.Input[str]
|
|
5851
|
+
"""
|
|
5852
|
+
Value of the label
|
|
5853
|
+
"""
|
|
5854
|
+
elif False:
|
|
5855
|
+
VolumeLabelArgsDict: TypeAlias = Mapping[str, Any]
|
|
5856
|
+
|
|
4476
5857
|
@pulumi.input_type
|
|
4477
5858
|
class VolumeLabelArgs:
|
|
4478
5859
|
def __init__(__self__, *,
|
|
@@ -4510,6 +5891,18 @@ class VolumeLabelArgs:
|
|
|
4510
5891
|
pulumi.set(self, "value", value)
|
|
4511
5892
|
|
|
4512
5893
|
|
|
5894
|
+
if not MYPY:
|
|
5895
|
+
class CacheFromArgsDict(TypedDict):
|
|
5896
|
+
"""
|
|
5897
|
+
Contains a list of images to reference when building using a cache
|
|
5898
|
+
"""
|
|
5899
|
+
images: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
|
|
5900
|
+
"""
|
|
5901
|
+
Specifies cached images
|
|
5902
|
+
"""
|
|
5903
|
+
elif False:
|
|
5904
|
+
CacheFromArgsDict: TypeAlias = Mapping[str, Any]
|
|
5905
|
+
|
|
4513
5906
|
@pulumi.input_type
|
|
4514
5907
|
class CacheFromArgs:
|
|
4515
5908
|
def __init__(__self__, *,
|
|
@@ -4534,6 +5927,50 @@ class CacheFromArgs:
|
|
|
4534
5927
|
pulumi.set(self, "images", value)
|
|
4535
5928
|
|
|
4536
5929
|
|
|
5930
|
+
if not MYPY:
|
|
5931
|
+
class DockerBuildArgsDict(TypedDict):
|
|
5932
|
+
"""
|
|
5933
|
+
The Docker build context
|
|
5934
|
+
"""
|
|
5935
|
+
add_hosts: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
|
|
5936
|
+
"""
|
|
5937
|
+
Custom host-to-IP mappings to use while building (format: "host:ip")
|
|
5938
|
+
"""
|
|
5939
|
+
args: NotRequired[pulumi.Input[Mapping[str, pulumi.Input[str]]]]
|
|
5940
|
+
"""
|
|
5941
|
+
An optional map of named build-time argument variables to set during the Docker build. This flag allows you to pass build-time variables that can be accessed like environment variables inside the RUN instruction.
|
|
5942
|
+
"""
|
|
5943
|
+
builder_version: NotRequired[pulumi.Input['BuilderVersion']]
|
|
5944
|
+
"""
|
|
5945
|
+
The version of the Docker builder.
|
|
5946
|
+
"""
|
|
5947
|
+
cache_from: NotRequired[pulumi.Input['CacheFromArgsDict']]
|
|
5948
|
+
"""
|
|
5949
|
+
A list of image names to use as build cache. Images provided must have a cache manifest. Must provide authentication to cache registry.
|
|
5950
|
+
"""
|
|
5951
|
+
context: NotRequired[pulumi.Input[str]]
|
|
5952
|
+
"""
|
|
5953
|
+
The path to the build context to use.
|
|
5954
|
+
"""
|
|
5955
|
+
dockerfile: NotRequired[pulumi.Input[str]]
|
|
5956
|
+
"""
|
|
5957
|
+
The path to the Dockerfile to use.
|
|
5958
|
+
"""
|
|
5959
|
+
network: NotRequired[pulumi.Input[str]]
|
|
5960
|
+
"""
|
|
5961
|
+
Set the networking mode for RUN instructions
|
|
5962
|
+
"""
|
|
5963
|
+
platform: NotRequired[pulumi.Input[str]]
|
|
5964
|
+
"""
|
|
5965
|
+
The architecture of the platform you want to build this image for, e.g. `linux/arm64`.
|
|
5966
|
+
"""
|
|
5967
|
+
target: NotRequired[pulumi.Input[str]]
|
|
5968
|
+
"""
|
|
5969
|
+
The target of the Dockerfile to build
|
|
5970
|
+
"""
|
|
5971
|
+
elif False:
|
|
5972
|
+
DockerBuildArgsDict: TypeAlias = Mapping[str, Any]
|
|
5973
|
+
|
|
4537
5974
|
@pulumi.input_type
|
|
4538
5975
|
class DockerBuildArgs:
|
|
4539
5976
|
def __init__(__self__, *,
|
|
@@ -4686,6 +6123,26 @@ class DockerBuildArgs:
|
|
|
4686
6123
|
pulumi.set(self, "target", value)
|
|
4687
6124
|
|
|
4688
6125
|
|
|
6126
|
+
if not MYPY:
|
|
6127
|
+
class RegistryArgsDict(TypedDict):
|
|
6128
|
+
"""
|
|
6129
|
+
Describes a Docker container registry
|
|
6130
|
+
"""
|
|
6131
|
+
password: NotRequired[pulumi.Input[str]]
|
|
6132
|
+
"""
|
|
6133
|
+
The password to authenticate to the registry. Does not cause image rebuild when changed.
|
|
6134
|
+
"""
|
|
6135
|
+
server: NotRequired[pulumi.Input[str]]
|
|
6136
|
+
"""
|
|
6137
|
+
The URL of the Docker registry server
|
|
6138
|
+
"""
|
|
6139
|
+
username: NotRequired[pulumi.Input[str]]
|
|
6140
|
+
"""
|
|
6141
|
+
The username to authenticate to the registry. Does not cause image rebuild when changed.
|
|
6142
|
+
"""
|
|
6143
|
+
elif False:
|
|
6144
|
+
RegistryArgsDict: TypeAlias = Mapping[str, Any]
|
|
6145
|
+
|
|
4689
6146
|
@pulumi.input_type
|
|
4690
6147
|
class RegistryArgs:
|
|
4691
6148
|
def __init__(__self__, *,
|