pulumi-docker-build 0.1.0a1736895711__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-build might be problematic. Click here for more details.
- pulumi_docker_build/__init__.py +46 -0
- pulumi_docker_build/_enums.py +84 -0
- pulumi_docker_build/_inputs.py +3485 -0
- pulumi_docker_build/_utilities.py +327 -0
- pulumi_docker_build/config/__init__.py +8 -0
- pulumi_docker_build/config/__init__.pyi +24 -0
- pulumi_docker_build/config/vars.py +34 -0
- pulumi_docker_build/image.py +1804 -0
- pulumi_docker_build/index.py +381 -0
- pulumi_docker_build/outputs.py +2404 -0
- pulumi_docker_build/provider.py +123 -0
- pulumi_docker_build/pulumi-plugin.json +5 -0
- pulumi_docker_build/py.typed +0 -0
- pulumi_docker_build-0.1.0a1736895711.dist-info/METADATA +38 -0
- pulumi_docker_build-0.1.0a1736895711.dist-info/RECORD +17 -0
- pulumi_docker_build-0.1.0a1736895711.dist-info/WHEEL +5 -0
- pulumi_docker_build-0.1.0a1736895711.dist-info/top_level.txt +1 -0
|
@@ -0,0 +1,3485 @@
|
|
|
1
|
+
# coding=utf-8
|
|
2
|
+
# *** WARNING: this file was generated by pulumi-language-python. ***
|
|
3
|
+
# *** Do not edit by hand unless you're certain you know what you are doing! ***
|
|
4
|
+
|
|
5
|
+
import copy
|
|
6
|
+
import warnings
|
|
7
|
+
import sys
|
|
8
|
+
import pulumi
|
|
9
|
+
import pulumi.runtime
|
|
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
|
|
15
|
+
from . import _utilities
|
|
16
|
+
from ._enums import *
|
|
17
|
+
|
|
18
|
+
__all__ = [
|
|
19
|
+
'BuildContextArgs',
|
|
20
|
+
'BuildContextArgsDict',
|
|
21
|
+
'BuilderConfigArgs',
|
|
22
|
+
'BuilderConfigArgsDict',
|
|
23
|
+
'CacheFromAzureBlobArgs',
|
|
24
|
+
'CacheFromAzureBlobArgsDict',
|
|
25
|
+
'CacheFromGitHubActionsArgs',
|
|
26
|
+
'CacheFromGitHubActionsArgsDict',
|
|
27
|
+
'CacheFromLocalArgs',
|
|
28
|
+
'CacheFromLocalArgsDict',
|
|
29
|
+
'CacheFromRegistryArgs',
|
|
30
|
+
'CacheFromRegistryArgsDict',
|
|
31
|
+
'CacheFromS3Args',
|
|
32
|
+
'CacheFromS3ArgsDict',
|
|
33
|
+
'CacheFromArgs',
|
|
34
|
+
'CacheFromArgsDict',
|
|
35
|
+
'CacheToAzureBlobArgs',
|
|
36
|
+
'CacheToAzureBlobArgsDict',
|
|
37
|
+
'CacheToGitHubActionsArgs',
|
|
38
|
+
'CacheToGitHubActionsArgsDict',
|
|
39
|
+
'CacheToInlineArgs',
|
|
40
|
+
'CacheToInlineArgsDict',
|
|
41
|
+
'CacheToLocalArgs',
|
|
42
|
+
'CacheToLocalArgsDict',
|
|
43
|
+
'CacheToRegistryArgs',
|
|
44
|
+
'CacheToRegistryArgsDict',
|
|
45
|
+
'CacheToS3Args',
|
|
46
|
+
'CacheToS3ArgsDict',
|
|
47
|
+
'CacheToArgs',
|
|
48
|
+
'CacheToArgsDict',
|
|
49
|
+
'ContextArgs',
|
|
50
|
+
'ContextArgsDict',
|
|
51
|
+
'DockerfileArgs',
|
|
52
|
+
'DockerfileArgsDict',
|
|
53
|
+
'ExportCacheOnlyArgs',
|
|
54
|
+
'ExportCacheOnlyArgsDict',
|
|
55
|
+
'ExportDockerArgs',
|
|
56
|
+
'ExportDockerArgsDict',
|
|
57
|
+
'ExportImageArgs',
|
|
58
|
+
'ExportImageArgsDict',
|
|
59
|
+
'ExportLocalArgs',
|
|
60
|
+
'ExportLocalArgsDict',
|
|
61
|
+
'ExportOCIArgs',
|
|
62
|
+
'ExportOCIArgsDict',
|
|
63
|
+
'ExportRegistryArgs',
|
|
64
|
+
'ExportRegistryArgsDict',
|
|
65
|
+
'ExportTarArgs',
|
|
66
|
+
'ExportTarArgsDict',
|
|
67
|
+
'ExportArgs',
|
|
68
|
+
'ExportArgsDict',
|
|
69
|
+
'RegistryArgs',
|
|
70
|
+
'RegistryArgsDict',
|
|
71
|
+
'SSHArgs',
|
|
72
|
+
'SSHArgsDict',
|
|
73
|
+
]
|
|
74
|
+
|
|
75
|
+
MYPY = False
|
|
76
|
+
|
|
77
|
+
if not MYPY:
|
|
78
|
+
class BuildContextArgsDict(TypedDict):
|
|
79
|
+
location: pulumi.Input[str]
|
|
80
|
+
"""
|
|
81
|
+
Resources to use for build context.
|
|
82
|
+
|
|
83
|
+
The location can be:
|
|
84
|
+
* A relative or absolute path to a local directory (`.`, `./app`,
|
|
85
|
+
`/app`, etc.).
|
|
86
|
+
* A remote URL of a Git repository, tarball, or plain text file
|
|
87
|
+
(`https://github.com/user/myrepo.git`, `http://server/context.tar.gz`,
|
|
88
|
+
etc.).
|
|
89
|
+
"""
|
|
90
|
+
named: NotRequired[pulumi.Input[Mapping[str, pulumi.Input['ContextArgsDict']]]]
|
|
91
|
+
"""
|
|
92
|
+
Additional build contexts to use.
|
|
93
|
+
|
|
94
|
+
These contexts are accessed with `FROM name` or `--from=name`
|
|
95
|
+
statements when using Dockerfile 1.4+ syntax.
|
|
96
|
+
|
|
97
|
+
Values can be local paths, HTTP URLs, or `docker-image://` images.
|
|
98
|
+
"""
|
|
99
|
+
elif False:
|
|
100
|
+
BuildContextArgsDict: TypeAlias = Mapping[str, Any]
|
|
101
|
+
|
|
102
|
+
@pulumi.input_type
|
|
103
|
+
class BuildContextArgs:
|
|
104
|
+
def __init__(__self__, *,
|
|
105
|
+
location: pulumi.Input[str],
|
|
106
|
+
named: Optional[pulumi.Input[Mapping[str, pulumi.Input['ContextArgs']]]] = None):
|
|
107
|
+
"""
|
|
108
|
+
:param pulumi.Input[str] location: Resources to use for build context.
|
|
109
|
+
|
|
110
|
+
The location can be:
|
|
111
|
+
* A relative or absolute path to a local directory (`.`, `./app`,
|
|
112
|
+
`/app`, etc.).
|
|
113
|
+
* A remote URL of a Git repository, tarball, or plain text file
|
|
114
|
+
(`https://github.com/user/myrepo.git`, `http://server/context.tar.gz`,
|
|
115
|
+
etc.).
|
|
116
|
+
:param pulumi.Input[Mapping[str, pulumi.Input['ContextArgs']]] named: Additional build contexts to use.
|
|
117
|
+
|
|
118
|
+
These contexts are accessed with `FROM name` or `--from=name`
|
|
119
|
+
statements when using Dockerfile 1.4+ syntax.
|
|
120
|
+
|
|
121
|
+
Values can be local paths, HTTP URLs, or `docker-image://` images.
|
|
122
|
+
"""
|
|
123
|
+
pulumi.set(__self__, "location", location)
|
|
124
|
+
if named is not None:
|
|
125
|
+
pulumi.set(__self__, "named", named)
|
|
126
|
+
|
|
127
|
+
@property
|
|
128
|
+
@pulumi.getter
|
|
129
|
+
def location(self) -> pulumi.Input[str]:
|
|
130
|
+
"""
|
|
131
|
+
Resources to use for build context.
|
|
132
|
+
|
|
133
|
+
The location can be:
|
|
134
|
+
* A relative or absolute path to a local directory (`.`, `./app`,
|
|
135
|
+
`/app`, etc.).
|
|
136
|
+
* A remote URL of a Git repository, tarball, or plain text file
|
|
137
|
+
(`https://github.com/user/myrepo.git`, `http://server/context.tar.gz`,
|
|
138
|
+
etc.).
|
|
139
|
+
"""
|
|
140
|
+
return pulumi.get(self, "location")
|
|
141
|
+
|
|
142
|
+
@location.setter
|
|
143
|
+
def location(self, value: pulumi.Input[str]):
|
|
144
|
+
pulumi.set(self, "location", value)
|
|
145
|
+
|
|
146
|
+
@property
|
|
147
|
+
@pulumi.getter
|
|
148
|
+
def named(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input['ContextArgs']]]]:
|
|
149
|
+
"""
|
|
150
|
+
Additional build contexts to use.
|
|
151
|
+
|
|
152
|
+
These contexts are accessed with `FROM name` or `--from=name`
|
|
153
|
+
statements when using Dockerfile 1.4+ syntax.
|
|
154
|
+
|
|
155
|
+
Values can be local paths, HTTP URLs, or `docker-image://` images.
|
|
156
|
+
"""
|
|
157
|
+
return pulumi.get(self, "named")
|
|
158
|
+
|
|
159
|
+
@named.setter
|
|
160
|
+
def named(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input['ContextArgs']]]]):
|
|
161
|
+
pulumi.set(self, "named", value)
|
|
162
|
+
|
|
163
|
+
|
|
164
|
+
if not MYPY:
|
|
165
|
+
class BuilderConfigArgsDict(TypedDict):
|
|
166
|
+
name: NotRequired[pulumi.Input[str]]
|
|
167
|
+
"""
|
|
168
|
+
Name of an existing buildx builder to use.
|
|
169
|
+
|
|
170
|
+
Only `docker-container`, `kubernetes`, or `remote` drivers are
|
|
171
|
+
supported. The legacy `docker` driver is not supported.
|
|
172
|
+
|
|
173
|
+
Equivalent to Docker's `--builder` flag.
|
|
174
|
+
"""
|
|
175
|
+
elif False:
|
|
176
|
+
BuilderConfigArgsDict: TypeAlias = Mapping[str, Any]
|
|
177
|
+
|
|
178
|
+
@pulumi.input_type
|
|
179
|
+
class BuilderConfigArgs:
|
|
180
|
+
def __init__(__self__, *,
|
|
181
|
+
name: Optional[pulumi.Input[str]] = None):
|
|
182
|
+
"""
|
|
183
|
+
:param pulumi.Input[str] name: Name of an existing buildx builder to use.
|
|
184
|
+
|
|
185
|
+
Only `docker-container`, `kubernetes`, or `remote` drivers are
|
|
186
|
+
supported. The legacy `docker` driver is not supported.
|
|
187
|
+
|
|
188
|
+
Equivalent to Docker's `--builder` flag.
|
|
189
|
+
"""
|
|
190
|
+
if name is not None:
|
|
191
|
+
pulumi.set(__self__, "name", name)
|
|
192
|
+
|
|
193
|
+
@property
|
|
194
|
+
@pulumi.getter
|
|
195
|
+
def name(self) -> Optional[pulumi.Input[str]]:
|
|
196
|
+
"""
|
|
197
|
+
Name of an existing buildx builder to use.
|
|
198
|
+
|
|
199
|
+
Only `docker-container`, `kubernetes`, or `remote` drivers are
|
|
200
|
+
supported. The legacy `docker` driver is not supported.
|
|
201
|
+
|
|
202
|
+
Equivalent to Docker's `--builder` flag.
|
|
203
|
+
"""
|
|
204
|
+
return pulumi.get(self, "name")
|
|
205
|
+
|
|
206
|
+
@name.setter
|
|
207
|
+
def name(self, value: Optional[pulumi.Input[str]]):
|
|
208
|
+
pulumi.set(self, "name", value)
|
|
209
|
+
|
|
210
|
+
|
|
211
|
+
if not MYPY:
|
|
212
|
+
class CacheFromAzureBlobArgsDict(TypedDict):
|
|
213
|
+
name: pulumi.Input[str]
|
|
214
|
+
"""
|
|
215
|
+
The name of the cache image.
|
|
216
|
+
"""
|
|
217
|
+
account_url: NotRequired[pulumi.Input[str]]
|
|
218
|
+
"""
|
|
219
|
+
Base URL of the storage account.
|
|
220
|
+
"""
|
|
221
|
+
secret_access_key: NotRequired[pulumi.Input[str]]
|
|
222
|
+
"""
|
|
223
|
+
Blob storage account key.
|
|
224
|
+
"""
|
|
225
|
+
elif False:
|
|
226
|
+
CacheFromAzureBlobArgsDict: TypeAlias = Mapping[str, Any]
|
|
227
|
+
|
|
228
|
+
@pulumi.input_type
|
|
229
|
+
class CacheFromAzureBlobArgs:
|
|
230
|
+
def __init__(__self__, *,
|
|
231
|
+
name: pulumi.Input[str],
|
|
232
|
+
account_url: Optional[pulumi.Input[str]] = None,
|
|
233
|
+
secret_access_key: Optional[pulumi.Input[str]] = None):
|
|
234
|
+
"""
|
|
235
|
+
:param pulumi.Input[str] name: The name of the cache image.
|
|
236
|
+
:param pulumi.Input[str] account_url: Base URL of the storage account.
|
|
237
|
+
:param pulumi.Input[str] secret_access_key: Blob storage account key.
|
|
238
|
+
"""
|
|
239
|
+
pulumi.set(__self__, "name", name)
|
|
240
|
+
if account_url is not None:
|
|
241
|
+
pulumi.set(__self__, "account_url", account_url)
|
|
242
|
+
if secret_access_key is not None:
|
|
243
|
+
pulumi.set(__self__, "secret_access_key", secret_access_key)
|
|
244
|
+
|
|
245
|
+
@property
|
|
246
|
+
@pulumi.getter
|
|
247
|
+
def name(self) -> pulumi.Input[str]:
|
|
248
|
+
"""
|
|
249
|
+
The name of the cache image.
|
|
250
|
+
"""
|
|
251
|
+
return pulumi.get(self, "name")
|
|
252
|
+
|
|
253
|
+
@name.setter
|
|
254
|
+
def name(self, value: pulumi.Input[str]):
|
|
255
|
+
pulumi.set(self, "name", value)
|
|
256
|
+
|
|
257
|
+
@property
|
|
258
|
+
@pulumi.getter(name="accountUrl")
|
|
259
|
+
def account_url(self) -> Optional[pulumi.Input[str]]:
|
|
260
|
+
"""
|
|
261
|
+
Base URL of the storage account.
|
|
262
|
+
"""
|
|
263
|
+
return pulumi.get(self, "account_url")
|
|
264
|
+
|
|
265
|
+
@account_url.setter
|
|
266
|
+
def account_url(self, value: Optional[pulumi.Input[str]]):
|
|
267
|
+
pulumi.set(self, "account_url", value)
|
|
268
|
+
|
|
269
|
+
@property
|
|
270
|
+
@pulumi.getter(name="secretAccessKey")
|
|
271
|
+
def secret_access_key(self) -> Optional[pulumi.Input[str]]:
|
|
272
|
+
"""
|
|
273
|
+
Blob storage account key.
|
|
274
|
+
"""
|
|
275
|
+
return pulumi.get(self, "secret_access_key")
|
|
276
|
+
|
|
277
|
+
@secret_access_key.setter
|
|
278
|
+
def secret_access_key(self, value: Optional[pulumi.Input[str]]):
|
|
279
|
+
pulumi.set(self, "secret_access_key", value)
|
|
280
|
+
|
|
281
|
+
|
|
282
|
+
if not MYPY:
|
|
283
|
+
class CacheFromGitHubActionsArgsDict(TypedDict):
|
|
284
|
+
scope: NotRequired[pulumi.Input[str]]
|
|
285
|
+
"""
|
|
286
|
+
The scope to use for cache keys. Defaults to `buildkit`.
|
|
287
|
+
|
|
288
|
+
This should be set if building and caching multiple images in one
|
|
289
|
+
workflow, otherwise caches will overwrite each other.
|
|
290
|
+
"""
|
|
291
|
+
token: NotRequired[pulumi.Input[str]]
|
|
292
|
+
"""
|
|
293
|
+
The GitHub Actions token to use. This is not a personal access tokens
|
|
294
|
+
and is typically generated automatically as part of each job.
|
|
295
|
+
|
|
296
|
+
Defaults to `$ACTIONS_RUNTIME_TOKEN`, although a separate action like
|
|
297
|
+
`crazy-max/ghaction-github-runtime` is recommended to expose this
|
|
298
|
+
environment variable to your jobs.
|
|
299
|
+
"""
|
|
300
|
+
url: NotRequired[pulumi.Input[str]]
|
|
301
|
+
"""
|
|
302
|
+
The cache server URL to use for artifacts.
|
|
303
|
+
|
|
304
|
+
Defaults to `$ACTIONS_CACHE_URL`, although a separate action like
|
|
305
|
+
`crazy-max/ghaction-github-runtime` is recommended to expose this
|
|
306
|
+
environment variable to your jobs.
|
|
307
|
+
"""
|
|
308
|
+
elif False:
|
|
309
|
+
CacheFromGitHubActionsArgsDict: TypeAlias = Mapping[str, Any]
|
|
310
|
+
|
|
311
|
+
@pulumi.input_type
|
|
312
|
+
class CacheFromGitHubActionsArgs:
|
|
313
|
+
def __init__(__self__, *,
|
|
314
|
+
scope: Optional[pulumi.Input[str]] = None,
|
|
315
|
+
token: Optional[pulumi.Input[str]] = None,
|
|
316
|
+
url: Optional[pulumi.Input[str]] = None):
|
|
317
|
+
"""
|
|
318
|
+
:param pulumi.Input[str] scope: The scope to use for cache keys. Defaults to `buildkit`.
|
|
319
|
+
|
|
320
|
+
This should be set if building and caching multiple images in one
|
|
321
|
+
workflow, otherwise caches will overwrite each other.
|
|
322
|
+
:param pulumi.Input[str] token: The GitHub Actions token to use. This is not a personal access tokens
|
|
323
|
+
and is typically generated automatically as part of each job.
|
|
324
|
+
|
|
325
|
+
Defaults to `$ACTIONS_RUNTIME_TOKEN`, although a separate action like
|
|
326
|
+
`crazy-max/ghaction-github-runtime` is recommended to expose this
|
|
327
|
+
environment variable to your jobs.
|
|
328
|
+
:param pulumi.Input[str] url: The cache server URL to use for artifacts.
|
|
329
|
+
|
|
330
|
+
Defaults to `$ACTIONS_CACHE_URL`, although a separate action like
|
|
331
|
+
`crazy-max/ghaction-github-runtime` is recommended to expose this
|
|
332
|
+
environment variable to your jobs.
|
|
333
|
+
"""
|
|
334
|
+
if scope is None:
|
|
335
|
+
scope = (_utilities.get_env('buildkit') or '')
|
|
336
|
+
if scope is not None:
|
|
337
|
+
pulumi.set(__self__, "scope", scope)
|
|
338
|
+
if token is None:
|
|
339
|
+
token = (_utilities.get_env('ACTIONS_RUNTIME_TOKEN') or '')
|
|
340
|
+
if token is not None:
|
|
341
|
+
pulumi.set(__self__, "token", token)
|
|
342
|
+
if url is None:
|
|
343
|
+
url = (_utilities.get_env('ACTIONS_CACHE_URL') or '')
|
|
344
|
+
if url is not None:
|
|
345
|
+
pulumi.set(__self__, "url", url)
|
|
346
|
+
|
|
347
|
+
@property
|
|
348
|
+
@pulumi.getter
|
|
349
|
+
def scope(self) -> Optional[pulumi.Input[str]]:
|
|
350
|
+
"""
|
|
351
|
+
The scope to use for cache keys. Defaults to `buildkit`.
|
|
352
|
+
|
|
353
|
+
This should be set if building and caching multiple images in one
|
|
354
|
+
workflow, otherwise caches will overwrite each other.
|
|
355
|
+
"""
|
|
356
|
+
return pulumi.get(self, "scope")
|
|
357
|
+
|
|
358
|
+
@scope.setter
|
|
359
|
+
def scope(self, value: Optional[pulumi.Input[str]]):
|
|
360
|
+
pulumi.set(self, "scope", value)
|
|
361
|
+
|
|
362
|
+
@property
|
|
363
|
+
@pulumi.getter
|
|
364
|
+
def token(self) -> Optional[pulumi.Input[str]]:
|
|
365
|
+
"""
|
|
366
|
+
The GitHub Actions token to use. This is not a personal access tokens
|
|
367
|
+
and is typically generated automatically as part of each job.
|
|
368
|
+
|
|
369
|
+
Defaults to `$ACTIONS_RUNTIME_TOKEN`, although a separate action like
|
|
370
|
+
`crazy-max/ghaction-github-runtime` is recommended to expose this
|
|
371
|
+
environment variable to your jobs.
|
|
372
|
+
"""
|
|
373
|
+
return pulumi.get(self, "token")
|
|
374
|
+
|
|
375
|
+
@token.setter
|
|
376
|
+
def token(self, value: Optional[pulumi.Input[str]]):
|
|
377
|
+
pulumi.set(self, "token", value)
|
|
378
|
+
|
|
379
|
+
@property
|
|
380
|
+
@pulumi.getter
|
|
381
|
+
def url(self) -> Optional[pulumi.Input[str]]:
|
|
382
|
+
"""
|
|
383
|
+
The cache server URL to use for artifacts.
|
|
384
|
+
|
|
385
|
+
Defaults to `$ACTIONS_CACHE_URL`, although a separate action like
|
|
386
|
+
`crazy-max/ghaction-github-runtime` is recommended to expose this
|
|
387
|
+
environment variable to your jobs.
|
|
388
|
+
"""
|
|
389
|
+
return pulumi.get(self, "url")
|
|
390
|
+
|
|
391
|
+
@url.setter
|
|
392
|
+
def url(self, value: Optional[pulumi.Input[str]]):
|
|
393
|
+
pulumi.set(self, "url", value)
|
|
394
|
+
|
|
395
|
+
|
|
396
|
+
if not MYPY:
|
|
397
|
+
class CacheFromLocalArgsDict(TypedDict):
|
|
398
|
+
src: pulumi.Input[str]
|
|
399
|
+
"""
|
|
400
|
+
Path of the local directory where cache gets imported from.
|
|
401
|
+
"""
|
|
402
|
+
digest: NotRequired[pulumi.Input[str]]
|
|
403
|
+
"""
|
|
404
|
+
Digest of manifest to import.
|
|
405
|
+
"""
|
|
406
|
+
elif False:
|
|
407
|
+
CacheFromLocalArgsDict: TypeAlias = Mapping[str, Any]
|
|
408
|
+
|
|
409
|
+
@pulumi.input_type
|
|
410
|
+
class CacheFromLocalArgs:
|
|
411
|
+
def __init__(__self__, *,
|
|
412
|
+
src: pulumi.Input[str],
|
|
413
|
+
digest: Optional[pulumi.Input[str]] = None):
|
|
414
|
+
"""
|
|
415
|
+
:param pulumi.Input[str] src: Path of the local directory where cache gets imported from.
|
|
416
|
+
:param pulumi.Input[str] digest: Digest of manifest to import.
|
|
417
|
+
"""
|
|
418
|
+
pulumi.set(__self__, "src", src)
|
|
419
|
+
if digest is not None:
|
|
420
|
+
pulumi.set(__self__, "digest", digest)
|
|
421
|
+
|
|
422
|
+
@property
|
|
423
|
+
@pulumi.getter
|
|
424
|
+
def src(self) -> pulumi.Input[str]:
|
|
425
|
+
"""
|
|
426
|
+
Path of the local directory where cache gets imported from.
|
|
427
|
+
"""
|
|
428
|
+
return pulumi.get(self, "src")
|
|
429
|
+
|
|
430
|
+
@src.setter
|
|
431
|
+
def src(self, value: pulumi.Input[str]):
|
|
432
|
+
pulumi.set(self, "src", value)
|
|
433
|
+
|
|
434
|
+
@property
|
|
435
|
+
@pulumi.getter
|
|
436
|
+
def digest(self) -> Optional[pulumi.Input[str]]:
|
|
437
|
+
"""
|
|
438
|
+
Digest of manifest to import.
|
|
439
|
+
"""
|
|
440
|
+
return pulumi.get(self, "digest")
|
|
441
|
+
|
|
442
|
+
@digest.setter
|
|
443
|
+
def digest(self, value: Optional[pulumi.Input[str]]):
|
|
444
|
+
pulumi.set(self, "digest", value)
|
|
445
|
+
|
|
446
|
+
|
|
447
|
+
if not MYPY:
|
|
448
|
+
class CacheFromRegistryArgsDict(TypedDict):
|
|
449
|
+
ref: pulumi.Input[str]
|
|
450
|
+
"""
|
|
451
|
+
Fully qualified name of the cache image to import.
|
|
452
|
+
"""
|
|
453
|
+
elif False:
|
|
454
|
+
CacheFromRegistryArgsDict: TypeAlias = Mapping[str, Any]
|
|
455
|
+
|
|
456
|
+
@pulumi.input_type
|
|
457
|
+
class CacheFromRegistryArgs:
|
|
458
|
+
def __init__(__self__, *,
|
|
459
|
+
ref: pulumi.Input[str]):
|
|
460
|
+
"""
|
|
461
|
+
:param pulumi.Input[str] ref: Fully qualified name of the cache image to import.
|
|
462
|
+
"""
|
|
463
|
+
pulumi.set(__self__, "ref", ref)
|
|
464
|
+
|
|
465
|
+
@property
|
|
466
|
+
@pulumi.getter
|
|
467
|
+
def ref(self) -> pulumi.Input[str]:
|
|
468
|
+
"""
|
|
469
|
+
Fully qualified name of the cache image to import.
|
|
470
|
+
"""
|
|
471
|
+
return pulumi.get(self, "ref")
|
|
472
|
+
|
|
473
|
+
@ref.setter
|
|
474
|
+
def ref(self, value: pulumi.Input[str]):
|
|
475
|
+
pulumi.set(self, "ref", value)
|
|
476
|
+
|
|
477
|
+
|
|
478
|
+
if not MYPY:
|
|
479
|
+
class CacheFromS3ArgsDict(TypedDict):
|
|
480
|
+
bucket: pulumi.Input[str]
|
|
481
|
+
"""
|
|
482
|
+
Name of the S3 bucket.
|
|
483
|
+
"""
|
|
484
|
+
region: pulumi.Input[str]
|
|
485
|
+
"""
|
|
486
|
+
The geographic location of the bucket. Defaults to `$AWS_REGION`.
|
|
487
|
+
"""
|
|
488
|
+
access_key_id: NotRequired[pulumi.Input[str]]
|
|
489
|
+
"""
|
|
490
|
+
Defaults to `$AWS_ACCESS_KEY_ID`.
|
|
491
|
+
"""
|
|
492
|
+
blobs_prefix: NotRequired[pulumi.Input[str]]
|
|
493
|
+
"""
|
|
494
|
+
Prefix to prepend to blob filenames.
|
|
495
|
+
"""
|
|
496
|
+
endpoint_url: NotRequired[pulumi.Input[str]]
|
|
497
|
+
"""
|
|
498
|
+
Endpoint of the S3 bucket.
|
|
499
|
+
"""
|
|
500
|
+
manifests_prefix: NotRequired[pulumi.Input[str]]
|
|
501
|
+
"""
|
|
502
|
+
Prefix to prepend on manifest filenames.
|
|
503
|
+
"""
|
|
504
|
+
name: NotRequired[pulumi.Input[str]]
|
|
505
|
+
"""
|
|
506
|
+
Name of the cache image.
|
|
507
|
+
"""
|
|
508
|
+
secret_access_key: NotRequired[pulumi.Input[str]]
|
|
509
|
+
"""
|
|
510
|
+
Defaults to `$AWS_SECRET_ACCESS_KEY`.
|
|
511
|
+
"""
|
|
512
|
+
session_token: NotRequired[pulumi.Input[str]]
|
|
513
|
+
"""
|
|
514
|
+
Defaults to `$AWS_SESSION_TOKEN`.
|
|
515
|
+
"""
|
|
516
|
+
use_path_style: NotRequired[pulumi.Input[bool]]
|
|
517
|
+
"""
|
|
518
|
+
Uses `bucket` in the URL instead of hostname when `true`.
|
|
519
|
+
"""
|
|
520
|
+
elif False:
|
|
521
|
+
CacheFromS3ArgsDict: TypeAlias = Mapping[str, Any]
|
|
522
|
+
|
|
523
|
+
@pulumi.input_type
|
|
524
|
+
class CacheFromS3Args:
|
|
525
|
+
def __init__(__self__, *,
|
|
526
|
+
bucket: pulumi.Input[str],
|
|
527
|
+
region: Optional[pulumi.Input[str]] = None,
|
|
528
|
+
access_key_id: Optional[pulumi.Input[str]] = None,
|
|
529
|
+
blobs_prefix: Optional[pulumi.Input[str]] = None,
|
|
530
|
+
endpoint_url: Optional[pulumi.Input[str]] = None,
|
|
531
|
+
manifests_prefix: Optional[pulumi.Input[str]] = None,
|
|
532
|
+
name: Optional[pulumi.Input[str]] = None,
|
|
533
|
+
secret_access_key: Optional[pulumi.Input[str]] = None,
|
|
534
|
+
session_token: Optional[pulumi.Input[str]] = None,
|
|
535
|
+
use_path_style: Optional[pulumi.Input[bool]] = None):
|
|
536
|
+
"""
|
|
537
|
+
:param pulumi.Input[str] bucket: Name of the S3 bucket.
|
|
538
|
+
:param pulumi.Input[str] region: The geographic location of the bucket. Defaults to `$AWS_REGION`.
|
|
539
|
+
:param pulumi.Input[str] access_key_id: Defaults to `$AWS_ACCESS_KEY_ID`.
|
|
540
|
+
:param pulumi.Input[str] blobs_prefix: Prefix to prepend to blob filenames.
|
|
541
|
+
:param pulumi.Input[str] endpoint_url: Endpoint of the S3 bucket.
|
|
542
|
+
:param pulumi.Input[str] manifests_prefix: Prefix to prepend on manifest filenames.
|
|
543
|
+
:param pulumi.Input[str] name: Name of the cache image.
|
|
544
|
+
:param pulumi.Input[str] secret_access_key: Defaults to `$AWS_SECRET_ACCESS_KEY`.
|
|
545
|
+
:param pulumi.Input[str] session_token: Defaults to `$AWS_SESSION_TOKEN`.
|
|
546
|
+
:param pulumi.Input[bool] use_path_style: Uses `bucket` in the URL instead of hostname when `true`.
|
|
547
|
+
"""
|
|
548
|
+
pulumi.set(__self__, "bucket", bucket)
|
|
549
|
+
if region is None:
|
|
550
|
+
region = (_utilities.get_env('AWS_REGION') or '')
|
|
551
|
+
pulumi.set(__self__, "region", region)
|
|
552
|
+
if access_key_id is None:
|
|
553
|
+
access_key_id = (_utilities.get_env('AWS_ACCESS_KEY_ID') or '')
|
|
554
|
+
if access_key_id is not None:
|
|
555
|
+
pulumi.set(__self__, "access_key_id", access_key_id)
|
|
556
|
+
if blobs_prefix is not None:
|
|
557
|
+
pulumi.set(__self__, "blobs_prefix", blobs_prefix)
|
|
558
|
+
if endpoint_url is not None:
|
|
559
|
+
pulumi.set(__self__, "endpoint_url", endpoint_url)
|
|
560
|
+
if manifests_prefix is not None:
|
|
561
|
+
pulumi.set(__self__, "manifests_prefix", manifests_prefix)
|
|
562
|
+
if name is not None:
|
|
563
|
+
pulumi.set(__self__, "name", name)
|
|
564
|
+
if secret_access_key is None:
|
|
565
|
+
secret_access_key = (_utilities.get_env('AWS_SECRET_ACCESS_KEY') or '')
|
|
566
|
+
if secret_access_key is not None:
|
|
567
|
+
pulumi.set(__self__, "secret_access_key", secret_access_key)
|
|
568
|
+
if session_token is None:
|
|
569
|
+
session_token = (_utilities.get_env('AWS_SESSION_TOKEN') or '')
|
|
570
|
+
if session_token is not None:
|
|
571
|
+
pulumi.set(__self__, "session_token", session_token)
|
|
572
|
+
if use_path_style is not None:
|
|
573
|
+
pulumi.set(__self__, "use_path_style", use_path_style)
|
|
574
|
+
|
|
575
|
+
@property
|
|
576
|
+
@pulumi.getter
|
|
577
|
+
def bucket(self) -> pulumi.Input[str]:
|
|
578
|
+
"""
|
|
579
|
+
Name of the S3 bucket.
|
|
580
|
+
"""
|
|
581
|
+
return pulumi.get(self, "bucket")
|
|
582
|
+
|
|
583
|
+
@bucket.setter
|
|
584
|
+
def bucket(self, value: pulumi.Input[str]):
|
|
585
|
+
pulumi.set(self, "bucket", value)
|
|
586
|
+
|
|
587
|
+
@property
|
|
588
|
+
@pulumi.getter
|
|
589
|
+
def region(self) -> pulumi.Input[str]:
|
|
590
|
+
"""
|
|
591
|
+
The geographic location of the bucket. Defaults to `$AWS_REGION`.
|
|
592
|
+
"""
|
|
593
|
+
return pulumi.get(self, "region")
|
|
594
|
+
|
|
595
|
+
@region.setter
|
|
596
|
+
def region(self, value: pulumi.Input[str]):
|
|
597
|
+
pulumi.set(self, "region", value)
|
|
598
|
+
|
|
599
|
+
@property
|
|
600
|
+
@pulumi.getter(name="accessKeyId")
|
|
601
|
+
def access_key_id(self) -> Optional[pulumi.Input[str]]:
|
|
602
|
+
"""
|
|
603
|
+
Defaults to `$AWS_ACCESS_KEY_ID`.
|
|
604
|
+
"""
|
|
605
|
+
return pulumi.get(self, "access_key_id")
|
|
606
|
+
|
|
607
|
+
@access_key_id.setter
|
|
608
|
+
def access_key_id(self, value: Optional[pulumi.Input[str]]):
|
|
609
|
+
pulumi.set(self, "access_key_id", value)
|
|
610
|
+
|
|
611
|
+
@property
|
|
612
|
+
@pulumi.getter(name="blobsPrefix")
|
|
613
|
+
def blobs_prefix(self) -> Optional[pulumi.Input[str]]:
|
|
614
|
+
"""
|
|
615
|
+
Prefix to prepend to blob filenames.
|
|
616
|
+
"""
|
|
617
|
+
return pulumi.get(self, "blobs_prefix")
|
|
618
|
+
|
|
619
|
+
@blobs_prefix.setter
|
|
620
|
+
def blobs_prefix(self, value: Optional[pulumi.Input[str]]):
|
|
621
|
+
pulumi.set(self, "blobs_prefix", value)
|
|
622
|
+
|
|
623
|
+
@property
|
|
624
|
+
@pulumi.getter(name="endpointUrl")
|
|
625
|
+
def endpoint_url(self) -> Optional[pulumi.Input[str]]:
|
|
626
|
+
"""
|
|
627
|
+
Endpoint of the S3 bucket.
|
|
628
|
+
"""
|
|
629
|
+
return pulumi.get(self, "endpoint_url")
|
|
630
|
+
|
|
631
|
+
@endpoint_url.setter
|
|
632
|
+
def endpoint_url(self, value: Optional[pulumi.Input[str]]):
|
|
633
|
+
pulumi.set(self, "endpoint_url", value)
|
|
634
|
+
|
|
635
|
+
@property
|
|
636
|
+
@pulumi.getter(name="manifestsPrefix")
|
|
637
|
+
def manifests_prefix(self) -> Optional[pulumi.Input[str]]:
|
|
638
|
+
"""
|
|
639
|
+
Prefix to prepend on manifest filenames.
|
|
640
|
+
"""
|
|
641
|
+
return pulumi.get(self, "manifests_prefix")
|
|
642
|
+
|
|
643
|
+
@manifests_prefix.setter
|
|
644
|
+
def manifests_prefix(self, value: Optional[pulumi.Input[str]]):
|
|
645
|
+
pulumi.set(self, "manifests_prefix", value)
|
|
646
|
+
|
|
647
|
+
@property
|
|
648
|
+
@pulumi.getter
|
|
649
|
+
def name(self) -> Optional[pulumi.Input[str]]:
|
|
650
|
+
"""
|
|
651
|
+
Name of the cache image.
|
|
652
|
+
"""
|
|
653
|
+
return pulumi.get(self, "name")
|
|
654
|
+
|
|
655
|
+
@name.setter
|
|
656
|
+
def name(self, value: Optional[pulumi.Input[str]]):
|
|
657
|
+
pulumi.set(self, "name", value)
|
|
658
|
+
|
|
659
|
+
@property
|
|
660
|
+
@pulumi.getter(name="secretAccessKey")
|
|
661
|
+
def secret_access_key(self) -> Optional[pulumi.Input[str]]:
|
|
662
|
+
"""
|
|
663
|
+
Defaults to `$AWS_SECRET_ACCESS_KEY`.
|
|
664
|
+
"""
|
|
665
|
+
return pulumi.get(self, "secret_access_key")
|
|
666
|
+
|
|
667
|
+
@secret_access_key.setter
|
|
668
|
+
def secret_access_key(self, value: Optional[pulumi.Input[str]]):
|
|
669
|
+
pulumi.set(self, "secret_access_key", value)
|
|
670
|
+
|
|
671
|
+
@property
|
|
672
|
+
@pulumi.getter(name="sessionToken")
|
|
673
|
+
def session_token(self) -> Optional[pulumi.Input[str]]:
|
|
674
|
+
"""
|
|
675
|
+
Defaults to `$AWS_SESSION_TOKEN`.
|
|
676
|
+
"""
|
|
677
|
+
return pulumi.get(self, "session_token")
|
|
678
|
+
|
|
679
|
+
@session_token.setter
|
|
680
|
+
def session_token(self, value: Optional[pulumi.Input[str]]):
|
|
681
|
+
pulumi.set(self, "session_token", value)
|
|
682
|
+
|
|
683
|
+
@property
|
|
684
|
+
@pulumi.getter(name="usePathStyle")
|
|
685
|
+
def use_path_style(self) -> Optional[pulumi.Input[bool]]:
|
|
686
|
+
"""
|
|
687
|
+
Uses `bucket` in the URL instead of hostname when `true`.
|
|
688
|
+
"""
|
|
689
|
+
return pulumi.get(self, "use_path_style")
|
|
690
|
+
|
|
691
|
+
@use_path_style.setter
|
|
692
|
+
def use_path_style(self, value: Optional[pulumi.Input[bool]]):
|
|
693
|
+
pulumi.set(self, "use_path_style", value)
|
|
694
|
+
|
|
695
|
+
|
|
696
|
+
if not MYPY:
|
|
697
|
+
class CacheFromArgsDict(TypedDict):
|
|
698
|
+
azblob: NotRequired[pulumi.Input['CacheFromAzureBlobArgsDict']]
|
|
699
|
+
"""
|
|
700
|
+
Upload build caches to Azure's blob storage service.
|
|
701
|
+
"""
|
|
702
|
+
disabled: NotRequired[pulumi.Input[bool]]
|
|
703
|
+
"""
|
|
704
|
+
When `true` this entry will be excluded. Defaults to `false`.
|
|
705
|
+
"""
|
|
706
|
+
gha: NotRequired[pulumi.Input['CacheFromGitHubActionsArgsDict']]
|
|
707
|
+
"""
|
|
708
|
+
Recommended for use with GitHub Actions workflows.
|
|
709
|
+
|
|
710
|
+
An action like `crazy-max/ghaction-github-runtime` is recommended to
|
|
711
|
+
expose appropriate credentials to your GitHub workflow.
|
|
712
|
+
"""
|
|
713
|
+
local: NotRequired[pulumi.Input['CacheFromLocalArgsDict']]
|
|
714
|
+
"""
|
|
715
|
+
A simple backend which caches images on your local filesystem.
|
|
716
|
+
"""
|
|
717
|
+
raw: NotRequired[pulumi.Input[str]]
|
|
718
|
+
"""
|
|
719
|
+
A raw string as you would provide it to the Docker CLI (e.g.,
|
|
720
|
+
`type=inline`).
|
|
721
|
+
"""
|
|
722
|
+
registry: NotRequired[pulumi.Input['CacheFromRegistryArgsDict']]
|
|
723
|
+
"""
|
|
724
|
+
Upload build caches to remote registries.
|
|
725
|
+
"""
|
|
726
|
+
s3: NotRequired[pulumi.Input['CacheFromS3ArgsDict']]
|
|
727
|
+
"""
|
|
728
|
+
Upload build caches to AWS S3 or an S3-compatible services such as
|
|
729
|
+
MinIO.
|
|
730
|
+
"""
|
|
731
|
+
elif False:
|
|
732
|
+
CacheFromArgsDict: TypeAlias = Mapping[str, Any]
|
|
733
|
+
|
|
734
|
+
@pulumi.input_type
|
|
735
|
+
class CacheFromArgs:
|
|
736
|
+
def __init__(__self__, *,
|
|
737
|
+
azblob: Optional[pulumi.Input['CacheFromAzureBlobArgs']] = None,
|
|
738
|
+
disabled: Optional[pulumi.Input[bool]] = None,
|
|
739
|
+
gha: Optional[pulumi.Input['CacheFromGitHubActionsArgs']] = None,
|
|
740
|
+
local: Optional[pulumi.Input['CacheFromLocalArgs']] = None,
|
|
741
|
+
raw: Optional[pulumi.Input[str]] = None,
|
|
742
|
+
registry: Optional[pulumi.Input['CacheFromRegistryArgs']] = None,
|
|
743
|
+
s3: Optional[pulumi.Input['CacheFromS3Args']] = None):
|
|
744
|
+
"""
|
|
745
|
+
:param pulumi.Input['CacheFromAzureBlobArgs'] azblob: Upload build caches to Azure's blob storage service.
|
|
746
|
+
:param pulumi.Input[bool] disabled: When `true` this entry will be excluded. Defaults to `false`.
|
|
747
|
+
:param pulumi.Input['CacheFromGitHubActionsArgs'] gha: Recommended for use with GitHub Actions workflows.
|
|
748
|
+
|
|
749
|
+
An action like `crazy-max/ghaction-github-runtime` is recommended to
|
|
750
|
+
expose appropriate credentials to your GitHub workflow.
|
|
751
|
+
:param pulumi.Input['CacheFromLocalArgs'] local: A simple backend which caches images on your local filesystem.
|
|
752
|
+
:param pulumi.Input[str] raw: A raw string as you would provide it to the Docker CLI (e.g.,
|
|
753
|
+
`type=inline`).
|
|
754
|
+
:param pulumi.Input['CacheFromRegistryArgs'] registry: Upload build caches to remote registries.
|
|
755
|
+
:param pulumi.Input['CacheFromS3Args'] s3: Upload build caches to AWS S3 or an S3-compatible services such as
|
|
756
|
+
MinIO.
|
|
757
|
+
"""
|
|
758
|
+
if azblob is not None:
|
|
759
|
+
pulumi.set(__self__, "azblob", azblob)
|
|
760
|
+
if disabled is not None:
|
|
761
|
+
pulumi.set(__self__, "disabled", disabled)
|
|
762
|
+
if gha is not None:
|
|
763
|
+
pulumi.set(__self__, "gha", gha)
|
|
764
|
+
if local is not None:
|
|
765
|
+
pulumi.set(__self__, "local", local)
|
|
766
|
+
if raw is not None:
|
|
767
|
+
pulumi.set(__self__, "raw", raw)
|
|
768
|
+
if registry is not None:
|
|
769
|
+
pulumi.set(__self__, "registry", registry)
|
|
770
|
+
if s3 is not None:
|
|
771
|
+
pulumi.set(__self__, "s3", s3)
|
|
772
|
+
|
|
773
|
+
@property
|
|
774
|
+
@pulumi.getter
|
|
775
|
+
def azblob(self) -> Optional[pulumi.Input['CacheFromAzureBlobArgs']]:
|
|
776
|
+
"""
|
|
777
|
+
Upload build caches to Azure's blob storage service.
|
|
778
|
+
"""
|
|
779
|
+
return pulumi.get(self, "azblob")
|
|
780
|
+
|
|
781
|
+
@azblob.setter
|
|
782
|
+
def azblob(self, value: Optional[pulumi.Input['CacheFromAzureBlobArgs']]):
|
|
783
|
+
pulumi.set(self, "azblob", value)
|
|
784
|
+
|
|
785
|
+
@property
|
|
786
|
+
@pulumi.getter
|
|
787
|
+
def disabled(self) -> Optional[pulumi.Input[bool]]:
|
|
788
|
+
"""
|
|
789
|
+
When `true` this entry will be excluded. Defaults to `false`.
|
|
790
|
+
"""
|
|
791
|
+
return pulumi.get(self, "disabled")
|
|
792
|
+
|
|
793
|
+
@disabled.setter
|
|
794
|
+
def disabled(self, value: Optional[pulumi.Input[bool]]):
|
|
795
|
+
pulumi.set(self, "disabled", value)
|
|
796
|
+
|
|
797
|
+
@property
|
|
798
|
+
@pulumi.getter
|
|
799
|
+
def gha(self) -> Optional[pulumi.Input['CacheFromGitHubActionsArgs']]:
|
|
800
|
+
"""
|
|
801
|
+
Recommended for use with GitHub Actions workflows.
|
|
802
|
+
|
|
803
|
+
An action like `crazy-max/ghaction-github-runtime` is recommended to
|
|
804
|
+
expose appropriate credentials to your GitHub workflow.
|
|
805
|
+
"""
|
|
806
|
+
return pulumi.get(self, "gha")
|
|
807
|
+
|
|
808
|
+
@gha.setter
|
|
809
|
+
def gha(self, value: Optional[pulumi.Input['CacheFromGitHubActionsArgs']]):
|
|
810
|
+
pulumi.set(self, "gha", value)
|
|
811
|
+
|
|
812
|
+
@property
|
|
813
|
+
@pulumi.getter
|
|
814
|
+
def local(self) -> Optional[pulumi.Input['CacheFromLocalArgs']]:
|
|
815
|
+
"""
|
|
816
|
+
A simple backend which caches images on your local filesystem.
|
|
817
|
+
"""
|
|
818
|
+
return pulumi.get(self, "local")
|
|
819
|
+
|
|
820
|
+
@local.setter
|
|
821
|
+
def local(self, value: Optional[pulumi.Input['CacheFromLocalArgs']]):
|
|
822
|
+
pulumi.set(self, "local", value)
|
|
823
|
+
|
|
824
|
+
@property
|
|
825
|
+
@pulumi.getter
|
|
826
|
+
def raw(self) -> Optional[pulumi.Input[str]]:
|
|
827
|
+
"""
|
|
828
|
+
A raw string as you would provide it to the Docker CLI (e.g.,
|
|
829
|
+
`type=inline`).
|
|
830
|
+
"""
|
|
831
|
+
return pulumi.get(self, "raw")
|
|
832
|
+
|
|
833
|
+
@raw.setter
|
|
834
|
+
def raw(self, value: Optional[pulumi.Input[str]]):
|
|
835
|
+
pulumi.set(self, "raw", value)
|
|
836
|
+
|
|
837
|
+
@property
|
|
838
|
+
@pulumi.getter
|
|
839
|
+
def registry(self) -> Optional[pulumi.Input['CacheFromRegistryArgs']]:
|
|
840
|
+
"""
|
|
841
|
+
Upload build caches to remote registries.
|
|
842
|
+
"""
|
|
843
|
+
return pulumi.get(self, "registry")
|
|
844
|
+
|
|
845
|
+
@registry.setter
|
|
846
|
+
def registry(self, value: Optional[pulumi.Input['CacheFromRegistryArgs']]):
|
|
847
|
+
pulumi.set(self, "registry", value)
|
|
848
|
+
|
|
849
|
+
@property
|
|
850
|
+
@pulumi.getter
|
|
851
|
+
def s3(self) -> Optional[pulumi.Input['CacheFromS3Args']]:
|
|
852
|
+
"""
|
|
853
|
+
Upload build caches to AWS S3 or an S3-compatible services such as
|
|
854
|
+
MinIO.
|
|
855
|
+
"""
|
|
856
|
+
return pulumi.get(self, "s3")
|
|
857
|
+
|
|
858
|
+
@s3.setter
|
|
859
|
+
def s3(self, value: Optional[pulumi.Input['CacheFromS3Args']]):
|
|
860
|
+
pulumi.set(self, "s3", value)
|
|
861
|
+
|
|
862
|
+
|
|
863
|
+
if not MYPY:
|
|
864
|
+
class CacheToAzureBlobArgsDict(TypedDict):
|
|
865
|
+
name: pulumi.Input[str]
|
|
866
|
+
"""
|
|
867
|
+
The name of the cache image.
|
|
868
|
+
"""
|
|
869
|
+
account_url: NotRequired[pulumi.Input[str]]
|
|
870
|
+
"""
|
|
871
|
+
Base URL of the storage account.
|
|
872
|
+
"""
|
|
873
|
+
ignore_error: NotRequired[pulumi.Input[bool]]
|
|
874
|
+
"""
|
|
875
|
+
Ignore errors caused by failed cache exports.
|
|
876
|
+
"""
|
|
877
|
+
mode: NotRequired[pulumi.Input['CacheMode']]
|
|
878
|
+
"""
|
|
879
|
+
The cache mode to use. Defaults to `min`.
|
|
880
|
+
"""
|
|
881
|
+
secret_access_key: NotRequired[pulumi.Input[str]]
|
|
882
|
+
"""
|
|
883
|
+
Blob storage account key.
|
|
884
|
+
"""
|
|
885
|
+
elif False:
|
|
886
|
+
CacheToAzureBlobArgsDict: TypeAlias = Mapping[str, Any]
|
|
887
|
+
|
|
888
|
+
@pulumi.input_type
|
|
889
|
+
class CacheToAzureBlobArgs:
|
|
890
|
+
def __init__(__self__, *,
|
|
891
|
+
name: pulumi.Input[str],
|
|
892
|
+
account_url: Optional[pulumi.Input[str]] = None,
|
|
893
|
+
ignore_error: Optional[pulumi.Input[bool]] = None,
|
|
894
|
+
mode: Optional[pulumi.Input['CacheMode']] = None,
|
|
895
|
+
secret_access_key: Optional[pulumi.Input[str]] = None):
|
|
896
|
+
"""
|
|
897
|
+
:param pulumi.Input[str] name: The name of the cache image.
|
|
898
|
+
:param pulumi.Input[str] account_url: Base URL of the storage account.
|
|
899
|
+
:param pulumi.Input[bool] ignore_error: Ignore errors caused by failed cache exports.
|
|
900
|
+
:param pulumi.Input['CacheMode'] mode: The cache mode to use. Defaults to `min`.
|
|
901
|
+
:param pulumi.Input[str] secret_access_key: Blob storage account key.
|
|
902
|
+
"""
|
|
903
|
+
pulumi.set(__self__, "name", name)
|
|
904
|
+
if account_url is not None:
|
|
905
|
+
pulumi.set(__self__, "account_url", account_url)
|
|
906
|
+
if ignore_error is None:
|
|
907
|
+
ignore_error = False
|
|
908
|
+
if ignore_error is not None:
|
|
909
|
+
pulumi.set(__self__, "ignore_error", ignore_error)
|
|
910
|
+
if mode is None:
|
|
911
|
+
mode = 'min'
|
|
912
|
+
if mode is not None:
|
|
913
|
+
pulumi.set(__self__, "mode", mode)
|
|
914
|
+
if secret_access_key is not None:
|
|
915
|
+
pulumi.set(__self__, "secret_access_key", secret_access_key)
|
|
916
|
+
|
|
917
|
+
@property
|
|
918
|
+
@pulumi.getter
|
|
919
|
+
def name(self) -> pulumi.Input[str]:
|
|
920
|
+
"""
|
|
921
|
+
The name of the cache image.
|
|
922
|
+
"""
|
|
923
|
+
return pulumi.get(self, "name")
|
|
924
|
+
|
|
925
|
+
@name.setter
|
|
926
|
+
def name(self, value: pulumi.Input[str]):
|
|
927
|
+
pulumi.set(self, "name", value)
|
|
928
|
+
|
|
929
|
+
@property
|
|
930
|
+
@pulumi.getter(name="accountUrl")
|
|
931
|
+
def account_url(self) -> Optional[pulumi.Input[str]]:
|
|
932
|
+
"""
|
|
933
|
+
Base URL of the storage account.
|
|
934
|
+
"""
|
|
935
|
+
return pulumi.get(self, "account_url")
|
|
936
|
+
|
|
937
|
+
@account_url.setter
|
|
938
|
+
def account_url(self, value: Optional[pulumi.Input[str]]):
|
|
939
|
+
pulumi.set(self, "account_url", value)
|
|
940
|
+
|
|
941
|
+
@property
|
|
942
|
+
@pulumi.getter(name="ignoreError")
|
|
943
|
+
def ignore_error(self) -> Optional[pulumi.Input[bool]]:
|
|
944
|
+
"""
|
|
945
|
+
Ignore errors caused by failed cache exports.
|
|
946
|
+
"""
|
|
947
|
+
return pulumi.get(self, "ignore_error")
|
|
948
|
+
|
|
949
|
+
@ignore_error.setter
|
|
950
|
+
def ignore_error(self, value: Optional[pulumi.Input[bool]]):
|
|
951
|
+
pulumi.set(self, "ignore_error", value)
|
|
952
|
+
|
|
953
|
+
@property
|
|
954
|
+
@pulumi.getter
|
|
955
|
+
def mode(self) -> Optional[pulumi.Input['CacheMode']]:
|
|
956
|
+
"""
|
|
957
|
+
The cache mode to use. Defaults to `min`.
|
|
958
|
+
"""
|
|
959
|
+
return pulumi.get(self, "mode")
|
|
960
|
+
|
|
961
|
+
@mode.setter
|
|
962
|
+
def mode(self, value: Optional[pulumi.Input['CacheMode']]):
|
|
963
|
+
pulumi.set(self, "mode", value)
|
|
964
|
+
|
|
965
|
+
@property
|
|
966
|
+
@pulumi.getter(name="secretAccessKey")
|
|
967
|
+
def secret_access_key(self) -> Optional[pulumi.Input[str]]:
|
|
968
|
+
"""
|
|
969
|
+
Blob storage account key.
|
|
970
|
+
"""
|
|
971
|
+
return pulumi.get(self, "secret_access_key")
|
|
972
|
+
|
|
973
|
+
@secret_access_key.setter
|
|
974
|
+
def secret_access_key(self, value: Optional[pulumi.Input[str]]):
|
|
975
|
+
pulumi.set(self, "secret_access_key", value)
|
|
976
|
+
|
|
977
|
+
|
|
978
|
+
if not MYPY:
|
|
979
|
+
class CacheToGitHubActionsArgsDict(TypedDict):
|
|
980
|
+
ignore_error: NotRequired[pulumi.Input[bool]]
|
|
981
|
+
"""
|
|
982
|
+
Ignore errors caused by failed cache exports.
|
|
983
|
+
"""
|
|
984
|
+
mode: NotRequired[pulumi.Input['CacheMode']]
|
|
985
|
+
"""
|
|
986
|
+
The cache mode to use. Defaults to `min`.
|
|
987
|
+
"""
|
|
988
|
+
scope: NotRequired[pulumi.Input[str]]
|
|
989
|
+
"""
|
|
990
|
+
The scope to use for cache keys. Defaults to `buildkit`.
|
|
991
|
+
|
|
992
|
+
This should be set if building and caching multiple images in one
|
|
993
|
+
workflow, otherwise caches will overwrite each other.
|
|
994
|
+
"""
|
|
995
|
+
token: NotRequired[pulumi.Input[str]]
|
|
996
|
+
"""
|
|
997
|
+
The GitHub Actions token to use. This is not a personal access tokens
|
|
998
|
+
and is typically generated automatically as part of each job.
|
|
999
|
+
|
|
1000
|
+
Defaults to `$ACTIONS_RUNTIME_TOKEN`, although a separate action like
|
|
1001
|
+
`crazy-max/ghaction-github-runtime` is recommended to expose this
|
|
1002
|
+
environment variable to your jobs.
|
|
1003
|
+
"""
|
|
1004
|
+
url: NotRequired[pulumi.Input[str]]
|
|
1005
|
+
"""
|
|
1006
|
+
The cache server URL to use for artifacts.
|
|
1007
|
+
|
|
1008
|
+
Defaults to `$ACTIONS_CACHE_URL`, although a separate action like
|
|
1009
|
+
`crazy-max/ghaction-github-runtime` is recommended to expose this
|
|
1010
|
+
environment variable to your jobs.
|
|
1011
|
+
"""
|
|
1012
|
+
elif False:
|
|
1013
|
+
CacheToGitHubActionsArgsDict: TypeAlias = Mapping[str, Any]
|
|
1014
|
+
|
|
1015
|
+
@pulumi.input_type
|
|
1016
|
+
class CacheToGitHubActionsArgs:
|
|
1017
|
+
def __init__(__self__, *,
|
|
1018
|
+
ignore_error: Optional[pulumi.Input[bool]] = None,
|
|
1019
|
+
mode: Optional[pulumi.Input['CacheMode']] = None,
|
|
1020
|
+
scope: Optional[pulumi.Input[str]] = None,
|
|
1021
|
+
token: Optional[pulumi.Input[str]] = None,
|
|
1022
|
+
url: Optional[pulumi.Input[str]] = None):
|
|
1023
|
+
"""
|
|
1024
|
+
:param pulumi.Input[bool] ignore_error: Ignore errors caused by failed cache exports.
|
|
1025
|
+
:param pulumi.Input['CacheMode'] mode: The cache mode to use. Defaults to `min`.
|
|
1026
|
+
:param pulumi.Input[str] scope: The scope to use for cache keys. Defaults to `buildkit`.
|
|
1027
|
+
|
|
1028
|
+
This should be set if building and caching multiple images in one
|
|
1029
|
+
workflow, otherwise caches will overwrite each other.
|
|
1030
|
+
:param pulumi.Input[str] token: The GitHub Actions token to use. This is not a personal access tokens
|
|
1031
|
+
and is typically generated automatically as part of each job.
|
|
1032
|
+
|
|
1033
|
+
Defaults to `$ACTIONS_RUNTIME_TOKEN`, although a separate action like
|
|
1034
|
+
`crazy-max/ghaction-github-runtime` is recommended to expose this
|
|
1035
|
+
environment variable to your jobs.
|
|
1036
|
+
:param pulumi.Input[str] url: The cache server URL to use for artifacts.
|
|
1037
|
+
|
|
1038
|
+
Defaults to `$ACTIONS_CACHE_URL`, although a separate action like
|
|
1039
|
+
`crazy-max/ghaction-github-runtime` is recommended to expose this
|
|
1040
|
+
environment variable to your jobs.
|
|
1041
|
+
"""
|
|
1042
|
+
if ignore_error is None:
|
|
1043
|
+
ignore_error = False
|
|
1044
|
+
if ignore_error is not None:
|
|
1045
|
+
pulumi.set(__self__, "ignore_error", ignore_error)
|
|
1046
|
+
if mode is None:
|
|
1047
|
+
mode = 'min'
|
|
1048
|
+
if mode is not None:
|
|
1049
|
+
pulumi.set(__self__, "mode", mode)
|
|
1050
|
+
if scope is None:
|
|
1051
|
+
scope = (_utilities.get_env('buildkit') or '')
|
|
1052
|
+
if scope is not None:
|
|
1053
|
+
pulumi.set(__self__, "scope", scope)
|
|
1054
|
+
if token is None:
|
|
1055
|
+
token = (_utilities.get_env('ACTIONS_RUNTIME_TOKEN') or '')
|
|
1056
|
+
if token is not None:
|
|
1057
|
+
pulumi.set(__self__, "token", token)
|
|
1058
|
+
if url is None:
|
|
1059
|
+
url = (_utilities.get_env('ACTIONS_CACHE_URL') or '')
|
|
1060
|
+
if url is not None:
|
|
1061
|
+
pulumi.set(__self__, "url", url)
|
|
1062
|
+
|
|
1063
|
+
@property
|
|
1064
|
+
@pulumi.getter(name="ignoreError")
|
|
1065
|
+
def ignore_error(self) -> Optional[pulumi.Input[bool]]:
|
|
1066
|
+
"""
|
|
1067
|
+
Ignore errors caused by failed cache exports.
|
|
1068
|
+
"""
|
|
1069
|
+
return pulumi.get(self, "ignore_error")
|
|
1070
|
+
|
|
1071
|
+
@ignore_error.setter
|
|
1072
|
+
def ignore_error(self, value: Optional[pulumi.Input[bool]]):
|
|
1073
|
+
pulumi.set(self, "ignore_error", value)
|
|
1074
|
+
|
|
1075
|
+
@property
|
|
1076
|
+
@pulumi.getter
|
|
1077
|
+
def mode(self) -> Optional[pulumi.Input['CacheMode']]:
|
|
1078
|
+
"""
|
|
1079
|
+
The cache mode to use. Defaults to `min`.
|
|
1080
|
+
"""
|
|
1081
|
+
return pulumi.get(self, "mode")
|
|
1082
|
+
|
|
1083
|
+
@mode.setter
|
|
1084
|
+
def mode(self, value: Optional[pulumi.Input['CacheMode']]):
|
|
1085
|
+
pulumi.set(self, "mode", value)
|
|
1086
|
+
|
|
1087
|
+
@property
|
|
1088
|
+
@pulumi.getter
|
|
1089
|
+
def scope(self) -> Optional[pulumi.Input[str]]:
|
|
1090
|
+
"""
|
|
1091
|
+
The scope to use for cache keys. Defaults to `buildkit`.
|
|
1092
|
+
|
|
1093
|
+
This should be set if building and caching multiple images in one
|
|
1094
|
+
workflow, otherwise caches will overwrite each other.
|
|
1095
|
+
"""
|
|
1096
|
+
return pulumi.get(self, "scope")
|
|
1097
|
+
|
|
1098
|
+
@scope.setter
|
|
1099
|
+
def scope(self, value: Optional[pulumi.Input[str]]):
|
|
1100
|
+
pulumi.set(self, "scope", value)
|
|
1101
|
+
|
|
1102
|
+
@property
|
|
1103
|
+
@pulumi.getter
|
|
1104
|
+
def token(self) -> Optional[pulumi.Input[str]]:
|
|
1105
|
+
"""
|
|
1106
|
+
The GitHub Actions token to use. This is not a personal access tokens
|
|
1107
|
+
and is typically generated automatically as part of each job.
|
|
1108
|
+
|
|
1109
|
+
Defaults to `$ACTIONS_RUNTIME_TOKEN`, although a separate action like
|
|
1110
|
+
`crazy-max/ghaction-github-runtime` is recommended to expose this
|
|
1111
|
+
environment variable to your jobs.
|
|
1112
|
+
"""
|
|
1113
|
+
return pulumi.get(self, "token")
|
|
1114
|
+
|
|
1115
|
+
@token.setter
|
|
1116
|
+
def token(self, value: Optional[pulumi.Input[str]]):
|
|
1117
|
+
pulumi.set(self, "token", value)
|
|
1118
|
+
|
|
1119
|
+
@property
|
|
1120
|
+
@pulumi.getter
|
|
1121
|
+
def url(self) -> Optional[pulumi.Input[str]]:
|
|
1122
|
+
"""
|
|
1123
|
+
The cache server URL to use for artifacts.
|
|
1124
|
+
|
|
1125
|
+
Defaults to `$ACTIONS_CACHE_URL`, although a separate action like
|
|
1126
|
+
`crazy-max/ghaction-github-runtime` is recommended to expose this
|
|
1127
|
+
environment variable to your jobs.
|
|
1128
|
+
"""
|
|
1129
|
+
return pulumi.get(self, "url")
|
|
1130
|
+
|
|
1131
|
+
@url.setter
|
|
1132
|
+
def url(self, value: Optional[pulumi.Input[str]]):
|
|
1133
|
+
pulumi.set(self, "url", value)
|
|
1134
|
+
|
|
1135
|
+
|
|
1136
|
+
if not MYPY:
|
|
1137
|
+
class CacheToInlineArgsDict(TypedDict):
|
|
1138
|
+
"""
|
|
1139
|
+
Include an inline cache with the exported image.
|
|
1140
|
+
"""
|
|
1141
|
+
pass
|
|
1142
|
+
elif False:
|
|
1143
|
+
CacheToInlineArgsDict: TypeAlias = Mapping[str, Any]
|
|
1144
|
+
|
|
1145
|
+
@pulumi.input_type
|
|
1146
|
+
class CacheToInlineArgs:
|
|
1147
|
+
def __init__(__self__):
|
|
1148
|
+
"""
|
|
1149
|
+
Include an inline cache with the exported image.
|
|
1150
|
+
"""
|
|
1151
|
+
pass
|
|
1152
|
+
|
|
1153
|
+
|
|
1154
|
+
if not MYPY:
|
|
1155
|
+
class CacheToLocalArgsDict(TypedDict):
|
|
1156
|
+
dest: pulumi.Input[str]
|
|
1157
|
+
"""
|
|
1158
|
+
Path of the local directory to export the cache.
|
|
1159
|
+
"""
|
|
1160
|
+
compression: NotRequired[pulumi.Input['CompressionType']]
|
|
1161
|
+
"""
|
|
1162
|
+
The compression type to use.
|
|
1163
|
+
"""
|
|
1164
|
+
compression_level: NotRequired[pulumi.Input[int]]
|
|
1165
|
+
"""
|
|
1166
|
+
Compression level from 0 to 22.
|
|
1167
|
+
"""
|
|
1168
|
+
force_compression: NotRequired[pulumi.Input[bool]]
|
|
1169
|
+
"""
|
|
1170
|
+
Forcefully apply compression.
|
|
1171
|
+
"""
|
|
1172
|
+
ignore_error: NotRequired[pulumi.Input[bool]]
|
|
1173
|
+
"""
|
|
1174
|
+
Ignore errors caused by failed cache exports.
|
|
1175
|
+
"""
|
|
1176
|
+
mode: NotRequired[pulumi.Input['CacheMode']]
|
|
1177
|
+
"""
|
|
1178
|
+
The cache mode to use. Defaults to `min`.
|
|
1179
|
+
"""
|
|
1180
|
+
elif False:
|
|
1181
|
+
CacheToLocalArgsDict: TypeAlias = Mapping[str, Any]
|
|
1182
|
+
|
|
1183
|
+
@pulumi.input_type
|
|
1184
|
+
class CacheToLocalArgs:
|
|
1185
|
+
def __init__(__self__, *,
|
|
1186
|
+
dest: pulumi.Input[str],
|
|
1187
|
+
compression: Optional[pulumi.Input['CompressionType']] = None,
|
|
1188
|
+
compression_level: Optional[pulumi.Input[int]] = None,
|
|
1189
|
+
force_compression: Optional[pulumi.Input[bool]] = None,
|
|
1190
|
+
ignore_error: Optional[pulumi.Input[bool]] = None,
|
|
1191
|
+
mode: Optional[pulumi.Input['CacheMode']] = None):
|
|
1192
|
+
"""
|
|
1193
|
+
:param pulumi.Input[str] dest: Path of the local directory to export the cache.
|
|
1194
|
+
:param pulumi.Input['CompressionType'] compression: The compression type to use.
|
|
1195
|
+
:param pulumi.Input[int] compression_level: Compression level from 0 to 22.
|
|
1196
|
+
:param pulumi.Input[bool] force_compression: Forcefully apply compression.
|
|
1197
|
+
:param pulumi.Input[bool] ignore_error: Ignore errors caused by failed cache exports.
|
|
1198
|
+
:param pulumi.Input['CacheMode'] mode: The cache mode to use. Defaults to `min`.
|
|
1199
|
+
"""
|
|
1200
|
+
pulumi.set(__self__, "dest", dest)
|
|
1201
|
+
if compression is None:
|
|
1202
|
+
compression = 'gzip'
|
|
1203
|
+
if compression is not None:
|
|
1204
|
+
pulumi.set(__self__, "compression", compression)
|
|
1205
|
+
if compression_level is None:
|
|
1206
|
+
compression_level = 0
|
|
1207
|
+
if compression_level is not None:
|
|
1208
|
+
pulumi.set(__self__, "compression_level", compression_level)
|
|
1209
|
+
if force_compression is None:
|
|
1210
|
+
force_compression = False
|
|
1211
|
+
if force_compression is not None:
|
|
1212
|
+
pulumi.set(__self__, "force_compression", force_compression)
|
|
1213
|
+
if ignore_error is None:
|
|
1214
|
+
ignore_error = False
|
|
1215
|
+
if ignore_error is not None:
|
|
1216
|
+
pulumi.set(__self__, "ignore_error", ignore_error)
|
|
1217
|
+
if mode is None:
|
|
1218
|
+
mode = 'min'
|
|
1219
|
+
if mode is not None:
|
|
1220
|
+
pulumi.set(__self__, "mode", mode)
|
|
1221
|
+
|
|
1222
|
+
@property
|
|
1223
|
+
@pulumi.getter
|
|
1224
|
+
def dest(self) -> pulumi.Input[str]:
|
|
1225
|
+
"""
|
|
1226
|
+
Path of the local directory to export the cache.
|
|
1227
|
+
"""
|
|
1228
|
+
return pulumi.get(self, "dest")
|
|
1229
|
+
|
|
1230
|
+
@dest.setter
|
|
1231
|
+
def dest(self, value: pulumi.Input[str]):
|
|
1232
|
+
pulumi.set(self, "dest", value)
|
|
1233
|
+
|
|
1234
|
+
@property
|
|
1235
|
+
@pulumi.getter
|
|
1236
|
+
def compression(self) -> Optional[pulumi.Input['CompressionType']]:
|
|
1237
|
+
"""
|
|
1238
|
+
The compression type to use.
|
|
1239
|
+
"""
|
|
1240
|
+
return pulumi.get(self, "compression")
|
|
1241
|
+
|
|
1242
|
+
@compression.setter
|
|
1243
|
+
def compression(self, value: Optional[pulumi.Input['CompressionType']]):
|
|
1244
|
+
pulumi.set(self, "compression", value)
|
|
1245
|
+
|
|
1246
|
+
@property
|
|
1247
|
+
@pulumi.getter(name="compressionLevel")
|
|
1248
|
+
def compression_level(self) -> Optional[pulumi.Input[int]]:
|
|
1249
|
+
"""
|
|
1250
|
+
Compression level from 0 to 22.
|
|
1251
|
+
"""
|
|
1252
|
+
return pulumi.get(self, "compression_level")
|
|
1253
|
+
|
|
1254
|
+
@compression_level.setter
|
|
1255
|
+
def compression_level(self, value: Optional[pulumi.Input[int]]):
|
|
1256
|
+
pulumi.set(self, "compression_level", value)
|
|
1257
|
+
|
|
1258
|
+
@property
|
|
1259
|
+
@pulumi.getter(name="forceCompression")
|
|
1260
|
+
def force_compression(self) -> Optional[pulumi.Input[bool]]:
|
|
1261
|
+
"""
|
|
1262
|
+
Forcefully apply compression.
|
|
1263
|
+
"""
|
|
1264
|
+
return pulumi.get(self, "force_compression")
|
|
1265
|
+
|
|
1266
|
+
@force_compression.setter
|
|
1267
|
+
def force_compression(self, value: Optional[pulumi.Input[bool]]):
|
|
1268
|
+
pulumi.set(self, "force_compression", value)
|
|
1269
|
+
|
|
1270
|
+
@property
|
|
1271
|
+
@pulumi.getter(name="ignoreError")
|
|
1272
|
+
def ignore_error(self) -> Optional[pulumi.Input[bool]]:
|
|
1273
|
+
"""
|
|
1274
|
+
Ignore errors caused by failed cache exports.
|
|
1275
|
+
"""
|
|
1276
|
+
return pulumi.get(self, "ignore_error")
|
|
1277
|
+
|
|
1278
|
+
@ignore_error.setter
|
|
1279
|
+
def ignore_error(self, value: Optional[pulumi.Input[bool]]):
|
|
1280
|
+
pulumi.set(self, "ignore_error", value)
|
|
1281
|
+
|
|
1282
|
+
@property
|
|
1283
|
+
@pulumi.getter
|
|
1284
|
+
def mode(self) -> Optional[pulumi.Input['CacheMode']]:
|
|
1285
|
+
"""
|
|
1286
|
+
The cache mode to use. Defaults to `min`.
|
|
1287
|
+
"""
|
|
1288
|
+
return pulumi.get(self, "mode")
|
|
1289
|
+
|
|
1290
|
+
@mode.setter
|
|
1291
|
+
def mode(self, value: Optional[pulumi.Input['CacheMode']]):
|
|
1292
|
+
pulumi.set(self, "mode", value)
|
|
1293
|
+
|
|
1294
|
+
|
|
1295
|
+
if not MYPY:
|
|
1296
|
+
class CacheToRegistryArgsDict(TypedDict):
|
|
1297
|
+
ref: pulumi.Input[str]
|
|
1298
|
+
"""
|
|
1299
|
+
Fully qualified name of the cache image to import.
|
|
1300
|
+
"""
|
|
1301
|
+
compression: NotRequired[pulumi.Input['CompressionType']]
|
|
1302
|
+
"""
|
|
1303
|
+
The compression type to use.
|
|
1304
|
+
"""
|
|
1305
|
+
compression_level: NotRequired[pulumi.Input[int]]
|
|
1306
|
+
"""
|
|
1307
|
+
Compression level from 0 to 22.
|
|
1308
|
+
"""
|
|
1309
|
+
force_compression: NotRequired[pulumi.Input[bool]]
|
|
1310
|
+
"""
|
|
1311
|
+
Forcefully apply compression.
|
|
1312
|
+
"""
|
|
1313
|
+
ignore_error: NotRequired[pulumi.Input[bool]]
|
|
1314
|
+
"""
|
|
1315
|
+
Ignore errors caused by failed cache exports.
|
|
1316
|
+
"""
|
|
1317
|
+
image_manifest: NotRequired[pulumi.Input[bool]]
|
|
1318
|
+
"""
|
|
1319
|
+
Export cache manifest as an OCI-compatible image manifest instead of a
|
|
1320
|
+
manifest list. Requires `ociMediaTypes` to also be `true`.
|
|
1321
|
+
|
|
1322
|
+
Some registries like AWS ECR will not work with caching if this is
|
|
1323
|
+
`false`.
|
|
1324
|
+
|
|
1325
|
+
Defaults to `false` to match Docker's default behavior.
|
|
1326
|
+
"""
|
|
1327
|
+
mode: NotRequired[pulumi.Input['CacheMode']]
|
|
1328
|
+
"""
|
|
1329
|
+
The cache mode to use. Defaults to `min`.
|
|
1330
|
+
"""
|
|
1331
|
+
oci_media_types: NotRequired[pulumi.Input[bool]]
|
|
1332
|
+
"""
|
|
1333
|
+
Whether to use OCI media types in exported manifests. Defaults to
|
|
1334
|
+
`true`.
|
|
1335
|
+
"""
|
|
1336
|
+
elif False:
|
|
1337
|
+
CacheToRegistryArgsDict: TypeAlias = Mapping[str, Any]
|
|
1338
|
+
|
|
1339
|
+
@pulumi.input_type
|
|
1340
|
+
class CacheToRegistryArgs:
|
|
1341
|
+
def __init__(__self__, *,
|
|
1342
|
+
ref: pulumi.Input[str],
|
|
1343
|
+
compression: Optional[pulumi.Input['CompressionType']] = None,
|
|
1344
|
+
compression_level: Optional[pulumi.Input[int]] = None,
|
|
1345
|
+
force_compression: Optional[pulumi.Input[bool]] = None,
|
|
1346
|
+
ignore_error: Optional[pulumi.Input[bool]] = None,
|
|
1347
|
+
image_manifest: Optional[pulumi.Input[bool]] = None,
|
|
1348
|
+
mode: Optional[pulumi.Input['CacheMode']] = None,
|
|
1349
|
+
oci_media_types: Optional[pulumi.Input[bool]] = None):
|
|
1350
|
+
"""
|
|
1351
|
+
:param pulumi.Input[str] ref: Fully qualified name of the cache image to import.
|
|
1352
|
+
:param pulumi.Input['CompressionType'] compression: The compression type to use.
|
|
1353
|
+
:param pulumi.Input[int] compression_level: Compression level from 0 to 22.
|
|
1354
|
+
:param pulumi.Input[bool] force_compression: Forcefully apply compression.
|
|
1355
|
+
:param pulumi.Input[bool] ignore_error: Ignore errors caused by failed cache exports.
|
|
1356
|
+
:param pulumi.Input[bool] image_manifest: Export cache manifest as an OCI-compatible image manifest instead of a
|
|
1357
|
+
manifest list. Requires `ociMediaTypes` to also be `true`.
|
|
1358
|
+
|
|
1359
|
+
Some registries like AWS ECR will not work with caching if this is
|
|
1360
|
+
`false`.
|
|
1361
|
+
|
|
1362
|
+
Defaults to `false` to match Docker's default behavior.
|
|
1363
|
+
:param pulumi.Input['CacheMode'] mode: The cache mode to use. Defaults to `min`.
|
|
1364
|
+
:param pulumi.Input[bool] oci_media_types: Whether to use OCI media types in exported manifests. Defaults to
|
|
1365
|
+
`true`.
|
|
1366
|
+
"""
|
|
1367
|
+
pulumi.set(__self__, "ref", ref)
|
|
1368
|
+
if compression is None:
|
|
1369
|
+
compression = 'gzip'
|
|
1370
|
+
if compression is not None:
|
|
1371
|
+
pulumi.set(__self__, "compression", compression)
|
|
1372
|
+
if compression_level is None:
|
|
1373
|
+
compression_level = 0
|
|
1374
|
+
if compression_level is not None:
|
|
1375
|
+
pulumi.set(__self__, "compression_level", compression_level)
|
|
1376
|
+
if force_compression is None:
|
|
1377
|
+
force_compression = False
|
|
1378
|
+
if force_compression is not None:
|
|
1379
|
+
pulumi.set(__self__, "force_compression", force_compression)
|
|
1380
|
+
if ignore_error is None:
|
|
1381
|
+
ignore_error = False
|
|
1382
|
+
if ignore_error is not None:
|
|
1383
|
+
pulumi.set(__self__, "ignore_error", ignore_error)
|
|
1384
|
+
if image_manifest is None:
|
|
1385
|
+
image_manifest = False
|
|
1386
|
+
if image_manifest is not None:
|
|
1387
|
+
pulumi.set(__self__, "image_manifest", image_manifest)
|
|
1388
|
+
if mode is None:
|
|
1389
|
+
mode = 'min'
|
|
1390
|
+
if mode is not None:
|
|
1391
|
+
pulumi.set(__self__, "mode", mode)
|
|
1392
|
+
if oci_media_types is None:
|
|
1393
|
+
oci_media_types = True
|
|
1394
|
+
if oci_media_types is not None:
|
|
1395
|
+
pulumi.set(__self__, "oci_media_types", oci_media_types)
|
|
1396
|
+
|
|
1397
|
+
@property
|
|
1398
|
+
@pulumi.getter
|
|
1399
|
+
def ref(self) -> pulumi.Input[str]:
|
|
1400
|
+
"""
|
|
1401
|
+
Fully qualified name of the cache image to import.
|
|
1402
|
+
"""
|
|
1403
|
+
return pulumi.get(self, "ref")
|
|
1404
|
+
|
|
1405
|
+
@ref.setter
|
|
1406
|
+
def ref(self, value: pulumi.Input[str]):
|
|
1407
|
+
pulumi.set(self, "ref", value)
|
|
1408
|
+
|
|
1409
|
+
@property
|
|
1410
|
+
@pulumi.getter
|
|
1411
|
+
def compression(self) -> Optional[pulumi.Input['CompressionType']]:
|
|
1412
|
+
"""
|
|
1413
|
+
The compression type to use.
|
|
1414
|
+
"""
|
|
1415
|
+
return pulumi.get(self, "compression")
|
|
1416
|
+
|
|
1417
|
+
@compression.setter
|
|
1418
|
+
def compression(self, value: Optional[pulumi.Input['CompressionType']]):
|
|
1419
|
+
pulumi.set(self, "compression", value)
|
|
1420
|
+
|
|
1421
|
+
@property
|
|
1422
|
+
@pulumi.getter(name="compressionLevel")
|
|
1423
|
+
def compression_level(self) -> Optional[pulumi.Input[int]]:
|
|
1424
|
+
"""
|
|
1425
|
+
Compression level from 0 to 22.
|
|
1426
|
+
"""
|
|
1427
|
+
return pulumi.get(self, "compression_level")
|
|
1428
|
+
|
|
1429
|
+
@compression_level.setter
|
|
1430
|
+
def compression_level(self, value: Optional[pulumi.Input[int]]):
|
|
1431
|
+
pulumi.set(self, "compression_level", value)
|
|
1432
|
+
|
|
1433
|
+
@property
|
|
1434
|
+
@pulumi.getter(name="forceCompression")
|
|
1435
|
+
def force_compression(self) -> Optional[pulumi.Input[bool]]:
|
|
1436
|
+
"""
|
|
1437
|
+
Forcefully apply compression.
|
|
1438
|
+
"""
|
|
1439
|
+
return pulumi.get(self, "force_compression")
|
|
1440
|
+
|
|
1441
|
+
@force_compression.setter
|
|
1442
|
+
def force_compression(self, value: Optional[pulumi.Input[bool]]):
|
|
1443
|
+
pulumi.set(self, "force_compression", value)
|
|
1444
|
+
|
|
1445
|
+
@property
|
|
1446
|
+
@pulumi.getter(name="ignoreError")
|
|
1447
|
+
def ignore_error(self) -> Optional[pulumi.Input[bool]]:
|
|
1448
|
+
"""
|
|
1449
|
+
Ignore errors caused by failed cache exports.
|
|
1450
|
+
"""
|
|
1451
|
+
return pulumi.get(self, "ignore_error")
|
|
1452
|
+
|
|
1453
|
+
@ignore_error.setter
|
|
1454
|
+
def ignore_error(self, value: Optional[pulumi.Input[bool]]):
|
|
1455
|
+
pulumi.set(self, "ignore_error", value)
|
|
1456
|
+
|
|
1457
|
+
@property
|
|
1458
|
+
@pulumi.getter(name="imageManifest")
|
|
1459
|
+
def image_manifest(self) -> Optional[pulumi.Input[bool]]:
|
|
1460
|
+
"""
|
|
1461
|
+
Export cache manifest as an OCI-compatible image manifest instead of a
|
|
1462
|
+
manifest list. Requires `ociMediaTypes` to also be `true`.
|
|
1463
|
+
|
|
1464
|
+
Some registries like AWS ECR will not work with caching if this is
|
|
1465
|
+
`false`.
|
|
1466
|
+
|
|
1467
|
+
Defaults to `false` to match Docker's default behavior.
|
|
1468
|
+
"""
|
|
1469
|
+
return pulumi.get(self, "image_manifest")
|
|
1470
|
+
|
|
1471
|
+
@image_manifest.setter
|
|
1472
|
+
def image_manifest(self, value: Optional[pulumi.Input[bool]]):
|
|
1473
|
+
pulumi.set(self, "image_manifest", value)
|
|
1474
|
+
|
|
1475
|
+
@property
|
|
1476
|
+
@pulumi.getter
|
|
1477
|
+
def mode(self) -> Optional[pulumi.Input['CacheMode']]:
|
|
1478
|
+
"""
|
|
1479
|
+
The cache mode to use. Defaults to `min`.
|
|
1480
|
+
"""
|
|
1481
|
+
return pulumi.get(self, "mode")
|
|
1482
|
+
|
|
1483
|
+
@mode.setter
|
|
1484
|
+
def mode(self, value: Optional[pulumi.Input['CacheMode']]):
|
|
1485
|
+
pulumi.set(self, "mode", value)
|
|
1486
|
+
|
|
1487
|
+
@property
|
|
1488
|
+
@pulumi.getter(name="ociMediaTypes")
|
|
1489
|
+
def oci_media_types(self) -> Optional[pulumi.Input[bool]]:
|
|
1490
|
+
"""
|
|
1491
|
+
Whether to use OCI media types in exported manifests. Defaults to
|
|
1492
|
+
`true`.
|
|
1493
|
+
"""
|
|
1494
|
+
return pulumi.get(self, "oci_media_types")
|
|
1495
|
+
|
|
1496
|
+
@oci_media_types.setter
|
|
1497
|
+
def oci_media_types(self, value: Optional[pulumi.Input[bool]]):
|
|
1498
|
+
pulumi.set(self, "oci_media_types", value)
|
|
1499
|
+
|
|
1500
|
+
|
|
1501
|
+
if not MYPY:
|
|
1502
|
+
class CacheToS3ArgsDict(TypedDict):
|
|
1503
|
+
bucket: pulumi.Input[str]
|
|
1504
|
+
"""
|
|
1505
|
+
Name of the S3 bucket.
|
|
1506
|
+
"""
|
|
1507
|
+
region: pulumi.Input[str]
|
|
1508
|
+
"""
|
|
1509
|
+
The geographic location of the bucket. Defaults to `$AWS_REGION`.
|
|
1510
|
+
"""
|
|
1511
|
+
access_key_id: NotRequired[pulumi.Input[str]]
|
|
1512
|
+
"""
|
|
1513
|
+
Defaults to `$AWS_ACCESS_KEY_ID`.
|
|
1514
|
+
"""
|
|
1515
|
+
blobs_prefix: NotRequired[pulumi.Input[str]]
|
|
1516
|
+
"""
|
|
1517
|
+
Prefix to prepend to blob filenames.
|
|
1518
|
+
"""
|
|
1519
|
+
endpoint_url: NotRequired[pulumi.Input[str]]
|
|
1520
|
+
"""
|
|
1521
|
+
Endpoint of the S3 bucket.
|
|
1522
|
+
"""
|
|
1523
|
+
ignore_error: NotRequired[pulumi.Input[bool]]
|
|
1524
|
+
"""
|
|
1525
|
+
Ignore errors caused by failed cache exports.
|
|
1526
|
+
"""
|
|
1527
|
+
manifests_prefix: NotRequired[pulumi.Input[str]]
|
|
1528
|
+
"""
|
|
1529
|
+
Prefix to prepend on manifest filenames.
|
|
1530
|
+
"""
|
|
1531
|
+
mode: NotRequired[pulumi.Input['CacheMode']]
|
|
1532
|
+
"""
|
|
1533
|
+
The cache mode to use. Defaults to `min`.
|
|
1534
|
+
"""
|
|
1535
|
+
name: NotRequired[pulumi.Input[str]]
|
|
1536
|
+
"""
|
|
1537
|
+
Name of the cache image.
|
|
1538
|
+
"""
|
|
1539
|
+
secret_access_key: NotRequired[pulumi.Input[str]]
|
|
1540
|
+
"""
|
|
1541
|
+
Defaults to `$AWS_SECRET_ACCESS_KEY`.
|
|
1542
|
+
"""
|
|
1543
|
+
session_token: NotRequired[pulumi.Input[str]]
|
|
1544
|
+
"""
|
|
1545
|
+
Defaults to `$AWS_SESSION_TOKEN`.
|
|
1546
|
+
"""
|
|
1547
|
+
use_path_style: NotRequired[pulumi.Input[bool]]
|
|
1548
|
+
"""
|
|
1549
|
+
Uses `bucket` in the URL instead of hostname when `true`.
|
|
1550
|
+
"""
|
|
1551
|
+
elif False:
|
|
1552
|
+
CacheToS3ArgsDict: TypeAlias = Mapping[str, Any]
|
|
1553
|
+
|
|
1554
|
+
@pulumi.input_type
|
|
1555
|
+
class CacheToS3Args:
|
|
1556
|
+
def __init__(__self__, *,
|
|
1557
|
+
bucket: pulumi.Input[str],
|
|
1558
|
+
region: Optional[pulumi.Input[str]] = None,
|
|
1559
|
+
access_key_id: Optional[pulumi.Input[str]] = None,
|
|
1560
|
+
blobs_prefix: Optional[pulumi.Input[str]] = None,
|
|
1561
|
+
endpoint_url: Optional[pulumi.Input[str]] = None,
|
|
1562
|
+
ignore_error: Optional[pulumi.Input[bool]] = None,
|
|
1563
|
+
manifests_prefix: Optional[pulumi.Input[str]] = None,
|
|
1564
|
+
mode: Optional[pulumi.Input['CacheMode']] = None,
|
|
1565
|
+
name: Optional[pulumi.Input[str]] = None,
|
|
1566
|
+
secret_access_key: Optional[pulumi.Input[str]] = None,
|
|
1567
|
+
session_token: Optional[pulumi.Input[str]] = None,
|
|
1568
|
+
use_path_style: Optional[pulumi.Input[bool]] = None):
|
|
1569
|
+
"""
|
|
1570
|
+
:param pulumi.Input[str] bucket: Name of the S3 bucket.
|
|
1571
|
+
:param pulumi.Input[str] region: The geographic location of the bucket. Defaults to `$AWS_REGION`.
|
|
1572
|
+
:param pulumi.Input[str] access_key_id: Defaults to `$AWS_ACCESS_KEY_ID`.
|
|
1573
|
+
:param pulumi.Input[str] blobs_prefix: Prefix to prepend to blob filenames.
|
|
1574
|
+
:param pulumi.Input[str] endpoint_url: Endpoint of the S3 bucket.
|
|
1575
|
+
:param pulumi.Input[bool] ignore_error: Ignore errors caused by failed cache exports.
|
|
1576
|
+
:param pulumi.Input[str] manifests_prefix: Prefix to prepend on manifest filenames.
|
|
1577
|
+
:param pulumi.Input['CacheMode'] mode: The cache mode to use. Defaults to `min`.
|
|
1578
|
+
:param pulumi.Input[str] name: Name of the cache image.
|
|
1579
|
+
:param pulumi.Input[str] secret_access_key: Defaults to `$AWS_SECRET_ACCESS_KEY`.
|
|
1580
|
+
:param pulumi.Input[str] session_token: Defaults to `$AWS_SESSION_TOKEN`.
|
|
1581
|
+
:param pulumi.Input[bool] use_path_style: Uses `bucket` in the URL instead of hostname when `true`.
|
|
1582
|
+
"""
|
|
1583
|
+
pulumi.set(__self__, "bucket", bucket)
|
|
1584
|
+
if region is None:
|
|
1585
|
+
region = (_utilities.get_env('AWS_REGION') or '')
|
|
1586
|
+
pulumi.set(__self__, "region", region)
|
|
1587
|
+
if access_key_id is None:
|
|
1588
|
+
access_key_id = (_utilities.get_env('AWS_ACCESS_KEY_ID') or '')
|
|
1589
|
+
if access_key_id is not None:
|
|
1590
|
+
pulumi.set(__self__, "access_key_id", access_key_id)
|
|
1591
|
+
if blobs_prefix is not None:
|
|
1592
|
+
pulumi.set(__self__, "blobs_prefix", blobs_prefix)
|
|
1593
|
+
if endpoint_url is not None:
|
|
1594
|
+
pulumi.set(__self__, "endpoint_url", endpoint_url)
|
|
1595
|
+
if ignore_error is None:
|
|
1596
|
+
ignore_error = False
|
|
1597
|
+
if ignore_error is not None:
|
|
1598
|
+
pulumi.set(__self__, "ignore_error", ignore_error)
|
|
1599
|
+
if manifests_prefix is not None:
|
|
1600
|
+
pulumi.set(__self__, "manifests_prefix", manifests_prefix)
|
|
1601
|
+
if mode is None:
|
|
1602
|
+
mode = 'min'
|
|
1603
|
+
if mode is not None:
|
|
1604
|
+
pulumi.set(__self__, "mode", mode)
|
|
1605
|
+
if name is not None:
|
|
1606
|
+
pulumi.set(__self__, "name", name)
|
|
1607
|
+
if secret_access_key is None:
|
|
1608
|
+
secret_access_key = (_utilities.get_env('AWS_SECRET_ACCESS_KEY') or '')
|
|
1609
|
+
if secret_access_key is not None:
|
|
1610
|
+
pulumi.set(__self__, "secret_access_key", secret_access_key)
|
|
1611
|
+
if session_token is None:
|
|
1612
|
+
session_token = (_utilities.get_env('AWS_SESSION_TOKEN') or '')
|
|
1613
|
+
if session_token is not None:
|
|
1614
|
+
pulumi.set(__self__, "session_token", session_token)
|
|
1615
|
+
if use_path_style is not None:
|
|
1616
|
+
pulumi.set(__self__, "use_path_style", use_path_style)
|
|
1617
|
+
|
|
1618
|
+
@property
|
|
1619
|
+
@pulumi.getter
|
|
1620
|
+
def bucket(self) -> pulumi.Input[str]:
|
|
1621
|
+
"""
|
|
1622
|
+
Name of the S3 bucket.
|
|
1623
|
+
"""
|
|
1624
|
+
return pulumi.get(self, "bucket")
|
|
1625
|
+
|
|
1626
|
+
@bucket.setter
|
|
1627
|
+
def bucket(self, value: pulumi.Input[str]):
|
|
1628
|
+
pulumi.set(self, "bucket", value)
|
|
1629
|
+
|
|
1630
|
+
@property
|
|
1631
|
+
@pulumi.getter
|
|
1632
|
+
def region(self) -> pulumi.Input[str]:
|
|
1633
|
+
"""
|
|
1634
|
+
The geographic location of the bucket. Defaults to `$AWS_REGION`.
|
|
1635
|
+
"""
|
|
1636
|
+
return pulumi.get(self, "region")
|
|
1637
|
+
|
|
1638
|
+
@region.setter
|
|
1639
|
+
def region(self, value: pulumi.Input[str]):
|
|
1640
|
+
pulumi.set(self, "region", value)
|
|
1641
|
+
|
|
1642
|
+
@property
|
|
1643
|
+
@pulumi.getter(name="accessKeyId")
|
|
1644
|
+
def access_key_id(self) -> Optional[pulumi.Input[str]]:
|
|
1645
|
+
"""
|
|
1646
|
+
Defaults to `$AWS_ACCESS_KEY_ID`.
|
|
1647
|
+
"""
|
|
1648
|
+
return pulumi.get(self, "access_key_id")
|
|
1649
|
+
|
|
1650
|
+
@access_key_id.setter
|
|
1651
|
+
def access_key_id(self, value: Optional[pulumi.Input[str]]):
|
|
1652
|
+
pulumi.set(self, "access_key_id", value)
|
|
1653
|
+
|
|
1654
|
+
@property
|
|
1655
|
+
@pulumi.getter(name="blobsPrefix")
|
|
1656
|
+
def blobs_prefix(self) -> Optional[pulumi.Input[str]]:
|
|
1657
|
+
"""
|
|
1658
|
+
Prefix to prepend to blob filenames.
|
|
1659
|
+
"""
|
|
1660
|
+
return pulumi.get(self, "blobs_prefix")
|
|
1661
|
+
|
|
1662
|
+
@blobs_prefix.setter
|
|
1663
|
+
def blobs_prefix(self, value: Optional[pulumi.Input[str]]):
|
|
1664
|
+
pulumi.set(self, "blobs_prefix", value)
|
|
1665
|
+
|
|
1666
|
+
@property
|
|
1667
|
+
@pulumi.getter(name="endpointUrl")
|
|
1668
|
+
def endpoint_url(self) -> Optional[pulumi.Input[str]]:
|
|
1669
|
+
"""
|
|
1670
|
+
Endpoint of the S3 bucket.
|
|
1671
|
+
"""
|
|
1672
|
+
return pulumi.get(self, "endpoint_url")
|
|
1673
|
+
|
|
1674
|
+
@endpoint_url.setter
|
|
1675
|
+
def endpoint_url(self, value: Optional[pulumi.Input[str]]):
|
|
1676
|
+
pulumi.set(self, "endpoint_url", value)
|
|
1677
|
+
|
|
1678
|
+
@property
|
|
1679
|
+
@pulumi.getter(name="ignoreError")
|
|
1680
|
+
def ignore_error(self) -> Optional[pulumi.Input[bool]]:
|
|
1681
|
+
"""
|
|
1682
|
+
Ignore errors caused by failed cache exports.
|
|
1683
|
+
"""
|
|
1684
|
+
return pulumi.get(self, "ignore_error")
|
|
1685
|
+
|
|
1686
|
+
@ignore_error.setter
|
|
1687
|
+
def ignore_error(self, value: Optional[pulumi.Input[bool]]):
|
|
1688
|
+
pulumi.set(self, "ignore_error", value)
|
|
1689
|
+
|
|
1690
|
+
@property
|
|
1691
|
+
@pulumi.getter(name="manifestsPrefix")
|
|
1692
|
+
def manifests_prefix(self) -> Optional[pulumi.Input[str]]:
|
|
1693
|
+
"""
|
|
1694
|
+
Prefix to prepend on manifest filenames.
|
|
1695
|
+
"""
|
|
1696
|
+
return pulumi.get(self, "manifests_prefix")
|
|
1697
|
+
|
|
1698
|
+
@manifests_prefix.setter
|
|
1699
|
+
def manifests_prefix(self, value: Optional[pulumi.Input[str]]):
|
|
1700
|
+
pulumi.set(self, "manifests_prefix", value)
|
|
1701
|
+
|
|
1702
|
+
@property
|
|
1703
|
+
@pulumi.getter
|
|
1704
|
+
def mode(self) -> Optional[pulumi.Input['CacheMode']]:
|
|
1705
|
+
"""
|
|
1706
|
+
The cache mode to use. Defaults to `min`.
|
|
1707
|
+
"""
|
|
1708
|
+
return pulumi.get(self, "mode")
|
|
1709
|
+
|
|
1710
|
+
@mode.setter
|
|
1711
|
+
def mode(self, value: Optional[pulumi.Input['CacheMode']]):
|
|
1712
|
+
pulumi.set(self, "mode", value)
|
|
1713
|
+
|
|
1714
|
+
@property
|
|
1715
|
+
@pulumi.getter
|
|
1716
|
+
def name(self) -> Optional[pulumi.Input[str]]:
|
|
1717
|
+
"""
|
|
1718
|
+
Name of the cache image.
|
|
1719
|
+
"""
|
|
1720
|
+
return pulumi.get(self, "name")
|
|
1721
|
+
|
|
1722
|
+
@name.setter
|
|
1723
|
+
def name(self, value: Optional[pulumi.Input[str]]):
|
|
1724
|
+
pulumi.set(self, "name", value)
|
|
1725
|
+
|
|
1726
|
+
@property
|
|
1727
|
+
@pulumi.getter(name="secretAccessKey")
|
|
1728
|
+
def secret_access_key(self) -> Optional[pulumi.Input[str]]:
|
|
1729
|
+
"""
|
|
1730
|
+
Defaults to `$AWS_SECRET_ACCESS_KEY`.
|
|
1731
|
+
"""
|
|
1732
|
+
return pulumi.get(self, "secret_access_key")
|
|
1733
|
+
|
|
1734
|
+
@secret_access_key.setter
|
|
1735
|
+
def secret_access_key(self, value: Optional[pulumi.Input[str]]):
|
|
1736
|
+
pulumi.set(self, "secret_access_key", value)
|
|
1737
|
+
|
|
1738
|
+
@property
|
|
1739
|
+
@pulumi.getter(name="sessionToken")
|
|
1740
|
+
def session_token(self) -> Optional[pulumi.Input[str]]:
|
|
1741
|
+
"""
|
|
1742
|
+
Defaults to `$AWS_SESSION_TOKEN`.
|
|
1743
|
+
"""
|
|
1744
|
+
return pulumi.get(self, "session_token")
|
|
1745
|
+
|
|
1746
|
+
@session_token.setter
|
|
1747
|
+
def session_token(self, value: Optional[pulumi.Input[str]]):
|
|
1748
|
+
pulumi.set(self, "session_token", value)
|
|
1749
|
+
|
|
1750
|
+
@property
|
|
1751
|
+
@pulumi.getter(name="usePathStyle")
|
|
1752
|
+
def use_path_style(self) -> Optional[pulumi.Input[bool]]:
|
|
1753
|
+
"""
|
|
1754
|
+
Uses `bucket` in the URL instead of hostname when `true`.
|
|
1755
|
+
"""
|
|
1756
|
+
return pulumi.get(self, "use_path_style")
|
|
1757
|
+
|
|
1758
|
+
@use_path_style.setter
|
|
1759
|
+
def use_path_style(self, value: Optional[pulumi.Input[bool]]):
|
|
1760
|
+
pulumi.set(self, "use_path_style", value)
|
|
1761
|
+
|
|
1762
|
+
|
|
1763
|
+
if not MYPY:
|
|
1764
|
+
class CacheToArgsDict(TypedDict):
|
|
1765
|
+
azblob: NotRequired[pulumi.Input['CacheToAzureBlobArgsDict']]
|
|
1766
|
+
"""
|
|
1767
|
+
Push cache to Azure's blob storage service.
|
|
1768
|
+
"""
|
|
1769
|
+
disabled: NotRequired[pulumi.Input[bool]]
|
|
1770
|
+
"""
|
|
1771
|
+
When `true` this entry will be excluded. Defaults to `false`.
|
|
1772
|
+
"""
|
|
1773
|
+
gha: NotRequired[pulumi.Input['CacheToGitHubActionsArgsDict']]
|
|
1774
|
+
"""
|
|
1775
|
+
Recommended for use with GitHub Actions workflows.
|
|
1776
|
+
|
|
1777
|
+
An action like `crazy-max/ghaction-github-runtime` is recommended to
|
|
1778
|
+
expose appropriate credentials to your GitHub workflow.
|
|
1779
|
+
"""
|
|
1780
|
+
inline: NotRequired[pulumi.Input['CacheToInlineArgsDict']]
|
|
1781
|
+
"""
|
|
1782
|
+
The inline cache storage backend is the simplest implementation to get
|
|
1783
|
+
started with, but it does not handle multi-stage builds. Consider the
|
|
1784
|
+
`registry` cache backend instead.
|
|
1785
|
+
"""
|
|
1786
|
+
local: NotRequired[pulumi.Input['CacheToLocalArgsDict']]
|
|
1787
|
+
"""
|
|
1788
|
+
A simple backend which caches imagines on your local filesystem.
|
|
1789
|
+
"""
|
|
1790
|
+
raw: NotRequired[pulumi.Input[str]]
|
|
1791
|
+
"""
|
|
1792
|
+
A raw string as you would provide it to the Docker CLI (e.g.,
|
|
1793
|
+
`type=inline`)
|
|
1794
|
+
"""
|
|
1795
|
+
registry: NotRequired[pulumi.Input['CacheToRegistryArgsDict']]
|
|
1796
|
+
"""
|
|
1797
|
+
Push caches to remote registries. Incompatible with the `docker` build
|
|
1798
|
+
driver.
|
|
1799
|
+
"""
|
|
1800
|
+
s3: NotRequired[pulumi.Input['CacheToS3ArgsDict']]
|
|
1801
|
+
"""
|
|
1802
|
+
Push cache to AWS S3 or S3-compatible services such as MinIO.
|
|
1803
|
+
"""
|
|
1804
|
+
elif False:
|
|
1805
|
+
CacheToArgsDict: TypeAlias = Mapping[str, Any]
|
|
1806
|
+
|
|
1807
|
+
@pulumi.input_type
|
|
1808
|
+
class CacheToArgs:
|
|
1809
|
+
def __init__(__self__, *,
|
|
1810
|
+
azblob: Optional[pulumi.Input['CacheToAzureBlobArgs']] = None,
|
|
1811
|
+
disabled: Optional[pulumi.Input[bool]] = None,
|
|
1812
|
+
gha: Optional[pulumi.Input['CacheToGitHubActionsArgs']] = None,
|
|
1813
|
+
inline: Optional[pulumi.Input['CacheToInlineArgs']] = None,
|
|
1814
|
+
local: Optional[pulumi.Input['CacheToLocalArgs']] = None,
|
|
1815
|
+
raw: Optional[pulumi.Input[str]] = None,
|
|
1816
|
+
registry: Optional[pulumi.Input['CacheToRegistryArgs']] = None,
|
|
1817
|
+
s3: Optional[pulumi.Input['CacheToS3Args']] = None):
|
|
1818
|
+
"""
|
|
1819
|
+
:param pulumi.Input['CacheToAzureBlobArgs'] azblob: Push cache to Azure's blob storage service.
|
|
1820
|
+
:param pulumi.Input[bool] disabled: When `true` this entry will be excluded. Defaults to `false`.
|
|
1821
|
+
:param pulumi.Input['CacheToGitHubActionsArgs'] gha: Recommended for use with GitHub Actions workflows.
|
|
1822
|
+
|
|
1823
|
+
An action like `crazy-max/ghaction-github-runtime` is recommended to
|
|
1824
|
+
expose appropriate credentials to your GitHub workflow.
|
|
1825
|
+
:param pulumi.Input['CacheToInlineArgs'] inline: The inline cache storage backend is the simplest implementation to get
|
|
1826
|
+
started with, but it does not handle multi-stage builds. Consider the
|
|
1827
|
+
`registry` cache backend instead.
|
|
1828
|
+
:param pulumi.Input['CacheToLocalArgs'] local: A simple backend which caches imagines on your local filesystem.
|
|
1829
|
+
:param pulumi.Input[str] raw: A raw string as you would provide it to the Docker CLI (e.g.,
|
|
1830
|
+
`type=inline`)
|
|
1831
|
+
:param pulumi.Input['CacheToRegistryArgs'] registry: Push caches to remote registries. Incompatible with the `docker` build
|
|
1832
|
+
driver.
|
|
1833
|
+
:param pulumi.Input['CacheToS3Args'] s3: Push cache to AWS S3 or S3-compatible services such as MinIO.
|
|
1834
|
+
"""
|
|
1835
|
+
if azblob is not None:
|
|
1836
|
+
pulumi.set(__self__, "azblob", azblob)
|
|
1837
|
+
if disabled is not None:
|
|
1838
|
+
pulumi.set(__self__, "disabled", disabled)
|
|
1839
|
+
if gha is not None:
|
|
1840
|
+
pulumi.set(__self__, "gha", gha)
|
|
1841
|
+
if inline is not None:
|
|
1842
|
+
pulumi.set(__self__, "inline", inline)
|
|
1843
|
+
if local is not None:
|
|
1844
|
+
pulumi.set(__self__, "local", local)
|
|
1845
|
+
if raw is not None:
|
|
1846
|
+
pulumi.set(__self__, "raw", raw)
|
|
1847
|
+
if registry is not None:
|
|
1848
|
+
pulumi.set(__self__, "registry", registry)
|
|
1849
|
+
if s3 is not None:
|
|
1850
|
+
pulumi.set(__self__, "s3", s3)
|
|
1851
|
+
|
|
1852
|
+
@property
|
|
1853
|
+
@pulumi.getter
|
|
1854
|
+
def azblob(self) -> Optional[pulumi.Input['CacheToAzureBlobArgs']]:
|
|
1855
|
+
"""
|
|
1856
|
+
Push cache to Azure's blob storage service.
|
|
1857
|
+
"""
|
|
1858
|
+
return pulumi.get(self, "azblob")
|
|
1859
|
+
|
|
1860
|
+
@azblob.setter
|
|
1861
|
+
def azblob(self, value: Optional[pulumi.Input['CacheToAzureBlobArgs']]):
|
|
1862
|
+
pulumi.set(self, "azblob", value)
|
|
1863
|
+
|
|
1864
|
+
@property
|
|
1865
|
+
@pulumi.getter
|
|
1866
|
+
def disabled(self) -> Optional[pulumi.Input[bool]]:
|
|
1867
|
+
"""
|
|
1868
|
+
When `true` this entry will be excluded. Defaults to `false`.
|
|
1869
|
+
"""
|
|
1870
|
+
return pulumi.get(self, "disabled")
|
|
1871
|
+
|
|
1872
|
+
@disabled.setter
|
|
1873
|
+
def disabled(self, value: Optional[pulumi.Input[bool]]):
|
|
1874
|
+
pulumi.set(self, "disabled", value)
|
|
1875
|
+
|
|
1876
|
+
@property
|
|
1877
|
+
@pulumi.getter
|
|
1878
|
+
def gha(self) -> Optional[pulumi.Input['CacheToGitHubActionsArgs']]:
|
|
1879
|
+
"""
|
|
1880
|
+
Recommended for use with GitHub Actions workflows.
|
|
1881
|
+
|
|
1882
|
+
An action like `crazy-max/ghaction-github-runtime` is recommended to
|
|
1883
|
+
expose appropriate credentials to your GitHub workflow.
|
|
1884
|
+
"""
|
|
1885
|
+
return pulumi.get(self, "gha")
|
|
1886
|
+
|
|
1887
|
+
@gha.setter
|
|
1888
|
+
def gha(self, value: Optional[pulumi.Input['CacheToGitHubActionsArgs']]):
|
|
1889
|
+
pulumi.set(self, "gha", value)
|
|
1890
|
+
|
|
1891
|
+
@property
|
|
1892
|
+
@pulumi.getter
|
|
1893
|
+
def inline(self) -> Optional[pulumi.Input['CacheToInlineArgs']]:
|
|
1894
|
+
"""
|
|
1895
|
+
The inline cache storage backend is the simplest implementation to get
|
|
1896
|
+
started with, but it does not handle multi-stage builds. Consider the
|
|
1897
|
+
`registry` cache backend instead.
|
|
1898
|
+
"""
|
|
1899
|
+
return pulumi.get(self, "inline")
|
|
1900
|
+
|
|
1901
|
+
@inline.setter
|
|
1902
|
+
def inline(self, value: Optional[pulumi.Input['CacheToInlineArgs']]):
|
|
1903
|
+
pulumi.set(self, "inline", value)
|
|
1904
|
+
|
|
1905
|
+
@property
|
|
1906
|
+
@pulumi.getter
|
|
1907
|
+
def local(self) -> Optional[pulumi.Input['CacheToLocalArgs']]:
|
|
1908
|
+
"""
|
|
1909
|
+
A simple backend which caches imagines on your local filesystem.
|
|
1910
|
+
"""
|
|
1911
|
+
return pulumi.get(self, "local")
|
|
1912
|
+
|
|
1913
|
+
@local.setter
|
|
1914
|
+
def local(self, value: Optional[pulumi.Input['CacheToLocalArgs']]):
|
|
1915
|
+
pulumi.set(self, "local", value)
|
|
1916
|
+
|
|
1917
|
+
@property
|
|
1918
|
+
@pulumi.getter
|
|
1919
|
+
def raw(self) -> Optional[pulumi.Input[str]]:
|
|
1920
|
+
"""
|
|
1921
|
+
A raw string as you would provide it to the Docker CLI (e.g.,
|
|
1922
|
+
`type=inline`)
|
|
1923
|
+
"""
|
|
1924
|
+
return pulumi.get(self, "raw")
|
|
1925
|
+
|
|
1926
|
+
@raw.setter
|
|
1927
|
+
def raw(self, value: Optional[pulumi.Input[str]]):
|
|
1928
|
+
pulumi.set(self, "raw", value)
|
|
1929
|
+
|
|
1930
|
+
@property
|
|
1931
|
+
@pulumi.getter
|
|
1932
|
+
def registry(self) -> Optional[pulumi.Input['CacheToRegistryArgs']]:
|
|
1933
|
+
"""
|
|
1934
|
+
Push caches to remote registries. Incompatible with the `docker` build
|
|
1935
|
+
driver.
|
|
1936
|
+
"""
|
|
1937
|
+
return pulumi.get(self, "registry")
|
|
1938
|
+
|
|
1939
|
+
@registry.setter
|
|
1940
|
+
def registry(self, value: Optional[pulumi.Input['CacheToRegistryArgs']]):
|
|
1941
|
+
pulumi.set(self, "registry", value)
|
|
1942
|
+
|
|
1943
|
+
@property
|
|
1944
|
+
@pulumi.getter
|
|
1945
|
+
def s3(self) -> Optional[pulumi.Input['CacheToS3Args']]:
|
|
1946
|
+
"""
|
|
1947
|
+
Push cache to AWS S3 or S3-compatible services such as MinIO.
|
|
1948
|
+
"""
|
|
1949
|
+
return pulumi.get(self, "s3")
|
|
1950
|
+
|
|
1951
|
+
@s3.setter
|
|
1952
|
+
def s3(self, value: Optional[pulumi.Input['CacheToS3Args']]):
|
|
1953
|
+
pulumi.set(self, "s3", value)
|
|
1954
|
+
|
|
1955
|
+
|
|
1956
|
+
if not MYPY:
|
|
1957
|
+
class ContextArgsDict(TypedDict):
|
|
1958
|
+
location: pulumi.Input[str]
|
|
1959
|
+
"""
|
|
1960
|
+
Resources to use for build context.
|
|
1961
|
+
|
|
1962
|
+
The location can be:
|
|
1963
|
+
* A relative or absolute path to a local directory (`.`, `./app`,
|
|
1964
|
+
`/app`, etc.).
|
|
1965
|
+
* A remote URL of a Git repository, tarball, or plain text file
|
|
1966
|
+
(`https://github.com/user/myrepo.git`, `http://server/context.tar.gz`,
|
|
1967
|
+
etc.).
|
|
1968
|
+
"""
|
|
1969
|
+
elif False:
|
|
1970
|
+
ContextArgsDict: TypeAlias = Mapping[str, Any]
|
|
1971
|
+
|
|
1972
|
+
@pulumi.input_type
|
|
1973
|
+
class ContextArgs:
|
|
1974
|
+
def __init__(__self__, *,
|
|
1975
|
+
location: pulumi.Input[str]):
|
|
1976
|
+
"""
|
|
1977
|
+
:param pulumi.Input[str] location: Resources to use for build context.
|
|
1978
|
+
|
|
1979
|
+
The location can be:
|
|
1980
|
+
* A relative or absolute path to a local directory (`.`, `./app`,
|
|
1981
|
+
`/app`, etc.).
|
|
1982
|
+
* A remote URL of a Git repository, tarball, or plain text file
|
|
1983
|
+
(`https://github.com/user/myrepo.git`, `http://server/context.tar.gz`,
|
|
1984
|
+
etc.).
|
|
1985
|
+
"""
|
|
1986
|
+
pulumi.set(__self__, "location", location)
|
|
1987
|
+
|
|
1988
|
+
@property
|
|
1989
|
+
@pulumi.getter
|
|
1990
|
+
def location(self) -> pulumi.Input[str]:
|
|
1991
|
+
"""
|
|
1992
|
+
Resources to use for build context.
|
|
1993
|
+
|
|
1994
|
+
The location can be:
|
|
1995
|
+
* A relative or absolute path to a local directory (`.`, `./app`,
|
|
1996
|
+
`/app`, etc.).
|
|
1997
|
+
* A remote URL of a Git repository, tarball, or plain text file
|
|
1998
|
+
(`https://github.com/user/myrepo.git`, `http://server/context.tar.gz`,
|
|
1999
|
+
etc.).
|
|
2000
|
+
"""
|
|
2001
|
+
return pulumi.get(self, "location")
|
|
2002
|
+
|
|
2003
|
+
@location.setter
|
|
2004
|
+
def location(self, value: pulumi.Input[str]):
|
|
2005
|
+
pulumi.set(self, "location", value)
|
|
2006
|
+
|
|
2007
|
+
|
|
2008
|
+
if not MYPY:
|
|
2009
|
+
class DockerfileArgsDict(TypedDict):
|
|
2010
|
+
inline: NotRequired[pulumi.Input[str]]
|
|
2011
|
+
"""
|
|
2012
|
+
Raw Dockerfile contents.
|
|
2013
|
+
|
|
2014
|
+
Conflicts with `location`.
|
|
2015
|
+
|
|
2016
|
+
Equivalent to invoking Docker with `-f -`.
|
|
2017
|
+
"""
|
|
2018
|
+
location: NotRequired[pulumi.Input[str]]
|
|
2019
|
+
"""
|
|
2020
|
+
Location of the Dockerfile to use.
|
|
2021
|
+
|
|
2022
|
+
Can be a relative or absolute path to a local file, or a remote URL.
|
|
2023
|
+
|
|
2024
|
+
Defaults to `${context.location}/Dockerfile` if context is on-disk.
|
|
2025
|
+
|
|
2026
|
+
Conflicts with `inline`.
|
|
2027
|
+
"""
|
|
2028
|
+
elif False:
|
|
2029
|
+
DockerfileArgsDict: TypeAlias = Mapping[str, Any]
|
|
2030
|
+
|
|
2031
|
+
@pulumi.input_type
|
|
2032
|
+
class DockerfileArgs:
|
|
2033
|
+
def __init__(__self__, *,
|
|
2034
|
+
inline: Optional[pulumi.Input[str]] = None,
|
|
2035
|
+
location: Optional[pulumi.Input[str]] = None):
|
|
2036
|
+
"""
|
|
2037
|
+
:param pulumi.Input[str] inline: Raw Dockerfile contents.
|
|
2038
|
+
|
|
2039
|
+
Conflicts with `location`.
|
|
2040
|
+
|
|
2041
|
+
Equivalent to invoking Docker with `-f -`.
|
|
2042
|
+
:param pulumi.Input[str] location: Location of the Dockerfile to use.
|
|
2043
|
+
|
|
2044
|
+
Can be a relative or absolute path to a local file, or a remote URL.
|
|
2045
|
+
|
|
2046
|
+
Defaults to `${context.location}/Dockerfile` if context is on-disk.
|
|
2047
|
+
|
|
2048
|
+
Conflicts with `inline`.
|
|
2049
|
+
"""
|
|
2050
|
+
if inline is not None:
|
|
2051
|
+
pulumi.set(__self__, "inline", inline)
|
|
2052
|
+
if location is not None:
|
|
2053
|
+
pulumi.set(__self__, "location", location)
|
|
2054
|
+
|
|
2055
|
+
@property
|
|
2056
|
+
@pulumi.getter
|
|
2057
|
+
def inline(self) -> Optional[pulumi.Input[str]]:
|
|
2058
|
+
"""
|
|
2059
|
+
Raw Dockerfile contents.
|
|
2060
|
+
|
|
2061
|
+
Conflicts with `location`.
|
|
2062
|
+
|
|
2063
|
+
Equivalent to invoking Docker with `-f -`.
|
|
2064
|
+
"""
|
|
2065
|
+
return pulumi.get(self, "inline")
|
|
2066
|
+
|
|
2067
|
+
@inline.setter
|
|
2068
|
+
def inline(self, value: Optional[pulumi.Input[str]]):
|
|
2069
|
+
pulumi.set(self, "inline", value)
|
|
2070
|
+
|
|
2071
|
+
@property
|
|
2072
|
+
@pulumi.getter
|
|
2073
|
+
def location(self) -> Optional[pulumi.Input[str]]:
|
|
2074
|
+
"""
|
|
2075
|
+
Location of the Dockerfile to use.
|
|
2076
|
+
|
|
2077
|
+
Can be a relative or absolute path to a local file, or a remote URL.
|
|
2078
|
+
|
|
2079
|
+
Defaults to `${context.location}/Dockerfile` if context is on-disk.
|
|
2080
|
+
|
|
2081
|
+
Conflicts with `inline`.
|
|
2082
|
+
"""
|
|
2083
|
+
return pulumi.get(self, "location")
|
|
2084
|
+
|
|
2085
|
+
@location.setter
|
|
2086
|
+
def location(self, value: Optional[pulumi.Input[str]]):
|
|
2087
|
+
pulumi.set(self, "location", value)
|
|
2088
|
+
|
|
2089
|
+
|
|
2090
|
+
if not MYPY:
|
|
2091
|
+
class ExportCacheOnlyArgsDict(TypedDict):
|
|
2092
|
+
pass
|
|
2093
|
+
elif False:
|
|
2094
|
+
ExportCacheOnlyArgsDict: TypeAlias = Mapping[str, Any]
|
|
2095
|
+
|
|
2096
|
+
@pulumi.input_type
|
|
2097
|
+
class ExportCacheOnlyArgs:
|
|
2098
|
+
def __init__(__self__):
|
|
2099
|
+
pass
|
|
2100
|
+
|
|
2101
|
+
|
|
2102
|
+
if not MYPY:
|
|
2103
|
+
class ExportDockerArgsDict(TypedDict):
|
|
2104
|
+
annotations: NotRequired[pulumi.Input[Mapping[str, pulumi.Input[str]]]]
|
|
2105
|
+
"""
|
|
2106
|
+
Attach an arbitrary key/value annotation to the image.
|
|
2107
|
+
"""
|
|
2108
|
+
compression: NotRequired[pulumi.Input['CompressionType']]
|
|
2109
|
+
"""
|
|
2110
|
+
The compression type to use.
|
|
2111
|
+
"""
|
|
2112
|
+
compression_level: NotRequired[pulumi.Input[int]]
|
|
2113
|
+
"""
|
|
2114
|
+
Compression level from 0 to 22.
|
|
2115
|
+
"""
|
|
2116
|
+
dest: NotRequired[pulumi.Input[str]]
|
|
2117
|
+
"""
|
|
2118
|
+
The local export path.
|
|
2119
|
+
"""
|
|
2120
|
+
force_compression: NotRequired[pulumi.Input[bool]]
|
|
2121
|
+
"""
|
|
2122
|
+
Forcefully apply compression.
|
|
2123
|
+
"""
|
|
2124
|
+
names: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
|
|
2125
|
+
"""
|
|
2126
|
+
Specify images names to export. This is overridden if tags are already specified.
|
|
2127
|
+
"""
|
|
2128
|
+
oci_media_types: NotRequired[pulumi.Input[bool]]
|
|
2129
|
+
"""
|
|
2130
|
+
Use OCI media types in exporter manifests.
|
|
2131
|
+
"""
|
|
2132
|
+
tar: NotRequired[pulumi.Input[bool]]
|
|
2133
|
+
"""
|
|
2134
|
+
Bundle the output into a tarball layout.
|
|
2135
|
+
"""
|
|
2136
|
+
elif False:
|
|
2137
|
+
ExportDockerArgsDict: TypeAlias = Mapping[str, Any]
|
|
2138
|
+
|
|
2139
|
+
@pulumi.input_type
|
|
2140
|
+
class ExportDockerArgs:
|
|
2141
|
+
def __init__(__self__, *,
|
|
2142
|
+
annotations: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None,
|
|
2143
|
+
compression: Optional[pulumi.Input['CompressionType']] = None,
|
|
2144
|
+
compression_level: Optional[pulumi.Input[int]] = None,
|
|
2145
|
+
dest: Optional[pulumi.Input[str]] = None,
|
|
2146
|
+
force_compression: Optional[pulumi.Input[bool]] = None,
|
|
2147
|
+
names: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
|
|
2148
|
+
oci_media_types: Optional[pulumi.Input[bool]] = None,
|
|
2149
|
+
tar: Optional[pulumi.Input[bool]] = None):
|
|
2150
|
+
"""
|
|
2151
|
+
:param pulumi.Input[Mapping[str, pulumi.Input[str]]] annotations: Attach an arbitrary key/value annotation to the image.
|
|
2152
|
+
:param pulumi.Input['CompressionType'] compression: The compression type to use.
|
|
2153
|
+
:param pulumi.Input[int] compression_level: Compression level from 0 to 22.
|
|
2154
|
+
:param pulumi.Input[str] dest: The local export path.
|
|
2155
|
+
:param pulumi.Input[bool] force_compression: Forcefully apply compression.
|
|
2156
|
+
:param pulumi.Input[Sequence[pulumi.Input[str]]] names: Specify images names to export. This is overridden if tags are already specified.
|
|
2157
|
+
:param pulumi.Input[bool] oci_media_types: Use OCI media types in exporter manifests.
|
|
2158
|
+
:param pulumi.Input[bool] tar: Bundle the output into a tarball layout.
|
|
2159
|
+
"""
|
|
2160
|
+
if annotations is not None:
|
|
2161
|
+
pulumi.set(__self__, "annotations", annotations)
|
|
2162
|
+
if compression is None:
|
|
2163
|
+
compression = 'gzip'
|
|
2164
|
+
if compression is not None:
|
|
2165
|
+
pulumi.set(__self__, "compression", compression)
|
|
2166
|
+
if compression_level is None:
|
|
2167
|
+
compression_level = 0
|
|
2168
|
+
if compression_level is not None:
|
|
2169
|
+
pulumi.set(__self__, "compression_level", compression_level)
|
|
2170
|
+
if dest is not None:
|
|
2171
|
+
pulumi.set(__self__, "dest", dest)
|
|
2172
|
+
if force_compression is None:
|
|
2173
|
+
force_compression = False
|
|
2174
|
+
if force_compression is not None:
|
|
2175
|
+
pulumi.set(__self__, "force_compression", force_compression)
|
|
2176
|
+
if names is not None:
|
|
2177
|
+
pulumi.set(__self__, "names", names)
|
|
2178
|
+
if oci_media_types is None:
|
|
2179
|
+
oci_media_types = False
|
|
2180
|
+
if oci_media_types is not None:
|
|
2181
|
+
pulumi.set(__self__, "oci_media_types", oci_media_types)
|
|
2182
|
+
if tar is None:
|
|
2183
|
+
tar = True
|
|
2184
|
+
if tar is not None:
|
|
2185
|
+
pulumi.set(__self__, "tar", tar)
|
|
2186
|
+
|
|
2187
|
+
@property
|
|
2188
|
+
@pulumi.getter
|
|
2189
|
+
def annotations(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]:
|
|
2190
|
+
"""
|
|
2191
|
+
Attach an arbitrary key/value annotation to the image.
|
|
2192
|
+
"""
|
|
2193
|
+
return pulumi.get(self, "annotations")
|
|
2194
|
+
|
|
2195
|
+
@annotations.setter
|
|
2196
|
+
def annotations(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]):
|
|
2197
|
+
pulumi.set(self, "annotations", value)
|
|
2198
|
+
|
|
2199
|
+
@property
|
|
2200
|
+
@pulumi.getter
|
|
2201
|
+
def compression(self) -> Optional[pulumi.Input['CompressionType']]:
|
|
2202
|
+
"""
|
|
2203
|
+
The compression type to use.
|
|
2204
|
+
"""
|
|
2205
|
+
return pulumi.get(self, "compression")
|
|
2206
|
+
|
|
2207
|
+
@compression.setter
|
|
2208
|
+
def compression(self, value: Optional[pulumi.Input['CompressionType']]):
|
|
2209
|
+
pulumi.set(self, "compression", value)
|
|
2210
|
+
|
|
2211
|
+
@property
|
|
2212
|
+
@pulumi.getter(name="compressionLevel")
|
|
2213
|
+
def compression_level(self) -> Optional[pulumi.Input[int]]:
|
|
2214
|
+
"""
|
|
2215
|
+
Compression level from 0 to 22.
|
|
2216
|
+
"""
|
|
2217
|
+
return pulumi.get(self, "compression_level")
|
|
2218
|
+
|
|
2219
|
+
@compression_level.setter
|
|
2220
|
+
def compression_level(self, value: Optional[pulumi.Input[int]]):
|
|
2221
|
+
pulumi.set(self, "compression_level", value)
|
|
2222
|
+
|
|
2223
|
+
@property
|
|
2224
|
+
@pulumi.getter
|
|
2225
|
+
def dest(self) -> Optional[pulumi.Input[str]]:
|
|
2226
|
+
"""
|
|
2227
|
+
The local export path.
|
|
2228
|
+
"""
|
|
2229
|
+
return pulumi.get(self, "dest")
|
|
2230
|
+
|
|
2231
|
+
@dest.setter
|
|
2232
|
+
def dest(self, value: Optional[pulumi.Input[str]]):
|
|
2233
|
+
pulumi.set(self, "dest", value)
|
|
2234
|
+
|
|
2235
|
+
@property
|
|
2236
|
+
@pulumi.getter(name="forceCompression")
|
|
2237
|
+
def force_compression(self) -> Optional[pulumi.Input[bool]]:
|
|
2238
|
+
"""
|
|
2239
|
+
Forcefully apply compression.
|
|
2240
|
+
"""
|
|
2241
|
+
return pulumi.get(self, "force_compression")
|
|
2242
|
+
|
|
2243
|
+
@force_compression.setter
|
|
2244
|
+
def force_compression(self, value: Optional[pulumi.Input[bool]]):
|
|
2245
|
+
pulumi.set(self, "force_compression", value)
|
|
2246
|
+
|
|
2247
|
+
@property
|
|
2248
|
+
@pulumi.getter
|
|
2249
|
+
def names(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
|
|
2250
|
+
"""
|
|
2251
|
+
Specify images names to export. This is overridden if tags are already specified.
|
|
2252
|
+
"""
|
|
2253
|
+
return pulumi.get(self, "names")
|
|
2254
|
+
|
|
2255
|
+
@names.setter
|
|
2256
|
+
def names(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
|
|
2257
|
+
pulumi.set(self, "names", value)
|
|
2258
|
+
|
|
2259
|
+
@property
|
|
2260
|
+
@pulumi.getter(name="ociMediaTypes")
|
|
2261
|
+
def oci_media_types(self) -> Optional[pulumi.Input[bool]]:
|
|
2262
|
+
"""
|
|
2263
|
+
Use OCI media types in exporter manifests.
|
|
2264
|
+
"""
|
|
2265
|
+
return pulumi.get(self, "oci_media_types")
|
|
2266
|
+
|
|
2267
|
+
@oci_media_types.setter
|
|
2268
|
+
def oci_media_types(self, value: Optional[pulumi.Input[bool]]):
|
|
2269
|
+
pulumi.set(self, "oci_media_types", value)
|
|
2270
|
+
|
|
2271
|
+
@property
|
|
2272
|
+
@pulumi.getter
|
|
2273
|
+
def tar(self) -> Optional[pulumi.Input[bool]]:
|
|
2274
|
+
"""
|
|
2275
|
+
Bundle the output into a tarball layout.
|
|
2276
|
+
"""
|
|
2277
|
+
return pulumi.get(self, "tar")
|
|
2278
|
+
|
|
2279
|
+
@tar.setter
|
|
2280
|
+
def tar(self, value: Optional[pulumi.Input[bool]]):
|
|
2281
|
+
pulumi.set(self, "tar", value)
|
|
2282
|
+
|
|
2283
|
+
|
|
2284
|
+
if not MYPY:
|
|
2285
|
+
class ExportImageArgsDict(TypedDict):
|
|
2286
|
+
annotations: NotRequired[pulumi.Input[Mapping[str, pulumi.Input[str]]]]
|
|
2287
|
+
"""
|
|
2288
|
+
Attach an arbitrary key/value annotation to the image.
|
|
2289
|
+
"""
|
|
2290
|
+
compression: NotRequired[pulumi.Input['CompressionType']]
|
|
2291
|
+
"""
|
|
2292
|
+
The compression type to use.
|
|
2293
|
+
"""
|
|
2294
|
+
compression_level: NotRequired[pulumi.Input[int]]
|
|
2295
|
+
"""
|
|
2296
|
+
Compression level from 0 to 22.
|
|
2297
|
+
"""
|
|
2298
|
+
dangling_name_prefix: NotRequired[pulumi.Input[str]]
|
|
2299
|
+
"""
|
|
2300
|
+
Name image with `prefix@<digest>`, used for anonymous images.
|
|
2301
|
+
"""
|
|
2302
|
+
force_compression: NotRequired[pulumi.Input[bool]]
|
|
2303
|
+
"""
|
|
2304
|
+
Forcefully apply compression.
|
|
2305
|
+
"""
|
|
2306
|
+
insecure: NotRequired[pulumi.Input[bool]]
|
|
2307
|
+
"""
|
|
2308
|
+
Allow pushing to an insecure registry.
|
|
2309
|
+
"""
|
|
2310
|
+
name_canonical: NotRequired[pulumi.Input[bool]]
|
|
2311
|
+
"""
|
|
2312
|
+
Add additional canonical name (`name@<digest>`).
|
|
2313
|
+
"""
|
|
2314
|
+
names: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
|
|
2315
|
+
"""
|
|
2316
|
+
Specify images names to export. This is overridden if tags are already specified.
|
|
2317
|
+
"""
|
|
2318
|
+
oci_media_types: NotRequired[pulumi.Input[bool]]
|
|
2319
|
+
"""
|
|
2320
|
+
Use OCI media types in exporter manifests.
|
|
2321
|
+
"""
|
|
2322
|
+
push: NotRequired[pulumi.Input[bool]]
|
|
2323
|
+
"""
|
|
2324
|
+
Push after creating the image. Defaults to `false`.
|
|
2325
|
+
"""
|
|
2326
|
+
push_by_digest: NotRequired[pulumi.Input[bool]]
|
|
2327
|
+
"""
|
|
2328
|
+
Push image without name.
|
|
2329
|
+
"""
|
|
2330
|
+
store: NotRequired[pulumi.Input[bool]]
|
|
2331
|
+
"""
|
|
2332
|
+
Store resulting images to the worker's image store and ensure all of
|
|
2333
|
+
its blobs are in the content store.
|
|
2334
|
+
|
|
2335
|
+
Defaults to `true`.
|
|
2336
|
+
|
|
2337
|
+
Ignored if the worker doesn't have image store (when using OCI workers,
|
|
2338
|
+
for example).
|
|
2339
|
+
"""
|
|
2340
|
+
unpack: NotRequired[pulumi.Input[bool]]
|
|
2341
|
+
"""
|
|
2342
|
+
Unpack image after creation (for use with containerd). Defaults to
|
|
2343
|
+
`false`.
|
|
2344
|
+
"""
|
|
2345
|
+
elif False:
|
|
2346
|
+
ExportImageArgsDict: TypeAlias = Mapping[str, Any]
|
|
2347
|
+
|
|
2348
|
+
@pulumi.input_type
|
|
2349
|
+
class ExportImageArgs:
|
|
2350
|
+
def __init__(__self__, *,
|
|
2351
|
+
annotations: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None,
|
|
2352
|
+
compression: Optional[pulumi.Input['CompressionType']] = None,
|
|
2353
|
+
compression_level: Optional[pulumi.Input[int]] = None,
|
|
2354
|
+
dangling_name_prefix: Optional[pulumi.Input[str]] = None,
|
|
2355
|
+
force_compression: Optional[pulumi.Input[bool]] = None,
|
|
2356
|
+
insecure: Optional[pulumi.Input[bool]] = None,
|
|
2357
|
+
name_canonical: Optional[pulumi.Input[bool]] = None,
|
|
2358
|
+
names: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
|
|
2359
|
+
oci_media_types: Optional[pulumi.Input[bool]] = None,
|
|
2360
|
+
push: Optional[pulumi.Input[bool]] = None,
|
|
2361
|
+
push_by_digest: Optional[pulumi.Input[bool]] = None,
|
|
2362
|
+
store: Optional[pulumi.Input[bool]] = None,
|
|
2363
|
+
unpack: Optional[pulumi.Input[bool]] = None):
|
|
2364
|
+
"""
|
|
2365
|
+
:param pulumi.Input[Mapping[str, pulumi.Input[str]]] annotations: Attach an arbitrary key/value annotation to the image.
|
|
2366
|
+
:param pulumi.Input['CompressionType'] compression: The compression type to use.
|
|
2367
|
+
:param pulumi.Input[int] compression_level: Compression level from 0 to 22.
|
|
2368
|
+
:param pulumi.Input[str] dangling_name_prefix: Name image with `prefix@<digest>`, used for anonymous images.
|
|
2369
|
+
:param pulumi.Input[bool] force_compression: Forcefully apply compression.
|
|
2370
|
+
:param pulumi.Input[bool] insecure: Allow pushing to an insecure registry.
|
|
2371
|
+
:param pulumi.Input[bool] name_canonical: Add additional canonical name (`name@<digest>`).
|
|
2372
|
+
:param pulumi.Input[Sequence[pulumi.Input[str]]] names: Specify images names to export. This is overridden if tags are already specified.
|
|
2373
|
+
:param pulumi.Input[bool] oci_media_types: Use OCI media types in exporter manifests.
|
|
2374
|
+
:param pulumi.Input[bool] push: Push after creating the image. Defaults to `false`.
|
|
2375
|
+
:param pulumi.Input[bool] push_by_digest: Push image without name.
|
|
2376
|
+
:param pulumi.Input[bool] store: Store resulting images to the worker's image store and ensure all of
|
|
2377
|
+
its blobs are in the content store.
|
|
2378
|
+
|
|
2379
|
+
Defaults to `true`.
|
|
2380
|
+
|
|
2381
|
+
Ignored if the worker doesn't have image store (when using OCI workers,
|
|
2382
|
+
for example).
|
|
2383
|
+
:param pulumi.Input[bool] unpack: Unpack image after creation (for use with containerd). Defaults to
|
|
2384
|
+
`false`.
|
|
2385
|
+
"""
|
|
2386
|
+
if annotations is not None:
|
|
2387
|
+
pulumi.set(__self__, "annotations", annotations)
|
|
2388
|
+
if compression is None:
|
|
2389
|
+
compression = 'gzip'
|
|
2390
|
+
if compression is not None:
|
|
2391
|
+
pulumi.set(__self__, "compression", compression)
|
|
2392
|
+
if compression_level is None:
|
|
2393
|
+
compression_level = 0
|
|
2394
|
+
if compression_level is not None:
|
|
2395
|
+
pulumi.set(__self__, "compression_level", compression_level)
|
|
2396
|
+
if dangling_name_prefix is not None:
|
|
2397
|
+
pulumi.set(__self__, "dangling_name_prefix", dangling_name_prefix)
|
|
2398
|
+
if force_compression is None:
|
|
2399
|
+
force_compression = False
|
|
2400
|
+
if force_compression is not None:
|
|
2401
|
+
pulumi.set(__self__, "force_compression", force_compression)
|
|
2402
|
+
if insecure is not None:
|
|
2403
|
+
pulumi.set(__self__, "insecure", insecure)
|
|
2404
|
+
if name_canonical is not None:
|
|
2405
|
+
pulumi.set(__self__, "name_canonical", name_canonical)
|
|
2406
|
+
if names is not None:
|
|
2407
|
+
pulumi.set(__self__, "names", names)
|
|
2408
|
+
if oci_media_types is None:
|
|
2409
|
+
oci_media_types = False
|
|
2410
|
+
if oci_media_types is not None:
|
|
2411
|
+
pulumi.set(__self__, "oci_media_types", oci_media_types)
|
|
2412
|
+
if push is not None:
|
|
2413
|
+
pulumi.set(__self__, "push", push)
|
|
2414
|
+
if push_by_digest is not None:
|
|
2415
|
+
pulumi.set(__self__, "push_by_digest", push_by_digest)
|
|
2416
|
+
if store is None:
|
|
2417
|
+
store = True
|
|
2418
|
+
if store is not None:
|
|
2419
|
+
pulumi.set(__self__, "store", store)
|
|
2420
|
+
if unpack is not None:
|
|
2421
|
+
pulumi.set(__self__, "unpack", unpack)
|
|
2422
|
+
|
|
2423
|
+
@property
|
|
2424
|
+
@pulumi.getter
|
|
2425
|
+
def annotations(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]:
|
|
2426
|
+
"""
|
|
2427
|
+
Attach an arbitrary key/value annotation to the image.
|
|
2428
|
+
"""
|
|
2429
|
+
return pulumi.get(self, "annotations")
|
|
2430
|
+
|
|
2431
|
+
@annotations.setter
|
|
2432
|
+
def annotations(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]):
|
|
2433
|
+
pulumi.set(self, "annotations", value)
|
|
2434
|
+
|
|
2435
|
+
@property
|
|
2436
|
+
@pulumi.getter
|
|
2437
|
+
def compression(self) -> Optional[pulumi.Input['CompressionType']]:
|
|
2438
|
+
"""
|
|
2439
|
+
The compression type to use.
|
|
2440
|
+
"""
|
|
2441
|
+
return pulumi.get(self, "compression")
|
|
2442
|
+
|
|
2443
|
+
@compression.setter
|
|
2444
|
+
def compression(self, value: Optional[pulumi.Input['CompressionType']]):
|
|
2445
|
+
pulumi.set(self, "compression", value)
|
|
2446
|
+
|
|
2447
|
+
@property
|
|
2448
|
+
@pulumi.getter(name="compressionLevel")
|
|
2449
|
+
def compression_level(self) -> Optional[pulumi.Input[int]]:
|
|
2450
|
+
"""
|
|
2451
|
+
Compression level from 0 to 22.
|
|
2452
|
+
"""
|
|
2453
|
+
return pulumi.get(self, "compression_level")
|
|
2454
|
+
|
|
2455
|
+
@compression_level.setter
|
|
2456
|
+
def compression_level(self, value: Optional[pulumi.Input[int]]):
|
|
2457
|
+
pulumi.set(self, "compression_level", value)
|
|
2458
|
+
|
|
2459
|
+
@property
|
|
2460
|
+
@pulumi.getter(name="danglingNamePrefix")
|
|
2461
|
+
def dangling_name_prefix(self) -> Optional[pulumi.Input[str]]:
|
|
2462
|
+
"""
|
|
2463
|
+
Name image with `prefix@<digest>`, used for anonymous images.
|
|
2464
|
+
"""
|
|
2465
|
+
return pulumi.get(self, "dangling_name_prefix")
|
|
2466
|
+
|
|
2467
|
+
@dangling_name_prefix.setter
|
|
2468
|
+
def dangling_name_prefix(self, value: Optional[pulumi.Input[str]]):
|
|
2469
|
+
pulumi.set(self, "dangling_name_prefix", value)
|
|
2470
|
+
|
|
2471
|
+
@property
|
|
2472
|
+
@pulumi.getter(name="forceCompression")
|
|
2473
|
+
def force_compression(self) -> Optional[pulumi.Input[bool]]:
|
|
2474
|
+
"""
|
|
2475
|
+
Forcefully apply compression.
|
|
2476
|
+
"""
|
|
2477
|
+
return pulumi.get(self, "force_compression")
|
|
2478
|
+
|
|
2479
|
+
@force_compression.setter
|
|
2480
|
+
def force_compression(self, value: Optional[pulumi.Input[bool]]):
|
|
2481
|
+
pulumi.set(self, "force_compression", value)
|
|
2482
|
+
|
|
2483
|
+
@property
|
|
2484
|
+
@pulumi.getter
|
|
2485
|
+
def insecure(self) -> Optional[pulumi.Input[bool]]:
|
|
2486
|
+
"""
|
|
2487
|
+
Allow pushing to an insecure registry.
|
|
2488
|
+
"""
|
|
2489
|
+
return pulumi.get(self, "insecure")
|
|
2490
|
+
|
|
2491
|
+
@insecure.setter
|
|
2492
|
+
def insecure(self, value: Optional[pulumi.Input[bool]]):
|
|
2493
|
+
pulumi.set(self, "insecure", value)
|
|
2494
|
+
|
|
2495
|
+
@property
|
|
2496
|
+
@pulumi.getter(name="nameCanonical")
|
|
2497
|
+
def name_canonical(self) -> Optional[pulumi.Input[bool]]:
|
|
2498
|
+
"""
|
|
2499
|
+
Add additional canonical name (`name@<digest>`).
|
|
2500
|
+
"""
|
|
2501
|
+
return pulumi.get(self, "name_canonical")
|
|
2502
|
+
|
|
2503
|
+
@name_canonical.setter
|
|
2504
|
+
def name_canonical(self, value: Optional[pulumi.Input[bool]]):
|
|
2505
|
+
pulumi.set(self, "name_canonical", value)
|
|
2506
|
+
|
|
2507
|
+
@property
|
|
2508
|
+
@pulumi.getter
|
|
2509
|
+
def names(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
|
|
2510
|
+
"""
|
|
2511
|
+
Specify images names to export. This is overridden if tags are already specified.
|
|
2512
|
+
"""
|
|
2513
|
+
return pulumi.get(self, "names")
|
|
2514
|
+
|
|
2515
|
+
@names.setter
|
|
2516
|
+
def names(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
|
|
2517
|
+
pulumi.set(self, "names", value)
|
|
2518
|
+
|
|
2519
|
+
@property
|
|
2520
|
+
@pulumi.getter(name="ociMediaTypes")
|
|
2521
|
+
def oci_media_types(self) -> Optional[pulumi.Input[bool]]:
|
|
2522
|
+
"""
|
|
2523
|
+
Use OCI media types in exporter manifests.
|
|
2524
|
+
"""
|
|
2525
|
+
return pulumi.get(self, "oci_media_types")
|
|
2526
|
+
|
|
2527
|
+
@oci_media_types.setter
|
|
2528
|
+
def oci_media_types(self, value: Optional[pulumi.Input[bool]]):
|
|
2529
|
+
pulumi.set(self, "oci_media_types", value)
|
|
2530
|
+
|
|
2531
|
+
@property
|
|
2532
|
+
@pulumi.getter
|
|
2533
|
+
def push(self) -> Optional[pulumi.Input[bool]]:
|
|
2534
|
+
"""
|
|
2535
|
+
Push after creating the image. Defaults to `false`.
|
|
2536
|
+
"""
|
|
2537
|
+
return pulumi.get(self, "push")
|
|
2538
|
+
|
|
2539
|
+
@push.setter
|
|
2540
|
+
def push(self, value: Optional[pulumi.Input[bool]]):
|
|
2541
|
+
pulumi.set(self, "push", value)
|
|
2542
|
+
|
|
2543
|
+
@property
|
|
2544
|
+
@pulumi.getter(name="pushByDigest")
|
|
2545
|
+
def push_by_digest(self) -> Optional[pulumi.Input[bool]]:
|
|
2546
|
+
"""
|
|
2547
|
+
Push image without name.
|
|
2548
|
+
"""
|
|
2549
|
+
return pulumi.get(self, "push_by_digest")
|
|
2550
|
+
|
|
2551
|
+
@push_by_digest.setter
|
|
2552
|
+
def push_by_digest(self, value: Optional[pulumi.Input[bool]]):
|
|
2553
|
+
pulumi.set(self, "push_by_digest", value)
|
|
2554
|
+
|
|
2555
|
+
@property
|
|
2556
|
+
@pulumi.getter
|
|
2557
|
+
def store(self) -> Optional[pulumi.Input[bool]]:
|
|
2558
|
+
"""
|
|
2559
|
+
Store resulting images to the worker's image store and ensure all of
|
|
2560
|
+
its blobs are in the content store.
|
|
2561
|
+
|
|
2562
|
+
Defaults to `true`.
|
|
2563
|
+
|
|
2564
|
+
Ignored if the worker doesn't have image store (when using OCI workers,
|
|
2565
|
+
for example).
|
|
2566
|
+
"""
|
|
2567
|
+
return pulumi.get(self, "store")
|
|
2568
|
+
|
|
2569
|
+
@store.setter
|
|
2570
|
+
def store(self, value: Optional[pulumi.Input[bool]]):
|
|
2571
|
+
pulumi.set(self, "store", value)
|
|
2572
|
+
|
|
2573
|
+
@property
|
|
2574
|
+
@pulumi.getter
|
|
2575
|
+
def unpack(self) -> Optional[pulumi.Input[bool]]:
|
|
2576
|
+
"""
|
|
2577
|
+
Unpack image after creation (for use with containerd). Defaults to
|
|
2578
|
+
`false`.
|
|
2579
|
+
"""
|
|
2580
|
+
return pulumi.get(self, "unpack")
|
|
2581
|
+
|
|
2582
|
+
@unpack.setter
|
|
2583
|
+
def unpack(self, value: Optional[pulumi.Input[bool]]):
|
|
2584
|
+
pulumi.set(self, "unpack", value)
|
|
2585
|
+
|
|
2586
|
+
|
|
2587
|
+
if not MYPY:
|
|
2588
|
+
class ExportLocalArgsDict(TypedDict):
|
|
2589
|
+
dest: pulumi.Input[str]
|
|
2590
|
+
"""
|
|
2591
|
+
Output path.
|
|
2592
|
+
"""
|
|
2593
|
+
elif False:
|
|
2594
|
+
ExportLocalArgsDict: TypeAlias = Mapping[str, Any]
|
|
2595
|
+
|
|
2596
|
+
@pulumi.input_type
|
|
2597
|
+
class ExportLocalArgs:
|
|
2598
|
+
def __init__(__self__, *,
|
|
2599
|
+
dest: pulumi.Input[str]):
|
|
2600
|
+
"""
|
|
2601
|
+
:param pulumi.Input[str] dest: Output path.
|
|
2602
|
+
"""
|
|
2603
|
+
pulumi.set(__self__, "dest", dest)
|
|
2604
|
+
|
|
2605
|
+
@property
|
|
2606
|
+
@pulumi.getter
|
|
2607
|
+
def dest(self) -> pulumi.Input[str]:
|
|
2608
|
+
"""
|
|
2609
|
+
Output path.
|
|
2610
|
+
"""
|
|
2611
|
+
return pulumi.get(self, "dest")
|
|
2612
|
+
|
|
2613
|
+
@dest.setter
|
|
2614
|
+
def dest(self, value: pulumi.Input[str]):
|
|
2615
|
+
pulumi.set(self, "dest", value)
|
|
2616
|
+
|
|
2617
|
+
|
|
2618
|
+
if not MYPY:
|
|
2619
|
+
class ExportOCIArgsDict(TypedDict):
|
|
2620
|
+
annotations: NotRequired[pulumi.Input[Mapping[str, pulumi.Input[str]]]]
|
|
2621
|
+
"""
|
|
2622
|
+
Attach an arbitrary key/value annotation to the image.
|
|
2623
|
+
"""
|
|
2624
|
+
compression: NotRequired[pulumi.Input['CompressionType']]
|
|
2625
|
+
"""
|
|
2626
|
+
The compression type to use.
|
|
2627
|
+
"""
|
|
2628
|
+
compression_level: NotRequired[pulumi.Input[int]]
|
|
2629
|
+
"""
|
|
2630
|
+
Compression level from 0 to 22.
|
|
2631
|
+
"""
|
|
2632
|
+
dest: NotRequired[pulumi.Input[str]]
|
|
2633
|
+
"""
|
|
2634
|
+
The local export path.
|
|
2635
|
+
"""
|
|
2636
|
+
force_compression: NotRequired[pulumi.Input[bool]]
|
|
2637
|
+
"""
|
|
2638
|
+
Forcefully apply compression.
|
|
2639
|
+
"""
|
|
2640
|
+
names: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
|
|
2641
|
+
"""
|
|
2642
|
+
Specify images names to export. This is overridden if tags are already specified.
|
|
2643
|
+
"""
|
|
2644
|
+
oci_media_types: NotRequired[pulumi.Input[bool]]
|
|
2645
|
+
"""
|
|
2646
|
+
Use OCI media types in exporter manifests.
|
|
2647
|
+
"""
|
|
2648
|
+
tar: NotRequired[pulumi.Input[bool]]
|
|
2649
|
+
"""
|
|
2650
|
+
Bundle the output into a tarball layout.
|
|
2651
|
+
"""
|
|
2652
|
+
elif False:
|
|
2653
|
+
ExportOCIArgsDict: TypeAlias = Mapping[str, Any]
|
|
2654
|
+
|
|
2655
|
+
@pulumi.input_type
|
|
2656
|
+
class ExportOCIArgs:
|
|
2657
|
+
def __init__(__self__, *,
|
|
2658
|
+
annotations: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None,
|
|
2659
|
+
compression: Optional[pulumi.Input['CompressionType']] = None,
|
|
2660
|
+
compression_level: Optional[pulumi.Input[int]] = None,
|
|
2661
|
+
dest: Optional[pulumi.Input[str]] = None,
|
|
2662
|
+
force_compression: Optional[pulumi.Input[bool]] = None,
|
|
2663
|
+
names: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
|
|
2664
|
+
oci_media_types: Optional[pulumi.Input[bool]] = None,
|
|
2665
|
+
tar: Optional[pulumi.Input[bool]] = None):
|
|
2666
|
+
"""
|
|
2667
|
+
:param pulumi.Input[Mapping[str, pulumi.Input[str]]] annotations: Attach an arbitrary key/value annotation to the image.
|
|
2668
|
+
:param pulumi.Input['CompressionType'] compression: The compression type to use.
|
|
2669
|
+
:param pulumi.Input[int] compression_level: Compression level from 0 to 22.
|
|
2670
|
+
:param pulumi.Input[str] dest: The local export path.
|
|
2671
|
+
:param pulumi.Input[bool] force_compression: Forcefully apply compression.
|
|
2672
|
+
:param pulumi.Input[Sequence[pulumi.Input[str]]] names: Specify images names to export. This is overridden if tags are already specified.
|
|
2673
|
+
:param pulumi.Input[bool] oci_media_types: Use OCI media types in exporter manifests.
|
|
2674
|
+
:param pulumi.Input[bool] tar: Bundle the output into a tarball layout.
|
|
2675
|
+
"""
|
|
2676
|
+
if annotations is not None:
|
|
2677
|
+
pulumi.set(__self__, "annotations", annotations)
|
|
2678
|
+
if compression is None:
|
|
2679
|
+
compression = 'gzip'
|
|
2680
|
+
if compression is not None:
|
|
2681
|
+
pulumi.set(__self__, "compression", compression)
|
|
2682
|
+
if compression_level is None:
|
|
2683
|
+
compression_level = 0
|
|
2684
|
+
if compression_level is not None:
|
|
2685
|
+
pulumi.set(__self__, "compression_level", compression_level)
|
|
2686
|
+
if dest is not None:
|
|
2687
|
+
pulumi.set(__self__, "dest", dest)
|
|
2688
|
+
if force_compression is None:
|
|
2689
|
+
force_compression = False
|
|
2690
|
+
if force_compression is not None:
|
|
2691
|
+
pulumi.set(__self__, "force_compression", force_compression)
|
|
2692
|
+
if names is not None:
|
|
2693
|
+
pulumi.set(__self__, "names", names)
|
|
2694
|
+
if oci_media_types is None:
|
|
2695
|
+
oci_media_types = True
|
|
2696
|
+
if oci_media_types is not None:
|
|
2697
|
+
pulumi.set(__self__, "oci_media_types", oci_media_types)
|
|
2698
|
+
if tar is None:
|
|
2699
|
+
tar = True
|
|
2700
|
+
if tar is not None:
|
|
2701
|
+
pulumi.set(__self__, "tar", tar)
|
|
2702
|
+
|
|
2703
|
+
@property
|
|
2704
|
+
@pulumi.getter
|
|
2705
|
+
def annotations(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]:
|
|
2706
|
+
"""
|
|
2707
|
+
Attach an arbitrary key/value annotation to the image.
|
|
2708
|
+
"""
|
|
2709
|
+
return pulumi.get(self, "annotations")
|
|
2710
|
+
|
|
2711
|
+
@annotations.setter
|
|
2712
|
+
def annotations(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]):
|
|
2713
|
+
pulumi.set(self, "annotations", value)
|
|
2714
|
+
|
|
2715
|
+
@property
|
|
2716
|
+
@pulumi.getter
|
|
2717
|
+
def compression(self) -> Optional[pulumi.Input['CompressionType']]:
|
|
2718
|
+
"""
|
|
2719
|
+
The compression type to use.
|
|
2720
|
+
"""
|
|
2721
|
+
return pulumi.get(self, "compression")
|
|
2722
|
+
|
|
2723
|
+
@compression.setter
|
|
2724
|
+
def compression(self, value: Optional[pulumi.Input['CompressionType']]):
|
|
2725
|
+
pulumi.set(self, "compression", value)
|
|
2726
|
+
|
|
2727
|
+
@property
|
|
2728
|
+
@pulumi.getter(name="compressionLevel")
|
|
2729
|
+
def compression_level(self) -> Optional[pulumi.Input[int]]:
|
|
2730
|
+
"""
|
|
2731
|
+
Compression level from 0 to 22.
|
|
2732
|
+
"""
|
|
2733
|
+
return pulumi.get(self, "compression_level")
|
|
2734
|
+
|
|
2735
|
+
@compression_level.setter
|
|
2736
|
+
def compression_level(self, value: Optional[pulumi.Input[int]]):
|
|
2737
|
+
pulumi.set(self, "compression_level", value)
|
|
2738
|
+
|
|
2739
|
+
@property
|
|
2740
|
+
@pulumi.getter
|
|
2741
|
+
def dest(self) -> Optional[pulumi.Input[str]]:
|
|
2742
|
+
"""
|
|
2743
|
+
The local export path.
|
|
2744
|
+
"""
|
|
2745
|
+
return pulumi.get(self, "dest")
|
|
2746
|
+
|
|
2747
|
+
@dest.setter
|
|
2748
|
+
def dest(self, value: Optional[pulumi.Input[str]]):
|
|
2749
|
+
pulumi.set(self, "dest", value)
|
|
2750
|
+
|
|
2751
|
+
@property
|
|
2752
|
+
@pulumi.getter(name="forceCompression")
|
|
2753
|
+
def force_compression(self) -> Optional[pulumi.Input[bool]]:
|
|
2754
|
+
"""
|
|
2755
|
+
Forcefully apply compression.
|
|
2756
|
+
"""
|
|
2757
|
+
return pulumi.get(self, "force_compression")
|
|
2758
|
+
|
|
2759
|
+
@force_compression.setter
|
|
2760
|
+
def force_compression(self, value: Optional[pulumi.Input[bool]]):
|
|
2761
|
+
pulumi.set(self, "force_compression", value)
|
|
2762
|
+
|
|
2763
|
+
@property
|
|
2764
|
+
@pulumi.getter
|
|
2765
|
+
def names(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
|
|
2766
|
+
"""
|
|
2767
|
+
Specify images names to export. This is overridden if tags are already specified.
|
|
2768
|
+
"""
|
|
2769
|
+
return pulumi.get(self, "names")
|
|
2770
|
+
|
|
2771
|
+
@names.setter
|
|
2772
|
+
def names(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
|
|
2773
|
+
pulumi.set(self, "names", value)
|
|
2774
|
+
|
|
2775
|
+
@property
|
|
2776
|
+
@pulumi.getter(name="ociMediaTypes")
|
|
2777
|
+
def oci_media_types(self) -> Optional[pulumi.Input[bool]]:
|
|
2778
|
+
"""
|
|
2779
|
+
Use OCI media types in exporter manifests.
|
|
2780
|
+
"""
|
|
2781
|
+
return pulumi.get(self, "oci_media_types")
|
|
2782
|
+
|
|
2783
|
+
@oci_media_types.setter
|
|
2784
|
+
def oci_media_types(self, value: Optional[pulumi.Input[bool]]):
|
|
2785
|
+
pulumi.set(self, "oci_media_types", value)
|
|
2786
|
+
|
|
2787
|
+
@property
|
|
2788
|
+
@pulumi.getter
|
|
2789
|
+
def tar(self) -> Optional[pulumi.Input[bool]]:
|
|
2790
|
+
"""
|
|
2791
|
+
Bundle the output into a tarball layout.
|
|
2792
|
+
"""
|
|
2793
|
+
return pulumi.get(self, "tar")
|
|
2794
|
+
|
|
2795
|
+
@tar.setter
|
|
2796
|
+
def tar(self, value: Optional[pulumi.Input[bool]]):
|
|
2797
|
+
pulumi.set(self, "tar", value)
|
|
2798
|
+
|
|
2799
|
+
|
|
2800
|
+
if not MYPY:
|
|
2801
|
+
class ExportRegistryArgsDict(TypedDict):
|
|
2802
|
+
annotations: NotRequired[pulumi.Input[Mapping[str, pulumi.Input[str]]]]
|
|
2803
|
+
"""
|
|
2804
|
+
Attach an arbitrary key/value annotation to the image.
|
|
2805
|
+
"""
|
|
2806
|
+
compression: NotRequired[pulumi.Input['CompressionType']]
|
|
2807
|
+
"""
|
|
2808
|
+
The compression type to use.
|
|
2809
|
+
"""
|
|
2810
|
+
compression_level: NotRequired[pulumi.Input[int]]
|
|
2811
|
+
"""
|
|
2812
|
+
Compression level from 0 to 22.
|
|
2813
|
+
"""
|
|
2814
|
+
dangling_name_prefix: NotRequired[pulumi.Input[str]]
|
|
2815
|
+
"""
|
|
2816
|
+
Name image with `prefix@<digest>`, used for anonymous images.
|
|
2817
|
+
"""
|
|
2818
|
+
force_compression: NotRequired[pulumi.Input[bool]]
|
|
2819
|
+
"""
|
|
2820
|
+
Forcefully apply compression.
|
|
2821
|
+
"""
|
|
2822
|
+
insecure: NotRequired[pulumi.Input[bool]]
|
|
2823
|
+
"""
|
|
2824
|
+
Allow pushing to an insecure registry.
|
|
2825
|
+
"""
|
|
2826
|
+
name_canonical: NotRequired[pulumi.Input[bool]]
|
|
2827
|
+
"""
|
|
2828
|
+
Add additional canonical name (`name@<digest>`).
|
|
2829
|
+
"""
|
|
2830
|
+
names: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
|
|
2831
|
+
"""
|
|
2832
|
+
Specify images names to export. This is overridden if tags are already specified.
|
|
2833
|
+
"""
|
|
2834
|
+
oci_media_types: NotRequired[pulumi.Input[bool]]
|
|
2835
|
+
"""
|
|
2836
|
+
Use OCI media types in exporter manifests.
|
|
2837
|
+
"""
|
|
2838
|
+
push: NotRequired[pulumi.Input[bool]]
|
|
2839
|
+
"""
|
|
2840
|
+
Push after creating the image. Defaults to `true`.
|
|
2841
|
+
"""
|
|
2842
|
+
push_by_digest: NotRequired[pulumi.Input[bool]]
|
|
2843
|
+
"""
|
|
2844
|
+
Push image without name.
|
|
2845
|
+
"""
|
|
2846
|
+
store: NotRequired[pulumi.Input[bool]]
|
|
2847
|
+
"""
|
|
2848
|
+
Store resulting images to the worker's image store and ensure all of
|
|
2849
|
+
its blobs are in the content store.
|
|
2850
|
+
|
|
2851
|
+
Defaults to `true`.
|
|
2852
|
+
|
|
2853
|
+
Ignored if the worker doesn't have image store (when using OCI workers,
|
|
2854
|
+
for example).
|
|
2855
|
+
"""
|
|
2856
|
+
unpack: NotRequired[pulumi.Input[bool]]
|
|
2857
|
+
"""
|
|
2858
|
+
Unpack image after creation (for use with containerd). Defaults to
|
|
2859
|
+
`false`.
|
|
2860
|
+
"""
|
|
2861
|
+
elif False:
|
|
2862
|
+
ExportRegistryArgsDict: TypeAlias = Mapping[str, Any]
|
|
2863
|
+
|
|
2864
|
+
@pulumi.input_type
|
|
2865
|
+
class ExportRegistryArgs:
|
|
2866
|
+
def __init__(__self__, *,
|
|
2867
|
+
annotations: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None,
|
|
2868
|
+
compression: Optional[pulumi.Input['CompressionType']] = None,
|
|
2869
|
+
compression_level: Optional[pulumi.Input[int]] = None,
|
|
2870
|
+
dangling_name_prefix: Optional[pulumi.Input[str]] = None,
|
|
2871
|
+
force_compression: Optional[pulumi.Input[bool]] = None,
|
|
2872
|
+
insecure: Optional[pulumi.Input[bool]] = None,
|
|
2873
|
+
name_canonical: Optional[pulumi.Input[bool]] = None,
|
|
2874
|
+
names: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
|
|
2875
|
+
oci_media_types: Optional[pulumi.Input[bool]] = None,
|
|
2876
|
+
push: Optional[pulumi.Input[bool]] = None,
|
|
2877
|
+
push_by_digest: Optional[pulumi.Input[bool]] = None,
|
|
2878
|
+
store: Optional[pulumi.Input[bool]] = None,
|
|
2879
|
+
unpack: Optional[pulumi.Input[bool]] = None):
|
|
2880
|
+
"""
|
|
2881
|
+
:param pulumi.Input[Mapping[str, pulumi.Input[str]]] annotations: Attach an arbitrary key/value annotation to the image.
|
|
2882
|
+
:param pulumi.Input['CompressionType'] compression: The compression type to use.
|
|
2883
|
+
:param pulumi.Input[int] compression_level: Compression level from 0 to 22.
|
|
2884
|
+
:param pulumi.Input[str] dangling_name_prefix: Name image with `prefix@<digest>`, used for anonymous images.
|
|
2885
|
+
:param pulumi.Input[bool] force_compression: Forcefully apply compression.
|
|
2886
|
+
:param pulumi.Input[bool] insecure: Allow pushing to an insecure registry.
|
|
2887
|
+
:param pulumi.Input[bool] name_canonical: Add additional canonical name (`name@<digest>`).
|
|
2888
|
+
:param pulumi.Input[Sequence[pulumi.Input[str]]] names: Specify images names to export. This is overridden if tags are already specified.
|
|
2889
|
+
:param pulumi.Input[bool] oci_media_types: Use OCI media types in exporter manifests.
|
|
2890
|
+
:param pulumi.Input[bool] push: Push after creating the image. Defaults to `true`.
|
|
2891
|
+
:param pulumi.Input[bool] push_by_digest: Push image without name.
|
|
2892
|
+
:param pulumi.Input[bool] store: Store resulting images to the worker's image store and ensure all of
|
|
2893
|
+
its blobs are in the content store.
|
|
2894
|
+
|
|
2895
|
+
Defaults to `true`.
|
|
2896
|
+
|
|
2897
|
+
Ignored if the worker doesn't have image store (when using OCI workers,
|
|
2898
|
+
for example).
|
|
2899
|
+
:param pulumi.Input[bool] unpack: Unpack image after creation (for use with containerd). Defaults to
|
|
2900
|
+
`false`.
|
|
2901
|
+
"""
|
|
2902
|
+
if annotations is not None:
|
|
2903
|
+
pulumi.set(__self__, "annotations", annotations)
|
|
2904
|
+
if compression is None:
|
|
2905
|
+
compression = 'gzip'
|
|
2906
|
+
if compression is not None:
|
|
2907
|
+
pulumi.set(__self__, "compression", compression)
|
|
2908
|
+
if compression_level is None:
|
|
2909
|
+
compression_level = 0
|
|
2910
|
+
if compression_level is not None:
|
|
2911
|
+
pulumi.set(__self__, "compression_level", compression_level)
|
|
2912
|
+
if dangling_name_prefix is not None:
|
|
2913
|
+
pulumi.set(__self__, "dangling_name_prefix", dangling_name_prefix)
|
|
2914
|
+
if force_compression is None:
|
|
2915
|
+
force_compression = False
|
|
2916
|
+
if force_compression is not None:
|
|
2917
|
+
pulumi.set(__self__, "force_compression", force_compression)
|
|
2918
|
+
if insecure is not None:
|
|
2919
|
+
pulumi.set(__self__, "insecure", insecure)
|
|
2920
|
+
if name_canonical is not None:
|
|
2921
|
+
pulumi.set(__self__, "name_canonical", name_canonical)
|
|
2922
|
+
if names is not None:
|
|
2923
|
+
pulumi.set(__self__, "names", names)
|
|
2924
|
+
if oci_media_types is None:
|
|
2925
|
+
oci_media_types = False
|
|
2926
|
+
if oci_media_types is not None:
|
|
2927
|
+
pulumi.set(__self__, "oci_media_types", oci_media_types)
|
|
2928
|
+
if push is None:
|
|
2929
|
+
push = True
|
|
2930
|
+
if push is not None:
|
|
2931
|
+
pulumi.set(__self__, "push", push)
|
|
2932
|
+
if push_by_digest is not None:
|
|
2933
|
+
pulumi.set(__self__, "push_by_digest", push_by_digest)
|
|
2934
|
+
if store is None:
|
|
2935
|
+
store = True
|
|
2936
|
+
if store is not None:
|
|
2937
|
+
pulumi.set(__self__, "store", store)
|
|
2938
|
+
if unpack is not None:
|
|
2939
|
+
pulumi.set(__self__, "unpack", unpack)
|
|
2940
|
+
|
|
2941
|
+
@property
|
|
2942
|
+
@pulumi.getter
|
|
2943
|
+
def annotations(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]:
|
|
2944
|
+
"""
|
|
2945
|
+
Attach an arbitrary key/value annotation to the image.
|
|
2946
|
+
"""
|
|
2947
|
+
return pulumi.get(self, "annotations")
|
|
2948
|
+
|
|
2949
|
+
@annotations.setter
|
|
2950
|
+
def annotations(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]):
|
|
2951
|
+
pulumi.set(self, "annotations", value)
|
|
2952
|
+
|
|
2953
|
+
@property
|
|
2954
|
+
@pulumi.getter
|
|
2955
|
+
def compression(self) -> Optional[pulumi.Input['CompressionType']]:
|
|
2956
|
+
"""
|
|
2957
|
+
The compression type to use.
|
|
2958
|
+
"""
|
|
2959
|
+
return pulumi.get(self, "compression")
|
|
2960
|
+
|
|
2961
|
+
@compression.setter
|
|
2962
|
+
def compression(self, value: Optional[pulumi.Input['CompressionType']]):
|
|
2963
|
+
pulumi.set(self, "compression", value)
|
|
2964
|
+
|
|
2965
|
+
@property
|
|
2966
|
+
@pulumi.getter(name="compressionLevel")
|
|
2967
|
+
def compression_level(self) -> Optional[pulumi.Input[int]]:
|
|
2968
|
+
"""
|
|
2969
|
+
Compression level from 0 to 22.
|
|
2970
|
+
"""
|
|
2971
|
+
return pulumi.get(self, "compression_level")
|
|
2972
|
+
|
|
2973
|
+
@compression_level.setter
|
|
2974
|
+
def compression_level(self, value: Optional[pulumi.Input[int]]):
|
|
2975
|
+
pulumi.set(self, "compression_level", value)
|
|
2976
|
+
|
|
2977
|
+
@property
|
|
2978
|
+
@pulumi.getter(name="danglingNamePrefix")
|
|
2979
|
+
def dangling_name_prefix(self) -> Optional[pulumi.Input[str]]:
|
|
2980
|
+
"""
|
|
2981
|
+
Name image with `prefix@<digest>`, used for anonymous images.
|
|
2982
|
+
"""
|
|
2983
|
+
return pulumi.get(self, "dangling_name_prefix")
|
|
2984
|
+
|
|
2985
|
+
@dangling_name_prefix.setter
|
|
2986
|
+
def dangling_name_prefix(self, value: Optional[pulumi.Input[str]]):
|
|
2987
|
+
pulumi.set(self, "dangling_name_prefix", value)
|
|
2988
|
+
|
|
2989
|
+
@property
|
|
2990
|
+
@pulumi.getter(name="forceCompression")
|
|
2991
|
+
def force_compression(self) -> Optional[pulumi.Input[bool]]:
|
|
2992
|
+
"""
|
|
2993
|
+
Forcefully apply compression.
|
|
2994
|
+
"""
|
|
2995
|
+
return pulumi.get(self, "force_compression")
|
|
2996
|
+
|
|
2997
|
+
@force_compression.setter
|
|
2998
|
+
def force_compression(self, value: Optional[pulumi.Input[bool]]):
|
|
2999
|
+
pulumi.set(self, "force_compression", value)
|
|
3000
|
+
|
|
3001
|
+
@property
|
|
3002
|
+
@pulumi.getter
|
|
3003
|
+
def insecure(self) -> Optional[pulumi.Input[bool]]:
|
|
3004
|
+
"""
|
|
3005
|
+
Allow pushing to an insecure registry.
|
|
3006
|
+
"""
|
|
3007
|
+
return pulumi.get(self, "insecure")
|
|
3008
|
+
|
|
3009
|
+
@insecure.setter
|
|
3010
|
+
def insecure(self, value: Optional[pulumi.Input[bool]]):
|
|
3011
|
+
pulumi.set(self, "insecure", value)
|
|
3012
|
+
|
|
3013
|
+
@property
|
|
3014
|
+
@pulumi.getter(name="nameCanonical")
|
|
3015
|
+
def name_canonical(self) -> Optional[pulumi.Input[bool]]:
|
|
3016
|
+
"""
|
|
3017
|
+
Add additional canonical name (`name@<digest>`).
|
|
3018
|
+
"""
|
|
3019
|
+
return pulumi.get(self, "name_canonical")
|
|
3020
|
+
|
|
3021
|
+
@name_canonical.setter
|
|
3022
|
+
def name_canonical(self, value: Optional[pulumi.Input[bool]]):
|
|
3023
|
+
pulumi.set(self, "name_canonical", value)
|
|
3024
|
+
|
|
3025
|
+
@property
|
|
3026
|
+
@pulumi.getter
|
|
3027
|
+
def names(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
|
|
3028
|
+
"""
|
|
3029
|
+
Specify images names to export. This is overridden if tags are already specified.
|
|
3030
|
+
"""
|
|
3031
|
+
return pulumi.get(self, "names")
|
|
3032
|
+
|
|
3033
|
+
@names.setter
|
|
3034
|
+
def names(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
|
|
3035
|
+
pulumi.set(self, "names", value)
|
|
3036
|
+
|
|
3037
|
+
@property
|
|
3038
|
+
@pulumi.getter(name="ociMediaTypes")
|
|
3039
|
+
def oci_media_types(self) -> Optional[pulumi.Input[bool]]:
|
|
3040
|
+
"""
|
|
3041
|
+
Use OCI media types in exporter manifests.
|
|
3042
|
+
"""
|
|
3043
|
+
return pulumi.get(self, "oci_media_types")
|
|
3044
|
+
|
|
3045
|
+
@oci_media_types.setter
|
|
3046
|
+
def oci_media_types(self, value: Optional[pulumi.Input[bool]]):
|
|
3047
|
+
pulumi.set(self, "oci_media_types", value)
|
|
3048
|
+
|
|
3049
|
+
@property
|
|
3050
|
+
@pulumi.getter
|
|
3051
|
+
def push(self) -> Optional[pulumi.Input[bool]]:
|
|
3052
|
+
"""
|
|
3053
|
+
Push after creating the image. Defaults to `true`.
|
|
3054
|
+
"""
|
|
3055
|
+
return pulumi.get(self, "push")
|
|
3056
|
+
|
|
3057
|
+
@push.setter
|
|
3058
|
+
def push(self, value: Optional[pulumi.Input[bool]]):
|
|
3059
|
+
pulumi.set(self, "push", value)
|
|
3060
|
+
|
|
3061
|
+
@property
|
|
3062
|
+
@pulumi.getter(name="pushByDigest")
|
|
3063
|
+
def push_by_digest(self) -> Optional[pulumi.Input[bool]]:
|
|
3064
|
+
"""
|
|
3065
|
+
Push image without name.
|
|
3066
|
+
"""
|
|
3067
|
+
return pulumi.get(self, "push_by_digest")
|
|
3068
|
+
|
|
3069
|
+
@push_by_digest.setter
|
|
3070
|
+
def push_by_digest(self, value: Optional[pulumi.Input[bool]]):
|
|
3071
|
+
pulumi.set(self, "push_by_digest", value)
|
|
3072
|
+
|
|
3073
|
+
@property
|
|
3074
|
+
@pulumi.getter
|
|
3075
|
+
def store(self) -> Optional[pulumi.Input[bool]]:
|
|
3076
|
+
"""
|
|
3077
|
+
Store resulting images to the worker's image store and ensure all of
|
|
3078
|
+
its blobs are in the content store.
|
|
3079
|
+
|
|
3080
|
+
Defaults to `true`.
|
|
3081
|
+
|
|
3082
|
+
Ignored if the worker doesn't have image store (when using OCI workers,
|
|
3083
|
+
for example).
|
|
3084
|
+
"""
|
|
3085
|
+
return pulumi.get(self, "store")
|
|
3086
|
+
|
|
3087
|
+
@store.setter
|
|
3088
|
+
def store(self, value: Optional[pulumi.Input[bool]]):
|
|
3089
|
+
pulumi.set(self, "store", value)
|
|
3090
|
+
|
|
3091
|
+
@property
|
|
3092
|
+
@pulumi.getter
|
|
3093
|
+
def unpack(self) -> Optional[pulumi.Input[bool]]:
|
|
3094
|
+
"""
|
|
3095
|
+
Unpack image after creation (for use with containerd). Defaults to
|
|
3096
|
+
`false`.
|
|
3097
|
+
"""
|
|
3098
|
+
return pulumi.get(self, "unpack")
|
|
3099
|
+
|
|
3100
|
+
@unpack.setter
|
|
3101
|
+
def unpack(self, value: Optional[pulumi.Input[bool]]):
|
|
3102
|
+
pulumi.set(self, "unpack", value)
|
|
3103
|
+
|
|
3104
|
+
|
|
3105
|
+
if not MYPY:
|
|
3106
|
+
class ExportTarArgsDict(TypedDict):
|
|
3107
|
+
dest: pulumi.Input[str]
|
|
3108
|
+
"""
|
|
3109
|
+
Output path.
|
|
3110
|
+
"""
|
|
3111
|
+
elif False:
|
|
3112
|
+
ExportTarArgsDict: TypeAlias = Mapping[str, Any]
|
|
3113
|
+
|
|
3114
|
+
@pulumi.input_type
|
|
3115
|
+
class ExportTarArgs:
|
|
3116
|
+
def __init__(__self__, *,
|
|
3117
|
+
dest: pulumi.Input[str]):
|
|
3118
|
+
"""
|
|
3119
|
+
:param pulumi.Input[str] dest: Output path.
|
|
3120
|
+
"""
|
|
3121
|
+
pulumi.set(__self__, "dest", dest)
|
|
3122
|
+
|
|
3123
|
+
@property
|
|
3124
|
+
@pulumi.getter
|
|
3125
|
+
def dest(self) -> pulumi.Input[str]:
|
|
3126
|
+
"""
|
|
3127
|
+
Output path.
|
|
3128
|
+
"""
|
|
3129
|
+
return pulumi.get(self, "dest")
|
|
3130
|
+
|
|
3131
|
+
@dest.setter
|
|
3132
|
+
def dest(self, value: pulumi.Input[str]):
|
|
3133
|
+
pulumi.set(self, "dest", value)
|
|
3134
|
+
|
|
3135
|
+
|
|
3136
|
+
if not MYPY:
|
|
3137
|
+
class ExportArgsDict(TypedDict):
|
|
3138
|
+
cacheonly: NotRequired[pulumi.Input['ExportCacheOnlyArgsDict']]
|
|
3139
|
+
"""
|
|
3140
|
+
A no-op export. Helpful for silencing the 'no exports' warning if you
|
|
3141
|
+
just want to populate caches.
|
|
3142
|
+
"""
|
|
3143
|
+
disabled: NotRequired[pulumi.Input[bool]]
|
|
3144
|
+
"""
|
|
3145
|
+
When `true` this entry will be excluded. Defaults to `false`.
|
|
3146
|
+
"""
|
|
3147
|
+
docker: NotRequired[pulumi.Input['ExportDockerArgsDict']]
|
|
3148
|
+
"""
|
|
3149
|
+
Export as a Docker image layout.
|
|
3150
|
+
"""
|
|
3151
|
+
image: NotRequired[pulumi.Input['ExportImageArgsDict']]
|
|
3152
|
+
"""
|
|
3153
|
+
Outputs the build result into a container image format.
|
|
3154
|
+
"""
|
|
3155
|
+
local: NotRequired[pulumi.Input['ExportLocalArgsDict']]
|
|
3156
|
+
"""
|
|
3157
|
+
Export to a local directory as files and directories.
|
|
3158
|
+
"""
|
|
3159
|
+
oci: NotRequired[pulumi.Input['ExportOCIArgsDict']]
|
|
3160
|
+
"""
|
|
3161
|
+
Identical to the Docker exporter but uses OCI media types by default.
|
|
3162
|
+
"""
|
|
3163
|
+
raw: NotRequired[pulumi.Input[str]]
|
|
3164
|
+
"""
|
|
3165
|
+
A raw string as you would provide it to the Docker CLI (e.g.,
|
|
3166
|
+
`type=docker`)
|
|
3167
|
+
"""
|
|
3168
|
+
registry: NotRequired[pulumi.Input['ExportRegistryArgsDict']]
|
|
3169
|
+
"""
|
|
3170
|
+
Identical to the Image exporter, but pushes by default.
|
|
3171
|
+
"""
|
|
3172
|
+
tar: NotRequired[pulumi.Input['ExportTarArgsDict']]
|
|
3173
|
+
"""
|
|
3174
|
+
Export to a local directory as a tarball.
|
|
3175
|
+
"""
|
|
3176
|
+
elif False:
|
|
3177
|
+
ExportArgsDict: TypeAlias = Mapping[str, Any]
|
|
3178
|
+
|
|
3179
|
+
@pulumi.input_type
|
|
3180
|
+
class ExportArgs:
|
|
3181
|
+
def __init__(__self__, *,
|
|
3182
|
+
cacheonly: Optional[pulumi.Input['ExportCacheOnlyArgs']] = None,
|
|
3183
|
+
disabled: Optional[pulumi.Input[bool]] = None,
|
|
3184
|
+
docker: Optional[pulumi.Input['ExportDockerArgs']] = None,
|
|
3185
|
+
image: Optional[pulumi.Input['ExportImageArgs']] = None,
|
|
3186
|
+
local: Optional[pulumi.Input['ExportLocalArgs']] = None,
|
|
3187
|
+
oci: Optional[pulumi.Input['ExportOCIArgs']] = None,
|
|
3188
|
+
raw: Optional[pulumi.Input[str]] = None,
|
|
3189
|
+
registry: Optional[pulumi.Input['ExportRegistryArgs']] = None,
|
|
3190
|
+
tar: Optional[pulumi.Input['ExportTarArgs']] = None):
|
|
3191
|
+
"""
|
|
3192
|
+
:param pulumi.Input['ExportCacheOnlyArgs'] cacheonly: A no-op export. Helpful for silencing the 'no exports' warning if you
|
|
3193
|
+
just want to populate caches.
|
|
3194
|
+
:param pulumi.Input[bool] disabled: When `true` this entry will be excluded. Defaults to `false`.
|
|
3195
|
+
:param pulumi.Input['ExportDockerArgs'] docker: Export as a Docker image layout.
|
|
3196
|
+
:param pulumi.Input['ExportImageArgs'] image: Outputs the build result into a container image format.
|
|
3197
|
+
:param pulumi.Input['ExportLocalArgs'] local: Export to a local directory as files and directories.
|
|
3198
|
+
:param pulumi.Input['ExportOCIArgs'] oci: Identical to the Docker exporter but uses OCI media types by default.
|
|
3199
|
+
:param pulumi.Input[str] raw: A raw string as you would provide it to the Docker CLI (e.g.,
|
|
3200
|
+
`type=docker`)
|
|
3201
|
+
:param pulumi.Input['ExportRegistryArgs'] registry: Identical to the Image exporter, but pushes by default.
|
|
3202
|
+
:param pulumi.Input['ExportTarArgs'] tar: Export to a local directory as a tarball.
|
|
3203
|
+
"""
|
|
3204
|
+
if cacheonly is not None:
|
|
3205
|
+
pulumi.set(__self__, "cacheonly", cacheonly)
|
|
3206
|
+
if disabled is not None:
|
|
3207
|
+
pulumi.set(__self__, "disabled", disabled)
|
|
3208
|
+
if docker is not None:
|
|
3209
|
+
pulumi.set(__self__, "docker", docker)
|
|
3210
|
+
if image is not None:
|
|
3211
|
+
pulumi.set(__self__, "image", image)
|
|
3212
|
+
if local is not None:
|
|
3213
|
+
pulumi.set(__self__, "local", local)
|
|
3214
|
+
if oci is not None:
|
|
3215
|
+
pulumi.set(__self__, "oci", oci)
|
|
3216
|
+
if raw is not None:
|
|
3217
|
+
pulumi.set(__self__, "raw", raw)
|
|
3218
|
+
if registry is not None:
|
|
3219
|
+
pulumi.set(__self__, "registry", registry)
|
|
3220
|
+
if tar is not None:
|
|
3221
|
+
pulumi.set(__self__, "tar", tar)
|
|
3222
|
+
|
|
3223
|
+
@property
|
|
3224
|
+
@pulumi.getter
|
|
3225
|
+
def cacheonly(self) -> Optional[pulumi.Input['ExportCacheOnlyArgs']]:
|
|
3226
|
+
"""
|
|
3227
|
+
A no-op export. Helpful for silencing the 'no exports' warning if you
|
|
3228
|
+
just want to populate caches.
|
|
3229
|
+
"""
|
|
3230
|
+
return pulumi.get(self, "cacheonly")
|
|
3231
|
+
|
|
3232
|
+
@cacheonly.setter
|
|
3233
|
+
def cacheonly(self, value: Optional[pulumi.Input['ExportCacheOnlyArgs']]):
|
|
3234
|
+
pulumi.set(self, "cacheonly", value)
|
|
3235
|
+
|
|
3236
|
+
@property
|
|
3237
|
+
@pulumi.getter
|
|
3238
|
+
def disabled(self) -> Optional[pulumi.Input[bool]]:
|
|
3239
|
+
"""
|
|
3240
|
+
When `true` this entry will be excluded. Defaults to `false`.
|
|
3241
|
+
"""
|
|
3242
|
+
return pulumi.get(self, "disabled")
|
|
3243
|
+
|
|
3244
|
+
@disabled.setter
|
|
3245
|
+
def disabled(self, value: Optional[pulumi.Input[bool]]):
|
|
3246
|
+
pulumi.set(self, "disabled", value)
|
|
3247
|
+
|
|
3248
|
+
@property
|
|
3249
|
+
@pulumi.getter
|
|
3250
|
+
def docker(self) -> Optional[pulumi.Input['ExportDockerArgs']]:
|
|
3251
|
+
"""
|
|
3252
|
+
Export as a Docker image layout.
|
|
3253
|
+
"""
|
|
3254
|
+
return pulumi.get(self, "docker")
|
|
3255
|
+
|
|
3256
|
+
@docker.setter
|
|
3257
|
+
def docker(self, value: Optional[pulumi.Input['ExportDockerArgs']]):
|
|
3258
|
+
pulumi.set(self, "docker", value)
|
|
3259
|
+
|
|
3260
|
+
@property
|
|
3261
|
+
@pulumi.getter
|
|
3262
|
+
def image(self) -> Optional[pulumi.Input['ExportImageArgs']]:
|
|
3263
|
+
"""
|
|
3264
|
+
Outputs the build result into a container image format.
|
|
3265
|
+
"""
|
|
3266
|
+
return pulumi.get(self, "image")
|
|
3267
|
+
|
|
3268
|
+
@image.setter
|
|
3269
|
+
def image(self, value: Optional[pulumi.Input['ExportImageArgs']]):
|
|
3270
|
+
pulumi.set(self, "image", value)
|
|
3271
|
+
|
|
3272
|
+
@property
|
|
3273
|
+
@pulumi.getter
|
|
3274
|
+
def local(self) -> Optional[pulumi.Input['ExportLocalArgs']]:
|
|
3275
|
+
"""
|
|
3276
|
+
Export to a local directory as files and directories.
|
|
3277
|
+
"""
|
|
3278
|
+
return pulumi.get(self, "local")
|
|
3279
|
+
|
|
3280
|
+
@local.setter
|
|
3281
|
+
def local(self, value: Optional[pulumi.Input['ExportLocalArgs']]):
|
|
3282
|
+
pulumi.set(self, "local", value)
|
|
3283
|
+
|
|
3284
|
+
@property
|
|
3285
|
+
@pulumi.getter
|
|
3286
|
+
def oci(self) -> Optional[pulumi.Input['ExportOCIArgs']]:
|
|
3287
|
+
"""
|
|
3288
|
+
Identical to the Docker exporter but uses OCI media types by default.
|
|
3289
|
+
"""
|
|
3290
|
+
return pulumi.get(self, "oci")
|
|
3291
|
+
|
|
3292
|
+
@oci.setter
|
|
3293
|
+
def oci(self, value: Optional[pulumi.Input['ExportOCIArgs']]):
|
|
3294
|
+
pulumi.set(self, "oci", value)
|
|
3295
|
+
|
|
3296
|
+
@property
|
|
3297
|
+
@pulumi.getter
|
|
3298
|
+
def raw(self) -> Optional[pulumi.Input[str]]:
|
|
3299
|
+
"""
|
|
3300
|
+
A raw string as you would provide it to the Docker CLI (e.g.,
|
|
3301
|
+
`type=docker`)
|
|
3302
|
+
"""
|
|
3303
|
+
return pulumi.get(self, "raw")
|
|
3304
|
+
|
|
3305
|
+
@raw.setter
|
|
3306
|
+
def raw(self, value: Optional[pulumi.Input[str]]):
|
|
3307
|
+
pulumi.set(self, "raw", value)
|
|
3308
|
+
|
|
3309
|
+
@property
|
|
3310
|
+
@pulumi.getter
|
|
3311
|
+
def registry(self) -> Optional[pulumi.Input['ExportRegistryArgs']]:
|
|
3312
|
+
"""
|
|
3313
|
+
Identical to the Image exporter, but pushes by default.
|
|
3314
|
+
"""
|
|
3315
|
+
return pulumi.get(self, "registry")
|
|
3316
|
+
|
|
3317
|
+
@registry.setter
|
|
3318
|
+
def registry(self, value: Optional[pulumi.Input['ExportRegistryArgs']]):
|
|
3319
|
+
pulumi.set(self, "registry", value)
|
|
3320
|
+
|
|
3321
|
+
@property
|
|
3322
|
+
@pulumi.getter
|
|
3323
|
+
def tar(self) -> Optional[pulumi.Input['ExportTarArgs']]:
|
|
3324
|
+
"""
|
|
3325
|
+
Export to a local directory as a tarball.
|
|
3326
|
+
"""
|
|
3327
|
+
return pulumi.get(self, "tar")
|
|
3328
|
+
|
|
3329
|
+
@tar.setter
|
|
3330
|
+
def tar(self, value: Optional[pulumi.Input['ExportTarArgs']]):
|
|
3331
|
+
pulumi.set(self, "tar", value)
|
|
3332
|
+
|
|
3333
|
+
|
|
3334
|
+
if not MYPY:
|
|
3335
|
+
class RegistryArgsDict(TypedDict):
|
|
3336
|
+
address: pulumi.Input[str]
|
|
3337
|
+
"""
|
|
3338
|
+
The registry's address (e.g. "docker.io").
|
|
3339
|
+
"""
|
|
3340
|
+
password: NotRequired[pulumi.Input[str]]
|
|
3341
|
+
"""
|
|
3342
|
+
Password or token for the registry.
|
|
3343
|
+
"""
|
|
3344
|
+
username: NotRequired[pulumi.Input[str]]
|
|
3345
|
+
"""
|
|
3346
|
+
Username for the registry.
|
|
3347
|
+
"""
|
|
3348
|
+
elif False:
|
|
3349
|
+
RegistryArgsDict: TypeAlias = Mapping[str, Any]
|
|
3350
|
+
|
|
3351
|
+
@pulumi.input_type
|
|
3352
|
+
class RegistryArgs:
|
|
3353
|
+
def __init__(__self__, *,
|
|
3354
|
+
address: pulumi.Input[str],
|
|
3355
|
+
password: Optional[pulumi.Input[str]] = None,
|
|
3356
|
+
username: Optional[pulumi.Input[str]] = None):
|
|
3357
|
+
"""
|
|
3358
|
+
:param pulumi.Input[str] address: The registry's address (e.g. "docker.io").
|
|
3359
|
+
:param pulumi.Input[str] password: Password or token for the registry.
|
|
3360
|
+
:param pulumi.Input[str] username: Username for the registry.
|
|
3361
|
+
"""
|
|
3362
|
+
pulumi.set(__self__, "address", address)
|
|
3363
|
+
if password is not None:
|
|
3364
|
+
pulumi.set(__self__, "password", password)
|
|
3365
|
+
if username is not None:
|
|
3366
|
+
pulumi.set(__self__, "username", username)
|
|
3367
|
+
|
|
3368
|
+
@property
|
|
3369
|
+
@pulumi.getter
|
|
3370
|
+
def address(self) -> pulumi.Input[str]:
|
|
3371
|
+
"""
|
|
3372
|
+
The registry's address (e.g. "docker.io").
|
|
3373
|
+
"""
|
|
3374
|
+
return pulumi.get(self, "address")
|
|
3375
|
+
|
|
3376
|
+
@address.setter
|
|
3377
|
+
def address(self, value: pulumi.Input[str]):
|
|
3378
|
+
pulumi.set(self, "address", value)
|
|
3379
|
+
|
|
3380
|
+
@property
|
|
3381
|
+
@pulumi.getter
|
|
3382
|
+
def password(self) -> Optional[pulumi.Input[str]]:
|
|
3383
|
+
"""
|
|
3384
|
+
Password or token for the registry.
|
|
3385
|
+
"""
|
|
3386
|
+
return pulumi.get(self, "password")
|
|
3387
|
+
|
|
3388
|
+
@password.setter
|
|
3389
|
+
def password(self, value: Optional[pulumi.Input[str]]):
|
|
3390
|
+
pulumi.set(self, "password", value)
|
|
3391
|
+
|
|
3392
|
+
@property
|
|
3393
|
+
@pulumi.getter
|
|
3394
|
+
def username(self) -> Optional[pulumi.Input[str]]:
|
|
3395
|
+
"""
|
|
3396
|
+
Username for the registry.
|
|
3397
|
+
"""
|
|
3398
|
+
return pulumi.get(self, "username")
|
|
3399
|
+
|
|
3400
|
+
@username.setter
|
|
3401
|
+
def username(self, value: Optional[pulumi.Input[str]]):
|
|
3402
|
+
pulumi.set(self, "username", value)
|
|
3403
|
+
|
|
3404
|
+
|
|
3405
|
+
if not MYPY:
|
|
3406
|
+
class SSHArgsDict(TypedDict):
|
|
3407
|
+
id: pulumi.Input[str]
|
|
3408
|
+
"""
|
|
3409
|
+
Useful for distinguishing different servers that are part of the same
|
|
3410
|
+
build.
|
|
3411
|
+
|
|
3412
|
+
A value of `default` is appropriate if only dealing with a single host.
|
|
3413
|
+
"""
|
|
3414
|
+
paths: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
|
|
3415
|
+
"""
|
|
3416
|
+
SSH agent socket or private keys to expose to the build under the given
|
|
3417
|
+
identifier.
|
|
3418
|
+
|
|
3419
|
+
Defaults to `[$SSH_AUTH_SOCK]`.
|
|
3420
|
+
|
|
3421
|
+
Note that your keys are **not** automatically added when using an
|
|
3422
|
+
agent. Run `ssh-add -l` locally to confirm which public keys are
|
|
3423
|
+
visible to the agent; these will be exposed to your build.
|
|
3424
|
+
"""
|
|
3425
|
+
elif False:
|
|
3426
|
+
SSHArgsDict: TypeAlias = Mapping[str, Any]
|
|
3427
|
+
|
|
3428
|
+
@pulumi.input_type
|
|
3429
|
+
class SSHArgs:
|
|
3430
|
+
def __init__(__self__, *,
|
|
3431
|
+
id: pulumi.Input[str],
|
|
3432
|
+
paths: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None):
|
|
3433
|
+
"""
|
|
3434
|
+
:param pulumi.Input[str] id: Useful for distinguishing different servers that are part of the same
|
|
3435
|
+
build.
|
|
3436
|
+
|
|
3437
|
+
A value of `default` is appropriate if only dealing with a single host.
|
|
3438
|
+
:param pulumi.Input[Sequence[pulumi.Input[str]]] paths: SSH agent socket or private keys to expose to the build under the given
|
|
3439
|
+
identifier.
|
|
3440
|
+
|
|
3441
|
+
Defaults to `[$SSH_AUTH_SOCK]`.
|
|
3442
|
+
|
|
3443
|
+
Note that your keys are **not** automatically added when using an
|
|
3444
|
+
agent. Run `ssh-add -l` locally to confirm which public keys are
|
|
3445
|
+
visible to the agent; these will be exposed to your build.
|
|
3446
|
+
"""
|
|
3447
|
+
pulumi.set(__self__, "id", id)
|
|
3448
|
+
if paths is not None:
|
|
3449
|
+
pulumi.set(__self__, "paths", paths)
|
|
3450
|
+
|
|
3451
|
+
@property
|
|
3452
|
+
@pulumi.getter
|
|
3453
|
+
def id(self) -> pulumi.Input[str]:
|
|
3454
|
+
"""
|
|
3455
|
+
Useful for distinguishing different servers that are part of the same
|
|
3456
|
+
build.
|
|
3457
|
+
|
|
3458
|
+
A value of `default` is appropriate if only dealing with a single host.
|
|
3459
|
+
"""
|
|
3460
|
+
return pulumi.get(self, "id")
|
|
3461
|
+
|
|
3462
|
+
@id.setter
|
|
3463
|
+
def id(self, value: pulumi.Input[str]):
|
|
3464
|
+
pulumi.set(self, "id", value)
|
|
3465
|
+
|
|
3466
|
+
@property
|
|
3467
|
+
@pulumi.getter
|
|
3468
|
+
def paths(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
|
|
3469
|
+
"""
|
|
3470
|
+
SSH agent socket or private keys to expose to the build under the given
|
|
3471
|
+
identifier.
|
|
3472
|
+
|
|
3473
|
+
Defaults to `[$SSH_AUTH_SOCK]`.
|
|
3474
|
+
|
|
3475
|
+
Note that your keys are **not** automatically added when using an
|
|
3476
|
+
agent. Run `ssh-add -l` locally to confirm which public keys are
|
|
3477
|
+
visible to the agent; these will be exposed to your build.
|
|
3478
|
+
"""
|
|
3479
|
+
return pulumi.get(self, "paths")
|
|
3480
|
+
|
|
3481
|
+
@paths.setter
|
|
3482
|
+
def paths(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
|
|
3483
|
+
pulumi.set(self, "paths", value)
|
|
3484
|
+
|
|
3485
|
+
|