pulumi-kubernetes-coredns 0.0.1a102__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_kubernetes_coredns/__init__.py +35 -0
- pulumi_kubernetes_coredns/_inputs.py +1942 -0
- pulumi_kubernetes_coredns/_utilities.py +327 -0
- pulumi_kubernetes_coredns/core_dns.py +687 -0
- pulumi_kubernetes_coredns/outputs.py +121 -0
- pulumi_kubernetes_coredns/provider.py +76 -0
- pulumi_kubernetes_coredns/pulumi-plugin.json +5 -0
- pulumi_kubernetes_coredns/py.typed +0 -0
- pulumi_kubernetes_coredns-0.0.1a102.dist-info/METADATA +45 -0
- pulumi_kubernetes_coredns-0.0.1a102.dist-info/RECORD +12 -0
- pulumi_kubernetes_coredns-0.0.1a102.dist-info/WHEEL +5 -0
- pulumi_kubernetes_coredns-0.0.1a102.dist-info/top_level.txt +1 -0
|
@@ -0,0 +1,1942 @@
|
|
|
1
|
+
# coding=utf-8
|
|
2
|
+
# *** WARNING: this file was generated by pulumi-language-python. ***
|
|
3
|
+
# *** Do not edit by hand unless you're certain you know what you are doing! ***
|
|
4
|
+
|
|
5
|
+
import copy
|
|
6
|
+
import warnings
|
|
7
|
+
import sys
|
|
8
|
+
import pulumi
|
|
9
|
+
import pulumi.runtime
|
|
10
|
+
from typing import Any, Mapping, Optional, Sequence, Union, overload
|
|
11
|
+
if sys.version_info >= (3, 11):
|
|
12
|
+
from typing import NotRequired, TypedDict, TypeAlias
|
|
13
|
+
else:
|
|
14
|
+
from typing_extensions import NotRequired, TypedDict, TypeAlias
|
|
15
|
+
from . import _utilities
|
|
16
|
+
import pulumi_kubernetes
|
|
17
|
+
|
|
18
|
+
__all__ = [
|
|
19
|
+
'CoreDNSAutoscalerArgs',
|
|
20
|
+
'CoreDNSAutoscalerArgsDict',
|
|
21
|
+
'CoreDNSDeploymentArgs',
|
|
22
|
+
'CoreDNSDeploymentArgsDict',
|
|
23
|
+
'CoreDNSHPAArgs',
|
|
24
|
+
'CoreDNSHPAArgsDict',
|
|
25
|
+
'CoreDNSImageArgs',
|
|
26
|
+
'CoreDNSImageArgsDict',
|
|
27
|
+
'CoreDNSPrometheusMonitorArgs',
|
|
28
|
+
'CoreDNSPrometheusMonitorArgsDict',
|
|
29
|
+
'CoreDNSPrometheusServiceArgs',
|
|
30
|
+
'CoreDNSPrometheusServiceArgsDict',
|
|
31
|
+
'CoreDNSPrometheusArgs',
|
|
32
|
+
'CoreDNSPrometheusArgsDict',
|
|
33
|
+
'CoreDNSRBACArgs',
|
|
34
|
+
'CoreDNSRBACArgsDict',
|
|
35
|
+
'CoreDNSServerPluginArgs',
|
|
36
|
+
'CoreDNSServerPluginArgsDict',
|
|
37
|
+
'CoreDNSServerZoneArgs',
|
|
38
|
+
'CoreDNSServerZoneArgsDict',
|
|
39
|
+
'CoreDNSServerArgs',
|
|
40
|
+
'CoreDNSServerArgsDict',
|
|
41
|
+
'CoreDNSServiceAccountArgs',
|
|
42
|
+
'CoreDNSServiceAccountArgsDict',
|
|
43
|
+
'CoreDNSServiceArgs',
|
|
44
|
+
'CoreDNSServiceArgsDict',
|
|
45
|
+
'CoreDNSZoneFileArgs',
|
|
46
|
+
'CoreDNSZoneFileArgsDict',
|
|
47
|
+
'ReleaseArgs',
|
|
48
|
+
'ReleaseArgsDict',
|
|
49
|
+
'RepositoryOptsArgs',
|
|
50
|
+
'RepositoryOptsArgsDict',
|
|
51
|
+
]
|
|
52
|
+
|
|
53
|
+
MYPY = False
|
|
54
|
+
|
|
55
|
+
if not MYPY:
|
|
56
|
+
class CoreDNSAutoscalerArgsDict(TypedDict):
|
|
57
|
+
cores_per_replica: NotRequired[pulumi.Input[int]]
|
|
58
|
+
"""
|
|
59
|
+
Number of cores in the cluster per coredns replica.
|
|
60
|
+
"""
|
|
61
|
+
enabled: NotRequired[pulumi.Input[bool]]
|
|
62
|
+
"""
|
|
63
|
+
Enabled the cluster-proportional-autoscaler.
|
|
64
|
+
"""
|
|
65
|
+
image: NotRequired[pulumi.Input['CoreDNSImageArgsDict']]
|
|
66
|
+
"""
|
|
67
|
+
The image to pull from for the autoscaler.
|
|
68
|
+
"""
|
|
69
|
+
include_unschedulable_nodes: NotRequired[pulumi.Input[bool]]
|
|
70
|
+
"""
|
|
71
|
+
Whether to include unschedulable nodes in the nodes/cores calculations - this requires version 1.8.0+ of the autoscaler.
|
|
72
|
+
"""
|
|
73
|
+
max: NotRequired[pulumi.Input[int]]
|
|
74
|
+
"""
|
|
75
|
+
Max size of replicaCount
|
|
76
|
+
"""
|
|
77
|
+
min: NotRequired[pulumi.Input[int]]
|
|
78
|
+
"""
|
|
79
|
+
Min size of replicaCount
|
|
80
|
+
"""
|
|
81
|
+
nodes_per_replica: NotRequired[pulumi.Input[int]]
|
|
82
|
+
"""
|
|
83
|
+
Number of nodes in the cluster per coredns replica.
|
|
84
|
+
"""
|
|
85
|
+
prevent_single_point_failure: NotRequired[pulumi.Input[bool]]
|
|
86
|
+
"""
|
|
87
|
+
If true does not allow single points of failure to form.
|
|
88
|
+
"""
|
|
89
|
+
elif False:
|
|
90
|
+
CoreDNSAutoscalerArgsDict: TypeAlias = Mapping[str, Any]
|
|
91
|
+
|
|
92
|
+
@pulumi.input_type
|
|
93
|
+
class CoreDNSAutoscalerArgs:
|
|
94
|
+
def __init__(__self__, *,
|
|
95
|
+
cores_per_replica: Optional[pulumi.Input[int]] = None,
|
|
96
|
+
enabled: Optional[pulumi.Input[bool]] = None,
|
|
97
|
+
image: Optional[pulumi.Input['CoreDNSImageArgs']] = None,
|
|
98
|
+
include_unschedulable_nodes: Optional[pulumi.Input[bool]] = None,
|
|
99
|
+
max: Optional[pulumi.Input[int]] = None,
|
|
100
|
+
min: Optional[pulumi.Input[int]] = None,
|
|
101
|
+
nodes_per_replica: Optional[pulumi.Input[int]] = None,
|
|
102
|
+
prevent_single_point_failure: Optional[pulumi.Input[bool]] = None):
|
|
103
|
+
"""
|
|
104
|
+
:param pulumi.Input[int] cores_per_replica: Number of cores in the cluster per coredns replica.
|
|
105
|
+
:param pulumi.Input[bool] enabled: Enabled the cluster-proportional-autoscaler.
|
|
106
|
+
:param pulumi.Input['CoreDNSImageArgs'] image: The image to pull from for the autoscaler.
|
|
107
|
+
:param pulumi.Input[bool] include_unschedulable_nodes: Whether to include unschedulable nodes in the nodes/cores calculations - this requires version 1.8.0+ of the autoscaler.
|
|
108
|
+
:param pulumi.Input[int] max: Max size of replicaCount
|
|
109
|
+
:param pulumi.Input[int] min: Min size of replicaCount
|
|
110
|
+
:param pulumi.Input[int] nodes_per_replica: Number of nodes in the cluster per coredns replica.
|
|
111
|
+
:param pulumi.Input[bool] prevent_single_point_failure: If true does not allow single points of failure to form.
|
|
112
|
+
"""
|
|
113
|
+
if cores_per_replica is not None:
|
|
114
|
+
pulumi.set(__self__, "cores_per_replica", cores_per_replica)
|
|
115
|
+
if enabled is not None:
|
|
116
|
+
pulumi.set(__self__, "enabled", enabled)
|
|
117
|
+
if image is not None:
|
|
118
|
+
pulumi.set(__self__, "image", image)
|
|
119
|
+
if include_unschedulable_nodes is not None:
|
|
120
|
+
pulumi.set(__self__, "include_unschedulable_nodes", include_unschedulable_nodes)
|
|
121
|
+
if max is not None:
|
|
122
|
+
pulumi.set(__self__, "max", max)
|
|
123
|
+
if min is not None:
|
|
124
|
+
pulumi.set(__self__, "min", min)
|
|
125
|
+
if nodes_per_replica is not None:
|
|
126
|
+
pulumi.set(__self__, "nodes_per_replica", nodes_per_replica)
|
|
127
|
+
if prevent_single_point_failure is not None:
|
|
128
|
+
pulumi.set(__self__, "prevent_single_point_failure", prevent_single_point_failure)
|
|
129
|
+
|
|
130
|
+
@property
|
|
131
|
+
@pulumi.getter(name="coresPerReplica")
|
|
132
|
+
def cores_per_replica(self) -> Optional[pulumi.Input[int]]:
|
|
133
|
+
"""
|
|
134
|
+
Number of cores in the cluster per coredns replica.
|
|
135
|
+
"""
|
|
136
|
+
return pulumi.get(self, "cores_per_replica")
|
|
137
|
+
|
|
138
|
+
@cores_per_replica.setter
|
|
139
|
+
def cores_per_replica(self, value: Optional[pulumi.Input[int]]):
|
|
140
|
+
pulumi.set(self, "cores_per_replica", value)
|
|
141
|
+
|
|
142
|
+
@property
|
|
143
|
+
@pulumi.getter
|
|
144
|
+
def enabled(self) -> Optional[pulumi.Input[bool]]:
|
|
145
|
+
"""
|
|
146
|
+
Enabled the cluster-proportional-autoscaler.
|
|
147
|
+
"""
|
|
148
|
+
return pulumi.get(self, "enabled")
|
|
149
|
+
|
|
150
|
+
@enabled.setter
|
|
151
|
+
def enabled(self, value: Optional[pulumi.Input[bool]]):
|
|
152
|
+
pulumi.set(self, "enabled", value)
|
|
153
|
+
|
|
154
|
+
@property
|
|
155
|
+
@pulumi.getter
|
|
156
|
+
def image(self) -> Optional[pulumi.Input['CoreDNSImageArgs']]:
|
|
157
|
+
"""
|
|
158
|
+
The image to pull from for the autoscaler.
|
|
159
|
+
"""
|
|
160
|
+
return pulumi.get(self, "image")
|
|
161
|
+
|
|
162
|
+
@image.setter
|
|
163
|
+
def image(self, value: Optional[pulumi.Input['CoreDNSImageArgs']]):
|
|
164
|
+
pulumi.set(self, "image", value)
|
|
165
|
+
|
|
166
|
+
@property
|
|
167
|
+
@pulumi.getter(name="includeUnschedulableNodes")
|
|
168
|
+
def include_unschedulable_nodes(self) -> Optional[pulumi.Input[bool]]:
|
|
169
|
+
"""
|
|
170
|
+
Whether to include unschedulable nodes in the nodes/cores calculations - this requires version 1.8.0+ of the autoscaler.
|
|
171
|
+
"""
|
|
172
|
+
return pulumi.get(self, "include_unschedulable_nodes")
|
|
173
|
+
|
|
174
|
+
@include_unschedulable_nodes.setter
|
|
175
|
+
def include_unschedulable_nodes(self, value: Optional[pulumi.Input[bool]]):
|
|
176
|
+
pulumi.set(self, "include_unschedulable_nodes", value)
|
|
177
|
+
|
|
178
|
+
@property
|
|
179
|
+
@pulumi.getter
|
|
180
|
+
def max(self) -> Optional[pulumi.Input[int]]:
|
|
181
|
+
"""
|
|
182
|
+
Max size of replicaCount
|
|
183
|
+
"""
|
|
184
|
+
return pulumi.get(self, "max")
|
|
185
|
+
|
|
186
|
+
@max.setter
|
|
187
|
+
def max(self, value: Optional[pulumi.Input[int]]):
|
|
188
|
+
pulumi.set(self, "max", value)
|
|
189
|
+
|
|
190
|
+
@property
|
|
191
|
+
@pulumi.getter
|
|
192
|
+
def min(self) -> Optional[pulumi.Input[int]]:
|
|
193
|
+
"""
|
|
194
|
+
Min size of replicaCount
|
|
195
|
+
"""
|
|
196
|
+
return pulumi.get(self, "min")
|
|
197
|
+
|
|
198
|
+
@min.setter
|
|
199
|
+
def min(self, value: Optional[pulumi.Input[int]]):
|
|
200
|
+
pulumi.set(self, "min", value)
|
|
201
|
+
|
|
202
|
+
@property
|
|
203
|
+
@pulumi.getter(name="nodesPerReplica")
|
|
204
|
+
def nodes_per_replica(self) -> Optional[pulumi.Input[int]]:
|
|
205
|
+
"""
|
|
206
|
+
Number of nodes in the cluster per coredns replica.
|
|
207
|
+
"""
|
|
208
|
+
return pulumi.get(self, "nodes_per_replica")
|
|
209
|
+
|
|
210
|
+
@nodes_per_replica.setter
|
|
211
|
+
def nodes_per_replica(self, value: Optional[pulumi.Input[int]]):
|
|
212
|
+
pulumi.set(self, "nodes_per_replica", value)
|
|
213
|
+
|
|
214
|
+
@property
|
|
215
|
+
@pulumi.getter(name="preventSinglePointFailure")
|
|
216
|
+
def prevent_single_point_failure(self) -> Optional[pulumi.Input[bool]]:
|
|
217
|
+
"""
|
|
218
|
+
If true does not allow single points of failure to form.
|
|
219
|
+
"""
|
|
220
|
+
return pulumi.get(self, "prevent_single_point_failure")
|
|
221
|
+
|
|
222
|
+
@prevent_single_point_failure.setter
|
|
223
|
+
def prevent_single_point_failure(self, value: Optional[pulumi.Input[bool]]):
|
|
224
|
+
pulumi.set(self, "prevent_single_point_failure", value)
|
|
225
|
+
|
|
226
|
+
|
|
227
|
+
if not MYPY:
|
|
228
|
+
class CoreDNSDeploymentArgsDict(TypedDict):
|
|
229
|
+
enabled: NotRequired[pulumi.Input[bool]]
|
|
230
|
+
"""
|
|
231
|
+
Optionally disable the main deployment and its respective resources.
|
|
232
|
+
"""
|
|
233
|
+
name: NotRequired[pulumi.Input[str]]
|
|
234
|
+
"""
|
|
235
|
+
Name of the deployment if deployment.enabled is true. Otherwise the name of an existing deployment for the autoscaler or HPA to target.
|
|
236
|
+
"""
|
|
237
|
+
elif False:
|
|
238
|
+
CoreDNSDeploymentArgsDict: TypeAlias = Mapping[str, Any]
|
|
239
|
+
|
|
240
|
+
@pulumi.input_type
|
|
241
|
+
class CoreDNSDeploymentArgs:
|
|
242
|
+
def __init__(__self__, *,
|
|
243
|
+
enabled: Optional[pulumi.Input[bool]] = None,
|
|
244
|
+
name: Optional[pulumi.Input[str]] = None):
|
|
245
|
+
"""
|
|
246
|
+
:param pulumi.Input[bool] enabled: Optionally disable the main deployment and its respective resources.
|
|
247
|
+
:param pulumi.Input[str] name: Name of the deployment if deployment.enabled is true. Otherwise the name of an existing deployment for the autoscaler or HPA to target.
|
|
248
|
+
"""
|
|
249
|
+
if enabled is not None:
|
|
250
|
+
pulumi.set(__self__, "enabled", enabled)
|
|
251
|
+
if name is not None:
|
|
252
|
+
pulumi.set(__self__, "name", name)
|
|
253
|
+
|
|
254
|
+
@property
|
|
255
|
+
@pulumi.getter
|
|
256
|
+
def enabled(self) -> Optional[pulumi.Input[bool]]:
|
|
257
|
+
"""
|
|
258
|
+
Optionally disable the main deployment and its respective resources.
|
|
259
|
+
"""
|
|
260
|
+
return pulumi.get(self, "enabled")
|
|
261
|
+
|
|
262
|
+
@enabled.setter
|
|
263
|
+
def enabled(self, value: Optional[pulumi.Input[bool]]):
|
|
264
|
+
pulumi.set(self, "enabled", value)
|
|
265
|
+
|
|
266
|
+
@property
|
|
267
|
+
@pulumi.getter
|
|
268
|
+
def name(self) -> Optional[pulumi.Input[str]]:
|
|
269
|
+
"""
|
|
270
|
+
Name of the deployment if deployment.enabled is true. Otherwise the name of an existing deployment for the autoscaler or HPA to target.
|
|
271
|
+
"""
|
|
272
|
+
return pulumi.get(self, "name")
|
|
273
|
+
|
|
274
|
+
@name.setter
|
|
275
|
+
def name(self, value: Optional[pulumi.Input[str]]):
|
|
276
|
+
pulumi.set(self, "name", value)
|
|
277
|
+
|
|
278
|
+
|
|
279
|
+
if not MYPY:
|
|
280
|
+
class CoreDNSHPAArgsDict(TypedDict):
|
|
281
|
+
enabled: NotRequired[pulumi.Input[bool]]
|
|
282
|
+
max_replicas: NotRequired[pulumi.Input[int]]
|
|
283
|
+
metrics: NotRequired[pulumi.Input['pulumi_kubernetes.autoscaling.v2beta2.MetricSpecArgsDict']]
|
|
284
|
+
min_replicas: NotRequired[pulumi.Input[int]]
|
|
285
|
+
elif False:
|
|
286
|
+
CoreDNSHPAArgsDict: TypeAlias = Mapping[str, Any]
|
|
287
|
+
|
|
288
|
+
@pulumi.input_type
|
|
289
|
+
class CoreDNSHPAArgs:
|
|
290
|
+
def __init__(__self__, *,
|
|
291
|
+
enabled: Optional[pulumi.Input[bool]] = None,
|
|
292
|
+
max_replicas: Optional[pulumi.Input[int]] = None,
|
|
293
|
+
metrics: Optional[pulumi.Input['pulumi_kubernetes.autoscaling.v2beta2.MetricSpecArgs']] = None,
|
|
294
|
+
min_replicas: Optional[pulumi.Input[int]] = None):
|
|
295
|
+
if enabled is not None:
|
|
296
|
+
pulumi.set(__self__, "enabled", enabled)
|
|
297
|
+
if max_replicas is not None:
|
|
298
|
+
pulumi.set(__self__, "max_replicas", max_replicas)
|
|
299
|
+
if metrics is not None:
|
|
300
|
+
pulumi.set(__self__, "metrics", metrics)
|
|
301
|
+
if min_replicas is not None:
|
|
302
|
+
pulumi.set(__self__, "min_replicas", min_replicas)
|
|
303
|
+
|
|
304
|
+
@property
|
|
305
|
+
@pulumi.getter
|
|
306
|
+
def enabled(self) -> Optional[pulumi.Input[bool]]:
|
|
307
|
+
return pulumi.get(self, "enabled")
|
|
308
|
+
|
|
309
|
+
@enabled.setter
|
|
310
|
+
def enabled(self, value: Optional[pulumi.Input[bool]]):
|
|
311
|
+
pulumi.set(self, "enabled", value)
|
|
312
|
+
|
|
313
|
+
@property
|
|
314
|
+
@pulumi.getter(name="maxReplicas")
|
|
315
|
+
def max_replicas(self) -> Optional[pulumi.Input[int]]:
|
|
316
|
+
return pulumi.get(self, "max_replicas")
|
|
317
|
+
|
|
318
|
+
@max_replicas.setter
|
|
319
|
+
def max_replicas(self, value: Optional[pulumi.Input[int]]):
|
|
320
|
+
pulumi.set(self, "max_replicas", value)
|
|
321
|
+
|
|
322
|
+
@property
|
|
323
|
+
@pulumi.getter
|
|
324
|
+
def metrics(self) -> Optional[pulumi.Input['pulumi_kubernetes.autoscaling.v2beta2.MetricSpecArgs']]:
|
|
325
|
+
return pulumi.get(self, "metrics")
|
|
326
|
+
|
|
327
|
+
@metrics.setter
|
|
328
|
+
def metrics(self, value: Optional[pulumi.Input['pulumi_kubernetes.autoscaling.v2beta2.MetricSpecArgs']]):
|
|
329
|
+
pulumi.set(self, "metrics", value)
|
|
330
|
+
|
|
331
|
+
@property
|
|
332
|
+
@pulumi.getter(name="minReplicas")
|
|
333
|
+
def min_replicas(self) -> Optional[pulumi.Input[int]]:
|
|
334
|
+
return pulumi.get(self, "min_replicas")
|
|
335
|
+
|
|
336
|
+
@min_replicas.setter
|
|
337
|
+
def min_replicas(self, value: Optional[pulumi.Input[int]]):
|
|
338
|
+
pulumi.set(self, "min_replicas", value)
|
|
339
|
+
|
|
340
|
+
|
|
341
|
+
if not MYPY:
|
|
342
|
+
class CoreDNSImageArgsDict(TypedDict):
|
|
343
|
+
pull_policy: NotRequired[pulumi.Input[str]]
|
|
344
|
+
"""
|
|
345
|
+
Image pull policy.
|
|
346
|
+
"""
|
|
347
|
+
pull_secrets: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
|
|
348
|
+
"""
|
|
349
|
+
Specify container image pull secrets.
|
|
350
|
+
"""
|
|
351
|
+
repository: NotRequired[pulumi.Input[str]]
|
|
352
|
+
"""
|
|
353
|
+
The image repository to pull from.
|
|
354
|
+
"""
|
|
355
|
+
tag: NotRequired[pulumi.Input[str]]
|
|
356
|
+
"""
|
|
357
|
+
The image tag to pull from.
|
|
358
|
+
"""
|
|
359
|
+
elif False:
|
|
360
|
+
CoreDNSImageArgsDict: TypeAlias = Mapping[str, Any]
|
|
361
|
+
|
|
362
|
+
@pulumi.input_type
|
|
363
|
+
class CoreDNSImageArgs:
|
|
364
|
+
def __init__(__self__, *,
|
|
365
|
+
pull_policy: Optional[pulumi.Input[str]] = None,
|
|
366
|
+
pull_secrets: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
|
|
367
|
+
repository: Optional[pulumi.Input[str]] = None,
|
|
368
|
+
tag: Optional[pulumi.Input[str]] = None):
|
|
369
|
+
"""
|
|
370
|
+
:param pulumi.Input[str] pull_policy: Image pull policy.
|
|
371
|
+
:param pulumi.Input[Sequence[pulumi.Input[str]]] pull_secrets: Specify container image pull secrets.
|
|
372
|
+
:param pulumi.Input[str] repository: The image repository to pull from.
|
|
373
|
+
:param pulumi.Input[str] tag: The image tag to pull from.
|
|
374
|
+
"""
|
|
375
|
+
if pull_policy is not None:
|
|
376
|
+
pulumi.set(__self__, "pull_policy", pull_policy)
|
|
377
|
+
if pull_secrets is not None:
|
|
378
|
+
pulumi.set(__self__, "pull_secrets", pull_secrets)
|
|
379
|
+
if repository is not None:
|
|
380
|
+
pulumi.set(__self__, "repository", repository)
|
|
381
|
+
if tag is not None:
|
|
382
|
+
pulumi.set(__self__, "tag", tag)
|
|
383
|
+
|
|
384
|
+
@property
|
|
385
|
+
@pulumi.getter(name="pullPolicy")
|
|
386
|
+
def pull_policy(self) -> Optional[pulumi.Input[str]]:
|
|
387
|
+
"""
|
|
388
|
+
Image pull policy.
|
|
389
|
+
"""
|
|
390
|
+
return pulumi.get(self, "pull_policy")
|
|
391
|
+
|
|
392
|
+
@pull_policy.setter
|
|
393
|
+
def pull_policy(self, value: Optional[pulumi.Input[str]]):
|
|
394
|
+
pulumi.set(self, "pull_policy", value)
|
|
395
|
+
|
|
396
|
+
@property
|
|
397
|
+
@pulumi.getter(name="pullSecrets")
|
|
398
|
+
def pull_secrets(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
|
|
399
|
+
"""
|
|
400
|
+
Specify container image pull secrets.
|
|
401
|
+
"""
|
|
402
|
+
return pulumi.get(self, "pull_secrets")
|
|
403
|
+
|
|
404
|
+
@pull_secrets.setter
|
|
405
|
+
def pull_secrets(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
|
|
406
|
+
pulumi.set(self, "pull_secrets", value)
|
|
407
|
+
|
|
408
|
+
@property
|
|
409
|
+
@pulumi.getter
|
|
410
|
+
def repository(self) -> Optional[pulumi.Input[str]]:
|
|
411
|
+
"""
|
|
412
|
+
The image repository to pull from.
|
|
413
|
+
"""
|
|
414
|
+
return pulumi.get(self, "repository")
|
|
415
|
+
|
|
416
|
+
@repository.setter
|
|
417
|
+
def repository(self, value: Optional[pulumi.Input[str]]):
|
|
418
|
+
pulumi.set(self, "repository", value)
|
|
419
|
+
|
|
420
|
+
@property
|
|
421
|
+
@pulumi.getter
|
|
422
|
+
def tag(self) -> Optional[pulumi.Input[str]]:
|
|
423
|
+
"""
|
|
424
|
+
The image tag to pull from.
|
|
425
|
+
"""
|
|
426
|
+
return pulumi.get(self, "tag")
|
|
427
|
+
|
|
428
|
+
@tag.setter
|
|
429
|
+
def tag(self, value: Optional[pulumi.Input[str]]):
|
|
430
|
+
pulumi.set(self, "tag", value)
|
|
431
|
+
|
|
432
|
+
|
|
433
|
+
if not MYPY:
|
|
434
|
+
class CoreDNSPrometheusMonitorArgsDict(TypedDict):
|
|
435
|
+
additional_labels: NotRequired[pulumi.Input[Mapping[str, pulumi.Input[str]]]]
|
|
436
|
+
"""
|
|
437
|
+
Additional labels that can be used so ServiceMonitor will be discovered by Prometheus.
|
|
438
|
+
"""
|
|
439
|
+
enabled: NotRequired[pulumi.Input[bool]]
|
|
440
|
+
"""
|
|
441
|
+
Set this to true to create ServiceMonitor for Prometheus operator.
|
|
442
|
+
"""
|
|
443
|
+
namespace: NotRequired[pulumi.Input[str]]
|
|
444
|
+
"""
|
|
445
|
+
Selector to select which namespaces the Endpoints objects are discovered from.
|
|
446
|
+
"""
|
|
447
|
+
elif False:
|
|
448
|
+
CoreDNSPrometheusMonitorArgsDict: TypeAlias = Mapping[str, Any]
|
|
449
|
+
|
|
450
|
+
@pulumi.input_type
|
|
451
|
+
class CoreDNSPrometheusMonitorArgs:
|
|
452
|
+
def __init__(__self__, *,
|
|
453
|
+
additional_labels: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None,
|
|
454
|
+
enabled: Optional[pulumi.Input[bool]] = None,
|
|
455
|
+
namespace: Optional[pulumi.Input[str]] = None):
|
|
456
|
+
"""
|
|
457
|
+
:param pulumi.Input[Mapping[str, pulumi.Input[str]]] additional_labels: Additional labels that can be used so ServiceMonitor will be discovered by Prometheus.
|
|
458
|
+
:param pulumi.Input[bool] enabled: Set this to true to create ServiceMonitor for Prometheus operator.
|
|
459
|
+
:param pulumi.Input[str] namespace: Selector to select which namespaces the Endpoints objects are discovered from.
|
|
460
|
+
"""
|
|
461
|
+
if additional_labels is not None:
|
|
462
|
+
pulumi.set(__self__, "additional_labels", additional_labels)
|
|
463
|
+
if enabled is not None:
|
|
464
|
+
pulumi.set(__self__, "enabled", enabled)
|
|
465
|
+
if namespace is not None:
|
|
466
|
+
pulumi.set(__self__, "namespace", namespace)
|
|
467
|
+
|
|
468
|
+
@property
|
|
469
|
+
@pulumi.getter(name="additionalLabels")
|
|
470
|
+
def additional_labels(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]:
|
|
471
|
+
"""
|
|
472
|
+
Additional labels that can be used so ServiceMonitor will be discovered by Prometheus.
|
|
473
|
+
"""
|
|
474
|
+
return pulumi.get(self, "additional_labels")
|
|
475
|
+
|
|
476
|
+
@additional_labels.setter
|
|
477
|
+
def additional_labels(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]):
|
|
478
|
+
pulumi.set(self, "additional_labels", value)
|
|
479
|
+
|
|
480
|
+
@property
|
|
481
|
+
@pulumi.getter
|
|
482
|
+
def enabled(self) -> Optional[pulumi.Input[bool]]:
|
|
483
|
+
"""
|
|
484
|
+
Set this to true to create ServiceMonitor for Prometheus operator.
|
|
485
|
+
"""
|
|
486
|
+
return pulumi.get(self, "enabled")
|
|
487
|
+
|
|
488
|
+
@enabled.setter
|
|
489
|
+
def enabled(self, value: Optional[pulumi.Input[bool]]):
|
|
490
|
+
pulumi.set(self, "enabled", value)
|
|
491
|
+
|
|
492
|
+
@property
|
|
493
|
+
@pulumi.getter
|
|
494
|
+
def namespace(self) -> Optional[pulumi.Input[str]]:
|
|
495
|
+
"""
|
|
496
|
+
Selector to select which namespaces the Endpoints objects are discovered from.
|
|
497
|
+
"""
|
|
498
|
+
return pulumi.get(self, "namespace")
|
|
499
|
+
|
|
500
|
+
@namespace.setter
|
|
501
|
+
def namespace(self, value: Optional[pulumi.Input[str]]):
|
|
502
|
+
pulumi.set(self, "namespace", value)
|
|
503
|
+
|
|
504
|
+
|
|
505
|
+
if not MYPY:
|
|
506
|
+
class CoreDNSPrometheusServiceArgsDict(TypedDict):
|
|
507
|
+
annotations: NotRequired[pulumi.Input[Mapping[str, pulumi.Input[str]]]]
|
|
508
|
+
"""
|
|
509
|
+
Annotations to add to the metrics Service.
|
|
510
|
+
"""
|
|
511
|
+
enabled: NotRequired[pulumi.Input[bool]]
|
|
512
|
+
"""
|
|
513
|
+
Set this to true to create Service for Prometheus metrics.
|
|
514
|
+
"""
|
|
515
|
+
elif False:
|
|
516
|
+
CoreDNSPrometheusServiceArgsDict: TypeAlias = Mapping[str, Any]
|
|
517
|
+
|
|
518
|
+
@pulumi.input_type
|
|
519
|
+
class CoreDNSPrometheusServiceArgs:
|
|
520
|
+
def __init__(__self__, *,
|
|
521
|
+
annotations: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None,
|
|
522
|
+
enabled: Optional[pulumi.Input[bool]] = None):
|
|
523
|
+
"""
|
|
524
|
+
:param pulumi.Input[Mapping[str, pulumi.Input[str]]] annotations: Annotations to add to the metrics Service.
|
|
525
|
+
:param pulumi.Input[bool] enabled: Set this to true to create Service for Prometheus metrics.
|
|
526
|
+
"""
|
|
527
|
+
if annotations is not None:
|
|
528
|
+
pulumi.set(__self__, "annotations", annotations)
|
|
529
|
+
if enabled is not None:
|
|
530
|
+
pulumi.set(__self__, "enabled", enabled)
|
|
531
|
+
|
|
532
|
+
@property
|
|
533
|
+
@pulumi.getter
|
|
534
|
+
def annotations(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]:
|
|
535
|
+
"""
|
|
536
|
+
Annotations to add to the metrics Service.
|
|
537
|
+
"""
|
|
538
|
+
return pulumi.get(self, "annotations")
|
|
539
|
+
|
|
540
|
+
@annotations.setter
|
|
541
|
+
def annotations(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]):
|
|
542
|
+
pulumi.set(self, "annotations", value)
|
|
543
|
+
|
|
544
|
+
@property
|
|
545
|
+
@pulumi.getter
|
|
546
|
+
def enabled(self) -> Optional[pulumi.Input[bool]]:
|
|
547
|
+
"""
|
|
548
|
+
Set this to true to create Service for Prometheus metrics.
|
|
549
|
+
"""
|
|
550
|
+
return pulumi.get(self, "enabled")
|
|
551
|
+
|
|
552
|
+
@enabled.setter
|
|
553
|
+
def enabled(self, value: Optional[pulumi.Input[bool]]):
|
|
554
|
+
pulumi.set(self, "enabled", value)
|
|
555
|
+
|
|
556
|
+
|
|
557
|
+
if not MYPY:
|
|
558
|
+
class CoreDNSPrometheusArgsDict(TypedDict):
|
|
559
|
+
monitor: NotRequired[pulumi.Input['CoreDNSPrometheusMonitorArgsDict']]
|
|
560
|
+
service: NotRequired[pulumi.Input['CoreDNSPrometheusServiceArgsDict']]
|
|
561
|
+
elif False:
|
|
562
|
+
CoreDNSPrometheusArgsDict: TypeAlias = Mapping[str, Any]
|
|
563
|
+
|
|
564
|
+
@pulumi.input_type
|
|
565
|
+
class CoreDNSPrometheusArgs:
|
|
566
|
+
def __init__(__self__, *,
|
|
567
|
+
monitor: Optional[pulumi.Input['CoreDNSPrometheusMonitorArgs']] = None,
|
|
568
|
+
service: Optional[pulumi.Input['CoreDNSPrometheusServiceArgs']] = None):
|
|
569
|
+
if monitor is not None:
|
|
570
|
+
pulumi.set(__self__, "monitor", monitor)
|
|
571
|
+
if service is not None:
|
|
572
|
+
pulumi.set(__self__, "service", service)
|
|
573
|
+
|
|
574
|
+
@property
|
|
575
|
+
@pulumi.getter
|
|
576
|
+
def monitor(self) -> Optional[pulumi.Input['CoreDNSPrometheusMonitorArgs']]:
|
|
577
|
+
return pulumi.get(self, "monitor")
|
|
578
|
+
|
|
579
|
+
@monitor.setter
|
|
580
|
+
def monitor(self, value: Optional[pulumi.Input['CoreDNSPrometheusMonitorArgs']]):
|
|
581
|
+
pulumi.set(self, "monitor", value)
|
|
582
|
+
|
|
583
|
+
@property
|
|
584
|
+
@pulumi.getter
|
|
585
|
+
def service(self) -> Optional[pulumi.Input['CoreDNSPrometheusServiceArgs']]:
|
|
586
|
+
return pulumi.get(self, "service")
|
|
587
|
+
|
|
588
|
+
@service.setter
|
|
589
|
+
def service(self, value: Optional[pulumi.Input['CoreDNSPrometheusServiceArgs']]):
|
|
590
|
+
pulumi.set(self, "service", value)
|
|
591
|
+
|
|
592
|
+
|
|
593
|
+
if not MYPY:
|
|
594
|
+
class CoreDNSRBACArgsDict(TypedDict):
|
|
595
|
+
create: NotRequired[pulumi.Input[bool]]
|
|
596
|
+
"""
|
|
597
|
+
If true, create & use RBAC resources
|
|
598
|
+
"""
|
|
599
|
+
name: NotRequired[pulumi.Input[str]]
|
|
600
|
+
"""
|
|
601
|
+
The name of the ServiceAccount to use. If not set and create is true, a name is generated using the fullname template.
|
|
602
|
+
"""
|
|
603
|
+
psp_enable: NotRequired[pulumi.Input[bool]]
|
|
604
|
+
"""
|
|
605
|
+
If true, create and use PodSecurityPolicy
|
|
606
|
+
"""
|
|
607
|
+
elif False:
|
|
608
|
+
CoreDNSRBACArgsDict: TypeAlias = Mapping[str, Any]
|
|
609
|
+
|
|
610
|
+
@pulumi.input_type
|
|
611
|
+
class CoreDNSRBACArgs:
|
|
612
|
+
def __init__(__self__, *,
|
|
613
|
+
create: Optional[pulumi.Input[bool]] = None,
|
|
614
|
+
name: Optional[pulumi.Input[str]] = None,
|
|
615
|
+
psp_enable: Optional[pulumi.Input[bool]] = None):
|
|
616
|
+
"""
|
|
617
|
+
:param pulumi.Input[bool] create: If true, create & use RBAC resources
|
|
618
|
+
:param pulumi.Input[str] name: The name of the ServiceAccount to use. If not set and create is true, a name is generated using the fullname template.
|
|
619
|
+
:param pulumi.Input[bool] psp_enable: If true, create and use PodSecurityPolicy
|
|
620
|
+
"""
|
|
621
|
+
if create is not None:
|
|
622
|
+
pulumi.set(__self__, "create", create)
|
|
623
|
+
if name is not None:
|
|
624
|
+
pulumi.set(__self__, "name", name)
|
|
625
|
+
if psp_enable is not None:
|
|
626
|
+
pulumi.set(__self__, "psp_enable", psp_enable)
|
|
627
|
+
|
|
628
|
+
@property
|
|
629
|
+
@pulumi.getter
|
|
630
|
+
def create(self) -> Optional[pulumi.Input[bool]]:
|
|
631
|
+
"""
|
|
632
|
+
If true, create & use RBAC resources
|
|
633
|
+
"""
|
|
634
|
+
return pulumi.get(self, "create")
|
|
635
|
+
|
|
636
|
+
@create.setter
|
|
637
|
+
def create(self, value: Optional[pulumi.Input[bool]]):
|
|
638
|
+
pulumi.set(self, "create", value)
|
|
639
|
+
|
|
640
|
+
@property
|
|
641
|
+
@pulumi.getter
|
|
642
|
+
def name(self) -> Optional[pulumi.Input[str]]:
|
|
643
|
+
"""
|
|
644
|
+
The name of the ServiceAccount to use. If not set and create is true, a name is generated using the fullname template.
|
|
645
|
+
"""
|
|
646
|
+
return pulumi.get(self, "name")
|
|
647
|
+
|
|
648
|
+
@name.setter
|
|
649
|
+
def name(self, value: Optional[pulumi.Input[str]]):
|
|
650
|
+
pulumi.set(self, "name", value)
|
|
651
|
+
|
|
652
|
+
@property
|
|
653
|
+
@pulumi.getter(name="pspEnable")
|
|
654
|
+
def psp_enable(self) -> Optional[pulumi.Input[bool]]:
|
|
655
|
+
"""
|
|
656
|
+
If true, create and use PodSecurityPolicy
|
|
657
|
+
"""
|
|
658
|
+
return pulumi.get(self, "psp_enable")
|
|
659
|
+
|
|
660
|
+
@psp_enable.setter
|
|
661
|
+
def psp_enable(self, value: Optional[pulumi.Input[bool]]):
|
|
662
|
+
pulumi.set(self, "psp_enable", value)
|
|
663
|
+
|
|
664
|
+
|
|
665
|
+
if not MYPY:
|
|
666
|
+
class CoreDNSServerPluginArgsDict(TypedDict):
|
|
667
|
+
config_block: NotRequired[pulumi.Input[str]]
|
|
668
|
+
"""
|
|
669
|
+
if the plugin supports extra block style config, supply it here
|
|
670
|
+
"""
|
|
671
|
+
name: NotRequired[pulumi.Input[str]]
|
|
672
|
+
"""
|
|
673
|
+
name of plugin, if used multiple times ensure that the plugin supports it!
|
|
674
|
+
"""
|
|
675
|
+
parameters: NotRequired[pulumi.Input[str]]
|
|
676
|
+
"""
|
|
677
|
+
list of parameters after the plugin
|
|
678
|
+
"""
|
|
679
|
+
elif False:
|
|
680
|
+
CoreDNSServerPluginArgsDict: TypeAlias = Mapping[str, Any]
|
|
681
|
+
|
|
682
|
+
@pulumi.input_type
|
|
683
|
+
class CoreDNSServerPluginArgs:
|
|
684
|
+
def __init__(__self__, *,
|
|
685
|
+
config_block: Optional[pulumi.Input[str]] = None,
|
|
686
|
+
name: Optional[pulumi.Input[str]] = None,
|
|
687
|
+
parameters: Optional[pulumi.Input[str]] = None):
|
|
688
|
+
"""
|
|
689
|
+
:param pulumi.Input[str] config_block: if the plugin supports extra block style config, supply it here
|
|
690
|
+
:param pulumi.Input[str] name: name of plugin, if used multiple times ensure that the plugin supports it!
|
|
691
|
+
:param pulumi.Input[str] parameters: list of parameters after the plugin
|
|
692
|
+
"""
|
|
693
|
+
if config_block is not None:
|
|
694
|
+
pulumi.set(__self__, "config_block", config_block)
|
|
695
|
+
if name is not None:
|
|
696
|
+
pulumi.set(__self__, "name", name)
|
|
697
|
+
if parameters is not None:
|
|
698
|
+
pulumi.set(__self__, "parameters", parameters)
|
|
699
|
+
|
|
700
|
+
@property
|
|
701
|
+
@pulumi.getter(name="configBlock")
|
|
702
|
+
def config_block(self) -> Optional[pulumi.Input[str]]:
|
|
703
|
+
"""
|
|
704
|
+
if the plugin supports extra block style config, supply it here
|
|
705
|
+
"""
|
|
706
|
+
return pulumi.get(self, "config_block")
|
|
707
|
+
|
|
708
|
+
@config_block.setter
|
|
709
|
+
def config_block(self, value: Optional[pulumi.Input[str]]):
|
|
710
|
+
pulumi.set(self, "config_block", value)
|
|
711
|
+
|
|
712
|
+
@property
|
|
713
|
+
@pulumi.getter
|
|
714
|
+
def name(self) -> Optional[pulumi.Input[str]]:
|
|
715
|
+
"""
|
|
716
|
+
name of plugin, if used multiple times ensure that the plugin supports it!
|
|
717
|
+
"""
|
|
718
|
+
return pulumi.get(self, "name")
|
|
719
|
+
|
|
720
|
+
@name.setter
|
|
721
|
+
def name(self, value: Optional[pulumi.Input[str]]):
|
|
722
|
+
pulumi.set(self, "name", value)
|
|
723
|
+
|
|
724
|
+
@property
|
|
725
|
+
@pulumi.getter
|
|
726
|
+
def parameters(self) -> Optional[pulumi.Input[str]]:
|
|
727
|
+
"""
|
|
728
|
+
list of parameters after the plugin
|
|
729
|
+
"""
|
|
730
|
+
return pulumi.get(self, "parameters")
|
|
731
|
+
|
|
732
|
+
@parameters.setter
|
|
733
|
+
def parameters(self, value: Optional[pulumi.Input[str]]):
|
|
734
|
+
pulumi.set(self, "parameters", value)
|
|
735
|
+
|
|
736
|
+
|
|
737
|
+
if not MYPY:
|
|
738
|
+
class CoreDNSServerZoneArgsDict(TypedDict):
|
|
739
|
+
scheme: NotRequired[pulumi.Input[str]]
|
|
740
|
+
"""
|
|
741
|
+
optional, defaults to "" (which equals "dns://" in CoreDNS)
|
|
742
|
+
"""
|
|
743
|
+
use_tcp: NotRequired[pulumi.Input[bool]]
|
|
744
|
+
"""
|
|
745
|
+
set this parameter to optionally expose the port on tcp as well as udp for the DNS protocol. Note that this will not work if you are also exposing tls or grpc on the same server.
|
|
746
|
+
"""
|
|
747
|
+
zone: NotRequired[pulumi.Input[str]]
|
|
748
|
+
"""
|
|
749
|
+
optional, defaults to "."
|
|
750
|
+
"""
|
|
751
|
+
elif False:
|
|
752
|
+
CoreDNSServerZoneArgsDict: TypeAlias = Mapping[str, Any]
|
|
753
|
+
|
|
754
|
+
@pulumi.input_type
|
|
755
|
+
class CoreDNSServerZoneArgs:
|
|
756
|
+
def __init__(__self__, *,
|
|
757
|
+
scheme: Optional[pulumi.Input[str]] = None,
|
|
758
|
+
use_tcp: Optional[pulumi.Input[bool]] = None,
|
|
759
|
+
zone: Optional[pulumi.Input[str]] = None):
|
|
760
|
+
"""
|
|
761
|
+
:param pulumi.Input[str] scheme: optional, defaults to "" (which equals "dns://" in CoreDNS)
|
|
762
|
+
:param pulumi.Input[bool] use_tcp: set this parameter to optionally expose the port on tcp as well as udp for the DNS protocol. Note that this will not work if you are also exposing tls or grpc on the same server.
|
|
763
|
+
:param pulumi.Input[str] zone: optional, defaults to "."
|
|
764
|
+
"""
|
|
765
|
+
if scheme is not None:
|
|
766
|
+
pulumi.set(__self__, "scheme", scheme)
|
|
767
|
+
if use_tcp is not None:
|
|
768
|
+
pulumi.set(__self__, "use_tcp", use_tcp)
|
|
769
|
+
if zone is not None:
|
|
770
|
+
pulumi.set(__self__, "zone", zone)
|
|
771
|
+
|
|
772
|
+
@property
|
|
773
|
+
@pulumi.getter
|
|
774
|
+
def scheme(self) -> Optional[pulumi.Input[str]]:
|
|
775
|
+
"""
|
|
776
|
+
optional, defaults to "" (which equals "dns://" in CoreDNS)
|
|
777
|
+
"""
|
|
778
|
+
return pulumi.get(self, "scheme")
|
|
779
|
+
|
|
780
|
+
@scheme.setter
|
|
781
|
+
def scheme(self, value: Optional[pulumi.Input[str]]):
|
|
782
|
+
pulumi.set(self, "scheme", value)
|
|
783
|
+
|
|
784
|
+
@property
|
|
785
|
+
@pulumi.getter
|
|
786
|
+
def use_tcp(self) -> Optional[pulumi.Input[bool]]:
|
|
787
|
+
"""
|
|
788
|
+
set this parameter to optionally expose the port on tcp as well as udp for the DNS protocol. Note that this will not work if you are also exposing tls or grpc on the same server.
|
|
789
|
+
"""
|
|
790
|
+
return pulumi.get(self, "use_tcp")
|
|
791
|
+
|
|
792
|
+
@use_tcp.setter
|
|
793
|
+
def use_tcp(self, value: Optional[pulumi.Input[bool]]):
|
|
794
|
+
pulumi.set(self, "use_tcp", value)
|
|
795
|
+
|
|
796
|
+
@property
|
|
797
|
+
@pulumi.getter
|
|
798
|
+
def zone(self) -> Optional[pulumi.Input[str]]:
|
|
799
|
+
"""
|
|
800
|
+
optional, defaults to "."
|
|
801
|
+
"""
|
|
802
|
+
return pulumi.get(self, "zone")
|
|
803
|
+
|
|
804
|
+
@zone.setter
|
|
805
|
+
def zone(self, value: Optional[pulumi.Input[str]]):
|
|
806
|
+
pulumi.set(self, "zone", value)
|
|
807
|
+
|
|
808
|
+
|
|
809
|
+
if not MYPY:
|
|
810
|
+
class CoreDNSServerArgsDict(TypedDict):
|
|
811
|
+
plugins: NotRequired[pulumi.Input[Sequence[pulumi.Input['CoreDNSServerPluginArgsDict']]]]
|
|
812
|
+
"""
|
|
813
|
+
the plugins to use for this server block.
|
|
814
|
+
"""
|
|
815
|
+
port: NotRequired[pulumi.Input[int]]
|
|
816
|
+
"""
|
|
817
|
+
optional, defaults to "" (which equals 53 in CoreDNS).
|
|
818
|
+
"""
|
|
819
|
+
zones: NotRequired[pulumi.Input[Sequence[pulumi.Input['CoreDNSServerZoneArgsDict']]]]
|
|
820
|
+
"""
|
|
821
|
+
the `zones` block can be left out entirely, defaults to "."
|
|
822
|
+
"""
|
|
823
|
+
elif False:
|
|
824
|
+
CoreDNSServerArgsDict: TypeAlias = Mapping[str, Any]
|
|
825
|
+
|
|
826
|
+
@pulumi.input_type
|
|
827
|
+
class CoreDNSServerArgs:
|
|
828
|
+
def __init__(__self__, *,
|
|
829
|
+
plugins: Optional[pulumi.Input[Sequence[pulumi.Input['CoreDNSServerPluginArgs']]]] = None,
|
|
830
|
+
port: Optional[pulumi.Input[int]] = None,
|
|
831
|
+
zones: Optional[pulumi.Input[Sequence[pulumi.Input['CoreDNSServerZoneArgs']]]] = None):
|
|
832
|
+
"""
|
|
833
|
+
:param pulumi.Input[Sequence[pulumi.Input['CoreDNSServerPluginArgs']]] plugins: the plugins to use for this server block.
|
|
834
|
+
:param pulumi.Input[int] port: optional, defaults to "" (which equals 53 in CoreDNS).
|
|
835
|
+
:param pulumi.Input[Sequence[pulumi.Input['CoreDNSServerZoneArgs']]] zones: the `zones` block can be left out entirely, defaults to "."
|
|
836
|
+
"""
|
|
837
|
+
if plugins is not None:
|
|
838
|
+
pulumi.set(__self__, "plugins", plugins)
|
|
839
|
+
if port is not None:
|
|
840
|
+
pulumi.set(__self__, "port", port)
|
|
841
|
+
if zones is not None:
|
|
842
|
+
pulumi.set(__self__, "zones", zones)
|
|
843
|
+
|
|
844
|
+
@property
|
|
845
|
+
@pulumi.getter
|
|
846
|
+
def plugins(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['CoreDNSServerPluginArgs']]]]:
|
|
847
|
+
"""
|
|
848
|
+
the plugins to use for this server block.
|
|
849
|
+
"""
|
|
850
|
+
return pulumi.get(self, "plugins")
|
|
851
|
+
|
|
852
|
+
@plugins.setter
|
|
853
|
+
def plugins(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['CoreDNSServerPluginArgs']]]]):
|
|
854
|
+
pulumi.set(self, "plugins", value)
|
|
855
|
+
|
|
856
|
+
@property
|
|
857
|
+
@pulumi.getter
|
|
858
|
+
def port(self) -> Optional[pulumi.Input[int]]:
|
|
859
|
+
"""
|
|
860
|
+
optional, defaults to "" (which equals 53 in CoreDNS).
|
|
861
|
+
"""
|
|
862
|
+
return pulumi.get(self, "port")
|
|
863
|
+
|
|
864
|
+
@port.setter
|
|
865
|
+
def port(self, value: Optional[pulumi.Input[int]]):
|
|
866
|
+
pulumi.set(self, "port", value)
|
|
867
|
+
|
|
868
|
+
@property
|
|
869
|
+
@pulumi.getter
|
|
870
|
+
def zones(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['CoreDNSServerZoneArgs']]]]:
|
|
871
|
+
"""
|
|
872
|
+
the `zones` block can be left out entirely, defaults to "."
|
|
873
|
+
"""
|
|
874
|
+
return pulumi.get(self, "zones")
|
|
875
|
+
|
|
876
|
+
@zones.setter
|
|
877
|
+
def zones(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['CoreDNSServerZoneArgs']]]]):
|
|
878
|
+
pulumi.set(self, "zones", value)
|
|
879
|
+
|
|
880
|
+
|
|
881
|
+
if not MYPY:
|
|
882
|
+
class CoreDNSServiceAccountArgsDict(TypedDict):
|
|
883
|
+
annotations: NotRequired[pulumi.Input[Mapping[str, pulumi.Input[str]]]]
|
|
884
|
+
create: NotRequired[pulumi.Input[bool]]
|
|
885
|
+
"""
|
|
886
|
+
If true, create & use serviceAccount.
|
|
887
|
+
"""
|
|
888
|
+
name: NotRequired[pulumi.Input[str]]
|
|
889
|
+
"""
|
|
890
|
+
The name of the ServiceAccount to use. If not set and create is true, a name is generated using the fullname template
|
|
891
|
+
"""
|
|
892
|
+
elif False:
|
|
893
|
+
CoreDNSServiceAccountArgsDict: TypeAlias = Mapping[str, Any]
|
|
894
|
+
|
|
895
|
+
@pulumi.input_type
|
|
896
|
+
class CoreDNSServiceAccountArgs:
|
|
897
|
+
def __init__(__self__, *,
|
|
898
|
+
annotations: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None,
|
|
899
|
+
create: Optional[pulumi.Input[bool]] = None,
|
|
900
|
+
name: Optional[pulumi.Input[str]] = None):
|
|
901
|
+
"""
|
|
902
|
+
:param pulumi.Input[bool] create: If true, create & use serviceAccount.
|
|
903
|
+
:param pulumi.Input[str] name: The name of the ServiceAccount to use. If not set and create is true, a name is generated using the fullname template
|
|
904
|
+
"""
|
|
905
|
+
if annotations is not None:
|
|
906
|
+
pulumi.set(__self__, "annotations", annotations)
|
|
907
|
+
if create is not None:
|
|
908
|
+
pulumi.set(__self__, "create", create)
|
|
909
|
+
if name is not None:
|
|
910
|
+
pulumi.set(__self__, "name", name)
|
|
911
|
+
|
|
912
|
+
@property
|
|
913
|
+
@pulumi.getter
|
|
914
|
+
def annotations(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]:
|
|
915
|
+
return pulumi.get(self, "annotations")
|
|
916
|
+
|
|
917
|
+
@annotations.setter
|
|
918
|
+
def annotations(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]):
|
|
919
|
+
pulumi.set(self, "annotations", value)
|
|
920
|
+
|
|
921
|
+
@property
|
|
922
|
+
@pulumi.getter
|
|
923
|
+
def create(self) -> Optional[pulumi.Input[bool]]:
|
|
924
|
+
"""
|
|
925
|
+
If true, create & use serviceAccount.
|
|
926
|
+
"""
|
|
927
|
+
return pulumi.get(self, "create")
|
|
928
|
+
|
|
929
|
+
@create.setter
|
|
930
|
+
def create(self, value: Optional[pulumi.Input[bool]]):
|
|
931
|
+
pulumi.set(self, "create", value)
|
|
932
|
+
|
|
933
|
+
@property
|
|
934
|
+
@pulumi.getter
|
|
935
|
+
def name(self) -> Optional[pulumi.Input[str]]:
|
|
936
|
+
"""
|
|
937
|
+
The name of the ServiceAccount to use. If not set and create is true, a name is generated using the fullname template
|
|
938
|
+
"""
|
|
939
|
+
return pulumi.get(self, "name")
|
|
940
|
+
|
|
941
|
+
@name.setter
|
|
942
|
+
def name(self, value: Optional[pulumi.Input[str]]):
|
|
943
|
+
pulumi.set(self, "name", value)
|
|
944
|
+
|
|
945
|
+
|
|
946
|
+
if not MYPY:
|
|
947
|
+
class CoreDNSServiceArgsDict(TypedDict):
|
|
948
|
+
annotations: NotRequired[pulumi.Input[Mapping[str, pulumi.Input[str]]]]
|
|
949
|
+
"""
|
|
950
|
+
Annotations to add to service.
|
|
951
|
+
"""
|
|
952
|
+
cluster_ip: NotRequired[pulumi.Input[str]]
|
|
953
|
+
"""
|
|
954
|
+
IP address to assign to service.
|
|
955
|
+
"""
|
|
956
|
+
external_ips: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
|
|
957
|
+
"""
|
|
958
|
+
External IP addresses.
|
|
959
|
+
"""
|
|
960
|
+
external_traffic_policy: NotRequired[pulumi.Input[str]]
|
|
961
|
+
"""
|
|
962
|
+
Enable client source IP preservation.
|
|
963
|
+
"""
|
|
964
|
+
load_balancer_ip: NotRequired[pulumi.Input[str]]
|
|
965
|
+
"""
|
|
966
|
+
IP address to assign to load balancer (if supported).
|
|
967
|
+
"""
|
|
968
|
+
name: NotRequired[pulumi.Input[str]]
|
|
969
|
+
"""
|
|
970
|
+
The name of the Service. If not set, a name is generated using the fullname template.
|
|
971
|
+
"""
|
|
972
|
+
elif False:
|
|
973
|
+
CoreDNSServiceArgsDict: TypeAlias = Mapping[str, Any]
|
|
974
|
+
|
|
975
|
+
@pulumi.input_type
|
|
976
|
+
class CoreDNSServiceArgs:
|
|
977
|
+
def __init__(__self__, *,
|
|
978
|
+
annotations: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None,
|
|
979
|
+
cluster_ip: Optional[pulumi.Input[str]] = None,
|
|
980
|
+
external_ips: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
|
|
981
|
+
external_traffic_policy: Optional[pulumi.Input[str]] = None,
|
|
982
|
+
load_balancer_ip: Optional[pulumi.Input[str]] = None,
|
|
983
|
+
name: Optional[pulumi.Input[str]] = None):
|
|
984
|
+
"""
|
|
985
|
+
:param pulumi.Input[Mapping[str, pulumi.Input[str]]] annotations: Annotations to add to service.
|
|
986
|
+
:param pulumi.Input[str] cluster_ip: IP address to assign to service.
|
|
987
|
+
:param pulumi.Input[Sequence[pulumi.Input[str]]] external_ips: External IP addresses.
|
|
988
|
+
:param pulumi.Input[str] external_traffic_policy: Enable client source IP preservation.
|
|
989
|
+
:param pulumi.Input[str] load_balancer_ip: IP address to assign to load balancer (if supported).
|
|
990
|
+
:param pulumi.Input[str] name: The name of the Service. If not set, a name is generated using the fullname template.
|
|
991
|
+
"""
|
|
992
|
+
if annotations is not None:
|
|
993
|
+
pulumi.set(__self__, "annotations", annotations)
|
|
994
|
+
if cluster_ip is not None:
|
|
995
|
+
pulumi.set(__self__, "cluster_ip", cluster_ip)
|
|
996
|
+
if external_ips is not None:
|
|
997
|
+
pulumi.set(__self__, "external_ips", external_ips)
|
|
998
|
+
if external_traffic_policy is not None:
|
|
999
|
+
pulumi.set(__self__, "external_traffic_policy", external_traffic_policy)
|
|
1000
|
+
if load_balancer_ip is not None:
|
|
1001
|
+
pulumi.set(__self__, "load_balancer_ip", load_balancer_ip)
|
|
1002
|
+
if name is not None:
|
|
1003
|
+
pulumi.set(__self__, "name", name)
|
|
1004
|
+
|
|
1005
|
+
@property
|
|
1006
|
+
@pulumi.getter
|
|
1007
|
+
def annotations(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]:
|
|
1008
|
+
"""
|
|
1009
|
+
Annotations to add to service.
|
|
1010
|
+
"""
|
|
1011
|
+
return pulumi.get(self, "annotations")
|
|
1012
|
+
|
|
1013
|
+
@annotations.setter
|
|
1014
|
+
def annotations(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]):
|
|
1015
|
+
pulumi.set(self, "annotations", value)
|
|
1016
|
+
|
|
1017
|
+
@property
|
|
1018
|
+
@pulumi.getter(name="clusterIP")
|
|
1019
|
+
def cluster_ip(self) -> Optional[pulumi.Input[str]]:
|
|
1020
|
+
"""
|
|
1021
|
+
IP address to assign to service.
|
|
1022
|
+
"""
|
|
1023
|
+
return pulumi.get(self, "cluster_ip")
|
|
1024
|
+
|
|
1025
|
+
@cluster_ip.setter
|
|
1026
|
+
def cluster_ip(self, value: Optional[pulumi.Input[str]]):
|
|
1027
|
+
pulumi.set(self, "cluster_ip", value)
|
|
1028
|
+
|
|
1029
|
+
@property
|
|
1030
|
+
@pulumi.getter(name="externalIPs")
|
|
1031
|
+
def external_ips(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
|
|
1032
|
+
"""
|
|
1033
|
+
External IP addresses.
|
|
1034
|
+
"""
|
|
1035
|
+
return pulumi.get(self, "external_ips")
|
|
1036
|
+
|
|
1037
|
+
@external_ips.setter
|
|
1038
|
+
def external_ips(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
|
|
1039
|
+
pulumi.set(self, "external_ips", value)
|
|
1040
|
+
|
|
1041
|
+
@property
|
|
1042
|
+
@pulumi.getter(name="externalTrafficPolicy")
|
|
1043
|
+
def external_traffic_policy(self) -> Optional[pulumi.Input[str]]:
|
|
1044
|
+
"""
|
|
1045
|
+
Enable client source IP preservation.
|
|
1046
|
+
"""
|
|
1047
|
+
return pulumi.get(self, "external_traffic_policy")
|
|
1048
|
+
|
|
1049
|
+
@external_traffic_policy.setter
|
|
1050
|
+
def external_traffic_policy(self, value: Optional[pulumi.Input[str]]):
|
|
1051
|
+
pulumi.set(self, "external_traffic_policy", value)
|
|
1052
|
+
|
|
1053
|
+
@property
|
|
1054
|
+
@pulumi.getter(name="loadBalancerIP")
|
|
1055
|
+
def load_balancer_ip(self) -> Optional[pulumi.Input[str]]:
|
|
1056
|
+
"""
|
|
1057
|
+
IP address to assign to load balancer (if supported).
|
|
1058
|
+
"""
|
|
1059
|
+
return pulumi.get(self, "load_balancer_ip")
|
|
1060
|
+
|
|
1061
|
+
@load_balancer_ip.setter
|
|
1062
|
+
def load_balancer_ip(self, value: Optional[pulumi.Input[str]]):
|
|
1063
|
+
pulumi.set(self, "load_balancer_ip", value)
|
|
1064
|
+
|
|
1065
|
+
@property
|
|
1066
|
+
@pulumi.getter
|
|
1067
|
+
def name(self) -> Optional[pulumi.Input[str]]:
|
|
1068
|
+
"""
|
|
1069
|
+
The name of the Service. If not set, a name is generated using the fullname template.
|
|
1070
|
+
"""
|
|
1071
|
+
return pulumi.get(self, "name")
|
|
1072
|
+
|
|
1073
|
+
@name.setter
|
|
1074
|
+
def name(self, value: Optional[pulumi.Input[str]]):
|
|
1075
|
+
pulumi.set(self, "name", value)
|
|
1076
|
+
|
|
1077
|
+
|
|
1078
|
+
if not MYPY:
|
|
1079
|
+
class CoreDNSZoneFileArgsDict(TypedDict):
|
|
1080
|
+
contents: NotRequired[pulumi.Input[str]]
|
|
1081
|
+
domain: NotRequired[pulumi.Input[str]]
|
|
1082
|
+
string: NotRequired[pulumi.Input[str]]
|
|
1083
|
+
elif False:
|
|
1084
|
+
CoreDNSZoneFileArgsDict: TypeAlias = Mapping[str, Any]
|
|
1085
|
+
|
|
1086
|
+
@pulumi.input_type
|
|
1087
|
+
class CoreDNSZoneFileArgs:
|
|
1088
|
+
def __init__(__self__, *,
|
|
1089
|
+
contents: Optional[pulumi.Input[str]] = None,
|
|
1090
|
+
domain: Optional[pulumi.Input[str]] = None,
|
|
1091
|
+
string: Optional[pulumi.Input[str]] = None):
|
|
1092
|
+
if contents is not None:
|
|
1093
|
+
pulumi.set(__self__, "contents", contents)
|
|
1094
|
+
if domain is not None:
|
|
1095
|
+
pulumi.set(__self__, "domain", domain)
|
|
1096
|
+
if string is not None:
|
|
1097
|
+
pulumi.set(__self__, "string", string)
|
|
1098
|
+
|
|
1099
|
+
@property
|
|
1100
|
+
@pulumi.getter
|
|
1101
|
+
def contents(self) -> Optional[pulumi.Input[str]]:
|
|
1102
|
+
return pulumi.get(self, "contents")
|
|
1103
|
+
|
|
1104
|
+
@contents.setter
|
|
1105
|
+
def contents(self, value: Optional[pulumi.Input[str]]):
|
|
1106
|
+
pulumi.set(self, "contents", value)
|
|
1107
|
+
|
|
1108
|
+
@property
|
|
1109
|
+
@pulumi.getter
|
|
1110
|
+
def domain(self) -> Optional[pulumi.Input[str]]:
|
|
1111
|
+
return pulumi.get(self, "domain")
|
|
1112
|
+
|
|
1113
|
+
@domain.setter
|
|
1114
|
+
def domain(self, value: Optional[pulumi.Input[str]]):
|
|
1115
|
+
pulumi.set(self, "domain", value)
|
|
1116
|
+
|
|
1117
|
+
@property
|
|
1118
|
+
@pulumi.getter
|
|
1119
|
+
def string(self) -> Optional[pulumi.Input[str]]:
|
|
1120
|
+
return pulumi.get(self, "string")
|
|
1121
|
+
|
|
1122
|
+
@string.setter
|
|
1123
|
+
def string(self, value: Optional[pulumi.Input[str]]):
|
|
1124
|
+
pulumi.set(self, "string", value)
|
|
1125
|
+
|
|
1126
|
+
|
|
1127
|
+
if not MYPY:
|
|
1128
|
+
class ReleaseArgsDict(TypedDict):
|
|
1129
|
+
"""
|
|
1130
|
+
A Release is an instance of a chart running in a Kubernetes cluster.
|
|
1131
|
+
A Chart is a Helm package. It contains all of the resource definitions necessary to run an application, tool, or service inside of a Kubernetes cluster.
|
|
1132
|
+
Note - Helm Release is currently in BETA and may change. Use in production environment is discouraged.
|
|
1133
|
+
"""
|
|
1134
|
+
atomic: NotRequired[pulumi.Input[bool]]
|
|
1135
|
+
"""
|
|
1136
|
+
If set, installation process purges chart on fail. `skipAwait` will be disabled automatically if atomic is used.
|
|
1137
|
+
"""
|
|
1138
|
+
chart: NotRequired[pulumi.Input[str]]
|
|
1139
|
+
"""
|
|
1140
|
+
Chart name to be installed. A path may be used.
|
|
1141
|
+
"""
|
|
1142
|
+
cleanup_on_fail: NotRequired[pulumi.Input[bool]]
|
|
1143
|
+
"""
|
|
1144
|
+
Allow deletion of new resources created in this upgrade when upgrade fails.
|
|
1145
|
+
"""
|
|
1146
|
+
create_namespace: NotRequired[pulumi.Input[bool]]
|
|
1147
|
+
"""
|
|
1148
|
+
Create the namespace if it does not exist.
|
|
1149
|
+
"""
|
|
1150
|
+
dependency_update: NotRequired[pulumi.Input[bool]]
|
|
1151
|
+
"""
|
|
1152
|
+
Run helm dependency update before installing the chart.
|
|
1153
|
+
"""
|
|
1154
|
+
description: NotRequired[pulumi.Input[str]]
|
|
1155
|
+
"""
|
|
1156
|
+
Add a custom description
|
|
1157
|
+
"""
|
|
1158
|
+
devel: NotRequired[pulumi.Input[bool]]
|
|
1159
|
+
"""
|
|
1160
|
+
Use chart development versions, too. Equivalent to version '>0.0.0-0'. If `version` is set, this is ignored.
|
|
1161
|
+
"""
|
|
1162
|
+
disable_crd_hooks: NotRequired[pulumi.Input[bool]]
|
|
1163
|
+
"""
|
|
1164
|
+
Prevent CRD hooks from, running, but run other hooks. See helm install --no-crd-hook
|
|
1165
|
+
"""
|
|
1166
|
+
disable_openapi_validation: NotRequired[pulumi.Input[bool]]
|
|
1167
|
+
"""
|
|
1168
|
+
If set, the installation process will not validate rendered templates against the Kubernetes OpenAPI Schema
|
|
1169
|
+
"""
|
|
1170
|
+
disable_webhooks: NotRequired[pulumi.Input[bool]]
|
|
1171
|
+
"""
|
|
1172
|
+
Prevent hooks from running.
|
|
1173
|
+
"""
|
|
1174
|
+
force_update: NotRequired[pulumi.Input[bool]]
|
|
1175
|
+
"""
|
|
1176
|
+
Force resource update through delete/recreate if needed.
|
|
1177
|
+
"""
|
|
1178
|
+
keyring: NotRequired[pulumi.Input[str]]
|
|
1179
|
+
"""
|
|
1180
|
+
Location of public keys used for verification. Used only if `verify` is true
|
|
1181
|
+
"""
|
|
1182
|
+
lint: NotRequired[pulumi.Input[bool]]
|
|
1183
|
+
"""
|
|
1184
|
+
Run helm lint when planning.
|
|
1185
|
+
"""
|
|
1186
|
+
manifest: NotRequired[pulumi.Input[Mapping[str, Any]]]
|
|
1187
|
+
"""
|
|
1188
|
+
The rendered manifests as JSON. Not yet supported.
|
|
1189
|
+
"""
|
|
1190
|
+
max_history: NotRequired[pulumi.Input[int]]
|
|
1191
|
+
"""
|
|
1192
|
+
Limit the maximum number of revisions saved per release. Use 0 for no limit.
|
|
1193
|
+
"""
|
|
1194
|
+
name: NotRequired[pulumi.Input[str]]
|
|
1195
|
+
"""
|
|
1196
|
+
Release name.
|
|
1197
|
+
"""
|
|
1198
|
+
namespace: NotRequired[pulumi.Input[str]]
|
|
1199
|
+
"""
|
|
1200
|
+
Namespace to install the release into.
|
|
1201
|
+
"""
|
|
1202
|
+
postrender: NotRequired[pulumi.Input[str]]
|
|
1203
|
+
"""
|
|
1204
|
+
Postrender command to run.
|
|
1205
|
+
"""
|
|
1206
|
+
recreate_pods: NotRequired[pulumi.Input[bool]]
|
|
1207
|
+
"""
|
|
1208
|
+
Perform pods restart during upgrade/rollback.
|
|
1209
|
+
"""
|
|
1210
|
+
render_subchart_notes: NotRequired[pulumi.Input[bool]]
|
|
1211
|
+
"""
|
|
1212
|
+
If set, render subchart notes along with the parent.
|
|
1213
|
+
"""
|
|
1214
|
+
replace: NotRequired[pulumi.Input[bool]]
|
|
1215
|
+
"""
|
|
1216
|
+
Re-use the given name, even if that name is already used. This is unsafe in production
|
|
1217
|
+
"""
|
|
1218
|
+
repository_opts: NotRequired[pulumi.Input['RepositoryOptsArgsDict']]
|
|
1219
|
+
"""
|
|
1220
|
+
Specification defining the Helm chart repository to use.
|
|
1221
|
+
"""
|
|
1222
|
+
reset_values: NotRequired[pulumi.Input[bool]]
|
|
1223
|
+
"""
|
|
1224
|
+
When upgrading, reset the values to the ones built into the chart.
|
|
1225
|
+
"""
|
|
1226
|
+
resource_names: NotRequired[pulumi.Input[Mapping[str, pulumi.Input[Sequence[pulumi.Input[str]]]]]]
|
|
1227
|
+
"""
|
|
1228
|
+
Names of resources created by the release grouped by "kind/version".
|
|
1229
|
+
"""
|
|
1230
|
+
reuse_values: NotRequired[pulumi.Input[bool]]
|
|
1231
|
+
"""
|
|
1232
|
+
When upgrading, reuse the last release's values and merge in any overrides. If 'resetValues' is specified, this is ignored
|
|
1233
|
+
"""
|
|
1234
|
+
skip_await: NotRequired[pulumi.Input[bool]]
|
|
1235
|
+
"""
|
|
1236
|
+
By default, the provider waits until all resources are in a ready state before marking the release as successful. Setting this to true will skip such await logic.
|
|
1237
|
+
"""
|
|
1238
|
+
skip_crds: NotRequired[pulumi.Input[bool]]
|
|
1239
|
+
"""
|
|
1240
|
+
If set, no CRDs will be installed. By default, CRDs are installed if not already present.
|
|
1241
|
+
"""
|
|
1242
|
+
timeout: NotRequired[pulumi.Input[int]]
|
|
1243
|
+
"""
|
|
1244
|
+
Time in seconds to wait for any individual kubernetes operation.
|
|
1245
|
+
"""
|
|
1246
|
+
value_yaml_files: NotRequired[pulumi.Input[Sequence[pulumi.Input[Union[pulumi.Asset, pulumi.Archive]]]]]
|
|
1247
|
+
"""
|
|
1248
|
+
List of assets (raw yaml files). Content is read and merged with values. Not yet supported.
|
|
1249
|
+
"""
|
|
1250
|
+
values: NotRequired[pulumi.Input[Mapping[str, Any]]]
|
|
1251
|
+
"""
|
|
1252
|
+
Custom values set for the release.
|
|
1253
|
+
"""
|
|
1254
|
+
verify: NotRequired[pulumi.Input[bool]]
|
|
1255
|
+
"""
|
|
1256
|
+
Verify the package before installing it.
|
|
1257
|
+
"""
|
|
1258
|
+
version: NotRequired[pulumi.Input[str]]
|
|
1259
|
+
"""
|
|
1260
|
+
Specify the exact chart version to install. If this is not specified, the latest version is installed.
|
|
1261
|
+
"""
|
|
1262
|
+
wait_for_jobs: NotRequired[pulumi.Input[bool]]
|
|
1263
|
+
"""
|
|
1264
|
+
Will wait until all Jobs have been completed before marking the release as successful. This is ignored if `skipAwait` is enabled.
|
|
1265
|
+
"""
|
|
1266
|
+
elif False:
|
|
1267
|
+
ReleaseArgsDict: TypeAlias = Mapping[str, Any]
|
|
1268
|
+
|
|
1269
|
+
@pulumi.input_type
|
|
1270
|
+
class ReleaseArgs:
|
|
1271
|
+
def __init__(__self__, *,
|
|
1272
|
+
atomic: Optional[pulumi.Input[bool]] = None,
|
|
1273
|
+
chart: Optional[pulumi.Input[str]] = None,
|
|
1274
|
+
cleanup_on_fail: Optional[pulumi.Input[bool]] = None,
|
|
1275
|
+
create_namespace: Optional[pulumi.Input[bool]] = None,
|
|
1276
|
+
dependency_update: Optional[pulumi.Input[bool]] = None,
|
|
1277
|
+
description: Optional[pulumi.Input[str]] = None,
|
|
1278
|
+
devel: Optional[pulumi.Input[bool]] = None,
|
|
1279
|
+
disable_crd_hooks: Optional[pulumi.Input[bool]] = None,
|
|
1280
|
+
disable_openapi_validation: Optional[pulumi.Input[bool]] = None,
|
|
1281
|
+
disable_webhooks: Optional[pulumi.Input[bool]] = None,
|
|
1282
|
+
force_update: Optional[pulumi.Input[bool]] = None,
|
|
1283
|
+
keyring: Optional[pulumi.Input[str]] = None,
|
|
1284
|
+
lint: Optional[pulumi.Input[bool]] = None,
|
|
1285
|
+
manifest: Optional[pulumi.Input[Mapping[str, Any]]] = None,
|
|
1286
|
+
max_history: Optional[pulumi.Input[int]] = None,
|
|
1287
|
+
name: Optional[pulumi.Input[str]] = None,
|
|
1288
|
+
namespace: Optional[pulumi.Input[str]] = None,
|
|
1289
|
+
postrender: Optional[pulumi.Input[str]] = None,
|
|
1290
|
+
recreate_pods: Optional[pulumi.Input[bool]] = None,
|
|
1291
|
+
render_subchart_notes: Optional[pulumi.Input[bool]] = None,
|
|
1292
|
+
replace: Optional[pulumi.Input[bool]] = None,
|
|
1293
|
+
repository_opts: Optional[pulumi.Input['RepositoryOptsArgs']] = None,
|
|
1294
|
+
reset_values: Optional[pulumi.Input[bool]] = None,
|
|
1295
|
+
resource_names: Optional[pulumi.Input[Mapping[str, pulumi.Input[Sequence[pulumi.Input[str]]]]]] = None,
|
|
1296
|
+
reuse_values: Optional[pulumi.Input[bool]] = None,
|
|
1297
|
+
skip_await: Optional[pulumi.Input[bool]] = None,
|
|
1298
|
+
skip_crds: Optional[pulumi.Input[bool]] = None,
|
|
1299
|
+
timeout: Optional[pulumi.Input[int]] = None,
|
|
1300
|
+
value_yaml_files: Optional[pulumi.Input[Sequence[pulumi.Input[Union[pulumi.Asset, pulumi.Archive]]]]] = None,
|
|
1301
|
+
values: Optional[pulumi.Input[Mapping[str, Any]]] = None,
|
|
1302
|
+
verify: Optional[pulumi.Input[bool]] = None,
|
|
1303
|
+
version: Optional[pulumi.Input[str]] = None,
|
|
1304
|
+
wait_for_jobs: Optional[pulumi.Input[bool]] = None):
|
|
1305
|
+
"""
|
|
1306
|
+
A Release is an instance of a chart running in a Kubernetes cluster.
|
|
1307
|
+
A Chart is a Helm package. It contains all of the resource definitions necessary to run an application, tool, or service inside of a Kubernetes cluster.
|
|
1308
|
+
Note - Helm Release is currently in BETA and may change. Use in production environment is discouraged.
|
|
1309
|
+
:param pulumi.Input[bool] atomic: If set, installation process purges chart on fail. `skipAwait` will be disabled automatically if atomic is used.
|
|
1310
|
+
:param pulumi.Input[str] chart: Chart name to be installed. A path may be used.
|
|
1311
|
+
:param pulumi.Input[bool] cleanup_on_fail: Allow deletion of new resources created in this upgrade when upgrade fails.
|
|
1312
|
+
:param pulumi.Input[bool] create_namespace: Create the namespace if it does not exist.
|
|
1313
|
+
:param pulumi.Input[bool] dependency_update: Run helm dependency update before installing the chart.
|
|
1314
|
+
:param pulumi.Input[str] description: Add a custom description
|
|
1315
|
+
:param pulumi.Input[bool] devel: Use chart development versions, too. Equivalent to version '>0.0.0-0'. If `version` is set, this is ignored.
|
|
1316
|
+
:param pulumi.Input[bool] disable_crd_hooks: Prevent CRD hooks from, running, but run other hooks. See helm install --no-crd-hook
|
|
1317
|
+
:param pulumi.Input[bool] disable_openapi_validation: If set, the installation process will not validate rendered templates against the Kubernetes OpenAPI Schema
|
|
1318
|
+
:param pulumi.Input[bool] disable_webhooks: Prevent hooks from running.
|
|
1319
|
+
:param pulumi.Input[bool] force_update: Force resource update through delete/recreate if needed.
|
|
1320
|
+
:param pulumi.Input[str] keyring: Location of public keys used for verification. Used only if `verify` is true
|
|
1321
|
+
:param pulumi.Input[bool] lint: Run helm lint when planning.
|
|
1322
|
+
:param pulumi.Input[Mapping[str, Any]] manifest: The rendered manifests as JSON. Not yet supported.
|
|
1323
|
+
:param pulumi.Input[int] max_history: Limit the maximum number of revisions saved per release. Use 0 for no limit.
|
|
1324
|
+
:param pulumi.Input[str] name: Release name.
|
|
1325
|
+
:param pulumi.Input[str] namespace: Namespace to install the release into.
|
|
1326
|
+
:param pulumi.Input[str] postrender: Postrender command to run.
|
|
1327
|
+
:param pulumi.Input[bool] recreate_pods: Perform pods restart during upgrade/rollback.
|
|
1328
|
+
:param pulumi.Input[bool] render_subchart_notes: If set, render subchart notes along with the parent.
|
|
1329
|
+
:param pulumi.Input[bool] replace: Re-use the given name, even if that name is already used. This is unsafe in production
|
|
1330
|
+
:param pulumi.Input['RepositoryOptsArgs'] repository_opts: Specification defining the Helm chart repository to use.
|
|
1331
|
+
:param pulumi.Input[bool] reset_values: When upgrading, reset the values to the ones built into the chart.
|
|
1332
|
+
:param pulumi.Input[Mapping[str, pulumi.Input[Sequence[pulumi.Input[str]]]]] resource_names: Names of resources created by the release grouped by "kind/version".
|
|
1333
|
+
:param pulumi.Input[bool] reuse_values: When upgrading, reuse the last release's values and merge in any overrides. If 'resetValues' is specified, this is ignored
|
|
1334
|
+
:param pulumi.Input[bool] skip_await: By default, the provider waits until all resources are in a ready state before marking the release as successful. Setting this to true will skip such await logic.
|
|
1335
|
+
:param pulumi.Input[bool] skip_crds: If set, no CRDs will be installed. By default, CRDs are installed if not already present.
|
|
1336
|
+
:param pulumi.Input[int] timeout: Time in seconds to wait for any individual kubernetes operation.
|
|
1337
|
+
:param pulumi.Input[Sequence[pulumi.Input[Union[pulumi.Asset, pulumi.Archive]]]] value_yaml_files: List of assets (raw yaml files). Content is read and merged with values. Not yet supported.
|
|
1338
|
+
:param pulumi.Input[Mapping[str, Any]] values: Custom values set for the release.
|
|
1339
|
+
:param pulumi.Input[bool] verify: Verify the package before installing it.
|
|
1340
|
+
:param pulumi.Input[str] version: Specify the exact chart version to install. If this is not specified, the latest version is installed.
|
|
1341
|
+
:param pulumi.Input[bool] wait_for_jobs: Will wait until all Jobs have been completed before marking the release as successful. This is ignored if `skipAwait` is enabled.
|
|
1342
|
+
"""
|
|
1343
|
+
if atomic is not None:
|
|
1344
|
+
pulumi.set(__self__, "atomic", atomic)
|
|
1345
|
+
if chart is not None:
|
|
1346
|
+
pulumi.set(__self__, "chart", chart)
|
|
1347
|
+
if cleanup_on_fail is not None:
|
|
1348
|
+
pulumi.set(__self__, "cleanup_on_fail", cleanup_on_fail)
|
|
1349
|
+
if create_namespace is not None:
|
|
1350
|
+
pulumi.set(__self__, "create_namespace", create_namespace)
|
|
1351
|
+
if dependency_update is not None:
|
|
1352
|
+
pulumi.set(__self__, "dependency_update", dependency_update)
|
|
1353
|
+
if description is not None:
|
|
1354
|
+
pulumi.set(__self__, "description", description)
|
|
1355
|
+
if devel is not None:
|
|
1356
|
+
pulumi.set(__self__, "devel", devel)
|
|
1357
|
+
if disable_crd_hooks is not None:
|
|
1358
|
+
pulumi.set(__self__, "disable_crd_hooks", disable_crd_hooks)
|
|
1359
|
+
if disable_openapi_validation is not None:
|
|
1360
|
+
pulumi.set(__self__, "disable_openapi_validation", disable_openapi_validation)
|
|
1361
|
+
if disable_webhooks is not None:
|
|
1362
|
+
pulumi.set(__self__, "disable_webhooks", disable_webhooks)
|
|
1363
|
+
if force_update is not None:
|
|
1364
|
+
pulumi.set(__self__, "force_update", force_update)
|
|
1365
|
+
if keyring is not None:
|
|
1366
|
+
pulumi.set(__self__, "keyring", keyring)
|
|
1367
|
+
if lint is not None:
|
|
1368
|
+
pulumi.set(__self__, "lint", lint)
|
|
1369
|
+
if manifest is not None:
|
|
1370
|
+
pulumi.set(__self__, "manifest", manifest)
|
|
1371
|
+
if max_history is not None:
|
|
1372
|
+
pulumi.set(__self__, "max_history", max_history)
|
|
1373
|
+
if name is not None:
|
|
1374
|
+
pulumi.set(__self__, "name", name)
|
|
1375
|
+
if namespace is not None:
|
|
1376
|
+
pulumi.set(__self__, "namespace", namespace)
|
|
1377
|
+
if postrender is not None:
|
|
1378
|
+
pulumi.set(__self__, "postrender", postrender)
|
|
1379
|
+
if recreate_pods is not None:
|
|
1380
|
+
pulumi.set(__self__, "recreate_pods", recreate_pods)
|
|
1381
|
+
if render_subchart_notes is not None:
|
|
1382
|
+
pulumi.set(__self__, "render_subchart_notes", render_subchart_notes)
|
|
1383
|
+
if replace is not None:
|
|
1384
|
+
pulumi.set(__self__, "replace", replace)
|
|
1385
|
+
if repository_opts is not None:
|
|
1386
|
+
pulumi.set(__self__, "repository_opts", repository_opts)
|
|
1387
|
+
if reset_values is not None:
|
|
1388
|
+
pulumi.set(__self__, "reset_values", reset_values)
|
|
1389
|
+
if resource_names is not None:
|
|
1390
|
+
pulumi.set(__self__, "resource_names", resource_names)
|
|
1391
|
+
if reuse_values is not None:
|
|
1392
|
+
pulumi.set(__self__, "reuse_values", reuse_values)
|
|
1393
|
+
if skip_await is not None:
|
|
1394
|
+
pulumi.set(__self__, "skip_await", skip_await)
|
|
1395
|
+
if skip_crds is not None:
|
|
1396
|
+
pulumi.set(__self__, "skip_crds", skip_crds)
|
|
1397
|
+
if timeout is not None:
|
|
1398
|
+
pulumi.set(__self__, "timeout", timeout)
|
|
1399
|
+
if value_yaml_files is not None:
|
|
1400
|
+
pulumi.set(__self__, "value_yaml_files", value_yaml_files)
|
|
1401
|
+
if values is not None:
|
|
1402
|
+
pulumi.set(__self__, "values", values)
|
|
1403
|
+
if verify is not None:
|
|
1404
|
+
pulumi.set(__self__, "verify", verify)
|
|
1405
|
+
if version is not None:
|
|
1406
|
+
pulumi.set(__self__, "version", version)
|
|
1407
|
+
if wait_for_jobs is not None:
|
|
1408
|
+
pulumi.set(__self__, "wait_for_jobs", wait_for_jobs)
|
|
1409
|
+
|
|
1410
|
+
@property
|
|
1411
|
+
@pulumi.getter
|
|
1412
|
+
def atomic(self) -> Optional[pulumi.Input[bool]]:
|
|
1413
|
+
"""
|
|
1414
|
+
If set, installation process purges chart on fail. `skipAwait` will be disabled automatically if atomic is used.
|
|
1415
|
+
"""
|
|
1416
|
+
return pulumi.get(self, "atomic")
|
|
1417
|
+
|
|
1418
|
+
@atomic.setter
|
|
1419
|
+
def atomic(self, value: Optional[pulumi.Input[bool]]):
|
|
1420
|
+
pulumi.set(self, "atomic", value)
|
|
1421
|
+
|
|
1422
|
+
@property
|
|
1423
|
+
@pulumi.getter
|
|
1424
|
+
def chart(self) -> Optional[pulumi.Input[str]]:
|
|
1425
|
+
"""
|
|
1426
|
+
Chart name to be installed. A path may be used.
|
|
1427
|
+
"""
|
|
1428
|
+
return pulumi.get(self, "chart")
|
|
1429
|
+
|
|
1430
|
+
@chart.setter
|
|
1431
|
+
def chart(self, value: Optional[pulumi.Input[str]]):
|
|
1432
|
+
pulumi.set(self, "chart", value)
|
|
1433
|
+
|
|
1434
|
+
@property
|
|
1435
|
+
@pulumi.getter(name="cleanupOnFail")
|
|
1436
|
+
def cleanup_on_fail(self) -> Optional[pulumi.Input[bool]]:
|
|
1437
|
+
"""
|
|
1438
|
+
Allow deletion of new resources created in this upgrade when upgrade fails.
|
|
1439
|
+
"""
|
|
1440
|
+
return pulumi.get(self, "cleanup_on_fail")
|
|
1441
|
+
|
|
1442
|
+
@cleanup_on_fail.setter
|
|
1443
|
+
def cleanup_on_fail(self, value: Optional[pulumi.Input[bool]]):
|
|
1444
|
+
pulumi.set(self, "cleanup_on_fail", value)
|
|
1445
|
+
|
|
1446
|
+
@property
|
|
1447
|
+
@pulumi.getter(name="createNamespace")
|
|
1448
|
+
def create_namespace(self) -> Optional[pulumi.Input[bool]]:
|
|
1449
|
+
"""
|
|
1450
|
+
Create the namespace if it does not exist.
|
|
1451
|
+
"""
|
|
1452
|
+
return pulumi.get(self, "create_namespace")
|
|
1453
|
+
|
|
1454
|
+
@create_namespace.setter
|
|
1455
|
+
def create_namespace(self, value: Optional[pulumi.Input[bool]]):
|
|
1456
|
+
pulumi.set(self, "create_namespace", value)
|
|
1457
|
+
|
|
1458
|
+
@property
|
|
1459
|
+
@pulumi.getter(name="dependencyUpdate")
|
|
1460
|
+
def dependency_update(self) -> Optional[pulumi.Input[bool]]:
|
|
1461
|
+
"""
|
|
1462
|
+
Run helm dependency update before installing the chart.
|
|
1463
|
+
"""
|
|
1464
|
+
return pulumi.get(self, "dependency_update")
|
|
1465
|
+
|
|
1466
|
+
@dependency_update.setter
|
|
1467
|
+
def dependency_update(self, value: Optional[pulumi.Input[bool]]):
|
|
1468
|
+
pulumi.set(self, "dependency_update", value)
|
|
1469
|
+
|
|
1470
|
+
@property
|
|
1471
|
+
@pulumi.getter
|
|
1472
|
+
def description(self) -> Optional[pulumi.Input[str]]:
|
|
1473
|
+
"""
|
|
1474
|
+
Add a custom description
|
|
1475
|
+
"""
|
|
1476
|
+
return pulumi.get(self, "description")
|
|
1477
|
+
|
|
1478
|
+
@description.setter
|
|
1479
|
+
def description(self, value: Optional[pulumi.Input[str]]):
|
|
1480
|
+
pulumi.set(self, "description", value)
|
|
1481
|
+
|
|
1482
|
+
@property
|
|
1483
|
+
@pulumi.getter
|
|
1484
|
+
def devel(self) -> Optional[pulumi.Input[bool]]:
|
|
1485
|
+
"""
|
|
1486
|
+
Use chart development versions, too. Equivalent to version '>0.0.0-0'. If `version` is set, this is ignored.
|
|
1487
|
+
"""
|
|
1488
|
+
return pulumi.get(self, "devel")
|
|
1489
|
+
|
|
1490
|
+
@devel.setter
|
|
1491
|
+
def devel(self, value: Optional[pulumi.Input[bool]]):
|
|
1492
|
+
pulumi.set(self, "devel", value)
|
|
1493
|
+
|
|
1494
|
+
@property
|
|
1495
|
+
@pulumi.getter(name="disableCRDHooks")
|
|
1496
|
+
def disable_crd_hooks(self) -> Optional[pulumi.Input[bool]]:
|
|
1497
|
+
"""
|
|
1498
|
+
Prevent CRD hooks from, running, but run other hooks. See helm install --no-crd-hook
|
|
1499
|
+
"""
|
|
1500
|
+
return pulumi.get(self, "disable_crd_hooks")
|
|
1501
|
+
|
|
1502
|
+
@disable_crd_hooks.setter
|
|
1503
|
+
def disable_crd_hooks(self, value: Optional[pulumi.Input[bool]]):
|
|
1504
|
+
pulumi.set(self, "disable_crd_hooks", value)
|
|
1505
|
+
|
|
1506
|
+
@property
|
|
1507
|
+
@pulumi.getter(name="disableOpenapiValidation")
|
|
1508
|
+
def disable_openapi_validation(self) -> Optional[pulumi.Input[bool]]:
|
|
1509
|
+
"""
|
|
1510
|
+
If set, the installation process will not validate rendered templates against the Kubernetes OpenAPI Schema
|
|
1511
|
+
"""
|
|
1512
|
+
return pulumi.get(self, "disable_openapi_validation")
|
|
1513
|
+
|
|
1514
|
+
@disable_openapi_validation.setter
|
|
1515
|
+
def disable_openapi_validation(self, value: Optional[pulumi.Input[bool]]):
|
|
1516
|
+
pulumi.set(self, "disable_openapi_validation", value)
|
|
1517
|
+
|
|
1518
|
+
@property
|
|
1519
|
+
@pulumi.getter(name="disableWebhooks")
|
|
1520
|
+
def disable_webhooks(self) -> Optional[pulumi.Input[bool]]:
|
|
1521
|
+
"""
|
|
1522
|
+
Prevent hooks from running.
|
|
1523
|
+
"""
|
|
1524
|
+
return pulumi.get(self, "disable_webhooks")
|
|
1525
|
+
|
|
1526
|
+
@disable_webhooks.setter
|
|
1527
|
+
def disable_webhooks(self, value: Optional[pulumi.Input[bool]]):
|
|
1528
|
+
pulumi.set(self, "disable_webhooks", value)
|
|
1529
|
+
|
|
1530
|
+
@property
|
|
1531
|
+
@pulumi.getter(name="forceUpdate")
|
|
1532
|
+
def force_update(self) -> Optional[pulumi.Input[bool]]:
|
|
1533
|
+
"""
|
|
1534
|
+
Force resource update through delete/recreate if needed.
|
|
1535
|
+
"""
|
|
1536
|
+
return pulumi.get(self, "force_update")
|
|
1537
|
+
|
|
1538
|
+
@force_update.setter
|
|
1539
|
+
def force_update(self, value: Optional[pulumi.Input[bool]]):
|
|
1540
|
+
pulumi.set(self, "force_update", value)
|
|
1541
|
+
|
|
1542
|
+
@property
|
|
1543
|
+
@pulumi.getter
|
|
1544
|
+
def keyring(self) -> Optional[pulumi.Input[str]]:
|
|
1545
|
+
"""
|
|
1546
|
+
Location of public keys used for verification. Used only if `verify` is true
|
|
1547
|
+
"""
|
|
1548
|
+
return pulumi.get(self, "keyring")
|
|
1549
|
+
|
|
1550
|
+
@keyring.setter
|
|
1551
|
+
def keyring(self, value: Optional[pulumi.Input[str]]):
|
|
1552
|
+
pulumi.set(self, "keyring", value)
|
|
1553
|
+
|
|
1554
|
+
@property
|
|
1555
|
+
@pulumi.getter
|
|
1556
|
+
def lint(self) -> Optional[pulumi.Input[bool]]:
|
|
1557
|
+
"""
|
|
1558
|
+
Run helm lint when planning.
|
|
1559
|
+
"""
|
|
1560
|
+
return pulumi.get(self, "lint")
|
|
1561
|
+
|
|
1562
|
+
@lint.setter
|
|
1563
|
+
def lint(self, value: Optional[pulumi.Input[bool]]):
|
|
1564
|
+
pulumi.set(self, "lint", value)
|
|
1565
|
+
|
|
1566
|
+
@property
|
|
1567
|
+
@pulumi.getter
|
|
1568
|
+
def manifest(self) -> Optional[pulumi.Input[Mapping[str, Any]]]:
|
|
1569
|
+
"""
|
|
1570
|
+
The rendered manifests as JSON. Not yet supported.
|
|
1571
|
+
"""
|
|
1572
|
+
return pulumi.get(self, "manifest")
|
|
1573
|
+
|
|
1574
|
+
@manifest.setter
|
|
1575
|
+
def manifest(self, value: Optional[pulumi.Input[Mapping[str, Any]]]):
|
|
1576
|
+
pulumi.set(self, "manifest", value)
|
|
1577
|
+
|
|
1578
|
+
@property
|
|
1579
|
+
@pulumi.getter(name="maxHistory")
|
|
1580
|
+
def max_history(self) -> Optional[pulumi.Input[int]]:
|
|
1581
|
+
"""
|
|
1582
|
+
Limit the maximum number of revisions saved per release. Use 0 for no limit.
|
|
1583
|
+
"""
|
|
1584
|
+
return pulumi.get(self, "max_history")
|
|
1585
|
+
|
|
1586
|
+
@max_history.setter
|
|
1587
|
+
def max_history(self, value: Optional[pulumi.Input[int]]):
|
|
1588
|
+
pulumi.set(self, "max_history", value)
|
|
1589
|
+
|
|
1590
|
+
@property
|
|
1591
|
+
@pulumi.getter
|
|
1592
|
+
def name(self) -> Optional[pulumi.Input[str]]:
|
|
1593
|
+
"""
|
|
1594
|
+
Release name.
|
|
1595
|
+
"""
|
|
1596
|
+
return pulumi.get(self, "name")
|
|
1597
|
+
|
|
1598
|
+
@name.setter
|
|
1599
|
+
def name(self, value: Optional[pulumi.Input[str]]):
|
|
1600
|
+
pulumi.set(self, "name", value)
|
|
1601
|
+
|
|
1602
|
+
@property
|
|
1603
|
+
@pulumi.getter
|
|
1604
|
+
def namespace(self) -> Optional[pulumi.Input[str]]:
|
|
1605
|
+
"""
|
|
1606
|
+
Namespace to install the release into.
|
|
1607
|
+
"""
|
|
1608
|
+
return pulumi.get(self, "namespace")
|
|
1609
|
+
|
|
1610
|
+
@namespace.setter
|
|
1611
|
+
def namespace(self, value: Optional[pulumi.Input[str]]):
|
|
1612
|
+
pulumi.set(self, "namespace", value)
|
|
1613
|
+
|
|
1614
|
+
@property
|
|
1615
|
+
@pulumi.getter
|
|
1616
|
+
def postrender(self) -> Optional[pulumi.Input[str]]:
|
|
1617
|
+
"""
|
|
1618
|
+
Postrender command to run.
|
|
1619
|
+
"""
|
|
1620
|
+
return pulumi.get(self, "postrender")
|
|
1621
|
+
|
|
1622
|
+
@postrender.setter
|
|
1623
|
+
def postrender(self, value: Optional[pulumi.Input[str]]):
|
|
1624
|
+
pulumi.set(self, "postrender", value)
|
|
1625
|
+
|
|
1626
|
+
@property
|
|
1627
|
+
@pulumi.getter(name="recreatePods")
|
|
1628
|
+
def recreate_pods(self) -> Optional[pulumi.Input[bool]]:
|
|
1629
|
+
"""
|
|
1630
|
+
Perform pods restart during upgrade/rollback.
|
|
1631
|
+
"""
|
|
1632
|
+
return pulumi.get(self, "recreate_pods")
|
|
1633
|
+
|
|
1634
|
+
@recreate_pods.setter
|
|
1635
|
+
def recreate_pods(self, value: Optional[pulumi.Input[bool]]):
|
|
1636
|
+
pulumi.set(self, "recreate_pods", value)
|
|
1637
|
+
|
|
1638
|
+
@property
|
|
1639
|
+
@pulumi.getter(name="renderSubchartNotes")
|
|
1640
|
+
def render_subchart_notes(self) -> Optional[pulumi.Input[bool]]:
|
|
1641
|
+
"""
|
|
1642
|
+
If set, render subchart notes along with the parent.
|
|
1643
|
+
"""
|
|
1644
|
+
return pulumi.get(self, "render_subchart_notes")
|
|
1645
|
+
|
|
1646
|
+
@render_subchart_notes.setter
|
|
1647
|
+
def render_subchart_notes(self, value: Optional[pulumi.Input[bool]]):
|
|
1648
|
+
pulumi.set(self, "render_subchart_notes", value)
|
|
1649
|
+
|
|
1650
|
+
@property
|
|
1651
|
+
@pulumi.getter
|
|
1652
|
+
def replace(self) -> Optional[pulumi.Input[bool]]:
|
|
1653
|
+
"""
|
|
1654
|
+
Re-use the given name, even if that name is already used. This is unsafe in production
|
|
1655
|
+
"""
|
|
1656
|
+
return pulumi.get(self, "replace")
|
|
1657
|
+
|
|
1658
|
+
@replace.setter
|
|
1659
|
+
def replace(self, value: Optional[pulumi.Input[bool]]):
|
|
1660
|
+
pulumi.set(self, "replace", value)
|
|
1661
|
+
|
|
1662
|
+
@property
|
|
1663
|
+
@pulumi.getter(name="repositoryOpts")
|
|
1664
|
+
def repository_opts(self) -> Optional[pulumi.Input['RepositoryOptsArgs']]:
|
|
1665
|
+
"""
|
|
1666
|
+
Specification defining the Helm chart repository to use.
|
|
1667
|
+
"""
|
|
1668
|
+
return pulumi.get(self, "repository_opts")
|
|
1669
|
+
|
|
1670
|
+
@repository_opts.setter
|
|
1671
|
+
def repository_opts(self, value: Optional[pulumi.Input['RepositoryOptsArgs']]):
|
|
1672
|
+
pulumi.set(self, "repository_opts", value)
|
|
1673
|
+
|
|
1674
|
+
@property
|
|
1675
|
+
@pulumi.getter(name="resetValues")
|
|
1676
|
+
def reset_values(self) -> Optional[pulumi.Input[bool]]:
|
|
1677
|
+
"""
|
|
1678
|
+
When upgrading, reset the values to the ones built into the chart.
|
|
1679
|
+
"""
|
|
1680
|
+
return pulumi.get(self, "reset_values")
|
|
1681
|
+
|
|
1682
|
+
@reset_values.setter
|
|
1683
|
+
def reset_values(self, value: Optional[pulumi.Input[bool]]):
|
|
1684
|
+
pulumi.set(self, "reset_values", value)
|
|
1685
|
+
|
|
1686
|
+
@property
|
|
1687
|
+
@pulumi.getter(name="resourceNames")
|
|
1688
|
+
def resource_names(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[Sequence[pulumi.Input[str]]]]]]:
|
|
1689
|
+
"""
|
|
1690
|
+
Names of resources created by the release grouped by "kind/version".
|
|
1691
|
+
"""
|
|
1692
|
+
return pulumi.get(self, "resource_names")
|
|
1693
|
+
|
|
1694
|
+
@resource_names.setter
|
|
1695
|
+
def resource_names(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[Sequence[pulumi.Input[str]]]]]]):
|
|
1696
|
+
pulumi.set(self, "resource_names", value)
|
|
1697
|
+
|
|
1698
|
+
@property
|
|
1699
|
+
@pulumi.getter(name="reuseValues")
|
|
1700
|
+
def reuse_values(self) -> Optional[pulumi.Input[bool]]:
|
|
1701
|
+
"""
|
|
1702
|
+
When upgrading, reuse the last release's values and merge in any overrides. If 'resetValues' is specified, this is ignored
|
|
1703
|
+
"""
|
|
1704
|
+
return pulumi.get(self, "reuse_values")
|
|
1705
|
+
|
|
1706
|
+
@reuse_values.setter
|
|
1707
|
+
def reuse_values(self, value: Optional[pulumi.Input[bool]]):
|
|
1708
|
+
pulumi.set(self, "reuse_values", value)
|
|
1709
|
+
|
|
1710
|
+
@property
|
|
1711
|
+
@pulumi.getter(name="skipAwait")
|
|
1712
|
+
def skip_await(self) -> Optional[pulumi.Input[bool]]:
|
|
1713
|
+
"""
|
|
1714
|
+
By default, the provider waits until all resources are in a ready state before marking the release as successful. Setting this to true will skip such await logic.
|
|
1715
|
+
"""
|
|
1716
|
+
return pulumi.get(self, "skip_await")
|
|
1717
|
+
|
|
1718
|
+
@skip_await.setter
|
|
1719
|
+
def skip_await(self, value: Optional[pulumi.Input[bool]]):
|
|
1720
|
+
pulumi.set(self, "skip_await", value)
|
|
1721
|
+
|
|
1722
|
+
@property
|
|
1723
|
+
@pulumi.getter(name="skipCrds")
|
|
1724
|
+
def skip_crds(self) -> Optional[pulumi.Input[bool]]:
|
|
1725
|
+
"""
|
|
1726
|
+
If set, no CRDs will be installed. By default, CRDs are installed if not already present.
|
|
1727
|
+
"""
|
|
1728
|
+
return pulumi.get(self, "skip_crds")
|
|
1729
|
+
|
|
1730
|
+
@skip_crds.setter
|
|
1731
|
+
def skip_crds(self, value: Optional[pulumi.Input[bool]]):
|
|
1732
|
+
pulumi.set(self, "skip_crds", value)
|
|
1733
|
+
|
|
1734
|
+
@property
|
|
1735
|
+
@pulumi.getter
|
|
1736
|
+
def timeout(self) -> Optional[pulumi.Input[int]]:
|
|
1737
|
+
"""
|
|
1738
|
+
Time in seconds to wait for any individual kubernetes operation.
|
|
1739
|
+
"""
|
|
1740
|
+
return pulumi.get(self, "timeout")
|
|
1741
|
+
|
|
1742
|
+
@timeout.setter
|
|
1743
|
+
def timeout(self, value: Optional[pulumi.Input[int]]):
|
|
1744
|
+
pulumi.set(self, "timeout", value)
|
|
1745
|
+
|
|
1746
|
+
@property
|
|
1747
|
+
@pulumi.getter(name="valueYamlFiles")
|
|
1748
|
+
def value_yaml_files(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[Union[pulumi.Asset, pulumi.Archive]]]]]:
|
|
1749
|
+
"""
|
|
1750
|
+
List of assets (raw yaml files). Content is read and merged with values. Not yet supported.
|
|
1751
|
+
"""
|
|
1752
|
+
return pulumi.get(self, "value_yaml_files")
|
|
1753
|
+
|
|
1754
|
+
@value_yaml_files.setter
|
|
1755
|
+
def value_yaml_files(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[Union[pulumi.Asset, pulumi.Archive]]]]]):
|
|
1756
|
+
pulumi.set(self, "value_yaml_files", value)
|
|
1757
|
+
|
|
1758
|
+
@property
|
|
1759
|
+
@pulumi.getter
|
|
1760
|
+
def values(self) -> Optional[pulumi.Input[Mapping[str, Any]]]:
|
|
1761
|
+
"""
|
|
1762
|
+
Custom values set for the release.
|
|
1763
|
+
"""
|
|
1764
|
+
return pulumi.get(self, "values")
|
|
1765
|
+
|
|
1766
|
+
@values.setter
|
|
1767
|
+
def values(self, value: Optional[pulumi.Input[Mapping[str, Any]]]):
|
|
1768
|
+
pulumi.set(self, "values", value)
|
|
1769
|
+
|
|
1770
|
+
@property
|
|
1771
|
+
@pulumi.getter
|
|
1772
|
+
def verify(self) -> Optional[pulumi.Input[bool]]:
|
|
1773
|
+
"""
|
|
1774
|
+
Verify the package before installing it.
|
|
1775
|
+
"""
|
|
1776
|
+
return pulumi.get(self, "verify")
|
|
1777
|
+
|
|
1778
|
+
@verify.setter
|
|
1779
|
+
def verify(self, value: Optional[pulumi.Input[bool]]):
|
|
1780
|
+
pulumi.set(self, "verify", value)
|
|
1781
|
+
|
|
1782
|
+
@property
|
|
1783
|
+
@pulumi.getter
|
|
1784
|
+
def version(self) -> Optional[pulumi.Input[str]]:
|
|
1785
|
+
"""
|
|
1786
|
+
Specify the exact chart version to install. If this is not specified, the latest version is installed.
|
|
1787
|
+
"""
|
|
1788
|
+
return pulumi.get(self, "version")
|
|
1789
|
+
|
|
1790
|
+
@version.setter
|
|
1791
|
+
def version(self, value: Optional[pulumi.Input[str]]):
|
|
1792
|
+
pulumi.set(self, "version", value)
|
|
1793
|
+
|
|
1794
|
+
@property
|
|
1795
|
+
@pulumi.getter(name="waitForJobs")
|
|
1796
|
+
def wait_for_jobs(self) -> Optional[pulumi.Input[bool]]:
|
|
1797
|
+
"""
|
|
1798
|
+
Will wait until all Jobs have been completed before marking the release as successful. This is ignored if `skipAwait` is enabled.
|
|
1799
|
+
"""
|
|
1800
|
+
return pulumi.get(self, "wait_for_jobs")
|
|
1801
|
+
|
|
1802
|
+
@wait_for_jobs.setter
|
|
1803
|
+
def wait_for_jobs(self, value: Optional[pulumi.Input[bool]]):
|
|
1804
|
+
pulumi.set(self, "wait_for_jobs", value)
|
|
1805
|
+
|
|
1806
|
+
|
|
1807
|
+
if not MYPY:
|
|
1808
|
+
class RepositoryOptsArgsDict(TypedDict):
|
|
1809
|
+
"""
|
|
1810
|
+
Specification defining the Helm chart repository to use.
|
|
1811
|
+
"""
|
|
1812
|
+
ca_file: NotRequired[pulumi.Input[str]]
|
|
1813
|
+
"""
|
|
1814
|
+
The Repository's CA File
|
|
1815
|
+
"""
|
|
1816
|
+
cert_file: NotRequired[pulumi.Input[str]]
|
|
1817
|
+
"""
|
|
1818
|
+
The repository's cert file
|
|
1819
|
+
"""
|
|
1820
|
+
key_file: NotRequired[pulumi.Input[str]]
|
|
1821
|
+
"""
|
|
1822
|
+
The repository's cert key file
|
|
1823
|
+
"""
|
|
1824
|
+
password: NotRequired[pulumi.Input[str]]
|
|
1825
|
+
"""
|
|
1826
|
+
Password for HTTP basic authentication
|
|
1827
|
+
"""
|
|
1828
|
+
repo: NotRequired[pulumi.Input[str]]
|
|
1829
|
+
"""
|
|
1830
|
+
Repository where to locate the requested chart. If is a URL the chart is installed without installing the repository.
|
|
1831
|
+
"""
|
|
1832
|
+
username: NotRequired[pulumi.Input[str]]
|
|
1833
|
+
"""
|
|
1834
|
+
Username for HTTP basic authentication
|
|
1835
|
+
"""
|
|
1836
|
+
elif False:
|
|
1837
|
+
RepositoryOptsArgsDict: TypeAlias = Mapping[str, Any]
|
|
1838
|
+
|
|
1839
|
+
@pulumi.input_type
|
|
1840
|
+
class RepositoryOptsArgs:
|
|
1841
|
+
def __init__(__self__, *,
|
|
1842
|
+
ca_file: Optional[pulumi.Input[str]] = None,
|
|
1843
|
+
cert_file: Optional[pulumi.Input[str]] = None,
|
|
1844
|
+
key_file: Optional[pulumi.Input[str]] = None,
|
|
1845
|
+
password: Optional[pulumi.Input[str]] = None,
|
|
1846
|
+
repo: Optional[pulumi.Input[str]] = None,
|
|
1847
|
+
username: Optional[pulumi.Input[str]] = None):
|
|
1848
|
+
"""
|
|
1849
|
+
Specification defining the Helm chart repository to use.
|
|
1850
|
+
:param pulumi.Input[str] ca_file: The Repository's CA File
|
|
1851
|
+
:param pulumi.Input[str] cert_file: The repository's cert file
|
|
1852
|
+
:param pulumi.Input[str] key_file: The repository's cert key file
|
|
1853
|
+
:param pulumi.Input[str] password: Password for HTTP basic authentication
|
|
1854
|
+
:param pulumi.Input[str] repo: Repository where to locate the requested chart. If is a URL the chart is installed without installing the repository.
|
|
1855
|
+
:param pulumi.Input[str] username: Username for HTTP basic authentication
|
|
1856
|
+
"""
|
|
1857
|
+
if ca_file is not None:
|
|
1858
|
+
pulumi.set(__self__, "ca_file", ca_file)
|
|
1859
|
+
if cert_file is not None:
|
|
1860
|
+
pulumi.set(__self__, "cert_file", cert_file)
|
|
1861
|
+
if key_file is not None:
|
|
1862
|
+
pulumi.set(__self__, "key_file", key_file)
|
|
1863
|
+
if password is not None:
|
|
1864
|
+
pulumi.set(__self__, "password", password)
|
|
1865
|
+
if repo is not None:
|
|
1866
|
+
pulumi.set(__self__, "repo", repo)
|
|
1867
|
+
if username is not None:
|
|
1868
|
+
pulumi.set(__self__, "username", username)
|
|
1869
|
+
|
|
1870
|
+
@property
|
|
1871
|
+
@pulumi.getter(name="caFile")
|
|
1872
|
+
def ca_file(self) -> Optional[pulumi.Input[str]]:
|
|
1873
|
+
"""
|
|
1874
|
+
The Repository's CA File
|
|
1875
|
+
"""
|
|
1876
|
+
return pulumi.get(self, "ca_file")
|
|
1877
|
+
|
|
1878
|
+
@ca_file.setter
|
|
1879
|
+
def ca_file(self, value: Optional[pulumi.Input[str]]):
|
|
1880
|
+
pulumi.set(self, "ca_file", value)
|
|
1881
|
+
|
|
1882
|
+
@property
|
|
1883
|
+
@pulumi.getter(name="certFile")
|
|
1884
|
+
def cert_file(self) -> Optional[pulumi.Input[str]]:
|
|
1885
|
+
"""
|
|
1886
|
+
The repository's cert file
|
|
1887
|
+
"""
|
|
1888
|
+
return pulumi.get(self, "cert_file")
|
|
1889
|
+
|
|
1890
|
+
@cert_file.setter
|
|
1891
|
+
def cert_file(self, value: Optional[pulumi.Input[str]]):
|
|
1892
|
+
pulumi.set(self, "cert_file", value)
|
|
1893
|
+
|
|
1894
|
+
@property
|
|
1895
|
+
@pulumi.getter(name="keyFile")
|
|
1896
|
+
def key_file(self) -> Optional[pulumi.Input[str]]:
|
|
1897
|
+
"""
|
|
1898
|
+
The repository's cert key file
|
|
1899
|
+
"""
|
|
1900
|
+
return pulumi.get(self, "key_file")
|
|
1901
|
+
|
|
1902
|
+
@key_file.setter
|
|
1903
|
+
def key_file(self, value: Optional[pulumi.Input[str]]):
|
|
1904
|
+
pulumi.set(self, "key_file", value)
|
|
1905
|
+
|
|
1906
|
+
@property
|
|
1907
|
+
@pulumi.getter
|
|
1908
|
+
def password(self) -> Optional[pulumi.Input[str]]:
|
|
1909
|
+
"""
|
|
1910
|
+
Password for HTTP basic authentication
|
|
1911
|
+
"""
|
|
1912
|
+
return pulumi.get(self, "password")
|
|
1913
|
+
|
|
1914
|
+
@password.setter
|
|
1915
|
+
def password(self, value: Optional[pulumi.Input[str]]):
|
|
1916
|
+
pulumi.set(self, "password", value)
|
|
1917
|
+
|
|
1918
|
+
@property
|
|
1919
|
+
@pulumi.getter
|
|
1920
|
+
def repo(self) -> Optional[pulumi.Input[str]]:
|
|
1921
|
+
"""
|
|
1922
|
+
Repository where to locate the requested chart. If is a URL the chart is installed without installing the repository.
|
|
1923
|
+
"""
|
|
1924
|
+
return pulumi.get(self, "repo")
|
|
1925
|
+
|
|
1926
|
+
@repo.setter
|
|
1927
|
+
def repo(self, value: Optional[pulumi.Input[str]]):
|
|
1928
|
+
pulumi.set(self, "repo", value)
|
|
1929
|
+
|
|
1930
|
+
@property
|
|
1931
|
+
@pulumi.getter
|
|
1932
|
+
def username(self) -> Optional[pulumi.Input[str]]:
|
|
1933
|
+
"""
|
|
1934
|
+
Username for HTTP basic authentication
|
|
1935
|
+
"""
|
|
1936
|
+
return pulumi.get(self, "username")
|
|
1937
|
+
|
|
1938
|
+
@username.setter
|
|
1939
|
+
def username(self, value: Optional[pulumi.Input[str]]):
|
|
1940
|
+
pulumi.set(self, "username", value)
|
|
1941
|
+
|
|
1942
|
+
|