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