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