pulumi-kubernetes-cert-manager 0.2.0a1736827123__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_cert_manager/__init__.py +35 -0
- pulumi_kubernetes_cert_manager/_inputs.py +2517 -0
- pulumi_kubernetes_cert_manager/_utilities.py +327 -0
- pulumi_kubernetes_cert_manager/cert_manager.py +657 -0
- pulumi_kubernetes_cert_manager/outputs.py +121 -0
- pulumi_kubernetes_cert_manager/provider.py +76 -0
- pulumi_kubernetes_cert_manager/pulumi-plugin.json +5 -0
- pulumi_kubernetes_cert_manager/py.typed +0 -0
- pulumi_kubernetes_cert_manager-0.2.0a1736827123.dist-info/METADATA +47 -0
- pulumi_kubernetes_cert_manager-0.2.0a1736827123.dist-info/RECORD +12 -0
- pulumi_kubernetes_cert_manager-0.2.0a1736827123.dist-info/WHEEL +5 -0
- pulumi_kubernetes_cert_manager-0.2.0a1736827123.dist-info/top_level.txt +1 -0
|
@@ -0,0 +1,2517 @@
|
|
|
1
|
+
# coding=utf-8
|
|
2
|
+
# *** WARNING: this file was generated by pulumi-language-python. ***
|
|
3
|
+
# *** Do not edit by hand unless you're certain you know what you are doing! ***
|
|
4
|
+
|
|
5
|
+
import copy
|
|
6
|
+
import warnings
|
|
7
|
+
import sys
|
|
8
|
+
import pulumi
|
|
9
|
+
import pulumi.runtime
|
|
10
|
+
from typing import Any, Mapping, Optional, Sequence, Union, overload
|
|
11
|
+
if sys.version_info >= (3, 11):
|
|
12
|
+
from typing import NotRequired, TypedDict, TypeAlias
|
|
13
|
+
else:
|
|
14
|
+
from typing_extensions import NotRequired, TypedDict, TypeAlias
|
|
15
|
+
from . import _utilities
|
|
16
|
+
import pulumi_kubernetes
|
|
17
|
+
|
|
18
|
+
__all__ = [
|
|
19
|
+
'CertManagerCaInjectorArgs',
|
|
20
|
+
'CertManagerCaInjectorArgsDict',
|
|
21
|
+
'CertManagerGlobalLeaderElectionArgs',
|
|
22
|
+
'CertManagerGlobalLeaderElectionArgsDict',
|
|
23
|
+
'CertManagerGlobalPodSecurityPolicyArgs',
|
|
24
|
+
'CertManagerGlobalPodSecurityPolicyArgsDict',
|
|
25
|
+
'CertManagerGlobalRbacArgs',
|
|
26
|
+
'CertManagerGlobalRbacArgsDict',
|
|
27
|
+
'CertManagerGlobalArgs',
|
|
28
|
+
'CertManagerGlobalArgsDict',
|
|
29
|
+
'CertManagerImageArgs',
|
|
30
|
+
'CertManagerImageArgsDict',
|
|
31
|
+
'CertManagerIngressShimArgs',
|
|
32
|
+
'CertManagerIngressShimArgsDict',
|
|
33
|
+
'CertManagerPrometheusServiceMonitorArgs',
|
|
34
|
+
'CertManagerPrometheusServiceMonitorArgsDict',
|
|
35
|
+
'CertManagerPrometheusArgs',
|
|
36
|
+
'CertManagerPrometheusArgsDict',
|
|
37
|
+
'CertManagerServiceAccountArgs',
|
|
38
|
+
'CertManagerServiceAccountArgsDict',
|
|
39
|
+
'CertManagerStartupAPICheckRBACArgs',
|
|
40
|
+
'CertManagerStartupAPICheckRBACArgsDict',
|
|
41
|
+
'CertManagerStartupAPICheckArgs',
|
|
42
|
+
'CertManagerStartupAPICheckArgsDict',
|
|
43
|
+
'CertManagerWebhookURLArgs',
|
|
44
|
+
'CertManagerWebhookURLArgsDict',
|
|
45
|
+
'CertManagerWebhookArgs',
|
|
46
|
+
'CertManagerWebhookArgsDict',
|
|
47
|
+
'ReleaseArgs',
|
|
48
|
+
'ReleaseArgsDict',
|
|
49
|
+
'RepositoryOptsArgs',
|
|
50
|
+
'RepositoryOptsArgsDict',
|
|
51
|
+
]
|
|
52
|
+
|
|
53
|
+
MYPY = False
|
|
54
|
+
|
|
55
|
+
if not MYPY:
|
|
56
|
+
class CertManagerCaInjectorArgsDict(TypedDict):
|
|
57
|
+
affinity: NotRequired[pulumi.Input['pulumi_kubernetes.core.v1.AffinityArgsDict']]
|
|
58
|
+
container_security_context: NotRequired[pulumi.Input['pulumi_kubernetes.core.v1.SecurityContextArgsDict']]
|
|
59
|
+
"""
|
|
60
|
+
Container Security Context to be set on the cainjector component container. ref: https://kubernetes.io/docs/tasks/configure-pod-container/security-context/
|
|
61
|
+
"""
|
|
62
|
+
deployment_annotations: NotRequired[pulumi.Input[Mapping[str, pulumi.Input[str]]]]
|
|
63
|
+
"""
|
|
64
|
+
Optional additional annotations to add to the cainjector Deployment
|
|
65
|
+
"""
|
|
66
|
+
extra_args: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
|
|
67
|
+
"""
|
|
68
|
+
Optional additional arguments for cainjector
|
|
69
|
+
"""
|
|
70
|
+
image: NotRequired[pulumi.Input['CertManagerImageArgsDict']]
|
|
71
|
+
node_selector: NotRequired[pulumi.Input[Mapping[str, pulumi.Input[str]]]]
|
|
72
|
+
pod_annotations: NotRequired[pulumi.Input[Mapping[str, pulumi.Input[str]]]]
|
|
73
|
+
"""
|
|
74
|
+
Optional additional annotations to add to the cainjector Pods
|
|
75
|
+
"""
|
|
76
|
+
pod_labels: NotRequired[pulumi.Input[Mapping[str, pulumi.Input[str]]]]
|
|
77
|
+
"""
|
|
78
|
+
Optional additional labels to add to the Webhook Pods
|
|
79
|
+
"""
|
|
80
|
+
pod_security_context: NotRequired[pulumi.Input['pulumi_kubernetes.core.v1.PodSecurityContextArgsDict']]
|
|
81
|
+
"""
|
|
82
|
+
Pod Security Context to be set on the cainjector component Pod. ref: https://kubernetes.io/docs/tasks/configure-pod-container/security-context/
|
|
83
|
+
"""
|
|
84
|
+
replica_count: NotRequired[pulumi.Input[int]]
|
|
85
|
+
resources: NotRequired[pulumi.Input['pulumi_kubernetes.core.v1.ResourceRequirementsArgsDict']]
|
|
86
|
+
service_account: NotRequired[pulumi.Input['CertManagerServiceAccountArgsDict']]
|
|
87
|
+
strategy: NotRequired[pulumi.Input['pulumi_kubernetes.apps.v1.DeploymentStrategyArgsDict']]
|
|
88
|
+
timeout_seconds: NotRequired[pulumi.Input[int]]
|
|
89
|
+
tolerations: NotRequired[pulumi.Input[Sequence[pulumi.Input['pulumi_kubernetes.core.v1.TolerationArgsDict']]]]
|
|
90
|
+
elif False:
|
|
91
|
+
CertManagerCaInjectorArgsDict: TypeAlias = Mapping[str, Any]
|
|
92
|
+
|
|
93
|
+
@pulumi.input_type
|
|
94
|
+
class CertManagerCaInjectorArgs:
|
|
95
|
+
def __init__(__self__, *,
|
|
96
|
+
affinity: Optional[pulumi.Input['pulumi_kubernetes.core.v1.AffinityArgs']] = None,
|
|
97
|
+
container_security_context: Optional[pulumi.Input['pulumi_kubernetes.core.v1.SecurityContextArgs']] = None,
|
|
98
|
+
deployment_annotations: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None,
|
|
99
|
+
extra_args: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
|
|
100
|
+
image: Optional[pulumi.Input['CertManagerImageArgs']] = None,
|
|
101
|
+
node_selector: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None,
|
|
102
|
+
pod_annotations: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None,
|
|
103
|
+
pod_labels: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None,
|
|
104
|
+
pod_security_context: Optional[pulumi.Input['pulumi_kubernetes.core.v1.PodSecurityContextArgs']] = None,
|
|
105
|
+
replica_count: Optional[pulumi.Input[int]] = None,
|
|
106
|
+
resources: Optional[pulumi.Input['pulumi_kubernetes.core.v1.ResourceRequirementsArgs']] = None,
|
|
107
|
+
service_account: Optional[pulumi.Input['CertManagerServiceAccountArgs']] = None,
|
|
108
|
+
strategy: Optional[pulumi.Input['pulumi_kubernetes.apps.v1.DeploymentStrategyArgs']] = None,
|
|
109
|
+
timeout_seconds: Optional[pulumi.Input[int]] = None,
|
|
110
|
+
tolerations: Optional[pulumi.Input[Sequence[pulumi.Input['pulumi_kubernetes.core.v1.TolerationArgs']]]] = None):
|
|
111
|
+
"""
|
|
112
|
+
:param pulumi.Input['pulumi_kubernetes.core.v1.SecurityContextArgs'] container_security_context: Container Security Context to be set on the cainjector component container. ref: https://kubernetes.io/docs/tasks/configure-pod-container/security-context/
|
|
113
|
+
:param pulumi.Input[Mapping[str, pulumi.Input[str]]] deployment_annotations: Optional additional annotations to add to the cainjector Deployment
|
|
114
|
+
:param pulumi.Input[Sequence[pulumi.Input[str]]] extra_args: Optional additional arguments for cainjector
|
|
115
|
+
:param pulumi.Input[Mapping[str, pulumi.Input[str]]] pod_annotations: Optional additional annotations to add to the cainjector Pods
|
|
116
|
+
:param pulumi.Input[Mapping[str, pulumi.Input[str]]] pod_labels: Optional additional labels to add to the Webhook Pods
|
|
117
|
+
:param pulumi.Input['pulumi_kubernetes.core.v1.PodSecurityContextArgs'] pod_security_context: Pod Security Context to be set on the cainjector component Pod. ref: https://kubernetes.io/docs/tasks/configure-pod-container/security-context/
|
|
118
|
+
"""
|
|
119
|
+
if affinity is not None:
|
|
120
|
+
pulumi.set(__self__, "affinity", affinity)
|
|
121
|
+
if container_security_context is not None:
|
|
122
|
+
pulumi.set(__self__, "container_security_context", container_security_context)
|
|
123
|
+
if deployment_annotations is not None:
|
|
124
|
+
pulumi.set(__self__, "deployment_annotations", deployment_annotations)
|
|
125
|
+
if extra_args is not None:
|
|
126
|
+
pulumi.set(__self__, "extra_args", extra_args)
|
|
127
|
+
if image is not None:
|
|
128
|
+
pulumi.set(__self__, "image", image)
|
|
129
|
+
if node_selector is not None:
|
|
130
|
+
pulumi.set(__self__, "node_selector", node_selector)
|
|
131
|
+
if pod_annotations is not None:
|
|
132
|
+
pulumi.set(__self__, "pod_annotations", pod_annotations)
|
|
133
|
+
if pod_labels is not None:
|
|
134
|
+
pulumi.set(__self__, "pod_labels", pod_labels)
|
|
135
|
+
if pod_security_context is not None:
|
|
136
|
+
pulumi.set(__self__, "pod_security_context", pod_security_context)
|
|
137
|
+
if replica_count is not None:
|
|
138
|
+
pulumi.set(__self__, "replica_count", replica_count)
|
|
139
|
+
if resources is not None:
|
|
140
|
+
pulumi.set(__self__, "resources", resources)
|
|
141
|
+
if service_account is not None:
|
|
142
|
+
pulumi.set(__self__, "service_account", service_account)
|
|
143
|
+
if strategy is not None:
|
|
144
|
+
pulumi.set(__self__, "strategy", strategy)
|
|
145
|
+
if timeout_seconds is not None:
|
|
146
|
+
pulumi.set(__self__, "timeout_seconds", timeout_seconds)
|
|
147
|
+
if tolerations is not None:
|
|
148
|
+
pulumi.set(__self__, "tolerations", tolerations)
|
|
149
|
+
|
|
150
|
+
@property
|
|
151
|
+
@pulumi.getter
|
|
152
|
+
def affinity(self) -> Optional[pulumi.Input['pulumi_kubernetes.core.v1.AffinityArgs']]:
|
|
153
|
+
return pulumi.get(self, "affinity")
|
|
154
|
+
|
|
155
|
+
@affinity.setter
|
|
156
|
+
def affinity(self, value: Optional[pulumi.Input['pulumi_kubernetes.core.v1.AffinityArgs']]):
|
|
157
|
+
pulumi.set(self, "affinity", value)
|
|
158
|
+
|
|
159
|
+
@property
|
|
160
|
+
@pulumi.getter(name="containerSecurityContext")
|
|
161
|
+
def container_security_context(self) -> Optional[pulumi.Input['pulumi_kubernetes.core.v1.SecurityContextArgs']]:
|
|
162
|
+
"""
|
|
163
|
+
Container Security Context to be set on the cainjector component container. ref: https://kubernetes.io/docs/tasks/configure-pod-container/security-context/
|
|
164
|
+
"""
|
|
165
|
+
return pulumi.get(self, "container_security_context")
|
|
166
|
+
|
|
167
|
+
@container_security_context.setter
|
|
168
|
+
def container_security_context(self, value: Optional[pulumi.Input['pulumi_kubernetes.core.v1.SecurityContextArgs']]):
|
|
169
|
+
pulumi.set(self, "container_security_context", value)
|
|
170
|
+
|
|
171
|
+
@property
|
|
172
|
+
@pulumi.getter(name="deploymentAnnotations")
|
|
173
|
+
def deployment_annotations(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]:
|
|
174
|
+
"""
|
|
175
|
+
Optional additional annotations to add to the cainjector Deployment
|
|
176
|
+
"""
|
|
177
|
+
return pulumi.get(self, "deployment_annotations")
|
|
178
|
+
|
|
179
|
+
@deployment_annotations.setter
|
|
180
|
+
def deployment_annotations(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]):
|
|
181
|
+
pulumi.set(self, "deployment_annotations", value)
|
|
182
|
+
|
|
183
|
+
@property
|
|
184
|
+
@pulumi.getter(name="extraArgs")
|
|
185
|
+
def extra_args(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
|
|
186
|
+
"""
|
|
187
|
+
Optional additional arguments for cainjector
|
|
188
|
+
"""
|
|
189
|
+
return pulumi.get(self, "extra_args")
|
|
190
|
+
|
|
191
|
+
@extra_args.setter
|
|
192
|
+
def extra_args(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
|
|
193
|
+
pulumi.set(self, "extra_args", value)
|
|
194
|
+
|
|
195
|
+
@property
|
|
196
|
+
@pulumi.getter
|
|
197
|
+
def image(self) -> Optional[pulumi.Input['CertManagerImageArgs']]:
|
|
198
|
+
return pulumi.get(self, "image")
|
|
199
|
+
|
|
200
|
+
@image.setter
|
|
201
|
+
def image(self, value: Optional[pulumi.Input['CertManagerImageArgs']]):
|
|
202
|
+
pulumi.set(self, "image", value)
|
|
203
|
+
|
|
204
|
+
@property
|
|
205
|
+
@pulumi.getter(name="nodeSelector")
|
|
206
|
+
def node_selector(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]:
|
|
207
|
+
return pulumi.get(self, "node_selector")
|
|
208
|
+
|
|
209
|
+
@node_selector.setter
|
|
210
|
+
def node_selector(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]):
|
|
211
|
+
pulumi.set(self, "node_selector", value)
|
|
212
|
+
|
|
213
|
+
@property
|
|
214
|
+
@pulumi.getter(name="podAnnotations")
|
|
215
|
+
def pod_annotations(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]:
|
|
216
|
+
"""
|
|
217
|
+
Optional additional annotations to add to the cainjector Pods
|
|
218
|
+
"""
|
|
219
|
+
return pulumi.get(self, "pod_annotations")
|
|
220
|
+
|
|
221
|
+
@pod_annotations.setter
|
|
222
|
+
def pod_annotations(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]):
|
|
223
|
+
pulumi.set(self, "pod_annotations", value)
|
|
224
|
+
|
|
225
|
+
@property
|
|
226
|
+
@pulumi.getter(name="podLabels")
|
|
227
|
+
def pod_labels(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]:
|
|
228
|
+
"""
|
|
229
|
+
Optional additional labels to add to the Webhook Pods
|
|
230
|
+
"""
|
|
231
|
+
return pulumi.get(self, "pod_labels")
|
|
232
|
+
|
|
233
|
+
@pod_labels.setter
|
|
234
|
+
def pod_labels(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]):
|
|
235
|
+
pulumi.set(self, "pod_labels", value)
|
|
236
|
+
|
|
237
|
+
@property
|
|
238
|
+
@pulumi.getter(name="podSecurityContext")
|
|
239
|
+
def pod_security_context(self) -> Optional[pulumi.Input['pulumi_kubernetes.core.v1.PodSecurityContextArgs']]:
|
|
240
|
+
"""
|
|
241
|
+
Pod Security Context to be set on the cainjector component Pod. ref: https://kubernetes.io/docs/tasks/configure-pod-container/security-context/
|
|
242
|
+
"""
|
|
243
|
+
return pulumi.get(self, "pod_security_context")
|
|
244
|
+
|
|
245
|
+
@pod_security_context.setter
|
|
246
|
+
def pod_security_context(self, value: Optional[pulumi.Input['pulumi_kubernetes.core.v1.PodSecurityContextArgs']]):
|
|
247
|
+
pulumi.set(self, "pod_security_context", value)
|
|
248
|
+
|
|
249
|
+
@property
|
|
250
|
+
@pulumi.getter(name="replicaCount")
|
|
251
|
+
def replica_count(self) -> Optional[pulumi.Input[int]]:
|
|
252
|
+
return pulumi.get(self, "replica_count")
|
|
253
|
+
|
|
254
|
+
@replica_count.setter
|
|
255
|
+
def replica_count(self, value: Optional[pulumi.Input[int]]):
|
|
256
|
+
pulumi.set(self, "replica_count", value)
|
|
257
|
+
|
|
258
|
+
@property
|
|
259
|
+
@pulumi.getter
|
|
260
|
+
def resources(self) -> Optional[pulumi.Input['pulumi_kubernetes.core.v1.ResourceRequirementsArgs']]:
|
|
261
|
+
return pulumi.get(self, "resources")
|
|
262
|
+
|
|
263
|
+
@resources.setter
|
|
264
|
+
def resources(self, value: Optional[pulumi.Input['pulumi_kubernetes.core.v1.ResourceRequirementsArgs']]):
|
|
265
|
+
pulumi.set(self, "resources", value)
|
|
266
|
+
|
|
267
|
+
@property
|
|
268
|
+
@pulumi.getter(name="serviceAccount")
|
|
269
|
+
def service_account(self) -> Optional[pulumi.Input['CertManagerServiceAccountArgs']]:
|
|
270
|
+
return pulumi.get(self, "service_account")
|
|
271
|
+
|
|
272
|
+
@service_account.setter
|
|
273
|
+
def service_account(self, value: Optional[pulumi.Input['CertManagerServiceAccountArgs']]):
|
|
274
|
+
pulumi.set(self, "service_account", value)
|
|
275
|
+
|
|
276
|
+
@property
|
|
277
|
+
@pulumi.getter
|
|
278
|
+
def strategy(self) -> Optional[pulumi.Input['pulumi_kubernetes.apps.v1.DeploymentStrategyArgs']]:
|
|
279
|
+
return pulumi.get(self, "strategy")
|
|
280
|
+
|
|
281
|
+
@strategy.setter
|
|
282
|
+
def strategy(self, value: Optional[pulumi.Input['pulumi_kubernetes.apps.v1.DeploymentStrategyArgs']]):
|
|
283
|
+
pulumi.set(self, "strategy", value)
|
|
284
|
+
|
|
285
|
+
@property
|
|
286
|
+
@pulumi.getter(name="timeoutSeconds")
|
|
287
|
+
def timeout_seconds(self) -> Optional[pulumi.Input[int]]:
|
|
288
|
+
return pulumi.get(self, "timeout_seconds")
|
|
289
|
+
|
|
290
|
+
@timeout_seconds.setter
|
|
291
|
+
def timeout_seconds(self, value: Optional[pulumi.Input[int]]):
|
|
292
|
+
pulumi.set(self, "timeout_seconds", value)
|
|
293
|
+
|
|
294
|
+
@property
|
|
295
|
+
@pulumi.getter
|
|
296
|
+
def tolerations(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['pulumi_kubernetes.core.v1.TolerationArgs']]]]:
|
|
297
|
+
return pulumi.get(self, "tolerations")
|
|
298
|
+
|
|
299
|
+
@tolerations.setter
|
|
300
|
+
def tolerations(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['pulumi_kubernetes.core.v1.TolerationArgs']]]]):
|
|
301
|
+
pulumi.set(self, "tolerations", value)
|
|
302
|
+
|
|
303
|
+
|
|
304
|
+
if not MYPY:
|
|
305
|
+
class CertManagerGlobalLeaderElectionArgsDict(TypedDict):
|
|
306
|
+
lease_duration: NotRequired[pulumi.Input[str]]
|
|
307
|
+
"""
|
|
308
|
+
The duration that non-leader candidates will wait after observing a leadership renewal until attempting to acquire leadership of a led but unrenewed leader slot. This is effectively the maximum duration that a leader can be stopped before it is replaced by another candidate.
|
|
309
|
+
"""
|
|
310
|
+
namespace: NotRequired[pulumi.Input[str]]
|
|
311
|
+
"""
|
|
312
|
+
Override the namespace used to store the ConfigMap for leader election.
|
|
313
|
+
"""
|
|
314
|
+
renew_deadline: NotRequired[pulumi.Input[str]]
|
|
315
|
+
"""
|
|
316
|
+
The interval between attempts by the acting master to renew a leadership slot before it stops leading. This must be less than or equal to the lease duration.
|
|
317
|
+
"""
|
|
318
|
+
elif False:
|
|
319
|
+
CertManagerGlobalLeaderElectionArgsDict: TypeAlias = Mapping[str, Any]
|
|
320
|
+
|
|
321
|
+
@pulumi.input_type
|
|
322
|
+
class CertManagerGlobalLeaderElectionArgs:
|
|
323
|
+
def __init__(__self__, *,
|
|
324
|
+
lease_duration: Optional[pulumi.Input[str]] = None,
|
|
325
|
+
namespace: Optional[pulumi.Input[str]] = None,
|
|
326
|
+
renew_deadline: Optional[pulumi.Input[str]] = None):
|
|
327
|
+
"""
|
|
328
|
+
:param pulumi.Input[str] lease_duration: The duration that non-leader candidates will wait after observing a leadership renewal until attempting to acquire leadership of a led but unrenewed leader slot. This is effectively the maximum duration that a leader can be stopped before it is replaced by another candidate.
|
|
329
|
+
:param pulumi.Input[str] namespace: Override the namespace used to store the ConfigMap for leader election.
|
|
330
|
+
:param pulumi.Input[str] renew_deadline: The interval between attempts by the acting master to renew a leadership slot before it stops leading. This must be less than or equal to the lease duration.
|
|
331
|
+
"""
|
|
332
|
+
if lease_duration is not None:
|
|
333
|
+
pulumi.set(__self__, "lease_duration", lease_duration)
|
|
334
|
+
if namespace is not None:
|
|
335
|
+
pulumi.set(__self__, "namespace", namespace)
|
|
336
|
+
if renew_deadline is not None:
|
|
337
|
+
pulumi.set(__self__, "renew_deadline", renew_deadline)
|
|
338
|
+
|
|
339
|
+
@property
|
|
340
|
+
@pulumi.getter(name="leaseDuration")
|
|
341
|
+
def lease_duration(self) -> Optional[pulumi.Input[str]]:
|
|
342
|
+
"""
|
|
343
|
+
The duration that non-leader candidates will wait after observing a leadership renewal until attempting to acquire leadership of a led but unrenewed leader slot. This is effectively the maximum duration that a leader can be stopped before it is replaced by another candidate.
|
|
344
|
+
"""
|
|
345
|
+
return pulumi.get(self, "lease_duration")
|
|
346
|
+
|
|
347
|
+
@lease_duration.setter
|
|
348
|
+
def lease_duration(self, value: Optional[pulumi.Input[str]]):
|
|
349
|
+
pulumi.set(self, "lease_duration", value)
|
|
350
|
+
|
|
351
|
+
@property
|
|
352
|
+
@pulumi.getter
|
|
353
|
+
def namespace(self) -> Optional[pulumi.Input[str]]:
|
|
354
|
+
"""
|
|
355
|
+
Override the namespace used to store the ConfigMap for leader election.
|
|
356
|
+
"""
|
|
357
|
+
return pulumi.get(self, "namespace")
|
|
358
|
+
|
|
359
|
+
@namespace.setter
|
|
360
|
+
def namespace(self, value: Optional[pulumi.Input[str]]):
|
|
361
|
+
pulumi.set(self, "namespace", value)
|
|
362
|
+
|
|
363
|
+
@property
|
|
364
|
+
@pulumi.getter(name="renewDeadline")
|
|
365
|
+
def renew_deadline(self) -> Optional[pulumi.Input[str]]:
|
|
366
|
+
"""
|
|
367
|
+
The interval between attempts by the acting master to renew a leadership slot before it stops leading. This must be less than or equal to the lease duration.
|
|
368
|
+
"""
|
|
369
|
+
return pulumi.get(self, "renew_deadline")
|
|
370
|
+
|
|
371
|
+
@renew_deadline.setter
|
|
372
|
+
def renew_deadline(self, value: Optional[pulumi.Input[str]]):
|
|
373
|
+
pulumi.set(self, "renew_deadline", value)
|
|
374
|
+
|
|
375
|
+
|
|
376
|
+
if not MYPY:
|
|
377
|
+
class CertManagerGlobalPodSecurityPolicyArgsDict(TypedDict):
|
|
378
|
+
enabled: NotRequired[pulumi.Input[bool]]
|
|
379
|
+
use_app_armor: NotRequired[pulumi.Input[bool]]
|
|
380
|
+
elif False:
|
|
381
|
+
CertManagerGlobalPodSecurityPolicyArgsDict: TypeAlias = Mapping[str, Any]
|
|
382
|
+
|
|
383
|
+
@pulumi.input_type
|
|
384
|
+
class CertManagerGlobalPodSecurityPolicyArgs:
|
|
385
|
+
def __init__(__self__, *,
|
|
386
|
+
enabled: Optional[pulumi.Input[bool]] = None,
|
|
387
|
+
use_app_armor: Optional[pulumi.Input[bool]] = None):
|
|
388
|
+
if enabled is not None:
|
|
389
|
+
pulumi.set(__self__, "enabled", enabled)
|
|
390
|
+
if use_app_armor is not None:
|
|
391
|
+
pulumi.set(__self__, "use_app_armor", use_app_armor)
|
|
392
|
+
|
|
393
|
+
@property
|
|
394
|
+
@pulumi.getter
|
|
395
|
+
def enabled(self) -> Optional[pulumi.Input[bool]]:
|
|
396
|
+
return pulumi.get(self, "enabled")
|
|
397
|
+
|
|
398
|
+
@enabled.setter
|
|
399
|
+
def enabled(self, value: Optional[pulumi.Input[bool]]):
|
|
400
|
+
pulumi.set(self, "enabled", value)
|
|
401
|
+
|
|
402
|
+
@property
|
|
403
|
+
@pulumi.getter(name="useAppArmor")
|
|
404
|
+
def use_app_armor(self) -> Optional[pulumi.Input[bool]]:
|
|
405
|
+
return pulumi.get(self, "use_app_armor")
|
|
406
|
+
|
|
407
|
+
@use_app_armor.setter
|
|
408
|
+
def use_app_armor(self, value: Optional[pulumi.Input[bool]]):
|
|
409
|
+
pulumi.set(self, "use_app_armor", value)
|
|
410
|
+
|
|
411
|
+
|
|
412
|
+
if not MYPY:
|
|
413
|
+
class CertManagerGlobalRbacArgsDict(TypedDict):
|
|
414
|
+
create: NotRequired[pulumi.Input[bool]]
|
|
415
|
+
elif False:
|
|
416
|
+
CertManagerGlobalRbacArgsDict: TypeAlias = Mapping[str, Any]
|
|
417
|
+
|
|
418
|
+
@pulumi.input_type
|
|
419
|
+
class CertManagerGlobalRbacArgs:
|
|
420
|
+
def __init__(__self__, *,
|
|
421
|
+
create: Optional[pulumi.Input[bool]] = None):
|
|
422
|
+
if create is not None:
|
|
423
|
+
pulumi.set(__self__, "create", create)
|
|
424
|
+
|
|
425
|
+
@property
|
|
426
|
+
@pulumi.getter
|
|
427
|
+
def create(self) -> Optional[pulumi.Input[bool]]:
|
|
428
|
+
return pulumi.get(self, "create")
|
|
429
|
+
|
|
430
|
+
@create.setter
|
|
431
|
+
def create(self, value: Optional[pulumi.Input[bool]]):
|
|
432
|
+
pulumi.set(self, "create", value)
|
|
433
|
+
|
|
434
|
+
|
|
435
|
+
if not MYPY:
|
|
436
|
+
class CertManagerGlobalArgsDict(TypedDict):
|
|
437
|
+
image_pull_secrets: NotRequired[pulumi.Input[Sequence[pulumi.Input['pulumi_kubernetes.core.v1.LocalObjectReferenceArgsDict']]]]
|
|
438
|
+
"""
|
|
439
|
+
Reference to one or more secrets to be used when pulling images. ref: https://kubernetes.io/docs/tasks/configure-pod-container/pull-image-private-registry/
|
|
440
|
+
"""
|
|
441
|
+
leader_election: NotRequired[pulumi.Input['CertManagerGlobalLeaderElectionArgsDict']]
|
|
442
|
+
log_level: NotRequired[pulumi.Input[int]]
|
|
443
|
+
"""
|
|
444
|
+
Set the verbosity of cert-manager. Range of 0 - 6 with 6 being the most verbose.
|
|
445
|
+
"""
|
|
446
|
+
pod_security_policy: NotRequired[pulumi.Input['CertManagerGlobalPodSecurityPolicyArgsDict']]
|
|
447
|
+
priority_class_name: NotRequired[pulumi.Input[str]]
|
|
448
|
+
"""
|
|
449
|
+
Optional priority class to be used for the cert-manager pods.
|
|
450
|
+
"""
|
|
451
|
+
rbac: NotRequired[pulumi.Input['CertManagerGlobalRbacArgsDict']]
|
|
452
|
+
elif False:
|
|
453
|
+
CertManagerGlobalArgsDict: TypeAlias = Mapping[str, Any]
|
|
454
|
+
|
|
455
|
+
@pulumi.input_type
|
|
456
|
+
class CertManagerGlobalArgs:
|
|
457
|
+
def __init__(__self__, *,
|
|
458
|
+
image_pull_secrets: Optional[pulumi.Input[Sequence[pulumi.Input['pulumi_kubernetes.core.v1.LocalObjectReferenceArgs']]]] = None,
|
|
459
|
+
leader_election: Optional[pulumi.Input['CertManagerGlobalLeaderElectionArgs']] = None,
|
|
460
|
+
log_level: Optional[pulumi.Input[int]] = None,
|
|
461
|
+
pod_security_policy: Optional[pulumi.Input['CertManagerGlobalPodSecurityPolicyArgs']] = None,
|
|
462
|
+
priority_class_name: Optional[pulumi.Input[str]] = None,
|
|
463
|
+
rbac: Optional[pulumi.Input['CertManagerGlobalRbacArgs']] = None):
|
|
464
|
+
"""
|
|
465
|
+
:param pulumi.Input[Sequence[pulumi.Input['pulumi_kubernetes.core.v1.LocalObjectReferenceArgs']]] image_pull_secrets: Reference to one or more secrets to be used when pulling images. ref: https://kubernetes.io/docs/tasks/configure-pod-container/pull-image-private-registry/
|
|
466
|
+
:param pulumi.Input[int] log_level: Set the verbosity of cert-manager. Range of 0 - 6 with 6 being the most verbose.
|
|
467
|
+
:param pulumi.Input[str] priority_class_name: Optional priority class to be used for the cert-manager pods.
|
|
468
|
+
"""
|
|
469
|
+
if image_pull_secrets is not None:
|
|
470
|
+
pulumi.set(__self__, "image_pull_secrets", image_pull_secrets)
|
|
471
|
+
if leader_election is not None:
|
|
472
|
+
pulumi.set(__self__, "leader_election", leader_election)
|
|
473
|
+
if log_level is not None:
|
|
474
|
+
pulumi.set(__self__, "log_level", log_level)
|
|
475
|
+
if pod_security_policy is not None:
|
|
476
|
+
pulumi.set(__self__, "pod_security_policy", pod_security_policy)
|
|
477
|
+
if priority_class_name is not None:
|
|
478
|
+
pulumi.set(__self__, "priority_class_name", priority_class_name)
|
|
479
|
+
if rbac is not None:
|
|
480
|
+
pulumi.set(__self__, "rbac", rbac)
|
|
481
|
+
|
|
482
|
+
@property
|
|
483
|
+
@pulumi.getter(name="imagePullSecrets")
|
|
484
|
+
def image_pull_secrets(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['pulumi_kubernetes.core.v1.LocalObjectReferenceArgs']]]]:
|
|
485
|
+
"""
|
|
486
|
+
Reference to one or more secrets to be used when pulling images. ref: https://kubernetes.io/docs/tasks/configure-pod-container/pull-image-private-registry/
|
|
487
|
+
"""
|
|
488
|
+
return pulumi.get(self, "image_pull_secrets")
|
|
489
|
+
|
|
490
|
+
@image_pull_secrets.setter
|
|
491
|
+
def image_pull_secrets(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['pulumi_kubernetes.core.v1.LocalObjectReferenceArgs']]]]):
|
|
492
|
+
pulumi.set(self, "image_pull_secrets", value)
|
|
493
|
+
|
|
494
|
+
@property
|
|
495
|
+
@pulumi.getter(name="leaderElection")
|
|
496
|
+
def leader_election(self) -> Optional[pulumi.Input['CertManagerGlobalLeaderElectionArgs']]:
|
|
497
|
+
return pulumi.get(self, "leader_election")
|
|
498
|
+
|
|
499
|
+
@leader_election.setter
|
|
500
|
+
def leader_election(self, value: Optional[pulumi.Input['CertManagerGlobalLeaderElectionArgs']]):
|
|
501
|
+
pulumi.set(self, "leader_election", value)
|
|
502
|
+
|
|
503
|
+
@property
|
|
504
|
+
@pulumi.getter(name="logLevel")
|
|
505
|
+
def log_level(self) -> Optional[pulumi.Input[int]]:
|
|
506
|
+
"""
|
|
507
|
+
Set the verbosity of cert-manager. Range of 0 - 6 with 6 being the most verbose.
|
|
508
|
+
"""
|
|
509
|
+
return pulumi.get(self, "log_level")
|
|
510
|
+
|
|
511
|
+
@log_level.setter
|
|
512
|
+
def log_level(self, value: Optional[pulumi.Input[int]]):
|
|
513
|
+
pulumi.set(self, "log_level", value)
|
|
514
|
+
|
|
515
|
+
@property
|
|
516
|
+
@pulumi.getter(name="podSecurityPolicy")
|
|
517
|
+
def pod_security_policy(self) -> Optional[pulumi.Input['CertManagerGlobalPodSecurityPolicyArgs']]:
|
|
518
|
+
return pulumi.get(self, "pod_security_policy")
|
|
519
|
+
|
|
520
|
+
@pod_security_policy.setter
|
|
521
|
+
def pod_security_policy(self, value: Optional[pulumi.Input['CertManagerGlobalPodSecurityPolicyArgs']]):
|
|
522
|
+
pulumi.set(self, "pod_security_policy", value)
|
|
523
|
+
|
|
524
|
+
@property
|
|
525
|
+
@pulumi.getter(name="priorityClassName")
|
|
526
|
+
def priority_class_name(self) -> Optional[pulumi.Input[str]]:
|
|
527
|
+
"""
|
|
528
|
+
Optional priority class to be used for the cert-manager pods.
|
|
529
|
+
"""
|
|
530
|
+
return pulumi.get(self, "priority_class_name")
|
|
531
|
+
|
|
532
|
+
@priority_class_name.setter
|
|
533
|
+
def priority_class_name(self, value: Optional[pulumi.Input[str]]):
|
|
534
|
+
pulumi.set(self, "priority_class_name", value)
|
|
535
|
+
|
|
536
|
+
@property
|
|
537
|
+
@pulumi.getter
|
|
538
|
+
def rbac(self) -> Optional[pulumi.Input['CertManagerGlobalRbacArgs']]:
|
|
539
|
+
return pulumi.get(self, "rbac")
|
|
540
|
+
|
|
541
|
+
@rbac.setter
|
|
542
|
+
def rbac(self, value: Optional[pulumi.Input['CertManagerGlobalRbacArgs']]):
|
|
543
|
+
pulumi.set(self, "rbac", value)
|
|
544
|
+
|
|
545
|
+
|
|
546
|
+
if not MYPY:
|
|
547
|
+
class CertManagerImageArgsDict(TypedDict):
|
|
548
|
+
digest: NotRequired[pulumi.Input[str]]
|
|
549
|
+
"""
|
|
550
|
+
Setting a digest will override any tag, e.g. `digest: sha256:0e072dddd1f7f8fc8909a2ca6f65e76c5f0d2fcfb8be47935ae3457e8bbceb20`.
|
|
551
|
+
"""
|
|
552
|
+
pull_policy: NotRequired[pulumi.Input[str]]
|
|
553
|
+
registry: NotRequired[pulumi.Input[str]]
|
|
554
|
+
"""
|
|
555
|
+
You can manage a registry with `registry: quay.io`.
|
|
556
|
+
"""
|
|
557
|
+
repository: NotRequired[pulumi.Input[str]]
|
|
558
|
+
"""
|
|
559
|
+
You can manage a registry with `repository: jetstack/cert-manager-controller`.
|
|
560
|
+
"""
|
|
561
|
+
tag: NotRequired[pulumi.Input[str]]
|
|
562
|
+
"""
|
|
563
|
+
Override the image tag to deploy by setting this variable. If no value is set, the chart's appVersion will be used.
|
|
564
|
+
"""
|
|
565
|
+
elif False:
|
|
566
|
+
CertManagerImageArgsDict: TypeAlias = Mapping[str, Any]
|
|
567
|
+
|
|
568
|
+
@pulumi.input_type
|
|
569
|
+
class CertManagerImageArgs:
|
|
570
|
+
def __init__(__self__, *,
|
|
571
|
+
digest: Optional[pulumi.Input[str]] = None,
|
|
572
|
+
pull_policy: Optional[pulumi.Input[str]] = None,
|
|
573
|
+
registry: Optional[pulumi.Input[str]] = None,
|
|
574
|
+
repository: Optional[pulumi.Input[str]] = None,
|
|
575
|
+
tag: Optional[pulumi.Input[str]] = None):
|
|
576
|
+
"""
|
|
577
|
+
:param pulumi.Input[str] digest: Setting a digest will override any tag, e.g. `digest: sha256:0e072dddd1f7f8fc8909a2ca6f65e76c5f0d2fcfb8be47935ae3457e8bbceb20`.
|
|
578
|
+
:param pulumi.Input[str] registry: You can manage a registry with `registry: quay.io`.
|
|
579
|
+
:param pulumi.Input[str] repository: You can manage a registry with `repository: jetstack/cert-manager-controller`.
|
|
580
|
+
:param pulumi.Input[str] tag: Override the image tag to deploy by setting this variable. If no value is set, the chart's appVersion will be used.
|
|
581
|
+
"""
|
|
582
|
+
if digest is not None:
|
|
583
|
+
pulumi.set(__self__, "digest", digest)
|
|
584
|
+
if pull_policy is not None:
|
|
585
|
+
pulumi.set(__self__, "pull_policy", pull_policy)
|
|
586
|
+
if registry is not None:
|
|
587
|
+
pulumi.set(__self__, "registry", registry)
|
|
588
|
+
if repository is not None:
|
|
589
|
+
pulumi.set(__self__, "repository", repository)
|
|
590
|
+
if tag is not None:
|
|
591
|
+
pulumi.set(__self__, "tag", tag)
|
|
592
|
+
|
|
593
|
+
@property
|
|
594
|
+
@pulumi.getter
|
|
595
|
+
def digest(self) -> Optional[pulumi.Input[str]]:
|
|
596
|
+
"""
|
|
597
|
+
Setting a digest will override any tag, e.g. `digest: sha256:0e072dddd1f7f8fc8909a2ca6f65e76c5f0d2fcfb8be47935ae3457e8bbceb20`.
|
|
598
|
+
"""
|
|
599
|
+
return pulumi.get(self, "digest")
|
|
600
|
+
|
|
601
|
+
@digest.setter
|
|
602
|
+
def digest(self, value: Optional[pulumi.Input[str]]):
|
|
603
|
+
pulumi.set(self, "digest", value)
|
|
604
|
+
|
|
605
|
+
@property
|
|
606
|
+
@pulumi.getter(name="pullPolicy")
|
|
607
|
+
def pull_policy(self) -> Optional[pulumi.Input[str]]:
|
|
608
|
+
return pulumi.get(self, "pull_policy")
|
|
609
|
+
|
|
610
|
+
@pull_policy.setter
|
|
611
|
+
def pull_policy(self, value: Optional[pulumi.Input[str]]):
|
|
612
|
+
pulumi.set(self, "pull_policy", value)
|
|
613
|
+
|
|
614
|
+
@property
|
|
615
|
+
@pulumi.getter
|
|
616
|
+
def registry(self) -> Optional[pulumi.Input[str]]:
|
|
617
|
+
"""
|
|
618
|
+
You can manage a registry with `registry: quay.io`.
|
|
619
|
+
"""
|
|
620
|
+
return pulumi.get(self, "registry")
|
|
621
|
+
|
|
622
|
+
@registry.setter
|
|
623
|
+
def registry(self, value: Optional[pulumi.Input[str]]):
|
|
624
|
+
pulumi.set(self, "registry", value)
|
|
625
|
+
|
|
626
|
+
@property
|
|
627
|
+
@pulumi.getter
|
|
628
|
+
def repository(self) -> Optional[pulumi.Input[str]]:
|
|
629
|
+
"""
|
|
630
|
+
You can manage a registry with `repository: jetstack/cert-manager-controller`.
|
|
631
|
+
"""
|
|
632
|
+
return pulumi.get(self, "repository")
|
|
633
|
+
|
|
634
|
+
@repository.setter
|
|
635
|
+
def repository(self, value: Optional[pulumi.Input[str]]):
|
|
636
|
+
pulumi.set(self, "repository", value)
|
|
637
|
+
|
|
638
|
+
@property
|
|
639
|
+
@pulumi.getter
|
|
640
|
+
def tag(self) -> Optional[pulumi.Input[str]]:
|
|
641
|
+
"""
|
|
642
|
+
Override the image tag to deploy by setting this variable. If no value is set, the chart's appVersion will be used.
|
|
643
|
+
"""
|
|
644
|
+
return pulumi.get(self, "tag")
|
|
645
|
+
|
|
646
|
+
@tag.setter
|
|
647
|
+
def tag(self, value: Optional[pulumi.Input[str]]):
|
|
648
|
+
pulumi.set(self, "tag", value)
|
|
649
|
+
|
|
650
|
+
|
|
651
|
+
if not MYPY:
|
|
652
|
+
class CertManagerIngressShimArgsDict(TypedDict):
|
|
653
|
+
default_issuer_group: NotRequired[pulumi.Input[str]]
|
|
654
|
+
default_issuer_kind: NotRequired[pulumi.Input[str]]
|
|
655
|
+
default_issuer_name: NotRequired[pulumi.Input[str]]
|
|
656
|
+
elif False:
|
|
657
|
+
CertManagerIngressShimArgsDict: TypeAlias = Mapping[str, Any]
|
|
658
|
+
|
|
659
|
+
@pulumi.input_type
|
|
660
|
+
class CertManagerIngressShimArgs:
|
|
661
|
+
def __init__(__self__, *,
|
|
662
|
+
default_issuer_group: Optional[pulumi.Input[str]] = None,
|
|
663
|
+
default_issuer_kind: Optional[pulumi.Input[str]] = None,
|
|
664
|
+
default_issuer_name: Optional[pulumi.Input[str]] = None):
|
|
665
|
+
if default_issuer_group is not None:
|
|
666
|
+
pulumi.set(__self__, "default_issuer_group", default_issuer_group)
|
|
667
|
+
if default_issuer_kind is not None:
|
|
668
|
+
pulumi.set(__self__, "default_issuer_kind", default_issuer_kind)
|
|
669
|
+
if default_issuer_name is not None:
|
|
670
|
+
pulumi.set(__self__, "default_issuer_name", default_issuer_name)
|
|
671
|
+
|
|
672
|
+
@property
|
|
673
|
+
@pulumi.getter(name="defaultIssuerGroup")
|
|
674
|
+
def default_issuer_group(self) -> Optional[pulumi.Input[str]]:
|
|
675
|
+
return pulumi.get(self, "default_issuer_group")
|
|
676
|
+
|
|
677
|
+
@default_issuer_group.setter
|
|
678
|
+
def default_issuer_group(self, value: Optional[pulumi.Input[str]]):
|
|
679
|
+
pulumi.set(self, "default_issuer_group", value)
|
|
680
|
+
|
|
681
|
+
@property
|
|
682
|
+
@pulumi.getter(name="defaultIssuerKind")
|
|
683
|
+
def default_issuer_kind(self) -> Optional[pulumi.Input[str]]:
|
|
684
|
+
return pulumi.get(self, "default_issuer_kind")
|
|
685
|
+
|
|
686
|
+
@default_issuer_kind.setter
|
|
687
|
+
def default_issuer_kind(self, value: Optional[pulumi.Input[str]]):
|
|
688
|
+
pulumi.set(self, "default_issuer_kind", value)
|
|
689
|
+
|
|
690
|
+
@property
|
|
691
|
+
@pulumi.getter(name="defaultIssuerName")
|
|
692
|
+
def default_issuer_name(self) -> Optional[pulumi.Input[str]]:
|
|
693
|
+
return pulumi.get(self, "default_issuer_name")
|
|
694
|
+
|
|
695
|
+
@default_issuer_name.setter
|
|
696
|
+
def default_issuer_name(self, value: Optional[pulumi.Input[str]]):
|
|
697
|
+
pulumi.set(self, "default_issuer_name", value)
|
|
698
|
+
|
|
699
|
+
|
|
700
|
+
if not MYPY:
|
|
701
|
+
class CertManagerPrometheusServiceMonitorArgsDict(TypedDict):
|
|
702
|
+
enabled: NotRequired[pulumi.Input[bool]]
|
|
703
|
+
interval: NotRequired[pulumi.Input[str]]
|
|
704
|
+
labels: NotRequired[pulumi.Input[Mapping[str, pulumi.Input[str]]]]
|
|
705
|
+
path: NotRequired[pulumi.Input[str]]
|
|
706
|
+
prometheus_instance: NotRequired[pulumi.Input[str]]
|
|
707
|
+
string: NotRequired[pulumi.Input[str]]
|
|
708
|
+
target_port: NotRequired[pulumi.Input[int]]
|
|
709
|
+
elif False:
|
|
710
|
+
CertManagerPrometheusServiceMonitorArgsDict: TypeAlias = Mapping[str, Any]
|
|
711
|
+
|
|
712
|
+
@pulumi.input_type
|
|
713
|
+
class CertManagerPrometheusServiceMonitorArgs:
|
|
714
|
+
def __init__(__self__, *,
|
|
715
|
+
enabled: Optional[pulumi.Input[bool]] = None,
|
|
716
|
+
interval: Optional[pulumi.Input[str]] = None,
|
|
717
|
+
labels: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None,
|
|
718
|
+
path: Optional[pulumi.Input[str]] = None,
|
|
719
|
+
prometheus_instance: Optional[pulumi.Input[str]] = None,
|
|
720
|
+
string: Optional[pulumi.Input[str]] = None,
|
|
721
|
+
target_port: Optional[pulumi.Input[int]] = None):
|
|
722
|
+
if enabled is not None:
|
|
723
|
+
pulumi.set(__self__, "enabled", enabled)
|
|
724
|
+
if interval is not None:
|
|
725
|
+
pulumi.set(__self__, "interval", interval)
|
|
726
|
+
if labels is not None:
|
|
727
|
+
pulumi.set(__self__, "labels", labels)
|
|
728
|
+
if path is not None:
|
|
729
|
+
pulumi.set(__self__, "path", path)
|
|
730
|
+
if prometheus_instance is not None:
|
|
731
|
+
pulumi.set(__self__, "prometheus_instance", prometheus_instance)
|
|
732
|
+
if string is not None:
|
|
733
|
+
pulumi.set(__self__, "string", string)
|
|
734
|
+
if target_port is not None:
|
|
735
|
+
pulumi.set(__self__, "target_port", target_port)
|
|
736
|
+
|
|
737
|
+
@property
|
|
738
|
+
@pulumi.getter
|
|
739
|
+
def enabled(self) -> Optional[pulumi.Input[bool]]:
|
|
740
|
+
return pulumi.get(self, "enabled")
|
|
741
|
+
|
|
742
|
+
@enabled.setter
|
|
743
|
+
def enabled(self, value: Optional[pulumi.Input[bool]]):
|
|
744
|
+
pulumi.set(self, "enabled", value)
|
|
745
|
+
|
|
746
|
+
@property
|
|
747
|
+
@pulumi.getter
|
|
748
|
+
def interval(self) -> Optional[pulumi.Input[str]]:
|
|
749
|
+
return pulumi.get(self, "interval")
|
|
750
|
+
|
|
751
|
+
@interval.setter
|
|
752
|
+
def interval(self, value: Optional[pulumi.Input[str]]):
|
|
753
|
+
pulumi.set(self, "interval", value)
|
|
754
|
+
|
|
755
|
+
@property
|
|
756
|
+
@pulumi.getter
|
|
757
|
+
def labels(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]:
|
|
758
|
+
return pulumi.get(self, "labels")
|
|
759
|
+
|
|
760
|
+
@labels.setter
|
|
761
|
+
def labels(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]):
|
|
762
|
+
pulumi.set(self, "labels", value)
|
|
763
|
+
|
|
764
|
+
@property
|
|
765
|
+
@pulumi.getter
|
|
766
|
+
def path(self) -> Optional[pulumi.Input[str]]:
|
|
767
|
+
return pulumi.get(self, "path")
|
|
768
|
+
|
|
769
|
+
@path.setter
|
|
770
|
+
def path(self, value: Optional[pulumi.Input[str]]):
|
|
771
|
+
pulumi.set(self, "path", value)
|
|
772
|
+
|
|
773
|
+
@property
|
|
774
|
+
@pulumi.getter(name="prometheusInstance")
|
|
775
|
+
def prometheus_instance(self) -> Optional[pulumi.Input[str]]:
|
|
776
|
+
return pulumi.get(self, "prometheus_instance")
|
|
777
|
+
|
|
778
|
+
@prometheus_instance.setter
|
|
779
|
+
def prometheus_instance(self, value: Optional[pulumi.Input[str]]):
|
|
780
|
+
pulumi.set(self, "prometheus_instance", value)
|
|
781
|
+
|
|
782
|
+
@property
|
|
783
|
+
@pulumi.getter
|
|
784
|
+
def string(self) -> Optional[pulumi.Input[str]]:
|
|
785
|
+
return pulumi.get(self, "string")
|
|
786
|
+
|
|
787
|
+
@string.setter
|
|
788
|
+
def string(self, value: Optional[pulumi.Input[str]]):
|
|
789
|
+
pulumi.set(self, "string", value)
|
|
790
|
+
|
|
791
|
+
@property
|
|
792
|
+
@pulumi.getter(name="targetPort")
|
|
793
|
+
def target_port(self) -> Optional[pulumi.Input[int]]:
|
|
794
|
+
return pulumi.get(self, "target_port")
|
|
795
|
+
|
|
796
|
+
@target_port.setter
|
|
797
|
+
def target_port(self, value: Optional[pulumi.Input[int]]):
|
|
798
|
+
pulumi.set(self, "target_port", value)
|
|
799
|
+
|
|
800
|
+
|
|
801
|
+
if not MYPY:
|
|
802
|
+
class CertManagerPrometheusArgsDict(TypedDict):
|
|
803
|
+
enabled: NotRequired[pulumi.Input[bool]]
|
|
804
|
+
service_monitor: NotRequired[pulumi.Input['CertManagerPrometheusServiceMonitorArgsDict']]
|
|
805
|
+
elif False:
|
|
806
|
+
CertManagerPrometheusArgsDict: TypeAlias = Mapping[str, Any]
|
|
807
|
+
|
|
808
|
+
@pulumi.input_type
|
|
809
|
+
class CertManagerPrometheusArgs:
|
|
810
|
+
def __init__(__self__, *,
|
|
811
|
+
enabled: Optional[pulumi.Input[bool]] = None,
|
|
812
|
+
service_monitor: Optional[pulumi.Input['CertManagerPrometheusServiceMonitorArgs']] = None):
|
|
813
|
+
if enabled is not None:
|
|
814
|
+
pulumi.set(__self__, "enabled", enabled)
|
|
815
|
+
if service_monitor is not None:
|
|
816
|
+
pulumi.set(__self__, "service_monitor", service_monitor)
|
|
817
|
+
|
|
818
|
+
@property
|
|
819
|
+
@pulumi.getter
|
|
820
|
+
def enabled(self) -> Optional[pulumi.Input[bool]]:
|
|
821
|
+
return pulumi.get(self, "enabled")
|
|
822
|
+
|
|
823
|
+
@enabled.setter
|
|
824
|
+
def enabled(self, value: Optional[pulumi.Input[bool]]):
|
|
825
|
+
pulumi.set(self, "enabled", value)
|
|
826
|
+
|
|
827
|
+
@property
|
|
828
|
+
@pulumi.getter(name="serviceMonitor")
|
|
829
|
+
def service_monitor(self) -> Optional[pulumi.Input['CertManagerPrometheusServiceMonitorArgs']]:
|
|
830
|
+
return pulumi.get(self, "service_monitor")
|
|
831
|
+
|
|
832
|
+
@service_monitor.setter
|
|
833
|
+
def service_monitor(self, value: Optional[pulumi.Input['CertManagerPrometheusServiceMonitorArgs']]):
|
|
834
|
+
pulumi.set(self, "service_monitor", value)
|
|
835
|
+
|
|
836
|
+
|
|
837
|
+
if not MYPY:
|
|
838
|
+
class CertManagerServiceAccountArgsDict(TypedDict):
|
|
839
|
+
annotations: NotRequired[pulumi.Input[Mapping[str, pulumi.Input[str]]]]
|
|
840
|
+
"""
|
|
841
|
+
Optional additional annotations to add to the controller's ServiceAccount.
|
|
842
|
+
"""
|
|
843
|
+
automount_service_account_token: NotRequired[pulumi.Input[bool]]
|
|
844
|
+
"""
|
|
845
|
+
Automount API credentials for a Service Account.
|
|
846
|
+
"""
|
|
847
|
+
create: NotRequired[pulumi.Input[bool]]
|
|
848
|
+
"""
|
|
849
|
+
Specifies whether a service account should be created
|
|
850
|
+
"""
|
|
851
|
+
name: NotRequired[pulumi.Input[str]]
|
|
852
|
+
"""
|
|
853
|
+
The name of the service account to use. If not set and create is true, a name is generated using the fullname template.
|
|
854
|
+
"""
|
|
855
|
+
elif False:
|
|
856
|
+
CertManagerServiceAccountArgsDict: TypeAlias = Mapping[str, Any]
|
|
857
|
+
|
|
858
|
+
@pulumi.input_type
|
|
859
|
+
class CertManagerServiceAccountArgs:
|
|
860
|
+
def __init__(__self__, *,
|
|
861
|
+
annotations: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None,
|
|
862
|
+
automount_service_account_token: Optional[pulumi.Input[bool]] = None,
|
|
863
|
+
create: Optional[pulumi.Input[bool]] = None,
|
|
864
|
+
name: Optional[pulumi.Input[str]] = None):
|
|
865
|
+
"""
|
|
866
|
+
:param pulumi.Input[Mapping[str, pulumi.Input[str]]] annotations: Optional additional annotations to add to the controller's ServiceAccount.
|
|
867
|
+
:param pulumi.Input[bool] automount_service_account_token: Automount API credentials for a Service Account.
|
|
868
|
+
:param pulumi.Input[bool] create: Specifies whether a service account should be created
|
|
869
|
+
:param pulumi.Input[str] name: The name of the service account to use. If not set and create is true, a name is generated using the fullname template.
|
|
870
|
+
"""
|
|
871
|
+
if annotations is not None:
|
|
872
|
+
pulumi.set(__self__, "annotations", annotations)
|
|
873
|
+
if automount_service_account_token is not None:
|
|
874
|
+
pulumi.set(__self__, "automount_service_account_token", automount_service_account_token)
|
|
875
|
+
if create is not None:
|
|
876
|
+
pulumi.set(__self__, "create", create)
|
|
877
|
+
if name is not None:
|
|
878
|
+
pulumi.set(__self__, "name", name)
|
|
879
|
+
|
|
880
|
+
@property
|
|
881
|
+
@pulumi.getter
|
|
882
|
+
def annotations(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]:
|
|
883
|
+
"""
|
|
884
|
+
Optional additional annotations to add to the controller's ServiceAccount.
|
|
885
|
+
"""
|
|
886
|
+
return pulumi.get(self, "annotations")
|
|
887
|
+
|
|
888
|
+
@annotations.setter
|
|
889
|
+
def annotations(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]):
|
|
890
|
+
pulumi.set(self, "annotations", value)
|
|
891
|
+
|
|
892
|
+
@property
|
|
893
|
+
@pulumi.getter(name="automountServiceAccountToken")
|
|
894
|
+
def automount_service_account_token(self) -> Optional[pulumi.Input[bool]]:
|
|
895
|
+
"""
|
|
896
|
+
Automount API credentials for a Service Account.
|
|
897
|
+
"""
|
|
898
|
+
return pulumi.get(self, "automount_service_account_token")
|
|
899
|
+
|
|
900
|
+
@automount_service_account_token.setter
|
|
901
|
+
def automount_service_account_token(self, value: Optional[pulumi.Input[bool]]):
|
|
902
|
+
pulumi.set(self, "automount_service_account_token", value)
|
|
903
|
+
|
|
904
|
+
@property
|
|
905
|
+
@pulumi.getter
|
|
906
|
+
def create(self) -> Optional[pulumi.Input[bool]]:
|
|
907
|
+
"""
|
|
908
|
+
Specifies whether a service account should be created
|
|
909
|
+
"""
|
|
910
|
+
return pulumi.get(self, "create")
|
|
911
|
+
|
|
912
|
+
@create.setter
|
|
913
|
+
def create(self, value: Optional[pulumi.Input[bool]]):
|
|
914
|
+
pulumi.set(self, "create", value)
|
|
915
|
+
|
|
916
|
+
@property
|
|
917
|
+
@pulumi.getter
|
|
918
|
+
def name(self) -> Optional[pulumi.Input[str]]:
|
|
919
|
+
"""
|
|
920
|
+
The name of the service account to use. If not set and create is true, a name is generated using the fullname template.
|
|
921
|
+
"""
|
|
922
|
+
return pulumi.get(self, "name")
|
|
923
|
+
|
|
924
|
+
@name.setter
|
|
925
|
+
def name(self, value: Optional[pulumi.Input[str]]):
|
|
926
|
+
pulumi.set(self, "name", value)
|
|
927
|
+
|
|
928
|
+
|
|
929
|
+
if not MYPY:
|
|
930
|
+
class CertManagerStartupAPICheckRBACArgsDict(TypedDict):
|
|
931
|
+
annotations: NotRequired[pulumi.Input[Mapping[str, pulumi.Input[str]]]]
|
|
932
|
+
"""
|
|
933
|
+
annotations for the startup API Check job RBAC and PSP resources
|
|
934
|
+
"""
|
|
935
|
+
elif False:
|
|
936
|
+
CertManagerStartupAPICheckRBACArgsDict: TypeAlias = Mapping[str, Any]
|
|
937
|
+
|
|
938
|
+
@pulumi.input_type
|
|
939
|
+
class CertManagerStartupAPICheckRBACArgs:
|
|
940
|
+
def __init__(__self__, *,
|
|
941
|
+
annotations: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None):
|
|
942
|
+
"""
|
|
943
|
+
:param pulumi.Input[Mapping[str, pulumi.Input[str]]] annotations: annotations for the startup API Check job RBAC and PSP resources
|
|
944
|
+
"""
|
|
945
|
+
if annotations is not None:
|
|
946
|
+
pulumi.set(__self__, "annotations", annotations)
|
|
947
|
+
|
|
948
|
+
@property
|
|
949
|
+
@pulumi.getter
|
|
950
|
+
def annotations(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]:
|
|
951
|
+
"""
|
|
952
|
+
annotations for the startup API Check job RBAC and PSP resources
|
|
953
|
+
"""
|
|
954
|
+
return pulumi.get(self, "annotations")
|
|
955
|
+
|
|
956
|
+
@annotations.setter
|
|
957
|
+
def annotations(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]):
|
|
958
|
+
pulumi.set(self, "annotations", value)
|
|
959
|
+
|
|
960
|
+
|
|
961
|
+
if not MYPY:
|
|
962
|
+
class CertManagerStartupAPICheckArgsDict(TypedDict):
|
|
963
|
+
affinity: NotRequired[pulumi.Input['pulumi_kubernetes.core.v1.AffinityArgsDict']]
|
|
964
|
+
backoff_limit: NotRequired[pulumi.Input[int]]
|
|
965
|
+
"""
|
|
966
|
+
Job backoffLimit
|
|
967
|
+
"""
|
|
968
|
+
enabled: NotRequired[pulumi.Input[bool]]
|
|
969
|
+
extra_args: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
|
|
970
|
+
"""
|
|
971
|
+
Optional additional arguments for startupapicheck
|
|
972
|
+
"""
|
|
973
|
+
image: NotRequired[pulumi.Input['CertManagerImageArgsDict']]
|
|
974
|
+
job_annotations: NotRequired[pulumi.Input[Mapping[str, pulumi.Input[str]]]]
|
|
975
|
+
"""
|
|
976
|
+
Optional additional annotations to add to the startupapicheck Job
|
|
977
|
+
"""
|
|
978
|
+
node_selector: NotRequired[pulumi.Input[Mapping[str, pulumi.Input[str]]]]
|
|
979
|
+
pod_annotations: NotRequired[pulumi.Input[Mapping[str, pulumi.Input[str]]]]
|
|
980
|
+
"""
|
|
981
|
+
Optional additional annotations to add to the startupapicheck Pods
|
|
982
|
+
"""
|
|
983
|
+
pod_labels: NotRequired[pulumi.Input[Mapping[str, pulumi.Input[str]]]]
|
|
984
|
+
"""
|
|
985
|
+
Optional additional labels to add to the startupapicheck Pods
|
|
986
|
+
"""
|
|
987
|
+
rbac: NotRequired[pulumi.Input['CertManagerStartupAPICheckRBACArgsDict']]
|
|
988
|
+
resources: NotRequired[pulumi.Input['pulumi_kubernetes.core.v1.ResourceRequirementsArgsDict']]
|
|
989
|
+
security_context: NotRequired[pulumi.Input['pulumi_kubernetes.core.v1.PodSecurityContextArgsDict']]
|
|
990
|
+
"""
|
|
991
|
+
Pod Security Context to be set on the startupapicheck component Pod. ref: https://kubernetes.io/docs/tasks/configure-pod-container/security-context/
|
|
992
|
+
"""
|
|
993
|
+
service_account: NotRequired[pulumi.Input['CertManagerServiceAccountArgsDict']]
|
|
994
|
+
timeout: NotRequired[pulumi.Input[str]]
|
|
995
|
+
"""
|
|
996
|
+
Timeout for 'kubectl check api' command
|
|
997
|
+
"""
|
|
998
|
+
tolerations: NotRequired[pulumi.Input[Sequence[pulumi.Input['pulumi_kubernetes.core.v1.TolerationArgsDict']]]]
|
|
999
|
+
elif False:
|
|
1000
|
+
CertManagerStartupAPICheckArgsDict: TypeAlias = Mapping[str, Any]
|
|
1001
|
+
|
|
1002
|
+
@pulumi.input_type
|
|
1003
|
+
class CertManagerStartupAPICheckArgs:
|
|
1004
|
+
def __init__(__self__, *,
|
|
1005
|
+
affinity: Optional[pulumi.Input['pulumi_kubernetes.core.v1.AffinityArgs']] = None,
|
|
1006
|
+
backoff_limit: Optional[pulumi.Input[int]] = None,
|
|
1007
|
+
enabled: Optional[pulumi.Input[bool]] = None,
|
|
1008
|
+
extra_args: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
|
|
1009
|
+
image: Optional[pulumi.Input['CertManagerImageArgs']] = None,
|
|
1010
|
+
job_annotations: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None,
|
|
1011
|
+
node_selector: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None,
|
|
1012
|
+
pod_annotations: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None,
|
|
1013
|
+
pod_labels: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None,
|
|
1014
|
+
rbac: Optional[pulumi.Input['CertManagerStartupAPICheckRBACArgs']] = None,
|
|
1015
|
+
resources: Optional[pulumi.Input['pulumi_kubernetes.core.v1.ResourceRequirementsArgs']] = None,
|
|
1016
|
+
security_context: Optional[pulumi.Input['pulumi_kubernetes.core.v1.PodSecurityContextArgs']] = None,
|
|
1017
|
+
service_account: Optional[pulumi.Input['CertManagerServiceAccountArgs']] = None,
|
|
1018
|
+
timeout: Optional[pulumi.Input[str]] = None,
|
|
1019
|
+
tolerations: Optional[pulumi.Input[Sequence[pulumi.Input['pulumi_kubernetes.core.v1.TolerationArgs']]]] = None):
|
|
1020
|
+
"""
|
|
1021
|
+
:param pulumi.Input[int] backoff_limit: Job backoffLimit
|
|
1022
|
+
:param pulumi.Input[Sequence[pulumi.Input[str]]] extra_args: Optional additional arguments for startupapicheck
|
|
1023
|
+
:param pulumi.Input[Mapping[str, pulumi.Input[str]]] job_annotations: Optional additional annotations to add to the startupapicheck Job
|
|
1024
|
+
:param pulumi.Input[Mapping[str, pulumi.Input[str]]] pod_annotations: Optional additional annotations to add to the startupapicheck Pods
|
|
1025
|
+
:param pulumi.Input[Mapping[str, pulumi.Input[str]]] pod_labels: Optional additional labels to add to the startupapicheck Pods
|
|
1026
|
+
:param pulumi.Input['pulumi_kubernetes.core.v1.PodSecurityContextArgs'] security_context: Pod Security Context to be set on the startupapicheck component Pod. ref: https://kubernetes.io/docs/tasks/configure-pod-container/security-context/
|
|
1027
|
+
:param pulumi.Input[str] timeout: Timeout for 'kubectl check api' command
|
|
1028
|
+
"""
|
|
1029
|
+
if affinity is not None:
|
|
1030
|
+
pulumi.set(__self__, "affinity", affinity)
|
|
1031
|
+
if backoff_limit is not None:
|
|
1032
|
+
pulumi.set(__self__, "backoff_limit", backoff_limit)
|
|
1033
|
+
if enabled is not None:
|
|
1034
|
+
pulumi.set(__self__, "enabled", enabled)
|
|
1035
|
+
if extra_args is not None:
|
|
1036
|
+
pulumi.set(__self__, "extra_args", extra_args)
|
|
1037
|
+
if image is not None:
|
|
1038
|
+
pulumi.set(__self__, "image", image)
|
|
1039
|
+
if job_annotations is not None:
|
|
1040
|
+
pulumi.set(__self__, "job_annotations", job_annotations)
|
|
1041
|
+
if node_selector is not None:
|
|
1042
|
+
pulumi.set(__self__, "node_selector", node_selector)
|
|
1043
|
+
if pod_annotations is not None:
|
|
1044
|
+
pulumi.set(__self__, "pod_annotations", pod_annotations)
|
|
1045
|
+
if pod_labels is not None:
|
|
1046
|
+
pulumi.set(__self__, "pod_labels", pod_labels)
|
|
1047
|
+
if rbac is not None:
|
|
1048
|
+
pulumi.set(__self__, "rbac", rbac)
|
|
1049
|
+
if resources is not None:
|
|
1050
|
+
pulumi.set(__self__, "resources", resources)
|
|
1051
|
+
if security_context is not None:
|
|
1052
|
+
pulumi.set(__self__, "security_context", security_context)
|
|
1053
|
+
if service_account is not None:
|
|
1054
|
+
pulumi.set(__self__, "service_account", service_account)
|
|
1055
|
+
if timeout is not None:
|
|
1056
|
+
pulumi.set(__self__, "timeout", timeout)
|
|
1057
|
+
if tolerations is not None:
|
|
1058
|
+
pulumi.set(__self__, "tolerations", tolerations)
|
|
1059
|
+
|
|
1060
|
+
@property
|
|
1061
|
+
@pulumi.getter
|
|
1062
|
+
def affinity(self) -> Optional[pulumi.Input['pulumi_kubernetes.core.v1.AffinityArgs']]:
|
|
1063
|
+
return pulumi.get(self, "affinity")
|
|
1064
|
+
|
|
1065
|
+
@affinity.setter
|
|
1066
|
+
def affinity(self, value: Optional[pulumi.Input['pulumi_kubernetes.core.v1.AffinityArgs']]):
|
|
1067
|
+
pulumi.set(self, "affinity", value)
|
|
1068
|
+
|
|
1069
|
+
@property
|
|
1070
|
+
@pulumi.getter(name="backoffLimit")
|
|
1071
|
+
def backoff_limit(self) -> Optional[pulumi.Input[int]]:
|
|
1072
|
+
"""
|
|
1073
|
+
Job backoffLimit
|
|
1074
|
+
"""
|
|
1075
|
+
return pulumi.get(self, "backoff_limit")
|
|
1076
|
+
|
|
1077
|
+
@backoff_limit.setter
|
|
1078
|
+
def backoff_limit(self, value: Optional[pulumi.Input[int]]):
|
|
1079
|
+
pulumi.set(self, "backoff_limit", value)
|
|
1080
|
+
|
|
1081
|
+
@property
|
|
1082
|
+
@pulumi.getter
|
|
1083
|
+
def enabled(self) -> Optional[pulumi.Input[bool]]:
|
|
1084
|
+
return pulumi.get(self, "enabled")
|
|
1085
|
+
|
|
1086
|
+
@enabled.setter
|
|
1087
|
+
def enabled(self, value: Optional[pulumi.Input[bool]]):
|
|
1088
|
+
pulumi.set(self, "enabled", value)
|
|
1089
|
+
|
|
1090
|
+
@property
|
|
1091
|
+
@pulumi.getter(name="extraArgs")
|
|
1092
|
+
def extra_args(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
|
|
1093
|
+
"""
|
|
1094
|
+
Optional additional arguments for startupapicheck
|
|
1095
|
+
"""
|
|
1096
|
+
return pulumi.get(self, "extra_args")
|
|
1097
|
+
|
|
1098
|
+
@extra_args.setter
|
|
1099
|
+
def extra_args(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
|
|
1100
|
+
pulumi.set(self, "extra_args", value)
|
|
1101
|
+
|
|
1102
|
+
@property
|
|
1103
|
+
@pulumi.getter
|
|
1104
|
+
def image(self) -> Optional[pulumi.Input['CertManagerImageArgs']]:
|
|
1105
|
+
return pulumi.get(self, "image")
|
|
1106
|
+
|
|
1107
|
+
@image.setter
|
|
1108
|
+
def image(self, value: Optional[pulumi.Input['CertManagerImageArgs']]):
|
|
1109
|
+
pulumi.set(self, "image", value)
|
|
1110
|
+
|
|
1111
|
+
@property
|
|
1112
|
+
@pulumi.getter(name="jobAnnotations")
|
|
1113
|
+
def job_annotations(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]:
|
|
1114
|
+
"""
|
|
1115
|
+
Optional additional annotations to add to the startupapicheck Job
|
|
1116
|
+
"""
|
|
1117
|
+
return pulumi.get(self, "job_annotations")
|
|
1118
|
+
|
|
1119
|
+
@job_annotations.setter
|
|
1120
|
+
def job_annotations(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]):
|
|
1121
|
+
pulumi.set(self, "job_annotations", value)
|
|
1122
|
+
|
|
1123
|
+
@property
|
|
1124
|
+
@pulumi.getter(name="nodeSelector")
|
|
1125
|
+
def node_selector(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]:
|
|
1126
|
+
return pulumi.get(self, "node_selector")
|
|
1127
|
+
|
|
1128
|
+
@node_selector.setter
|
|
1129
|
+
def node_selector(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]):
|
|
1130
|
+
pulumi.set(self, "node_selector", value)
|
|
1131
|
+
|
|
1132
|
+
@property
|
|
1133
|
+
@pulumi.getter(name="podAnnotations")
|
|
1134
|
+
def pod_annotations(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]:
|
|
1135
|
+
"""
|
|
1136
|
+
Optional additional annotations to add to the startupapicheck Pods
|
|
1137
|
+
"""
|
|
1138
|
+
return pulumi.get(self, "pod_annotations")
|
|
1139
|
+
|
|
1140
|
+
@pod_annotations.setter
|
|
1141
|
+
def pod_annotations(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]):
|
|
1142
|
+
pulumi.set(self, "pod_annotations", value)
|
|
1143
|
+
|
|
1144
|
+
@property
|
|
1145
|
+
@pulumi.getter(name="podLabels")
|
|
1146
|
+
def pod_labels(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]:
|
|
1147
|
+
"""
|
|
1148
|
+
Optional additional labels to add to the startupapicheck Pods
|
|
1149
|
+
"""
|
|
1150
|
+
return pulumi.get(self, "pod_labels")
|
|
1151
|
+
|
|
1152
|
+
@pod_labels.setter
|
|
1153
|
+
def pod_labels(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]):
|
|
1154
|
+
pulumi.set(self, "pod_labels", value)
|
|
1155
|
+
|
|
1156
|
+
@property
|
|
1157
|
+
@pulumi.getter
|
|
1158
|
+
def rbac(self) -> Optional[pulumi.Input['CertManagerStartupAPICheckRBACArgs']]:
|
|
1159
|
+
return pulumi.get(self, "rbac")
|
|
1160
|
+
|
|
1161
|
+
@rbac.setter
|
|
1162
|
+
def rbac(self, value: Optional[pulumi.Input['CertManagerStartupAPICheckRBACArgs']]):
|
|
1163
|
+
pulumi.set(self, "rbac", value)
|
|
1164
|
+
|
|
1165
|
+
@property
|
|
1166
|
+
@pulumi.getter
|
|
1167
|
+
def resources(self) -> Optional[pulumi.Input['pulumi_kubernetes.core.v1.ResourceRequirementsArgs']]:
|
|
1168
|
+
return pulumi.get(self, "resources")
|
|
1169
|
+
|
|
1170
|
+
@resources.setter
|
|
1171
|
+
def resources(self, value: Optional[pulumi.Input['pulumi_kubernetes.core.v1.ResourceRequirementsArgs']]):
|
|
1172
|
+
pulumi.set(self, "resources", value)
|
|
1173
|
+
|
|
1174
|
+
@property
|
|
1175
|
+
@pulumi.getter(name="securityContext")
|
|
1176
|
+
def security_context(self) -> Optional[pulumi.Input['pulumi_kubernetes.core.v1.PodSecurityContextArgs']]:
|
|
1177
|
+
"""
|
|
1178
|
+
Pod Security Context to be set on the startupapicheck component Pod. ref: https://kubernetes.io/docs/tasks/configure-pod-container/security-context/
|
|
1179
|
+
"""
|
|
1180
|
+
return pulumi.get(self, "security_context")
|
|
1181
|
+
|
|
1182
|
+
@security_context.setter
|
|
1183
|
+
def security_context(self, value: Optional[pulumi.Input['pulumi_kubernetes.core.v1.PodSecurityContextArgs']]):
|
|
1184
|
+
pulumi.set(self, "security_context", value)
|
|
1185
|
+
|
|
1186
|
+
@property
|
|
1187
|
+
@pulumi.getter(name="serviceAccount")
|
|
1188
|
+
def service_account(self) -> Optional[pulumi.Input['CertManagerServiceAccountArgs']]:
|
|
1189
|
+
return pulumi.get(self, "service_account")
|
|
1190
|
+
|
|
1191
|
+
@service_account.setter
|
|
1192
|
+
def service_account(self, value: Optional[pulumi.Input['CertManagerServiceAccountArgs']]):
|
|
1193
|
+
pulumi.set(self, "service_account", value)
|
|
1194
|
+
|
|
1195
|
+
@property
|
|
1196
|
+
@pulumi.getter
|
|
1197
|
+
def timeout(self) -> Optional[pulumi.Input[str]]:
|
|
1198
|
+
"""
|
|
1199
|
+
Timeout for 'kubectl check api' command
|
|
1200
|
+
"""
|
|
1201
|
+
return pulumi.get(self, "timeout")
|
|
1202
|
+
|
|
1203
|
+
@timeout.setter
|
|
1204
|
+
def timeout(self, value: Optional[pulumi.Input[str]]):
|
|
1205
|
+
pulumi.set(self, "timeout", value)
|
|
1206
|
+
|
|
1207
|
+
@property
|
|
1208
|
+
@pulumi.getter
|
|
1209
|
+
def tolerations(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['pulumi_kubernetes.core.v1.TolerationArgs']]]]:
|
|
1210
|
+
return pulumi.get(self, "tolerations")
|
|
1211
|
+
|
|
1212
|
+
@tolerations.setter
|
|
1213
|
+
def tolerations(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['pulumi_kubernetes.core.v1.TolerationArgs']]]]):
|
|
1214
|
+
pulumi.set(self, "tolerations", value)
|
|
1215
|
+
|
|
1216
|
+
|
|
1217
|
+
if not MYPY:
|
|
1218
|
+
class CertManagerWebhookURLArgsDict(TypedDict):
|
|
1219
|
+
host: NotRequired[pulumi.Input[str]]
|
|
1220
|
+
elif False:
|
|
1221
|
+
CertManagerWebhookURLArgsDict: TypeAlias = Mapping[str, Any]
|
|
1222
|
+
|
|
1223
|
+
@pulumi.input_type
|
|
1224
|
+
class CertManagerWebhookURLArgs:
|
|
1225
|
+
def __init__(__self__, *,
|
|
1226
|
+
host: Optional[pulumi.Input[str]] = None):
|
|
1227
|
+
if host is not None:
|
|
1228
|
+
pulumi.set(__self__, "host", host)
|
|
1229
|
+
|
|
1230
|
+
@property
|
|
1231
|
+
@pulumi.getter
|
|
1232
|
+
def host(self) -> Optional[pulumi.Input[str]]:
|
|
1233
|
+
return pulumi.get(self, "host")
|
|
1234
|
+
|
|
1235
|
+
@host.setter
|
|
1236
|
+
def host(self, value: Optional[pulumi.Input[str]]):
|
|
1237
|
+
pulumi.set(self, "host", value)
|
|
1238
|
+
|
|
1239
|
+
|
|
1240
|
+
if not MYPY:
|
|
1241
|
+
class CertManagerWebhookArgsDict(TypedDict):
|
|
1242
|
+
affinity: NotRequired[pulumi.Input['pulumi_kubernetes.core.v1.AffinityArgsDict']]
|
|
1243
|
+
container_security_context: NotRequired[pulumi.Input['pulumi_kubernetes.core.v1.SecurityContextArgsDict']]
|
|
1244
|
+
"""
|
|
1245
|
+
Container Security Context to be set on the webhook component container. ref: https://kubernetes.io/docs/tasks/configure-pod-container/security-context/
|
|
1246
|
+
"""
|
|
1247
|
+
deployment_annotations: NotRequired[pulumi.Input[Mapping[str, pulumi.Input[str]]]]
|
|
1248
|
+
"""
|
|
1249
|
+
Optional additional annotations to add to the webhook Deployment
|
|
1250
|
+
"""
|
|
1251
|
+
extra_args: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
|
|
1252
|
+
"""
|
|
1253
|
+
Optional additional arguments for webhook
|
|
1254
|
+
"""
|
|
1255
|
+
host_network: NotRequired[pulumi.Input[bool]]
|
|
1256
|
+
"""
|
|
1257
|
+
Specifies if the webhook should be started in hostNetwork mode. Required for use in some managed kubernetes clusters (such as AWS EKS) with custom CNI (such as calico), because control-plane managed by AWS cannot communicate with pods' IP CIDR and admission webhooks are not working Since the default port for the webhook conflicts with kubelet on the host network, `webhook.securePort` should be changed to an available port if running in hostNetwork mode.
|
|
1258
|
+
"""
|
|
1259
|
+
image: NotRequired[pulumi.Input['CertManagerImageArgsDict']]
|
|
1260
|
+
liveness_probe: NotRequired[pulumi.Input['pulumi_kubernetes.core.v1.ProbeArgsDict']]
|
|
1261
|
+
"""
|
|
1262
|
+
Liveness probe values. Ref: https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle/#container-probes
|
|
1263
|
+
"""
|
|
1264
|
+
load_balancer_ip: NotRequired[pulumi.Input[str]]
|
|
1265
|
+
mutating_webhook_configuration_annotations: NotRequired[pulumi.Input[Mapping[str, pulumi.Input[str]]]]
|
|
1266
|
+
"""
|
|
1267
|
+
Optional additional annotations to add to the webhook MutatingWebhookConfiguration
|
|
1268
|
+
"""
|
|
1269
|
+
node_selector: NotRequired[pulumi.Input[Mapping[str, pulumi.Input[str]]]]
|
|
1270
|
+
pod_annotations: NotRequired[pulumi.Input[Mapping[str, pulumi.Input[str]]]]
|
|
1271
|
+
"""
|
|
1272
|
+
Optional additional annotations to add to the webhook Pods
|
|
1273
|
+
"""
|
|
1274
|
+
pod_labels: NotRequired[pulumi.Input[Mapping[str, pulumi.Input[str]]]]
|
|
1275
|
+
"""
|
|
1276
|
+
Optional additional labels to add to the Webhook Pods
|
|
1277
|
+
"""
|
|
1278
|
+
readiness_probe: NotRequired[pulumi.Input['pulumi_kubernetes.core.v1.ProbeArgsDict']]
|
|
1279
|
+
"""
|
|
1280
|
+
Readiness probe values. Ref: https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle/#container-probes
|
|
1281
|
+
"""
|
|
1282
|
+
replica_count: NotRequired[pulumi.Input[int]]
|
|
1283
|
+
resources: NotRequired[pulumi.Input['pulumi_kubernetes.core.v1.ResourceRequirementsArgsDict']]
|
|
1284
|
+
secure_port: NotRequired[pulumi.Input[int]]
|
|
1285
|
+
"""
|
|
1286
|
+
The port that the webhook should listen on for requests. In GKE private clusters, by default kubernetes apiservers are allowed to talk to the cluster nodes only on 443 and 10250. so configuring securePort: 10250, will work out of the box without needing to add firewall rules or requiring NET_BIND_SERVICE capabilities to bind port numbers <1000
|
|
1287
|
+
"""
|
|
1288
|
+
security_context: NotRequired[pulumi.Input['pulumi_kubernetes.core.v1.PodSecurityContextArgsDict']]
|
|
1289
|
+
"""
|
|
1290
|
+
Pod Security Context to be set on the webhook component Pod. ref: https://kubernetes.io/docs/tasks/configure-pod-container/security-context/
|
|
1291
|
+
"""
|
|
1292
|
+
service_account: NotRequired[pulumi.Input['CertManagerServiceAccountArgsDict']]
|
|
1293
|
+
service_annotations: NotRequired[pulumi.Input[Mapping[str, pulumi.Input[str]]]]
|
|
1294
|
+
"""
|
|
1295
|
+
Optional additional annotations to add to the webhook service
|
|
1296
|
+
"""
|
|
1297
|
+
service_labels: NotRequired[pulumi.Input[Mapping[str, pulumi.Input[str]]]]
|
|
1298
|
+
"""
|
|
1299
|
+
Optional additional labels to add to the Webhook Service
|
|
1300
|
+
"""
|
|
1301
|
+
service_type: NotRequired[pulumi.Input[str]]
|
|
1302
|
+
"""
|
|
1303
|
+
Specifies how the service should be handled. Useful if you want to expose the webhook to outside of the cluster. In some cases, the control plane cannot reach internal services.
|
|
1304
|
+
"""
|
|
1305
|
+
strategy: NotRequired[pulumi.Input['pulumi_kubernetes.apps.v1.DeploymentStrategyArgsDict']]
|
|
1306
|
+
timeout_seconds: NotRequired[pulumi.Input[int]]
|
|
1307
|
+
tolerations: NotRequired[pulumi.Input[Sequence[pulumi.Input['pulumi_kubernetes.core.v1.TolerationArgsDict']]]]
|
|
1308
|
+
url: NotRequired[pulumi.Input['CertManagerWebhookURLArgsDict']]
|
|
1309
|
+
"""
|
|
1310
|
+
Overrides the mutating webhook and validating webhook so they reach the webhook service using the `url` field instead of a service.
|
|
1311
|
+
"""
|
|
1312
|
+
validating_webhook_configuration_annotations: NotRequired[pulumi.Input[Mapping[str, pulumi.Input[str]]]]
|
|
1313
|
+
"""
|
|
1314
|
+
Optional additional annotations to add to the webhook ValidatingWebhookConfiguration
|
|
1315
|
+
"""
|
|
1316
|
+
elif False:
|
|
1317
|
+
CertManagerWebhookArgsDict: TypeAlias = Mapping[str, Any]
|
|
1318
|
+
|
|
1319
|
+
@pulumi.input_type
|
|
1320
|
+
class CertManagerWebhookArgs:
|
|
1321
|
+
def __init__(__self__, *,
|
|
1322
|
+
affinity: Optional[pulumi.Input['pulumi_kubernetes.core.v1.AffinityArgs']] = None,
|
|
1323
|
+
container_security_context: Optional[pulumi.Input['pulumi_kubernetes.core.v1.SecurityContextArgs']] = None,
|
|
1324
|
+
deployment_annotations: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None,
|
|
1325
|
+
extra_args: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
|
|
1326
|
+
host_network: Optional[pulumi.Input[bool]] = None,
|
|
1327
|
+
image: Optional[pulumi.Input['CertManagerImageArgs']] = None,
|
|
1328
|
+
liveness_probe: Optional[pulumi.Input['pulumi_kubernetes.core.v1.ProbeArgs']] = None,
|
|
1329
|
+
load_balancer_ip: Optional[pulumi.Input[str]] = None,
|
|
1330
|
+
mutating_webhook_configuration_annotations: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None,
|
|
1331
|
+
node_selector: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None,
|
|
1332
|
+
pod_annotations: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None,
|
|
1333
|
+
pod_labels: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None,
|
|
1334
|
+
readiness_probe: Optional[pulumi.Input['pulumi_kubernetes.core.v1.ProbeArgs']] = None,
|
|
1335
|
+
replica_count: Optional[pulumi.Input[int]] = None,
|
|
1336
|
+
resources: Optional[pulumi.Input['pulumi_kubernetes.core.v1.ResourceRequirementsArgs']] = None,
|
|
1337
|
+
secure_port: Optional[pulumi.Input[int]] = None,
|
|
1338
|
+
security_context: Optional[pulumi.Input['pulumi_kubernetes.core.v1.PodSecurityContextArgs']] = None,
|
|
1339
|
+
service_account: Optional[pulumi.Input['CertManagerServiceAccountArgs']] = None,
|
|
1340
|
+
service_annotations: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None,
|
|
1341
|
+
service_labels: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None,
|
|
1342
|
+
service_type: Optional[pulumi.Input[str]] = None,
|
|
1343
|
+
strategy: Optional[pulumi.Input['pulumi_kubernetes.apps.v1.DeploymentStrategyArgs']] = None,
|
|
1344
|
+
timeout_seconds: Optional[pulumi.Input[int]] = None,
|
|
1345
|
+
tolerations: Optional[pulumi.Input[Sequence[pulumi.Input['pulumi_kubernetes.core.v1.TolerationArgs']]]] = None,
|
|
1346
|
+
url: Optional[pulumi.Input['CertManagerWebhookURLArgs']] = None,
|
|
1347
|
+
validating_webhook_configuration_annotations: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None):
|
|
1348
|
+
"""
|
|
1349
|
+
:param pulumi.Input['pulumi_kubernetes.core.v1.SecurityContextArgs'] container_security_context: Container Security Context to be set on the webhook component container. ref: https://kubernetes.io/docs/tasks/configure-pod-container/security-context/
|
|
1350
|
+
:param pulumi.Input[Mapping[str, pulumi.Input[str]]] deployment_annotations: Optional additional annotations to add to the webhook Deployment
|
|
1351
|
+
:param pulumi.Input[Sequence[pulumi.Input[str]]] extra_args: Optional additional arguments for webhook
|
|
1352
|
+
:param pulumi.Input[bool] host_network: Specifies if the webhook should be started in hostNetwork mode. Required for use in some managed kubernetes clusters (such as AWS EKS) with custom CNI (such as calico), because control-plane managed by AWS cannot communicate with pods' IP CIDR and admission webhooks are not working Since the default port for the webhook conflicts with kubelet on the host network, `webhook.securePort` should be changed to an available port if running in hostNetwork mode.
|
|
1353
|
+
:param pulumi.Input['pulumi_kubernetes.core.v1.ProbeArgs'] liveness_probe: Liveness probe values. Ref: https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle/#container-probes
|
|
1354
|
+
:param pulumi.Input[Mapping[str, pulumi.Input[str]]] mutating_webhook_configuration_annotations: Optional additional annotations to add to the webhook MutatingWebhookConfiguration
|
|
1355
|
+
:param pulumi.Input[Mapping[str, pulumi.Input[str]]] pod_annotations: Optional additional annotations to add to the webhook Pods
|
|
1356
|
+
:param pulumi.Input[Mapping[str, pulumi.Input[str]]] pod_labels: Optional additional labels to add to the Webhook Pods
|
|
1357
|
+
:param pulumi.Input['pulumi_kubernetes.core.v1.ProbeArgs'] readiness_probe: Readiness probe values. Ref: https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle/#container-probes
|
|
1358
|
+
:param pulumi.Input[int] secure_port: The port that the webhook should listen on for requests. In GKE private clusters, by default kubernetes apiservers are allowed to talk to the cluster nodes only on 443 and 10250. so configuring securePort: 10250, will work out of the box without needing to add firewall rules or requiring NET_BIND_SERVICE capabilities to bind port numbers <1000
|
|
1359
|
+
:param pulumi.Input['pulumi_kubernetes.core.v1.PodSecurityContextArgs'] security_context: Pod Security Context to be set on the webhook component Pod. ref: https://kubernetes.io/docs/tasks/configure-pod-container/security-context/
|
|
1360
|
+
:param pulumi.Input[Mapping[str, pulumi.Input[str]]] service_annotations: Optional additional annotations to add to the webhook service
|
|
1361
|
+
:param pulumi.Input[Mapping[str, pulumi.Input[str]]] service_labels: Optional additional labels to add to the Webhook Service
|
|
1362
|
+
:param pulumi.Input[str] service_type: Specifies how the service should be handled. Useful if you want to expose the webhook to outside of the cluster. In some cases, the control plane cannot reach internal services.
|
|
1363
|
+
:param pulumi.Input['CertManagerWebhookURLArgs'] url: Overrides the mutating webhook and validating webhook so they reach the webhook service using the `url` field instead of a service.
|
|
1364
|
+
:param pulumi.Input[Mapping[str, pulumi.Input[str]]] validating_webhook_configuration_annotations: Optional additional annotations to add to the webhook ValidatingWebhookConfiguration
|
|
1365
|
+
"""
|
|
1366
|
+
if affinity is not None:
|
|
1367
|
+
pulumi.set(__self__, "affinity", affinity)
|
|
1368
|
+
if container_security_context is not None:
|
|
1369
|
+
pulumi.set(__self__, "container_security_context", container_security_context)
|
|
1370
|
+
if deployment_annotations is not None:
|
|
1371
|
+
pulumi.set(__self__, "deployment_annotations", deployment_annotations)
|
|
1372
|
+
if extra_args is not None:
|
|
1373
|
+
pulumi.set(__self__, "extra_args", extra_args)
|
|
1374
|
+
if host_network is not None:
|
|
1375
|
+
pulumi.set(__self__, "host_network", host_network)
|
|
1376
|
+
if image is not None:
|
|
1377
|
+
pulumi.set(__self__, "image", image)
|
|
1378
|
+
if liveness_probe is not None:
|
|
1379
|
+
pulumi.set(__self__, "liveness_probe", liveness_probe)
|
|
1380
|
+
if load_balancer_ip is not None:
|
|
1381
|
+
pulumi.set(__self__, "load_balancer_ip", load_balancer_ip)
|
|
1382
|
+
if mutating_webhook_configuration_annotations is not None:
|
|
1383
|
+
pulumi.set(__self__, "mutating_webhook_configuration_annotations", mutating_webhook_configuration_annotations)
|
|
1384
|
+
if node_selector is not None:
|
|
1385
|
+
pulumi.set(__self__, "node_selector", node_selector)
|
|
1386
|
+
if pod_annotations is not None:
|
|
1387
|
+
pulumi.set(__self__, "pod_annotations", pod_annotations)
|
|
1388
|
+
if pod_labels is not None:
|
|
1389
|
+
pulumi.set(__self__, "pod_labels", pod_labels)
|
|
1390
|
+
if readiness_probe is not None:
|
|
1391
|
+
pulumi.set(__self__, "readiness_probe", readiness_probe)
|
|
1392
|
+
if replica_count is not None:
|
|
1393
|
+
pulumi.set(__self__, "replica_count", replica_count)
|
|
1394
|
+
if resources is not None:
|
|
1395
|
+
pulumi.set(__self__, "resources", resources)
|
|
1396
|
+
if secure_port is not None:
|
|
1397
|
+
pulumi.set(__self__, "secure_port", secure_port)
|
|
1398
|
+
if security_context is not None:
|
|
1399
|
+
pulumi.set(__self__, "security_context", security_context)
|
|
1400
|
+
if service_account is not None:
|
|
1401
|
+
pulumi.set(__self__, "service_account", service_account)
|
|
1402
|
+
if service_annotations is not None:
|
|
1403
|
+
pulumi.set(__self__, "service_annotations", service_annotations)
|
|
1404
|
+
if service_labels is not None:
|
|
1405
|
+
pulumi.set(__self__, "service_labels", service_labels)
|
|
1406
|
+
if service_type is not None:
|
|
1407
|
+
pulumi.set(__self__, "service_type", service_type)
|
|
1408
|
+
if strategy is not None:
|
|
1409
|
+
pulumi.set(__self__, "strategy", strategy)
|
|
1410
|
+
if timeout_seconds is not None:
|
|
1411
|
+
pulumi.set(__self__, "timeout_seconds", timeout_seconds)
|
|
1412
|
+
if tolerations is not None:
|
|
1413
|
+
pulumi.set(__self__, "tolerations", tolerations)
|
|
1414
|
+
if url is not None:
|
|
1415
|
+
pulumi.set(__self__, "url", url)
|
|
1416
|
+
if validating_webhook_configuration_annotations is not None:
|
|
1417
|
+
pulumi.set(__self__, "validating_webhook_configuration_annotations", validating_webhook_configuration_annotations)
|
|
1418
|
+
|
|
1419
|
+
@property
|
|
1420
|
+
@pulumi.getter
|
|
1421
|
+
def affinity(self) -> Optional[pulumi.Input['pulumi_kubernetes.core.v1.AffinityArgs']]:
|
|
1422
|
+
return pulumi.get(self, "affinity")
|
|
1423
|
+
|
|
1424
|
+
@affinity.setter
|
|
1425
|
+
def affinity(self, value: Optional[pulumi.Input['pulumi_kubernetes.core.v1.AffinityArgs']]):
|
|
1426
|
+
pulumi.set(self, "affinity", value)
|
|
1427
|
+
|
|
1428
|
+
@property
|
|
1429
|
+
@pulumi.getter(name="containerSecurityContext")
|
|
1430
|
+
def container_security_context(self) -> Optional[pulumi.Input['pulumi_kubernetes.core.v1.SecurityContextArgs']]:
|
|
1431
|
+
"""
|
|
1432
|
+
Container Security Context to be set on the webhook component container. ref: https://kubernetes.io/docs/tasks/configure-pod-container/security-context/
|
|
1433
|
+
"""
|
|
1434
|
+
return pulumi.get(self, "container_security_context")
|
|
1435
|
+
|
|
1436
|
+
@container_security_context.setter
|
|
1437
|
+
def container_security_context(self, value: Optional[pulumi.Input['pulumi_kubernetes.core.v1.SecurityContextArgs']]):
|
|
1438
|
+
pulumi.set(self, "container_security_context", value)
|
|
1439
|
+
|
|
1440
|
+
@property
|
|
1441
|
+
@pulumi.getter(name="deploymentAnnotations")
|
|
1442
|
+
def deployment_annotations(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]:
|
|
1443
|
+
"""
|
|
1444
|
+
Optional additional annotations to add to the webhook Deployment
|
|
1445
|
+
"""
|
|
1446
|
+
return pulumi.get(self, "deployment_annotations")
|
|
1447
|
+
|
|
1448
|
+
@deployment_annotations.setter
|
|
1449
|
+
def deployment_annotations(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]):
|
|
1450
|
+
pulumi.set(self, "deployment_annotations", value)
|
|
1451
|
+
|
|
1452
|
+
@property
|
|
1453
|
+
@pulumi.getter(name="extraArgs")
|
|
1454
|
+
def extra_args(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
|
|
1455
|
+
"""
|
|
1456
|
+
Optional additional arguments for webhook
|
|
1457
|
+
"""
|
|
1458
|
+
return pulumi.get(self, "extra_args")
|
|
1459
|
+
|
|
1460
|
+
@extra_args.setter
|
|
1461
|
+
def extra_args(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
|
|
1462
|
+
pulumi.set(self, "extra_args", value)
|
|
1463
|
+
|
|
1464
|
+
@property
|
|
1465
|
+
@pulumi.getter(name="hostNetwork")
|
|
1466
|
+
def host_network(self) -> Optional[pulumi.Input[bool]]:
|
|
1467
|
+
"""
|
|
1468
|
+
Specifies if the webhook should be started in hostNetwork mode. Required for use in some managed kubernetes clusters (such as AWS EKS) with custom CNI (such as calico), because control-plane managed by AWS cannot communicate with pods' IP CIDR and admission webhooks are not working Since the default port for the webhook conflicts with kubelet on the host network, `webhook.securePort` should be changed to an available port if running in hostNetwork mode.
|
|
1469
|
+
"""
|
|
1470
|
+
return pulumi.get(self, "host_network")
|
|
1471
|
+
|
|
1472
|
+
@host_network.setter
|
|
1473
|
+
def host_network(self, value: Optional[pulumi.Input[bool]]):
|
|
1474
|
+
pulumi.set(self, "host_network", value)
|
|
1475
|
+
|
|
1476
|
+
@property
|
|
1477
|
+
@pulumi.getter
|
|
1478
|
+
def image(self) -> Optional[pulumi.Input['CertManagerImageArgs']]:
|
|
1479
|
+
return pulumi.get(self, "image")
|
|
1480
|
+
|
|
1481
|
+
@image.setter
|
|
1482
|
+
def image(self, value: Optional[pulumi.Input['CertManagerImageArgs']]):
|
|
1483
|
+
pulumi.set(self, "image", value)
|
|
1484
|
+
|
|
1485
|
+
@property
|
|
1486
|
+
@pulumi.getter(name="livenessProbe")
|
|
1487
|
+
def liveness_probe(self) -> Optional[pulumi.Input['pulumi_kubernetes.core.v1.ProbeArgs']]:
|
|
1488
|
+
"""
|
|
1489
|
+
Liveness probe values. Ref: https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle/#container-probes
|
|
1490
|
+
"""
|
|
1491
|
+
return pulumi.get(self, "liveness_probe")
|
|
1492
|
+
|
|
1493
|
+
@liveness_probe.setter
|
|
1494
|
+
def liveness_probe(self, value: Optional[pulumi.Input['pulumi_kubernetes.core.v1.ProbeArgs']]):
|
|
1495
|
+
pulumi.set(self, "liveness_probe", value)
|
|
1496
|
+
|
|
1497
|
+
@property
|
|
1498
|
+
@pulumi.getter(name="loadBalancerIP")
|
|
1499
|
+
def load_balancer_ip(self) -> Optional[pulumi.Input[str]]:
|
|
1500
|
+
return pulumi.get(self, "load_balancer_ip")
|
|
1501
|
+
|
|
1502
|
+
@load_balancer_ip.setter
|
|
1503
|
+
def load_balancer_ip(self, value: Optional[pulumi.Input[str]]):
|
|
1504
|
+
pulumi.set(self, "load_balancer_ip", value)
|
|
1505
|
+
|
|
1506
|
+
@property
|
|
1507
|
+
@pulumi.getter(name="mutatingWebhookConfigurationAnnotations")
|
|
1508
|
+
def mutating_webhook_configuration_annotations(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]:
|
|
1509
|
+
"""
|
|
1510
|
+
Optional additional annotations to add to the webhook MutatingWebhookConfiguration
|
|
1511
|
+
"""
|
|
1512
|
+
return pulumi.get(self, "mutating_webhook_configuration_annotations")
|
|
1513
|
+
|
|
1514
|
+
@mutating_webhook_configuration_annotations.setter
|
|
1515
|
+
def mutating_webhook_configuration_annotations(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]):
|
|
1516
|
+
pulumi.set(self, "mutating_webhook_configuration_annotations", value)
|
|
1517
|
+
|
|
1518
|
+
@property
|
|
1519
|
+
@pulumi.getter(name="nodeSelector")
|
|
1520
|
+
def node_selector(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]:
|
|
1521
|
+
return pulumi.get(self, "node_selector")
|
|
1522
|
+
|
|
1523
|
+
@node_selector.setter
|
|
1524
|
+
def node_selector(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]):
|
|
1525
|
+
pulumi.set(self, "node_selector", value)
|
|
1526
|
+
|
|
1527
|
+
@property
|
|
1528
|
+
@pulumi.getter(name="podAnnotations")
|
|
1529
|
+
def pod_annotations(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]:
|
|
1530
|
+
"""
|
|
1531
|
+
Optional additional annotations to add to the webhook Pods
|
|
1532
|
+
"""
|
|
1533
|
+
return pulumi.get(self, "pod_annotations")
|
|
1534
|
+
|
|
1535
|
+
@pod_annotations.setter
|
|
1536
|
+
def pod_annotations(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]):
|
|
1537
|
+
pulumi.set(self, "pod_annotations", value)
|
|
1538
|
+
|
|
1539
|
+
@property
|
|
1540
|
+
@pulumi.getter(name="podLabels")
|
|
1541
|
+
def pod_labels(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]:
|
|
1542
|
+
"""
|
|
1543
|
+
Optional additional labels to add to the Webhook Pods
|
|
1544
|
+
"""
|
|
1545
|
+
return pulumi.get(self, "pod_labels")
|
|
1546
|
+
|
|
1547
|
+
@pod_labels.setter
|
|
1548
|
+
def pod_labels(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]):
|
|
1549
|
+
pulumi.set(self, "pod_labels", value)
|
|
1550
|
+
|
|
1551
|
+
@property
|
|
1552
|
+
@pulumi.getter(name="readinessProbe")
|
|
1553
|
+
def readiness_probe(self) -> Optional[pulumi.Input['pulumi_kubernetes.core.v1.ProbeArgs']]:
|
|
1554
|
+
"""
|
|
1555
|
+
Readiness probe values. Ref: https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle/#container-probes
|
|
1556
|
+
"""
|
|
1557
|
+
return pulumi.get(self, "readiness_probe")
|
|
1558
|
+
|
|
1559
|
+
@readiness_probe.setter
|
|
1560
|
+
def readiness_probe(self, value: Optional[pulumi.Input['pulumi_kubernetes.core.v1.ProbeArgs']]):
|
|
1561
|
+
pulumi.set(self, "readiness_probe", value)
|
|
1562
|
+
|
|
1563
|
+
@property
|
|
1564
|
+
@pulumi.getter(name="replicaCount")
|
|
1565
|
+
def replica_count(self) -> Optional[pulumi.Input[int]]:
|
|
1566
|
+
return pulumi.get(self, "replica_count")
|
|
1567
|
+
|
|
1568
|
+
@replica_count.setter
|
|
1569
|
+
def replica_count(self, value: Optional[pulumi.Input[int]]):
|
|
1570
|
+
pulumi.set(self, "replica_count", value)
|
|
1571
|
+
|
|
1572
|
+
@property
|
|
1573
|
+
@pulumi.getter
|
|
1574
|
+
def resources(self) -> Optional[pulumi.Input['pulumi_kubernetes.core.v1.ResourceRequirementsArgs']]:
|
|
1575
|
+
return pulumi.get(self, "resources")
|
|
1576
|
+
|
|
1577
|
+
@resources.setter
|
|
1578
|
+
def resources(self, value: Optional[pulumi.Input['pulumi_kubernetes.core.v1.ResourceRequirementsArgs']]):
|
|
1579
|
+
pulumi.set(self, "resources", value)
|
|
1580
|
+
|
|
1581
|
+
@property
|
|
1582
|
+
@pulumi.getter(name="securePort")
|
|
1583
|
+
def secure_port(self) -> Optional[pulumi.Input[int]]:
|
|
1584
|
+
"""
|
|
1585
|
+
The port that the webhook should listen on for requests. In GKE private clusters, by default kubernetes apiservers are allowed to talk to the cluster nodes only on 443 and 10250. so configuring securePort: 10250, will work out of the box without needing to add firewall rules or requiring NET_BIND_SERVICE capabilities to bind port numbers <1000
|
|
1586
|
+
"""
|
|
1587
|
+
return pulumi.get(self, "secure_port")
|
|
1588
|
+
|
|
1589
|
+
@secure_port.setter
|
|
1590
|
+
def secure_port(self, value: Optional[pulumi.Input[int]]):
|
|
1591
|
+
pulumi.set(self, "secure_port", value)
|
|
1592
|
+
|
|
1593
|
+
@property
|
|
1594
|
+
@pulumi.getter(name="securityContext")
|
|
1595
|
+
def security_context(self) -> Optional[pulumi.Input['pulumi_kubernetes.core.v1.PodSecurityContextArgs']]:
|
|
1596
|
+
"""
|
|
1597
|
+
Pod Security Context to be set on the webhook component Pod. ref: https://kubernetes.io/docs/tasks/configure-pod-container/security-context/
|
|
1598
|
+
"""
|
|
1599
|
+
return pulumi.get(self, "security_context")
|
|
1600
|
+
|
|
1601
|
+
@security_context.setter
|
|
1602
|
+
def security_context(self, value: Optional[pulumi.Input['pulumi_kubernetes.core.v1.PodSecurityContextArgs']]):
|
|
1603
|
+
pulumi.set(self, "security_context", value)
|
|
1604
|
+
|
|
1605
|
+
@property
|
|
1606
|
+
@pulumi.getter(name="serviceAccount")
|
|
1607
|
+
def service_account(self) -> Optional[pulumi.Input['CertManagerServiceAccountArgs']]:
|
|
1608
|
+
return pulumi.get(self, "service_account")
|
|
1609
|
+
|
|
1610
|
+
@service_account.setter
|
|
1611
|
+
def service_account(self, value: Optional[pulumi.Input['CertManagerServiceAccountArgs']]):
|
|
1612
|
+
pulumi.set(self, "service_account", value)
|
|
1613
|
+
|
|
1614
|
+
@property
|
|
1615
|
+
@pulumi.getter(name="serviceAnnotations")
|
|
1616
|
+
def service_annotations(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]:
|
|
1617
|
+
"""
|
|
1618
|
+
Optional additional annotations to add to the webhook service
|
|
1619
|
+
"""
|
|
1620
|
+
return pulumi.get(self, "service_annotations")
|
|
1621
|
+
|
|
1622
|
+
@service_annotations.setter
|
|
1623
|
+
def service_annotations(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]):
|
|
1624
|
+
pulumi.set(self, "service_annotations", value)
|
|
1625
|
+
|
|
1626
|
+
@property
|
|
1627
|
+
@pulumi.getter(name="serviceLabels")
|
|
1628
|
+
def service_labels(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]:
|
|
1629
|
+
"""
|
|
1630
|
+
Optional additional labels to add to the Webhook Service
|
|
1631
|
+
"""
|
|
1632
|
+
return pulumi.get(self, "service_labels")
|
|
1633
|
+
|
|
1634
|
+
@service_labels.setter
|
|
1635
|
+
def service_labels(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]):
|
|
1636
|
+
pulumi.set(self, "service_labels", value)
|
|
1637
|
+
|
|
1638
|
+
@property
|
|
1639
|
+
@pulumi.getter(name="serviceType")
|
|
1640
|
+
def service_type(self) -> Optional[pulumi.Input[str]]:
|
|
1641
|
+
"""
|
|
1642
|
+
Specifies how the service should be handled. Useful if you want to expose the webhook to outside of the cluster. In some cases, the control plane cannot reach internal services.
|
|
1643
|
+
"""
|
|
1644
|
+
return pulumi.get(self, "service_type")
|
|
1645
|
+
|
|
1646
|
+
@service_type.setter
|
|
1647
|
+
def service_type(self, value: Optional[pulumi.Input[str]]):
|
|
1648
|
+
pulumi.set(self, "service_type", value)
|
|
1649
|
+
|
|
1650
|
+
@property
|
|
1651
|
+
@pulumi.getter
|
|
1652
|
+
def strategy(self) -> Optional[pulumi.Input['pulumi_kubernetes.apps.v1.DeploymentStrategyArgs']]:
|
|
1653
|
+
return pulumi.get(self, "strategy")
|
|
1654
|
+
|
|
1655
|
+
@strategy.setter
|
|
1656
|
+
def strategy(self, value: Optional[pulumi.Input['pulumi_kubernetes.apps.v1.DeploymentStrategyArgs']]):
|
|
1657
|
+
pulumi.set(self, "strategy", value)
|
|
1658
|
+
|
|
1659
|
+
@property
|
|
1660
|
+
@pulumi.getter(name="timeoutSeconds")
|
|
1661
|
+
def timeout_seconds(self) -> Optional[pulumi.Input[int]]:
|
|
1662
|
+
return pulumi.get(self, "timeout_seconds")
|
|
1663
|
+
|
|
1664
|
+
@timeout_seconds.setter
|
|
1665
|
+
def timeout_seconds(self, value: Optional[pulumi.Input[int]]):
|
|
1666
|
+
pulumi.set(self, "timeout_seconds", value)
|
|
1667
|
+
|
|
1668
|
+
@property
|
|
1669
|
+
@pulumi.getter
|
|
1670
|
+
def tolerations(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['pulumi_kubernetes.core.v1.TolerationArgs']]]]:
|
|
1671
|
+
return pulumi.get(self, "tolerations")
|
|
1672
|
+
|
|
1673
|
+
@tolerations.setter
|
|
1674
|
+
def tolerations(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['pulumi_kubernetes.core.v1.TolerationArgs']]]]):
|
|
1675
|
+
pulumi.set(self, "tolerations", value)
|
|
1676
|
+
|
|
1677
|
+
@property
|
|
1678
|
+
@pulumi.getter
|
|
1679
|
+
def url(self) -> Optional[pulumi.Input['CertManagerWebhookURLArgs']]:
|
|
1680
|
+
"""
|
|
1681
|
+
Overrides the mutating webhook and validating webhook so they reach the webhook service using the `url` field instead of a service.
|
|
1682
|
+
"""
|
|
1683
|
+
return pulumi.get(self, "url")
|
|
1684
|
+
|
|
1685
|
+
@url.setter
|
|
1686
|
+
def url(self, value: Optional[pulumi.Input['CertManagerWebhookURLArgs']]):
|
|
1687
|
+
pulumi.set(self, "url", value)
|
|
1688
|
+
|
|
1689
|
+
@property
|
|
1690
|
+
@pulumi.getter(name="validatingWebhookConfigurationAnnotations")
|
|
1691
|
+
def validating_webhook_configuration_annotations(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]:
|
|
1692
|
+
"""
|
|
1693
|
+
Optional additional annotations to add to the webhook ValidatingWebhookConfiguration
|
|
1694
|
+
"""
|
|
1695
|
+
return pulumi.get(self, "validating_webhook_configuration_annotations")
|
|
1696
|
+
|
|
1697
|
+
@validating_webhook_configuration_annotations.setter
|
|
1698
|
+
def validating_webhook_configuration_annotations(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]):
|
|
1699
|
+
pulumi.set(self, "validating_webhook_configuration_annotations", value)
|
|
1700
|
+
|
|
1701
|
+
|
|
1702
|
+
if not MYPY:
|
|
1703
|
+
class ReleaseArgsDict(TypedDict):
|
|
1704
|
+
"""
|
|
1705
|
+
A Release is an instance of a chart running in a Kubernetes cluster.
|
|
1706
|
+
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.
|
|
1707
|
+
Note - Helm Release is currently in BETA and may change. Use in production environment is discouraged.
|
|
1708
|
+
"""
|
|
1709
|
+
atomic: NotRequired[pulumi.Input[bool]]
|
|
1710
|
+
"""
|
|
1711
|
+
If set, installation process purges chart on fail. `skipAwait` will be disabled automatically if atomic is used.
|
|
1712
|
+
"""
|
|
1713
|
+
chart: NotRequired[pulumi.Input[str]]
|
|
1714
|
+
"""
|
|
1715
|
+
Chart name to be installed. A path may be used.
|
|
1716
|
+
"""
|
|
1717
|
+
cleanup_on_fail: NotRequired[pulumi.Input[bool]]
|
|
1718
|
+
"""
|
|
1719
|
+
Allow deletion of new resources created in this upgrade when upgrade fails.
|
|
1720
|
+
"""
|
|
1721
|
+
create_namespace: NotRequired[pulumi.Input[bool]]
|
|
1722
|
+
"""
|
|
1723
|
+
Create the namespace if it does not exist.
|
|
1724
|
+
"""
|
|
1725
|
+
dependency_update: NotRequired[pulumi.Input[bool]]
|
|
1726
|
+
"""
|
|
1727
|
+
Run helm dependency update before installing the chart.
|
|
1728
|
+
"""
|
|
1729
|
+
description: NotRequired[pulumi.Input[str]]
|
|
1730
|
+
"""
|
|
1731
|
+
Add a custom description
|
|
1732
|
+
"""
|
|
1733
|
+
devel: NotRequired[pulumi.Input[bool]]
|
|
1734
|
+
"""
|
|
1735
|
+
Use chart development versions, too. Equivalent to version '>0.0.0-0'. If `version` is set, this is ignored.
|
|
1736
|
+
"""
|
|
1737
|
+
disable_crd_hooks: NotRequired[pulumi.Input[bool]]
|
|
1738
|
+
"""
|
|
1739
|
+
Prevent CRD hooks from, running, but run other hooks. See helm install --no-crd-hook
|
|
1740
|
+
"""
|
|
1741
|
+
disable_openapi_validation: NotRequired[pulumi.Input[bool]]
|
|
1742
|
+
"""
|
|
1743
|
+
If set, the installation process will not validate rendered templates against the Kubernetes OpenAPI Schema
|
|
1744
|
+
"""
|
|
1745
|
+
disable_webhooks: NotRequired[pulumi.Input[bool]]
|
|
1746
|
+
"""
|
|
1747
|
+
Prevent hooks from running.
|
|
1748
|
+
"""
|
|
1749
|
+
force_update: NotRequired[pulumi.Input[bool]]
|
|
1750
|
+
"""
|
|
1751
|
+
Force resource update through delete/recreate if needed.
|
|
1752
|
+
"""
|
|
1753
|
+
keyring: NotRequired[pulumi.Input[str]]
|
|
1754
|
+
"""
|
|
1755
|
+
Location of public keys used for verification. Used only if `verify` is true
|
|
1756
|
+
"""
|
|
1757
|
+
lint: NotRequired[pulumi.Input[bool]]
|
|
1758
|
+
"""
|
|
1759
|
+
Run helm lint when planning.
|
|
1760
|
+
"""
|
|
1761
|
+
manifest: NotRequired[pulumi.Input[Mapping[str, Any]]]
|
|
1762
|
+
"""
|
|
1763
|
+
The rendered manifests as JSON. Not yet supported.
|
|
1764
|
+
"""
|
|
1765
|
+
max_history: NotRequired[pulumi.Input[int]]
|
|
1766
|
+
"""
|
|
1767
|
+
Limit the maximum number of revisions saved per release. Use 0 for no limit.
|
|
1768
|
+
"""
|
|
1769
|
+
name: NotRequired[pulumi.Input[str]]
|
|
1770
|
+
"""
|
|
1771
|
+
Release name.
|
|
1772
|
+
"""
|
|
1773
|
+
namespace: NotRequired[pulumi.Input[str]]
|
|
1774
|
+
"""
|
|
1775
|
+
Namespace to install the release into.
|
|
1776
|
+
"""
|
|
1777
|
+
postrender: NotRequired[pulumi.Input[str]]
|
|
1778
|
+
"""
|
|
1779
|
+
Postrender command to run.
|
|
1780
|
+
"""
|
|
1781
|
+
recreate_pods: NotRequired[pulumi.Input[bool]]
|
|
1782
|
+
"""
|
|
1783
|
+
Perform pods restart during upgrade/rollback.
|
|
1784
|
+
"""
|
|
1785
|
+
render_subchart_notes: NotRequired[pulumi.Input[bool]]
|
|
1786
|
+
"""
|
|
1787
|
+
If set, render subchart notes along with the parent.
|
|
1788
|
+
"""
|
|
1789
|
+
replace: NotRequired[pulumi.Input[bool]]
|
|
1790
|
+
"""
|
|
1791
|
+
Re-use the given name, even if that name is already used. This is unsafe in production
|
|
1792
|
+
"""
|
|
1793
|
+
repository_opts: NotRequired[pulumi.Input['RepositoryOptsArgsDict']]
|
|
1794
|
+
"""
|
|
1795
|
+
Specification defining the Helm chart repository to use.
|
|
1796
|
+
"""
|
|
1797
|
+
reset_values: NotRequired[pulumi.Input[bool]]
|
|
1798
|
+
"""
|
|
1799
|
+
When upgrading, reset the values to the ones built into the chart.
|
|
1800
|
+
"""
|
|
1801
|
+
resource_names: NotRequired[pulumi.Input[Mapping[str, pulumi.Input[Sequence[pulumi.Input[str]]]]]]
|
|
1802
|
+
"""
|
|
1803
|
+
Names of resources created by the release grouped by "kind/version".
|
|
1804
|
+
"""
|
|
1805
|
+
reuse_values: NotRequired[pulumi.Input[bool]]
|
|
1806
|
+
"""
|
|
1807
|
+
When upgrading, reuse the last release's values and merge in any overrides. If 'resetValues' is specified, this is ignored
|
|
1808
|
+
"""
|
|
1809
|
+
skip_await: NotRequired[pulumi.Input[bool]]
|
|
1810
|
+
"""
|
|
1811
|
+
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.
|
|
1812
|
+
"""
|
|
1813
|
+
skip_crds: NotRequired[pulumi.Input[bool]]
|
|
1814
|
+
"""
|
|
1815
|
+
If set, no CRDs will be installed. By default, CRDs are installed if not already present.
|
|
1816
|
+
"""
|
|
1817
|
+
timeout: NotRequired[pulumi.Input[int]]
|
|
1818
|
+
"""
|
|
1819
|
+
Time in seconds to wait for any individual kubernetes operation.
|
|
1820
|
+
"""
|
|
1821
|
+
value_yaml_files: NotRequired[pulumi.Input[Sequence[pulumi.Input[Union[pulumi.Asset, pulumi.Archive]]]]]
|
|
1822
|
+
"""
|
|
1823
|
+
List of assets (raw yaml files). Content is read and merged with values. Not yet supported.
|
|
1824
|
+
"""
|
|
1825
|
+
values: NotRequired[pulumi.Input[Mapping[str, Any]]]
|
|
1826
|
+
"""
|
|
1827
|
+
Custom values set for the release.
|
|
1828
|
+
"""
|
|
1829
|
+
verify: NotRequired[pulumi.Input[bool]]
|
|
1830
|
+
"""
|
|
1831
|
+
Verify the package before installing it.
|
|
1832
|
+
"""
|
|
1833
|
+
version: NotRequired[pulumi.Input[str]]
|
|
1834
|
+
"""
|
|
1835
|
+
Specify the exact chart version to install. If this is not specified, the latest version is installed.
|
|
1836
|
+
"""
|
|
1837
|
+
wait_for_jobs: NotRequired[pulumi.Input[bool]]
|
|
1838
|
+
"""
|
|
1839
|
+
Will wait until all Jobs have been completed before marking the release as successful. This is ignored if `skipAwait` is enabled.
|
|
1840
|
+
"""
|
|
1841
|
+
elif False:
|
|
1842
|
+
ReleaseArgsDict: TypeAlias = Mapping[str, Any]
|
|
1843
|
+
|
|
1844
|
+
@pulumi.input_type
|
|
1845
|
+
class ReleaseArgs:
|
|
1846
|
+
def __init__(__self__, *,
|
|
1847
|
+
atomic: Optional[pulumi.Input[bool]] = None,
|
|
1848
|
+
chart: Optional[pulumi.Input[str]] = None,
|
|
1849
|
+
cleanup_on_fail: Optional[pulumi.Input[bool]] = None,
|
|
1850
|
+
create_namespace: Optional[pulumi.Input[bool]] = None,
|
|
1851
|
+
dependency_update: Optional[pulumi.Input[bool]] = None,
|
|
1852
|
+
description: Optional[pulumi.Input[str]] = None,
|
|
1853
|
+
devel: Optional[pulumi.Input[bool]] = None,
|
|
1854
|
+
disable_crd_hooks: Optional[pulumi.Input[bool]] = None,
|
|
1855
|
+
disable_openapi_validation: Optional[pulumi.Input[bool]] = None,
|
|
1856
|
+
disable_webhooks: Optional[pulumi.Input[bool]] = None,
|
|
1857
|
+
force_update: Optional[pulumi.Input[bool]] = None,
|
|
1858
|
+
keyring: Optional[pulumi.Input[str]] = None,
|
|
1859
|
+
lint: Optional[pulumi.Input[bool]] = None,
|
|
1860
|
+
manifest: Optional[pulumi.Input[Mapping[str, Any]]] = None,
|
|
1861
|
+
max_history: Optional[pulumi.Input[int]] = None,
|
|
1862
|
+
name: Optional[pulumi.Input[str]] = None,
|
|
1863
|
+
namespace: Optional[pulumi.Input[str]] = None,
|
|
1864
|
+
postrender: Optional[pulumi.Input[str]] = None,
|
|
1865
|
+
recreate_pods: Optional[pulumi.Input[bool]] = None,
|
|
1866
|
+
render_subchart_notes: Optional[pulumi.Input[bool]] = None,
|
|
1867
|
+
replace: Optional[pulumi.Input[bool]] = None,
|
|
1868
|
+
repository_opts: Optional[pulumi.Input['RepositoryOptsArgs']] = None,
|
|
1869
|
+
reset_values: Optional[pulumi.Input[bool]] = None,
|
|
1870
|
+
resource_names: Optional[pulumi.Input[Mapping[str, pulumi.Input[Sequence[pulumi.Input[str]]]]]] = None,
|
|
1871
|
+
reuse_values: Optional[pulumi.Input[bool]] = None,
|
|
1872
|
+
skip_await: Optional[pulumi.Input[bool]] = None,
|
|
1873
|
+
skip_crds: Optional[pulumi.Input[bool]] = None,
|
|
1874
|
+
timeout: Optional[pulumi.Input[int]] = None,
|
|
1875
|
+
value_yaml_files: Optional[pulumi.Input[Sequence[pulumi.Input[Union[pulumi.Asset, pulumi.Archive]]]]] = None,
|
|
1876
|
+
values: Optional[pulumi.Input[Mapping[str, Any]]] = None,
|
|
1877
|
+
verify: Optional[pulumi.Input[bool]] = None,
|
|
1878
|
+
version: Optional[pulumi.Input[str]] = None,
|
|
1879
|
+
wait_for_jobs: Optional[pulumi.Input[bool]] = None):
|
|
1880
|
+
"""
|
|
1881
|
+
A Release is an instance of a chart running in a Kubernetes cluster.
|
|
1882
|
+
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.
|
|
1883
|
+
Note - Helm Release is currently in BETA and may change. Use in production environment is discouraged.
|
|
1884
|
+
:param pulumi.Input[bool] atomic: If set, installation process purges chart on fail. `skipAwait` will be disabled automatically if atomic is used.
|
|
1885
|
+
:param pulumi.Input[str] chart: Chart name to be installed. A path may be used.
|
|
1886
|
+
:param pulumi.Input[bool] cleanup_on_fail: Allow deletion of new resources created in this upgrade when upgrade fails.
|
|
1887
|
+
:param pulumi.Input[bool] create_namespace: Create the namespace if it does not exist.
|
|
1888
|
+
:param pulumi.Input[bool] dependency_update: Run helm dependency update before installing the chart.
|
|
1889
|
+
:param pulumi.Input[str] description: Add a custom description
|
|
1890
|
+
:param pulumi.Input[bool] devel: Use chart development versions, too. Equivalent to version '>0.0.0-0'. If `version` is set, this is ignored.
|
|
1891
|
+
:param pulumi.Input[bool] disable_crd_hooks: Prevent CRD hooks from, running, but run other hooks. See helm install --no-crd-hook
|
|
1892
|
+
:param pulumi.Input[bool] disable_openapi_validation: If set, the installation process will not validate rendered templates against the Kubernetes OpenAPI Schema
|
|
1893
|
+
:param pulumi.Input[bool] disable_webhooks: Prevent hooks from running.
|
|
1894
|
+
:param pulumi.Input[bool] force_update: Force resource update through delete/recreate if needed.
|
|
1895
|
+
:param pulumi.Input[str] keyring: Location of public keys used for verification. Used only if `verify` is true
|
|
1896
|
+
:param pulumi.Input[bool] lint: Run helm lint when planning.
|
|
1897
|
+
:param pulumi.Input[Mapping[str, Any]] manifest: The rendered manifests as JSON. Not yet supported.
|
|
1898
|
+
:param pulumi.Input[int] max_history: Limit the maximum number of revisions saved per release. Use 0 for no limit.
|
|
1899
|
+
:param pulumi.Input[str] name: Release name.
|
|
1900
|
+
:param pulumi.Input[str] namespace: Namespace to install the release into.
|
|
1901
|
+
:param pulumi.Input[str] postrender: Postrender command to run.
|
|
1902
|
+
:param pulumi.Input[bool] recreate_pods: Perform pods restart during upgrade/rollback.
|
|
1903
|
+
:param pulumi.Input[bool] render_subchart_notes: If set, render subchart notes along with the parent.
|
|
1904
|
+
:param pulumi.Input[bool] replace: Re-use the given name, even if that name is already used. This is unsafe in production
|
|
1905
|
+
:param pulumi.Input['RepositoryOptsArgs'] repository_opts: Specification defining the Helm chart repository to use.
|
|
1906
|
+
:param pulumi.Input[bool] reset_values: When upgrading, reset the values to the ones built into the chart.
|
|
1907
|
+
:param pulumi.Input[Mapping[str, pulumi.Input[Sequence[pulumi.Input[str]]]]] resource_names: Names of resources created by the release grouped by "kind/version".
|
|
1908
|
+
: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
|
|
1909
|
+
: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.
|
|
1910
|
+
:param pulumi.Input[bool] skip_crds: If set, no CRDs will be installed. By default, CRDs are installed if not already present.
|
|
1911
|
+
:param pulumi.Input[int] timeout: Time in seconds to wait for any individual kubernetes operation.
|
|
1912
|
+
: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.
|
|
1913
|
+
:param pulumi.Input[Mapping[str, Any]] values: Custom values set for the release.
|
|
1914
|
+
:param pulumi.Input[bool] verify: Verify the package before installing it.
|
|
1915
|
+
:param pulumi.Input[str] version: Specify the exact chart version to install. If this is not specified, the latest version is installed.
|
|
1916
|
+
: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.
|
|
1917
|
+
"""
|
|
1918
|
+
if atomic is not None:
|
|
1919
|
+
pulumi.set(__self__, "atomic", atomic)
|
|
1920
|
+
if chart is not None:
|
|
1921
|
+
pulumi.set(__self__, "chart", chart)
|
|
1922
|
+
if cleanup_on_fail is not None:
|
|
1923
|
+
pulumi.set(__self__, "cleanup_on_fail", cleanup_on_fail)
|
|
1924
|
+
if create_namespace is not None:
|
|
1925
|
+
pulumi.set(__self__, "create_namespace", create_namespace)
|
|
1926
|
+
if dependency_update is not None:
|
|
1927
|
+
pulumi.set(__self__, "dependency_update", dependency_update)
|
|
1928
|
+
if description is not None:
|
|
1929
|
+
pulumi.set(__self__, "description", description)
|
|
1930
|
+
if devel is not None:
|
|
1931
|
+
pulumi.set(__self__, "devel", devel)
|
|
1932
|
+
if disable_crd_hooks is not None:
|
|
1933
|
+
pulumi.set(__self__, "disable_crd_hooks", disable_crd_hooks)
|
|
1934
|
+
if disable_openapi_validation is not None:
|
|
1935
|
+
pulumi.set(__self__, "disable_openapi_validation", disable_openapi_validation)
|
|
1936
|
+
if disable_webhooks is not None:
|
|
1937
|
+
pulumi.set(__self__, "disable_webhooks", disable_webhooks)
|
|
1938
|
+
if force_update is not None:
|
|
1939
|
+
pulumi.set(__self__, "force_update", force_update)
|
|
1940
|
+
if keyring is not None:
|
|
1941
|
+
pulumi.set(__self__, "keyring", keyring)
|
|
1942
|
+
if lint is not None:
|
|
1943
|
+
pulumi.set(__self__, "lint", lint)
|
|
1944
|
+
if manifest is not None:
|
|
1945
|
+
pulumi.set(__self__, "manifest", manifest)
|
|
1946
|
+
if max_history is not None:
|
|
1947
|
+
pulumi.set(__self__, "max_history", max_history)
|
|
1948
|
+
if name is not None:
|
|
1949
|
+
pulumi.set(__self__, "name", name)
|
|
1950
|
+
if namespace is not None:
|
|
1951
|
+
pulumi.set(__self__, "namespace", namespace)
|
|
1952
|
+
if postrender is not None:
|
|
1953
|
+
pulumi.set(__self__, "postrender", postrender)
|
|
1954
|
+
if recreate_pods is not None:
|
|
1955
|
+
pulumi.set(__self__, "recreate_pods", recreate_pods)
|
|
1956
|
+
if render_subchart_notes is not None:
|
|
1957
|
+
pulumi.set(__self__, "render_subchart_notes", render_subchart_notes)
|
|
1958
|
+
if replace is not None:
|
|
1959
|
+
pulumi.set(__self__, "replace", replace)
|
|
1960
|
+
if repository_opts is not None:
|
|
1961
|
+
pulumi.set(__self__, "repository_opts", repository_opts)
|
|
1962
|
+
if reset_values is not None:
|
|
1963
|
+
pulumi.set(__self__, "reset_values", reset_values)
|
|
1964
|
+
if resource_names is not None:
|
|
1965
|
+
pulumi.set(__self__, "resource_names", resource_names)
|
|
1966
|
+
if reuse_values is not None:
|
|
1967
|
+
pulumi.set(__self__, "reuse_values", reuse_values)
|
|
1968
|
+
if skip_await is not None:
|
|
1969
|
+
pulumi.set(__self__, "skip_await", skip_await)
|
|
1970
|
+
if skip_crds is not None:
|
|
1971
|
+
pulumi.set(__self__, "skip_crds", skip_crds)
|
|
1972
|
+
if timeout is not None:
|
|
1973
|
+
pulumi.set(__self__, "timeout", timeout)
|
|
1974
|
+
if value_yaml_files is not None:
|
|
1975
|
+
pulumi.set(__self__, "value_yaml_files", value_yaml_files)
|
|
1976
|
+
if values is not None:
|
|
1977
|
+
pulumi.set(__self__, "values", values)
|
|
1978
|
+
if verify is not None:
|
|
1979
|
+
pulumi.set(__self__, "verify", verify)
|
|
1980
|
+
if version is not None:
|
|
1981
|
+
pulumi.set(__self__, "version", version)
|
|
1982
|
+
if wait_for_jobs is not None:
|
|
1983
|
+
pulumi.set(__self__, "wait_for_jobs", wait_for_jobs)
|
|
1984
|
+
|
|
1985
|
+
@property
|
|
1986
|
+
@pulumi.getter
|
|
1987
|
+
def atomic(self) -> Optional[pulumi.Input[bool]]:
|
|
1988
|
+
"""
|
|
1989
|
+
If set, installation process purges chart on fail. `skipAwait` will be disabled automatically if atomic is used.
|
|
1990
|
+
"""
|
|
1991
|
+
return pulumi.get(self, "atomic")
|
|
1992
|
+
|
|
1993
|
+
@atomic.setter
|
|
1994
|
+
def atomic(self, value: Optional[pulumi.Input[bool]]):
|
|
1995
|
+
pulumi.set(self, "atomic", value)
|
|
1996
|
+
|
|
1997
|
+
@property
|
|
1998
|
+
@pulumi.getter
|
|
1999
|
+
def chart(self) -> Optional[pulumi.Input[str]]:
|
|
2000
|
+
"""
|
|
2001
|
+
Chart name to be installed. A path may be used.
|
|
2002
|
+
"""
|
|
2003
|
+
return pulumi.get(self, "chart")
|
|
2004
|
+
|
|
2005
|
+
@chart.setter
|
|
2006
|
+
def chart(self, value: Optional[pulumi.Input[str]]):
|
|
2007
|
+
pulumi.set(self, "chart", value)
|
|
2008
|
+
|
|
2009
|
+
@property
|
|
2010
|
+
@pulumi.getter(name="cleanupOnFail")
|
|
2011
|
+
def cleanup_on_fail(self) -> Optional[pulumi.Input[bool]]:
|
|
2012
|
+
"""
|
|
2013
|
+
Allow deletion of new resources created in this upgrade when upgrade fails.
|
|
2014
|
+
"""
|
|
2015
|
+
return pulumi.get(self, "cleanup_on_fail")
|
|
2016
|
+
|
|
2017
|
+
@cleanup_on_fail.setter
|
|
2018
|
+
def cleanup_on_fail(self, value: Optional[pulumi.Input[bool]]):
|
|
2019
|
+
pulumi.set(self, "cleanup_on_fail", value)
|
|
2020
|
+
|
|
2021
|
+
@property
|
|
2022
|
+
@pulumi.getter(name="createNamespace")
|
|
2023
|
+
def create_namespace(self) -> Optional[pulumi.Input[bool]]:
|
|
2024
|
+
"""
|
|
2025
|
+
Create the namespace if it does not exist.
|
|
2026
|
+
"""
|
|
2027
|
+
return pulumi.get(self, "create_namespace")
|
|
2028
|
+
|
|
2029
|
+
@create_namespace.setter
|
|
2030
|
+
def create_namespace(self, value: Optional[pulumi.Input[bool]]):
|
|
2031
|
+
pulumi.set(self, "create_namespace", value)
|
|
2032
|
+
|
|
2033
|
+
@property
|
|
2034
|
+
@pulumi.getter(name="dependencyUpdate")
|
|
2035
|
+
def dependency_update(self) -> Optional[pulumi.Input[bool]]:
|
|
2036
|
+
"""
|
|
2037
|
+
Run helm dependency update before installing the chart.
|
|
2038
|
+
"""
|
|
2039
|
+
return pulumi.get(self, "dependency_update")
|
|
2040
|
+
|
|
2041
|
+
@dependency_update.setter
|
|
2042
|
+
def dependency_update(self, value: Optional[pulumi.Input[bool]]):
|
|
2043
|
+
pulumi.set(self, "dependency_update", value)
|
|
2044
|
+
|
|
2045
|
+
@property
|
|
2046
|
+
@pulumi.getter
|
|
2047
|
+
def description(self) -> Optional[pulumi.Input[str]]:
|
|
2048
|
+
"""
|
|
2049
|
+
Add a custom description
|
|
2050
|
+
"""
|
|
2051
|
+
return pulumi.get(self, "description")
|
|
2052
|
+
|
|
2053
|
+
@description.setter
|
|
2054
|
+
def description(self, value: Optional[pulumi.Input[str]]):
|
|
2055
|
+
pulumi.set(self, "description", value)
|
|
2056
|
+
|
|
2057
|
+
@property
|
|
2058
|
+
@pulumi.getter
|
|
2059
|
+
def devel(self) -> Optional[pulumi.Input[bool]]:
|
|
2060
|
+
"""
|
|
2061
|
+
Use chart development versions, too. Equivalent to version '>0.0.0-0'. If `version` is set, this is ignored.
|
|
2062
|
+
"""
|
|
2063
|
+
return pulumi.get(self, "devel")
|
|
2064
|
+
|
|
2065
|
+
@devel.setter
|
|
2066
|
+
def devel(self, value: Optional[pulumi.Input[bool]]):
|
|
2067
|
+
pulumi.set(self, "devel", value)
|
|
2068
|
+
|
|
2069
|
+
@property
|
|
2070
|
+
@pulumi.getter(name="disableCRDHooks")
|
|
2071
|
+
def disable_crd_hooks(self) -> Optional[pulumi.Input[bool]]:
|
|
2072
|
+
"""
|
|
2073
|
+
Prevent CRD hooks from, running, but run other hooks. See helm install --no-crd-hook
|
|
2074
|
+
"""
|
|
2075
|
+
return pulumi.get(self, "disable_crd_hooks")
|
|
2076
|
+
|
|
2077
|
+
@disable_crd_hooks.setter
|
|
2078
|
+
def disable_crd_hooks(self, value: Optional[pulumi.Input[bool]]):
|
|
2079
|
+
pulumi.set(self, "disable_crd_hooks", value)
|
|
2080
|
+
|
|
2081
|
+
@property
|
|
2082
|
+
@pulumi.getter(name="disableOpenapiValidation")
|
|
2083
|
+
def disable_openapi_validation(self) -> Optional[pulumi.Input[bool]]:
|
|
2084
|
+
"""
|
|
2085
|
+
If set, the installation process will not validate rendered templates against the Kubernetes OpenAPI Schema
|
|
2086
|
+
"""
|
|
2087
|
+
return pulumi.get(self, "disable_openapi_validation")
|
|
2088
|
+
|
|
2089
|
+
@disable_openapi_validation.setter
|
|
2090
|
+
def disable_openapi_validation(self, value: Optional[pulumi.Input[bool]]):
|
|
2091
|
+
pulumi.set(self, "disable_openapi_validation", value)
|
|
2092
|
+
|
|
2093
|
+
@property
|
|
2094
|
+
@pulumi.getter(name="disableWebhooks")
|
|
2095
|
+
def disable_webhooks(self) -> Optional[pulumi.Input[bool]]:
|
|
2096
|
+
"""
|
|
2097
|
+
Prevent hooks from running.
|
|
2098
|
+
"""
|
|
2099
|
+
return pulumi.get(self, "disable_webhooks")
|
|
2100
|
+
|
|
2101
|
+
@disable_webhooks.setter
|
|
2102
|
+
def disable_webhooks(self, value: Optional[pulumi.Input[bool]]):
|
|
2103
|
+
pulumi.set(self, "disable_webhooks", value)
|
|
2104
|
+
|
|
2105
|
+
@property
|
|
2106
|
+
@pulumi.getter(name="forceUpdate")
|
|
2107
|
+
def force_update(self) -> Optional[pulumi.Input[bool]]:
|
|
2108
|
+
"""
|
|
2109
|
+
Force resource update through delete/recreate if needed.
|
|
2110
|
+
"""
|
|
2111
|
+
return pulumi.get(self, "force_update")
|
|
2112
|
+
|
|
2113
|
+
@force_update.setter
|
|
2114
|
+
def force_update(self, value: Optional[pulumi.Input[bool]]):
|
|
2115
|
+
pulumi.set(self, "force_update", value)
|
|
2116
|
+
|
|
2117
|
+
@property
|
|
2118
|
+
@pulumi.getter
|
|
2119
|
+
def keyring(self) -> Optional[pulumi.Input[str]]:
|
|
2120
|
+
"""
|
|
2121
|
+
Location of public keys used for verification. Used only if `verify` is true
|
|
2122
|
+
"""
|
|
2123
|
+
return pulumi.get(self, "keyring")
|
|
2124
|
+
|
|
2125
|
+
@keyring.setter
|
|
2126
|
+
def keyring(self, value: Optional[pulumi.Input[str]]):
|
|
2127
|
+
pulumi.set(self, "keyring", value)
|
|
2128
|
+
|
|
2129
|
+
@property
|
|
2130
|
+
@pulumi.getter
|
|
2131
|
+
def lint(self) -> Optional[pulumi.Input[bool]]:
|
|
2132
|
+
"""
|
|
2133
|
+
Run helm lint when planning.
|
|
2134
|
+
"""
|
|
2135
|
+
return pulumi.get(self, "lint")
|
|
2136
|
+
|
|
2137
|
+
@lint.setter
|
|
2138
|
+
def lint(self, value: Optional[pulumi.Input[bool]]):
|
|
2139
|
+
pulumi.set(self, "lint", value)
|
|
2140
|
+
|
|
2141
|
+
@property
|
|
2142
|
+
@pulumi.getter
|
|
2143
|
+
def manifest(self) -> Optional[pulumi.Input[Mapping[str, Any]]]:
|
|
2144
|
+
"""
|
|
2145
|
+
The rendered manifests as JSON. Not yet supported.
|
|
2146
|
+
"""
|
|
2147
|
+
return pulumi.get(self, "manifest")
|
|
2148
|
+
|
|
2149
|
+
@manifest.setter
|
|
2150
|
+
def manifest(self, value: Optional[pulumi.Input[Mapping[str, Any]]]):
|
|
2151
|
+
pulumi.set(self, "manifest", value)
|
|
2152
|
+
|
|
2153
|
+
@property
|
|
2154
|
+
@pulumi.getter(name="maxHistory")
|
|
2155
|
+
def max_history(self) -> Optional[pulumi.Input[int]]:
|
|
2156
|
+
"""
|
|
2157
|
+
Limit the maximum number of revisions saved per release. Use 0 for no limit.
|
|
2158
|
+
"""
|
|
2159
|
+
return pulumi.get(self, "max_history")
|
|
2160
|
+
|
|
2161
|
+
@max_history.setter
|
|
2162
|
+
def max_history(self, value: Optional[pulumi.Input[int]]):
|
|
2163
|
+
pulumi.set(self, "max_history", value)
|
|
2164
|
+
|
|
2165
|
+
@property
|
|
2166
|
+
@pulumi.getter
|
|
2167
|
+
def name(self) -> Optional[pulumi.Input[str]]:
|
|
2168
|
+
"""
|
|
2169
|
+
Release name.
|
|
2170
|
+
"""
|
|
2171
|
+
return pulumi.get(self, "name")
|
|
2172
|
+
|
|
2173
|
+
@name.setter
|
|
2174
|
+
def name(self, value: Optional[pulumi.Input[str]]):
|
|
2175
|
+
pulumi.set(self, "name", value)
|
|
2176
|
+
|
|
2177
|
+
@property
|
|
2178
|
+
@pulumi.getter
|
|
2179
|
+
def namespace(self) -> Optional[pulumi.Input[str]]:
|
|
2180
|
+
"""
|
|
2181
|
+
Namespace to install the release into.
|
|
2182
|
+
"""
|
|
2183
|
+
return pulumi.get(self, "namespace")
|
|
2184
|
+
|
|
2185
|
+
@namespace.setter
|
|
2186
|
+
def namespace(self, value: Optional[pulumi.Input[str]]):
|
|
2187
|
+
pulumi.set(self, "namespace", value)
|
|
2188
|
+
|
|
2189
|
+
@property
|
|
2190
|
+
@pulumi.getter
|
|
2191
|
+
def postrender(self) -> Optional[pulumi.Input[str]]:
|
|
2192
|
+
"""
|
|
2193
|
+
Postrender command to run.
|
|
2194
|
+
"""
|
|
2195
|
+
return pulumi.get(self, "postrender")
|
|
2196
|
+
|
|
2197
|
+
@postrender.setter
|
|
2198
|
+
def postrender(self, value: Optional[pulumi.Input[str]]):
|
|
2199
|
+
pulumi.set(self, "postrender", value)
|
|
2200
|
+
|
|
2201
|
+
@property
|
|
2202
|
+
@pulumi.getter(name="recreatePods")
|
|
2203
|
+
def recreate_pods(self) -> Optional[pulumi.Input[bool]]:
|
|
2204
|
+
"""
|
|
2205
|
+
Perform pods restart during upgrade/rollback.
|
|
2206
|
+
"""
|
|
2207
|
+
return pulumi.get(self, "recreate_pods")
|
|
2208
|
+
|
|
2209
|
+
@recreate_pods.setter
|
|
2210
|
+
def recreate_pods(self, value: Optional[pulumi.Input[bool]]):
|
|
2211
|
+
pulumi.set(self, "recreate_pods", value)
|
|
2212
|
+
|
|
2213
|
+
@property
|
|
2214
|
+
@pulumi.getter(name="renderSubchartNotes")
|
|
2215
|
+
def render_subchart_notes(self) -> Optional[pulumi.Input[bool]]:
|
|
2216
|
+
"""
|
|
2217
|
+
If set, render subchart notes along with the parent.
|
|
2218
|
+
"""
|
|
2219
|
+
return pulumi.get(self, "render_subchart_notes")
|
|
2220
|
+
|
|
2221
|
+
@render_subchart_notes.setter
|
|
2222
|
+
def render_subchart_notes(self, value: Optional[pulumi.Input[bool]]):
|
|
2223
|
+
pulumi.set(self, "render_subchart_notes", value)
|
|
2224
|
+
|
|
2225
|
+
@property
|
|
2226
|
+
@pulumi.getter
|
|
2227
|
+
def replace(self) -> Optional[pulumi.Input[bool]]:
|
|
2228
|
+
"""
|
|
2229
|
+
Re-use the given name, even if that name is already used. This is unsafe in production
|
|
2230
|
+
"""
|
|
2231
|
+
return pulumi.get(self, "replace")
|
|
2232
|
+
|
|
2233
|
+
@replace.setter
|
|
2234
|
+
def replace(self, value: Optional[pulumi.Input[bool]]):
|
|
2235
|
+
pulumi.set(self, "replace", value)
|
|
2236
|
+
|
|
2237
|
+
@property
|
|
2238
|
+
@pulumi.getter(name="repositoryOpts")
|
|
2239
|
+
def repository_opts(self) -> Optional[pulumi.Input['RepositoryOptsArgs']]:
|
|
2240
|
+
"""
|
|
2241
|
+
Specification defining the Helm chart repository to use.
|
|
2242
|
+
"""
|
|
2243
|
+
return pulumi.get(self, "repository_opts")
|
|
2244
|
+
|
|
2245
|
+
@repository_opts.setter
|
|
2246
|
+
def repository_opts(self, value: Optional[pulumi.Input['RepositoryOptsArgs']]):
|
|
2247
|
+
pulumi.set(self, "repository_opts", value)
|
|
2248
|
+
|
|
2249
|
+
@property
|
|
2250
|
+
@pulumi.getter(name="resetValues")
|
|
2251
|
+
def reset_values(self) -> Optional[pulumi.Input[bool]]:
|
|
2252
|
+
"""
|
|
2253
|
+
When upgrading, reset the values to the ones built into the chart.
|
|
2254
|
+
"""
|
|
2255
|
+
return pulumi.get(self, "reset_values")
|
|
2256
|
+
|
|
2257
|
+
@reset_values.setter
|
|
2258
|
+
def reset_values(self, value: Optional[pulumi.Input[bool]]):
|
|
2259
|
+
pulumi.set(self, "reset_values", value)
|
|
2260
|
+
|
|
2261
|
+
@property
|
|
2262
|
+
@pulumi.getter(name="resourceNames")
|
|
2263
|
+
def resource_names(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[Sequence[pulumi.Input[str]]]]]]:
|
|
2264
|
+
"""
|
|
2265
|
+
Names of resources created by the release grouped by "kind/version".
|
|
2266
|
+
"""
|
|
2267
|
+
return pulumi.get(self, "resource_names")
|
|
2268
|
+
|
|
2269
|
+
@resource_names.setter
|
|
2270
|
+
def resource_names(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[Sequence[pulumi.Input[str]]]]]]):
|
|
2271
|
+
pulumi.set(self, "resource_names", value)
|
|
2272
|
+
|
|
2273
|
+
@property
|
|
2274
|
+
@pulumi.getter(name="reuseValues")
|
|
2275
|
+
def reuse_values(self) -> Optional[pulumi.Input[bool]]:
|
|
2276
|
+
"""
|
|
2277
|
+
When upgrading, reuse the last release's values and merge in any overrides. If 'resetValues' is specified, this is ignored
|
|
2278
|
+
"""
|
|
2279
|
+
return pulumi.get(self, "reuse_values")
|
|
2280
|
+
|
|
2281
|
+
@reuse_values.setter
|
|
2282
|
+
def reuse_values(self, value: Optional[pulumi.Input[bool]]):
|
|
2283
|
+
pulumi.set(self, "reuse_values", value)
|
|
2284
|
+
|
|
2285
|
+
@property
|
|
2286
|
+
@pulumi.getter(name="skipAwait")
|
|
2287
|
+
def skip_await(self) -> Optional[pulumi.Input[bool]]:
|
|
2288
|
+
"""
|
|
2289
|
+
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.
|
|
2290
|
+
"""
|
|
2291
|
+
return pulumi.get(self, "skip_await")
|
|
2292
|
+
|
|
2293
|
+
@skip_await.setter
|
|
2294
|
+
def skip_await(self, value: Optional[pulumi.Input[bool]]):
|
|
2295
|
+
pulumi.set(self, "skip_await", value)
|
|
2296
|
+
|
|
2297
|
+
@property
|
|
2298
|
+
@pulumi.getter(name="skipCrds")
|
|
2299
|
+
def skip_crds(self) -> Optional[pulumi.Input[bool]]:
|
|
2300
|
+
"""
|
|
2301
|
+
If set, no CRDs will be installed. By default, CRDs are installed if not already present.
|
|
2302
|
+
"""
|
|
2303
|
+
return pulumi.get(self, "skip_crds")
|
|
2304
|
+
|
|
2305
|
+
@skip_crds.setter
|
|
2306
|
+
def skip_crds(self, value: Optional[pulumi.Input[bool]]):
|
|
2307
|
+
pulumi.set(self, "skip_crds", value)
|
|
2308
|
+
|
|
2309
|
+
@property
|
|
2310
|
+
@pulumi.getter
|
|
2311
|
+
def timeout(self) -> Optional[pulumi.Input[int]]:
|
|
2312
|
+
"""
|
|
2313
|
+
Time in seconds to wait for any individual kubernetes operation.
|
|
2314
|
+
"""
|
|
2315
|
+
return pulumi.get(self, "timeout")
|
|
2316
|
+
|
|
2317
|
+
@timeout.setter
|
|
2318
|
+
def timeout(self, value: Optional[pulumi.Input[int]]):
|
|
2319
|
+
pulumi.set(self, "timeout", value)
|
|
2320
|
+
|
|
2321
|
+
@property
|
|
2322
|
+
@pulumi.getter(name="valueYamlFiles")
|
|
2323
|
+
def value_yaml_files(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[Union[pulumi.Asset, pulumi.Archive]]]]]:
|
|
2324
|
+
"""
|
|
2325
|
+
List of assets (raw yaml files). Content is read and merged with values. Not yet supported.
|
|
2326
|
+
"""
|
|
2327
|
+
return pulumi.get(self, "value_yaml_files")
|
|
2328
|
+
|
|
2329
|
+
@value_yaml_files.setter
|
|
2330
|
+
def value_yaml_files(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[Union[pulumi.Asset, pulumi.Archive]]]]]):
|
|
2331
|
+
pulumi.set(self, "value_yaml_files", value)
|
|
2332
|
+
|
|
2333
|
+
@property
|
|
2334
|
+
@pulumi.getter
|
|
2335
|
+
def values(self) -> Optional[pulumi.Input[Mapping[str, Any]]]:
|
|
2336
|
+
"""
|
|
2337
|
+
Custom values set for the release.
|
|
2338
|
+
"""
|
|
2339
|
+
return pulumi.get(self, "values")
|
|
2340
|
+
|
|
2341
|
+
@values.setter
|
|
2342
|
+
def values(self, value: Optional[pulumi.Input[Mapping[str, Any]]]):
|
|
2343
|
+
pulumi.set(self, "values", value)
|
|
2344
|
+
|
|
2345
|
+
@property
|
|
2346
|
+
@pulumi.getter
|
|
2347
|
+
def verify(self) -> Optional[pulumi.Input[bool]]:
|
|
2348
|
+
"""
|
|
2349
|
+
Verify the package before installing it.
|
|
2350
|
+
"""
|
|
2351
|
+
return pulumi.get(self, "verify")
|
|
2352
|
+
|
|
2353
|
+
@verify.setter
|
|
2354
|
+
def verify(self, value: Optional[pulumi.Input[bool]]):
|
|
2355
|
+
pulumi.set(self, "verify", value)
|
|
2356
|
+
|
|
2357
|
+
@property
|
|
2358
|
+
@pulumi.getter
|
|
2359
|
+
def version(self) -> Optional[pulumi.Input[str]]:
|
|
2360
|
+
"""
|
|
2361
|
+
Specify the exact chart version to install. If this is not specified, the latest version is installed.
|
|
2362
|
+
"""
|
|
2363
|
+
return pulumi.get(self, "version")
|
|
2364
|
+
|
|
2365
|
+
@version.setter
|
|
2366
|
+
def version(self, value: Optional[pulumi.Input[str]]):
|
|
2367
|
+
pulumi.set(self, "version", value)
|
|
2368
|
+
|
|
2369
|
+
@property
|
|
2370
|
+
@pulumi.getter(name="waitForJobs")
|
|
2371
|
+
def wait_for_jobs(self) -> Optional[pulumi.Input[bool]]:
|
|
2372
|
+
"""
|
|
2373
|
+
Will wait until all Jobs have been completed before marking the release as successful. This is ignored if `skipAwait` is enabled.
|
|
2374
|
+
"""
|
|
2375
|
+
return pulumi.get(self, "wait_for_jobs")
|
|
2376
|
+
|
|
2377
|
+
@wait_for_jobs.setter
|
|
2378
|
+
def wait_for_jobs(self, value: Optional[pulumi.Input[bool]]):
|
|
2379
|
+
pulumi.set(self, "wait_for_jobs", value)
|
|
2380
|
+
|
|
2381
|
+
|
|
2382
|
+
if not MYPY:
|
|
2383
|
+
class RepositoryOptsArgsDict(TypedDict):
|
|
2384
|
+
"""
|
|
2385
|
+
Specification defining the Helm chart repository to use.
|
|
2386
|
+
"""
|
|
2387
|
+
ca_file: NotRequired[pulumi.Input[str]]
|
|
2388
|
+
"""
|
|
2389
|
+
The Repository's CA File
|
|
2390
|
+
"""
|
|
2391
|
+
cert_file: NotRequired[pulumi.Input[str]]
|
|
2392
|
+
"""
|
|
2393
|
+
The repository's cert file
|
|
2394
|
+
"""
|
|
2395
|
+
key_file: NotRequired[pulumi.Input[str]]
|
|
2396
|
+
"""
|
|
2397
|
+
The repository's cert key file
|
|
2398
|
+
"""
|
|
2399
|
+
password: NotRequired[pulumi.Input[str]]
|
|
2400
|
+
"""
|
|
2401
|
+
Password for HTTP basic authentication
|
|
2402
|
+
"""
|
|
2403
|
+
repo: NotRequired[pulumi.Input[str]]
|
|
2404
|
+
"""
|
|
2405
|
+
Repository where to locate the requested chart. If is a URL the chart is installed without installing the repository.
|
|
2406
|
+
"""
|
|
2407
|
+
username: NotRequired[pulumi.Input[str]]
|
|
2408
|
+
"""
|
|
2409
|
+
Username for HTTP basic authentication
|
|
2410
|
+
"""
|
|
2411
|
+
elif False:
|
|
2412
|
+
RepositoryOptsArgsDict: TypeAlias = Mapping[str, Any]
|
|
2413
|
+
|
|
2414
|
+
@pulumi.input_type
|
|
2415
|
+
class RepositoryOptsArgs:
|
|
2416
|
+
def __init__(__self__, *,
|
|
2417
|
+
ca_file: Optional[pulumi.Input[str]] = None,
|
|
2418
|
+
cert_file: Optional[pulumi.Input[str]] = None,
|
|
2419
|
+
key_file: Optional[pulumi.Input[str]] = None,
|
|
2420
|
+
password: Optional[pulumi.Input[str]] = None,
|
|
2421
|
+
repo: Optional[pulumi.Input[str]] = None,
|
|
2422
|
+
username: Optional[pulumi.Input[str]] = None):
|
|
2423
|
+
"""
|
|
2424
|
+
Specification defining the Helm chart repository to use.
|
|
2425
|
+
:param pulumi.Input[str] ca_file: The Repository's CA File
|
|
2426
|
+
:param pulumi.Input[str] cert_file: The repository's cert file
|
|
2427
|
+
:param pulumi.Input[str] key_file: The repository's cert key file
|
|
2428
|
+
:param pulumi.Input[str] password: Password for HTTP basic authentication
|
|
2429
|
+
:param pulumi.Input[str] repo: Repository where to locate the requested chart. If is a URL the chart is installed without installing the repository.
|
|
2430
|
+
:param pulumi.Input[str] username: Username for HTTP basic authentication
|
|
2431
|
+
"""
|
|
2432
|
+
if ca_file is not None:
|
|
2433
|
+
pulumi.set(__self__, "ca_file", ca_file)
|
|
2434
|
+
if cert_file is not None:
|
|
2435
|
+
pulumi.set(__self__, "cert_file", cert_file)
|
|
2436
|
+
if key_file is not None:
|
|
2437
|
+
pulumi.set(__self__, "key_file", key_file)
|
|
2438
|
+
if password is not None:
|
|
2439
|
+
pulumi.set(__self__, "password", password)
|
|
2440
|
+
if repo is not None:
|
|
2441
|
+
pulumi.set(__self__, "repo", repo)
|
|
2442
|
+
if username is not None:
|
|
2443
|
+
pulumi.set(__self__, "username", username)
|
|
2444
|
+
|
|
2445
|
+
@property
|
|
2446
|
+
@pulumi.getter(name="caFile")
|
|
2447
|
+
def ca_file(self) -> Optional[pulumi.Input[str]]:
|
|
2448
|
+
"""
|
|
2449
|
+
The Repository's CA File
|
|
2450
|
+
"""
|
|
2451
|
+
return pulumi.get(self, "ca_file")
|
|
2452
|
+
|
|
2453
|
+
@ca_file.setter
|
|
2454
|
+
def ca_file(self, value: Optional[pulumi.Input[str]]):
|
|
2455
|
+
pulumi.set(self, "ca_file", value)
|
|
2456
|
+
|
|
2457
|
+
@property
|
|
2458
|
+
@pulumi.getter(name="certFile")
|
|
2459
|
+
def cert_file(self) -> Optional[pulumi.Input[str]]:
|
|
2460
|
+
"""
|
|
2461
|
+
The repository's cert file
|
|
2462
|
+
"""
|
|
2463
|
+
return pulumi.get(self, "cert_file")
|
|
2464
|
+
|
|
2465
|
+
@cert_file.setter
|
|
2466
|
+
def cert_file(self, value: Optional[pulumi.Input[str]]):
|
|
2467
|
+
pulumi.set(self, "cert_file", value)
|
|
2468
|
+
|
|
2469
|
+
@property
|
|
2470
|
+
@pulumi.getter(name="keyFile")
|
|
2471
|
+
def key_file(self) -> Optional[pulumi.Input[str]]:
|
|
2472
|
+
"""
|
|
2473
|
+
The repository's cert key file
|
|
2474
|
+
"""
|
|
2475
|
+
return pulumi.get(self, "key_file")
|
|
2476
|
+
|
|
2477
|
+
@key_file.setter
|
|
2478
|
+
def key_file(self, value: Optional[pulumi.Input[str]]):
|
|
2479
|
+
pulumi.set(self, "key_file", value)
|
|
2480
|
+
|
|
2481
|
+
@property
|
|
2482
|
+
@pulumi.getter
|
|
2483
|
+
def password(self) -> Optional[pulumi.Input[str]]:
|
|
2484
|
+
"""
|
|
2485
|
+
Password for HTTP basic authentication
|
|
2486
|
+
"""
|
|
2487
|
+
return pulumi.get(self, "password")
|
|
2488
|
+
|
|
2489
|
+
@password.setter
|
|
2490
|
+
def password(self, value: Optional[pulumi.Input[str]]):
|
|
2491
|
+
pulumi.set(self, "password", value)
|
|
2492
|
+
|
|
2493
|
+
@property
|
|
2494
|
+
@pulumi.getter
|
|
2495
|
+
def repo(self) -> Optional[pulumi.Input[str]]:
|
|
2496
|
+
"""
|
|
2497
|
+
Repository where to locate the requested chart. If is a URL the chart is installed without installing the repository.
|
|
2498
|
+
"""
|
|
2499
|
+
return pulumi.get(self, "repo")
|
|
2500
|
+
|
|
2501
|
+
@repo.setter
|
|
2502
|
+
def repo(self, value: Optional[pulumi.Input[str]]):
|
|
2503
|
+
pulumi.set(self, "repo", value)
|
|
2504
|
+
|
|
2505
|
+
@property
|
|
2506
|
+
@pulumi.getter
|
|
2507
|
+
def username(self) -> Optional[pulumi.Input[str]]:
|
|
2508
|
+
"""
|
|
2509
|
+
Username for HTTP basic authentication
|
|
2510
|
+
"""
|
|
2511
|
+
return pulumi.get(self, "username")
|
|
2512
|
+
|
|
2513
|
+
@username.setter
|
|
2514
|
+
def username(self, value: Optional[pulumi.Input[str]]):
|
|
2515
|
+
pulumi.set(self, "username", value)
|
|
2516
|
+
|
|
2517
|
+
|