pulumi-docker 4.7.0a1705628423__py3-none-any.whl → 4.7.0a1736833147__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/_inputs.py +1583 -34
- pulumi_docker/_utilities.py +43 -7
- pulumi_docker/config/__init__.pyi +5 -0
- pulumi_docker/config/outputs.py +27 -0
- pulumi_docker/config/vars.py +5 -0
- pulumi_docker/container.py +202 -181
- 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 +73 -52
- pulumi_docker/network.py +95 -46
- pulumi_docker/outputs.py +95 -34
- pulumi_docker/plugin.py +19 -46
- pulumi_docker/provider.py +7 -2
- 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 +16 -7
- pulumi_docker/service.py +127 -82
- pulumi_docker/service_config.py +55 -10
- pulumi_docker/tag.py +5 -0
- pulumi_docker/volume.py +76 -27
- {pulumi_docker-4.7.0a1705628423.dist-info → pulumi_docker-4.7.0a1736833147.dist-info}/METADATA +7 -6
- pulumi_docker-4.7.0a1736833147.dist-info/RECORD +32 -0
- {pulumi_docker-4.7.0a1705628423.dist-info → pulumi_docker-4.7.0a1736833147.dist-info}/WHEEL +1 -1
- pulumi_docker-4.7.0a1705628423.dist-info/RECORD +0 -32
- {pulumi_docker-4.7.0a1705628423.dist-info → pulumi_docker-4.7.0a1736833147.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__, *,
|
|
@@ -626,6 +902,16 @@ class ContainerNetworkDataArgs:
|
|
|
626
902
|
ipv6_gateway: Optional[pulumi.Input[str]] = None,
|
|
627
903
|
mac_address: Optional[pulumi.Input[str]] = None,
|
|
628
904
|
network_name: Optional[pulumi.Input[str]] = None):
|
|
905
|
+
"""
|
|
906
|
+
:param pulumi.Input[str] gateway: The network gateway of the container.
|
|
907
|
+
:param pulumi.Input[str] global_ipv6_address: The IPV6 address of the container.
|
|
908
|
+
:param pulumi.Input[int] global_ipv6_prefix_length: The IPV6 prefix length address of the container.
|
|
909
|
+
:param pulumi.Input[str] ip_address: The IP address of the container.
|
|
910
|
+
:param pulumi.Input[int] ip_prefix_length: The IP prefix length of the container.
|
|
911
|
+
:param pulumi.Input[str] ipv6_gateway: The IPV6 gateway of the container.
|
|
912
|
+
:param pulumi.Input[str] mac_address: The MAC address of the container.
|
|
913
|
+
:param pulumi.Input[str] network_name: The name of the network
|
|
914
|
+
"""
|
|
629
915
|
if gateway is not None:
|
|
630
916
|
pulumi.set(__self__, "gateway", gateway)
|
|
631
917
|
if global_ipv6_address is not None:
|
|
@@ -646,6 +932,9 @@ class ContainerNetworkDataArgs:
|
|
|
646
932
|
@property
|
|
647
933
|
@pulumi.getter
|
|
648
934
|
def gateway(self) -> Optional[pulumi.Input[str]]:
|
|
935
|
+
"""
|
|
936
|
+
The network gateway of the container.
|
|
937
|
+
"""
|
|
649
938
|
return pulumi.get(self, "gateway")
|
|
650
939
|
|
|
651
940
|
@gateway.setter
|
|
@@ -655,6 +944,9 @@ class ContainerNetworkDataArgs:
|
|
|
655
944
|
@property
|
|
656
945
|
@pulumi.getter(name="globalIpv6Address")
|
|
657
946
|
def global_ipv6_address(self) -> Optional[pulumi.Input[str]]:
|
|
947
|
+
"""
|
|
948
|
+
The IPV6 address of the container.
|
|
949
|
+
"""
|
|
658
950
|
return pulumi.get(self, "global_ipv6_address")
|
|
659
951
|
|
|
660
952
|
@global_ipv6_address.setter
|
|
@@ -664,6 +956,9 @@ class ContainerNetworkDataArgs:
|
|
|
664
956
|
@property
|
|
665
957
|
@pulumi.getter(name="globalIpv6PrefixLength")
|
|
666
958
|
def global_ipv6_prefix_length(self) -> Optional[pulumi.Input[int]]:
|
|
959
|
+
"""
|
|
960
|
+
The IPV6 prefix length address of the container.
|
|
961
|
+
"""
|
|
667
962
|
return pulumi.get(self, "global_ipv6_prefix_length")
|
|
668
963
|
|
|
669
964
|
@global_ipv6_prefix_length.setter
|
|
@@ -673,6 +968,9 @@ class ContainerNetworkDataArgs:
|
|
|
673
968
|
@property
|
|
674
969
|
@pulumi.getter(name="ipAddress")
|
|
675
970
|
def ip_address(self) -> Optional[pulumi.Input[str]]:
|
|
971
|
+
"""
|
|
972
|
+
The IP address of the container.
|
|
973
|
+
"""
|
|
676
974
|
return pulumi.get(self, "ip_address")
|
|
677
975
|
|
|
678
976
|
@ip_address.setter
|
|
@@ -682,6 +980,9 @@ class ContainerNetworkDataArgs:
|
|
|
682
980
|
@property
|
|
683
981
|
@pulumi.getter(name="ipPrefixLength")
|
|
684
982
|
def ip_prefix_length(self) -> Optional[pulumi.Input[int]]:
|
|
983
|
+
"""
|
|
984
|
+
The IP prefix length of the container.
|
|
985
|
+
"""
|
|
685
986
|
return pulumi.get(self, "ip_prefix_length")
|
|
686
987
|
|
|
687
988
|
@ip_prefix_length.setter
|
|
@@ -691,6 +992,9 @@ class ContainerNetworkDataArgs:
|
|
|
691
992
|
@property
|
|
692
993
|
@pulumi.getter(name="ipv6Gateway")
|
|
693
994
|
def ipv6_gateway(self) -> Optional[pulumi.Input[str]]:
|
|
995
|
+
"""
|
|
996
|
+
The IPV6 gateway of the container.
|
|
997
|
+
"""
|
|
694
998
|
return pulumi.get(self, "ipv6_gateway")
|
|
695
999
|
|
|
696
1000
|
@ipv6_gateway.setter
|
|
@@ -700,6 +1004,9 @@ class ContainerNetworkDataArgs:
|
|
|
700
1004
|
@property
|
|
701
1005
|
@pulumi.getter(name="macAddress")
|
|
702
1006
|
def mac_address(self) -> Optional[pulumi.Input[str]]:
|
|
1007
|
+
"""
|
|
1008
|
+
The MAC address of the container.
|
|
1009
|
+
"""
|
|
703
1010
|
return pulumi.get(self, "mac_address")
|
|
704
1011
|
|
|
705
1012
|
@mac_address.setter
|
|
@@ -709,6 +1016,9 @@ class ContainerNetworkDataArgs:
|
|
|
709
1016
|
@property
|
|
710
1017
|
@pulumi.getter(name="networkName")
|
|
711
1018
|
def network_name(self) -> Optional[pulumi.Input[str]]:
|
|
1019
|
+
"""
|
|
1020
|
+
The name of the network
|
|
1021
|
+
"""
|
|
712
1022
|
return pulumi.get(self, "network_name")
|
|
713
1023
|
|
|
714
1024
|
@network_name.setter
|
|
@@ -716,6 +1026,27 @@ class ContainerNetworkDataArgs:
|
|
|
716
1026
|
pulumi.set(self, "network_name", value)
|
|
717
1027
|
|
|
718
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
|
+
|
|
719
1050
|
@pulumi.input_type
|
|
720
1051
|
class ContainerNetworksAdvancedArgs:
|
|
721
1052
|
def __init__(__self__, *,
|
|
@@ -786,6 +1117,27 @@ class ContainerNetworksAdvancedArgs:
|
|
|
786
1117
|
pulumi.set(self, "ipv6_address", value)
|
|
787
1118
|
|
|
788
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
|
+
|
|
789
1141
|
@pulumi.input_type
|
|
790
1142
|
class ContainerPortArgs:
|
|
791
1143
|
def __init__(__self__, *,
|
|
@@ -856,6 +1208,23 @@ class ContainerPortArgs:
|
|
|
856
1208
|
pulumi.set(self, "protocol", value)
|
|
857
1209
|
|
|
858
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
|
+
|
|
859
1228
|
@pulumi.input_type
|
|
860
1229
|
class ContainerUlimitArgs:
|
|
861
1230
|
def __init__(__self__, *,
|
|
@@ -908,6 +1277,35 @@ class ContainerUlimitArgs:
|
|
|
908
1277
|
pulumi.set(self, "soft", value)
|
|
909
1278
|
|
|
910
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
|
+
|
|
911
1309
|
@pulumi.input_type
|
|
912
1310
|
class ContainerUploadArgs:
|
|
913
1311
|
def __init__(__self__, *,
|
|
@@ -920,6 +1318,7 @@ class ContainerUploadArgs:
|
|
|
920
1318
|
"""
|
|
921
1319
|
:param pulumi.Input[str] file: Path to the file in the container where is upload goes to
|
|
922
1320
|
:param pulumi.Input[str] content: Literal string value to use as the object content, which will be uploaded as UTF-8-encoded text. Conflicts with `content_base64` & `source`
|
|
1321
|
+
:param pulumi.Input[str] content_base64: 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`
|
|
923
1322
|
:param pulumi.Input[bool] executable: If `true`, the file will be uploaded with user executable permission. Defaults to `false`.
|
|
924
1323
|
:param pulumi.Input[str] source: 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`
|
|
925
1324
|
:param pulumi.Input[str] source_hash: If using `source`, this will force an update if the file content has updated but the filename has not.
|
|
@@ -963,6 +1362,9 @@ class ContainerUploadArgs:
|
|
|
963
1362
|
@property
|
|
964
1363
|
@pulumi.getter(name="contentBase64")
|
|
965
1364
|
def content_base64(self) -> Optional[pulumi.Input[str]]:
|
|
1365
|
+
"""
|
|
1366
|
+
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`
|
|
1367
|
+
"""
|
|
966
1368
|
return pulumi.get(self, "content_base64")
|
|
967
1369
|
|
|
968
1370
|
@content_base64.setter
|
|
@@ -1006,6 +1408,31 @@ class ContainerUploadArgs:
|
|
|
1006
1408
|
pulumi.set(self, "source_hash", value)
|
|
1007
1409
|
|
|
1008
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
|
+
|
|
1009
1436
|
@pulumi.input_type
|
|
1010
1437
|
class ContainerVolumeArgs:
|
|
1011
1438
|
def __init__(__self__, *,
|
|
@@ -1093,15 +1520,36 @@ class ContainerVolumeArgs:
|
|
|
1093
1520
|
pulumi.set(self, "volume_name", value)
|
|
1094
1521
|
|
|
1095
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
|
+
|
|
1096
1544
|
@pulumi.input_type
|
|
1097
1545
|
class NetworkIpamConfigArgs:
|
|
1098
1546
|
def __init__(__self__, *,
|
|
1099
|
-
aux_address: Optional[pulumi.Input[Mapping[str,
|
|
1547
|
+
aux_address: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None,
|
|
1100
1548
|
gateway: Optional[pulumi.Input[str]] = None,
|
|
1101
1549
|
ip_range: Optional[pulumi.Input[str]] = None,
|
|
1102
1550
|
subnet: Optional[pulumi.Input[str]] = None):
|
|
1103
1551
|
"""
|
|
1104
|
-
: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
|
|
1105
1553
|
:param pulumi.Input[str] gateway: The IP address of the gateway
|
|
1106
1554
|
:param pulumi.Input[str] ip_range: The ip range in CIDR form
|
|
1107
1555
|
:param pulumi.Input[str] subnet: The subnet in CIDR form
|
|
@@ -1117,14 +1565,14 @@ class NetworkIpamConfigArgs:
|
|
|
1117
1565
|
|
|
1118
1566
|
@property
|
|
1119
1567
|
@pulumi.getter(name="auxAddress")
|
|
1120
|
-
def aux_address(self) -> Optional[pulumi.Input[Mapping[str,
|
|
1568
|
+
def aux_address(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]:
|
|
1121
1569
|
"""
|
|
1122
1570
|
Auxiliary IPv4 or IPv6 addresses used by Network driver
|
|
1123
1571
|
"""
|
|
1124
1572
|
return pulumi.get(self, "aux_address")
|
|
1125
1573
|
|
|
1126
1574
|
@aux_address.setter
|
|
1127
|
-
def aux_address(self, value: Optional[pulumi.Input[Mapping[str,
|
|
1575
|
+
def aux_address(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]):
|
|
1128
1576
|
pulumi.set(self, "aux_address", value)
|
|
1129
1577
|
|
|
1130
1578
|
@property
|
|
@@ -1164,6 +1612,19 @@ class NetworkIpamConfigArgs:
|
|
|
1164
1612
|
pulumi.set(self, "subnet", value)
|
|
1165
1613
|
|
|
1166
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
|
+
|
|
1167
1628
|
@pulumi.input_type
|
|
1168
1629
|
class NetworkLabelArgs:
|
|
1169
1630
|
def __init__(__self__, *,
|
|
@@ -1201,6 +1662,19 @@ class NetworkLabelArgs:
|
|
|
1201
1662
|
pulumi.set(self, "value", value)
|
|
1202
1663
|
|
|
1203
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
|
+
|
|
1204
1678
|
@pulumi.input_type
|
|
1205
1679
|
class PluginGrantPermissionArgs:
|
|
1206
1680
|
def __init__(__self__, *,
|
|
@@ -1238,6 +1712,32 @@ class PluginGrantPermissionArgs:
|
|
|
1238
1712
|
pulumi.set(self, "values", value)
|
|
1239
1713
|
|
|
1240
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
|
+
|
|
1241
1741
|
@pulumi.input_type
|
|
1242
1742
|
class ProviderRegistryAuthArgs:
|
|
1243
1743
|
def __init__(__self__, *,
|
|
@@ -1247,6 +1747,13 @@ class ProviderRegistryAuthArgs:
|
|
|
1247
1747
|
config_file_content: Optional[pulumi.Input[str]] = None,
|
|
1248
1748
|
password: Optional[pulumi.Input[str]] = None,
|
|
1249
1749
|
username: Optional[pulumi.Input[str]] = None):
|
|
1750
|
+
"""
|
|
1751
|
+
:param pulumi.Input[str] address: Address of the registry
|
|
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.
|
|
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.
|
|
1754
|
+
:param pulumi.Input[str] password: Password for the registry. Defaults to `DOCKER_REGISTRY_PASS` env variable if set.
|
|
1755
|
+
:param pulumi.Input[str] username: Username for the registry. Defaults to `DOCKER_REGISTRY_USER` env variable if set.
|
|
1756
|
+
"""
|
|
1250
1757
|
pulumi.set(__self__, "address", address)
|
|
1251
1758
|
if auth_disabled is not None:
|
|
1252
1759
|
pulumi.set(__self__, "auth_disabled", auth_disabled)
|
|
@@ -1262,6 +1769,9 @@ class ProviderRegistryAuthArgs:
|
|
|
1262
1769
|
@property
|
|
1263
1770
|
@pulumi.getter
|
|
1264
1771
|
def address(self) -> pulumi.Input[str]:
|
|
1772
|
+
"""
|
|
1773
|
+
Address of the registry
|
|
1774
|
+
"""
|
|
1265
1775
|
return pulumi.get(self, "address")
|
|
1266
1776
|
|
|
1267
1777
|
@address.setter
|
|
@@ -1280,6 +1790,9 @@ class ProviderRegistryAuthArgs:
|
|
|
1280
1790
|
@property
|
|
1281
1791
|
@pulumi.getter(name="configFile")
|
|
1282
1792
|
def config_file(self) -> Optional[pulumi.Input[str]]:
|
|
1793
|
+
"""
|
|
1794
|
+
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.
|
|
1795
|
+
"""
|
|
1283
1796
|
return pulumi.get(self, "config_file")
|
|
1284
1797
|
|
|
1285
1798
|
@config_file.setter
|
|
@@ -1289,6 +1802,9 @@ class ProviderRegistryAuthArgs:
|
|
|
1289
1802
|
@property
|
|
1290
1803
|
@pulumi.getter(name="configFileContent")
|
|
1291
1804
|
def config_file_content(self) -> Optional[pulumi.Input[str]]:
|
|
1805
|
+
"""
|
|
1806
|
+
Plain content of the docker json file for registry auth. `config_file_content` has precedence over username/password.
|
|
1807
|
+
"""
|
|
1292
1808
|
return pulumi.get(self, "config_file_content")
|
|
1293
1809
|
|
|
1294
1810
|
@config_file_content.setter
|
|
@@ -1298,6 +1814,9 @@ class ProviderRegistryAuthArgs:
|
|
|
1298
1814
|
@property
|
|
1299
1815
|
@pulumi.getter
|
|
1300
1816
|
def password(self) -> Optional[pulumi.Input[str]]:
|
|
1817
|
+
"""
|
|
1818
|
+
Password for the registry. Defaults to `DOCKER_REGISTRY_PASS` env variable if set.
|
|
1819
|
+
"""
|
|
1301
1820
|
return pulumi.get(self, "password")
|
|
1302
1821
|
|
|
1303
1822
|
@password.setter
|
|
@@ -1307,6 +1826,9 @@ class ProviderRegistryAuthArgs:
|
|
|
1307
1826
|
@property
|
|
1308
1827
|
@pulumi.getter
|
|
1309
1828
|
def username(self) -> Optional[pulumi.Input[str]]:
|
|
1829
|
+
"""
|
|
1830
|
+
Username for the registry. Defaults to `DOCKER_REGISTRY_USER` env variable if set.
|
|
1831
|
+
"""
|
|
1310
1832
|
return pulumi.get(self, "username")
|
|
1311
1833
|
|
|
1312
1834
|
@username.setter
|
|
@@ -1314,6 +1836,151 @@ class ProviderRegistryAuthArgs:
|
|
|
1314
1836
|
pulumi.set(self, "username", value)
|
|
1315
1837
|
|
|
1316
1838
|
|
|
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
|
+
|
|
1317
1984
|
@pulumi.input_type
|
|
1318
1985
|
class RemoteImageBuildArgs:
|
|
1319
1986
|
def __init__(__self__, *,
|
|
@@ -1880,6 +2547,43 @@ class RemoteImageBuildArgs:
|
|
|
1880
2547
|
pulumi.set(self, "version", value)
|
|
1881
2548
|
|
|
1882
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
|
+
|
|
1883
2587
|
@pulumi.input_type
|
|
1884
2588
|
class RemoteImageBuildAuthConfigArgs:
|
|
1885
2589
|
def __init__(__self__, *,
|
|
@@ -2014,6 +2718,23 @@ class RemoteImageBuildAuthConfigArgs:
|
|
|
2014
2718
|
pulumi.set(self, "user_name", value)
|
|
2015
2719
|
|
|
2016
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
|
+
|
|
2017
2738
|
@pulumi.input_type
|
|
2018
2739
|
class RemoteImageBuildUlimitArgs:
|
|
2019
2740
|
def __init__(__self__, *,
|
|
@@ -2066,6 +2787,19 @@ class RemoteImageBuildUlimitArgs:
|
|
|
2066
2787
|
pulumi.set(self, "soft", value)
|
|
2067
2788
|
|
|
2068
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
|
+
|
|
2069
2803
|
@pulumi.input_type
|
|
2070
2804
|
class SecretLabelArgs:
|
|
2071
2805
|
def __init__(__self__, *,
|
|
@@ -2103,6 +2837,23 @@ class SecretLabelArgs:
|
|
|
2103
2837
|
pulumi.set(self, "value", value)
|
|
2104
2838
|
|
|
2105
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
|
+
|
|
2106
2857
|
@pulumi.input_type
|
|
2107
2858
|
class ServiceAuthArgs:
|
|
2108
2859
|
def __init__(__self__, *,
|
|
@@ -2157,6 +2908,19 @@ class ServiceAuthArgs:
|
|
|
2157
2908
|
pulumi.set(self, "username", value)
|
|
2158
2909
|
|
|
2159
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
|
+
|
|
2160
2924
|
@pulumi.input_type
|
|
2161
2925
|
class ServiceConvergeConfigArgs:
|
|
2162
2926
|
def __init__(__self__, *,
|
|
@@ -2196,6 +2960,19 @@ class ServiceConvergeConfigArgs:
|
|
|
2196
2960
|
pulumi.set(self, "timeout", value)
|
|
2197
2961
|
|
|
2198
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
|
+
|
|
2199
2976
|
@pulumi.input_type
|
|
2200
2977
|
class ServiceEndpointSpecArgs:
|
|
2201
2978
|
def __init__(__self__, *,
|
|
@@ -2235,6 +3012,31 @@ class ServiceEndpointSpecArgs:
|
|
|
2235
3012
|
pulumi.set(self, "ports", value)
|
|
2236
3013
|
|
|
2237
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
|
+
|
|
2238
3040
|
@pulumi.input_type
|
|
2239
3041
|
class ServiceEndpointSpecPortArgs:
|
|
2240
3042
|
def __init__(__self__, *,
|
|
@@ -2321,6 +3123,19 @@ class ServiceEndpointSpecPortArgs:
|
|
|
2321
3123
|
pulumi.set(self, "published_port", value)
|
|
2322
3124
|
|
|
2323
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
|
+
|
|
2324
3139
|
@pulumi.input_type
|
|
2325
3140
|
class ServiceLabelArgs:
|
|
2326
3141
|
def __init__(__self__, *,
|
|
@@ -2358,6 +3173,19 @@ class ServiceLabelArgs:
|
|
|
2358
3173
|
pulumi.set(self, "value", value)
|
|
2359
3174
|
|
|
2360
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
|
+
|
|
2361
3189
|
@pulumi.input_type
|
|
2362
3190
|
class ServiceModeArgs:
|
|
2363
3191
|
def __init__(__self__, *,
|
|
@@ -2397,6 +3225,15 @@ class ServiceModeArgs:
|
|
|
2397
3225
|
pulumi.set(self, "replicated", value)
|
|
2398
3226
|
|
|
2399
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
|
+
|
|
2400
3237
|
@pulumi.input_type
|
|
2401
3238
|
class ServiceModeReplicatedArgs:
|
|
2402
3239
|
def __init__(__self__, *,
|
|
@@ -2420,6 +3257,35 @@ class ServiceModeReplicatedArgs:
|
|
|
2420
3257
|
pulumi.set(self, "replicas", value)
|
|
2421
3258
|
|
|
2422
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
|
+
|
|
2423
3289
|
@pulumi.input_type
|
|
2424
3290
|
class ServiceRollbackConfigArgs:
|
|
2425
3291
|
def __init__(__self__, *,
|
|
@@ -2523,6 +3389,43 @@ class ServiceRollbackConfigArgs:
|
|
|
2523
3389
|
pulumi.set(self, "parallelism", value)
|
|
2524
3390
|
|
|
2525
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
|
+
|
|
2526
3429
|
@pulumi.input_type
|
|
2527
3430
|
class ServiceTaskSpecArgs:
|
|
2528
3431
|
def __init__(__self__, *,
|
|
@@ -2657,6 +3560,95 @@ class ServiceTaskSpecArgs:
|
|
|
2657
3560
|
pulumi.set(self, "runtime", value)
|
|
2658
3561
|
|
|
2659
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
|
+
|
|
2660
3652
|
@pulumi.input_type
|
|
2661
3653
|
class ServiceTaskSpecContainerSpecArgs:
|
|
2662
3654
|
def __init__(__self__, *,
|
|
@@ -2679,7 +3671,7 @@ class ServiceTaskSpecContainerSpecArgs:
|
|
|
2679
3671
|
secrets: Optional[pulumi.Input[Sequence[pulumi.Input['ServiceTaskSpecContainerSpecSecretArgs']]]] = None,
|
|
2680
3672
|
stop_grace_period: Optional[pulumi.Input[str]] = None,
|
|
2681
3673
|
stop_signal: Optional[pulumi.Input[str]] = None,
|
|
2682
|
-
sysctl: Optional[pulumi.Input[Mapping[str,
|
|
3674
|
+
sysctl: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None,
|
|
2683
3675
|
user: Optional[pulumi.Input[str]] = None):
|
|
2684
3676
|
"""
|
|
2685
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.
|
|
@@ -2697,12 +3689,12 @@ class ServiceTaskSpecContainerSpecArgs:
|
|
|
2697
3689
|
:param pulumi.Input[Sequence[pulumi.Input['ServiceTaskSpecContainerSpecLabelArgs']]] labels: User-defined key/value metadata
|
|
2698
3690
|
:param pulumi.Input[Sequence[pulumi.Input['ServiceTaskSpecContainerSpecMountArgs']]] mounts: Specification for mounts to be added to containers created as part of the service
|
|
2699
3691
|
:param pulumi.Input['ServiceTaskSpecContainerSpecPrivilegesArgs'] privileges: Security options for the container
|
|
2700
|
-
:param pulumi.Input[bool] read_only:
|
|
3692
|
+
:param pulumi.Input[bool] read_only: Mount the container's root filesystem as read only
|
|
2701
3693
|
:param pulumi.Input[Sequence[pulumi.Input['ServiceTaskSpecContainerSpecSecretArgs']]] secrets: References to zero or more secrets that will be exposed to the service
|
|
2702
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.
|
|
2703
3695
|
:param pulumi.Input[str] stop_signal: Signal to stop the container
|
|
2704
|
-
:param pulumi.Input[Mapping[str,
|
|
2705
|
-
:param pulumi.Input[str] user:
|
|
3696
|
+
:param pulumi.Input[Mapping[str, pulumi.Input[str]]] sysctl: Sysctls config (Linux only)
|
|
3697
|
+
:param pulumi.Input[str] user: The user inside the container
|
|
2706
3698
|
"""
|
|
2707
3699
|
pulumi.set(__self__, "image", image)
|
|
2708
3700
|
if args is not None:
|
|
@@ -2930,7 +3922,7 @@ class ServiceTaskSpecContainerSpecArgs:
|
|
|
2930
3922
|
@pulumi.getter(name="readOnly")
|
|
2931
3923
|
def read_only(self) -> Optional[pulumi.Input[bool]]:
|
|
2932
3924
|
"""
|
|
2933
|
-
|
|
3925
|
+
Mount the container's root filesystem as read only
|
|
2934
3926
|
"""
|
|
2935
3927
|
return pulumi.get(self, "read_only")
|
|
2936
3928
|
|
|
@@ -2976,21 +3968,21 @@ class ServiceTaskSpecContainerSpecArgs:
|
|
|
2976
3968
|
|
|
2977
3969
|
@property
|
|
2978
3970
|
@pulumi.getter
|
|
2979
|
-
def sysctl(self) -> Optional[pulumi.Input[Mapping[str,
|
|
3971
|
+
def sysctl(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]:
|
|
2980
3972
|
"""
|
|
2981
3973
|
Sysctls config (Linux only)
|
|
2982
3974
|
"""
|
|
2983
3975
|
return pulumi.get(self, "sysctl")
|
|
2984
3976
|
|
|
2985
3977
|
@sysctl.setter
|
|
2986
|
-
def sysctl(self, value: Optional[pulumi.Input[Mapping[str,
|
|
3978
|
+
def sysctl(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]):
|
|
2987
3979
|
pulumi.set(self, "sysctl", value)
|
|
2988
3980
|
|
|
2989
3981
|
@property
|
|
2990
3982
|
@pulumi.getter
|
|
2991
3983
|
def user(self) -> Optional[pulumi.Input[str]]:
|
|
2992
3984
|
"""
|
|
2993
|
-
|
|
3985
|
+
The user inside the container
|
|
2994
3986
|
"""
|
|
2995
3987
|
return pulumi.get(self, "user")
|
|
2996
3988
|
|
|
@@ -2999,6 +3991,35 @@ class ServiceTaskSpecContainerSpecArgs:
|
|
|
2999
3991
|
pulumi.set(self, "user", value)
|
|
3000
3992
|
|
|
3001
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
|
+
|
|
3002
4023
|
@pulumi.input_type
|
|
3003
4024
|
class ServiceTaskSpecContainerSpecConfigArgs:
|
|
3004
4025
|
def __init__(__self__, *,
|
|
@@ -3100,6 +4121,23 @@ class ServiceTaskSpecContainerSpecConfigArgs:
|
|
|
3100
4121
|
pulumi.set(self, "file_uid", value)
|
|
3101
4122
|
|
|
3102
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
|
+
|
|
3103
4141
|
@pulumi.input_type
|
|
3104
4142
|
class ServiceTaskSpecContainerSpecDnsConfigArgs:
|
|
3105
4143
|
def __init__(__self__, *,
|
|
@@ -3154,6 +4192,31 @@ class ServiceTaskSpecContainerSpecDnsConfigArgs:
|
|
|
3154
4192
|
pulumi.set(self, "searches", value)
|
|
3155
4193
|
|
|
3156
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
|
+
|
|
3157
4220
|
@pulumi.input_type
|
|
3158
4221
|
class ServiceTaskSpecContainerSpecHealthcheckArgs:
|
|
3159
4222
|
def __init__(__self__, *,
|
|
@@ -3167,7 +4230,7 @@ class ServiceTaskSpecContainerSpecHealthcheckArgs:
|
|
|
3167
4230
|
:param pulumi.Input[str] interval: Time between running the check (ms|s|m|h). Defaults to `0s`.
|
|
3168
4231
|
:param pulumi.Input[int] retries: Consecutive failures needed to report unhealthy. Defaults to `0`
|
|
3169
4232
|
:param pulumi.Input[str] start_period: Start period for the container to initialize before counting retries towards unstable (ms|s|m|h). Defaults to `0s`.
|
|
3170
|
-
:param pulumi.Input[str] timeout:
|
|
4233
|
+
:param pulumi.Input[str] timeout: Maximum time to allow one check to run (ms|s|m|h). Defaults to `0s`.
|
|
3171
4234
|
"""
|
|
3172
4235
|
pulumi.set(__self__, "tests", tests)
|
|
3173
4236
|
if interval is not None:
|
|
@@ -3231,7 +4294,7 @@ class ServiceTaskSpecContainerSpecHealthcheckArgs:
|
|
|
3231
4294
|
@pulumi.getter
|
|
3232
4295
|
def timeout(self) -> Optional[pulumi.Input[str]]:
|
|
3233
4296
|
"""
|
|
3234
|
-
|
|
4297
|
+
Maximum time to allow one check to run (ms|s|m|h). Defaults to `0s`.
|
|
3235
4298
|
"""
|
|
3236
4299
|
return pulumi.get(self, "timeout")
|
|
3237
4300
|
|
|
@@ -3240,6 +4303,19 @@ class ServiceTaskSpecContainerSpecHealthcheckArgs:
|
|
|
3240
4303
|
pulumi.set(self, "timeout", value)
|
|
3241
4304
|
|
|
3242
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
|
+
|
|
3243
4319
|
@pulumi.input_type
|
|
3244
4320
|
class ServiceTaskSpecContainerSpecHostArgs:
|
|
3245
4321
|
def __init__(__self__, *,
|
|
@@ -3277,6 +4353,19 @@ class ServiceTaskSpecContainerSpecHostArgs:
|
|
|
3277
4353
|
pulumi.set(self, "ip", value)
|
|
3278
4354
|
|
|
3279
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
|
+
|
|
3280
4369
|
@pulumi.input_type
|
|
3281
4370
|
class ServiceTaskSpecContainerSpecLabelArgs:
|
|
3282
4371
|
def __init__(__self__, *,
|
|
@@ -3314,6 +4403,39 @@ class ServiceTaskSpecContainerSpecLabelArgs:
|
|
|
3314
4403
|
pulumi.set(self, "value", value)
|
|
3315
4404
|
|
|
3316
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']]
|
|
4433
|
+
"""
|
|
4434
|
+
Optional configuration for the volume type
|
|
4435
|
+
"""
|
|
4436
|
+
elif False:
|
|
4437
|
+
ServiceTaskSpecContainerSpecMountArgsDict: TypeAlias = Mapping[str, Any]
|
|
4438
|
+
|
|
3317
4439
|
@pulumi.input_type
|
|
3318
4440
|
class ServiceTaskSpecContainerSpecMountArgs:
|
|
3319
4441
|
def __init__(__self__, *,
|
|
@@ -3431,6 +4553,15 @@ class ServiceTaskSpecContainerSpecMountArgs:
|
|
|
3431
4553
|
pulumi.set(self, "volume_options", value)
|
|
3432
4554
|
|
|
3433
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
|
+
|
|
3434
4565
|
@pulumi.input_type
|
|
3435
4566
|
class ServiceTaskSpecContainerSpecMountBindOptionsArgs:
|
|
3436
4567
|
def __init__(__self__, *,
|
|
@@ -3454,13 +4585,26 @@ class ServiceTaskSpecContainerSpecMountBindOptionsArgs:
|
|
|
3454
4585
|
pulumi.set(self, "propagation", value)
|
|
3455
4586
|
|
|
3456
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
|
+
|
|
3457
4601
|
@pulumi.input_type
|
|
3458
4602
|
class ServiceTaskSpecContainerSpecMountTmpfsOptionsArgs:
|
|
3459
4603
|
def __init__(__self__, *,
|
|
3460
4604
|
mode: Optional[pulumi.Input[int]] = None,
|
|
3461
4605
|
size_bytes: Optional[pulumi.Input[int]] = None):
|
|
3462
4606
|
"""
|
|
3463
|
-
:param pulumi.Input[int] mode: The mode
|
|
4607
|
+
:param pulumi.Input[int] mode: The permission mode for the tmpfs mount in an integer
|
|
3464
4608
|
:param pulumi.Input[int] size_bytes: The size for the tmpfs mount in bytes
|
|
3465
4609
|
"""
|
|
3466
4610
|
if mode is not None:
|
|
@@ -3472,7 +4616,7 @@ class ServiceTaskSpecContainerSpecMountTmpfsOptionsArgs:
|
|
|
3472
4616
|
@pulumi.getter
|
|
3473
4617
|
def mode(self) -> Optional[pulumi.Input[int]]:
|
|
3474
4618
|
"""
|
|
3475
|
-
The mode
|
|
4619
|
+
The permission mode for the tmpfs mount in an integer
|
|
3476
4620
|
"""
|
|
3477
4621
|
return pulumi.get(self, "mode")
|
|
3478
4622
|
|
|
@@ -3493,6 +4637,27 @@ class ServiceTaskSpecContainerSpecMountTmpfsOptionsArgs:
|
|
|
3493
4637
|
pulumi.set(self, "size_bytes", value)
|
|
3494
4638
|
|
|
3495
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
|
+
|
|
3496
4661
|
@pulumi.input_type
|
|
3497
4662
|
class ServiceTaskSpecContainerSpecMountVolumeOptionsArgs:
|
|
3498
4663
|
def __init__(__self__, *,
|
|
@@ -3564,6 +4729,19 @@ class ServiceTaskSpecContainerSpecMountVolumeOptionsArgs:
|
|
|
3564
4729
|
pulumi.set(self, "no_copy", value)
|
|
3565
4730
|
|
|
3566
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
|
+
|
|
3567
4745
|
@pulumi.input_type
|
|
3568
4746
|
class ServiceTaskSpecContainerSpecMountVolumeOptionsLabelArgs:
|
|
3569
4747
|
def __init__(__self__, *,
|
|
@@ -3601,6 +4779,19 @@ class ServiceTaskSpecContainerSpecMountVolumeOptionsLabelArgs:
|
|
|
3601
4779
|
pulumi.set(self, "value", value)
|
|
3602
4780
|
|
|
3603
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
|
+
|
|
3604
4795
|
@pulumi.input_type
|
|
3605
4796
|
class ServiceTaskSpecContainerSpecPrivilegesArgs:
|
|
3606
4797
|
def __init__(__self__, *,
|
|
@@ -3640,6 +4831,19 @@ class ServiceTaskSpecContainerSpecPrivilegesArgs:
|
|
|
3640
4831
|
pulumi.set(self, "se_linux_context", value)
|
|
3641
4832
|
|
|
3642
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
|
+
|
|
3643
4847
|
@pulumi.input_type
|
|
3644
4848
|
class ServiceTaskSpecContainerSpecPrivilegesCredentialSpecArgs:
|
|
3645
4849
|
def __init__(__self__, *,
|
|
@@ -3679,6 +4883,31 @@ class ServiceTaskSpecContainerSpecPrivilegesCredentialSpecArgs:
|
|
|
3679
4883
|
pulumi.set(self, "registry", value)
|
|
3680
4884
|
|
|
3681
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
|
+
|
|
3682
4911
|
@pulumi.input_type
|
|
3683
4912
|
class ServiceTaskSpecContainerSpecPrivilegesSeLinuxContextArgs:
|
|
3684
4913
|
def __init__(__self__, *,
|
|
@@ -3691,7 +4920,7 @@ class ServiceTaskSpecContainerSpecPrivilegesSeLinuxContextArgs:
|
|
|
3691
4920
|
:param pulumi.Input[bool] disable: Disable SELinux
|
|
3692
4921
|
:param pulumi.Input[str] level: SELinux level label
|
|
3693
4922
|
:param pulumi.Input[str] role: SELinux role label
|
|
3694
|
-
:param pulumi.Input[str] type:
|
|
4923
|
+
:param pulumi.Input[str] type: SELinux type label
|
|
3695
4924
|
:param pulumi.Input[str] user: SELinux user label
|
|
3696
4925
|
"""
|
|
3697
4926
|
if disable is not None:
|
|
@@ -3745,7 +4974,7 @@ class ServiceTaskSpecContainerSpecPrivilegesSeLinuxContextArgs:
|
|
|
3745
4974
|
@pulumi.getter
|
|
3746
4975
|
def type(self) -> Optional[pulumi.Input[str]]:
|
|
3747
4976
|
"""
|
|
3748
|
-
|
|
4977
|
+
SELinux type label
|
|
3749
4978
|
"""
|
|
3750
4979
|
return pulumi.get(self, "type")
|
|
3751
4980
|
|
|
@@ -3766,6 +4995,35 @@ class ServiceTaskSpecContainerSpecPrivilegesSeLinuxContextArgs:
|
|
|
3766
4995
|
pulumi.set(self, "user", value)
|
|
3767
4996
|
|
|
3768
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
|
+
|
|
3769
5027
|
@pulumi.input_type
|
|
3770
5028
|
class ServiceTaskSpecContainerSpecSecretArgs:
|
|
3771
5029
|
def __init__(__self__, *,
|
|
@@ -3778,9 +5036,9 @@ class ServiceTaskSpecContainerSpecSecretArgs:
|
|
|
3778
5036
|
"""
|
|
3779
5037
|
:param pulumi.Input[str] file_name: Represents the final filename in the filesystem
|
|
3780
5038
|
:param pulumi.Input[str] secret_id: ID of the specific secret that we're referencing
|
|
3781
|
-
:param pulumi.Input[str] file_gid: Represents the file GID. Defaults to `0
|
|
3782
|
-
:param pulumi.Input[int] file_mode: Represents represents the FileMode of the file. Defaults to `0o444
|
|
3783
|
-
:param pulumi.Input[str] file_uid: Represents the file UID. Defaults to `0
|
|
5039
|
+
:param pulumi.Input[str] file_gid: Represents the file GID. Defaults to `0`
|
|
5040
|
+
:param pulumi.Input[int] file_mode: Represents represents the FileMode of the file. Defaults to `0o444`
|
|
5041
|
+
:param pulumi.Input[str] file_uid: Represents the file UID. Defaults to `0`
|
|
3784
5042
|
:param pulumi.Input[str] secret_name: 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
|
|
3785
5043
|
"""
|
|
3786
5044
|
pulumi.set(__self__, "file_name", file_name)
|
|
@@ -3822,7 +5080,7 @@ class ServiceTaskSpecContainerSpecSecretArgs:
|
|
|
3822
5080
|
@pulumi.getter(name="fileGid")
|
|
3823
5081
|
def file_gid(self) -> Optional[pulumi.Input[str]]:
|
|
3824
5082
|
"""
|
|
3825
|
-
Represents the file GID. Defaults to `0
|
|
5083
|
+
Represents the file GID. Defaults to `0`
|
|
3826
5084
|
"""
|
|
3827
5085
|
return pulumi.get(self, "file_gid")
|
|
3828
5086
|
|
|
@@ -3834,7 +5092,7 @@ class ServiceTaskSpecContainerSpecSecretArgs:
|
|
|
3834
5092
|
@pulumi.getter(name="fileMode")
|
|
3835
5093
|
def file_mode(self) -> Optional[pulumi.Input[int]]:
|
|
3836
5094
|
"""
|
|
3837
|
-
Represents represents the FileMode of the file. Defaults to `0o444
|
|
5095
|
+
Represents represents the FileMode of the file. Defaults to `0o444`
|
|
3838
5096
|
"""
|
|
3839
5097
|
return pulumi.get(self, "file_mode")
|
|
3840
5098
|
|
|
@@ -3846,7 +5104,7 @@ class ServiceTaskSpecContainerSpecSecretArgs:
|
|
|
3846
5104
|
@pulumi.getter(name="fileUid")
|
|
3847
5105
|
def file_uid(self) -> Optional[pulumi.Input[str]]:
|
|
3848
5106
|
"""
|
|
3849
|
-
Represents the file UID. Defaults to `0
|
|
5107
|
+
Represents the file UID. Defaults to `0`
|
|
3850
5108
|
"""
|
|
3851
5109
|
return pulumi.get(self, "file_uid")
|
|
3852
5110
|
|
|
@@ -3867,14 +5125,27 @@ class ServiceTaskSpecContainerSpecSecretArgs:
|
|
|
3867
5125
|
pulumi.set(self, "secret_name", value)
|
|
3868
5126
|
|
|
3869
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
|
+
|
|
3870
5141
|
@pulumi.input_type
|
|
3871
5142
|
class ServiceTaskSpecLogDriverArgs:
|
|
3872
5143
|
def __init__(__self__, *,
|
|
3873
5144
|
name: pulumi.Input[str],
|
|
3874
5145
|
options: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None):
|
|
3875
5146
|
"""
|
|
3876
|
-
:param pulumi.Input[str] name:
|
|
3877
|
-
:param pulumi.Input[Mapping[str, pulumi.Input[str]]] options:
|
|
5147
|
+
:param pulumi.Input[str] name: The logging driver to use
|
|
5148
|
+
:param pulumi.Input[Mapping[str, pulumi.Input[str]]] options: The options for the logging driver
|
|
3878
5149
|
"""
|
|
3879
5150
|
pulumi.set(__self__, "name", name)
|
|
3880
5151
|
if options is not None:
|
|
@@ -3884,7 +5155,7 @@ class ServiceTaskSpecLogDriverArgs:
|
|
|
3884
5155
|
@pulumi.getter
|
|
3885
5156
|
def name(self) -> pulumi.Input[str]:
|
|
3886
5157
|
"""
|
|
3887
|
-
|
|
5158
|
+
The logging driver to use
|
|
3888
5159
|
"""
|
|
3889
5160
|
return pulumi.get(self, "name")
|
|
3890
5161
|
|
|
@@ -3896,7 +5167,7 @@ class ServiceTaskSpecLogDriverArgs:
|
|
|
3896
5167
|
@pulumi.getter
|
|
3897
5168
|
def options(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]:
|
|
3898
5169
|
"""
|
|
3899
|
-
|
|
5170
|
+
The options for the logging driver
|
|
3900
5171
|
"""
|
|
3901
5172
|
return pulumi.get(self, "options")
|
|
3902
5173
|
|
|
@@ -3905,6 +5176,23 @@ class ServiceTaskSpecLogDriverArgs:
|
|
|
3905
5176
|
pulumi.set(self, "options", value)
|
|
3906
5177
|
|
|
3907
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
|
+
|
|
3908
5196
|
@pulumi.input_type
|
|
3909
5197
|
class ServiceTaskSpecNetworksAdvancedArgs:
|
|
3910
5198
|
def __init__(__self__, *,
|
|
@@ -3912,7 +5200,7 @@ class ServiceTaskSpecNetworksAdvancedArgs:
|
|
|
3912
5200
|
aliases: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
|
|
3913
5201
|
driver_opts: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None):
|
|
3914
5202
|
"""
|
|
3915
|
-
:param pulumi.Input[str] name:
|
|
5203
|
+
:param pulumi.Input[str] name: The name/id of the network.
|
|
3916
5204
|
:param pulumi.Input[Sequence[pulumi.Input[str]]] aliases: The network aliases of the container in the specific network.
|
|
3917
5205
|
:param pulumi.Input[Sequence[pulumi.Input[str]]] driver_opts: An array of driver options for the network, e.g. `opts1=value`
|
|
3918
5206
|
"""
|
|
@@ -3926,7 +5214,7 @@ class ServiceTaskSpecNetworksAdvancedArgs:
|
|
|
3926
5214
|
@pulumi.getter
|
|
3927
5215
|
def name(self) -> pulumi.Input[str]:
|
|
3928
5216
|
"""
|
|
3929
|
-
|
|
5217
|
+
The name/id of the network.
|
|
3930
5218
|
"""
|
|
3931
5219
|
return pulumi.get(self, "name")
|
|
3932
5220
|
|
|
@@ -3959,6 +5247,27 @@ class ServiceTaskSpecNetworksAdvancedArgs:
|
|
|
3959
5247
|
pulumi.set(self, "driver_opts", value)
|
|
3960
5248
|
|
|
3961
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
|
+
|
|
3962
5271
|
@pulumi.input_type
|
|
3963
5272
|
class ServiceTaskSpecPlacementArgs:
|
|
3964
5273
|
def __init__(__self__, *,
|
|
@@ -4030,6 +5339,19 @@ class ServiceTaskSpecPlacementArgs:
|
|
|
4030
5339
|
pulumi.set(self, "prefs", value)
|
|
4031
5340
|
|
|
4032
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
|
+
|
|
4033
5355
|
@pulumi.input_type
|
|
4034
5356
|
class ServiceTaskSpecPlacementPlatformArgs:
|
|
4035
5357
|
def __init__(__self__, *,
|
|
@@ -4067,6 +5389,19 @@ class ServiceTaskSpecPlacementPlatformArgs:
|
|
|
4067
5389
|
pulumi.set(self, "os", value)
|
|
4068
5390
|
|
|
4069
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
|
+
|
|
4070
5405
|
@pulumi.input_type
|
|
4071
5406
|
class ServiceTaskSpecResourcesArgs:
|
|
4072
5407
|
def __init__(__self__, *,
|
|
@@ -4106,6 +5441,19 @@ class ServiceTaskSpecResourcesArgs:
|
|
|
4106
5441
|
pulumi.set(self, "reservation", value)
|
|
4107
5442
|
|
|
4108
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
|
+
|
|
4109
5457
|
@pulumi.input_type
|
|
4110
5458
|
class ServiceTaskSpecResourcesLimitsArgs:
|
|
4111
5459
|
def __init__(__self__, *,
|
|
@@ -4145,6 +5493,23 @@ class ServiceTaskSpecResourcesLimitsArgs:
|
|
|
4145
5493
|
pulumi.set(self, "nano_cpus", value)
|
|
4146
5494
|
|
|
4147
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
|
+
|
|
4148
5513
|
@pulumi.input_type
|
|
4149
5514
|
class ServiceTaskSpecResourcesReservationArgs:
|
|
4150
5515
|
def __init__(__self__, *,
|
|
@@ -4154,7 +5519,7 @@ class ServiceTaskSpecResourcesReservationArgs:
|
|
|
4154
5519
|
"""
|
|
4155
5520
|
:param pulumi.Input['ServiceTaskSpecResourcesReservationGenericResourcesArgs'] generic_resources: User-defined resources can be either Integer resources (e.g, `SSD=3`) or String resources (e.g, GPU=UUID1)
|
|
4156
5521
|
:param pulumi.Input[int] memory_bytes: The amounf of memory in bytes the container allocates
|
|
4157
|
-
:param pulumi.Input[int] nano_cpus: CPU shares in units of
|
|
5522
|
+
:param pulumi.Input[int] nano_cpus: CPU shares in units of 1/1e9 (or 10^-9) of the CPU. Should be at least `1000000`
|
|
4158
5523
|
"""
|
|
4159
5524
|
if generic_resources is not None:
|
|
4160
5525
|
pulumi.set(__self__, "generic_resources", generic_resources)
|
|
@@ -4191,7 +5556,7 @@ class ServiceTaskSpecResourcesReservationArgs:
|
|
|
4191
5556
|
@pulumi.getter(name="nanoCpus")
|
|
4192
5557
|
def nano_cpus(self) -> Optional[pulumi.Input[int]]:
|
|
4193
5558
|
"""
|
|
4194
|
-
CPU shares in units of
|
|
5559
|
+
CPU shares in units of 1/1e9 (or 10^-9) of the CPU. Should be at least `1000000`
|
|
4195
5560
|
"""
|
|
4196
5561
|
return pulumi.get(self, "nano_cpus")
|
|
4197
5562
|
|
|
@@ -4200,6 +5565,19 @@ class ServiceTaskSpecResourcesReservationArgs:
|
|
|
4200
5565
|
pulumi.set(self, "nano_cpus", value)
|
|
4201
5566
|
|
|
4202
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
|
+
|
|
4203
5581
|
@pulumi.input_type
|
|
4204
5582
|
class ServiceTaskSpecResourcesReservationGenericResourcesArgs:
|
|
4205
5583
|
def __init__(__self__, *,
|
|
@@ -4239,6 +5617,27 @@ class ServiceTaskSpecResourcesReservationGenericResourcesArgs:
|
|
|
4239
5617
|
pulumi.set(self, "named_resources_specs", value)
|
|
4240
5618
|
|
|
4241
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
|
+
|
|
4242
5641
|
@pulumi.input_type
|
|
4243
5642
|
class ServiceTaskSpecRestartPolicyArgs:
|
|
4244
5643
|
def __init__(__self__, *,
|
|
@@ -4248,7 +5647,7 @@ class ServiceTaskSpecRestartPolicyArgs:
|
|
|
4248
5647
|
window: Optional[pulumi.Input[str]] = None):
|
|
4249
5648
|
"""
|
|
4250
5649
|
:param pulumi.Input[str] condition: Condition for restart
|
|
4251
|
-
:param pulumi.Input[str] delay:
|
|
5650
|
+
:param pulumi.Input[str] delay: Delay between restart attempts (ms|s|m|h)
|
|
4252
5651
|
:param pulumi.Input[int] max_attempts: Maximum attempts to restart a given container before giving up (default value is `0`, which is ignored)
|
|
4253
5652
|
:param pulumi.Input[str] window: The time window used to evaluate the restart policy (default value is `0`, which is unbounded) (ms|s|m|h)
|
|
4254
5653
|
"""
|
|
@@ -4277,7 +5676,7 @@ class ServiceTaskSpecRestartPolicyArgs:
|
|
|
4277
5676
|
@pulumi.getter
|
|
4278
5677
|
def delay(self) -> Optional[pulumi.Input[str]]:
|
|
4279
5678
|
"""
|
|
4280
|
-
|
|
5679
|
+
Delay between restart attempts (ms|s|m|h)
|
|
4281
5680
|
"""
|
|
4282
5681
|
return pulumi.get(self, "delay")
|
|
4283
5682
|
|
|
@@ -4310,6 +5709,35 @@ class ServiceTaskSpecRestartPolicyArgs:
|
|
|
4310
5709
|
pulumi.set(self, "window", value)
|
|
4311
5710
|
|
|
4312
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
|
+
|
|
4313
5741
|
@pulumi.input_type
|
|
4314
5742
|
class ServiceUpdateConfigArgs:
|
|
4315
5743
|
def __init__(__self__, *,
|
|
@@ -4413,6 +5841,19 @@ class ServiceUpdateConfigArgs:
|
|
|
4413
5841
|
pulumi.set(self, "parallelism", value)
|
|
4414
5842
|
|
|
4415
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
|
+
|
|
4416
5857
|
@pulumi.input_type
|
|
4417
5858
|
class VolumeLabelArgs:
|
|
4418
5859
|
def __init__(__self__, *,
|
|
@@ -4450,6 +5891,18 @@ class VolumeLabelArgs:
|
|
|
4450
5891
|
pulumi.set(self, "value", value)
|
|
4451
5892
|
|
|
4452
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
|
+
|
|
4453
5906
|
@pulumi.input_type
|
|
4454
5907
|
class CacheFromArgs:
|
|
4455
5908
|
def __init__(__self__, *,
|
|
@@ -4474,26 +5927,76 @@ class CacheFromArgs:
|
|
|
4474
5927
|
pulumi.set(self, "images", value)
|
|
4475
5928
|
|
|
4476
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
|
+
|
|
4477
5974
|
@pulumi.input_type
|
|
4478
5975
|
class DockerBuildArgs:
|
|
4479
5976
|
def __init__(__self__, *,
|
|
5977
|
+
add_hosts: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
|
|
4480
5978
|
args: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None,
|
|
4481
5979
|
builder_version: Optional[pulumi.Input['BuilderVersion']] = None,
|
|
4482
5980
|
cache_from: Optional[pulumi.Input['CacheFromArgs']] = None,
|
|
4483
5981
|
context: Optional[pulumi.Input[str]] = None,
|
|
4484
5982
|
dockerfile: Optional[pulumi.Input[str]] = None,
|
|
5983
|
+
network: Optional[pulumi.Input[str]] = None,
|
|
4485
5984
|
platform: Optional[pulumi.Input[str]] = None,
|
|
4486
5985
|
target: Optional[pulumi.Input[str]] = None):
|
|
4487
5986
|
"""
|
|
4488
5987
|
The Docker build context
|
|
5988
|
+
:param pulumi.Input[Sequence[pulumi.Input[str]]] add_hosts: Custom host-to-IP mappings to use while building (format: "host:ip")
|
|
4489
5989
|
:param pulumi.Input[Mapping[str, pulumi.Input[str]]] args: 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.
|
|
4490
5990
|
:param pulumi.Input['BuilderVersion'] builder_version: The version of the Docker builder.
|
|
4491
5991
|
:param pulumi.Input['CacheFromArgs'] cache_from: A list of image names to use as build cache. Images provided must have a cache manifest. Must provide authentication to cache registry.
|
|
4492
5992
|
:param pulumi.Input[str] context: The path to the build context to use.
|
|
4493
5993
|
:param pulumi.Input[str] dockerfile: The path to the Dockerfile to use.
|
|
5994
|
+
:param pulumi.Input[str] network: Set the networking mode for RUN instructions
|
|
4494
5995
|
:param pulumi.Input[str] platform: The architecture of the platform you want to build this image for, e.g. `linux/arm64`.
|
|
4495
5996
|
:param pulumi.Input[str] target: The target of the Dockerfile to build
|
|
4496
5997
|
"""
|
|
5998
|
+
if add_hosts is not None:
|
|
5999
|
+
pulumi.set(__self__, "add_hosts", add_hosts)
|
|
4497
6000
|
if args is not None:
|
|
4498
6001
|
pulumi.set(__self__, "args", args)
|
|
4499
6002
|
if builder_version is not None:
|
|
@@ -4504,11 +6007,25 @@ class DockerBuildArgs:
|
|
|
4504
6007
|
pulumi.set(__self__, "context", context)
|
|
4505
6008
|
if dockerfile is not None:
|
|
4506
6009
|
pulumi.set(__self__, "dockerfile", dockerfile)
|
|
6010
|
+
if network is not None:
|
|
6011
|
+
pulumi.set(__self__, "network", network)
|
|
4507
6012
|
if platform is not None:
|
|
4508
6013
|
pulumi.set(__self__, "platform", platform)
|
|
4509
6014
|
if target is not None:
|
|
4510
6015
|
pulumi.set(__self__, "target", target)
|
|
4511
6016
|
|
|
6017
|
+
@property
|
|
6018
|
+
@pulumi.getter(name="addHosts")
|
|
6019
|
+
def add_hosts(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
|
|
6020
|
+
"""
|
|
6021
|
+
Custom host-to-IP mappings to use while building (format: "host:ip")
|
|
6022
|
+
"""
|
|
6023
|
+
return pulumi.get(self, "add_hosts")
|
|
6024
|
+
|
|
6025
|
+
@add_hosts.setter
|
|
6026
|
+
def add_hosts(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
|
|
6027
|
+
pulumi.set(self, "add_hosts", value)
|
|
6028
|
+
|
|
4512
6029
|
@property
|
|
4513
6030
|
@pulumi.getter
|
|
4514
6031
|
def args(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]:
|
|
@@ -4569,6 +6086,18 @@ class DockerBuildArgs:
|
|
|
4569
6086
|
def dockerfile(self, value: Optional[pulumi.Input[str]]):
|
|
4570
6087
|
pulumi.set(self, "dockerfile", value)
|
|
4571
6088
|
|
|
6089
|
+
@property
|
|
6090
|
+
@pulumi.getter
|
|
6091
|
+
def network(self) -> Optional[pulumi.Input[str]]:
|
|
6092
|
+
"""
|
|
6093
|
+
Set the networking mode for RUN instructions
|
|
6094
|
+
"""
|
|
6095
|
+
return pulumi.get(self, "network")
|
|
6096
|
+
|
|
6097
|
+
@network.setter
|
|
6098
|
+
def network(self, value: Optional[pulumi.Input[str]]):
|
|
6099
|
+
pulumi.set(self, "network", value)
|
|
6100
|
+
|
|
4572
6101
|
@property
|
|
4573
6102
|
@pulumi.getter
|
|
4574
6103
|
def platform(self) -> Optional[pulumi.Input[str]]:
|
|
@@ -4594,6 +6123,26 @@ class DockerBuildArgs:
|
|
|
4594
6123
|
pulumi.set(self, "target", value)
|
|
4595
6124
|
|
|
4596
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
|
+
|
|
4597
6146
|
@pulumi.input_type
|
|
4598
6147
|
class RegistryArgs:
|
|
4599
6148
|
def __init__(__self__, *,
|