pulumi-docker 4.8.0a1750226298__py3-none-any.whl → 4.9.0a1752695771__py3-none-any.whl
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Potentially problematic release.
This version of pulumi-docker might be problematic. Click here for more details.
- pulumi_docker/__init__.py +9 -0
- pulumi_docker/_inputs.py +970 -6
- pulumi_docker/buildx_builder.py +765 -0
- pulumi_docker/container.py +148 -7
- pulumi_docker/get_registry_image.py +3 -3
- pulumi_docker/outputs.py +686 -5
- pulumi_docker/pulumi-plugin.json +1 -1
- {pulumi_docker-4.8.0a1750226298.dist-info → pulumi_docker-4.9.0a1752695771.dist-info}/METADATA +1 -1
- {pulumi_docker-4.8.0a1750226298.dist-info → pulumi_docker-4.9.0a1752695771.dist-info}/RECORD +11 -10
- {pulumi_docker-4.8.0a1750226298.dist-info → pulumi_docker-4.9.0a1752695771.dist-info}/WHEEL +0 -0
- {pulumi_docker-4.8.0a1750226298.dist-info → pulumi_docker-4.9.0a1752695771.dist-info}/top_level.txt +0 -0
pulumi_docker/_inputs.py
CHANGED
|
@@ -17,6 +17,18 @@ from . import _utilities
|
|
|
17
17
|
from ._enums import *
|
|
18
18
|
|
|
19
19
|
__all__ = [
|
|
20
|
+
'BuildxBuilderDockerContainerArgs',
|
|
21
|
+
'BuildxBuilderDockerContainerArgsDict',
|
|
22
|
+
'BuildxBuilderKubernetesArgs',
|
|
23
|
+
'BuildxBuilderKubernetesArgsDict',
|
|
24
|
+
'BuildxBuilderKubernetesLimitsArgs',
|
|
25
|
+
'BuildxBuilderKubernetesLimitsArgsDict',
|
|
26
|
+
'BuildxBuilderKubernetesQemuArgs',
|
|
27
|
+
'BuildxBuilderKubernetesQemuArgsDict',
|
|
28
|
+
'BuildxBuilderKubernetesRequestsArgs',
|
|
29
|
+
'BuildxBuilderKubernetesRequestsArgsDict',
|
|
30
|
+
'BuildxBuilderRemoteArgs',
|
|
31
|
+
'BuildxBuilderRemoteArgsDict',
|
|
20
32
|
'ContainerCapabilitiesArgs',
|
|
21
33
|
'ContainerCapabilitiesArgsDict',
|
|
22
34
|
'ContainerDeviceArgs',
|
|
@@ -151,6 +163,918 @@ __all__ = [
|
|
|
151
163
|
|
|
152
164
|
MYPY = False
|
|
153
165
|
|
|
166
|
+
if not MYPY:
|
|
167
|
+
class BuildxBuilderDockerContainerArgsDict(TypedDict):
|
|
168
|
+
cgroup_parent: NotRequired[pulumi.Input[builtins.str]]
|
|
169
|
+
"""
|
|
170
|
+
Sets the cgroup parent of the container if Docker is using the "cgroupfs" driver.
|
|
171
|
+
"""
|
|
172
|
+
cpu_period: NotRequired[pulumi.Input[builtins.str]]
|
|
173
|
+
"""
|
|
174
|
+
Sets the CPU CFS scheduler period for the container.
|
|
175
|
+
"""
|
|
176
|
+
cpu_quota: NotRequired[pulumi.Input[builtins.str]]
|
|
177
|
+
"""
|
|
178
|
+
Imposes a CPU CFS quota on the container.
|
|
179
|
+
"""
|
|
180
|
+
cpu_shares: NotRequired[pulumi.Input[builtins.str]]
|
|
181
|
+
"""
|
|
182
|
+
Configures CPU shares (relative weight) of the container.
|
|
183
|
+
"""
|
|
184
|
+
cpuset_cpus: NotRequired[pulumi.Input[builtins.str]]
|
|
185
|
+
"""
|
|
186
|
+
Limits the set of CPU cores the container can use.
|
|
187
|
+
"""
|
|
188
|
+
cpuset_mems: NotRequired[pulumi.Input[builtins.str]]
|
|
189
|
+
"""
|
|
190
|
+
Limits the set of CPU memory nodes the container can use.
|
|
191
|
+
"""
|
|
192
|
+
default_load: NotRequired[pulumi.Input[builtins.bool]]
|
|
193
|
+
"""
|
|
194
|
+
Automatically load images to the Docker Engine image store. Defaults to `false`
|
|
195
|
+
"""
|
|
196
|
+
env: NotRequired[pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]]
|
|
197
|
+
"""
|
|
198
|
+
Sets environment variables in the container.
|
|
199
|
+
"""
|
|
200
|
+
image: NotRequired[pulumi.Input[builtins.str]]
|
|
201
|
+
"""
|
|
202
|
+
Sets the BuildKit image to use for the container.
|
|
203
|
+
"""
|
|
204
|
+
memory: NotRequired[pulumi.Input[builtins.str]]
|
|
205
|
+
"""
|
|
206
|
+
Sets the amount of memory the container can use.
|
|
207
|
+
"""
|
|
208
|
+
memory_swap: NotRequired[pulumi.Input[builtins.str]]
|
|
209
|
+
"""
|
|
210
|
+
Sets the memory swap limit for the container.
|
|
211
|
+
"""
|
|
212
|
+
network: NotRequired[pulumi.Input[builtins.str]]
|
|
213
|
+
"""
|
|
214
|
+
Sets the network mode for the container.
|
|
215
|
+
"""
|
|
216
|
+
restart_policy: NotRequired[pulumi.Input[builtins.str]]
|
|
217
|
+
"""
|
|
218
|
+
Sets the container's restart policy.
|
|
219
|
+
"""
|
|
220
|
+
elif False:
|
|
221
|
+
BuildxBuilderDockerContainerArgsDict: TypeAlias = Mapping[str, Any]
|
|
222
|
+
|
|
223
|
+
@pulumi.input_type
|
|
224
|
+
class BuildxBuilderDockerContainerArgs:
|
|
225
|
+
def __init__(__self__, *,
|
|
226
|
+
cgroup_parent: Optional[pulumi.Input[builtins.str]] = None,
|
|
227
|
+
cpu_period: Optional[pulumi.Input[builtins.str]] = None,
|
|
228
|
+
cpu_quota: Optional[pulumi.Input[builtins.str]] = None,
|
|
229
|
+
cpu_shares: Optional[pulumi.Input[builtins.str]] = None,
|
|
230
|
+
cpuset_cpus: Optional[pulumi.Input[builtins.str]] = None,
|
|
231
|
+
cpuset_mems: Optional[pulumi.Input[builtins.str]] = None,
|
|
232
|
+
default_load: Optional[pulumi.Input[builtins.bool]] = None,
|
|
233
|
+
env: Optional[pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]] = None,
|
|
234
|
+
image: Optional[pulumi.Input[builtins.str]] = None,
|
|
235
|
+
memory: Optional[pulumi.Input[builtins.str]] = None,
|
|
236
|
+
memory_swap: Optional[pulumi.Input[builtins.str]] = None,
|
|
237
|
+
network: Optional[pulumi.Input[builtins.str]] = None,
|
|
238
|
+
restart_policy: Optional[pulumi.Input[builtins.str]] = None):
|
|
239
|
+
"""
|
|
240
|
+
:param pulumi.Input[builtins.str] cgroup_parent: Sets the cgroup parent of the container if Docker is using the "cgroupfs" driver.
|
|
241
|
+
:param pulumi.Input[builtins.str] cpu_period: Sets the CPU CFS scheduler period for the container.
|
|
242
|
+
:param pulumi.Input[builtins.str] cpu_quota: Imposes a CPU CFS quota on the container.
|
|
243
|
+
:param pulumi.Input[builtins.str] cpu_shares: Configures CPU shares (relative weight) of the container.
|
|
244
|
+
:param pulumi.Input[builtins.str] cpuset_cpus: Limits the set of CPU cores the container can use.
|
|
245
|
+
:param pulumi.Input[builtins.str] cpuset_mems: Limits the set of CPU memory nodes the container can use.
|
|
246
|
+
:param pulumi.Input[builtins.bool] default_load: Automatically load images to the Docker Engine image store. Defaults to `false`
|
|
247
|
+
:param pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]] env: Sets environment variables in the container.
|
|
248
|
+
:param pulumi.Input[builtins.str] image: Sets the BuildKit image to use for the container.
|
|
249
|
+
:param pulumi.Input[builtins.str] memory: Sets the amount of memory the container can use.
|
|
250
|
+
:param pulumi.Input[builtins.str] memory_swap: Sets the memory swap limit for the container.
|
|
251
|
+
:param pulumi.Input[builtins.str] network: Sets the network mode for the container.
|
|
252
|
+
:param pulumi.Input[builtins.str] restart_policy: Sets the container's restart policy.
|
|
253
|
+
"""
|
|
254
|
+
if cgroup_parent is not None:
|
|
255
|
+
pulumi.set(__self__, "cgroup_parent", cgroup_parent)
|
|
256
|
+
if cpu_period is not None:
|
|
257
|
+
pulumi.set(__self__, "cpu_period", cpu_period)
|
|
258
|
+
if cpu_quota is not None:
|
|
259
|
+
pulumi.set(__self__, "cpu_quota", cpu_quota)
|
|
260
|
+
if cpu_shares is not None:
|
|
261
|
+
pulumi.set(__self__, "cpu_shares", cpu_shares)
|
|
262
|
+
if cpuset_cpus is not None:
|
|
263
|
+
pulumi.set(__self__, "cpuset_cpus", cpuset_cpus)
|
|
264
|
+
if cpuset_mems is not None:
|
|
265
|
+
pulumi.set(__self__, "cpuset_mems", cpuset_mems)
|
|
266
|
+
if default_load is not None:
|
|
267
|
+
pulumi.set(__self__, "default_load", default_load)
|
|
268
|
+
if env is not None:
|
|
269
|
+
pulumi.set(__self__, "env", env)
|
|
270
|
+
if image is not None:
|
|
271
|
+
pulumi.set(__self__, "image", image)
|
|
272
|
+
if memory is not None:
|
|
273
|
+
pulumi.set(__self__, "memory", memory)
|
|
274
|
+
if memory_swap is not None:
|
|
275
|
+
pulumi.set(__self__, "memory_swap", memory_swap)
|
|
276
|
+
if network is not None:
|
|
277
|
+
pulumi.set(__self__, "network", network)
|
|
278
|
+
if restart_policy is not None:
|
|
279
|
+
pulumi.set(__self__, "restart_policy", restart_policy)
|
|
280
|
+
|
|
281
|
+
@property
|
|
282
|
+
@pulumi.getter(name="cgroupParent")
|
|
283
|
+
def cgroup_parent(self) -> Optional[pulumi.Input[builtins.str]]:
|
|
284
|
+
"""
|
|
285
|
+
Sets the cgroup parent of the container if Docker is using the "cgroupfs" driver.
|
|
286
|
+
"""
|
|
287
|
+
return pulumi.get(self, "cgroup_parent")
|
|
288
|
+
|
|
289
|
+
@cgroup_parent.setter
|
|
290
|
+
def cgroup_parent(self, value: Optional[pulumi.Input[builtins.str]]):
|
|
291
|
+
pulumi.set(self, "cgroup_parent", value)
|
|
292
|
+
|
|
293
|
+
@property
|
|
294
|
+
@pulumi.getter(name="cpuPeriod")
|
|
295
|
+
def cpu_period(self) -> Optional[pulumi.Input[builtins.str]]:
|
|
296
|
+
"""
|
|
297
|
+
Sets the CPU CFS scheduler period for the container.
|
|
298
|
+
"""
|
|
299
|
+
return pulumi.get(self, "cpu_period")
|
|
300
|
+
|
|
301
|
+
@cpu_period.setter
|
|
302
|
+
def cpu_period(self, value: Optional[pulumi.Input[builtins.str]]):
|
|
303
|
+
pulumi.set(self, "cpu_period", value)
|
|
304
|
+
|
|
305
|
+
@property
|
|
306
|
+
@pulumi.getter(name="cpuQuota")
|
|
307
|
+
def cpu_quota(self) -> Optional[pulumi.Input[builtins.str]]:
|
|
308
|
+
"""
|
|
309
|
+
Imposes a CPU CFS quota on the container.
|
|
310
|
+
"""
|
|
311
|
+
return pulumi.get(self, "cpu_quota")
|
|
312
|
+
|
|
313
|
+
@cpu_quota.setter
|
|
314
|
+
def cpu_quota(self, value: Optional[pulumi.Input[builtins.str]]):
|
|
315
|
+
pulumi.set(self, "cpu_quota", value)
|
|
316
|
+
|
|
317
|
+
@property
|
|
318
|
+
@pulumi.getter(name="cpuShares")
|
|
319
|
+
def cpu_shares(self) -> Optional[pulumi.Input[builtins.str]]:
|
|
320
|
+
"""
|
|
321
|
+
Configures CPU shares (relative weight) of the container.
|
|
322
|
+
"""
|
|
323
|
+
return pulumi.get(self, "cpu_shares")
|
|
324
|
+
|
|
325
|
+
@cpu_shares.setter
|
|
326
|
+
def cpu_shares(self, value: Optional[pulumi.Input[builtins.str]]):
|
|
327
|
+
pulumi.set(self, "cpu_shares", value)
|
|
328
|
+
|
|
329
|
+
@property
|
|
330
|
+
@pulumi.getter(name="cpusetCpus")
|
|
331
|
+
def cpuset_cpus(self) -> Optional[pulumi.Input[builtins.str]]:
|
|
332
|
+
"""
|
|
333
|
+
Limits the set of CPU cores the container can use.
|
|
334
|
+
"""
|
|
335
|
+
return pulumi.get(self, "cpuset_cpus")
|
|
336
|
+
|
|
337
|
+
@cpuset_cpus.setter
|
|
338
|
+
def cpuset_cpus(self, value: Optional[pulumi.Input[builtins.str]]):
|
|
339
|
+
pulumi.set(self, "cpuset_cpus", value)
|
|
340
|
+
|
|
341
|
+
@property
|
|
342
|
+
@pulumi.getter(name="cpusetMems")
|
|
343
|
+
def cpuset_mems(self) -> Optional[pulumi.Input[builtins.str]]:
|
|
344
|
+
"""
|
|
345
|
+
Limits the set of CPU memory nodes the container can use.
|
|
346
|
+
"""
|
|
347
|
+
return pulumi.get(self, "cpuset_mems")
|
|
348
|
+
|
|
349
|
+
@cpuset_mems.setter
|
|
350
|
+
def cpuset_mems(self, value: Optional[pulumi.Input[builtins.str]]):
|
|
351
|
+
pulumi.set(self, "cpuset_mems", value)
|
|
352
|
+
|
|
353
|
+
@property
|
|
354
|
+
@pulumi.getter(name="defaultLoad")
|
|
355
|
+
def default_load(self) -> Optional[pulumi.Input[builtins.bool]]:
|
|
356
|
+
"""
|
|
357
|
+
Automatically load images to the Docker Engine image store. Defaults to `false`
|
|
358
|
+
"""
|
|
359
|
+
return pulumi.get(self, "default_load")
|
|
360
|
+
|
|
361
|
+
@default_load.setter
|
|
362
|
+
def default_load(self, value: Optional[pulumi.Input[builtins.bool]]):
|
|
363
|
+
pulumi.set(self, "default_load", value)
|
|
364
|
+
|
|
365
|
+
@property
|
|
366
|
+
@pulumi.getter
|
|
367
|
+
def env(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]]:
|
|
368
|
+
"""
|
|
369
|
+
Sets environment variables in the container.
|
|
370
|
+
"""
|
|
371
|
+
return pulumi.get(self, "env")
|
|
372
|
+
|
|
373
|
+
@env.setter
|
|
374
|
+
def env(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]]):
|
|
375
|
+
pulumi.set(self, "env", value)
|
|
376
|
+
|
|
377
|
+
@property
|
|
378
|
+
@pulumi.getter
|
|
379
|
+
def image(self) -> Optional[pulumi.Input[builtins.str]]:
|
|
380
|
+
"""
|
|
381
|
+
Sets the BuildKit image to use for the container.
|
|
382
|
+
"""
|
|
383
|
+
return pulumi.get(self, "image")
|
|
384
|
+
|
|
385
|
+
@image.setter
|
|
386
|
+
def image(self, value: Optional[pulumi.Input[builtins.str]]):
|
|
387
|
+
pulumi.set(self, "image", value)
|
|
388
|
+
|
|
389
|
+
@property
|
|
390
|
+
@pulumi.getter
|
|
391
|
+
def memory(self) -> Optional[pulumi.Input[builtins.str]]:
|
|
392
|
+
"""
|
|
393
|
+
Sets the amount of memory the container can use.
|
|
394
|
+
"""
|
|
395
|
+
return pulumi.get(self, "memory")
|
|
396
|
+
|
|
397
|
+
@memory.setter
|
|
398
|
+
def memory(self, value: Optional[pulumi.Input[builtins.str]]):
|
|
399
|
+
pulumi.set(self, "memory", value)
|
|
400
|
+
|
|
401
|
+
@property
|
|
402
|
+
@pulumi.getter(name="memorySwap")
|
|
403
|
+
def memory_swap(self) -> Optional[pulumi.Input[builtins.str]]:
|
|
404
|
+
"""
|
|
405
|
+
Sets the memory swap limit for the container.
|
|
406
|
+
"""
|
|
407
|
+
return pulumi.get(self, "memory_swap")
|
|
408
|
+
|
|
409
|
+
@memory_swap.setter
|
|
410
|
+
def memory_swap(self, value: Optional[pulumi.Input[builtins.str]]):
|
|
411
|
+
pulumi.set(self, "memory_swap", value)
|
|
412
|
+
|
|
413
|
+
@property
|
|
414
|
+
@pulumi.getter
|
|
415
|
+
def network(self) -> Optional[pulumi.Input[builtins.str]]:
|
|
416
|
+
"""
|
|
417
|
+
Sets the network mode for the container.
|
|
418
|
+
"""
|
|
419
|
+
return pulumi.get(self, "network")
|
|
420
|
+
|
|
421
|
+
@network.setter
|
|
422
|
+
def network(self, value: Optional[pulumi.Input[builtins.str]]):
|
|
423
|
+
pulumi.set(self, "network", value)
|
|
424
|
+
|
|
425
|
+
@property
|
|
426
|
+
@pulumi.getter(name="restartPolicy")
|
|
427
|
+
def restart_policy(self) -> Optional[pulumi.Input[builtins.str]]:
|
|
428
|
+
"""
|
|
429
|
+
Sets the container's restart policy.
|
|
430
|
+
"""
|
|
431
|
+
return pulumi.get(self, "restart_policy")
|
|
432
|
+
|
|
433
|
+
@restart_policy.setter
|
|
434
|
+
def restart_policy(self, value: Optional[pulumi.Input[builtins.str]]):
|
|
435
|
+
pulumi.set(self, "restart_policy", value)
|
|
436
|
+
|
|
437
|
+
|
|
438
|
+
if not MYPY:
|
|
439
|
+
class BuildxBuilderKubernetesArgsDict(TypedDict):
|
|
440
|
+
annotations: NotRequired[pulumi.Input[builtins.str]]
|
|
441
|
+
"""
|
|
442
|
+
Sets additional annotations on the deployments and pods.
|
|
443
|
+
"""
|
|
444
|
+
default_load: NotRequired[pulumi.Input[builtins.bool]]
|
|
445
|
+
"""
|
|
446
|
+
Automatically load images to the Docker Engine image store. Defaults to `false`
|
|
447
|
+
"""
|
|
448
|
+
image: NotRequired[pulumi.Input[builtins.str]]
|
|
449
|
+
"""
|
|
450
|
+
Sets the image to use for running BuildKit.
|
|
451
|
+
"""
|
|
452
|
+
labels: NotRequired[pulumi.Input[builtins.str]]
|
|
453
|
+
"""
|
|
454
|
+
Sets additional labels on the deployments and pods.
|
|
455
|
+
"""
|
|
456
|
+
limits: NotRequired[pulumi.Input['BuildxBuilderKubernetesLimitsArgsDict']]
|
|
457
|
+
"""
|
|
458
|
+
Resource limits for CPU, memory, and ephemeral storage.
|
|
459
|
+
"""
|
|
460
|
+
loadbalance: NotRequired[pulumi.Input[builtins.str]]
|
|
461
|
+
"""
|
|
462
|
+
Load-balancing strategy (sticky or random).
|
|
463
|
+
"""
|
|
464
|
+
namespace: NotRequired[pulumi.Input[builtins.str]]
|
|
465
|
+
"""
|
|
466
|
+
Sets the Kubernetes namespace.
|
|
467
|
+
"""
|
|
468
|
+
nodeselector: NotRequired[pulumi.Input[builtins.str]]
|
|
469
|
+
"""
|
|
470
|
+
Sets the pod's nodeSelector label(s).
|
|
471
|
+
"""
|
|
472
|
+
qemu: NotRequired[pulumi.Input['BuildxBuilderKubernetesQemuArgsDict']]
|
|
473
|
+
"""
|
|
474
|
+
QEMU emulation configuration.
|
|
475
|
+
"""
|
|
476
|
+
replicas: NotRequired[pulumi.Input[builtins.int]]
|
|
477
|
+
"""
|
|
478
|
+
Sets the number of Pod replicas to create.
|
|
479
|
+
"""
|
|
480
|
+
requests: NotRequired[pulumi.Input['BuildxBuilderKubernetesRequestsArgsDict']]
|
|
481
|
+
"""
|
|
482
|
+
Resource requests for CPU, memory, and ephemeral storage.
|
|
483
|
+
"""
|
|
484
|
+
rootless: NotRequired[pulumi.Input[builtins.bool]]
|
|
485
|
+
"""
|
|
486
|
+
Run the container as a non-root user.
|
|
487
|
+
"""
|
|
488
|
+
schedulername: NotRequired[pulumi.Input[builtins.str]]
|
|
489
|
+
"""
|
|
490
|
+
Sets the scheduler responsible for scheduling the pod.
|
|
491
|
+
"""
|
|
492
|
+
serviceaccount: NotRequired[pulumi.Input[builtins.str]]
|
|
493
|
+
"""
|
|
494
|
+
Sets the pod's serviceAccountName.
|
|
495
|
+
"""
|
|
496
|
+
timeout: NotRequired[pulumi.Input[builtins.str]]
|
|
497
|
+
"""
|
|
498
|
+
Set the timeout limit for pod provisioning.
|
|
499
|
+
"""
|
|
500
|
+
tolerations: NotRequired[pulumi.Input[builtins.str]]
|
|
501
|
+
"""
|
|
502
|
+
Configures the pod's taint toleration.
|
|
503
|
+
"""
|
|
504
|
+
elif False:
|
|
505
|
+
BuildxBuilderKubernetesArgsDict: TypeAlias = Mapping[str, Any]
|
|
506
|
+
|
|
507
|
+
@pulumi.input_type
|
|
508
|
+
class BuildxBuilderKubernetesArgs:
|
|
509
|
+
def __init__(__self__, *,
|
|
510
|
+
annotations: Optional[pulumi.Input[builtins.str]] = None,
|
|
511
|
+
default_load: Optional[pulumi.Input[builtins.bool]] = None,
|
|
512
|
+
image: Optional[pulumi.Input[builtins.str]] = None,
|
|
513
|
+
labels: Optional[pulumi.Input[builtins.str]] = None,
|
|
514
|
+
limits: Optional[pulumi.Input['BuildxBuilderKubernetesLimitsArgs']] = None,
|
|
515
|
+
loadbalance: Optional[pulumi.Input[builtins.str]] = None,
|
|
516
|
+
namespace: Optional[pulumi.Input[builtins.str]] = None,
|
|
517
|
+
nodeselector: Optional[pulumi.Input[builtins.str]] = None,
|
|
518
|
+
qemu: Optional[pulumi.Input['BuildxBuilderKubernetesQemuArgs']] = None,
|
|
519
|
+
replicas: Optional[pulumi.Input[builtins.int]] = None,
|
|
520
|
+
requests: Optional[pulumi.Input['BuildxBuilderKubernetesRequestsArgs']] = None,
|
|
521
|
+
rootless: Optional[pulumi.Input[builtins.bool]] = None,
|
|
522
|
+
schedulername: Optional[pulumi.Input[builtins.str]] = None,
|
|
523
|
+
serviceaccount: Optional[pulumi.Input[builtins.str]] = None,
|
|
524
|
+
timeout: Optional[pulumi.Input[builtins.str]] = None,
|
|
525
|
+
tolerations: Optional[pulumi.Input[builtins.str]] = None):
|
|
526
|
+
"""
|
|
527
|
+
:param pulumi.Input[builtins.str] annotations: Sets additional annotations on the deployments and pods.
|
|
528
|
+
:param pulumi.Input[builtins.bool] default_load: Automatically load images to the Docker Engine image store. Defaults to `false`
|
|
529
|
+
:param pulumi.Input[builtins.str] image: Sets the image to use for running BuildKit.
|
|
530
|
+
:param pulumi.Input[builtins.str] labels: Sets additional labels on the deployments and pods.
|
|
531
|
+
:param pulumi.Input['BuildxBuilderKubernetesLimitsArgs'] limits: Resource limits for CPU, memory, and ephemeral storage.
|
|
532
|
+
:param pulumi.Input[builtins.str] loadbalance: Load-balancing strategy (sticky or random).
|
|
533
|
+
:param pulumi.Input[builtins.str] namespace: Sets the Kubernetes namespace.
|
|
534
|
+
:param pulumi.Input[builtins.str] nodeselector: Sets the pod's nodeSelector label(s).
|
|
535
|
+
:param pulumi.Input['BuildxBuilderKubernetesQemuArgs'] qemu: QEMU emulation configuration.
|
|
536
|
+
:param pulumi.Input[builtins.int] replicas: Sets the number of Pod replicas to create.
|
|
537
|
+
:param pulumi.Input['BuildxBuilderKubernetesRequestsArgs'] requests: Resource requests for CPU, memory, and ephemeral storage.
|
|
538
|
+
:param pulumi.Input[builtins.bool] rootless: Run the container as a non-root user.
|
|
539
|
+
:param pulumi.Input[builtins.str] schedulername: Sets the scheduler responsible for scheduling the pod.
|
|
540
|
+
:param pulumi.Input[builtins.str] serviceaccount: Sets the pod's serviceAccountName.
|
|
541
|
+
:param pulumi.Input[builtins.str] timeout: Set the timeout limit for pod provisioning.
|
|
542
|
+
:param pulumi.Input[builtins.str] tolerations: Configures the pod's taint toleration.
|
|
543
|
+
"""
|
|
544
|
+
if annotations is not None:
|
|
545
|
+
pulumi.set(__self__, "annotations", annotations)
|
|
546
|
+
if default_load is not None:
|
|
547
|
+
pulumi.set(__self__, "default_load", default_load)
|
|
548
|
+
if image is not None:
|
|
549
|
+
pulumi.set(__self__, "image", image)
|
|
550
|
+
if labels is not None:
|
|
551
|
+
pulumi.set(__self__, "labels", labels)
|
|
552
|
+
if limits is not None:
|
|
553
|
+
pulumi.set(__self__, "limits", limits)
|
|
554
|
+
if loadbalance is not None:
|
|
555
|
+
pulumi.set(__self__, "loadbalance", loadbalance)
|
|
556
|
+
if namespace is not None:
|
|
557
|
+
pulumi.set(__self__, "namespace", namespace)
|
|
558
|
+
if nodeselector is not None:
|
|
559
|
+
pulumi.set(__self__, "nodeselector", nodeselector)
|
|
560
|
+
if qemu is not None:
|
|
561
|
+
pulumi.set(__self__, "qemu", qemu)
|
|
562
|
+
if replicas is not None:
|
|
563
|
+
pulumi.set(__self__, "replicas", replicas)
|
|
564
|
+
if requests is not None:
|
|
565
|
+
pulumi.set(__self__, "requests", requests)
|
|
566
|
+
if rootless is not None:
|
|
567
|
+
pulumi.set(__self__, "rootless", rootless)
|
|
568
|
+
if schedulername is not None:
|
|
569
|
+
pulumi.set(__self__, "schedulername", schedulername)
|
|
570
|
+
if serviceaccount is not None:
|
|
571
|
+
pulumi.set(__self__, "serviceaccount", serviceaccount)
|
|
572
|
+
if timeout is not None:
|
|
573
|
+
pulumi.set(__self__, "timeout", timeout)
|
|
574
|
+
if tolerations is not None:
|
|
575
|
+
pulumi.set(__self__, "tolerations", tolerations)
|
|
576
|
+
|
|
577
|
+
@property
|
|
578
|
+
@pulumi.getter
|
|
579
|
+
def annotations(self) -> Optional[pulumi.Input[builtins.str]]:
|
|
580
|
+
"""
|
|
581
|
+
Sets additional annotations on the deployments and pods.
|
|
582
|
+
"""
|
|
583
|
+
return pulumi.get(self, "annotations")
|
|
584
|
+
|
|
585
|
+
@annotations.setter
|
|
586
|
+
def annotations(self, value: Optional[pulumi.Input[builtins.str]]):
|
|
587
|
+
pulumi.set(self, "annotations", value)
|
|
588
|
+
|
|
589
|
+
@property
|
|
590
|
+
@pulumi.getter(name="defaultLoad")
|
|
591
|
+
def default_load(self) -> Optional[pulumi.Input[builtins.bool]]:
|
|
592
|
+
"""
|
|
593
|
+
Automatically load images to the Docker Engine image store. Defaults to `false`
|
|
594
|
+
"""
|
|
595
|
+
return pulumi.get(self, "default_load")
|
|
596
|
+
|
|
597
|
+
@default_load.setter
|
|
598
|
+
def default_load(self, value: Optional[pulumi.Input[builtins.bool]]):
|
|
599
|
+
pulumi.set(self, "default_load", value)
|
|
600
|
+
|
|
601
|
+
@property
|
|
602
|
+
@pulumi.getter
|
|
603
|
+
def image(self) -> Optional[pulumi.Input[builtins.str]]:
|
|
604
|
+
"""
|
|
605
|
+
Sets the image to use for running BuildKit.
|
|
606
|
+
"""
|
|
607
|
+
return pulumi.get(self, "image")
|
|
608
|
+
|
|
609
|
+
@image.setter
|
|
610
|
+
def image(self, value: Optional[pulumi.Input[builtins.str]]):
|
|
611
|
+
pulumi.set(self, "image", value)
|
|
612
|
+
|
|
613
|
+
@property
|
|
614
|
+
@pulumi.getter
|
|
615
|
+
def labels(self) -> Optional[pulumi.Input[builtins.str]]:
|
|
616
|
+
"""
|
|
617
|
+
Sets additional labels on the deployments and pods.
|
|
618
|
+
"""
|
|
619
|
+
return pulumi.get(self, "labels")
|
|
620
|
+
|
|
621
|
+
@labels.setter
|
|
622
|
+
def labels(self, value: Optional[pulumi.Input[builtins.str]]):
|
|
623
|
+
pulumi.set(self, "labels", value)
|
|
624
|
+
|
|
625
|
+
@property
|
|
626
|
+
@pulumi.getter
|
|
627
|
+
def limits(self) -> Optional[pulumi.Input['BuildxBuilderKubernetesLimitsArgs']]:
|
|
628
|
+
"""
|
|
629
|
+
Resource limits for CPU, memory, and ephemeral storage.
|
|
630
|
+
"""
|
|
631
|
+
return pulumi.get(self, "limits")
|
|
632
|
+
|
|
633
|
+
@limits.setter
|
|
634
|
+
def limits(self, value: Optional[pulumi.Input['BuildxBuilderKubernetesLimitsArgs']]):
|
|
635
|
+
pulumi.set(self, "limits", value)
|
|
636
|
+
|
|
637
|
+
@property
|
|
638
|
+
@pulumi.getter
|
|
639
|
+
def loadbalance(self) -> Optional[pulumi.Input[builtins.str]]:
|
|
640
|
+
"""
|
|
641
|
+
Load-balancing strategy (sticky or random).
|
|
642
|
+
"""
|
|
643
|
+
return pulumi.get(self, "loadbalance")
|
|
644
|
+
|
|
645
|
+
@loadbalance.setter
|
|
646
|
+
def loadbalance(self, value: Optional[pulumi.Input[builtins.str]]):
|
|
647
|
+
pulumi.set(self, "loadbalance", value)
|
|
648
|
+
|
|
649
|
+
@property
|
|
650
|
+
@pulumi.getter
|
|
651
|
+
def namespace(self) -> Optional[pulumi.Input[builtins.str]]:
|
|
652
|
+
"""
|
|
653
|
+
Sets the Kubernetes namespace.
|
|
654
|
+
"""
|
|
655
|
+
return pulumi.get(self, "namespace")
|
|
656
|
+
|
|
657
|
+
@namespace.setter
|
|
658
|
+
def namespace(self, value: Optional[pulumi.Input[builtins.str]]):
|
|
659
|
+
pulumi.set(self, "namespace", value)
|
|
660
|
+
|
|
661
|
+
@property
|
|
662
|
+
@pulumi.getter
|
|
663
|
+
def nodeselector(self) -> Optional[pulumi.Input[builtins.str]]:
|
|
664
|
+
"""
|
|
665
|
+
Sets the pod's nodeSelector label(s).
|
|
666
|
+
"""
|
|
667
|
+
return pulumi.get(self, "nodeselector")
|
|
668
|
+
|
|
669
|
+
@nodeselector.setter
|
|
670
|
+
def nodeselector(self, value: Optional[pulumi.Input[builtins.str]]):
|
|
671
|
+
pulumi.set(self, "nodeselector", value)
|
|
672
|
+
|
|
673
|
+
@property
|
|
674
|
+
@pulumi.getter
|
|
675
|
+
def qemu(self) -> Optional[pulumi.Input['BuildxBuilderKubernetesQemuArgs']]:
|
|
676
|
+
"""
|
|
677
|
+
QEMU emulation configuration.
|
|
678
|
+
"""
|
|
679
|
+
return pulumi.get(self, "qemu")
|
|
680
|
+
|
|
681
|
+
@qemu.setter
|
|
682
|
+
def qemu(self, value: Optional[pulumi.Input['BuildxBuilderKubernetesQemuArgs']]):
|
|
683
|
+
pulumi.set(self, "qemu", value)
|
|
684
|
+
|
|
685
|
+
@property
|
|
686
|
+
@pulumi.getter
|
|
687
|
+
def replicas(self) -> Optional[pulumi.Input[builtins.int]]:
|
|
688
|
+
"""
|
|
689
|
+
Sets the number of Pod replicas to create.
|
|
690
|
+
"""
|
|
691
|
+
return pulumi.get(self, "replicas")
|
|
692
|
+
|
|
693
|
+
@replicas.setter
|
|
694
|
+
def replicas(self, value: Optional[pulumi.Input[builtins.int]]):
|
|
695
|
+
pulumi.set(self, "replicas", value)
|
|
696
|
+
|
|
697
|
+
@property
|
|
698
|
+
@pulumi.getter
|
|
699
|
+
def requests(self) -> Optional[pulumi.Input['BuildxBuilderKubernetesRequestsArgs']]:
|
|
700
|
+
"""
|
|
701
|
+
Resource requests for CPU, memory, and ephemeral storage.
|
|
702
|
+
"""
|
|
703
|
+
return pulumi.get(self, "requests")
|
|
704
|
+
|
|
705
|
+
@requests.setter
|
|
706
|
+
def requests(self, value: Optional[pulumi.Input['BuildxBuilderKubernetesRequestsArgs']]):
|
|
707
|
+
pulumi.set(self, "requests", value)
|
|
708
|
+
|
|
709
|
+
@property
|
|
710
|
+
@pulumi.getter
|
|
711
|
+
def rootless(self) -> Optional[pulumi.Input[builtins.bool]]:
|
|
712
|
+
"""
|
|
713
|
+
Run the container as a non-root user.
|
|
714
|
+
"""
|
|
715
|
+
return pulumi.get(self, "rootless")
|
|
716
|
+
|
|
717
|
+
@rootless.setter
|
|
718
|
+
def rootless(self, value: Optional[pulumi.Input[builtins.bool]]):
|
|
719
|
+
pulumi.set(self, "rootless", value)
|
|
720
|
+
|
|
721
|
+
@property
|
|
722
|
+
@pulumi.getter
|
|
723
|
+
def schedulername(self) -> Optional[pulumi.Input[builtins.str]]:
|
|
724
|
+
"""
|
|
725
|
+
Sets the scheduler responsible for scheduling the pod.
|
|
726
|
+
"""
|
|
727
|
+
return pulumi.get(self, "schedulername")
|
|
728
|
+
|
|
729
|
+
@schedulername.setter
|
|
730
|
+
def schedulername(self, value: Optional[pulumi.Input[builtins.str]]):
|
|
731
|
+
pulumi.set(self, "schedulername", value)
|
|
732
|
+
|
|
733
|
+
@property
|
|
734
|
+
@pulumi.getter
|
|
735
|
+
def serviceaccount(self) -> Optional[pulumi.Input[builtins.str]]:
|
|
736
|
+
"""
|
|
737
|
+
Sets the pod's serviceAccountName.
|
|
738
|
+
"""
|
|
739
|
+
return pulumi.get(self, "serviceaccount")
|
|
740
|
+
|
|
741
|
+
@serviceaccount.setter
|
|
742
|
+
def serviceaccount(self, value: Optional[pulumi.Input[builtins.str]]):
|
|
743
|
+
pulumi.set(self, "serviceaccount", value)
|
|
744
|
+
|
|
745
|
+
@property
|
|
746
|
+
@pulumi.getter
|
|
747
|
+
def timeout(self) -> Optional[pulumi.Input[builtins.str]]:
|
|
748
|
+
"""
|
|
749
|
+
Set the timeout limit for pod provisioning.
|
|
750
|
+
"""
|
|
751
|
+
return pulumi.get(self, "timeout")
|
|
752
|
+
|
|
753
|
+
@timeout.setter
|
|
754
|
+
def timeout(self, value: Optional[pulumi.Input[builtins.str]]):
|
|
755
|
+
pulumi.set(self, "timeout", value)
|
|
756
|
+
|
|
757
|
+
@property
|
|
758
|
+
@pulumi.getter
|
|
759
|
+
def tolerations(self) -> Optional[pulumi.Input[builtins.str]]:
|
|
760
|
+
"""
|
|
761
|
+
Configures the pod's taint toleration.
|
|
762
|
+
"""
|
|
763
|
+
return pulumi.get(self, "tolerations")
|
|
764
|
+
|
|
765
|
+
@tolerations.setter
|
|
766
|
+
def tolerations(self, value: Optional[pulumi.Input[builtins.str]]):
|
|
767
|
+
pulumi.set(self, "tolerations", value)
|
|
768
|
+
|
|
769
|
+
|
|
770
|
+
if not MYPY:
|
|
771
|
+
class BuildxBuilderKubernetesLimitsArgsDict(TypedDict):
|
|
772
|
+
cpu: NotRequired[pulumi.Input[builtins.str]]
|
|
773
|
+
"""
|
|
774
|
+
CPU limit for the Kubernetes pod.
|
|
775
|
+
"""
|
|
776
|
+
ephemeral_storage: NotRequired[pulumi.Input[builtins.str]]
|
|
777
|
+
"""
|
|
778
|
+
Ephemeral storage limit for the Kubernetes pod.
|
|
779
|
+
"""
|
|
780
|
+
memory: NotRequired[pulumi.Input[builtins.str]]
|
|
781
|
+
"""
|
|
782
|
+
Memory limit for the Kubernetes pod.
|
|
783
|
+
"""
|
|
784
|
+
elif False:
|
|
785
|
+
BuildxBuilderKubernetesLimitsArgsDict: TypeAlias = Mapping[str, Any]
|
|
786
|
+
|
|
787
|
+
@pulumi.input_type
|
|
788
|
+
class BuildxBuilderKubernetesLimitsArgs:
|
|
789
|
+
def __init__(__self__, *,
|
|
790
|
+
cpu: Optional[pulumi.Input[builtins.str]] = None,
|
|
791
|
+
ephemeral_storage: Optional[pulumi.Input[builtins.str]] = None,
|
|
792
|
+
memory: Optional[pulumi.Input[builtins.str]] = None):
|
|
793
|
+
"""
|
|
794
|
+
:param pulumi.Input[builtins.str] cpu: CPU limit for the Kubernetes pod.
|
|
795
|
+
:param pulumi.Input[builtins.str] ephemeral_storage: Ephemeral storage limit for the Kubernetes pod.
|
|
796
|
+
:param pulumi.Input[builtins.str] memory: Memory limit for the Kubernetes pod.
|
|
797
|
+
"""
|
|
798
|
+
if cpu is not None:
|
|
799
|
+
pulumi.set(__self__, "cpu", cpu)
|
|
800
|
+
if ephemeral_storage is not None:
|
|
801
|
+
pulumi.set(__self__, "ephemeral_storage", ephemeral_storage)
|
|
802
|
+
if memory is not None:
|
|
803
|
+
pulumi.set(__self__, "memory", memory)
|
|
804
|
+
|
|
805
|
+
@property
|
|
806
|
+
@pulumi.getter
|
|
807
|
+
def cpu(self) -> Optional[pulumi.Input[builtins.str]]:
|
|
808
|
+
"""
|
|
809
|
+
CPU limit for the Kubernetes pod.
|
|
810
|
+
"""
|
|
811
|
+
return pulumi.get(self, "cpu")
|
|
812
|
+
|
|
813
|
+
@cpu.setter
|
|
814
|
+
def cpu(self, value: Optional[pulumi.Input[builtins.str]]):
|
|
815
|
+
pulumi.set(self, "cpu", value)
|
|
816
|
+
|
|
817
|
+
@property
|
|
818
|
+
@pulumi.getter(name="ephemeralStorage")
|
|
819
|
+
def ephemeral_storage(self) -> Optional[pulumi.Input[builtins.str]]:
|
|
820
|
+
"""
|
|
821
|
+
Ephemeral storage limit for the Kubernetes pod.
|
|
822
|
+
"""
|
|
823
|
+
return pulumi.get(self, "ephemeral_storage")
|
|
824
|
+
|
|
825
|
+
@ephemeral_storage.setter
|
|
826
|
+
def ephemeral_storage(self, value: Optional[pulumi.Input[builtins.str]]):
|
|
827
|
+
pulumi.set(self, "ephemeral_storage", value)
|
|
828
|
+
|
|
829
|
+
@property
|
|
830
|
+
@pulumi.getter
|
|
831
|
+
def memory(self) -> Optional[pulumi.Input[builtins.str]]:
|
|
832
|
+
"""
|
|
833
|
+
Memory limit for the Kubernetes pod.
|
|
834
|
+
"""
|
|
835
|
+
return pulumi.get(self, "memory")
|
|
836
|
+
|
|
837
|
+
@memory.setter
|
|
838
|
+
def memory(self, value: Optional[pulumi.Input[builtins.str]]):
|
|
839
|
+
pulumi.set(self, "memory", value)
|
|
840
|
+
|
|
841
|
+
|
|
842
|
+
if not MYPY:
|
|
843
|
+
class BuildxBuilderKubernetesQemuArgsDict(TypedDict):
|
|
844
|
+
image: NotRequired[pulumi.Input[builtins.str]]
|
|
845
|
+
"""
|
|
846
|
+
Sets the QEMU emulation image.
|
|
847
|
+
"""
|
|
848
|
+
install: NotRequired[pulumi.Input[builtins.bool]]
|
|
849
|
+
"""
|
|
850
|
+
Install QEMU emulation for multi-platform support.
|
|
851
|
+
"""
|
|
852
|
+
elif False:
|
|
853
|
+
BuildxBuilderKubernetesQemuArgsDict: TypeAlias = Mapping[str, Any]
|
|
854
|
+
|
|
855
|
+
@pulumi.input_type
|
|
856
|
+
class BuildxBuilderKubernetesQemuArgs:
|
|
857
|
+
def __init__(__self__, *,
|
|
858
|
+
image: Optional[pulumi.Input[builtins.str]] = None,
|
|
859
|
+
install: Optional[pulumi.Input[builtins.bool]] = None):
|
|
860
|
+
"""
|
|
861
|
+
:param pulumi.Input[builtins.str] image: Sets the QEMU emulation image.
|
|
862
|
+
:param pulumi.Input[builtins.bool] install: Install QEMU emulation for multi-platform support.
|
|
863
|
+
"""
|
|
864
|
+
if image is not None:
|
|
865
|
+
pulumi.set(__self__, "image", image)
|
|
866
|
+
if install is not None:
|
|
867
|
+
pulumi.set(__self__, "install", install)
|
|
868
|
+
|
|
869
|
+
@property
|
|
870
|
+
@pulumi.getter
|
|
871
|
+
def image(self) -> Optional[pulumi.Input[builtins.str]]:
|
|
872
|
+
"""
|
|
873
|
+
Sets the QEMU emulation image.
|
|
874
|
+
"""
|
|
875
|
+
return pulumi.get(self, "image")
|
|
876
|
+
|
|
877
|
+
@image.setter
|
|
878
|
+
def image(self, value: Optional[pulumi.Input[builtins.str]]):
|
|
879
|
+
pulumi.set(self, "image", value)
|
|
880
|
+
|
|
881
|
+
@property
|
|
882
|
+
@pulumi.getter
|
|
883
|
+
def install(self) -> Optional[pulumi.Input[builtins.bool]]:
|
|
884
|
+
"""
|
|
885
|
+
Install QEMU emulation for multi-platform support.
|
|
886
|
+
"""
|
|
887
|
+
return pulumi.get(self, "install")
|
|
888
|
+
|
|
889
|
+
@install.setter
|
|
890
|
+
def install(self, value: Optional[pulumi.Input[builtins.bool]]):
|
|
891
|
+
pulumi.set(self, "install", value)
|
|
892
|
+
|
|
893
|
+
|
|
894
|
+
if not MYPY:
|
|
895
|
+
class BuildxBuilderKubernetesRequestsArgsDict(TypedDict):
|
|
896
|
+
cpu: NotRequired[pulumi.Input[builtins.str]]
|
|
897
|
+
"""
|
|
898
|
+
CPU limit for the Kubernetes pod.
|
|
899
|
+
"""
|
|
900
|
+
ephemeral_storage: NotRequired[pulumi.Input[builtins.str]]
|
|
901
|
+
"""
|
|
902
|
+
Ephemeral storage limit for the Kubernetes pod.
|
|
903
|
+
"""
|
|
904
|
+
memory: NotRequired[pulumi.Input[builtins.str]]
|
|
905
|
+
"""
|
|
906
|
+
Memory limit for the Kubernetes pod.
|
|
907
|
+
"""
|
|
908
|
+
elif False:
|
|
909
|
+
BuildxBuilderKubernetesRequestsArgsDict: TypeAlias = Mapping[str, Any]
|
|
910
|
+
|
|
911
|
+
@pulumi.input_type
|
|
912
|
+
class BuildxBuilderKubernetesRequestsArgs:
|
|
913
|
+
def __init__(__self__, *,
|
|
914
|
+
cpu: Optional[pulumi.Input[builtins.str]] = None,
|
|
915
|
+
ephemeral_storage: Optional[pulumi.Input[builtins.str]] = None,
|
|
916
|
+
memory: Optional[pulumi.Input[builtins.str]] = None):
|
|
917
|
+
"""
|
|
918
|
+
:param pulumi.Input[builtins.str] cpu: CPU limit for the Kubernetes pod.
|
|
919
|
+
:param pulumi.Input[builtins.str] ephemeral_storage: Ephemeral storage limit for the Kubernetes pod.
|
|
920
|
+
:param pulumi.Input[builtins.str] memory: Memory limit for the Kubernetes pod.
|
|
921
|
+
"""
|
|
922
|
+
if cpu is not None:
|
|
923
|
+
pulumi.set(__self__, "cpu", cpu)
|
|
924
|
+
if ephemeral_storage is not None:
|
|
925
|
+
pulumi.set(__self__, "ephemeral_storage", ephemeral_storage)
|
|
926
|
+
if memory is not None:
|
|
927
|
+
pulumi.set(__self__, "memory", memory)
|
|
928
|
+
|
|
929
|
+
@property
|
|
930
|
+
@pulumi.getter
|
|
931
|
+
def cpu(self) -> Optional[pulumi.Input[builtins.str]]:
|
|
932
|
+
"""
|
|
933
|
+
CPU limit for the Kubernetes pod.
|
|
934
|
+
"""
|
|
935
|
+
return pulumi.get(self, "cpu")
|
|
936
|
+
|
|
937
|
+
@cpu.setter
|
|
938
|
+
def cpu(self, value: Optional[pulumi.Input[builtins.str]]):
|
|
939
|
+
pulumi.set(self, "cpu", value)
|
|
940
|
+
|
|
941
|
+
@property
|
|
942
|
+
@pulumi.getter(name="ephemeralStorage")
|
|
943
|
+
def ephemeral_storage(self) -> Optional[pulumi.Input[builtins.str]]:
|
|
944
|
+
"""
|
|
945
|
+
Ephemeral storage limit for the Kubernetes pod.
|
|
946
|
+
"""
|
|
947
|
+
return pulumi.get(self, "ephemeral_storage")
|
|
948
|
+
|
|
949
|
+
@ephemeral_storage.setter
|
|
950
|
+
def ephemeral_storage(self, value: Optional[pulumi.Input[builtins.str]]):
|
|
951
|
+
pulumi.set(self, "ephemeral_storage", value)
|
|
952
|
+
|
|
953
|
+
@property
|
|
954
|
+
@pulumi.getter
|
|
955
|
+
def memory(self) -> Optional[pulumi.Input[builtins.str]]:
|
|
956
|
+
"""
|
|
957
|
+
Memory limit for the Kubernetes pod.
|
|
958
|
+
"""
|
|
959
|
+
return pulumi.get(self, "memory")
|
|
960
|
+
|
|
961
|
+
@memory.setter
|
|
962
|
+
def memory(self, value: Optional[pulumi.Input[builtins.str]]):
|
|
963
|
+
pulumi.set(self, "memory", value)
|
|
964
|
+
|
|
965
|
+
|
|
966
|
+
if not MYPY:
|
|
967
|
+
class BuildxBuilderRemoteArgsDict(TypedDict):
|
|
968
|
+
cacert: NotRequired[pulumi.Input[builtins.str]]
|
|
969
|
+
"""
|
|
970
|
+
Absolute path to the TLS certificate authority used for validation.
|
|
971
|
+
"""
|
|
972
|
+
cert: NotRequired[pulumi.Input[builtins.str]]
|
|
973
|
+
"""
|
|
974
|
+
Absolute path to the TLS client certificate to present to buildkitd.
|
|
975
|
+
"""
|
|
976
|
+
default_load: NotRequired[pulumi.Input[builtins.bool]]
|
|
977
|
+
"""
|
|
978
|
+
Automatically load images to the Docker Engine image store. Defaults to `false`
|
|
979
|
+
"""
|
|
980
|
+
key: NotRequired[pulumi.Input[builtins.str]]
|
|
981
|
+
"""
|
|
982
|
+
Sets the TLS client key.
|
|
983
|
+
"""
|
|
984
|
+
servername: NotRequired[pulumi.Input[builtins.str]]
|
|
985
|
+
"""
|
|
986
|
+
TLS server name used in requests.
|
|
987
|
+
"""
|
|
988
|
+
elif False:
|
|
989
|
+
BuildxBuilderRemoteArgsDict: TypeAlias = Mapping[str, Any]
|
|
990
|
+
|
|
991
|
+
@pulumi.input_type
|
|
992
|
+
class BuildxBuilderRemoteArgs:
|
|
993
|
+
def __init__(__self__, *,
|
|
994
|
+
cacert: Optional[pulumi.Input[builtins.str]] = None,
|
|
995
|
+
cert: Optional[pulumi.Input[builtins.str]] = None,
|
|
996
|
+
default_load: Optional[pulumi.Input[builtins.bool]] = None,
|
|
997
|
+
key: Optional[pulumi.Input[builtins.str]] = None,
|
|
998
|
+
servername: Optional[pulumi.Input[builtins.str]] = None):
|
|
999
|
+
"""
|
|
1000
|
+
:param pulumi.Input[builtins.str] cacert: Absolute path to the TLS certificate authority used for validation.
|
|
1001
|
+
:param pulumi.Input[builtins.str] cert: Absolute path to the TLS client certificate to present to buildkitd.
|
|
1002
|
+
:param pulumi.Input[builtins.bool] default_load: Automatically load images to the Docker Engine image store. Defaults to `false`
|
|
1003
|
+
:param pulumi.Input[builtins.str] key: Sets the TLS client key.
|
|
1004
|
+
:param pulumi.Input[builtins.str] servername: TLS server name used in requests.
|
|
1005
|
+
"""
|
|
1006
|
+
if cacert is not None:
|
|
1007
|
+
pulumi.set(__self__, "cacert", cacert)
|
|
1008
|
+
if cert is not None:
|
|
1009
|
+
pulumi.set(__self__, "cert", cert)
|
|
1010
|
+
if default_load is not None:
|
|
1011
|
+
pulumi.set(__self__, "default_load", default_load)
|
|
1012
|
+
if key is not None:
|
|
1013
|
+
pulumi.set(__self__, "key", key)
|
|
1014
|
+
if servername is not None:
|
|
1015
|
+
pulumi.set(__self__, "servername", servername)
|
|
1016
|
+
|
|
1017
|
+
@property
|
|
1018
|
+
@pulumi.getter
|
|
1019
|
+
def cacert(self) -> Optional[pulumi.Input[builtins.str]]:
|
|
1020
|
+
"""
|
|
1021
|
+
Absolute path to the TLS certificate authority used for validation.
|
|
1022
|
+
"""
|
|
1023
|
+
return pulumi.get(self, "cacert")
|
|
1024
|
+
|
|
1025
|
+
@cacert.setter
|
|
1026
|
+
def cacert(self, value: Optional[pulumi.Input[builtins.str]]):
|
|
1027
|
+
pulumi.set(self, "cacert", value)
|
|
1028
|
+
|
|
1029
|
+
@property
|
|
1030
|
+
@pulumi.getter
|
|
1031
|
+
def cert(self) -> Optional[pulumi.Input[builtins.str]]:
|
|
1032
|
+
"""
|
|
1033
|
+
Absolute path to the TLS client certificate to present to buildkitd.
|
|
1034
|
+
"""
|
|
1035
|
+
return pulumi.get(self, "cert")
|
|
1036
|
+
|
|
1037
|
+
@cert.setter
|
|
1038
|
+
def cert(self, value: Optional[pulumi.Input[builtins.str]]):
|
|
1039
|
+
pulumi.set(self, "cert", value)
|
|
1040
|
+
|
|
1041
|
+
@property
|
|
1042
|
+
@pulumi.getter(name="defaultLoad")
|
|
1043
|
+
def default_load(self) -> Optional[pulumi.Input[builtins.bool]]:
|
|
1044
|
+
"""
|
|
1045
|
+
Automatically load images to the Docker Engine image store. Defaults to `false`
|
|
1046
|
+
"""
|
|
1047
|
+
return pulumi.get(self, "default_load")
|
|
1048
|
+
|
|
1049
|
+
@default_load.setter
|
|
1050
|
+
def default_load(self, value: Optional[pulumi.Input[builtins.bool]]):
|
|
1051
|
+
pulumi.set(self, "default_load", value)
|
|
1052
|
+
|
|
1053
|
+
@property
|
|
1054
|
+
@pulumi.getter
|
|
1055
|
+
def key(self) -> Optional[pulumi.Input[builtins.str]]:
|
|
1056
|
+
"""
|
|
1057
|
+
Sets the TLS client key.
|
|
1058
|
+
"""
|
|
1059
|
+
return pulumi.get(self, "key")
|
|
1060
|
+
|
|
1061
|
+
@key.setter
|
|
1062
|
+
def key(self, value: Optional[pulumi.Input[builtins.str]]):
|
|
1063
|
+
pulumi.set(self, "key", value)
|
|
1064
|
+
|
|
1065
|
+
@property
|
|
1066
|
+
@pulumi.getter
|
|
1067
|
+
def servername(self) -> Optional[pulumi.Input[builtins.str]]:
|
|
1068
|
+
"""
|
|
1069
|
+
TLS server name used in requests.
|
|
1070
|
+
"""
|
|
1071
|
+
return pulumi.get(self, "servername")
|
|
1072
|
+
|
|
1073
|
+
@servername.setter
|
|
1074
|
+
def servername(self, value: Optional[pulumi.Input[builtins.str]]):
|
|
1075
|
+
pulumi.set(self, "servername", value)
|
|
1076
|
+
|
|
1077
|
+
|
|
154
1078
|
if not MYPY:
|
|
155
1079
|
class ContainerCapabilitiesArgsDict(TypedDict):
|
|
156
1080
|
adds: NotRequired[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]
|
|
@@ -1996,7 +2920,7 @@ if not MYPY:
|
|
|
1996
2920
|
"""
|
|
1997
2921
|
builder: NotRequired[pulumi.Input[builtins.str]]
|
|
1998
2922
|
"""
|
|
1999
|
-
Set the name of the buildx builder to use. If not set
|
|
2923
|
+
Set the name of the buildx builder to use. If not set, the legacy builder is used.
|
|
2000
2924
|
"""
|
|
2001
2925
|
cache_froms: NotRequired[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]
|
|
2002
2926
|
"""
|
|
@@ -2068,7 +2992,7 @@ if not MYPY:
|
|
|
2068
2992
|
"""
|
|
2069
2993
|
platform: NotRequired[pulumi.Input[builtins.str]]
|
|
2070
2994
|
"""
|
|
2071
|
-
Set platform
|
|
2995
|
+
Set the target platform for the build. Defaults to `GOOS/GOARCH`. For more information see the [docker documentation](https://github.com/docker/buildx/blob/master/docs/reference/buildx.md#-set-the-target-platforms-for-the-build---platform)
|
|
2072
2996
|
"""
|
|
2073
2997
|
pull_parent: NotRequired[pulumi.Input[builtins.bool]]
|
|
2074
2998
|
"""
|
|
@@ -2171,7 +3095,7 @@ class RemoteImageBuildArgs:
|
|
|
2171
3095
|
:param pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]] build_args: Pairs for build-time variables in the form of `ENDPOINT : "https://example.com"`
|
|
2172
3096
|
:param pulumi.Input[builtins.str] build_id: 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.
|
|
2173
3097
|
:param pulumi.Input[builtins.str] build_log_file: Path to a file where the buildx log are written to. Only available when `builder` is set. If not set, no logs are available. The path is taken as is, so make sure to use a path that is available.
|
|
2174
|
-
:param pulumi.Input[builtins.str] builder: Set the name of the buildx builder to use. If not set
|
|
3098
|
+
:param pulumi.Input[builtins.str] builder: Set the name of the buildx builder to use. If not set, the legacy builder is used.
|
|
2175
3099
|
:param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] cache_froms: Images to consider as cache sources
|
|
2176
3100
|
:param pulumi.Input[builtins.str] cgroup_parent: Optional parent cgroup for the container
|
|
2177
3101
|
:param pulumi.Input[builtins.int] cpu_period: The length of a CPU period in microseconds
|
|
@@ -2189,7 +3113,7 @@ class RemoteImageBuildArgs:
|
|
|
2189
3113
|
:param pulumi.Input[builtins.int] memory_swap: Total memory (memory + swap), -1 to enable unlimited swap
|
|
2190
3114
|
:param pulumi.Input[builtins.str] network_mode: Set the networking mode for the RUN instructions during build
|
|
2191
3115
|
:param pulumi.Input[builtins.bool] no_cache: Do not use the cache when building the image
|
|
2192
|
-
:param pulumi.Input[builtins.str] platform: Set platform
|
|
3116
|
+
:param pulumi.Input[builtins.str] platform: Set the target platform for the build. Defaults to `GOOS/GOARCH`. For more information see the [docker documentation](https://github.com/docker/buildx/blob/master/docs/reference/buildx.md#-set-the-target-platforms-for-the-build---platform)
|
|
2193
3117
|
:param pulumi.Input[builtins.bool] pull_parent: Attempt to pull the image even if an older image exists locally
|
|
2194
3118
|
:param pulumi.Input[builtins.str] remote_context: A Git repository URI or HTTP/HTTPS context URI. Will be ignored if `builder` is set.
|
|
2195
3119
|
:param pulumi.Input[builtins.bool] remove: Remove intermediate containers after a successful build. Defaults to `true`.
|
|
@@ -2342,7 +3266,7 @@ class RemoteImageBuildArgs:
|
|
|
2342
3266
|
@pulumi.getter
|
|
2343
3267
|
def builder(self) -> Optional[pulumi.Input[builtins.str]]:
|
|
2344
3268
|
"""
|
|
2345
|
-
Set the name of the buildx builder to use. If not set
|
|
3269
|
+
Set the name of the buildx builder to use. If not set, the legacy builder is used.
|
|
2346
3270
|
"""
|
|
2347
3271
|
return pulumi.get(self, "builder")
|
|
2348
3272
|
|
|
@@ -2558,7 +3482,7 @@ class RemoteImageBuildArgs:
|
|
|
2558
3482
|
@pulumi.getter
|
|
2559
3483
|
def platform(self) -> Optional[pulumi.Input[builtins.str]]:
|
|
2560
3484
|
"""
|
|
2561
|
-
Set platform
|
|
3485
|
+
Set the target platform for the build. Defaults to `GOOS/GOARCH`. For more information see the [docker documentation](https://github.com/docker/buildx/blob/master/docs/reference/buildx.md#-set-the-target-platforms-for-the-build---platform)
|
|
2562
3486
|
"""
|
|
2563
3487
|
return pulumi.get(self, "platform")
|
|
2564
3488
|
|
|
@@ -3817,6 +4741,14 @@ if not MYPY:
|
|
|
3817
4741
|
"""
|
|
3818
4742
|
Arguments to the command
|
|
3819
4743
|
"""
|
|
4744
|
+
cap_adds: NotRequired[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]
|
|
4745
|
+
"""
|
|
4746
|
+
List of Linux capabilities to add to the container
|
|
4747
|
+
"""
|
|
4748
|
+
cap_drops: NotRequired[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]
|
|
4749
|
+
"""
|
|
4750
|
+
List of Linux capabilities to drop from the container
|
|
4751
|
+
"""
|
|
3820
4752
|
commands: NotRequired[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]
|
|
3821
4753
|
"""
|
|
3822
4754
|
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.
|
|
@@ -3901,6 +4833,8 @@ class ServiceTaskSpecContainerSpecArgs:
|
|
|
3901
4833
|
def __init__(__self__, *,
|
|
3902
4834
|
image: pulumi.Input[builtins.str],
|
|
3903
4835
|
args: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None,
|
|
4836
|
+
cap_adds: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None,
|
|
4837
|
+
cap_drops: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None,
|
|
3904
4838
|
commands: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None,
|
|
3905
4839
|
configs: Optional[pulumi.Input[Sequence[pulumi.Input['ServiceTaskSpecContainerSpecConfigArgs']]]] = None,
|
|
3906
4840
|
dir: Optional[pulumi.Input[builtins.str]] = None,
|
|
@@ -3923,6 +4857,8 @@ class ServiceTaskSpecContainerSpecArgs:
|
|
|
3923
4857
|
"""
|
|
3924
4858
|
:param pulumi.Input[builtins.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.
|
|
3925
4859
|
:param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] args: Arguments to the command
|
|
4860
|
+
:param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] cap_adds: List of Linux capabilities to add to the container
|
|
4861
|
+
:param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] cap_drops: List of Linux capabilities to drop from the container
|
|
3926
4862
|
:param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] commands: 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.
|
|
3927
4863
|
:param pulumi.Input[Sequence[pulumi.Input['ServiceTaskSpecContainerSpecConfigArgs']]] configs: References to zero or more configs that will be exposed to the service
|
|
3928
4864
|
:param pulumi.Input[builtins.str] dir: The working directory for commands to run in
|
|
@@ -3946,6 +4882,10 @@ class ServiceTaskSpecContainerSpecArgs:
|
|
|
3946
4882
|
pulumi.set(__self__, "image", image)
|
|
3947
4883
|
if args is not None:
|
|
3948
4884
|
pulumi.set(__self__, "args", args)
|
|
4885
|
+
if cap_adds is not None:
|
|
4886
|
+
pulumi.set(__self__, "cap_adds", cap_adds)
|
|
4887
|
+
if cap_drops is not None:
|
|
4888
|
+
pulumi.set(__self__, "cap_drops", cap_drops)
|
|
3949
4889
|
if commands is not None:
|
|
3950
4890
|
pulumi.set(__self__, "commands", commands)
|
|
3951
4891
|
if configs is not None:
|
|
@@ -4009,6 +4949,30 @@ class ServiceTaskSpecContainerSpecArgs:
|
|
|
4009
4949
|
def args(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]):
|
|
4010
4950
|
pulumi.set(self, "args", value)
|
|
4011
4951
|
|
|
4952
|
+
@property
|
|
4953
|
+
@pulumi.getter(name="capAdds")
|
|
4954
|
+
def cap_adds(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]:
|
|
4955
|
+
"""
|
|
4956
|
+
List of Linux capabilities to add to the container
|
|
4957
|
+
"""
|
|
4958
|
+
return pulumi.get(self, "cap_adds")
|
|
4959
|
+
|
|
4960
|
+
@cap_adds.setter
|
|
4961
|
+
def cap_adds(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]):
|
|
4962
|
+
pulumi.set(self, "cap_adds", value)
|
|
4963
|
+
|
|
4964
|
+
@property
|
|
4965
|
+
@pulumi.getter(name="capDrops")
|
|
4966
|
+
def cap_drops(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]:
|
|
4967
|
+
"""
|
|
4968
|
+
List of Linux capabilities to drop from the container
|
|
4969
|
+
"""
|
|
4970
|
+
return pulumi.get(self, "cap_drops")
|
|
4971
|
+
|
|
4972
|
+
@cap_drops.setter
|
|
4973
|
+
def cap_drops(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]):
|
|
4974
|
+
pulumi.set(self, "cap_drops", value)
|
|
4975
|
+
|
|
4012
4976
|
@property
|
|
4013
4977
|
@pulumi.getter
|
|
4014
4978
|
def commands(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]:
|