pulumi-spotinst 3.117.0a1743489626__py3-none-any.whl → 3.117.0a1744183551__py3-none-any.whl
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Potentially problematic release.
This version of pulumi-spotinst might be problematic. Click here for more details.
- pulumi_spotinst/__init__.py +1 -0
- pulumi_spotinst/_inputs.py +1181 -1180
- pulumi_spotinst/account.py +15 -14
- pulumi_spotinst/aws/__init__.py +1 -0
- pulumi_spotinst/aws/_inputs.py +2919 -2918
- pulumi_spotinst/aws/account.py +15 -14
- pulumi_spotinst/aws/beanstalk.py +137 -136
- pulumi_spotinst/aws/credentials.py +29 -28
- pulumi_spotinst/aws/elastigroup.py +681 -680
- pulumi_spotinst/aws/managed_instance.py +361 -360
- pulumi_spotinst/aws/mr_scalar.py +470 -469
- pulumi_spotinst/aws/ocean.py +399 -398
- pulumi_spotinst/aws/ocean_extended_resource_definition.py +29 -28
- pulumi_spotinst/aws/ocean_launch_spec.py +197 -196
- pulumi_spotinst/aws/outputs.py +1673 -1672
- pulumi_spotinst/aws/suspension.py +15 -14
- pulumi_spotinst/azure/__init__.py +1 -0
- pulumi_spotinst/azure/_inputs.py +489 -488
- pulumi_spotinst/azure/ocean_np.py +289 -288
- pulumi_spotinst/azure/ocean_np_virtual_node_group.py +249 -248
- pulumi_spotinst/azure/outputs.py +293 -292
- pulumi_spotinst/config/__init__.py +1 -0
- pulumi_spotinst/config/__init__.pyi +1 -0
- pulumi_spotinst/config/vars.py +1 -0
- pulumi_spotinst/credentials_azure.py +71 -70
- pulumi_spotinst/credentials_gcp.py +155 -154
- pulumi_spotinst/data_integration.py +29 -28
- pulumi_spotinst/ecs/__init__.py +1 -0
- pulumi_spotinst/ecs/_inputs.py +475 -474
- pulumi_spotinst/ecs/ocean.py +315 -314
- pulumi_spotinst/ecs/ocean_launch_spec.py +141 -140
- pulumi_spotinst/ecs/outputs.py +285 -284
- pulumi_spotinst/elastigroup_azure_v3.py +201 -200
- pulumi_spotinst/gcp/__init__.py +1 -0
- pulumi_spotinst/gcp/_inputs.py +400 -399
- pulumi_spotinst/gcp/elastigroup.py +355 -354
- pulumi_spotinst/gcp/outputs.py +234 -233
- pulumi_spotinst/gke/__init__.py +1 -0
- pulumi_spotinst/gke/_inputs.py +726 -725
- pulumi_spotinst/gke/elastigroup.py +231 -230
- pulumi_spotinst/gke/ocean_import.py +146 -145
- pulumi_spotinst/gke/ocean_launch_spec.py +141 -140
- pulumi_spotinst/gke/ocean_launch_spec_import.py +29 -28
- pulumi_spotinst/gke/outputs.py +410 -409
- pulumi_spotinst/health_check.py +89 -48
- pulumi_spotinst/ocean_right_sizing_rule.py +41 -40
- pulumi_spotinst/oceancd/__init__.py +1 -0
- pulumi_spotinst/oceancd/_inputs.py +594 -593
- pulumi_spotinst/oceancd/outputs.py +356 -355
- pulumi_spotinst/oceancd/rollout_spec.py +15 -14
- pulumi_spotinst/oceancd/strategy.py +11 -10
- pulumi_spotinst/oceancd/verification_provider.py +29 -28
- pulumi_spotinst/oceancd/verification_template.py +15 -14
- pulumi_spotinst/organization/__init__.py +1 -0
- pulumi_spotinst/organization/_inputs.py +55 -54
- pulumi_spotinst/organization/outputs.py +33 -32
- pulumi_spotinst/organization/policy.py +29 -28
- pulumi_spotinst/organization/programmatic_user.py +43 -42
- pulumi_spotinst/organization/user.py +85 -84
- pulumi_spotinst/organization/user_group.py +43 -42
- pulumi_spotinst/outputs.py +595 -594
- pulumi_spotinst/provider.py +32 -31
- pulumi_spotinst/pulumi-plugin.json +1 -1
- pulumi_spotinst/spark/__init__.py +1 -0
- pulumi_spotinst/spark/_inputs.py +81 -80
- pulumi_spotinst/spark/ocean.py +15 -14
- pulumi_spotinst/spark/ocean_virtual_node_group.py +21 -20
- pulumi_spotinst/spark/outputs.py +49 -48
- pulumi_spotinst/stateful_node_azure.py +191 -190
- pulumi_spotinst/subscription.py +71 -70
- {pulumi_spotinst-3.117.0a1743489626.dist-info → pulumi_spotinst-3.117.0a1744183551.dist-info}/METADATA +1 -1
- pulumi_spotinst-3.117.0a1744183551.dist-info/RECORD +76 -0
- pulumi_spotinst-3.117.0a1743489626.dist-info/RECORD +0 -76
- {pulumi_spotinst-3.117.0a1743489626.dist-info → pulumi_spotinst-3.117.0a1744183551.dist-info}/WHEEL +0 -0
- {pulumi_spotinst-3.117.0a1743489626.dist-info → pulumi_spotinst-3.117.0a1744183551.dist-info}/top_level.txt +0 -0
|
@@ -2,6 +2,7 @@
|
|
|
2
2
|
# *** WARNING: this file was generated by the Pulumi Terraform Bridge (tfgen) Tool. ***
|
|
3
3
|
# *** Do not edit by hand unless you're certain you know what you are doing! ***
|
|
4
4
|
|
|
5
|
+
import builtins
|
|
5
6
|
import copy
|
|
6
7
|
import warnings
|
|
7
8
|
import sys
|
|
@@ -147,7 +148,7 @@ MYPY = False
|
|
|
147
148
|
|
|
148
149
|
if not MYPY:
|
|
149
150
|
class RolloutSpecFailurePolicyArgsDict(TypedDict):
|
|
150
|
-
action: pulumi.Input[str]
|
|
151
|
+
action: pulumi.Input[builtins.str]
|
|
151
152
|
"""
|
|
152
153
|
Choose an action to perform on failure. Default is `abort`. Enum: "abort" "pause" "promote".
|
|
153
154
|
"""
|
|
@@ -157,36 +158,36 @@ elif False:
|
|
|
157
158
|
@pulumi.input_type
|
|
158
159
|
class RolloutSpecFailurePolicyArgs:
|
|
159
160
|
def __init__(__self__, *,
|
|
160
|
-
action: pulumi.Input[str]):
|
|
161
|
+
action: pulumi.Input[builtins.str]):
|
|
161
162
|
"""
|
|
162
|
-
:param pulumi.Input[str] action: Choose an action to perform on failure. Default is `abort`. Enum: "abort" "pause" "promote".
|
|
163
|
+
:param pulumi.Input[builtins.str] action: Choose an action to perform on failure. Default is `abort`. Enum: "abort" "pause" "promote".
|
|
163
164
|
"""
|
|
164
165
|
pulumi.set(__self__, "action", action)
|
|
165
166
|
|
|
166
167
|
@property
|
|
167
168
|
@pulumi.getter
|
|
168
|
-
def action(self) -> pulumi.Input[str]:
|
|
169
|
+
def action(self) -> pulumi.Input[builtins.str]:
|
|
169
170
|
"""
|
|
170
171
|
Choose an action to perform on failure. Default is `abort`. Enum: "abort" "pause" "promote".
|
|
171
172
|
"""
|
|
172
173
|
return pulumi.get(self, "action")
|
|
173
174
|
|
|
174
175
|
@action.setter
|
|
175
|
-
def action(self, value: pulumi.Input[str]):
|
|
176
|
+
def action(self, value: pulumi.Input[builtins.str]):
|
|
176
177
|
pulumi.set(self, "action", value)
|
|
177
178
|
|
|
178
179
|
|
|
179
180
|
if not MYPY:
|
|
180
181
|
class RolloutSpecSpotDeploymentArgsDict(TypedDict):
|
|
181
|
-
spot_deployments_cluster_id: NotRequired[pulumi.Input[str]]
|
|
182
|
+
spot_deployments_cluster_id: NotRequired[pulumi.Input[builtins.str]]
|
|
182
183
|
"""
|
|
183
184
|
Ocean CD cluster identifier for the references `SpotDeployment`.
|
|
184
185
|
"""
|
|
185
|
-
spot_deployments_name: NotRequired[pulumi.Input[str]]
|
|
186
|
+
spot_deployments_name: NotRequired[pulumi.Input[builtins.str]]
|
|
186
187
|
"""
|
|
187
188
|
The name of the `SpotDeployment` resource
|
|
188
189
|
"""
|
|
189
|
-
spot_deployments_namespace: NotRequired[pulumi.Input[str]]
|
|
190
|
+
spot_deployments_namespace: NotRequired[pulumi.Input[builtins.str]]
|
|
190
191
|
"""
|
|
191
192
|
The namespace which the `SpotDeployment` resource exists within.
|
|
192
193
|
"""
|
|
@@ -196,13 +197,13 @@ elif False:
|
|
|
196
197
|
@pulumi.input_type
|
|
197
198
|
class RolloutSpecSpotDeploymentArgs:
|
|
198
199
|
def __init__(__self__, *,
|
|
199
|
-
spot_deployments_cluster_id: Optional[pulumi.Input[str]] = None,
|
|
200
|
-
spot_deployments_name: Optional[pulumi.Input[str]] = None,
|
|
201
|
-
spot_deployments_namespace: Optional[pulumi.Input[str]] = None):
|
|
200
|
+
spot_deployments_cluster_id: Optional[pulumi.Input[builtins.str]] = None,
|
|
201
|
+
spot_deployments_name: Optional[pulumi.Input[builtins.str]] = None,
|
|
202
|
+
spot_deployments_namespace: Optional[pulumi.Input[builtins.str]] = None):
|
|
202
203
|
"""
|
|
203
|
-
:param pulumi.Input[str] spot_deployments_cluster_id: Ocean CD cluster identifier for the references `SpotDeployment`.
|
|
204
|
-
:param pulumi.Input[str] spot_deployments_name: The name of the `SpotDeployment` resource
|
|
205
|
-
:param pulumi.Input[str] spot_deployments_namespace: The namespace which the `SpotDeployment` resource exists within.
|
|
204
|
+
:param pulumi.Input[builtins.str] spot_deployments_cluster_id: Ocean CD cluster identifier for the references `SpotDeployment`.
|
|
205
|
+
:param pulumi.Input[builtins.str] spot_deployments_name: The name of the `SpotDeployment` resource
|
|
206
|
+
:param pulumi.Input[builtins.str] spot_deployments_namespace: The namespace which the `SpotDeployment` resource exists within.
|
|
206
207
|
"""
|
|
207
208
|
if spot_deployments_cluster_id is not None:
|
|
208
209
|
pulumi.set(__self__, "spot_deployments_cluster_id", spot_deployments_cluster_id)
|
|
@@ -213,44 +214,44 @@ class RolloutSpecSpotDeploymentArgs:
|
|
|
213
214
|
|
|
214
215
|
@property
|
|
215
216
|
@pulumi.getter(name="spotDeploymentsClusterId")
|
|
216
|
-
def spot_deployments_cluster_id(self) -> Optional[pulumi.Input[str]]:
|
|
217
|
+
def spot_deployments_cluster_id(self) -> Optional[pulumi.Input[builtins.str]]:
|
|
217
218
|
"""
|
|
218
219
|
Ocean CD cluster identifier for the references `SpotDeployment`.
|
|
219
220
|
"""
|
|
220
221
|
return pulumi.get(self, "spot_deployments_cluster_id")
|
|
221
222
|
|
|
222
223
|
@spot_deployments_cluster_id.setter
|
|
223
|
-
def spot_deployments_cluster_id(self, value: Optional[pulumi.Input[str]]):
|
|
224
|
+
def spot_deployments_cluster_id(self, value: Optional[pulumi.Input[builtins.str]]):
|
|
224
225
|
pulumi.set(self, "spot_deployments_cluster_id", value)
|
|
225
226
|
|
|
226
227
|
@property
|
|
227
228
|
@pulumi.getter(name="spotDeploymentsName")
|
|
228
|
-
def spot_deployments_name(self) -> Optional[pulumi.Input[str]]:
|
|
229
|
+
def spot_deployments_name(self) -> Optional[pulumi.Input[builtins.str]]:
|
|
229
230
|
"""
|
|
230
231
|
The name of the `SpotDeployment` resource
|
|
231
232
|
"""
|
|
232
233
|
return pulumi.get(self, "spot_deployments_name")
|
|
233
234
|
|
|
234
235
|
@spot_deployments_name.setter
|
|
235
|
-
def spot_deployments_name(self, value: Optional[pulumi.Input[str]]):
|
|
236
|
+
def spot_deployments_name(self, value: Optional[pulumi.Input[builtins.str]]):
|
|
236
237
|
pulumi.set(self, "spot_deployments_name", value)
|
|
237
238
|
|
|
238
239
|
@property
|
|
239
240
|
@pulumi.getter(name="spotDeploymentsNamespace")
|
|
240
|
-
def spot_deployments_namespace(self) -> Optional[pulumi.Input[str]]:
|
|
241
|
+
def spot_deployments_namespace(self) -> Optional[pulumi.Input[builtins.str]]:
|
|
241
242
|
"""
|
|
242
243
|
The namespace which the `SpotDeployment` resource exists within.
|
|
243
244
|
"""
|
|
244
245
|
return pulumi.get(self, "spot_deployments_namespace")
|
|
245
246
|
|
|
246
247
|
@spot_deployments_namespace.setter
|
|
247
|
-
def spot_deployments_namespace(self, value: Optional[pulumi.Input[str]]):
|
|
248
|
+
def spot_deployments_namespace(self, value: Optional[pulumi.Input[builtins.str]]):
|
|
248
249
|
pulumi.set(self, "spot_deployments_namespace", value)
|
|
249
250
|
|
|
250
251
|
|
|
251
252
|
if not MYPY:
|
|
252
253
|
class RolloutSpecStrategyArgsDict(TypedDict):
|
|
253
|
-
strategy_name: pulumi.Input[str]
|
|
254
|
+
strategy_name: pulumi.Input[builtins.str]
|
|
254
255
|
"""
|
|
255
256
|
Ocean CD strategy name identifier.
|
|
256
257
|
"""
|
|
@@ -264,10 +265,10 @@ elif False:
|
|
|
264
265
|
@pulumi.input_type
|
|
265
266
|
class RolloutSpecStrategyArgs:
|
|
266
267
|
def __init__(__self__, *,
|
|
267
|
-
strategy_name: pulumi.Input[str],
|
|
268
|
+
strategy_name: pulumi.Input[builtins.str],
|
|
268
269
|
args: Optional[pulumi.Input[Sequence[pulumi.Input['RolloutSpecStrategyArgArgs']]]] = None):
|
|
269
270
|
"""
|
|
270
|
-
:param pulumi.Input[str] strategy_name: Ocean CD strategy name identifier.
|
|
271
|
+
:param pulumi.Input[builtins.str] strategy_name: Ocean CD strategy name identifier.
|
|
271
272
|
:param pulumi.Input[Sequence[pulumi.Input['RolloutSpecStrategyArgArgs']]] args: Arguments defined in Verification Templates.
|
|
272
273
|
"""
|
|
273
274
|
pulumi.set(__self__, "strategy_name", strategy_name)
|
|
@@ -276,14 +277,14 @@ class RolloutSpecStrategyArgs:
|
|
|
276
277
|
|
|
277
278
|
@property
|
|
278
279
|
@pulumi.getter(name="strategyName")
|
|
279
|
-
def strategy_name(self) -> pulumi.Input[str]:
|
|
280
|
+
def strategy_name(self) -> pulumi.Input[builtins.str]:
|
|
280
281
|
"""
|
|
281
282
|
Ocean CD strategy name identifier.
|
|
282
283
|
"""
|
|
283
284
|
return pulumi.get(self, "strategy_name")
|
|
284
285
|
|
|
285
286
|
@strategy_name.setter
|
|
286
|
-
def strategy_name(self, value: pulumi.Input[str]):
|
|
287
|
+
def strategy_name(self, value: pulumi.Input[builtins.str]):
|
|
287
288
|
pulumi.set(self, "strategy_name", value)
|
|
288
289
|
|
|
289
290
|
@property
|
|
@@ -301,11 +302,11 @@ class RolloutSpecStrategyArgs:
|
|
|
301
302
|
|
|
302
303
|
if not MYPY:
|
|
303
304
|
class RolloutSpecStrategyArgArgsDict(TypedDict):
|
|
304
|
-
arg_name: pulumi.Input[str]
|
|
305
|
+
arg_name: pulumi.Input[builtins.str]
|
|
305
306
|
"""
|
|
306
307
|
Name of an argument.
|
|
307
308
|
"""
|
|
308
|
-
arg_value: NotRequired[pulumi.Input[str]]
|
|
309
|
+
arg_value: NotRequired[pulumi.Input[builtins.str]]
|
|
309
310
|
"""
|
|
310
311
|
Value of an argument.
|
|
311
312
|
"""
|
|
@@ -319,12 +320,12 @@ elif False:
|
|
|
319
320
|
@pulumi.input_type
|
|
320
321
|
class RolloutSpecStrategyArgArgs:
|
|
321
322
|
def __init__(__self__, *,
|
|
322
|
-
arg_name: pulumi.Input[str],
|
|
323
|
-
arg_value: Optional[pulumi.Input[str]] = None,
|
|
323
|
+
arg_name: pulumi.Input[builtins.str],
|
|
324
|
+
arg_value: Optional[pulumi.Input[builtins.str]] = None,
|
|
324
325
|
value_from: Optional[pulumi.Input['RolloutSpecStrategyArgValueFromArgs']] = None):
|
|
325
326
|
"""
|
|
326
|
-
:param pulumi.Input[str] arg_name: Name of an argument.
|
|
327
|
-
:param pulumi.Input[str] arg_value: Value of an argument.
|
|
327
|
+
:param pulumi.Input[builtins.str] arg_name: Name of an argument.
|
|
328
|
+
:param pulumi.Input[builtins.str] arg_value: Value of an argument.
|
|
328
329
|
:param pulumi.Input['RolloutSpecStrategyArgValueFromArgs'] value_from: Defines from where to get the value of an argument.
|
|
329
330
|
"""
|
|
330
331
|
pulumi.set(__self__, "arg_name", arg_name)
|
|
@@ -335,26 +336,26 @@ class RolloutSpecStrategyArgArgs:
|
|
|
335
336
|
|
|
336
337
|
@property
|
|
337
338
|
@pulumi.getter(name="argName")
|
|
338
|
-
def arg_name(self) -> pulumi.Input[str]:
|
|
339
|
+
def arg_name(self) -> pulumi.Input[builtins.str]:
|
|
339
340
|
"""
|
|
340
341
|
Name of an argument.
|
|
341
342
|
"""
|
|
342
343
|
return pulumi.get(self, "arg_name")
|
|
343
344
|
|
|
344
345
|
@arg_name.setter
|
|
345
|
-
def arg_name(self, value: pulumi.Input[str]):
|
|
346
|
+
def arg_name(self, value: pulumi.Input[builtins.str]):
|
|
346
347
|
pulumi.set(self, "arg_name", value)
|
|
347
348
|
|
|
348
349
|
@property
|
|
349
350
|
@pulumi.getter(name="argValue")
|
|
350
|
-
def arg_value(self) -> Optional[pulumi.Input[str]]:
|
|
351
|
+
def arg_value(self) -> Optional[pulumi.Input[builtins.str]]:
|
|
351
352
|
"""
|
|
352
353
|
Value of an argument.
|
|
353
354
|
"""
|
|
354
355
|
return pulumi.get(self, "arg_value")
|
|
355
356
|
|
|
356
357
|
@arg_value.setter
|
|
357
|
-
def arg_value(self, value: Optional[pulumi.Input[str]]):
|
|
358
|
+
def arg_value(self, value: Optional[pulumi.Input[builtins.str]]):
|
|
358
359
|
pulumi.set(self, "arg_value", value)
|
|
359
360
|
|
|
360
361
|
@property
|
|
@@ -403,7 +404,7 @@ class RolloutSpecStrategyArgValueFromArgs:
|
|
|
403
404
|
|
|
404
405
|
if not MYPY:
|
|
405
406
|
class RolloutSpecStrategyArgValueFromFieldRefArgsDict(TypedDict):
|
|
406
|
-
field_path: pulumi.Input[str]
|
|
407
|
+
field_path: pulumi.Input[builtins.str]
|
|
407
408
|
"""
|
|
408
409
|
Path to SpotDeployment's field from where to get the value of an argument.
|
|
409
410
|
"""
|
|
@@ -413,22 +414,22 @@ elif False:
|
|
|
413
414
|
@pulumi.input_type
|
|
414
415
|
class RolloutSpecStrategyArgValueFromFieldRefArgs:
|
|
415
416
|
def __init__(__self__, *,
|
|
416
|
-
field_path: pulumi.Input[str]):
|
|
417
|
+
field_path: pulumi.Input[builtins.str]):
|
|
417
418
|
"""
|
|
418
|
-
:param pulumi.Input[str] field_path: Path to SpotDeployment's field from where to get the value of an argument.
|
|
419
|
+
:param pulumi.Input[builtins.str] field_path: Path to SpotDeployment's field from where to get the value of an argument.
|
|
419
420
|
"""
|
|
420
421
|
pulumi.set(__self__, "field_path", field_path)
|
|
421
422
|
|
|
422
423
|
@property
|
|
423
424
|
@pulumi.getter(name="fieldPath")
|
|
424
|
-
def field_path(self) -> pulumi.Input[str]:
|
|
425
|
+
def field_path(self) -> pulumi.Input[builtins.str]:
|
|
425
426
|
"""
|
|
426
427
|
Path to SpotDeployment's field from where to get the value of an argument.
|
|
427
428
|
"""
|
|
428
429
|
return pulumi.get(self, "field_path")
|
|
429
430
|
|
|
430
431
|
@field_path.setter
|
|
431
|
-
def field_path(self, value: pulumi.Input[str]):
|
|
432
|
+
def field_path(self, value: pulumi.Input[builtins.str]):
|
|
432
433
|
pulumi.set(self, "field_path", value)
|
|
433
434
|
|
|
434
435
|
|
|
@@ -442,7 +443,7 @@ if not MYPY:
|
|
|
442
443
|
"""
|
|
443
444
|
Holds specific configuration to use Ambassador to route traffic.
|
|
444
445
|
"""
|
|
445
|
-
canary_service: NotRequired[pulumi.Input[str]]
|
|
446
|
+
canary_service: NotRequired[pulumi.Input[builtins.str]]
|
|
446
447
|
"""
|
|
447
448
|
The canary service name.
|
|
448
449
|
"""
|
|
@@ -462,7 +463,7 @@ if not MYPY:
|
|
|
462
463
|
"""
|
|
463
464
|
Holds TrafficSplit specific configuration to route traffic.
|
|
464
465
|
"""
|
|
465
|
-
stable_service: NotRequired[pulumi.Input[str]]
|
|
466
|
+
stable_service: NotRequired[pulumi.Input[builtins.str]]
|
|
466
467
|
"""
|
|
467
468
|
The stable service name.
|
|
468
469
|
"""
|
|
@@ -474,21 +475,21 @@ class RolloutSpecTrafficArgs:
|
|
|
474
475
|
def __init__(__self__, *,
|
|
475
476
|
alb: Optional[pulumi.Input['RolloutSpecTrafficAlbArgs']] = None,
|
|
476
477
|
ambassador: Optional[pulumi.Input['RolloutSpecTrafficAmbassadorArgs']] = None,
|
|
477
|
-
canary_service: Optional[pulumi.Input[str]] = None,
|
|
478
|
+
canary_service: Optional[pulumi.Input[builtins.str]] = None,
|
|
478
479
|
istio: Optional[pulumi.Input['RolloutSpecTrafficIstioArgs']] = None,
|
|
479
480
|
nginx: Optional[pulumi.Input['RolloutSpecTrafficNginxArgs']] = None,
|
|
480
481
|
ping_pong: Optional[pulumi.Input['RolloutSpecTrafficPingPongArgs']] = None,
|
|
481
482
|
smi: Optional[pulumi.Input['RolloutSpecTrafficSmiArgs']] = None,
|
|
482
|
-
stable_service: Optional[pulumi.Input[str]] = None):
|
|
483
|
+
stable_service: Optional[pulumi.Input[builtins.str]] = None):
|
|
483
484
|
"""
|
|
484
485
|
:param pulumi.Input['RolloutSpecTrafficAlbArgs'] alb: Holds ALB Ingress specific configuration to route traffic.
|
|
485
486
|
:param pulumi.Input['RolloutSpecTrafficAmbassadorArgs'] ambassador: Holds specific configuration to use Ambassador to route traffic.
|
|
486
|
-
:param pulumi.Input[str] canary_service: The canary service name.
|
|
487
|
+
:param pulumi.Input[builtins.str] canary_service: The canary service name.
|
|
487
488
|
:param pulumi.Input['RolloutSpecTrafficIstioArgs'] istio: Holds Istio specific configuration to route traffic.
|
|
488
489
|
:param pulumi.Input['RolloutSpecTrafficNginxArgs'] nginx: Holds Nginx Ingress specific configuration to route traffic.
|
|
489
490
|
:param pulumi.Input['RolloutSpecTrafficPingPongArgs'] ping_pong: Holds the ping and pong services. You can use `pingPong` field only when using ALB as a traffic manager with the IP Mode approach.
|
|
490
491
|
:param pulumi.Input['RolloutSpecTrafficSmiArgs'] smi: Holds TrafficSplit specific configuration to route traffic.
|
|
491
|
-
:param pulumi.Input[str] stable_service: The stable service name.
|
|
492
|
+
:param pulumi.Input[builtins.str] stable_service: The stable service name.
|
|
492
493
|
"""
|
|
493
494
|
if alb is not None:
|
|
494
495
|
pulumi.set(__self__, "alb", alb)
|
|
@@ -533,14 +534,14 @@ class RolloutSpecTrafficArgs:
|
|
|
533
534
|
|
|
534
535
|
@property
|
|
535
536
|
@pulumi.getter(name="canaryService")
|
|
536
|
-
def canary_service(self) -> Optional[pulumi.Input[str]]:
|
|
537
|
+
def canary_service(self) -> Optional[pulumi.Input[builtins.str]]:
|
|
537
538
|
"""
|
|
538
539
|
The canary service name.
|
|
539
540
|
"""
|
|
540
541
|
return pulumi.get(self, "canary_service")
|
|
541
542
|
|
|
542
543
|
@canary_service.setter
|
|
543
|
-
def canary_service(self, value: Optional[pulumi.Input[str]]):
|
|
544
|
+
def canary_service(self, value: Optional[pulumi.Input[builtins.str]]):
|
|
544
545
|
pulumi.set(self, "canary_service", value)
|
|
545
546
|
|
|
546
547
|
@property
|
|
@@ -593,32 +594,32 @@ class RolloutSpecTrafficArgs:
|
|
|
593
594
|
|
|
594
595
|
@property
|
|
595
596
|
@pulumi.getter(name="stableService")
|
|
596
|
-
def stable_service(self) -> Optional[pulumi.Input[str]]:
|
|
597
|
+
def stable_service(self) -> Optional[pulumi.Input[builtins.str]]:
|
|
597
598
|
"""
|
|
598
599
|
The stable service name.
|
|
599
600
|
"""
|
|
600
601
|
return pulumi.get(self, "stable_service")
|
|
601
602
|
|
|
602
603
|
@stable_service.setter
|
|
603
|
-
def stable_service(self, value: Optional[pulumi.Input[str]]):
|
|
604
|
+
def stable_service(self, value: Optional[pulumi.Input[builtins.str]]):
|
|
604
605
|
pulumi.set(self, "stable_service", value)
|
|
605
606
|
|
|
606
607
|
|
|
607
608
|
if not MYPY:
|
|
608
609
|
class RolloutSpecTrafficAlbArgsDict(TypedDict):
|
|
609
|
-
alb_ingress: pulumi.Input[str]
|
|
610
|
+
alb_ingress: pulumi.Input[builtins.str]
|
|
610
611
|
"""
|
|
611
612
|
Refers to the name of an `Ingress` resource in the same namespace as the `SpotDeployment`.
|
|
612
613
|
"""
|
|
613
|
-
alb_root_service: pulumi.Input[str]
|
|
614
|
+
alb_root_service: pulumi.Input[builtins.str]
|
|
614
615
|
"""
|
|
615
616
|
References the service in the ingress to the controller should add the action to.
|
|
616
617
|
"""
|
|
617
|
-
service_port: pulumi.Input[int]
|
|
618
|
+
service_port: pulumi.Input[builtins.int]
|
|
618
619
|
"""
|
|
619
620
|
Refers to the port that the Ingress action should route traffic to.
|
|
620
621
|
"""
|
|
621
|
-
alb_annotation_prefix: NotRequired[pulumi.Input[str]]
|
|
622
|
+
alb_annotation_prefix: NotRequired[pulumi.Input[builtins.str]]
|
|
622
623
|
"""
|
|
623
624
|
Has to match the configured annotation prefix on the alb ingress controller.
|
|
624
625
|
"""
|
|
@@ -632,16 +633,16 @@ elif False:
|
|
|
632
633
|
@pulumi.input_type
|
|
633
634
|
class RolloutSpecTrafficAlbArgs:
|
|
634
635
|
def __init__(__self__, *,
|
|
635
|
-
alb_ingress: pulumi.Input[str],
|
|
636
|
-
alb_root_service: pulumi.Input[str],
|
|
637
|
-
service_port: pulumi.Input[int],
|
|
638
|
-
alb_annotation_prefix: Optional[pulumi.Input[str]] = None,
|
|
636
|
+
alb_ingress: pulumi.Input[builtins.str],
|
|
637
|
+
alb_root_service: pulumi.Input[builtins.str],
|
|
638
|
+
service_port: pulumi.Input[builtins.int],
|
|
639
|
+
alb_annotation_prefix: Optional[pulumi.Input[builtins.str]] = None,
|
|
639
640
|
stickiness_config: Optional[pulumi.Input['RolloutSpecTrafficAlbStickinessConfigArgs']] = None):
|
|
640
641
|
"""
|
|
641
|
-
:param pulumi.Input[str] alb_ingress: Refers to the name of an `Ingress` resource in the same namespace as the `SpotDeployment`.
|
|
642
|
-
:param pulumi.Input[str] alb_root_service: References the service in the ingress to the controller should add the action to.
|
|
643
|
-
:param pulumi.Input[int] service_port: Refers to the port that the Ingress action should route traffic to.
|
|
644
|
-
:param pulumi.Input[str] alb_annotation_prefix: Has to match the configured annotation prefix on the alb ingress controller.
|
|
642
|
+
:param pulumi.Input[builtins.str] alb_ingress: Refers to the name of an `Ingress` resource in the same namespace as the `SpotDeployment`.
|
|
643
|
+
:param pulumi.Input[builtins.str] alb_root_service: References the service in the ingress to the controller should add the action to.
|
|
644
|
+
:param pulumi.Input[builtins.int] service_port: Refers to the port that the Ingress action should route traffic to.
|
|
645
|
+
:param pulumi.Input[builtins.str] alb_annotation_prefix: Has to match the configured annotation prefix on the alb ingress controller.
|
|
645
646
|
:param pulumi.Input['RolloutSpecTrafficAlbStickinessConfigArgs'] stickiness_config: Allows to specify further settings on the ForwardConfig.
|
|
646
647
|
"""
|
|
647
648
|
pulumi.set(__self__, "alb_ingress", alb_ingress)
|
|
@@ -654,50 +655,50 @@ class RolloutSpecTrafficAlbArgs:
|
|
|
654
655
|
|
|
655
656
|
@property
|
|
656
657
|
@pulumi.getter(name="albIngress")
|
|
657
|
-
def alb_ingress(self) -> pulumi.Input[str]:
|
|
658
|
+
def alb_ingress(self) -> pulumi.Input[builtins.str]:
|
|
658
659
|
"""
|
|
659
660
|
Refers to the name of an `Ingress` resource in the same namespace as the `SpotDeployment`.
|
|
660
661
|
"""
|
|
661
662
|
return pulumi.get(self, "alb_ingress")
|
|
662
663
|
|
|
663
664
|
@alb_ingress.setter
|
|
664
|
-
def alb_ingress(self, value: pulumi.Input[str]):
|
|
665
|
+
def alb_ingress(self, value: pulumi.Input[builtins.str]):
|
|
665
666
|
pulumi.set(self, "alb_ingress", value)
|
|
666
667
|
|
|
667
668
|
@property
|
|
668
669
|
@pulumi.getter(name="albRootService")
|
|
669
|
-
def alb_root_service(self) -> pulumi.Input[str]:
|
|
670
|
+
def alb_root_service(self) -> pulumi.Input[builtins.str]:
|
|
670
671
|
"""
|
|
671
672
|
References the service in the ingress to the controller should add the action to.
|
|
672
673
|
"""
|
|
673
674
|
return pulumi.get(self, "alb_root_service")
|
|
674
675
|
|
|
675
676
|
@alb_root_service.setter
|
|
676
|
-
def alb_root_service(self, value: pulumi.Input[str]):
|
|
677
|
+
def alb_root_service(self, value: pulumi.Input[builtins.str]):
|
|
677
678
|
pulumi.set(self, "alb_root_service", value)
|
|
678
679
|
|
|
679
680
|
@property
|
|
680
681
|
@pulumi.getter(name="servicePort")
|
|
681
|
-
def service_port(self) -> pulumi.Input[int]:
|
|
682
|
+
def service_port(self) -> pulumi.Input[builtins.int]:
|
|
682
683
|
"""
|
|
683
684
|
Refers to the port that the Ingress action should route traffic to.
|
|
684
685
|
"""
|
|
685
686
|
return pulumi.get(self, "service_port")
|
|
686
687
|
|
|
687
688
|
@service_port.setter
|
|
688
|
-
def service_port(self, value: pulumi.Input[int]):
|
|
689
|
+
def service_port(self, value: pulumi.Input[builtins.int]):
|
|
689
690
|
pulumi.set(self, "service_port", value)
|
|
690
691
|
|
|
691
692
|
@property
|
|
692
693
|
@pulumi.getter(name="albAnnotationPrefix")
|
|
693
|
-
def alb_annotation_prefix(self) -> Optional[pulumi.Input[str]]:
|
|
694
|
+
def alb_annotation_prefix(self) -> Optional[pulumi.Input[builtins.str]]:
|
|
694
695
|
"""
|
|
695
696
|
Has to match the configured annotation prefix on the alb ingress controller.
|
|
696
697
|
"""
|
|
697
698
|
return pulumi.get(self, "alb_annotation_prefix")
|
|
698
699
|
|
|
699
700
|
@alb_annotation_prefix.setter
|
|
700
|
-
def alb_annotation_prefix(self, value: Optional[pulumi.Input[str]]):
|
|
701
|
+
def alb_annotation_prefix(self, value: Optional[pulumi.Input[builtins.str]]):
|
|
701
702
|
pulumi.set(self, "alb_annotation_prefix", value)
|
|
702
703
|
|
|
703
704
|
@property
|
|
@@ -715,11 +716,11 @@ class RolloutSpecTrafficAlbArgs:
|
|
|
715
716
|
|
|
716
717
|
if not MYPY:
|
|
717
718
|
class RolloutSpecTrafficAlbStickinessConfigArgsDict(TypedDict):
|
|
718
|
-
duration_seconds: NotRequired[pulumi.Input[int]]
|
|
719
|
+
duration_seconds: NotRequired[pulumi.Input[builtins.int]]
|
|
719
720
|
"""
|
|
720
721
|
Defines how long the load balancer should consistently route the user's request to the same target.
|
|
721
722
|
"""
|
|
722
|
-
enabled: NotRequired[pulumi.Input[bool]]
|
|
723
|
+
enabled: NotRequired[pulumi.Input[builtins.bool]]
|
|
723
724
|
"""
|
|
724
725
|
Enables the load balancer to bind a user's session to a specific target.
|
|
725
726
|
"""
|
|
@@ -729,11 +730,11 @@ elif False:
|
|
|
729
730
|
@pulumi.input_type
|
|
730
731
|
class RolloutSpecTrafficAlbStickinessConfigArgs:
|
|
731
732
|
def __init__(__self__, *,
|
|
732
|
-
duration_seconds: Optional[pulumi.Input[int]] = None,
|
|
733
|
-
enabled: Optional[pulumi.Input[bool]] = None):
|
|
733
|
+
duration_seconds: Optional[pulumi.Input[builtins.int]] = None,
|
|
734
|
+
enabled: Optional[pulumi.Input[builtins.bool]] = None):
|
|
734
735
|
"""
|
|
735
|
-
:param pulumi.Input[int] duration_seconds: Defines how long the load balancer should consistently route the user's request to the same target.
|
|
736
|
-
:param pulumi.Input[bool] enabled: Enables the load balancer to bind a user's session to a specific target.
|
|
736
|
+
:param pulumi.Input[builtins.int] duration_seconds: Defines how long the load balancer should consistently route the user's request to the same target.
|
|
737
|
+
:param pulumi.Input[builtins.bool] enabled: Enables the load balancer to bind a user's session to a specific target.
|
|
737
738
|
"""
|
|
738
739
|
if duration_seconds is not None:
|
|
739
740
|
pulumi.set(__self__, "duration_seconds", duration_seconds)
|
|
@@ -742,32 +743,32 @@ class RolloutSpecTrafficAlbStickinessConfigArgs:
|
|
|
742
743
|
|
|
743
744
|
@property
|
|
744
745
|
@pulumi.getter(name="durationSeconds")
|
|
745
|
-
def duration_seconds(self) -> Optional[pulumi.Input[int]]:
|
|
746
|
+
def duration_seconds(self) -> Optional[pulumi.Input[builtins.int]]:
|
|
746
747
|
"""
|
|
747
748
|
Defines how long the load balancer should consistently route the user's request to the same target.
|
|
748
749
|
"""
|
|
749
750
|
return pulumi.get(self, "duration_seconds")
|
|
750
751
|
|
|
751
752
|
@duration_seconds.setter
|
|
752
|
-
def duration_seconds(self, value: Optional[pulumi.Input[int]]):
|
|
753
|
+
def duration_seconds(self, value: Optional[pulumi.Input[builtins.int]]):
|
|
753
754
|
pulumi.set(self, "duration_seconds", value)
|
|
754
755
|
|
|
755
756
|
@property
|
|
756
757
|
@pulumi.getter
|
|
757
|
-
def enabled(self) -> Optional[pulumi.Input[bool]]:
|
|
758
|
+
def enabled(self) -> Optional[pulumi.Input[builtins.bool]]:
|
|
758
759
|
"""
|
|
759
760
|
Enables the load balancer to bind a user's session to a specific target.
|
|
760
761
|
"""
|
|
761
762
|
return pulumi.get(self, "enabled")
|
|
762
763
|
|
|
763
764
|
@enabled.setter
|
|
764
|
-
def enabled(self, value: Optional[pulumi.Input[bool]]):
|
|
765
|
+
def enabled(self, value: Optional[pulumi.Input[builtins.bool]]):
|
|
765
766
|
pulumi.set(self, "enabled", value)
|
|
766
767
|
|
|
767
768
|
|
|
768
769
|
if not MYPY:
|
|
769
770
|
class RolloutSpecTrafficAmbassadorArgsDict(TypedDict):
|
|
770
|
-
mappings: pulumi.Input[Sequence[pulumi.Input[str]]]
|
|
771
|
+
mappings: pulumi.Input[Sequence[pulumi.Input[builtins.str]]]
|
|
771
772
|
"""
|
|
772
773
|
A list of names of the Ambassador Mappings used to route traffic to the service.
|
|
773
774
|
"""
|
|
@@ -777,22 +778,22 @@ elif False:
|
|
|
777
778
|
@pulumi.input_type
|
|
778
779
|
class RolloutSpecTrafficAmbassadorArgs:
|
|
779
780
|
def __init__(__self__, *,
|
|
780
|
-
mappings: pulumi.Input[Sequence[pulumi.Input[str]]]):
|
|
781
|
+
mappings: pulumi.Input[Sequence[pulumi.Input[builtins.str]]]):
|
|
781
782
|
"""
|
|
782
|
-
:param pulumi.Input[Sequence[pulumi.Input[str]]] mappings: A list of names of the Ambassador Mappings used to route traffic to the service.
|
|
783
|
+
:param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] mappings: A list of names of the Ambassador Mappings used to route traffic to the service.
|
|
783
784
|
"""
|
|
784
785
|
pulumi.set(__self__, "mappings", mappings)
|
|
785
786
|
|
|
786
787
|
@property
|
|
787
788
|
@pulumi.getter
|
|
788
|
-
def mappings(self) -> pulumi.Input[Sequence[pulumi.Input[str]]]:
|
|
789
|
+
def mappings(self) -> pulumi.Input[Sequence[pulumi.Input[builtins.str]]]:
|
|
789
790
|
"""
|
|
790
791
|
A list of names of the Ambassador Mappings used to route traffic to the service.
|
|
791
792
|
"""
|
|
792
793
|
return pulumi.get(self, "mappings")
|
|
793
794
|
|
|
794
795
|
@mappings.setter
|
|
795
|
-
def mappings(self, value: pulumi.Input[Sequence[pulumi.Input[str]]]):
|
|
796
|
+
def mappings(self, value: pulumi.Input[Sequence[pulumi.Input[builtins.str]]]):
|
|
796
797
|
pulumi.set(self, "mappings", value)
|
|
797
798
|
|
|
798
799
|
|
|
@@ -849,15 +850,15 @@ class RolloutSpecTrafficIstioArgs:
|
|
|
849
850
|
|
|
850
851
|
if not MYPY:
|
|
851
852
|
class RolloutSpecTrafficIstioDestinationRuleArgsDict(TypedDict):
|
|
852
|
-
canary_subset_name: pulumi.Input[str]
|
|
853
|
+
canary_subset_name: pulumi.Input[builtins.str]
|
|
853
854
|
"""
|
|
854
855
|
The subset name to modify labels with the canary version.
|
|
855
856
|
"""
|
|
856
|
-
destination_rule_name: pulumi.Input[str]
|
|
857
|
+
destination_rule_name: pulumi.Input[builtins.str]
|
|
857
858
|
"""
|
|
858
859
|
Holds the name of the DestinationRule.
|
|
859
860
|
"""
|
|
860
|
-
stable_subset_name: pulumi.Input[str]
|
|
861
|
+
stable_subset_name: pulumi.Input[builtins.str]
|
|
861
862
|
"""
|
|
862
863
|
The subset name to modify labels with the stable version.
|
|
863
864
|
"""
|
|
@@ -867,13 +868,13 @@ elif False:
|
|
|
867
868
|
@pulumi.input_type
|
|
868
869
|
class RolloutSpecTrafficIstioDestinationRuleArgs:
|
|
869
870
|
def __init__(__self__, *,
|
|
870
|
-
canary_subset_name: pulumi.Input[str],
|
|
871
|
-
destination_rule_name: pulumi.Input[str],
|
|
872
|
-
stable_subset_name: pulumi.Input[str]):
|
|
871
|
+
canary_subset_name: pulumi.Input[builtins.str],
|
|
872
|
+
destination_rule_name: pulumi.Input[builtins.str],
|
|
873
|
+
stable_subset_name: pulumi.Input[builtins.str]):
|
|
873
874
|
"""
|
|
874
|
-
:param pulumi.Input[str] canary_subset_name: The subset name to modify labels with the canary version.
|
|
875
|
-
:param pulumi.Input[str] destination_rule_name: Holds the name of the DestinationRule.
|
|
876
|
-
:param pulumi.Input[str] stable_subset_name: The subset name to modify labels with the stable version.
|
|
875
|
+
:param pulumi.Input[builtins.str] canary_subset_name: The subset name to modify labels with the canary version.
|
|
876
|
+
:param pulumi.Input[builtins.str] destination_rule_name: Holds the name of the DestinationRule.
|
|
877
|
+
:param pulumi.Input[builtins.str] stable_subset_name: The subset name to modify labels with the stable version.
|
|
877
878
|
"""
|
|
878
879
|
pulumi.set(__self__, "canary_subset_name", canary_subset_name)
|
|
879
880
|
pulumi.set(__self__, "destination_rule_name", destination_rule_name)
|
|
@@ -881,44 +882,44 @@ class RolloutSpecTrafficIstioDestinationRuleArgs:
|
|
|
881
882
|
|
|
882
883
|
@property
|
|
883
884
|
@pulumi.getter(name="canarySubsetName")
|
|
884
|
-
def canary_subset_name(self) -> pulumi.Input[str]:
|
|
885
|
+
def canary_subset_name(self) -> pulumi.Input[builtins.str]:
|
|
885
886
|
"""
|
|
886
887
|
The subset name to modify labels with the canary version.
|
|
887
888
|
"""
|
|
888
889
|
return pulumi.get(self, "canary_subset_name")
|
|
889
890
|
|
|
890
891
|
@canary_subset_name.setter
|
|
891
|
-
def canary_subset_name(self, value: pulumi.Input[str]):
|
|
892
|
+
def canary_subset_name(self, value: pulumi.Input[builtins.str]):
|
|
892
893
|
pulumi.set(self, "canary_subset_name", value)
|
|
893
894
|
|
|
894
895
|
@property
|
|
895
896
|
@pulumi.getter(name="destinationRuleName")
|
|
896
|
-
def destination_rule_name(self) -> pulumi.Input[str]:
|
|
897
|
+
def destination_rule_name(self) -> pulumi.Input[builtins.str]:
|
|
897
898
|
"""
|
|
898
899
|
Holds the name of the DestinationRule.
|
|
899
900
|
"""
|
|
900
901
|
return pulumi.get(self, "destination_rule_name")
|
|
901
902
|
|
|
902
903
|
@destination_rule_name.setter
|
|
903
|
-
def destination_rule_name(self, value: pulumi.Input[str]):
|
|
904
|
+
def destination_rule_name(self, value: pulumi.Input[builtins.str]):
|
|
904
905
|
pulumi.set(self, "destination_rule_name", value)
|
|
905
906
|
|
|
906
907
|
@property
|
|
907
908
|
@pulumi.getter(name="stableSubsetName")
|
|
908
|
-
def stable_subset_name(self) -> pulumi.Input[str]:
|
|
909
|
+
def stable_subset_name(self) -> pulumi.Input[builtins.str]:
|
|
909
910
|
"""
|
|
910
911
|
The subset name to modify labels with the stable version.
|
|
911
912
|
"""
|
|
912
913
|
return pulumi.get(self, "stable_subset_name")
|
|
913
914
|
|
|
914
915
|
@stable_subset_name.setter
|
|
915
|
-
def stable_subset_name(self, value: pulumi.Input[str]):
|
|
916
|
+
def stable_subset_name(self, value: pulumi.Input[builtins.str]):
|
|
916
917
|
pulumi.set(self, "stable_subset_name", value)
|
|
917
918
|
|
|
918
919
|
|
|
919
920
|
if not MYPY:
|
|
920
921
|
class RolloutSpecTrafficIstioVirtualServiceArgsDict(TypedDict):
|
|
921
|
-
virtual_service_name: pulumi.Input[str]
|
|
922
|
+
virtual_service_name: pulumi.Input[builtins.str]
|
|
922
923
|
"""
|
|
923
924
|
Holds the name of the VirtualService.
|
|
924
925
|
"""
|
|
@@ -926,7 +927,7 @@ if not MYPY:
|
|
|
926
927
|
"""
|
|
927
928
|
A list of HTTPS routes within VirtualService.
|
|
928
929
|
"""
|
|
929
|
-
virtual_service_routes: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
|
|
930
|
+
virtual_service_routes: NotRequired[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]
|
|
930
931
|
"""
|
|
931
932
|
A list of HTTP routes within VirtualService.
|
|
932
933
|
"""
|
|
@@ -936,13 +937,13 @@ elif False:
|
|
|
936
937
|
@pulumi.input_type
|
|
937
938
|
class RolloutSpecTrafficIstioVirtualServiceArgs:
|
|
938
939
|
def __init__(__self__, *,
|
|
939
|
-
virtual_service_name: pulumi.Input[str],
|
|
940
|
+
virtual_service_name: pulumi.Input[builtins.str],
|
|
940
941
|
tls_routes: Optional[pulumi.Input[Sequence[pulumi.Input['RolloutSpecTrafficIstioVirtualServiceTlsRouteArgs']]]] = None,
|
|
941
|
-
virtual_service_routes: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None):
|
|
942
|
+
virtual_service_routes: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None):
|
|
942
943
|
"""
|
|
943
|
-
:param pulumi.Input[str] virtual_service_name: Holds the name of the VirtualService.
|
|
944
|
+
:param pulumi.Input[builtins.str] virtual_service_name: Holds the name of the VirtualService.
|
|
944
945
|
:param pulumi.Input[Sequence[pulumi.Input['RolloutSpecTrafficIstioVirtualServiceTlsRouteArgs']]] tls_routes: A list of HTTPS routes within VirtualService.
|
|
945
|
-
:param pulumi.Input[Sequence[pulumi.Input[str]]] virtual_service_routes: A list of HTTP routes within VirtualService.
|
|
946
|
+
:param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] virtual_service_routes: A list of HTTP routes within VirtualService.
|
|
946
947
|
"""
|
|
947
948
|
pulumi.set(__self__, "virtual_service_name", virtual_service_name)
|
|
948
949
|
if tls_routes is not None:
|
|
@@ -952,14 +953,14 @@ class RolloutSpecTrafficIstioVirtualServiceArgs:
|
|
|
952
953
|
|
|
953
954
|
@property
|
|
954
955
|
@pulumi.getter(name="virtualServiceName")
|
|
955
|
-
def virtual_service_name(self) -> pulumi.Input[str]:
|
|
956
|
+
def virtual_service_name(self) -> pulumi.Input[builtins.str]:
|
|
956
957
|
"""
|
|
957
958
|
Holds the name of the VirtualService.
|
|
958
959
|
"""
|
|
959
960
|
return pulumi.get(self, "virtual_service_name")
|
|
960
961
|
|
|
961
962
|
@virtual_service_name.setter
|
|
962
|
-
def virtual_service_name(self, value: pulumi.Input[str]):
|
|
963
|
+
def virtual_service_name(self, value: pulumi.Input[builtins.str]):
|
|
963
964
|
pulumi.set(self, "virtual_service_name", value)
|
|
964
965
|
|
|
965
966
|
@property
|
|
@@ -976,24 +977,24 @@ class RolloutSpecTrafficIstioVirtualServiceArgs:
|
|
|
976
977
|
|
|
977
978
|
@property
|
|
978
979
|
@pulumi.getter(name="virtualServiceRoutes")
|
|
979
|
-
def virtual_service_routes(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
|
|
980
|
+
def virtual_service_routes(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]:
|
|
980
981
|
"""
|
|
981
982
|
A list of HTTP routes within VirtualService.
|
|
982
983
|
"""
|
|
983
984
|
return pulumi.get(self, "virtual_service_routes")
|
|
984
985
|
|
|
985
986
|
@virtual_service_routes.setter
|
|
986
|
-
def virtual_service_routes(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
|
|
987
|
+
def virtual_service_routes(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]):
|
|
987
988
|
pulumi.set(self, "virtual_service_routes", value)
|
|
988
989
|
|
|
989
990
|
|
|
990
991
|
if not MYPY:
|
|
991
992
|
class RolloutSpecTrafficIstioVirtualServiceTlsRouteArgsDict(TypedDict):
|
|
992
|
-
port: NotRequired[pulumi.Input[int]]
|
|
993
|
+
port: NotRequired[pulumi.Input[builtins.int]]
|
|
993
994
|
"""
|
|
994
995
|
The port of the TLS Route desired to be matched in the given Istio VirtualService.
|
|
995
996
|
"""
|
|
996
|
-
sni_hosts: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
|
|
997
|
+
sni_hosts: NotRequired[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]
|
|
997
998
|
"""
|
|
998
999
|
A list of all the SNI Hosts of the TLS Route desired to be matched in the given Istio VirtualService.
|
|
999
1000
|
"""
|
|
@@ -1003,11 +1004,11 @@ elif False:
|
|
|
1003
1004
|
@pulumi.input_type
|
|
1004
1005
|
class RolloutSpecTrafficIstioVirtualServiceTlsRouteArgs:
|
|
1005
1006
|
def __init__(__self__, *,
|
|
1006
|
-
port: Optional[pulumi.Input[int]] = None,
|
|
1007
|
-
sni_hosts: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None):
|
|
1007
|
+
port: Optional[pulumi.Input[builtins.int]] = None,
|
|
1008
|
+
sni_hosts: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None):
|
|
1008
1009
|
"""
|
|
1009
|
-
:param pulumi.Input[int] port: The port of the TLS Route desired to be matched in the given Istio VirtualService.
|
|
1010
|
-
:param pulumi.Input[Sequence[pulumi.Input[str]]] sni_hosts: A list of all the SNI Hosts of the TLS Route desired to be matched in the given Istio VirtualService.
|
|
1010
|
+
:param pulumi.Input[builtins.int] port: The port of the TLS Route desired to be matched in the given Istio VirtualService.
|
|
1011
|
+
:param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] sni_hosts: A list of all the SNI Hosts of the TLS Route desired to be matched in the given Istio VirtualService.
|
|
1011
1012
|
"""
|
|
1012
1013
|
if port is not None:
|
|
1013
1014
|
pulumi.set(__self__, "port", port)
|
|
@@ -1016,32 +1017,32 @@ class RolloutSpecTrafficIstioVirtualServiceTlsRouteArgs:
|
|
|
1016
1017
|
|
|
1017
1018
|
@property
|
|
1018
1019
|
@pulumi.getter
|
|
1019
|
-
def port(self) -> Optional[pulumi.Input[int]]:
|
|
1020
|
+
def port(self) -> Optional[pulumi.Input[builtins.int]]:
|
|
1020
1021
|
"""
|
|
1021
1022
|
The port of the TLS Route desired to be matched in the given Istio VirtualService.
|
|
1022
1023
|
"""
|
|
1023
1024
|
return pulumi.get(self, "port")
|
|
1024
1025
|
|
|
1025
1026
|
@port.setter
|
|
1026
|
-
def port(self, value: Optional[pulumi.Input[int]]):
|
|
1027
|
+
def port(self, value: Optional[pulumi.Input[builtins.int]]):
|
|
1027
1028
|
pulumi.set(self, "port", value)
|
|
1028
1029
|
|
|
1029
1030
|
@property
|
|
1030
1031
|
@pulumi.getter(name="sniHosts")
|
|
1031
|
-
def sni_hosts(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
|
|
1032
|
+
def sni_hosts(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]:
|
|
1032
1033
|
"""
|
|
1033
1034
|
A list of all the SNI Hosts of the TLS Route desired to be matched in the given Istio VirtualService.
|
|
1034
1035
|
"""
|
|
1035
1036
|
return pulumi.get(self, "sni_hosts")
|
|
1036
1037
|
|
|
1037
1038
|
@sni_hosts.setter
|
|
1038
|
-
def sni_hosts(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
|
|
1039
|
+
def sni_hosts(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]):
|
|
1039
1040
|
pulumi.set(self, "sni_hosts", value)
|
|
1040
1041
|
|
|
1041
1042
|
|
|
1042
1043
|
if not MYPY:
|
|
1043
1044
|
class RolloutSpecTrafficNginxArgsDict(TypedDict):
|
|
1044
|
-
stable_ingress: pulumi.Input[str]
|
|
1045
|
+
stable_ingress: pulumi.Input[builtins.str]
|
|
1045
1046
|
"""
|
|
1046
1047
|
Refers to the name of an `Ingress` resource in the same namespace as the `SpotDeployment`.
|
|
1047
1048
|
"""
|
|
@@ -1049,7 +1050,7 @@ if not MYPY:
|
|
|
1049
1050
|
"""
|
|
1050
1051
|
Provides additional features to add to the canary ingress (such as routing by header, cookie, etc). You can add these Kubernetes annotations to specific Ingress objects to customize their behavior. Above are found examples of accepted k8s keys.For the full list of supported keys, you may reach the following documentation - https://kubernetes.github.io/ingress-nginx/user-guide/nginx-configuration/annotations/#canary.
|
|
1051
1052
|
"""
|
|
1052
|
-
nginx_annotation_prefix: NotRequired[pulumi.Input[str]]
|
|
1053
|
+
nginx_annotation_prefix: NotRequired[pulumi.Input[builtins.str]]
|
|
1053
1054
|
"""
|
|
1054
1055
|
Has to match the configured annotation prefix on the Nginx ingress controller.
|
|
1055
1056
|
"""
|
|
@@ -1059,13 +1060,13 @@ elif False:
|
|
|
1059
1060
|
@pulumi.input_type
|
|
1060
1061
|
class RolloutSpecTrafficNginxArgs:
|
|
1061
1062
|
def __init__(__self__, *,
|
|
1062
|
-
stable_ingress: pulumi.Input[str],
|
|
1063
|
+
stable_ingress: pulumi.Input[builtins.str],
|
|
1063
1064
|
additional_ingress_annotation: Optional[pulumi.Input['RolloutSpecTrafficNginxAdditionalIngressAnnotationArgs']] = None,
|
|
1064
|
-
nginx_annotation_prefix: Optional[pulumi.Input[str]] = None):
|
|
1065
|
+
nginx_annotation_prefix: Optional[pulumi.Input[builtins.str]] = None):
|
|
1065
1066
|
"""
|
|
1066
|
-
:param pulumi.Input[str] stable_ingress: Refers to the name of an `Ingress` resource in the same namespace as the `SpotDeployment`.
|
|
1067
|
+
:param pulumi.Input[builtins.str] stable_ingress: Refers to the name of an `Ingress` resource in the same namespace as the `SpotDeployment`.
|
|
1067
1068
|
:param pulumi.Input['RolloutSpecTrafficNginxAdditionalIngressAnnotationArgs'] additional_ingress_annotation: Provides additional features to add to the canary ingress (such as routing by header, cookie, etc). You can add these Kubernetes annotations to specific Ingress objects to customize their behavior. Above are found examples of accepted k8s keys.For the full list of supported keys, you may reach the following documentation - https://kubernetes.github.io/ingress-nginx/user-guide/nginx-configuration/annotations/#canary.
|
|
1068
|
-
:param pulumi.Input[str] nginx_annotation_prefix: Has to match the configured annotation prefix on the Nginx ingress controller.
|
|
1069
|
+
:param pulumi.Input[builtins.str] nginx_annotation_prefix: Has to match the configured annotation prefix on the Nginx ingress controller.
|
|
1069
1070
|
"""
|
|
1070
1071
|
pulumi.set(__self__, "stable_ingress", stable_ingress)
|
|
1071
1072
|
if additional_ingress_annotation is not None:
|
|
@@ -1075,14 +1076,14 @@ class RolloutSpecTrafficNginxArgs:
|
|
|
1075
1076
|
|
|
1076
1077
|
@property
|
|
1077
1078
|
@pulumi.getter(name="stableIngress")
|
|
1078
|
-
def stable_ingress(self) -> pulumi.Input[str]:
|
|
1079
|
+
def stable_ingress(self) -> pulumi.Input[builtins.str]:
|
|
1079
1080
|
"""
|
|
1080
1081
|
Refers to the name of an `Ingress` resource in the same namespace as the `SpotDeployment`.
|
|
1081
1082
|
"""
|
|
1082
1083
|
return pulumi.get(self, "stable_ingress")
|
|
1083
1084
|
|
|
1084
1085
|
@stable_ingress.setter
|
|
1085
|
-
def stable_ingress(self, value: pulumi.Input[str]):
|
|
1086
|
+
def stable_ingress(self, value: pulumi.Input[builtins.str]):
|
|
1086
1087
|
pulumi.set(self, "stable_ingress", value)
|
|
1087
1088
|
|
|
1088
1089
|
@property
|
|
@@ -1099,24 +1100,24 @@ class RolloutSpecTrafficNginxArgs:
|
|
|
1099
1100
|
|
|
1100
1101
|
@property
|
|
1101
1102
|
@pulumi.getter(name="nginxAnnotationPrefix")
|
|
1102
|
-
def nginx_annotation_prefix(self) -> Optional[pulumi.Input[str]]:
|
|
1103
|
+
def nginx_annotation_prefix(self) -> Optional[pulumi.Input[builtins.str]]:
|
|
1103
1104
|
"""
|
|
1104
1105
|
Has to match the configured annotation prefix on the Nginx ingress controller.
|
|
1105
1106
|
"""
|
|
1106
1107
|
return pulumi.get(self, "nginx_annotation_prefix")
|
|
1107
1108
|
|
|
1108
1109
|
@nginx_annotation_prefix.setter
|
|
1109
|
-
def nginx_annotation_prefix(self, value: Optional[pulumi.Input[str]]):
|
|
1110
|
+
def nginx_annotation_prefix(self, value: Optional[pulumi.Input[builtins.str]]):
|
|
1110
1111
|
pulumi.set(self, "nginx_annotation_prefix", value)
|
|
1111
1112
|
|
|
1112
1113
|
|
|
1113
1114
|
if not MYPY:
|
|
1114
1115
|
class RolloutSpecTrafficNginxAdditionalIngressAnnotationArgsDict(TypedDict):
|
|
1115
|
-
canary_by_header: NotRequired[pulumi.Input[str]]
|
|
1116
|
+
canary_by_header: NotRequired[pulumi.Input[builtins.str]]
|
|
1116
1117
|
"""
|
|
1117
1118
|
Allows customizing the header value instead of using hardcoded values.
|
|
1118
1119
|
"""
|
|
1119
|
-
key1: NotRequired[pulumi.Input[str]]
|
|
1120
|
+
key1: NotRequired[pulumi.Input[builtins.str]]
|
|
1120
1121
|
"""
|
|
1121
1122
|
Any of supported annotations.
|
|
1122
1123
|
"""
|
|
@@ -1126,11 +1127,11 @@ elif False:
|
|
|
1126
1127
|
@pulumi.input_type
|
|
1127
1128
|
class RolloutSpecTrafficNginxAdditionalIngressAnnotationArgs:
|
|
1128
1129
|
def __init__(__self__, *,
|
|
1129
|
-
canary_by_header: Optional[pulumi.Input[str]] = None,
|
|
1130
|
-
key1: Optional[pulumi.Input[str]] = None):
|
|
1130
|
+
canary_by_header: Optional[pulumi.Input[builtins.str]] = None,
|
|
1131
|
+
key1: Optional[pulumi.Input[builtins.str]] = None):
|
|
1131
1132
|
"""
|
|
1132
|
-
:param pulumi.Input[str] canary_by_header: Allows customizing the header value instead of using hardcoded values.
|
|
1133
|
-
:param pulumi.Input[str] key1: Any of supported annotations.
|
|
1133
|
+
:param pulumi.Input[builtins.str] canary_by_header: Allows customizing the header value instead of using hardcoded values.
|
|
1134
|
+
:param pulumi.Input[builtins.str] key1: Any of supported annotations.
|
|
1134
1135
|
"""
|
|
1135
1136
|
if canary_by_header is not None:
|
|
1136
1137
|
pulumi.set(__self__, "canary_by_header", canary_by_header)
|
|
@@ -1139,36 +1140,36 @@ class RolloutSpecTrafficNginxAdditionalIngressAnnotationArgs:
|
|
|
1139
1140
|
|
|
1140
1141
|
@property
|
|
1141
1142
|
@pulumi.getter(name="canaryByHeader")
|
|
1142
|
-
def canary_by_header(self) -> Optional[pulumi.Input[str]]:
|
|
1143
|
+
def canary_by_header(self) -> Optional[pulumi.Input[builtins.str]]:
|
|
1143
1144
|
"""
|
|
1144
1145
|
Allows customizing the header value instead of using hardcoded values.
|
|
1145
1146
|
"""
|
|
1146
1147
|
return pulumi.get(self, "canary_by_header")
|
|
1147
1148
|
|
|
1148
1149
|
@canary_by_header.setter
|
|
1149
|
-
def canary_by_header(self, value: Optional[pulumi.Input[str]]):
|
|
1150
|
+
def canary_by_header(self, value: Optional[pulumi.Input[builtins.str]]):
|
|
1150
1151
|
pulumi.set(self, "canary_by_header", value)
|
|
1151
1152
|
|
|
1152
1153
|
@property
|
|
1153
1154
|
@pulumi.getter
|
|
1154
|
-
def key1(self) -> Optional[pulumi.Input[str]]:
|
|
1155
|
+
def key1(self) -> Optional[pulumi.Input[builtins.str]]:
|
|
1155
1156
|
"""
|
|
1156
1157
|
Any of supported annotations.
|
|
1157
1158
|
"""
|
|
1158
1159
|
return pulumi.get(self, "key1")
|
|
1159
1160
|
|
|
1160
1161
|
@key1.setter
|
|
1161
|
-
def key1(self, value: Optional[pulumi.Input[str]]):
|
|
1162
|
+
def key1(self, value: Optional[pulumi.Input[builtins.str]]):
|
|
1162
1163
|
pulumi.set(self, "key1", value)
|
|
1163
1164
|
|
|
1164
1165
|
|
|
1165
1166
|
if not MYPY:
|
|
1166
1167
|
class RolloutSpecTrafficPingPongArgsDict(TypedDict):
|
|
1167
|
-
ping_service: pulumi.Input[str]
|
|
1168
|
+
ping_service: pulumi.Input[builtins.str]
|
|
1168
1169
|
"""
|
|
1169
1170
|
Holds the name of the ping service.
|
|
1170
1171
|
"""
|
|
1171
|
-
pong_service: pulumi.Input[str]
|
|
1172
|
+
pong_service: pulumi.Input[builtins.str]
|
|
1172
1173
|
"""
|
|
1173
1174
|
Holds the name of the pong service.
|
|
1174
1175
|
"""
|
|
@@ -1178,47 +1179,47 @@ elif False:
|
|
|
1178
1179
|
@pulumi.input_type
|
|
1179
1180
|
class RolloutSpecTrafficPingPongArgs:
|
|
1180
1181
|
def __init__(__self__, *,
|
|
1181
|
-
ping_service: pulumi.Input[str],
|
|
1182
|
-
pong_service: pulumi.Input[str]):
|
|
1182
|
+
ping_service: pulumi.Input[builtins.str],
|
|
1183
|
+
pong_service: pulumi.Input[builtins.str]):
|
|
1183
1184
|
"""
|
|
1184
|
-
:param pulumi.Input[str] ping_service: Holds the name of the ping service.
|
|
1185
|
-
:param pulumi.Input[str] pong_service: Holds the name of the pong service.
|
|
1185
|
+
:param pulumi.Input[builtins.str] ping_service: Holds the name of the ping service.
|
|
1186
|
+
:param pulumi.Input[builtins.str] pong_service: Holds the name of the pong service.
|
|
1186
1187
|
"""
|
|
1187
1188
|
pulumi.set(__self__, "ping_service", ping_service)
|
|
1188
1189
|
pulumi.set(__self__, "pong_service", pong_service)
|
|
1189
1190
|
|
|
1190
1191
|
@property
|
|
1191
1192
|
@pulumi.getter(name="pingService")
|
|
1192
|
-
def ping_service(self) -> pulumi.Input[str]:
|
|
1193
|
+
def ping_service(self) -> pulumi.Input[builtins.str]:
|
|
1193
1194
|
"""
|
|
1194
1195
|
Holds the name of the ping service.
|
|
1195
1196
|
"""
|
|
1196
1197
|
return pulumi.get(self, "ping_service")
|
|
1197
1198
|
|
|
1198
1199
|
@ping_service.setter
|
|
1199
|
-
def ping_service(self, value: pulumi.Input[str]):
|
|
1200
|
+
def ping_service(self, value: pulumi.Input[builtins.str]):
|
|
1200
1201
|
pulumi.set(self, "ping_service", value)
|
|
1201
1202
|
|
|
1202
1203
|
@property
|
|
1203
1204
|
@pulumi.getter(name="pongService")
|
|
1204
|
-
def pong_service(self) -> pulumi.Input[str]:
|
|
1205
|
+
def pong_service(self) -> pulumi.Input[builtins.str]:
|
|
1205
1206
|
"""
|
|
1206
1207
|
Holds the name of the pong service.
|
|
1207
1208
|
"""
|
|
1208
1209
|
return pulumi.get(self, "pong_service")
|
|
1209
1210
|
|
|
1210
1211
|
@pong_service.setter
|
|
1211
|
-
def pong_service(self, value: pulumi.Input[str]):
|
|
1212
|
+
def pong_service(self, value: pulumi.Input[builtins.str]):
|
|
1212
1213
|
pulumi.set(self, "pong_service", value)
|
|
1213
1214
|
|
|
1214
1215
|
|
|
1215
1216
|
if not MYPY:
|
|
1216
1217
|
class RolloutSpecTrafficSmiArgsDict(TypedDict):
|
|
1217
|
-
smi_root_service: NotRequired[pulumi.Input[str]]
|
|
1218
|
+
smi_root_service: NotRequired[pulumi.Input[builtins.str]]
|
|
1218
1219
|
"""
|
|
1219
1220
|
Holds the name of service that clients use to communicate.
|
|
1220
1221
|
"""
|
|
1221
|
-
traffic_split_name: NotRequired[pulumi.Input[str]]
|
|
1222
|
+
traffic_split_name: NotRequired[pulumi.Input[builtins.str]]
|
|
1222
1223
|
"""
|
|
1223
1224
|
Holds the name of the TrafficSplit.
|
|
1224
1225
|
"""
|
|
@@ -1228,11 +1229,11 @@ elif False:
|
|
|
1228
1229
|
@pulumi.input_type
|
|
1229
1230
|
class RolloutSpecTrafficSmiArgs:
|
|
1230
1231
|
def __init__(__self__, *,
|
|
1231
|
-
smi_root_service: Optional[pulumi.Input[str]] = None,
|
|
1232
|
-
traffic_split_name: Optional[pulumi.Input[str]] = None):
|
|
1232
|
+
smi_root_service: Optional[pulumi.Input[builtins.str]] = None,
|
|
1233
|
+
traffic_split_name: Optional[pulumi.Input[builtins.str]] = None):
|
|
1233
1234
|
"""
|
|
1234
|
-
:param pulumi.Input[str] smi_root_service: Holds the name of service that clients use to communicate.
|
|
1235
|
-
:param pulumi.Input[str] traffic_split_name: Holds the name of the TrafficSplit.
|
|
1235
|
+
:param pulumi.Input[builtins.str] smi_root_service: Holds the name of service that clients use to communicate.
|
|
1236
|
+
:param pulumi.Input[builtins.str] traffic_split_name: Holds the name of the TrafficSplit.
|
|
1236
1237
|
"""
|
|
1237
1238
|
if smi_root_service is not None:
|
|
1238
1239
|
pulumi.set(__self__, "smi_root_service", smi_root_service)
|
|
@@ -1241,26 +1242,26 @@ class RolloutSpecTrafficSmiArgs:
|
|
|
1241
1242
|
|
|
1242
1243
|
@property
|
|
1243
1244
|
@pulumi.getter(name="smiRootService")
|
|
1244
|
-
def smi_root_service(self) -> Optional[pulumi.Input[str]]:
|
|
1245
|
+
def smi_root_service(self) -> Optional[pulumi.Input[builtins.str]]:
|
|
1245
1246
|
"""
|
|
1246
1247
|
Holds the name of service that clients use to communicate.
|
|
1247
1248
|
"""
|
|
1248
1249
|
return pulumi.get(self, "smi_root_service")
|
|
1249
1250
|
|
|
1250
1251
|
@smi_root_service.setter
|
|
1251
|
-
def smi_root_service(self, value: Optional[pulumi.Input[str]]):
|
|
1252
|
+
def smi_root_service(self, value: Optional[pulumi.Input[builtins.str]]):
|
|
1252
1253
|
pulumi.set(self, "smi_root_service", value)
|
|
1253
1254
|
|
|
1254
1255
|
@property
|
|
1255
1256
|
@pulumi.getter(name="trafficSplitName")
|
|
1256
|
-
def traffic_split_name(self) -> Optional[pulumi.Input[str]]:
|
|
1257
|
+
def traffic_split_name(self) -> Optional[pulumi.Input[builtins.str]]:
|
|
1257
1258
|
"""
|
|
1258
1259
|
Holds the name of the TrafficSplit.
|
|
1259
1260
|
"""
|
|
1260
1261
|
return pulumi.get(self, "traffic_split_name")
|
|
1261
1262
|
|
|
1262
1263
|
@traffic_split_name.setter
|
|
1263
|
-
def traffic_split_name(self, value: Optional[pulumi.Input[str]]):
|
|
1264
|
+
def traffic_split_name(self, value: Optional[pulumi.Input[builtins.str]]):
|
|
1264
1265
|
pulumi.set(self, "traffic_split_name", value)
|
|
1265
1266
|
|
|
1266
1267
|
|
|
@@ -1317,7 +1318,7 @@ class StrategyCanaryArgs:
|
|
|
1317
1318
|
|
|
1318
1319
|
if not MYPY:
|
|
1319
1320
|
class StrategyCanaryBackgroundVerificationArgsDict(TypedDict):
|
|
1320
|
-
template_names: pulumi.Input[Sequence[pulumi.Input[str]]]
|
|
1321
|
+
template_names: pulumi.Input[Sequence[pulumi.Input[builtins.str]]]
|
|
1321
1322
|
"""
|
|
1322
1323
|
List of Verification Template names.
|
|
1323
1324
|
"""
|
|
@@ -1327,22 +1328,22 @@ elif False:
|
|
|
1327
1328
|
@pulumi.input_type
|
|
1328
1329
|
class StrategyCanaryBackgroundVerificationArgs:
|
|
1329
1330
|
def __init__(__self__, *,
|
|
1330
|
-
template_names: pulumi.Input[Sequence[pulumi.Input[str]]]):
|
|
1331
|
+
template_names: pulumi.Input[Sequence[pulumi.Input[builtins.str]]]):
|
|
1331
1332
|
"""
|
|
1332
|
-
:param pulumi.Input[Sequence[pulumi.Input[str]]] template_names: List of Verification Template names.
|
|
1333
|
+
:param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] template_names: List of Verification Template names.
|
|
1333
1334
|
"""
|
|
1334
1335
|
pulumi.set(__self__, "template_names", template_names)
|
|
1335
1336
|
|
|
1336
1337
|
@property
|
|
1337
1338
|
@pulumi.getter(name="templateNames")
|
|
1338
|
-
def template_names(self) -> pulumi.Input[Sequence[pulumi.Input[str]]]:
|
|
1339
|
+
def template_names(self) -> pulumi.Input[Sequence[pulumi.Input[builtins.str]]]:
|
|
1339
1340
|
"""
|
|
1340
1341
|
List of Verification Template names.
|
|
1341
1342
|
"""
|
|
1342
1343
|
return pulumi.get(self, "template_names")
|
|
1343
1344
|
|
|
1344
1345
|
@template_names.setter
|
|
1345
|
-
def template_names(self, value: pulumi.Input[Sequence[pulumi.Input[str]]]):
|
|
1346
|
+
def template_names(self, value: pulumi.Input[Sequence[pulumi.Input[builtins.str]]]):
|
|
1346
1347
|
pulumi.set(self, "template_names", value)
|
|
1347
1348
|
|
|
1348
1349
|
|
|
@@ -1360,11 +1361,11 @@ if not MYPY:
|
|
|
1360
1361
|
"""
|
|
1361
1362
|
Defines the list of HeaderRoutes to add to the Rollout.
|
|
1362
1363
|
"""
|
|
1363
|
-
set_weight: NotRequired[pulumi.Input[int]]
|
|
1364
|
+
set_weight: NotRequired[pulumi.Input[builtins.int]]
|
|
1364
1365
|
"""
|
|
1365
1366
|
Defines the percentage that the new version should receive.
|
|
1366
1367
|
"""
|
|
1367
|
-
step_name: NotRequired[pulumi.Input[str]]
|
|
1368
|
+
step_name: NotRequired[pulumi.Input[builtins.str]]
|
|
1368
1369
|
verification: NotRequired[pulumi.Input['StrategyCanaryStepVerificationArgsDict']]
|
|
1369
1370
|
"""
|
|
1370
1371
|
Represents the list of verifications to run in a step.
|
|
@@ -1378,14 +1379,14 @@ class StrategyCanaryStepArgs:
|
|
|
1378
1379
|
pause: Optional[pulumi.Input['StrategyCanaryStepPauseArgs']] = None,
|
|
1379
1380
|
set_canary_scale: Optional[pulumi.Input['StrategyCanaryStepSetCanaryScaleArgs']] = None,
|
|
1380
1381
|
set_header_route: Optional[pulumi.Input['StrategyCanaryStepSetHeaderRouteArgs']] = None,
|
|
1381
|
-
set_weight: Optional[pulumi.Input[int]] = None,
|
|
1382
|
-
step_name: Optional[pulumi.Input[str]] = None,
|
|
1382
|
+
set_weight: Optional[pulumi.Input[builtins.int]] = None,
|
|
1383
|
+
step_name: Optional[pulumi.Input[builtins.str]] = None,
|
|
1383
1384
|
verification: Optional[pulumi.Input['StrategyCanaryStepVerificationArgs']] = None):
|
|
1384
1385
|
"""
|
|
1385
1386
|
:param pulumi.Input['StrategyCanaryStepPauseArgs'] pause: Defines the duration of time to freeze the rollout.
|
|
1386
1387
|
:param pulumi.Input['StrategyCanaryStepSetCanaryScaleArgs'] set_canary_scale: Defines how to scale the version without traffic weight changing.
|
|
1387
1388
|
:param pulumi.Input['StrategyCanaryStepSetHeaderRouteArgs'] set_header_route: Defines the list of HeaderRoutes to add to the Rollout.
|
|
1388
|
-
:param pulumi.Input[int] set_weight: Defines the percentage that the new version should receive.
|
|
1389
|
+
:param pulumi.Input[builtins.int] set_weight: Defines the percentage that the new version should receive.
|
|
1389
1390
|
:param pulumi.Input['StrategyCanaryStepVerificationArgs'] verification: Represents the list of verifications to run in a step.
|
|
1390
1391
|
"""
|
|
1391
1392
|
if pause is not None:
|
|
@@ -1439,23 +1440,23 @@ class StrategyCanaryStepArgs:
|
|
|
1439
1440
|
|
|
1440
1441
|
@property
|
|
1441
1442
|
@pulumi.getter(name="setWeight")
|
|
1442
|
-
def set_weight(self) -> Optional[pulumi.Input[int]]:
|
|
1443
|
+
def set_weight(self) -> Optional[pulumi.Input[builtins.int]]:
|
|
1443
1444
|
"""
|
|
1444
1445
|
Defines the percentage that the new version should receive.
|
|
1445
1446
|
"""
|
|
1446
1447
|
return pulumi.get(self, "set_weight")
|
|
1447
1448
|
|
|
1448
1449
|
@set_weight.setter
|
|
1449
|
-
def set_weight(self, value: Optional[pulumi.Input[int]]):
|
|
1450
|
+
def set_weight(self, value: Optional[pulumi.Input[builtins.int]]):
|
|
1450
1451
|
pulumi.set(self, "set_weight", value)
|
|
1451
1452
|
|
|
1452
1453
|
@property
|
|
1453
1454
|
@pulumi.getter(name="stepName")
|
|
1454
|
-
def step_name(self) -> Optional[pulumi.Input[str]]:
|
|
1455
|
+
def step_name(self) -> Optional[pulumi.Input[builtins.str]]:
|
|
1455
1456
|
return pulumi.get(self, "step_name")
|
|
1456
1457
|
|
|
1457
1458
|
@step_name.setter
|
|
1458
|
-
def step_name(self, value: Optional[pulumi.Input[str]]):
|
|
1459
|
+
def step_name(self, value: Optional[pulumi.Input[builtins.str]]):
|
|
1459
1460
|
pulumi.set(self, "step_name", value)
|
|
1460
1461
|
|
|
1461
1462
|
@property
|
|
@@ -1473,7 +1474,7 @@ class StrategyCanaryStepArgs:
|
|
|
1473
1474
|
|
|
1474
1475
|
if not MYPY:
|
|
1475
1476
|
class StrategyCanaryStepPauseArgsDict(TypedDict):
|
|
1476
|
-
duration: NotRequired[pulumi.Input[str]]
|
|
1477
|
+
duration: NotRequired[pulumi.Input[builtins.str]]
|
|
1477
1478
|
"""
|
|
1478
1479
|
The amount of time to wait before moving to the next step.
|
|
1479
1480
|
"""
|
|
@@ -1483,37 +1484,37 @@ elif False:
|
|
|
1483
1484
|
@pulumi.input_type
|
|
1484
1485
|
class StrategyCanaryStepPauseArgs:
|
|
1485
1486
|
def __init__(__self__, *,
|
|
1486
|
-
duration: Optional[pulumi.Input[str]] = None):
|
|
1487
|
+
duration: Optional[pulumi.Input[builtins.str]] = None):
|
|
1487
1488
|
"""
|
|
1488
|
-
:param pulumi.Input[str] duration: The amount of time to wait before moving to the next step.
|
|
1489
|
+
:param pulumi.Input[builtins.str] duration: The amount of time to wait before moving to the next step.
|
|
1489
1490
|
"""
|
|
1490
1491
|
if duration is not None:
|
|
1491
1492
|
pulumi.set(__self__, "duration", duration)
|
|
1492
1493
|
|
|
1493
1494
|
@property
|
|
1494
1495
|
@pulumi.getter
|
|
1495
|
-
def duration(self) -> Optional[pulumi.Input[str]]:
|
|
1496
|
+
def duration(self) -> Optional[pulumi.Input[builtins.str]]:
|
|
1496
1497
|
"""
|
|
1497
1498
|
The amount of time to wait before moving to the next step.
|
|
1498
1499
|
"""
|
|
1499
1500
|
return pulumi.get(self, "duration")
|
|
1500
1501
|
|
|
1501
1502
|
@duration.setter
|
|
1502
|
-
def duration(self, value: Optional[pulumi.Input[str]]):
|
|
1503
|
+
def duration(self, value: Optional[pulumi.Input[builtins.str]]):
|
|
1503
1504
|
pulumi.set(self, "duration", value)
|
|
1504
1505
|
|
|
1505
1506
|
|
|
1506
1507
|
if not MYPY:
|
|
1507
1508
|
class StrategyCanaryStepSetCanaryScaleArgsDict(TypedDict):
|
|
1508
|
-
match_traffic_weight: NotRequired[pulumi.Input[bool]]
|
|
1509
|
+
match_traffic_weight: NotRequired[pulumi.Input[builtins.bool]]
|
|
1509
1510
|
"""
|
|
1510
1511
|
Defines whether a rollout should match the current canary's setWeight step.
|
|
1511
1512
|
"""
|
|
1512
|
-
replicas: NotRequired[pulumi.Input[int]]
|
|
1513
|
+
replicas: NotRequired[pulumi.Input[builtins.int]]
|
|
1513
1514
|
"""
|
|
1514
1515
|
Sets the number of replicas the new version should have.
|
|
1515
1516
|
"""
|
|
1516
|
-
weight: NotRequired[pulumi.Input[int]]
|
|
1517
|
+
weight: NotRequired[pulumi.Input[builtins.int]]
|
|
1517
1518
|
"""
|
|
1518
1519
|
Sets the percentage of replicas the new version should have.
|
|
1519
1520
|
"""
|
|
@@ -1523,13 +1524,13 @@ elif False:
|
|
|
1523
1524
|
@pulumi.input_type
|
|
1524
1525
|
class StrategyCanaryStepSetCanaryScaleArgs:
|
|
1525
1526
|
def __init__(__self__, *,
|
|
1526
|
-
match_traffic_weight: Optional[pulumi.Input[bool]] = None,
|
|
1527
|
-
replicas: Optional[pulumi.Input[int]] = None,
|
|
1528
|
-
weight: Optional[pulumi.Input[int]] = None):
|
|
1527
|
+
match_traffic_weight: Optional[pulumi.Input[builtins.bool]] = None,
|
|
1528
|
+
replicas: Optional[pulumi.Input[builtins.int]] = None,
|
|
1529
|
+
weight: Optional[pulumi.Input[builtins.int]] = None):
|
|
1529
1530
|
"""
|
|
1530
|
-
:param pulumi.Input[bool] match_traffic_weight: Defines whether a rollout should match the current canary's setWeight step.
|
|
1531
|
-
:param pulumi.Input[int] replicas: Sets the number of replicas the new version should have.
|
|
1532
|
-
:param pulumi.Input[int] weight: Sets the percentage of replicas the new version should have.
|
|
1531
|
+
:param pulumi.Input[builtins.bool] match_traffic_weight: Defines whether a rollout should match the current canary's setWeight step.
|
|
1532
|
+
:param pulumi.Input[builtins.int] replicas: Sets the number of replicas the new version should have.
|
|
1533
|
+
:param pulumi.Input[builtins.int] weight: Sets the percentage of replicas the new version should have.
|
|
1533
1534
|
"""
|
|
1534
1535
|
if match_traffic_weight is not None:
|
|
1535
1536
|
pulumi.set(__self__, "match_traffic_weight", match_traffic_weight)
|
|
@@ -1540,44 +1541,44 @@ class StrategyCanaryStepSetCanaryScaleArgs:
|
|
|
1540
1541
|
|
|
1541
1542
|
@property
|
|
1542
1543
|
@pulumi.getter(name="matchTrafficWeight")
|
|
1543
|
-
def match_traffic_weight(self) -> Optional[pulumi.Input[bool]]:
|
|
1544
|
+
def match_traffic_weight(self) -> Optional[pulumi.Input[builtins.bool]]:
|
|
1544
1545
|
"""
|
|
1545
1546
|
Defines whether a rollout should match the current canary's setWeight step.
|
|
1546
1547
|
"""
|
|
1547
1548
|
return pulumi.get(self, "match_traffic_weight")
|
|
1548
1549
|
|
|
1549
1550
|
@match_traffic_weight.setter
|
|
1550
|
-
def match_traffic_weight(self, value: Optional[pulumi.Input[bool]]):
|
|
1551
|
+
def match_traffic_weight(self, value: Optional[pulumi.Input[builtins.bool]]):
|
|
1551
1552
|
pulumi.set(self, "match_traffic_weight", value)
|
|
1552
1553
|
|
|
1553
1554
|
@property
|
|
1554
1555
|
@pulumi.getter
|
|
1555
|
-
def replicas(self) -> Optional[pulumi.Input[int]]:
|
|
1556
|
+
def replicas(self) -> Optional[pulumi.Input[builtins.int]]:
|
|
1556
1557
|
"""
|
|
1557
1558
|
Sets the number of replicas the new version should have.
|
|
1558
1559
|
"""
|
|
1559
1560
|
return pulumi.get(self, "replicas")
|
|
1560
1561
|
|
|
1561
1562
|
@replicas.setter
|
|
1562
|
-
def replicas(self, value: Optional[pulumi.Input[int]]):
|
|
1563
|
+
def replicas(self, value: Optional[pulumi.Input[builtins.int]]):
|
|
1563
1564
|
pulumi.set(self, "replicas", value)
|
|
1564
1565
|
|
|
1565
1566
|
@property
|
|
1566
1567
|
@pulumi.getter
|
|
1567
|
-
def weight(self) -> Optional[pulumi.Input[int]]:
|
|
1568
|
+
def weight(self) -> Optional[pulumi.Input[builtins.int]]:
|
|
1568
1569
|
"""
|
|
1569
1570
|
Sets the percentage of replicas the new version should have.
|
|
1570
1571
|
"""
|
|
1571
1572
|
return pulumi.get(self, "weight")
|
|
1572
1573
|
|
|
1573
1574
|
@weight.setter
|
|
1574
|
-
def weight(self, value: Optional[pulumi.Input[int]]):
|
|
1575
|
+
def weight(self, value: Optional[pulumi.Input[builtins.int]]):
|
|
1575
1576
|
pulumi.set(self, "weight", value)
|
|
1576
1577
|
|
|
1577
1578
|
|
|
1578
1579
|
if not MYPY:
|
|
1579
1580
|
class StrategyCanaryStepSetHeaderRouteArgsDict(TypedDict):
|
|
1580
|
-
header_route_name: pulumi.Input[str]
|
|
1581
|
+
header_route_name: pulumi.Input[builtins.str]
|
|
1581
1582
|
"""
|
|
1582
1583
|
The name of the HeaderRoute group.
|
|
1583
1584
|
"""
|
|
@@ -1591,10 +1592,10 @@ elif False:
|
|
|
1591
1592
|
@pulumi.input_type
|
|
1592
1593
|
class StrategyCanaryStepSetHeaderRouteArgs:
|
|
1593
1594
|
def __init__(__self__, *,
|
|
1594
|
-
header_route_name: pulumi.Input[str],
|
|
1595
|
+
header_route_name: pulumi.Input[builtins.str],
|
|
1595
1596
|
matches: pulumi.Input[Sequence[pulumi.Input['StrategyCanaryStepSetHeaderRouteMatchArgs']]]):
|
|
1596
1597
|
"""
|
|
1597
|
-
:param pulumi.Input[str] header_route_name: The name of the HeaderRoute group.
|
|
1598
|
+
:param pulumi.Input[builtins.str] header_route_name: The name of the HeaderRoute group.
|
|
1598
1599
|
:param pulumi.Input[Sequence[pulumi.Input['StrategyCanaryStepSetHeaderRouteMatchArgs']]] matches: The matching rules for the header route.
|
|
1599
1600
|
"""
|
|
1600
1601
|
pulumi.set(__self__, "header_route_name", header_route_name)
|
|
@@ -1602,14 +1603,14 @@ class StrategyCanaryStepSetHeaderRouteArgs:
|
|
|
1602
1603
|
|
|
1603
1604
|
@property
|
|
1604
1605
|
@pulumi.getter(name="headerRouteName")
|
|
1605
|
-
def header_route_name(self) -> pulumi.Input[str]:
|
|
1606
|
+
def header_route_name(self) -> pulumi.Input[builtins.str]:
|
|
1606
1607
|
"""
|
|
1607
1608
|
The name of the HeaderRoute group.
|
|
1608
1609
|
"""
|
|
1609
1610
|
return pulumi.get(self, "header_route_name")
|
|
1610
1611
|
|
|
1611
1612
|
@header_route_name.setter
|
|
1612
|
-
def header_route_name(self, value: pulumi.Input[str]):
|
|
1613
|
+
def header_route_name(self, value: pulumi.Input[builtins.str]):
|
|
1613
1614
|
pulumi.set(self, "header_route_name", value)
|
|
1614
1615
|
|
|
1615
1616
|
@property
|
|
@@ -1627,7 +1628,7 @@ class StrategyCanaryStepSetHeaderRouteArgs:
|
|
|
1627
1628
|
|
|
1628
1629
|
if not MYPY:
|
|
1629
1630
|
class StrategyCanaryStepSetHeaderRouteMatchArgsDict(TypedDict):
|
|
1630
|
-
header_name: pulumi.Input[str]
|
|
1631
|
+
header_name: pulumi.Input[builtins.str]
|
|
1631
1632
|
"""
|
|
1632
1633
|
The name of the header.
|
|
1633
1634
|
"""
|
|
@@ -1641,10 +1642,10 @@ elif False:
|
|
|
1641
1642
|
@pulumi.input_type
|
|
1642
1643
|
class StrategyCanaryStepSetHeaderRouteMatchArgs:
|
|
1643
1644
|
def __init__(__self__, *,
|
|
1644
|
-
header_name: pulumi.Input[str],
|
|
1645
|
+
header_name: pulumi.Input[builtins.str],
|
|
1645
1646
|
header_value: pulumi.Input['StrategyCanaryStepSetHeaderRouteMatchHeaderValueArgs']):
|
|
1646
1647
|
"""
|
|
1647
|
-
:param pulumi.Input[str] header_name: The name of the header.
|
|
1648
|
+
:param pulumi.Input[builtins.str] header_name: The name of the header.
|
|
1648
1649
|
:param pulumi.Input['StrategyCanaryStepSetHeaderRouteMatchHeaderValueArgs'] header_value: Defines a single header to add to the Rollout. Must be only one initialized from the following (exact, prefix, regex).
|
|
1649
1650
|
"""
|
|
1650
1651
|
pulumi.set(__self__, "header_name", header_name)
|
|
@@ -1652,14 +1653,14 @@ class StrategyCanaryStepSetHeaderRouteMatchArgs:
|
|
|
1652
1653
|
|
|
1653
1654
|
@property
|
|
1654
1655
|
@pulumi.getter(name="headerName")
|
|
1655
|
-
def header_name(self) -> pulumi.Input[str]:
|
|
1656
|
+
def header_name(self) -> pulumi.Input[builtins.str]:
|
|
1656
1657
|
"""
|
|
1657
1658
|
The name of the header.
|
|
1658
1659
|
"""
|
|
1659
1660
|
return pulumi.get(self, "header_name")
|
|
1660
1661
|
|
|
1661
1662
|
@header_name.setter
|
|
1662
|
-
def header_name(self, value: pulumi.Input[str]):
|
|
1663
|
+
def header_name(self, value: pulumi.Input[builtins.str]):
|
|
1663
1664
|
pulumi.set(self, "header_name", value)
|
|
1664
1665
|
|
|
1665
1666
|
@property
|
|
@@ -1677,15 +1678,15 @@ class StrategyCanaryStepSetHeaderRouteMatchArgs:
|
|
|
1677
1678
|
|
|
1678
1679
|
if not MYPY:
|
|
1679
1680
|
class StrategyCanaryStepSetHeaderRouteMatchHeaderValueArgsDict(TypedDict):
|
|
1680
|
-
exact: NotRequired[pulumi.Input[str]]
|
|
1681
|
+
exact: NotRequired[pulumi.Input[builtins.str]]
|
|
1681
1682
|
"""
|
|
1682
1683
|
The exact header value.
|
|
1683
1684
|
"""
|
|
1684
|
-
prefix: NotRequired[pulumi.Input[str]]
|
|
1685
|
+
prefix: NotRequired[pulumi.Input[builtins.str]]
|
|
1685
1686
|
"""
|
|
1686
1687
|
The prefix of the value.
|
|
1687
1688
|
"""
|
|
1688
|
-
regex: NotRequired[pulumi.Input[str]]
|
|
1689
|
+
regex: NotRequired[pulumi.Input[builtins.str]]
|
|
1689
1690
|
"""
|
|
1690
1691
|
The value in a regex format.
|
|
1691
1692
|
"""
|
|
@@ -1695,13 +1696,13 @@ elif False:
|
|
|
1695
1696
|
@pulumi.input_type
|
|
1696
1697
|
class StrategyCanaryStepSetHeaderRouteMatchHeaderValueArgs:
|
|
1697
1698
|
def __init__(__self__, *,
|
|
1698
|
-
exact: Optional[pulumi.Input[str]] = None,
|
|
1699
|
-
prefix: Optional[pulumi.Input[str]] = None,
|
|
1700
|
-
regex: Optional[pulumi.Input[str]] = None):
|
|
1699
|
+
exact: Optional[pulumi.Input[builtins.str]] = None,
|
|
1700
|
+
prefix: Optional[pulumi.Input[builtins.str]] = None,
|
|
1701
|
+
regex: Optional[pulumi.Input[builtins.str]] = None):
|
|
1701
1702
|
"""
|
|
1702
|
-
:param pulumi.Input[str] exact: The exact header value.
|
|
1703
|
-
:param pulumi.Input[str] prefix: The prefix of the value.
|
|
1704
|
-
:param pulumi.Input[str] regex: The value in a regex format.
|
|
1703
|
+
:param pulumi.Input[builtins.str] exact: The exact header value.
|
|
1704
|
+
:param pulumi.Input[builtins.str] prefix: The prefix of the value.
|
|
1705
|
+
:param pulumi.Input[builtins.str] regex: The value in a regex format.
|
|
1705
1706
|
"""
|
|
1706
1707
|
if exact is not None:
|
|
1707
1708
|
pulumi.set(__self__, "exact", exact)
|
|
@@ -1712,44 +1713,44 @@ class StrategyCanaryStepSetHeaderRouteMatchHeaderValueArgs:
|
|
|
1712
1713
|
|
|
1713
1714
|
@property
|
|
1714
1715
|
@pulumi.getter
|
|
1715
|
-
def exact(self) -> Optional[pulumi.Input[str]]:
|
|
1716
|
+
def exact(self) -> Optional[pulumi.Input[builtins.str]]:
|
|
1716
1717
|
"""
|
|
1717
1718
|
The exact header value.
|
|
1718
1719
|
"""
|
|
1719
1720
|
return pulumi.get(self, "exact")
|
|
1720
1721
|
|
|
1721
1722
|
@exact.setter
|
|
1722
|
-
def exact(self, value: Optional[pulumi.Input[str]]):
|
|
1723
|
+
def exact(self, value: Optional[pulumi.Input[builtins.str]]):
|
|
1723
1724
|
pulumi.set(self, "exact", value)
|
|
1724
1725
|
|
|
1725
1726
|
@property
|
|
1726
1727
|
@pulumi.getter
|
|
1727
|
-
def prefix(self) -> Optional[pulumi.Input[str]]:
|
|
1728
|
+
def prefix(self) -> Optional[pulumi.Input[builtins.str]]:
|
|
1728
1729
|
"""
|
|
1729
1730
|
The prefix of the value.
|
|
1730
1731
|
"""
|
|
1731
1732
|
return pulumi.get(self, "prefix")
|
|
1732
1733
|
|
|
1733
1734
|
@prefix.setter
|
|
1734
|
-
def prefix(self, value: Optional[pulumi.Input[str]]):
|
|
1735
|
+
def prefix(self, value: Optional[pulumi.Input[builtins.str]]):
|
|
1735
1736
|
pulumi.set(self, "prefix", value)
|
|
1736
1737
|
|
|
1737
1738
|
@property
|
|
1738
1739
|
@pulumi.getter
|
|
1739
|
-
def regex(self) -> Optional[pulumi.Input[str]]:
|
|
1740
|
+
def regex(self) -> Optional[pulumi.Input[builtins.str]]:
|
|
1740
1741
|
"""
|
|
1741
1742
|
The value in a regex format.
|
|
1742
1743
|
"""
|
|
1743
1744
|
return pulumi.get(self, "regex")
|
|
1744
1745
|
|
|
1745
1746
|
@regex.setter
|
|
1746
|
-
def regex(self, value: Optional[pulumi.Input[str]]):
|
|
1747
|
+
def regex(self, value: Optional[pulumi.Input[builtins.str]]):
|
|
1747
1748
|
pulumi.set(self, "regex", value)
|
|
1748
1749
|
|
|
1749
1750
|
|
|
1750
1751
|
if not MYPY:
|
|
1751
1752
|
class StrategyCanaryStepVerificationArgsDict(TypedDict):
|
|
1752
|
-
template_names: pulumi.Input[Sequence[pulumi.Input[str]]]
|
|
1753
|
+
template_names: pulumi.Input[Sequence[pulumi.Input[builtins.str]]]
|
|
1753
1754
|
"""
|
|
1754
1755
|
List of Verification Template names.
|
|
1755
1756
|
"""
|
|
@@ -1759,22 +1760,22 @@ elif False:
|
|
|
1759
1760
|
@pulumi.input_type
|
|
1760
1761
|
class StrategyCanaryStepVerificationArgs:
|
|
1761
1762
|
def __init__(__self__, *,
|
|
1762
|
-
template_names: pulumi.Input[Sequence[pulumi.Input[str]]]):
|
|
1763
|
+
template_names: pulumi.Input[Sequence[pulumi.Input[builtins.str]]]):
|
|
1763
1764
|
"""
|
|
1764
|
-
:param pulumi.Input[Sequence[pulumi.Input[str]]] template_names: List of Verification Template names.
|
|
1765
|
+
:param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] template_names: List of Verification Template names.
|
|
1765
1766
|
"""
|
|
1766
1767
|
pulumi.set(__self__, "template_names", template_names)
|
|
1767
1768
|
|
|
1768
1769
|
@property
|
|
1769
1770
|
@pulumi.getter(name="templateNames")
|
|
1770
|
-
def template_names(self) -> pulumi.Input[Sequence[pulumi.Input[str]]]:
|
|
1771
|
+
def template_names(self) -> pulumi.Input[Sequence[pulumi.Input[builtins.str]]]:
|
|
1771
1772
|
"""
|
|
1772
1773
|
List of Verification Template names.
|
|
1773
1774
|
"""
|
|
1774
1775
|
return pulumi.get(self, "template_names")
|
|
1775
1776
|
|
|
1776
1777
|
@template_names.setter
|
|
1777
|
-
def template_names(self, value: pulumi.Input[Sequence[pulumi.Input[str]]]):
|
|
1778
|
+
def template_names(self, value: pulumi.Input[Sequence[pulumi.Input[builtins.str]]]):
|
|
1778
1779
|
pulumi.set(self, "template_names", value)
|
|
1779
1780
|
|
|
1780
1781
|
|
|
@@ -1815,7 +1816,7 @@ if not MYPY:
|
|
|
1815
1816
|
"""
|
|
1816
1817
|
Defines the duration of time to freeze the rollout.
|
|
1817
1818
|
"""
|
|
1818
|
-
steps_name: NotRequired[pulumi.Input[str]]
|
|
1819
|
+
steps_name: NotRequired[pulumi.Input[builtins.str]]
|
|
1819
1820
|
verification: NotRequired[pulumi.Input['StrategyRollingStepVerificationArgsDict']]
|
|
1820
1821
|
"""
|
|
1821
1822
|
Represents the list of verifications to run in a step.
|
|
@@ -1827,7 +1828,7 @@ elif False:
|
|
|
1827
1828
|
class StrategyRollingStepArgs:
|
|
1828
1829
|
def __init__(__self__, *,
|
|
1829
1830
|
pause: Optional[pulumi.Input['StrategyRollingStepPauseArgs']] = None,
|
|
1830
|
-
steps_name: Optional[pulumi.Input[str]] = None,
|
|
1831
|
+
steps_name: Optional[pulumi.Input[builtins.str]] = None,
|
|
1831
1832
|
verification: Optional[pulumi.Input['StrategyRollingStepVerificationArgs']] = None):
|
|
1832
1833
|
"""
|
|
1833
1834
|
:param pulumi.Input['StrategyRollingStepPauseArgs'] pause: Defines the duration of time to freeze the rollout.
|
|
@@ -1854,11 +1855,11 @@ class StrategyRollingStepArgs:
|
|
|
1854
1855
|
|
|
1855
1856
|
@property
|
|
1856
1857
|
@pulumi.getter(name="stepsName")
|
|
1857
|
-
def steps_name(self) -> Optional[pulumi.Input[str]]:
|
|
1858
|
+
def steps_name(self) -> Optional[pulumi.Input[builtins.str]]:
|
|
1858
1859
|
return pulumi.get(self, "steps_name")
|
|
1859
1860
|
|
|
1860
1861
|
@steps_name.setter
|
|
1861
|
-
def steps_name(self, value: Optional[pulumi.Input[str]]):
|
|
1862
|
+
def steps_name(self, value: Optional[pulumi.Input[builtins.str]]):
|
|
1862
1863
|
pulumi.set(self, "steps_name", value)
|
|
1863
1864
|
|
|
1864
1865
|
@property
|
|
@@ -1876,7 +1877,7 @@ class StrategyRollingStepArgs:
|
|
|
1876
1877
|
|
|
1877
1878
|
if not MYPY:
|
|
1878
1879
|
class StrategyRollingStepPauseArgsDict(TypedDict):
|
|
1879
|
-
duration: NotRequired[pulumi.Input[str]]
|
|
1880
|
+
duration: NotRequired[pulumi.Input[builtins.str]]
|
|
1880
1881
|
"""
|
|
1881
1882
|
The amount of time to wait before moving to the next step.
|
|
1882
1883
|
"""
|
|
@@ -1886,29 +1887,29 @@ elif False:
|
|
|
1886
1887
|
@pulumi.input_type
|
|
1887
1888
|
class StrategyRollingStepPauseArgs:
|
|
1888
1889
|
def __init__(__self__, *,
|
|
1889
|
-
duration: Optional[pulumi.Input[str]] = None):
|
|
1890
|
+
duration: Optional[pulumi.Input[builtins.str]] = None):
|
|
1890
1891
|
"""
|
|
1891
|
-
:param pulumi.Input[str] duration: The amount of time to wait before moving to the next step.
|
|
1892
|
+
:param pulumi.Input[builtins.str] duration: The amount of time to wait before moving to the next step.
|
|
1892
1893
|
"""
|
|
1893
1894
|
if duration is not None:
|
|
1894
1895
|
pulumi.set(__self__, "duration", duration)
|
|
1895
1896
|
|
|
1896
1897
|
@property
|
|
1897
1898
|
@pulumi.getter
|
|
1898
|
-
def duration(self) -> Optional[pulumi.Input[str]]:
|
|
1899
|
+
def duration(self) -> Optional[pulumi.Input[builtins.str]]:
|
|
1899
1900
|
"""
|
|
1900
1901
|
The amount of time to wait before moving to the next step.
|
|
1901
1902
|
"""
|
|
1902
1903
|
return pulumi.get(self, "duration")
|
|
1903
1904
|
|
|
1904
1905
|
@duration.setter
|
|
1905
|
-
def duration(self, value: Optional[pulumi.Input[str]]):
|
|
1906
|
+
def duration(self, value: Optional[pulumi.Input[builtins.str]]):
|
|
1906
1907
|
pulumi.set(self, "duration", value)
|
|
1907
1908
|
|
|
1908
1909
|
|
|
1909
1910
|
if not MYPY:
|
|
1910
1911
|
class StrategyRollingStepVerificationArgsDict(TypedDict):
|
|
1911
|
-
template_names: pulumi.Input[Sequence[pulumi.Input[str]]]
|
|
1912
|
+
template_names: pulumi.Input[Sequence[pulumi.Input[builtins.str]]]
|
|
1912
1913
|
"""
|
|
1913
1914
|
List of Verification Template names.
|
|
1914
1915
|
"""
|
|
@@ -1918,28 +1919,28 @@ elif False:
|
|
|
1918
1919
|
@pulumi.input_type
|
|
1919
1920
|
class StrategyRollingStepVerificationArgs:
|
|
1920
1921
|
def __init__(__self__, *,
|
|
1921
|
-
template_names: pulumi.Input[Sequence[pulumi.Input[str]]]):
|
|
1922
|
+
template_names: pulumi.Input[Sequence[pulumi.Input[builtins.str]]]):
|
|
1922
1923
|
"""
|
|
1923
|
-
:param pulumi.Input[Sequence[pulumi.Input[str]]] template_names: List of Verification Template names.
|
|
1924
|
+
:param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] template_names: List of Verification Template names.
|
|
1924
1925
|
"""
|
|
1925
1926
|
pulumi.set(__self__, "template_names", template_names)
|
|
1926
1927
|
|
|
1927
1928
|
@property
|
|
1928
1929
|
@pulumi.getter(name="templateNames")
|
|
1929
|
-
def template_names(self) -> pulumi.Input[Sequence[pulumi.Input[str]]]:
|
|
1930
|
+
def template_names(self) -> pulumi.Input[Sequence[pulumi.Input[builtins.str]]]:
|
|
1930
1931
|
"""
|
|
1931
1932
|
List of Verification Template names.
|
|
1932
1933
|
"""
|
|
1933
1934
|
return pulumi.get(self, "template_names")
|
|
1934
1935
|
|
|
1935
1936
|
@template_names.setter
|
|
1936
|
-
def template_names(self, value: pulumi.Input[Sequence[pulumi.Input[str]]]):
|
|
1937
|
+
def template_names(self, value: pulumi.Input[Sequence[pulumi.Input[builtins.str]]]):
|
|
1937
1938
|
pulumi.set(self, "template_names", value)
|
|
1938
1939
|
|
|
1939
1940
|
|
|
1940
1941
|
if not MYPY:
|
|
1941
1942
|
class VerificationProviderCloudWatchArgsDict(TypedDict):
|
|
1942
|
-
iam_arn: pulumi.Input[str]
|
|
1943
|
+
iam_arn: pulumi.Input[builtins.str]
|
|
1943
1944
|
"""
|
|
1944
1945
|
Set label key.
|
|
1945
1946
|
"""
|
|
@@ -1949,36 +1950,36 @@ elif False:
|
|
|
1949
1950
|
@pulumi.input_type
|
|
1950
1951
|
class VerificationProviderCloudWatchArgs:
|
|
1951
1952
|
def __init__(__self__, *,
|
|
1952
|
-
iam_arn: pulumi.Input[str]):
|
|
1953
|
+
iam_arn: pulumi.Input[builtins.str]):
|
|
1953
1954
|
"""
|
|
1954
|
-
:param pulumi.Input[str] iam_arn: Set label key.
|
|
1955
|
+
:param pulumi.Input[builtins.str] iam_arn: Set label key.
|
|
1955
1956
|
"""
|
|
1956
1957
|
pulumi.set(__self__, "iam_arn", iam_arn)
|
|
1957
1958
|
|
|
1958
1959
|
@property
|
|
1959
1960
|
@pulumi.getter(name="iamArn")
|
|
1960
|
-
def iam_arn(self) -> pulumi.Input[str]:
|
|
1961
|
+
def iam_arn(self) -> pulumi.Input[builtins.str]:
|
|
1961
1962
|
"""
|
|
1962
1963
|
Set label key.
|
|
1963
1964
|
"""
|
|
1964
1965
|
return pulumi.get(self, "iam_arn")
|
|
1965
1966
|
|
|
1966
1967
|
@iam_arn.setter
|
|
1967
|
-
def iam_arn(self, value: pulumi.Input[str]):
|
|
1968
|
+
def iam_arn(self, value: pulumi.Input[builtins.str]):
|
|
1968
1969
|
pulumi.set(self, "iam_arn", value)
|
|
1969
1970
|
|
|
1970
1971
|
|
|
1971
1972
|
if not MYPY:
|
|
1972
1973
|
class VerificationProviderDatadogArgsDict(TypedDict):
|
|
1973
|
-
address: pulumi.Input[str]
|
|
1974
|
+
address: pulumi.Input[builtins.str]
|
|
1974
1975
|
"""
|
|
1975
1976
|
DataDog API URL.
|
|
1976
1977
|
"""
|
|
1977
|
-
api_key: pulumi.Input[str]
|
|
1978
|
+
api_key: pulumi.Input[builtins.str]
|
|
1978
1979
|
"""
|
|
1979
1980
|
API key required by the Datadog Agent to submit metrics and events to Datadog.
|
|
1980
1981
|
"""
|
|
1981
|
-
app_key: pulumi.Input[str]
|
|
1982
|
+
app_key: pulumi.Input[builtins.str]
|
|
1982
1983
|
"""
|
|
1983
1984
|
API key that gives users access to Datadog’s programmatic API.
|
|
1984
1985
|
"""
|
|
@@ -1988,13 +1989,13 @@ elif False:
|
|
|
1988
1989
|
@pulumi.input_type
|
|
1989
1990
|
class VerificationProviderDatadogArgs:
|
|
1990
1991
|
def __init__(__self__, *,
|
|
1991
|
-
address: pulumi.Input[str],
|
|
1992
|
-
api_key: pulumi.Input[str],
|
|
1993
|
-
app_key: pulumi.Input[str]):
|
|
1992
|
+
address: pulumi.Input[builtins.str],
|
|
1993
|
+
api_key: pulumi.Input[builtins.str],
|
|
1994
|
+
app_key: pulumi.Input[builtins.str]):
|
|
1994
1995
|
"""
|
|
1995
|
-
:param pulumi.Input[str] address: DataDog API URL.
|
|
1996
|
-
:param pulumi.Input[str] api_key: API key required by the Datadog Agent to submit metrics and events to Datadog.
|
|
1997
|
-
:param pulumi.Input[str] app_key: API key that gives users access to Datadog’s programmatic API.
|
|
1996
|
+
:param pulumi.Input[builtins.str] address: DataDog API URL.
|
|
1997
|
+
:param pulumi.Input[builtins.str] api_key: API key required by the Datadog Agent to submit metrics and events to Datadog.
|
|
1998
|
+
:param pulumi.Input[builtins.str] app_key: API key that gives users access to Datadog’s programmatic API.
|
|
1998
1999
|
"""
|
|
1999
2000
|
pulumi.set(__self__, "address", address)
|
|
2000
2001
|
pulumi.set(__self__, "api_key", api_key)
|
|
@@ -2002,52 +2003,52 @@ class VerificationProviderDatadogArgs:
|
|
|
2002
2003
|
|
|
2003
2004
|
@property
|
|
2004
2005
|
@pulumi.getter
|
|
2005
|
-
def address(self) -> pulumi.Input[str]:
|
|
2006
|
+
def address(self) -> pulumi.Input[builtins.str]:
|
|
2006
2007
|
"""
|
|
2007
2008
|
DataDog API URL.
|
|
2008
2009
|
"""
|
|
2009
2010
|
return pulumi.get(self, "address")
|
|
2010
2011
|
|
|
2011
2012
|
@address.setter
|
|
2012
|
-
def address(self, value: pulumi.Input[str]):
|
|
2013
|
+
def address(self, value: pulumi.Input[builtins.str]):
|
|
2013
2014
|
pulumi.set(self, "address", value)
|
|
2014
2015
|
|
|
2015
2016
|
@property
|
|
2016
2017
|
@pulumi.getter(name="apiKey")
|
|
2017
|
-
def api_key(self) -> pulumi.Input[str]:
|
|
2018
|
+
def api_key(self) -> pulumi.Input[builtins.str]:
|
|
2018
2019
|
"""
|
|
2019
2020
|
API key required by the Datadog Agent to submit metrics and events to Datadog.
|
|
2020
2021
|
"""
|
|
2021
2022
|
return pulumi.get(self, "api_key")
|
|
2022
2023
|
|
|
2023
2024
|
@api_key.setter
|
|
2024
|
-
def api_key(self, value: pulumi.Input[str]):
|
|
2025
|
+
def api_key(self, value: pulumi.Input[builtins.str]):
|
|
2025
2026
|
pulumi.set(self, "api_key", value)
|
|
2026
2027
|
|
|
2027
2028
|
@property
|
|
2028
2029
|
@pulumi.getter(name="appKey")
|
|
2029
|
-
def app_key(self) -> pulumi.Input[str]:
|
|
2030
|
+
def app_key(self) -> pulumi.Input[builtins.str]:
|
|
2030
2031
|
"""
|
|
2031
2032
|
API key that gives users access to Datadog’s programmatic API.
|
|
2032
2033
|
"""
|
|
2033
2034
|
return pulumi.get(self, "app_key")
|
|
2034
2035
|
|
|
2035
2036
|
@app_key.setter
|
|
2036
|
-
def app_key(self, value: pulumi.Input[str]):
|
|
2037
|
+
def app_key(self, value: pulumi.Input[builtins.str]):
|
|
2037
2038
|
pulumi.set(self, "app_key", value)
|
|
2038
2039
|
|
|
2039
2040
|
|
|
2040
2041
|
if not MYPY:
|
|
2041
2042
|
class VerificationProviderJenkinsArgsDict(TypedDict):
|
|
2042
|
-
api_token: pulumi.Input[str]
|
|
2043
|
+
api_token: pulumi.Input[builtins.str]
|
|
2043
2044
|
"""
|
|
2044
2045
|
The Jenkins server’s access apiToken.
|
|
2045
2046
|
"""
|
|
2046
|
-
base_url: pulumi.Input[str]
|
|
2047
|
+
base_url: pulumi.Input[builtins.str]
|
|
2047
2048
|
"""
|
|
2048
2049
|
The address of the Jenkins server within the cluster.
|
|
2049
2050
|
"""
|
|
2050
|
-
username: pulumi.Input[str]
|
|
2051
|
+
username: pulumi.Input[builtins.str]
|
|
2051
2052
|
"""
|
|
2052
2053
|
The Jenkins server’s access username.
|
|
2053
2054
|
"""
|
|
@@ -2057,13 +2058,13 @@ elif False:
|
|
|
2057
2058
|
@pulumi.input_type
|
|
2058
2059
|
class VerificationProviderJenkinsArgs:
|
|
2059
2060
|
def __init__(__self__, *,
|
|
2060
|
-
api_token: pulumi.Input[str],
|
|
2061
|
-
base_url: pulumi.Input[str],
|
|
2062
|
-
username: pulumi.Input[str]):
|
|
2061
|
+
api_token: pulumi.Input[builtins.str],
|
|
2062
|
+
base_url: pulumi.Input[builtins.str],
|
|
2063
|
+
username: pulumi.Input[builtins.str]):
|
|
2063
2064
|
"""
|
|
2064
|
-
:param pulumi.Input[str] api_token: The Jenkins server’s access apiToken.
|
|
2065
|
-
:param pulumi.Input[str] base_url: The address of the Jenkins server within the cluster.
|
|
2066
|
-
:param pulumi.Input[str] username: The Jenkins server’s access username.
|
|
2065
|
+
:param pulumi.Input[builtins.str] api_token: The Jenkins server’s access apiToken.
|
|
2066
|
+
:param pulumi.Input[builtins.str] base_url: The address of the Jenkins server within the cluster.
|
|
2067
|
+
:param pulumi.Input[builtins.str] username: The Jenkins server’s access username.
|
|
2067
2068
|
"""
|
|
2068
2069
|
pulumi.set(__self__, "api_token", api_token)
|
|
2069
2070
|
pulumi.set(__self__, "base_url", base_url)
|
|
@@ -2071,57 +2072,57 @@ class VerificationProviderJenkinsArgs:
|
|
|
2071
2072
|
|
|
2072
2073
|
@property
|
|
2073
2074
|
@pulumi.getter(name="apiToken")
|
|
2074
|
-
def api_token(self) -> pulumi.Input[str]:
|
|
2075
|
+
def api_token(self) -> pulumi.Input[builtins.str]:
|
|
2075
2076
|
"""
|
|
2076
2077
|
The Jenkins server’s access apiToken.
|
|
2077
2078
|
"""
|
|
2078
2079
|
return pulumi.get(self, "api_token")
|
|
2079
2080
|
|
|
2080
2081
|
@api_token.setter
|
|
2081
|
-
def api_token(self, value: pulumi.Input[str]):
|
|
2082
|
+
def api_token(self, value: pulumi.Input[builtins.str]):
|
|
2082
2083
|
pulumi.set(self, "api_token", value)
|
|
2083
2084
|
|
|
2084
2085
|
@property
|
|
2085
2086
|
@pulumi.getter(name="baseUrl")
|
|
2086
|
-
def base_url(self) -> pulumi.Input[str]:
|
|
2087
|
+
def base_url(self) -> pulumi.Input[builtins.str]:
|
|
2087
2088
|
"""
|
|
2088
2089
|
The address of the Jenkins server within the cluster.
|
|
2089
2090
|
"""
|
|
2090
2091
|
return pulumi.get(self, "base_url")
|
|
2091
2092
|
|
|
2092
2093
|
@base_url.setter
|
|
2093
|
-
def base_url(self, value: pulumi.Input[str]):
|
|
2094
|
+
def base_url(self, value: pulumi.Input[builtins.str]):
|
|
2094
2095
|
pulumi.set(self, "base_url", value)
|
|
2095
2096
|
|
|
2096
2097
|
@property
|
|
2097
2098
|
@pulumi.getter
|
|
2098
|
-
def username(self) -> pulumi.Input[str]:
|
|
2099
|
+
def username(self) -> pulumi.Input[builtins.str]:
|
|
2099
2100
|
"""
|
|
2100
2101
|
The Jenkins server’s access username.
|
|
2101
2102
|
"""
|
|
2102
2103
|
return pulumi.get(self, "username")
|
|
2103
2104
|
|
|
2104
2105
|
@username.setter
|
|
2105
|
-
def username(self, value: pulumi.Input[str]):
|
|
2106
|
+
def username(self, value: pulumi.Input[builtins.str]):
|
|
2106
2107
|
pulumi.set(self, "username", value)
|
|
2107
2108
|
|
|
2108
2109
|
|
|
2109
2110
|
if not MYPY:
|
|
2110
2111
|
class VerificationProviderNewRelicArgsDict(TypedDict):
|
|
2111
|
-
account_id: pulumi.Input[str]
|
|
2112
|
-
personal_api_key: pulumi.Input[str]
|
|
2112
|
+
account_id: pulumi.Input[builtins.str]
|
|
2113
|
+
personal_api_key: pulumi.Input[builtins.str]
|
|
2113
2114
|
"""
|
|
2114
2115
|
The NewRelic user key
|
|
2115
2116
|
"""
|
|
2116
|
-
base_url_nerd_graph: NotRequired[pulumi.Input[str]]
|
|
2117
|
+
base_url_nerd_graph: NotRequired[pulumi.Input[builtins.str]]
|
|
2117
2118
|
"""
|
|
2118
2119
|
The base URL for NerdGraph for a proxy.
|
|
2119
2120
|
"""
|
|
2120
|
-
base_url_rest: NotRequired[pulumi.Input[str]]
|
|
2121
|
+
base_url_rest: NotRequired[pulumi.Input[builtins.str]]
|
|
2121
2122
|
"""
|
|
2122
2123
|
The base URL of the New Relic REST API for a proxy.
|
|
2123
2124
|
"""
|
|
2124
|
-
region: NotRequired[pulumi.Input[str]]
|
|
2125
|
+
region: NotRequired[pulumi.Input[builtins.str]]
|
|
2125
2126
|
"""
|
|
2126
2127
|
A region which the account is attached to. Default is "us".
|
|
2127
2128
|
"""
|
|
@@ -2131,16 +2132,16 @@ elif False:
|
|
|
2131
2132
|
@pulumi.input_type
|
|
2132
2133
|
class VerificationProviderNewRelicArgs:
|
|
2133
2134
|
def __init__(__self__, *,
|
|
2134
|
-
account_id: pulumi.Input[str],
|
|
2135
|
-
personal_api_key: pulumi.Input[str],
|
|
2136
|
-
base_url_nerd_graph: Optional[pulumi.Input[str]] = None,
|
|
2137
|
-
base_url_rest: Optional[pulumi.Input[str]] = None,
|
|
2138
|
-
region: Optional[pulumi.Input[str]] = None):
|
|
2135
|
+
account_id: pulumi.Input[builtins.str],
|
|
2136
|
+
personal_api_key: pulumi.Input[builtins.str],
|
|
2137
|
+
base_url_nerd_graph: Optional[pulumi.Input[builtins.str]] = None,
|
|
2138
|
+
base_url_rest: Optional[pulumi.Input[builtins.str]] = None,
|
|
2139
|
+
region: Optional[pulumi.Input[builtins.str]] = None):
|
|
2139
2140
|
"""
|
|
2140
|
-
:param pulumi.Input[str] personal_api_key: The NewRelic user key
|
|
2141
|
-
:param pulumi.Input[str] base_url_nerd_graph: The base URL for NerdGraph for a proxy.
|
|
2142
|
-
:param pulumi.Input[str] base_url_rest: The base URL of the New Relic REST API for a proxy.
|
|
2143
|
-
:param pulumi.Input[str] region: A region which the account is attached to. Default is "us".
|
|
2141
|
+
:param pulumi.Input[builtins.str] personal_api_key: The NewRelic user key
|
|
2142
|
+
:param pulumi.Input[builtins.str] base_url_nerd_graph: The base URL for NerdGraph for a proxy.
|
|
2143
|
+
:param pulumi.Input[builtins.str] base_url_rest: The base URL of the New Relic REST API for a proxy.
|
|
2144
|
+
:param pulumi.Input[builtins.str] region: A region which the account is attached to. Default is "us".
|
|
2144
2145
|
"""
|
|
2145
2146
|
pulumi.set(__self__, "account_id", account_id)
|
|
2146
2147
|
pulumi.set(__self__, "personal_api_key", personal_api_key)
|
|
@@ -2153,65 +2154,65 @@ class VerificationProviderNewRelicArgs:
|
|
|
2153
2154
|
|
|
2154
2155
|
@property
|
|
2155
2156
|
@pulumi.getter(name="accountId")
|
|
2156
|
-
def account_id(self) -> pulumi.Input[str]:
|
|
2157
|
+
def account_id(self) -> pulumi.Input[builtins.str]:
|
|
2157
2158
|
return pulumi.get(self, "account_id")
|
|
2158
2159
|
|
|
2159
2160
|
@account_id.setter
|
|
2160
|
-
def account_id(self, value: pulumi.Input[str]):
|
|
2161
|
+
def account_id(self, value: pulumi.Input[builtins.str]):
|
|
2161
2162
|
pulumi.set(self, "account_id", value)
|
|
2162
2163
|
|
|
2163
2164
|
@property
|
|
2164
2165
|
@pulumi.getter(name="personalApiKey")
|
|
2165
|
-
def personal_api_key(self) -> pulumi.Input[str]:
|
|
2166
|
+
def personal_api_key(self) -> pulumi.Input[builtins.str]:
|
|
2166
2167
|
"""
|
|
2167
2168
|
The NewRelic user key
|
|
2168
2169
|
"""
|
|
2169
2170
|
return pulumi.get(self, "personal_api_key")
|
|
2170
2171
|
|
|
2171
2172
|
@personal_api_key.setter
|
|
2172
|
-
def personal_api_key(self, value: pulumi.Input[str]):
|
|
2173
|
+
def personal_api_key(self, value: pulumi.Input[builtins.str]):
|
|
2173
2174
|
pulumi.set(self, "personal_api_key", value)
|
|
2174
2175
|
|
|
2175
2176
|
@property
|
|
2176
2177
|
@pulumi.getter(name="baseUrlNerdGraph")
|
|
2177
|
-
def base_url_nerd_graph(self) -> Optional[pulumi.Input[str]]:
|
|
2178
|
+
def base_url_nerd_graph(self) -> Optional[pulumi.Input[builtins.str]]:
|
|
2178
2179
|
"""
|
|
2179
2180
|
The base URL for NerdGraph for a proxy.
|
|
2180
2181
|
"""
|
|
2181
2182
|
return pulumi.get(self, "base_url_nerd_graph")
|
|
2182
2183
|
|
|
2183
2184
|
@base_url_nerd_graph.setter
|
|
2184
|
-
def base_url_nerd_graph(self, value: Optional[pulumi.Input[str]]):
|
|
2185
|
+
def base_url_nerd_graph(self, value: Optional[pulumi.Input[builtins.str]]):
|
|
2185
2186
|
pulumi.set(self, "base_url_nerd_graph", value)
|
|
2186
2187
|
|
|
2187
2188
|
@property
|
|
2188
2189
|
@pulumi.getter(name="baseUrlRest")
|
|
2189
|
-
def base_url_rest(self) -> Optional[pulumi.Input[str]]:
|
|
2190
|
+
def base_url_rest(self) -> Optional[pulumi.Input[builtins.str]]:
|
|
2190
2191
|
"""
|
|
2191
2192
|
The base URL of the New Relic REST API for a proxy.
|
|
2192
2193
|
"""
|
|
2193
2194
|
return pulumi.get(self, "base_url_rest")
|
|
2194
2195
|
|
|
2195
2196
|
@base_url_rest.setter
|
|
2196
|
-
def base_url_rest(self, value: Optional[pulumi.Input[str]]):
|
|
2197
|
+
def base_url_rest(self, value: Optional[pulumi.Input[builtins.str]]):
|
|
2197
2198
|
pulumi.set(self, "base_url_rest", value)
|
|
2198
2199
|
|
|
2199
2200
|
@property
|
|
2200
2201
|
@pulumi.getter
|
|
2201
|
-
def region(self) -> Optional[pulumi.Input[str]]:
|
|
2202
|
+
def region(self) -> Optional[pulumi.Input[builtins.str]]:
|
|
2202
2203
|
"""
|
|
2203
2204
|
A region which the account is attached to. Default is "us".
|
|
2204
2205
|
"""
|
|
2205
2206
|
return pulumi.get(self, "region")
|
|
2206
2207
|
|
|
2207
2208
|
@region.setter
|
|
2208
|
-
def region(self, value: Optional[pulumi.Input[str]]):
|
|
2209
|
+
def region(self, value: Optional[pulumi.Input[builtins.str]]):
|
|
2209
2210
|
pulumi.set(self, "region", value)
|
|
2210
2211
|
|
|
2211
2212
|
|
|
2212
2213
|
if not MYPY:
|
|
2213
2214
|
class VerificationProviderPrometheusArgsDict(TypedDict):
|
|
2214
|
-
address: pulumi.Input[str]
|
|
2215
|
+
address: pulumi.Input[builtins.str]
|
|
2215
2216
|
"""
|
|
2216
2217
|
The address which the Prometheus server available on.
|
|
2217
2218
|
"""
|
|
@@ -2221,32 +2222,32 @@ elif False:
|
|
|
2221
2222
|
@pulumi.input_type
|
|
2222
2223
|
class VerificationProviderPrometheusArgs:
|
|
2223
2224
|
def __init__(__self__, *,
|
|
2224
|
-
address: pulumi.Input[str]):
|
|
2225
|
+
address: pulumi.Input[builtins.str]):
|
|
2225
2226
|
"""
|
|
2226
|
-
:param pulumi.Input[str] address: The address which the Prometheus server available on.
|
|
2227
|
+
:param pulumi.Input[builtins.str] address: The address which the Prometheus server available on.
|
|
2227
2228
|
"""
|
|
2228
2229
|
pulumi.set(__self__, "address", address)
|
|
2229
2230
|
|
|
2230
2231
|
@property
|
|
2231
2232
|
@pulumi.getter
|
|
2232
|
-
def address(self) -> pulumi.Input[str]:
|
|
2233
|
+
def address(self) -> pulumi.Input[builtins.str]:
|
|
2233
2234
|
"""
|
|
2234
2235
|
The address which the Prometheus server available on.
|
|
2235
2236
|
"""
|
|
2236
2237
|
return pulumi.get(self, "address")
|
|
2237
2238
|
|
|
2238
2239
|
@address.setter
|
|
2239
|
-
def address(self, value: pulumi.Input[str]):
|
|
2240
|
+
def address(self, value: pulumi.Input[builtins.str]):
|
|
2240
2241
|
pulumi.set(self, "address", value)
|
|
2241
2242
|
|
|
2242
2243
|
|
|
2243
2244
|
if not MYPY:
|
|
2244
2245
|
class VerificationTemplateArgArgsDict(TypedDict):
|
|
2245
|
-
arg_name: pulumi.Input[str]
|
|
2246
|
+
arg_name: pulumi.Input[builtins.str]
|
|
2246
2247
|
"""
|
|
2247
2248
|
Name of an argument.
|
|
2248
2249
|
"""
|
|
2249
|
-
value: NotRequired[pulumi.Input[str]]
|
|
2250
|
+
value: NotRequired[pulumi.Input[builtins.str]]
|
|
2250
2251
|
"""
|
|
2251
2252
|
String representation of data.
|
|
2252
2253
|
"""
|
|
@@ -2260,12 +2261,12 @@ elif False:
|
|
|
2260
2261
|
@pulumi.input_type
|
|
2261
2262
|
class VerificationTemplateArgArgs:
|
|
2262
2263
|
def __init__(__self__, *,
|
|
2263
|
-
arg_name: pulumi.Input[str],
|
|
2264
|
-
value: Optional[pulumi.Input[str]] = None,
|
|
2264
|
+
arg_name: pulumi.Input[builtins.str],
|
|
2265
|
+
value: Optional[pulumi.Input[builtins.str]] = None,
|
|
2265
2266
|
value_from: Optional[pulumi.Input['VerificationTemplateArgValueFromArgs']] = None):
|
|
2266
2267
|
"""
|
|
2267
|
-
:param pulumi.Input[str] arg_name: Name of an argument.
|
|
2268
|
-
:param pulumi.Input[str] value: String representation of data.
|
|
2268
|
+
:param pulumi.Input[builtins.str] arg_name: Name of an argument.
|
|
2269
|
+
:param pulumi.Input[builtins.str] value: String representation of data.
|
|
2269
2270
|
:param pulumi.Input['VerificationTemplateArgValueFromArgs'] value_from: ValueFrom object.
|
|
2270
2271
|
"""
|
|
2271
2272
|
pulumi.set(__self__, "arg_name", arg_name)
|
|
@@ -2276,26 +2277,26 @@ class VerificationTemplateArgArgs:
|
|
|
2276
2277
|
|
|
2277
2278
|
@property
|
|
2278
2279
|
@pulumi.getter(name="argName")
|
|
2279
|
-
def arg_name(self) -> pulumi.Input[str]:
|
|
2280
|
+
def arg_name(self) -> pulumi.Input[builtins.str]:
|
|
2280
2281
|
"""
|
|
2281
2282
|
Name of an argument.
|
|
2282
2283
|
"""
|
|
2283
2284
|
return pulumi.get(self, "arg_name")
|
|
2284
2285
|
|
|
2285
2286
|
@arg_name.setter
|
|
2286
|
-
def arg_name(self, value: pulumi.Input[str]):
|
|
2287
|
+
def arg_name(self, value: pulumi.Input[builtins.str]):
|
|
2287
2288
|
pulumi.set(self, "arg_name", value)
|
|
2288
2289
|
|
|
2289
2290
|
@property
|
|
2290
2291
|
@pulumi.getter
|
|
2291
|
-
def value(self) -> Optional[pulumi.Input[str]]:
|
|
2292
|
+
def value(self) -> Optional[pulumi.Input[builtins.str]]:
|
|
2292
2293
|
"""
|
|
2293
2294
|
String representation of data.
|
|
2294
2295
|
"""
|
|
2295
2296
|
return pulumi.get(self, "value")
|
|
2296
2297
|
|
|
2297
2298
|
@value.setter
|
|
2298
|
-
def value(self, value: Optional[pulumi.Input[str]]):
|
|
2299
|
+
def value(self, value: Optional[pulumi.Input[builtins.str]]):
|
|
2299
2300
|
pulumi.set(self, "value", value)
|
|
2300
2301
|
|
|
2301
2302
|
@property
|
|
@@ -2345,11 +2346,11 @@ class VerificationTemplateArgValueFromArgs:
|
|
|
2345
2346
|
|
|
2346
2347
|
if not MYPY:
|
|
2347
2348
|
class VerificationTemplateArgValueFromSecretKeyRefArgsDict(TypedDict):
|
|
2348
|
-
key: pulumi.Input[str]
|
|
2349
|
+
key: pulumi.Input[builtins.str]
|
|
2349
2350
|
"""
|
|
2350
2351
|
The name of the field inside the secret.
|
|
2351
2352
|
"""
|
|
2352
|
-
name: pulumi.Input[str]
|
|
2353
|
+
name: pulumi.Input[builtins.str]
|
|
2353
2354
|
"""
|
|
2354
2355
|
The name of the secret.
|
|
2355
2356
|
"""
|
|
@@ -2359,43 +2360,43 @@ elif False:
|
|
|
2359
2360
|
@pulumi.input_type
|
|
2360
2361
|
class VerificationTemplateArgValueFromSecretKeyRefArgs:
|
|
2361
2362
|
def __init__(__self__, *,
|
|
2362
|
-
key: pulumi.Input[str],
|
|
2363
|
-
name: pulumi.Input[str]):
|
|
2363
|
+
key: pulumi.Input[builtins.str],
|
|
2364
|
+
name: pulumi.Input[builtins.str]):
|
|
2364
2365
|
"""
|
|
2365
|
-
:param pulumi.Input[str] key: The name of the field inside the secret.
|
|
2366
|
-
:param pulumi.Input[str] name: The name of the secret.
|
|
2366
|
+
:param pulumi.Input[builtins.str] key: The name of the field inside the secret.
|
|
2367
|
+
:param pulumi.Input[builtins.str] name: The name of the secret.
|
|
2367
2368
|
"""
|
|
2368
2369
|
pulumi.set(__self__, "key", key)
|
|
2369
2370
|
pulumi.set(__self__, "name", name)
|
|
2370
2371
|
|
|
2371
2372
|
@property
|
|
2372
2373
|
@pulumi.getter
|
|
2373
|
-
def key(self) -> pulumi.Input[str]:
|
|
2374
|
+
def key(self) -> pulumi.Input[builtins.str]:
|
|
2374
2375
|
"""
|
|
2375
2376
|
The name of the field inside the secret.
|
|
2376
2377
|
"""
|
|
2377
2378
|
return pulumi.get(self, "key")
|
|
2378
2379
|
|
|
2379
2380
|
@key.setter
|
|
2380
|
-
def key(self, value: pulumi.Input[str]):
|
|
2381
|
+
def key(self, value: pulumi.Input[builtins.str]):
|
|
2381
2382
|
pulumi.set(self, "key", value)
|
|
2382
2383
|
|
|
2383
2384
|
@property
|
|
2384
2385
|
@pulumi.getter
|
|
2385
|
-
def name(self) -> pulumi.Input[str]:
|
|
2386
|
+
def name(self) -> pulumi.Input[builtins.str]:
|
|
2386
2387
|
"""
|
|
2387
2388
|
The name of the secret.
|
|
2388
2389
|
"""
|
|
2389
2390
|
return pulumi.get(self, "name")
|
|
2390
2391
|
|
|
2391
2392
|
@name.setter
|
|
2392
|
-
def name(self, value: pulumi.Input[str]):
|
|
2393
|
+
def name(self, value: pulumi.Input[builtins.str]):
|
|
2393
2394
|
pulumi.set(self, "name", value)
|
|
2394
2395
|
|
|
2395
2396
|
|
|
2396
2397
|
if not MYPY:
|
|
2397
2398
|
class VerificationTemplateMetricArgsDict(TypedDict):
|
|
2398
|
-
metrics_name: pulumi.Input[str]
|
|
2399
|
+
metrics_name: pulumi.Input[builtins.str]
|
|
2399
2400
|
"""
|
|
2400
2401
|
The name of the verification metric.
|
|
2401
2402
|
"""
|
|
@@ -2407,35 +2408,35 @@ if not MYPY:
|
|
|
2407
2408
|
"""
|
|
2408
2409
|
Baseline Object.
|
|
2409
2410
|
"""
|
|
2410
|
-
consecutive_error_limit: NotRequired[pulumi.Input[int]]
|
|
2411
|
+
consecutive_error_limit: NotRequired[pulumi.Input[builtins.int]]
|
|
2411
2412
|
"""
|
|
2412
2413
|
The maximum number of times the measurement is allowed to error in succession, before the metric is considered error.Default is 4.When choosing `Jenkins` as the provider, there is no need to send this variable.
|
|
2413
2414
|
"""
|
|
2414
|
-
count: NotRequired[pulumi.Input[int]]
|
|
2415
|
+
count: NotRequired[pulumi.Input[builtins.int]]
|
|
2415
2416
|
"""
|
|
2416
2417
|
The number of times to run the measurement. If both interval and count are omitted, the effective count is 1. If only interval is specified, metric runs indefinitely. If count > 1, interval must be specified. When choosing `Jenkins` as the provider, there is no need to send this variable.
|
|
2417
2418
|
"""
|
|
2418
|
-
dry_run: NotRequired[pulumi.Input[bool]]
|
|
2419
|
+
dry_run: NotRequired[pulumi.Input[builtins.bool]]
|
|
2419
2420
|
"""
|
|
2420
2421
|
Defines whether the metric should have an impact on the result of the rollout.
|
|
2421
2422
|
"""
|
|
2422
|
-
failure_condition: NotRequired[pulumi.Input[str]]
|
|
2423
|
+
failure_condition: NotRequired[pulumi.Input[builtins.str]]
|
|
2423
2424
|
"""
|
|
2424
2425
|
An expression which determines if a measurement is considered failed.If failureCondition is set, then successCondition is not allowed. When choosing Jenkins as the provider, there is no need to send this variable.
|
|
2425
2426
|
"""
|
|
2426
|
-
failure_limit: NotRequired[pulumi.Input[int]]
|
|
2427
|
+
failure_limit: NotRequired[pulumi.Input[builtins.int]]
|
|
2427
2428
|
"""
|
|
2428
2429
|
The maximum number of times the measurement is allowed to fail, before the entire metric is considered failed.Default is 0. When choosing `Jenkins` as the provider, there is no need to send this variable.
|
|
2429
2430
|
"""
|
|
2430
|
-
initial_delay: NotRequired[pulumi.Input[str]]
|
|
2431
|
+
initial_delay: NotRequired[pulumi.Input[builtins.str]]
|
|
2431
2432
|
"""
|
|
2432
2433
|
How long to wait before starting this metric measurements. When choosing Jenkins as the provider, there is no need to send this variable.
|
|
2433
2434
|
"""
|
|
2434
|
-
interval: NotRequired[pulumi.Input[str]]
|
|
2435
|
+
interval: NotRequired[pulumi.Input[builtins.str]]
|
|
2435
2436
|
"""
|
|
2436
2437
|
Defines an interval string (30s, 5m, 1h) between each verification measurements. If omitted, will perform a single measurement.When choosing Jenkins as the provider, there is no need to send this variable.
|
|
2437
2438
|
"""
|
|
2438
|
-
success_condition: NotRequired[pulumi.Input[str]]
|
|
2439
|
+
success_condition: NotRequired[pulumi.Input[builtins.str]]
|
|
2439
2440
|
"""
|
|
2440
2441
|
An expression which determines if a measurement is considered successful. The keyword `result` is a variable reference to the value of measurement. Results can be both structured data or primitive. If successCondition is set, then failureCondition is not allowed. When choosing `Jenkins` as the provider, there is no need to send this variable.
|
|
2441
2442
|
"""
|
|
@@ -2445,29 +2446,29 @@ elif False:
|
|
|
2445
2446
|
@pulumi.input_type
|
|
2446
2447
|
class VerificationTemplateMetricArgs:
|
|
2447
2448
|
def __init__(__self__, *,
|
|
2448
|
-
metrics_name: pulumi.Input[str],
|
|
2449
|
+
metrics_name: pulumi.Input[builtins.str],
|
|
2449
2450
|
providers: pulumi.Input[Sequence[pulumi.Input['VerificationTemplateMetricProviderArgs']]],
|
|
2450
2451
|
baseline: Optional[pulumi.Input['VerificationTemplateMetricBaselineArgs']] = None,
|
|
2451
|
-
consecutive_error_limit: Optional[pulumi.Input[int]] = None,
|
|
2452
|
-
count: Optional[pulumi.Input[int]] = None,
|
|
2453
|
-
dry_run: Optional[pulumi.Input[bool]] = None,
|
|
2454
|
-
failure_condition: Optional[pulumi.Input[str]] = None,
|
|
2455
|
-
failure_limit: Optional[pulumi.Input[int]] = None,
|
|
2456
|
-
initial_delay: Optional[pulumi.Input[str]] = None,
|
|
2457
|
-
interval: Optional[pulumi.Input[str]] = None,
|
|
2458
|
-
success_condition: Optional[pulumi.Input[str]] = None):
|
|
2459
|
-
"""
|
|
2460
|
-
:param pulumi.Input[str] metrics_name: The name of the verification metric.
|
|
2452
|
+
consecutive_error_limit: Optional[pulumi.Input[builtins.int]] = None,
|
|
2453
|
+
count: Optional[pulumi.Input[builtins.int]] = None,
|
|
2454
|
+
dry_run: Optional[pulumi.Input[builtins.bool]] = None,
|
|
2455
|
+
failure_condition: Optional[pulumi.Input[builtins.str]] = None,
|
|
2456
|
+
failure_limit: Optional[pulumi.Input[builtins.int]] = None,
|
|
2457
|
+
initial_delay: Optional[pulumi.Input[builtins.str]] = None,
|
|
2458
|
+
interval: Optional[pulumi.Input[builtins.str]] = None,
|
|
2459
|
+
success_condition: Optional[pulumi.Input[builtins.str]] = None):
|
|
2460
|
+
"""
|
|
2461
|
+
:param pulumi.Input[builtins.str] metrics_name: The name of the verification metric.
|
|
2461
2462
|
:param pulumi.Input[Sequence[pulumi.Input['VerificationTemplateMetricProviderArgs']]] providers: The name of the monitoring tool chosen for the metric.
|
|
2462
2463
|
:param pulumi.Input['VerificationTemplateMetricBaselineArgs'] baseline: Baseline Object.
|
|
2463
|
-
:param pulumi.Input[int] consecutive_error_limit: The maximum number of times the measurement is allowed to error in succession, before the metric is considered error.Default is 4.When choosing `Jenkins` as the provider, there is no need to send this variable.
|
|
2464
|
-
:param pulumi.Input[int] count: The number of times to run the measurement. If both interval and count are omitted, the effective count is 1. If only interval is specified, metric runs indefinitely. If count > 1, interval must be specified. When choosing `Jenkins` as the provider, there is no need to send this variable.
|
|
2465
|
-
:param pulumi.Input[bool] dry_run: Defines whether the metric should have an impact on the result of the rollout.
|
|
2466
|
-
:param pulumi.Input[str] failure_condition: An expression which determines if a measurement is considered failed.If failureCondition is set, then successCondition is not allowed. When choosing Jenkins as the provider, there is no need to send this variable.
|
|
2467
|
-
:param pulumi.Input[int] failure_limit: The maximum number of times the measurement is allowed to fail, before the entire metric is considered failed.Default is 0. When choosing `Jenkins` as the provider, there is no need to send this variable.
|
|
2468
|
-
:param pulumi.Input[str] initial_delay: How long to wait before starting this metric measurements. When choosing Jenkins as the provider, there is no need to send this variable.
|
|
2469
|
-
:param pulumi.Input[str] interval: Defines an interval string (30s, 5m, 1h) between each verification measurements. If omitted, will perform a single measurement.When choosing Jenkins as the provider, there is no need to send this variable.
|
|
2470
|
-
:param pulumi.Input[str] success_condition: An expression which determines if a measurement is considered successful. The keyword `result` is a variable reference to the value of measurement. Results can be both structured data or primitive. If successCondition is set, then failureCondition is not allowed. When choosing `Jenkins` as the provider, there is no need to send this variable.
|
|
2464
|
+
:param pulumi.Input[builtins.int] consecutive_error_limit: The maximum number of times the measurement is allowed to error in succession, before the metric is considered error.Default is 4.When choosing `Jenkins` as the provider, there is no need to send this variable.
|
|
2465
|
+
:param pulumi.Input[builtins.int] count: The number of times to run the measurement. If both interval and count are omitted, the effective count is 1. If only interval is specified, metric runs indefinitely. If count > 1, interval must be specified. When choosing `Jenkins` as the provider, there is no need to send this variable.
|
|
2466
|
+
:param pulumi.Input[builtins.bool] dry_run: Defines whether the metric should have an impact on the result of the rollout.
|
|
2467
|
+
:param pulumi.Input[builtins.str] failure_condition: An expression which determines if a measurement is considered failed.If failureCondition is set, then successCondition is not allowed. When choosing Jenkins as the provider, there is no need to send this variable.
|
|
2468
|
+
:param pulumi.Input[builtins.int] failure_limit: The maximum number of times the measurement is allowed to fail, before the entire metric is considered failed.Default is 0. When choosing `Jenkins` as the provider, there is no need to send this variable.
|
|
2469
|
+
:param pulumi.Input[builtins.str] initial_delay: How long to wait before starting this metric measurements. When choosing Jenkins as the provider, there is no need to send this variable.
|
|
2470
|
+
:param pulumi.Input[builtins.str] interval: Defines an interval string (30s, 5m, 1h) between each verification measurements. If omitted, will perform a single measurement.When choosing Jenkins as the provider, there is no need to send this variable.
|
|
2471
|
+
:param pulumi.Input[builtins.str] success_condition: An expression which determines if a measurement is considered successful. The keyword `result` is a variable reference to the value of measurement. Results can be both structured data or primitive. If successCondition is set, then failureCondition is not allowed. When choosing `Jenkins` as the provider, there is no need to send this variable.
|
|
2471
2472
|
"""
|
|
2472
2473
|
pulumi.set(__self__, "metrics_name", metrics_name)
|
|
2473
2474
|
pulumi.set(__self__, "providers", providers)
|
|
@@ -2492,14 +2493,14 @@ class VerificationTemplateMetricArgs:
|
|
|
2492
2493
|
|
|
2493
2494
|
@property
|
|
2494
2495
|
@pulumi.getter(name="metricsName")
|
|
2495
|
-
def metrics_name(self) -> pulumi.Input[str]:
|
|
2496
|
+
def metrics_name(self) -> pulumi.Input[builtins.str]:
|
|
2496
2497
|
"""
|
|
2497
2498
|
The name of the verification metric.
|
|
2498
2499
|
"""
|
|
2499
2500
|
return pulumi.get(self, "metrics_name")
|
|
2500
2501
|
|
|
2501
2502
|
@metrics_name.setter
|
|
2502
|
-
def metrics_name(self, value: pulumi.Input[str]):
|
|
2503
|
+
def metrics_name(self, value: pulumi.Input[builtins.str]):
|
|
2503
2504
|
pulumi.set(self, "metrics_name", value)
|
|
2504
2505
|
|
|
2505
2506
|
@property
|
|
@@ -2528,98 +2529,98 @@ class VerificationTemplateMetricArgs:
|
|
|
2528
2529
|
|
|
2529
2530
|
@property
|
|
2530
2531
|
@pulumi.getter(name="consecutiveErrorLimit")
|
|
2531
|
-
def consecutive_error_limit(self) -> Optional[pulumi.Input[int]]:
|
|
2532
|
+
def consecutive_error_limit(self) -> Optional[pulumi.Input[builtins.int]]:
|
|
2532
2533
|
"""
|
|
2533
2534
|
The maximum number of times the measurement is allowed to error in succession, before the metric is considered error.Default is 4.When choosing `Jenkins` as the provider, there is no need to send this variable.
|
|
2534
2535
|
"""
|
|
2535
2536
|
return pulumi.get(self, "consecutive_error_limit")
|
|
2536
2537
|
|
|
2537
2538
|
@consecutive_error_limit.setter
|
|
2538
|
-
def consecutive_error_limit(self, value: Optional[pulumi.Input[int]]):
|
|
2539
|
+
def consecutive_error_limit(self, value: Optional[pulumi.Input[builtins.int]]):
|
|
2539
2540
|
pulumi.set(self, "consecutive_error_limit", value)
|
|
2540
2541
|
|
|
2541
2542
|
@property
|
|
2542
2543
|
@pulumi.getter
|
|
2543
|
-
def count(self) -> Optional[pulumi.Input[int]]:
|
|
2544
|
+
def count(self) -> Optional[pulumi.Input[builtins.int]]:
|
|
2544
2545
|
"""
|
|
2545
2546
|
The number of times to run the measurement. If both interval and count are omitted, the effective count is 1. If only interval is specified, metric runs indefinitely. If count > 1, interval must be specified. When choosing `Jenkins` as the provider, there is no need to send this variable.
|
|
2546
2547
|
"""
|
|
2547
2548
|
return pulumi.get(self, "count")
|
|
2548
2549
|
|
|
2549
2550
|
@count.setter
|
|
2550
|
-
def count(self, value: Optional[pulumi.Input[int]]):
|
|
2551
|
+
def count(self, value: Optional[pulumi.Input[builtins.int]]):
|
|
2551
2552
|
pulumi.set(self, "count", value)
|
|
2552
2553
|
|
|
2553
2554
|
@property
|
|
2554
2555
|
@pulumi.getter(name="dryRun")
|
|
2555
|
-
def dry_run(self) -> Optional[pulumi.Input[bool]]:
|
|
2556
|
+
def dry_run(self) -> Optional[pulumi.Input[builtins.bool]]:
|
|
2556
2557
|
"""
|
|
2557
2558
|
Defines whether the metric should have an impact on the result of the rollout.
|
|
2558
2559
|
"""
|
|
2559
2560
|
return pulumi.get(self, "dry_run")
|
|
2560
2561
|
|
|
2561
2562
|
@dry_run.setter
|
|
2562
|
-
def dry_run(self, value: Optional[pulumi.Input[bool]]):
|
|
2563
|
+
def dry_run(self, value: Optional[pulumi.Input[builtins.bool]]):
|
|
2563
2564
|
pulumi.set(self, "dry_run", value)
|
|
2564
2565
|
|
|
2565
2566
|
@property
|
|
2566
2567
|
@pulumi.getter(name="failureCondition")
|
|
2567
|
-
def failure_condition(self) -> Optional[pulumi.Input[str]]:
|
|
2568
|
+
def failure_condition(self) -> Optional[pulumi.Input[builtins.str]]:
|
|
2568
2569
|
"""
|
|
2569
2570
|
An expression which determines if a measurement is considered failed.If failureCondition is set, then successCondition is not allowed. When choosing Jenkins as the provider, there is no need to send this variable.
|
|
2570
2571
|
"""
|
|
2571
2572
|
return pulumi.get(self, "failure_condition")
|
|
2572
2573
|
|
|
2573
2574
|
@failure_condition.setter
|
|
2574
|
-
def failure_condition(self, value: Optional[pulumi.Input[str]]):
|
|
2575
|
+
def failure_condition(self, value: Optional[pulumi.Input[builtins.str]]):
|
|
2575
2576
|
pulumi.set(self, "failure_condition", value)
|
|
2576
2577
|
|
|
2577
2578
|
@property
|
|
2578
2579
|
@pulumi.getter(name="failureLimit")
|
|
2579
|
-
def failure_limit(self) -> Optional[pulumi.Input[int]]:
|
|
2580
|
+
def failure_limit(self) -> Optional[pulumi.Input[builtins.int]]:
|
|
2580
2581
|
"""
|
|
2581
2582
|
The maximum number of times the measurement is allowed to fail, before the entire metric is considered failed.Default is 0. When choosing `Jenkins` as the provider, there is no need to send this variable.
|
|
2582
2583
|
"""
|
|
2583
2584
|
return pulumi.get(self, "failure_limit")
|
|
2584
2585
|
|
|
2585
2586
|
@failure_limit.setter
|
|
2586
|
-
def failure_limit(self, value: Optional[pulumi.Input[int]]):
|
|
2587
|
+
def failure_limit(self, value: Optional[pulumi.Input[builtins.int]]):
|
|
2587
2588
|
pulumi.set(self, "failure_limit", value)
|
|
2588
2589
|
|
|
2589
2590
|
@property
|
|
2590
2591
|
@pulumi.getter(name="initialDelay")
|
|
2591
|
-
def initial_delay(self) -> Optional[pulumi.Input[str]]:
|
|
2592
|
+
def initial_delay(self) -> Optional[pulumi.Input[builtins.str]]:
|
|
2592
2593
|
"""
|
|
2593
2594
|
How long to wait before starting this metric measurements. When choosing Jenkins as the provider, there is no need to send this variable.
|
|
2594
2595
|
"""
|
|
2595
2596
|
return pulumi.get(self, "initial_delay")
|
|
2596
2597
|
|
|
2597
2598
|
@initial_delay.setter
|
|
2598
|
-
def initial_delay(self, value: Optional[pulumi.Input[str]]):
|
|
2599
|
+
def initial_delay(self, value: Optional[pulumi.Input[builtins.str]]):
|
|
2599
2600
|
pulumi.set(self, "initial_delay", value)
|
|
2600
2601
|
|
|
2601
2602
|
@property
|
|
2602
2603
|
@pulumi.getter
|
|
2603
|
-
def interval(self) -> Optional[pulumi.Input[str]]:
|
|
2604
|
+
def interval(self) -> Optional[pulumi.Input[builtins.str]]:
|
|
2604
2605
|
"""
|
|
2605
2606
|
Defines an interval string (30s, 5m, 1h) between each verification measurements. If omitted, will perform a single measurement.When choosing Jenkins as the provider, there is no need to send this variable.
|
|
2606
2607
|
"""
|
|
2607
2608
|
return pulumi.get(self, "interval")
|
|
2608
2609
|
|
|
2609
2610
|
@interval.setter
|
|
2610
|
-
def interval(self, value: Optional[pulumi.Input[str]]):
|
|
2611
|
+
def interval(self, value: Optional[pulumi.Input[builtins.str]]):
|
|
2611
2612
|
pulumi.set(self, "interval", value)
|
|
2612
2613
|
|
|
2613
2614
|
@property
|
|
2614
2615
|
@pulumi.getter(name="successCondition")
|
|
2615
|
-
def success_condition(self) -> Optional[pulumi.Input[str]]:
|
|
2616
|
+
def success_condition(self) -> Optional[pulumi.Input[builtins.str]]:
|
|
2616
2617
|
"""
|
|
2617
2618
|
An expression which determines if a measurement is considered successful. The keyword `result` is a variable reference to the value of measurement. Results can be both structured data or primitive. If successCondition is set, then failureCondition is not allowed. When choosing `Jenkins` as the provider, there is no need to send this variable.
|
|
2618
2619
|
"""
|
|
2619
2620
|
return pulumi.get(self, "success_condition")
|
|
2620
2621
|
|
|
2621
2622
|
@success_condition.setter
|
|
2622
|
-
def success_condition(self, value: Optional[pulumi.Input[str]]):
|
|
2623
|
+
def success_condition(self, value: Optional[pulumi.Input[builtins.str]]):
|
|
2623
2624
|
pulumi.set(self, "success_condition", value)
|
|
2624
2625
|
|
|
2625
2626
|
|
|
@@ -2629,15 +2630,15 @@ if not MYPY:
|
|
|
2629
2630
|
"""
|
|
2630
2631
|
The name of the monitoring tool chosen for the metric.
|
|
2631
2632
|
"""
|
|
2632
|
-
threshold: pulumi.Input[str]
|
|
2633
|
+
threshold: pulumi.Input[builtins.str]
|
|
2633
2634
|
"""
|
|
2634
2635
|
A mathematical expression needed for the comparison. Enum: "<" ">" "<=" ">=" "=" "range"
|
|
2635
2636
|
"""
|
|
2636
|
-
max_range: NotRequired[pulumi.Input[int]]
|
|
2637
|
+
max_range: NotRequired[pulumi.Input[builtins.int]]
|
|
2637
2638
|
"""
|
|
2638
2639
|
Number in percent we allow the new version’s data result to be under baseline data result.
|
|
2639
2640
|
"""
|
|
2640
|
-
min_range: NotRequired[pulumi.Input[int]]
|
|
2641
|
+
min_range: NotRequired[pulumi.Input[builtins.int]]
|
|
2641
2642
|
"""
|
|
2642
2643
|
Number in percent we allow the new version’s data result to be under baseline data result.*
|
|
2643
2644
|
"""
|
|
@@ -2648,14 +2649,14 @@ elif False:
|
|
|
2648
2649
|
class VerificationTemplateMetricBaselineArgs:
|
|
2649
2650
|
def __init__(__self__, *,
|
|
2650
2651
|
baseline_providers: pulumi.Input[Sequence[pulumi.Input['VerificationTemplateMetricBaselineBaselineProviderArgs']]],
|
|
2651
|
-
threshold: pulumi.Input[str],
|
|
2652
|
-
max_range: Optional[pulumi.Input[int]] = None,
|
|
2653
|
-
min_range: Optional[pulumi.Input[int]] = None):
|
|
2652
|
+
threshold: pulumi.Input[builtins.str],
|
|
2653
|
+
max_range: Optional[pulumi.Input[builtins.int]] = None,
|
|
2654
|
+
min_range: Optional[pulumi.Input[builtins.int]] = None):
|
|
2654
2655
|
"""
|
|
2655
2656
|
:param pulumi.Input[Sequence[pulumi.Input['VerificationTemplateMetricBaselineBaselineProviderArgs']]] baseline_providers: The name of the monitoring tool chosen for the metric.
|
|
2656
|
-
:param pulumi.Input[str] threshold: A mathematical expression needed for the comparison. Enum: "<" ">" "<=" ">=" "=" "range"
|
|
2657
|
-
:param pulumi.Input[int] max_range: Number in percent we allow the new version’s data result to be under baseline data result.
|
|
2658
|
-
:param pulumi.Input[int] min_range: Number in percent we allow the new version’s data result to be under baseline data result.*
|
|
2657
|
+
:param pulumi.Input[builtins.str] threshold: A mathematical expression needed for the comparison. Enum: "<" ">" "<=" ">=" "=" "range"
|
|
2658
|
+
:param pulumi.Input[builtins.int] max_range: Number in percent we allow the new version’s data result to be under baseline data result.
|
|
2659
|
+
:param pulumi.Input[builtins.int] min_range: Number in percent we allow the new version’s data result to be under baseline data result.*
|
|
2659
2660
|
"""
|
|
2660
2661
|
pulumi.set(__self__, "baseline_providers", baseline_providers)
|
|
2661
2662
|
pulumi.set(__self__, "threshold", threshold)
|
|
@@ -2678,38 +2679,38 @@ class VerificationTemplateMetricBaselineArgs:
|
|
|
2678
2679
|
|
|
2679
2680
|
@property
|
|
2680
2681
|
@pulumi.getter
|
|
2681
|
-
def threshold(self) -> pulumi.Input[str]:
|
|
2682
|
+
def threshold(self) -> pulumi.Input[builtins.str]:
|
|
2682
2683
|
"""
|
|
2683
2684
|
A mathematical expression needed for the comparison. Enum: "<" ">" "<=" ">=" "=" "range"
|
|
2684
2685
|
"""
|
|
2685
2686
|
return pulumi.get(self, "threshold")
|
|
2686
2687
|
|
|
2687
2688
|
@threshold.setter
|
|
2688
|
-
def threshold(self, value: pulumi.Input[str]):
|
|
2689
|
+
def threshold(self, value: pulumi.Input[builtins.str]):
|
|
2689
2690
|
pulumi.set(self, "threshold", value)
|
|
2690
2691
|
|
|
2691
2692
|
@property
|
|
2692
2693
|
@pulumi.getter(name="maxRange")
|
|
2693
|
-
def max_range(self) -> Optional[pulumi.Input[int]]:
|
|
2694
|
+
def max_range(self) -> Optional[pulumi.Input[builtins.int]]:
|
|
2694
2695
|
"""
|
|
2695
2696
|
Number in percent we allow the new version’s data result to be under baseline data result.
|
|
2696
2697
|
"""
|
|
2697
2698
|
return pulumi.get(self, "max_range")
|
|
2698
2699
|
|
|
2699
2700
|
@max_range.setter
|
|
2700
|
-
def max_range(self, value: Optional[pulumi.Input[int]]):
|
|
2701
|
+
def max_range(self, value: Optional[pulumi.Input[builtins.int]]):
|
|
2701
2702
|
pulumi.set(self, "max_range", value)
|
|
2702
2703
|
|
|
2703
2704
|
@property
|
|
2704
2705
|
@pulumi.getter(name="minRange")
|
|
2705
|
-
def min_range(self) -> Optional[pulumi.Input[int]]:
|
|
2706
|
+
def min_range(self) -> Optional[pulumi.Input[builtins.int]]:
|
|
2706
2707
|
"""
|
|
2707
2708
|
Number in percent we allow the new version’s data result to be under baseline data result.*
|
|
2708
2709
|
"""
|
|
2709
2710
|
return pulumi.get(self, "min_range")
|
|
2710
2711
|
|
|
2711
2712
|
@min_range.setter
|
|
2712
|
-
def min_range(self, value: Optional[pulumi.Input[int]]):
|
|
2713
|
+
def min_range(self, value: Optional[pulumi.Input[builtins.int]]):
|
|
2713
2714
|
pulumi.set(self, "min_range", value)
|
|
2714
2715
|
|
|
2715
2716
|
|
|
@@ -2787,11 +2788,11 @@ class VerificationTemplateMetricBaselineBaselineProviderArgs:
|
|
|
2787
2788
|
|
|
2788
2789
|
if not MYPY:
|
|
2789
2790
|
class VerificationTemplateMetricBaselineBaselineProviderDatadogArgsDict(TypedDict):
|
|
2790
|
-
datadog_query: pulumi.Input[str]
|
|
2791
|
+
datadog_query: pulumi.Input[builtins.str]
|
|
2791
2792
|
"""
|
|
2792
2793
|
A request for information retrieved from Datadog.
|
|
2793
2794
|
"""
|
|
2794
|
-
duration: NotRequired[pulumi.Input[str]]
|
|
2795
|
+
duration: NotRequired[pulumi.Input[builtins.str]]
|
|
2795
2796
|
"""
|
|
2796
2797
|
The window of time we are looking at in DataDog.
|
|
2797
2798
|
"""
|
|
@@ -2801,11 +2802,11 @@ elif False:
|
|
|
2801
2802
|
@pulumi.input_type
|
|
2802
2803
|
class VerificationTemplateMetricBaselineBaselineProviderDatadogArgs:
|
|
2803
2804
|
def __init__(__self__, *,
|
|
2804
|
-
datadog_query: pulumi.Input[str],
|
|
2805
|
-
duration: Optional[pulumi.Input[str]] = None):
|
|
2805
|
+
datadog_query: pulumi.Input[builtins.str],
|
|
2806
|
+
duration: Optional[pulumi.Input[builtins.str]] = None):
|
|
2806
2807
|
"""
|
|
2807
|
-
:param pulumi.Input[str] datadog_query: A request for information retrieved from Datadog.
|
|
2808
|
-
:param pulumi.Input[str] duration: The window of time we are looking at in DataDog.
|
|
2808
|
+
:param pulumi.Input[builtins.str] datadog_query: A request for information retrieved from Datadog.
|
|
2809
|
+
:param pulumi.Input[builtins.str] duration: The window of time we are looking at in DataDog.
|
|
2809
2810
|
"""
|
|
2810
2811
|
pulumi.set(__self__, "datadog_query", datadog_query)
|
|
2811
2812
|
if duration is not None:
|
|
@@ -2813,36 +2814,36 @@ class VerificationTemplateMetricBaselineBaselineProviderDatadogArgs:
|
|
|
2813
2814
|
|
|
2814
2815
|
@property
|
|
2815
2816
|
@pulumi.getter(name="datadogQuery")
|
|
2816
|
-
def datadog_query(self) -> pulumi.Input[str]:
|
|
2817
|
+
def datadog_query(self) -> pulumi.Input[builtins.str]:
|
|
2817
2818
|
"""
|
|
2818
2819
|
A request for information retrieved from Datadog.
|
|
2819
2820
|
"""
|
|
2820
2821
|
return pulumi.get(self, "datadog_query")
|
|
2821
2822
|
|
|
2822
2823
|
@datadog_query.setter
|
|
2823
|
-
def datadog_query(self, value: pulumi.Input[str]):
|
|
2824
|
+
def datadog_query(self, value: pulumi.Input[builtins.str]):
|
|
2824
2825
|
pulumi.set(self, "datadog_query", value)
|
|
2825
2826
|
|
|
2826
2827
|
@property
|
|
2827
2828
|
@pulumi.getter
|
|
2828
|
-
def duration(self) -> Optional[pulumi.Input[str]]:
|
|
2829
|
+
def duration(self) -> Optional[pulumi.Input[builtins.str]]:
|
|
2829
2830
|
"""
|
|
2830
2831
|
The window of time we are looking at in DataDog.
|
|
2831
2832
|
"""
|
|
2832
2833
|
return pulumi.get(self, "duration")
|
|
2833
2834
|
|
|
2834
2835
|
@duration.setter
|
|
2835
|
-
def duration(self, value: Optional[pulumi.Input[str]]):
|
|
2836
|
+
def duration(self, value: Optional[pulumi.Input[builtins.str]]):
|
|
2836
2837
|
pulumi.set(self, "duration", value)
|
|
2837
2838
|
|
|
2838
2839
|
|
|
2839
2840
|
if not MYPY:
|
|
2840
2841
|
class VerificationTemplateMetricBaselineBaselineProviderNewRelicArgsDict(TypedDict):
|
|
2841
|
-
new_relic_query: pulumi.Input[str]
|
|
2842
|
+
new_relic_query: pulumi.Input[builtins.str]
|
|
2842
2843
|
"""
|
|
2843
2844
|
A raw newrelic NRQL query to perform.
|
|
2844
2845
|
"""
|
|
2845
|
-
profile: NotRequired[pulumi.Input[str]]
|
|
2846
|
+
profile: NotRequired[pulumi.Input[builtins.str]]
|
|
2846
2847
|
"""
|
|
2847
2848
|
The name of the secret holding NR account configuration.
|
|
2848
2849
|
"""
|
|
@@ -2852,11 +2853,11 @@ elif False:
|
|
|
2852
2853
|
@pulumi.input_type
|
|
2853
2854
|
class VerificationTemplateMetricBaselineBaselineProviderNewRelicArgs:
|
|
2854
2855
|
def __init__(__self__, *,
|
|
2855
|
-
new_relic_query: pulumi.Input[str],
|
|
2856
|
-
profile: Optional[pulumi.Input[str]] = None):
|
|
2856
|
+
new_relic_query: pulumi.Input[builtins.str],
|
|
2857
|
+
profile: Optional[pulumi.Input[builtins.str]] = None):
|
|
2857
2858
|
"""
|
|
2858
|
-
:param pulumi.Input[str] new_relic_query: A raw newrelic NRQL query to perform.
|
|
2859
|
-
:param pulumi.Input[str] profile: The name of the secret holding NR account configuration.
|
|
2859
|
+
:param pulumi.Input[builtins.str] new_relic_query: A raw newrelic NRQL query to perform.
|
|
2860
|
+
:param pulumi.Input[builtins.str] profile: The name of the secret holding NR account configuration.
|
|
2860
2861
|
"""
|
|
2861
2862
|
pulumi.set(__self__, "new_relic_query", new_relic_query)
|
|
2862
2863
|
if profile is not None:
|
|
@@ -2864,32 +2865,32 @@ class VerificationTemplateMetricBaselineBaselineProviderNewRelicArgs:
|
|
|
2864
2865
|
|
|
2865
2866
|
@property
|
|
2866
2867
|
@pulumi.getter(name="newRelicQuery")
|
|
2867
|
-
def new_relic_query(self) -> pulumi.Input[str]:
|
|
2868
|
+
def new_relic_query(self) -> pulumi.Input[builtins.str]:
|
|
2868
2869
|
"""
|
|
2869
2870
|
A raw newrelic NRQL query to perform.
|
|
2870
2871
|
"""
|
|
2871
2872
|
return pulumi.get(self, "new_relic_query")
|
|
2872
2873
|
|
|
2873
2874
|
@new_relic_query.setter
|
|
2874
|
-
def new_relic_query(self, value: pulumi.Input[str]):
|
|
2875
|
+
def new_relic_query(self, value: pulumi.Input[builtins.str]):
|
|
2875
2876
|
pulumi.set(self, "new_relic_query", value)
|
|
2876
2877
|
|
|
2877
2878
|
@property
|
|
2878
2879
|
@pulumi.getter
|
|
2879
|
-
def profile(self) -> Optional[pulumi.Input[str]]:
|
|
2880
|
+
def profile(self) -> Optional[pulumi.Input[builtins.str]]:
|
|
2880
2881
|
"""
|
|
2881
2882
|
The name of the secret holding NR account configuration.
|
|
2882
2883
|
"""
|
|
2883
2884
|
return pulumi.get(self, "profile")
|
|
2884
2885
|
|
|
2885
2886
|
@profile.setter
|
|
2886
|
-
def profile(self, value: Optional[pulumi.Input[str]]):
|
|
2887
|
+
def profile(self, value: Optional[pulumi.Input[builtins.str]]):
|
|
2887
2888
|
pulumi.set(self, "profile", value)
|
|
2888
2889
|
|
|
2889
2890
|
|
|
2890
2891
|
if not MYPY:
|
|
2891
2892
|
class VerificationTemplateMetricBaselineBaselineProviderPrometheusArgsDict(TypedDict):
|
|
2892
|
-
prometheus_query: pulumi.Input[str]
|
|
2893
|
+
prometheus_query: pulumi.Input[builtins.str]
|
|
2893
2894
|
"""
|
|
2894
2895
|
A request for information retrieved from Prometheus.
|
|
2895
2896
|
"""
|
|
@@ -2899,22 +2900,22 @@ elif False:
|
|
|
2899
2900
|
@pulumi.input_type
|
|
2900
2901
|
class VerificationTemplateMetricBaselineBaselineProviderPrometheusArgs:
|
|
2901
2902
|
def __init__(__self__, *,
|
|
2902
|
-
prometheus_query: pulumi.Input[str]):
|
|
2903
|
+
prometheus_query: pulumi.Input[builtins.str]):
|
|
2903
2904
|
"""
|
|
2904
|
-
:param pulumi.Input[str] prometheus_query: A request for information retrieved from Prometheus.
|
|
2905
|
+
:param pulumi.Input[builtins.str] prometheus_query: A request for information retrieved from Prometheus.
|
|
2905
2906
|
"""
|
|
2906
2907
|
pulumi.set(__self__, "prometheus_query", prometheus_query)
|
|
2907
2908
|
|
|
2908
2909
|
@property
|
|
2909
2910
|
@pulumi.getter(name="prometheusQuery")
|
|
2910
|
-
def prometheus_query(self) -> pulumi.Input[str]:
|
|
2911
|
+
def prometheus_query(self) -> pulumi.Input[builtins.str]:
|
|
2911
2912
|
"""
|
|
2912
2913
|
A request for information retrieved from Prometheus.
|
|
2913
2914
|
"""
|
|
2914
2915
|
return pulumi.get(self, "prometheus_query")
|
|
2915
2916
|
|
|
2916
2917
|
@prometheus_query.setter
|
|
2917
|
-
def prometheus_query(self, value: pulumi.Input[str]):
|
|
2918
|
+
def prometheus_query(self, value: pulumi.Input[builtins.str]):
|
|
2918
2919
|
pulumi.set(self, "prometheus_query", value)
|
|
2919
2920
|
|
|
2920
2921
|
|
|
@@ -3076,7 +3077,7 @@ if not MYPY:
|
|
|
3076
3077
|
"""
|
|
3077
3078
|
The metric queries to be returned. A single MetricData call can include as many as 500 MetricDataQuery structures. Each of these structures can specify either a metric to retrieve, a Metrics Insights query, or a math expression to perform on retrieved data.
|
|
3078
3079
|
"""
|
|
3079
|
-
duration: NotRequired[pulumi.Input[str]]
|
|
3080
|
+
duration: NotRequired[pulumi.Input[builtins.str]]
|
|
3080
3081
|
"""
|
|
3081
3082
|
The window of time we are looking at in CloudWatch.
|
|
3082
3083
|
"""
|
|
@@ -3087,10 +3088,10 @@ elif False:
|
|
|
3087
3088
|
class VerificationTemplateMetricProviderCloudWatchArgs:
|
|
3088
3089
|
def __init__(__self__, *,
|
|
3089
3090
|
metric_data_queries: pulumi.Input[Sequence[pulumi.Input['VerificationTemplateMetricProviderCloudWatchMetricDataQueryArgs']]],
|
|
3090
|
-
duration: Optional[pulumi.Input[str]] = None):
|
|
3091
|
+
duration: Optional[pulumi.Input[builtins.str]] = None):
|
|
3091
3092
|
"""
|
|
3092
3093
|
:param pulumi.Input[Sequence[pulumi.Input['VerificationTemplateMetricProviderCloudWatchMetricDataQueryArgs']]] metric_data_queries: The metric queries to be returned. A single MetricData call can include as many as 500 MetricDataQuery structures. Each of these structures can specify either a metric to retrieve, a Metrics Insights query, or a math expression to perform on retrieved data.
|
|
3093
|
-
:param pulumi.Input[str] duration: The window of time we are looking at in CloudWatch.
|
|
3094
|
+
:param pulumi.Input[builtins.str] duration: The window of time we are looking at in CloudWatch.
|
|
3094
3095
|
"""
|
|
3095
3096
|
pulumi.set(__self__, "metric_data_queries", metric_data_queries)
|
|
3096
3097
|
if duration is not None:
|
|
@@ -3110,28 +3111,28 @@ class VerificationTemplateMetricProviderCloudWatchArgs:
|
|
|
3110
3111
|
|
|
3111
3112
|
@property
|
|
3112
3113
|
@pulumi.getter
|
|
3113
|
-
def duration(self) -> Optional[pulumi.Input[str]]:
|
|
3114
|
+
def duration(self) -> Optional[pulumi.Input[builtins.str]]:
|
|
3114
3115
|
"""
|
|
3115
3116
|
The window of time we are looking at in CloudWatch.
|
|
3116
3117
|
"""
|
|
3117
3118
|
return pulumi.get(self, "duration")
|
|
3118
3119
|
|
|
3119
3120
|
@duration.setter
|
|
3120
|
-
def duration(self, value: Optional[pulumi.Input[str]]):
|
|
3121
|
+
def duration(self, value: Optional[pulumi.Input[builtins.str]]):
|
|
3121
3122
|
pulumi.set(self, "duration", value)
|
|
3122
3123
|
|
|
3123
3124
|
|
|
3124
3125
|
if not MYPY:
|
|
3125
3126
|
class VerificationTemplateMetricProviderCloudWatchMetricDataQueryArgsDict(TypedDict):
|
|
3126
|
-
id: pulumi.Input[str]
|
|
3127
|
+
id: pulumi.Input[builtins.str]
|
|
3127
3128
|
"""
|
|
3128
3129
|
The response ID. Must be unique and not null. This object can contain characters, letters, numbers and underscore. The first letter must be a lowercase letter.
|
|
3129
3130
|
"""
|
|
3130
|
-
expression: NotRequired[pulumi.Input[str]]
|
|
3131
|
+
expression: NotRequired[pulumi.Input[builtins.str]]
|
|
3131
3132
|
"""
|
|
3132
3133
|
This field can contain either a Metrics Insights query, or a metric math expression to be performed on the returned data. Within one metricdataquery object, you must specify either expression or metricstat but not both.
|
|
3133
3134
|
"""
|
|
3134
|
-
label: NotRequired[pulumi.Input[str]]
|
|
3135
|
+
label: NotRequired[pulumi.Input[builtins.str]]
|
|
3135
3136
|
"""
|
|
3136
3137
|
A human-readable label for this metric or expression. If the metric or expression is shown in a CloudWatch dashboard widget, the label is shown
|
|
3137
3138
|
"""
|
|
@@ -3139,11 +3140,11 @@ if not MYPY:
|
|
|
3139
3140
|
"""
|
|
3140
3141
|
The metric to be returned, along with statistics, period, and units. Use this parameter only if this object is retrieving a metric and not performing a math expression on returned data.Within one metricdataquery object, you must specify either expression or metricstat but not both.
|
|
3141
3142
|
"""
|
|
3142
|
-
period: NotRequired[pulumi.Input[int]]
|
|
3143
|
+
period: NotRequired[pulumi.Input[builtins.int]]
|
|
3143
3144
|
"""
|
|
3144
3145
|
The granularity, in seconds, of the returned data points.
|
|
3145
3146
|
"""
|
|
3146
|
-
return_data: NotRequired[pulumi.Input[bool]]
|
|
3147
|
+
return_data: NotRequired[pulumi.Input[builtins.bool]]
|
|
3147
3148
|
"""
|
|
3148
3149
|
This option indicates whether to return the timestamps and raw data values of this metric. If you are performing this call just to do math expressions and do not also need the raw data returned, you can specify `false`. If you omit this, the default of `true` is used.
|
|
3149
3150
|
"""
|
|
@@ -3153,19 +3154,19 @@ elif False:
|
|
|
3153
3154
|
@pulumi.input_type
|
|
3154
3155
|
class VerificationTemplateMetricProviderCloudWatchMetricDataQueryArgs:
|
|
3155
3156
|
def __init__(__self__, *,
|
|
3156
|
-
id: pulumi.Input[str],
|
|
3157
|
-
expression: Optional[pulumi.Input[str]] = None,
|
|
3158
|
-
label: Optional[pulumi.Input[str]] = None,
|
|
3157
|
+
id: pulumi.Input[builtins.str],
|
|
3158
|
+
expression: Optional[pulumi.Input[builtins.str]] = None,
|
|
3159
|
+
label: Optional[pulumi.Input[builtins.str]] = None,
|
|
3159
3160
|
metric_stat: Optional[pulumi.Input['VerificationTemplateMetricProviderCloudWatchMetricDataQueryMetricStatArgs']] = None,
|
|
3160
|
-
period: Optional[pulumi.Input[int]] = None,
|
|
3161
|
-
return_data: Optional[pulumi.Input[bool]] = None):
|
|
3161
|
+
period: Optional[pulumi.Input[builtins.int]] = None,
|
|
3162
|
+
return_data: Optional[pulumi.Input[builtins.bool]] = None):
|
|
3162
3163
|
"""
|
|
3163
|
-
:param pulumi.Input[str] id: The response ID. Must be unique and not null. This object can contain characters, letters, numbers and underscore. The first letter must be a lowercase letter.
|
|
3164
|
-
:param pulumi.Input[str] expression: This field can contain either a Metrics Insights query, or a metric math expression to be performed on the returned data. Within one metricdataquery object, you must specify either expression or metricstat but not both.
|
|
3165
|
-
:param pulumi.Input[str] label: A human-readable label for this metric or expression. If the metric or expression is shown in a CloudWatch dashboard widget, the label is shown
|
|
3164
|
+
:param pulumi.Input[builtins.str] id: The response ID. Must be unique and not null. This object can contain characters, letters, numbers and underscore. The first letter must be a lowercase letter.
|
|
3165
|
+
:param pulumi.Input[builtins.str] expression: This field can contain either a Metrics Insights query, or a metric math expression to be performed on the returned data. Within one metricdataquery object, you must specify either expression or metricstat but not both.
|
|
3166
|
+
:param pulumi.Input[builtins.str] label: A human-readable label for this metric or expression. If the metric or expression is shown in a CloudWatch dashboard widget, the label is shown
|
|
3166
3167
|
:param pulumi.Input['VerificationTemplateMetricProviderCloudWatchMetricDataQueryMetricStatArgs'] metric_stat: The metric to be returned, along with statistics, period, and units. Use this parameter only if this object is retrieving a metric and not performing a math expression on returned data.Within one metricdataquery object, you must specify either expression or metricstat but not both.
|
|
3167
|
-
:param pulumi.Input[int] period: The granularity, in seconds, of the returned data points.
|
|
3168
|
-
:param pulumi.Input[bool] return_data: This option indicates whether to return the timestamps and raw data values of this metric. If you are performing this call just to do math expressions and do not also need the raw data returned, you can specify `false`. If you omit this, the default of `true` is used.
|
|
3168
|
+
:param pulumi.Input[builtins.int] period: The granularity, in seconds, of the returned data points.
|
|
3169
|
+
:param pulumi.Input[builtins.bool] return_data: This option indicates whether to return the timestamps and raw data values of this metric. If you are performing this call just to do math expressions and do not also need the raw data returned, you can specify `false`. If you omit this, the default of `true` is used.
|
|
3169
3170
|
"""
|
|
3170
3171
|
pulumi.set(__self__, "id", id)
|
|
3171
3172
|
if expression is not None:
|
|
@@ -3181,38 +3182,38 @@ class VerificationTemplateMetricProviderCloudWatchMetricDataQueryArgs:
|
|
|
3181
3182
|
|
|
3182
3183
|
@property
|
|
3183
3184
|
@pulumi.getter
|
|
3184
|
-
def id(self) -> pulumi.Input[str]:
|
|
3185
|
+
def id(self) -> pulumi.Input[builtins.str]:
|
|
3185
3186
|
"""
|
|
3186
3187
|
The response ID. Must be unique and not null. This object can contain characters, letters, numbers and underscore. The first letter must be a lowercase letter.
|
|
3187
3188
|
"""
|
|
3188
3189
|
return pulumi.get(self, "id")
|
|
3189
3190
|
|
|
3190
3191
|
@id.setter
|
|
3191
|
-
def id(self, value: pulumi.Input[str]):
|
|
3192
|
+
def id(self, value: pulumi.Input[builtins.str]):
|
|
3192
3193
|
pulumi.set(self, "id", value)
|
|
3193
3194
|
|
|
3194
3195
|
@property
|
|
3195
3196
|
@pulumi.getter
|
|
3196
|
-
def expression(self) -> Optional[pulumi.Input[str]]:
|
|
3197
|
+
def expression(self) -> Optional[pulumi.Input[builtins.str]]:
|
|
3197
3198
|
"""
|
|
3198
3199
|
This field can contain either a Metrics Insights query, or a metric math expression to be performed on the returned data. Within one metricdataquery object, you must specify either expression or metricstat but not both.
|
|
3199
3200
|
"""
|
|
3200
3201
|
return pulumi.get(self, "expression")
|
|
3201
3202
|
|
|
3202
3203
|
@expression.setter
|
|
3203
|
-
def expression(self, value: Optional[pulumi.Input[str]]):
|
|
3204
|
+
def expression(self, value: Optional[pulumi.Input[builtins.str]]):
|
|
3204
3205
|
pulumi.set(self, "expression", value)
|
|
3205
3206
|
|
|
3206
3207
|
@property
|
|
3207
3208
|
@pulumi.getter
|
|
3208
|
-
def label(self) -> Optional[pulumi.Input[str]]:
|
|
3209
|
+
def label(self) -> Optional[pulumi.Input[builtins.str]]:
|
|
3209
3210
|
"""
|
|
3210
3211
|
A human-readable label for this metric or expression. If the metric or expression is shown in a CloudWatch dashboard widget, the label is shown
|
|
3211
3212
|
"""
|
|
3212
3213
|
return pulumi.get(self, "label")
|
|
3213
3214
|
|
|
3214
3215
|
@label.setter
|
|
3215
|
-
def label(self, value: Optional[pulumi.Input[str]]):
|
|
3216
|
+
def label(self, value: Optional[pulumi.Input[builtins.str]]):
|
|
3216
3217
|
pulumi.set(self, "label", value)
|
|
3217
3218
|
|
|
3218
3219
|
@property
|
|
@@ -3229,26 +3230,26 @@ class VerificationTemplateMetricProviderCloudWatchMetricDataQueryArgs:
|
|
|
3229
3230
|
|
|
3230
3231
|
@property
|
|
3231
3232
|
@pulumi.getter
|
|
3232
|
-
def period(self) -> Optional[pulumi.Input[int]]:
|
|
3233
|
+
def period(self) -> Optional[pulumi.Input[builtins.int]]:
|
|
3233
3234
|
"""
|
|
3234
3235
|
The granularity, in seconds, of the returned data points.
|
|
3235
3236
|
"""
|
|
3236
3237
|
return pulumi.get(self, "period")
|
|
3237
3238
|
|
|
3238
3239
|
@period.setter
|
|
3239
|
-
def period(self, value: Optional[pulumi.Input[int]]):
|
|
3240
|
+
def period(self, value: Optional[pulumi.Input[builtins.int]]):
|
|
3240
3241
|
pulumi.set(self, "period", value)
|
|
3241
3242
|
|
|
3242
3243
|
@property
|
|
3243
3244
|
@pulumi.getter(name="returnData")
|
|
3244
|
-
def return_data(self) -> Optional[pulumi.Input[bool]]:
|
|
3245
|
+
def return_data(self) -> Optional[pulumi.Input[builtins.bool]]:
|
|
3245
3246
|
"""
|
|
3246
3247
|
This option indicates whether to return the timestamps and raw data values of this metric. If you are performing this call just to do math expressions and do not also need the raw data returned, you can specify `false`. If you omit this, the default of `true` is used.
|
|
3247
3248
|
"""
|
|
3248
3249
|
return pulumi.get(self, "return_data")
|
|
3249
3250
|
|
|
3250
3251
|
@return_data.setter
|
|
3251
|
-
def return_data(self, value: Optional[pulumi.Input[bool]]):
|
|
3252
|
+
def return_data(self, value: Optional[pulumi.Input[builtins.bool]]):
|
|
3252
3253
|
pulumi.set(self, "return_data", value)
|
|
3253
3254
|
|
|
3254
3255
|
|
|
@@ -3258,15 +3259,15 @@ if not MYPY:
|
|
|
3258
3259
|
"""
|
|
3259
3260
|
The metric to return, including the metric name, namespace, and dimensions.
|
|
3260
3261
|
"""
|
|
3261
|
-
metric_period: NotRequired[pulumi.Input[int]]
|
|
3262
|
+
metric_period: NotRequired[pulumi.Input[builtins.int]]
|
|
3262
3263
|
"""
|
|
3263
3264
|
The granularity, in seconds, of the returned data points.
|
|
3264
3265
|
"""
|
|
3265
|
-
stat: NotRequired[pulumi.Input[str]]
|
|
3266
|
+
stat: NotRequired[pulumi.Input[builtins.str]]
|
|
3266
3267
|
"""
|
|
3267
3268
|
The statistic to return. It can include any CloudWatch statistic or extended statistic.
|
|
3268
3269
|
"""
|
|
3269
|
-
unit: NotRequired[pulumi.Input[str]]
|
|
3270
|
+
unit: NotRequired[pulumi.Input[builtins.str]]
|
|
3270
3271
|
"""
|
|
3271
3272
|
This defines what unit you want to use when storing the metric. Enum: `"Seconds" "Microseconds" "Milliseconds" "Bytes" "Kilobytes" "Megabytes" "Gigabytes" "Terabytes" "Bits" "Kilobits" "Megabits" "Gigabits" "Terabits" "Percent" "Count" "Bytes/Second" "Kilobytes/Second" "Megabytes/Second" "Gigabytes/Second" "Terabytes/Second" "Bits/Second" "Kilobits/Second" "Megabits/Second" "Gigabits/Second" "Terabits/Second" "Count/Second" "None"`
|
|
3272
3273
|
"""
|
|
@@ -3277,14 +3278,14 @@ elif False:
|
|
|
3277
3278
|
class VerificationTemplateMetricProviderCloudWatchMetricDataQueryMetricStatArgs:
|
|
3278
3279
|
def __init__(__self__, *,
|
|
3279
3280
|
metric: Optional[pulumi.Input['VerificationTemplateMetricProviderCloudWatchMetricDataQueryMetricStatMetricArgs']] = None,
|
|
3280
|
-
metric_period: Optional[pulumi.Input[int]] = None,
|
|
3281
|
-
stat: Optional[pulumi.Input[str]] = None,
|
|
3282
|
-
unit: Optional[pulumi.Input[str]] = None):
|
|
3281
|
+
metric_period: Optional[pulumi.Input[builtins.int]] = None,
|
|
3282
|
+
stat: Optional[pulumi.Input[builtins.str]] = None,
|
|
3283
|
+
unit: Optional[pulumi.Input[builtins.str]] = None):
|
|
3283
3284
|
"""
|
|
3284
3285
|
:param pulumi.Input['VerificationTemplateMetricProviderCloudWatchMetricDataQueryMetricStatMetricArgs'] metric: The metric to return, including the metric name, namespace, and dimensions.
|
|
3285
|
-
:param pulumi.Input[int] metric_period: The granularity, in seconds, of the returned data points.
|
|
3286
|
-
:param pulumi.Input[str] stat: The statistic to return. It can include any CloudWatch statistic or extended statistic.
|
|
3287
|
-
:param pulumi.Input[str] unit: This defines what unit you want to use when storing the metric. Enum: `"Seconds" "Microseconds" "Milliseconds" "Bytes" "Kilobytes" "Megabytes" "Gigabytes" "Terabytes" "Bits" "Kilobits" "Megabits" "Gigabits" "Terabits" "Percent" "Count" "Bytes/Second" "Kilobytes/Second" "Megabytes/Second" "Gigabytes/Second" "Terabytes/Second" "Bits/Second" "Kilobits/Second" "Megabits/Second" "Gigabits/Second" "Terabits/Second" "Count/Second" "None"`
|
|
3286
|
+
:param pulumi.Input[builtins.int] metric_period: The granularity, in seconds, of the returned data points.
|
|
3287
|
+
:param pulumi.Input[builtins.str] stat: The statistic to return. It can include any CloudWatch statistic or extended statistic.
|
|
3288
|
+
:param pulumi.Input[builtins.str] unit: This defines what unit you want to use when storing the metric. Enum: `"Seconds" "Microseconds" "Milliseconds" "Bytes" "Kilobytes" "Megabytes" "Gigabytes" "Terabytes" "Bits" "Kilobits" "Megabits" "Gigabits" "Terabits" "Percent" "Count" "Bytes/Second" "Kilobytes/Second" "Megabytes/Second" "Gigabytes/Second" "Terabytes/Second" "Bits/Second" "Kilobits/Second" "Megabits/Second" "Gigabits/Second" "Terabits/Second" "Count/Second" "None"`
|
|
3288
3289
|
"""
|
|
3289
3290
|
if metric is not None:
|
|
3290
3291
|
pulumi.set(__self__, "metric", metric)
|
|
@@ -3309,44 +3310,44 @@ class VerificationTemplateMetricProviderCloudWatchMetricDataQueryMetricStatArgs:
|
|
|
3309
3310
|
|
|
3310
3311
|
@property
|
|
3311
3312
|
@pulumi.getter(name="metricPeriod")
|
|
3312
|
-
def metric_period(self) -> Optional[pulumi.Input[int]]:
|
|
3313
|
+
def metric_period(self) -> Optional[pulumi.Input[builtins.int]]:
|
|
3313
3314
|
"""
|
|
3314
3315
|
The granularity, in seconds, of the returned data points.
|
|
3315
3316
|
"""
|
|
3316
3317
|
return pulumi.get(self, "metric_period")
|
|
3317
3318
|
|
|
3318
3319
|
@metric_period.setter
|
|
3319
|
-
def metric_period(self, value: Optional[pulumi.Input[int]]):
|
|
3320
|
+
def metric_period(self, value: Optional[pulumi.Input[builtins.int]]):
|
|
3320
3321
|
pulumi.set(self, "metric_period", value)
|
|
3321
3322
|
|
|
3322
3323
|
@property
|
|
3323
3324
|
@pulumi.getter
|
|
3324
|
-
def stat(self) -> Optional[pulumi.Input[str]]:
|
|
3325
|
+
def stat(self) -> Optional[pulumi.Input[builtins.str]]:
|
|
3325
3326
|
"""
|
|
3326
3327
|
The statistic to return. It can include any CloudWatch statistic or extended statistic.
|
|
3327
3328
|
"""
|
|
3328
3329
|
return pulumi.get(self, "stat")
|
|
3329
3330
|
|
|
3330
3331
|
@stat.setter
|
|
3331
|
-
def stat(self, value: Optional[pulumi.Input[str]]):
|
|
3332
|
+
def stat(self, value: Optional[pulumi.Input[builtins.str]]):
|
|
3332
3333
|
pulumi.set(self, "stat", value)
|
|
3333
3334
|
|
|
3334
3335
|
@property
|
|
3335
3336
|
@pulumi.getter
|
|
3336
|
-
def unit(self) -> Optional[pulumi.Input[str]]:
|
|
3337
|
+
def unit(self) -> Optional[pulumi.Input[builtins.str]]:
|
|
3337
3338
|
"""
|
|
3338
3339
|
This defines what unit you want to use when storing the metric. Enum: `"Seconds" "Microseconds" "Milliseconds" "Bytes" "Kilobytes" "Megabytes" "Gigabytes" "Terabytes" "Bits" "Kilobits" "Megabits" "Gigabits" "Terabits" "Percent" "Count" "Bytes/Second" "Kilobytes/Second" "Megabytes/Second" "Gigabytes/Second" "Terabytes/Second" "Bits/Second" "Kilobits/Second" "Megabits/Second" "Gigabits/Second" "Terabits/Second" "Count/Second" "None"`
|
|
3339
3340
|
"""
|
|
3340
3341
|
return pulumi.get(self, "unit")
|
|
3341
3342
|
|
|
3342
3343
|
@unit.setter
|
|
3343
|
-
def unit(self, value: Optional[pulumi.Input[str]]):
|
|
3344
|
+
def unit(self, value: Optional[pulumi.Input[builtins.str]]):
|
|
3344
3345
|
pulumi.set(self, "unit", value)
|
|
3345
3346
|
|
|
3346
3347
|
|
|
3347
3348
|
if not MYPY:
|
|
3348
3349
|
class VerificationTemplateMetricProviderCloudWatchMetricDataQueryMetricStatMetricArgsDict(TypedDict):
|
|
3349
|
-
metric_name: pulumi.Input[str]
|
|
3350
|
+
metric_name: pulumi.Input[builtins.str]
|
|
3350
3351
|
"""
|
|
3351
3352
|
The name of the metric.
|
|
3352
3353
|
"""
|
|
@@ -3354,7 +3355,7 @@ if not MYPY:
|
|
|
3354
3355
|
"""
|
|
3355
3356
|
A dimension is a name/value pair that is part of the identity of a metric.You can assign upto 30 dimensions to a metric
|
|
3356
3357
|
"""
|
|
3357
|
-
namespace: NotRequired[pulumi.Input[str]]
|
|
3358
|
+
namespace: NotRequired[pulumi.Input[builtins.str]]
|
|
3358
3359
|
"""
|
|
3359
3360
|
The namespace of the metric.
|
|
3360
3361
|
"""
|
|
@@ -3364,13 +3365,13 @@ elif False:
|
|
|
3364
3365
|
@pulumi.input_type
|
|
3365
3366
|
class VerificationTemplateMetricProviderCloudWatchMetricDataQueryMetricStatMetricArgs:
|
|
3366
3367
|
def __init__(__self__, *,
|
|
3367
|
-
metric_name: pulumi.Input[str],
|
|
3368
|
+
metric_name: pulumi.Input[builtins.str],
|
|
3368
3369
|
dimensions: Optional[pulumi.Input[Sequence[pulumi.Input['VerificationTemplateMetricProviderCloudWatchMetricDataQueryMetricStatMetricDimensionArgs']]]] = None,
|
|
3369
|
-
namespace: Optional[pulumi.Input[str]] = None):
|
|
3370
|
+
namespace: Optional[pulumi.Input[builtins.str]] = None):
|
|
3370
3371
|
"""
|
|
3371
|
-
:param pulumi.Input[str] metric_name: The name of the metric.
|
|
3372
|
+
:param pulumi.Input[builtins.str] metric_name: The name of the metric.
|
|
3372
3373
|
:param pulumi.Input[Sequence[pulumi.Input['VerificationTemplateMetricProviderCloudWatchMetricDataQueryMetricStatMetricDimensionArgs']]] dimensions: A dimension is a name/value pair that is part of the identity of a metric.You can assign upto 30 dimensions to a metric
|
|
3373
|
-
:param pulumi.Input[str] namespace: The namespace of the metric.
|
|
3374
|
+
:param pulumi.Input[builtins.str] namespace: The namespace of the metric.
|
|
3374
3375
|
"""
|
|
3375
3376
|
pulumi.set(__self__, "metric_name", metric_name)
|
|
3376
3377
|
if dimensions is not None:
|
|
@@ -3380,14 +3381,14 @@ class VerificationTemplateMetricProviderCloudWatchMetricDataQueryMetricStatMetri
|
|
|
3380
3381
|
|
|
3381
3382
|
@property
|
|
3382
3383
|
@pulumi.getter(name="metricName")
|
|
3383
|
-
def metric_name(self) -> pulumi.Input[str]:
|
|
3384
|
+
def metric_name(self) -> pulumi.Input[builtins.str]:
|
|
3384
3385
|
"""
|
|
3385
3386
|
The name of the metric.
|
|
3386
3387
|
"""
|
|
3387
3388
|
return pulumi.get(self, "metric_name")
|
|
3388
3389
|
|
|
3389
3390
|
@metric_name.setter
|
|
3390
|
-
def metric_name(self, value: pulumi.Input[str]):
|
|
3391
|
+
def metric_name(self, value: pulumi.Input[builtins.str]):
|
|
3391
3392
|
pulumi.set(self, "metric_name", value)
|
|
3392
3393
|
|
|
3393
3394
|
@property
|
|
@@ -3404,24 +3405,24 @@ class VerificationTemplateMetricProviderCloudWatchMetricDataQueryMetricStatMetri
|
|
|
3404
3405
|
|
|
3405
3406
|
@property
|
|
3406
3407
|
@pulumi.getter
|
|
3407
|
-
def namespace(self) -> Optional[pulumi.Input[str]]:
|
|
3408
|
+
def namespace(self) -> Optional[pulumi.Input[builtins.str]]:
|
|
3408
3409
|
"""
|
|
3409
3410
|
The namespace of the metric.
|
|
3410
3411
|
"""
|
|
3411
3412
|
return pulumi.get(self, "namespace")
|
|
3412
3413
|
|
|
3413
3414
|
@namespace.setter
|
|
3414
|
-
def namespace(self, value: Optional[pulumi.Input[str]]):
|
|
3415
|
+
def namespace(self, value: Optional[pulumi.Input[builtins.str]]):
|
|
3415
3416
|
pulumi.set(self, "namespace", value)
|
|
3416
3417
|
|
|
3417
3418
|
|
|
3418
3419
|
if not MYPY:
|
|
3419
3420
|
class VerificationTemplateMetricProviderCloudWatchMetricDataQueryMetricStatMetricDimensionArgsDict(TypedDict):
|
|
3420
|
-
dimension_name: pulumi.Input[str]
|
|
3421
|
+
dimension_name: pulumi.Input[builtins.str]
|
|
3421
3422
|
"""
|
|
3422
3423
|
The name of the dimensions. These values must contain only ASCII characters and must include at least one non-whitespace characte
|
|
3423
3424
|
"""
|
|
3424
|
-
dimension_value: pulumi.Input[str]
|
|
3425
|
+
dimension_value: pulumi.Input[builtins.str]
|
|
3425
3426
|
"""
|
|
3426
3427
|
The value of the dimensions.These values must contain only ASCII characters and must include at least one non-whitespace characte
|
|
3427
3428
|
"""
|
|
@@ -3431,47 +3432,47 @@ elif False:
|
|
|
3431
3432
|
@pulumi.input_type
|
|
3432
3433
|
class VerificationTemplateMetricProviderCloudWatchMetricDataQueryMetricStatMetricDimensionArgs:
|
|
3433
3434
|
def __init__(__self__, *,
|
|
3434
|
-
dimension_name: pulumi.Input[str],
|
|
3435
|
-
dimension_value: pulumi.Input[str]):
|
|
3435
|
+
dimension_name: pulumi.Input[builtins.str],
|
|
3436
|
+
dimension_value: pulumi.Input[builtins.str]):
|
|
3436
3437
|
"""
|
|
3437
|
-
:param pulumi.Input[str] dimension_name: The name of the dimensions. These values must contain only ASCII characters and must include at least one non-whitespace characte
|
|
3438
|
-
:param pulumi.Input[str] dimension_value: The value of the dimensions.These values must contain only ASCII characters and must include at least one non-whitespace characte
|
|
3438
|
+
:param pulumi.Input[builtins.str] dimension_name: The name of the dimensions. These values must contain only ASCII characters and must include at least one non-whitespace characte
|
|
3439
|
+
:param pulumi.Input[builtins.str] dimension_value: The value of the dimensions.These values must contain only ASCII characters and must include at least one non-whitespace characte
|
|
3439
3440
|
"""
|
|
3440
3441
|
pulumi.set(__self__, "dimension_name", dimension_name)
|
|
3441
3442
|
pulumi.set(__self__, "dimension_value", dimension_value)
|
|
3442
3443
|
|
|
3443
3444
|
@property
|
|
3444
3445
|
@pulumi.getter(name="dimensionName")
|
|
3445
|
-
def dimension_name(self) -> pulumi.Input[str]:
|
|
3446
|
+
def dimension_name(self) -> pulumi.Input[builtins.str]:
|
|
3446
3447
|
"""
|
|
3447
3448
|
The name of the dimensions. These values must contain only ASCII characters and must include at least one non-whitespace characte
|
|
3448
3449
|
"""
|
|
3449
3450
|
return pulumi.get(self, "dimension_name")
|
|
3450
3451
|
|
|
3451
3452
|
@dimension_name.setter
|
|
3452
|
-
def dimension_name(self, value: pulumi.Input[str]):
|
|
3453
|
+
def dimension_name(self, value: pulumi.Input[builtins.str]):
|
|
3453
3454
|
pulumi.set(self, "dimension_name", value)
|
|
3454
3455
|
|
|
3455
3456
|
@property
|
|
3456
3457
|
@pulumi.getter(name="dimensionValue")
|
|
3457
|
-
def dimension_value(self) -> pulumi.Input[str]:
|
|
3458
|
+
def dimension_value(self) -> pulumi.Input[builtins.str]:
|
|
3458
3459
|
"""
|
|
3459
3460
|
The value of the dimensions.These values must contain only ASCII characters and must include at least one non-whitespace characte
|
|
3460
3461
|
"""
|
|
3461
3462
|
return pulumi.get(self, "dimension_value")
|
|
3462
3463
|
|
|
3463
3464
|
@dimension_value.setter
|
|
3464
|
-
def dimension_value(self, value: pulumi.Input[str]):
|
|
3465
|
+
def dimension_value(self, value: pulumi.Input[builtins.str]):
|
|
3465
3466
|
pulumi.set(self, "dimension_value", value)
|
|
3466
3467
|
|
|
3467
3468
|
|
|
3468
3469
|
if not MYPY:
|
|
3469
3470
|
class VerificationTemplateMetricProviderDatadogArgsDict(TypedDict):
|
|
3470
|
-
datadog_query: NotRequired[pulumi.Input[str]]
|
|
3471
|
+
datadog_query: NotRequired[pulumi.Input[builtins.str]]
|
|
3471
3472
|
"""
|
|
3472
3473
|
A request for information retrieved from Datadog.
|
|
3473
3474
|
"""
|
|
3474
|
-
duration: NotRequired[pulumi.Input[str]]
|
|
3475
|
+
duration: NotRequired[pulumi.Input[builtins.str]]
|
|
3475
3476
|
"""
|
|
3476
3477
|
The window of time we are looking at in DataDog.
|
|
3477
3478
|
"""
|
|
@@ -3481,11 +3482,11 @@ elif False:
|
|
|
3481
3482
|
@pulumi.input_type
|
|
3482
3483
|
class VerificationTemplateMetricProviderDatadogArgs:
|
|
3483
3484
|
def __init__(__self__, *,
|
|
3484
|
-
datadog_query: Optional[pulumi.Input[str]] = None,
|
|
3485
|
-
duration: Optional[pulumi.Input[str]] = None):
|
|
3485
|
+
datadog_query: Optional[pulumi.Input[builtins.str]] = None,
|
|
3486
|
+
duration: Optional[pulumi.Input[builtins.str]] = None):
|
|
3486
3487
|
"""
|
|
3487
|
-
:param pulumi.Input[str] datadog_query: A request for information retrieved from Datadog.
|
|
3488
|
-
:param pulumi.Input[str] duration: The window of time we are looking at in DataDog.
|
|
3488
|
+
:param pulumi.Input[builtins.str] datadog_query: A request for information retrieved from Datadog.
|
|
3489
|
+
:param pulumi.Input[builtins.str] duration: The window of time we are looking at in DataDog.
|
|
3489
3490
|
"""
|
|
3490
3491
|
if datadog_query is not None:
|
|
3491
3492
|
pulumi.set(__self__, "datadog_query", datadog_query)
|
|
@@ -3494,40 +3495,40 @@ class VerificationTemplateMetricProviderDatadogArgs:
|
|
|
3494
3495
|
|
|
3495
3496
|
@property
|
|
3496
3497
|
@pulumi.getter(name="datadogQuery")
|
|
3497
|
-
def datadog_query(self) -> Optional[pulumi.Input[str]]:
|
|
3498
|
+
def datadog_query(self) -> Optional[pulumi.Input[builtins.str]]:
|
|
3498
3499
|
"""
|
|
3499
3500
|
A request for information retrieved from Datadog.
|
|
3500
3501
|
"""
|
|
3501
3502
|
return pulumi.get(self, "datadog_query")
|
|
3502
3503
|
|
|
3503
3504
|
@datadog_query.setter
|
|
3504
|
-
def datadog_query(self, value: Optional[pulumi.Input[str]]):
|
|
3505
|
+
def datadog_query(self, value: Optional[pulumi.Input[builtins.str]]):
|
|
3505
3506
|
pulumi.set(self, "datadog_query", value)
|
|
3506
3507
|
|
|
3507
3508
|
@property
|
|
3508
3509
|
@pulumi.getter
|
|
3509
|
-
def duration(self) -> Optional[pulumi.Input[str]]:
|
|
3510
|
+
def duration(self) -> Optional[pulumi.Input[builtins.str]]:
|
|
3510
3511
|
"""
|
|
3511
3512
|
The window of time we are looking at in DataDog.
|
|
3512
3513
|
"""
|
|
3513
3514
|
return pulumi.get(self, "duration")
|
|
3514
3515
|
|
|
3515
3516
|
@duration.setter
|
|
3516
|
-
def duration(self, value: Optional[pulumi.Input[str]]):
|
|
3517
|
+
def duration(self, value: Optional[pulumi.Input[builtins.str]]):
|
|
3517
3518
|
pulumi.set(self, "duration", value)
|
|
3518
3519
|
|
|
3519
3520
|
|
|
3520
3521
|
if not MYPY:
|
|
3521
3522
|
class VerificationTemplateMetricProviderJenkinsArgsDict(TypedDict):
|
|
3522
|
-
jenkins_interval: pulumi.Input[str]
|
|
3523
|
+
jenkins_interval: pulumi.Input[builtins.str]
|
|
3523
3524
|
"""
|
|
3524
3525
|
The interval time to poll status.
|
|
3525
3526
|
"""
|
|
3526
|
-
pipeline_name: pulumi.Input[str]
|
|
3527
|
+
pipeline_name: pulumi.Input[builtins.str]
|
|
3527
3528
|
"""
|
|
3528
3529
|
The Jenkins pipeline name.
|
|
3529
3530
|
"""
|
|
3530
|
-
timeout: pulumi.Input[str]
|
|
3531
|
+
timeout: pulumi.Input[builtins.str]
|
|
3531
3532
|
"""
|
|
3532
3533
|
The total jenkins timeout.
|
|
3533
3534
|
"""
|
|
@@ -3535,7 +3536,7 @@ if not MYPY:
|
|
|
3535
3536
|
"""
|
|
3536
3537
|
List of parameters.
|
|
3537
3538
|
"""
|
|
3538
|
-
tls_verification: NotRequired[pulumi.Input[bool]]
|
|
3539
|
+
tls_verification: NotRequired[pulumi.Input[builtins.bool]]
|
|
3539
3540
|
"""
|
|
3540
3541
|
Host TLS verification.
|
|
3541
3542
|
"""
|
|
@@ -3545,17 +3546,17 @@ elif False:
|
|
|
3545
3546
|
@pulumi.input_type
|
|
3546
3547
|
class VerificationTemplateMetricProviderJenkinsArgs:
|
|
3547
3548
|
def __init__(__self__, *,
|
|
3548
|
-
jenkins_interval: pulumi.Input[str],
|
|
3549
|
-
pipeline_name: pulumi.Input[str],
|
|
3550
|
-
timeout: pulumi.Input[str],
|
|
3549
|
+
jenkins_interval: pulumi.Input[builtins.str],
|
|
3550
|
+
pipeline_name: pulumi.Input[builtins.str],
|
|
3551
|
+
timeout: pulumi.Input[builtins.str],
|
|
3551
3552
|
jenkins_parameters: Optional[pulumi.Input['VerificationTemplateMetricProviderJenkinsJenkinsParametersArgs']] = None,
|
|
3552
|
-
tls_verification: Optional[pulumi.Input[bool]] = None):
|
|
3553
|
+
tls_verification: Optional[pulumi.Input[builtins.bool]] = None):
|
|
3553
3554
|
"""
|
|
3554
|
-
:param pulumi.Input[str] jenkins_interval: The interval time to poll status.
|
|
3555
|
-
:param pulumi.Input[str] pipeline_name: The Jenkins pipeline name.
|
|
3556
|
-
:param pulumi.Input[str] timeout: The total jenkins timeout.
|
|
3555
|
+
:param pulumi.Input[builtins.str] jenkins_interval: The interval time to poll status.
|
|
3556
|
+
:param pulumi.Input[builtins.str] pipeline_name: The Jenkins pipeline name.
|
|
3557
|
+
:param pulumi.Input[builtins.str] timeout: The total jenkins timeout.
|
|
3557
3558
|
:param pulumi.Input['VerificationTemplateMetricProviderJenkinsJenkinsParametersArgs'] jenkins_parameters: List of parameters.
|
|
3558
|
-
:param pulumi.Input[bool] tls_verification: Host TLS verification.
|
|
3559
|
+
:param pulumi.Input[builtins.bool] tls_verification: Host TLS verification.
|
|
3559
3560
|
"""
|
|
3560
3561
|
pulumi.set(__self__, "jenkins_interval", jenkins_interval)
|
|
3561
3562
|
pulumi.set(__self__, "pipeline_name", pipeline_name)
|
|
@@ -3567,38 +3568,38 @@ class VerificationTemplateMetricProviderJenkinsArgs:
|
|
|
3567
3568
|
|
|
3568
3569
|
@property
|
|
3569
3570
|
@pulumi.getter(name="jenkinsInterval")
|
|
3570
|
-
def jenkins_interval(self) -> pulumi.Input[str]:
|
|
3571
|
+
def jenkins_interval(self) -> pulumi.Input[builtins.str]:
|
|
3571
3572
|
"""
|
|
3572
3573
|
The interval time to poll status.
|
|
3573
3574
|
"""
|
|
3574
3575
|
return pulumi.get(self, "jenkins_interval")
|
|
3575
3576
|
|
|
3576
3577
|
@jenkins_interval.setter
|
|
3577
|
-
def jenkins_interval(self, value: pulumi.Input[str]):
|
|
3578
|
+
def jenkins_interval(self, value: pulumi.Input[builtins.str]):
|
|
3578
3579
|
pulumi.set(self, "jenkins_interval", value)
|
|
3579
3580
|
|
|
3580
3581
|
@property
|
|
3581
3582
|
@pulumi.getter(name="pipelineName")
|
|
3582
|
-
def pipeline_name(self) -> pulumi.Input[str]:
|
|
3583
|
+
def pipeline_name(self) -> pulumi.Input[builtins.str]:
|
|
3583
3584
|
"""
|
|
3584
3585
|
The Jenkins pipeline name.
|
|
3585
3586
|
"""
|
|
3586
3587
|
return pulumi.get(self, "pipeline_name")
|
|
3587
3588
|
|
|
3588
3589
|
@pipeline_name.setter
|
|
3589
|
-
def pipeline_name(self, value: pulumi.Input[str]):
|
|
3590
|
+
def pipeline_name(self, value: pulumi.Input[builtins.str]):
|
|
3590
3591
|
pulumi.set(self, "pipeline_name", value)
|
|
3591
3592
|
|
|
3592
3593
|
@property
|
|
3593
3594
|
@pulumi.getter
|
|
3594
|
-
def timeout(self) -> pulumi.Input[str]:
|
|
3595
|
+
def timeout(self) -> pulumi.Input[builtins.str]:
|
|
3595
3596
|
"""
|
|
3596
3597
|
The total jenkins timeout.
|
|
3597
3598
|
"""
|
|
3598
3599
|
return pulumi.get(self, "timeout")
|
|
3599
3600
|
|
|
3600
3601
|
@timeout.setter
|
|
3601
|
-
def timeout(self, value: pulumi.Input[str]):
|
|
3602
|
+
def timeout(self, value: pulumi.Input[builtins.str]):
|
|
3602
3603
|
pulumi.set(self, "timeout", value)
|
|
3603
3604
|
|
|
3604
3605
|
@property
|
|
@@ -3615,24 +3616,24 @@ class VerificationTemplateMetricProviderJenkinsArgs:
|
|
|
3615
3616
|
|
|
3616
3617
|
@property
|
|
3617
3618
|
@pulumi.getter(name="tlsVerification")
|
|
3618
|
-
def tls_verification(self) -> Optional[pulumi.Input[bool]]:
|
|
3619
|
+
def tls_verification(self) -> Optional[pulumi.Input[builtins.bool]]:
|
|
3619
3620
|
"""
|
|
3620
3621
|
Host TLS verification.
|
|
3621
3622
|
"""
|
|
3622
3623
|
return pulumi.get(self, "tls_verification")
|
|
3623
3624
|
|
|
3624
3625
|
@tls_verification.setter
|
|
3625
|
-
def tls_verification(self, value: Optional[pulumi.Input[bool]]):
|
|
3626
|
+
def tls_verification(self, value: Optional[pulumi.Input[builtins.bool]]):
|
|
3626
3627
|
pulumi.set(self, "tls_verification", value)
|
|
3627
3628
|
|
|
3628
3629
|
|
|
3629
3630
|
if not MYPY:
|
|
3630
3631
|
class VerificationTemplateMetricProviderJenkinsJenkinsParametersArgsDict(TypedDict):
|
|
3631
|
-
parameter_key: pulumi.Input[str]
|
|
3632
|
+
parameter_key: pulumi.Input[builtins.str]
|
|
3632
3633
|
"""
|
|
3633
3634
|
Key of an argument.
|
|
3634
3635
|
"""
|
|
3635
|
-
parameter_value: pulumi.Input[str]
|
|
3636
|
+
parameter_value: pulumi.Input[builtins.str]
|
|
3636
3637
|
"""
|
|
3637
3638
|
Value of an argument.
|
|
3638
3639
|
"""
|
|
@@ -3642,37 +3643,37 @@ elif False:
|
|
|
3642
3643
|
@pulumi.input_type
|
|
3643
3644
|
class VerificationTemplateMetricProviderJenkinsJenkinsParametersArgs:
|
|
3644
3645
|
def __init__(__self__, *,
|
|
3645
|
-
parameter_key: pulumi.Input[str],
|
|
3646
|
-
parameter_value: pulumi.Input[str]):
|
|
3646
|
+
parameter_key: pulumi.Input[builtins.str],
|
|
3647
|
+
parameter_value: pulumi.Input[builtins.str]):
|
|
3647
3648
|
"""
|
|
3648
|
-
:param pulumi.Input[str] parameter_key: Key of an argument.
|
|
3649
|
-
:param pulumi.Input[str] parameter_value: Value of an argument.
|
|
3649
|
+
:param pulumi.Input[builtins.str] parameter_key: Key of an argument.
|
|
3650
|
+
:param pulumi.Input[builtins.str] parameter_value: Value of an argument.
|
|
3650
3651
|
"""
|
|
3651
3652
|
pulumi.set(__self__, "parameter_key", parameter_key)
|
|
3652
3653
|
pulumi.set(__self__, "parameter_value", parameter_value)
|
|
3653
3654
|
|
|
3654
3655
|
@property
|
|
3655
3656
|
@pulumi.getter(name="parameterKey")
|
|
3656
|
-
def parameter_key(self) -> pulumi.Input[str]:
|
|
3657
|
+
def parameter_key(self) -> pulumi.Input[builtins.str]:
|
|
3657
3658
|
"""
|
|
3658
3659
|
Key of an argument.
|
|
3659
3660
|
"""
|
|
3660
3661
|
return pulumi.get(self, "parameter_key")
|
|
3661
3662
|
|
|
3662
3663
|
@parameter_key.setter
|
|
3663
|
-
def parameter_key(self, value: pulumi.Input[str]):
|
|
3664
|
+
def parameter_key(self, value: pulumi.Input[builtins.str]):
|
|
3664
3665
|
pulumi.set(self, "parameter_key", value)
|
|
3665
3666
|
|
|
3666
3667
|
@property
|
|
3667
3668
|
@pulumi.getter(name="parameterValue")
|
|
3668
|
-
def parameter_value(self) -> pulumi.Input[str]:
|
|
3669
|
+
def parameter_value(self) -> pulumi.Input[builtins.str]:
|
|
3669
3670
|
"""
|
|
3670
3671
|
Value of an argument.
|
|
3671
3672
|
"""
|
|
3672
3673
|
return pulumi.get(self, "parameter_value")
|
|
3673
3674
|
|
|
3674
3675
|
@parameter_value.setter
|
|
3675
|
-
def parameter_value(self, value: pulumi.Input[str]):
|
|
3676
|
+
def parameter_value(self, value: pulumi.Input[builtins.str]):
|
|
3676
3677
|
pulumi.set(self, "parameter_value", value)
|
|
3677
3678
|
|
|
3678
3679
|
|
|
@@ -3713,7 +3714,7 @@ if not MYPY:
|
|
|
3713
3714
|
"""
|
|
3714
3715
|
Describes the pod that will be created when executing a job.
|
|
3715
3716
|
"""
|
|
3716
|
-
backoff_limit: NotRequired[pulumi.Input[int]]
|
|
3717
|
+
backoff_limit: NotRequired[pulumi.Input[builtins.int]]
|
|
3717
3718
|
"""
|
|
3718
3719
|
Specifies the number of retries before marking this job failed.
|
|
3719
3720
|
"""
|
|
@@ -3724,10 +3725,10 @@ elif False:
|
|
|
3724
3725
|
class VerificationTemplateMetricProviderJobSpecArgs:
|
|
3725
3726
|
def __init__(__self__, *,
|
|
3726
3727
|
job_templates: pulumi.Input[Sequence[pulumi.Input['VerificationTemplateMetricProviderJobSpecJobTemplateArgs']]],
|
|
3727
|
-
backoff_limit: Optional[pulumi.Input[int]] = None):
|
|
3728
|
+
backoff_limit: Optional[pulumi.Input[builtins.int]] = None):
|
|
3728
3729
|
"""
|
|
3729
3730
|
:param pulumi.Input[Sequence[pulumi.Input['VerificationTemplateMetricProviderJobSpecJobTemplateArgs']]] job_templates: Describes the pod that will be created when executing a job.
|
|
3730
|
-
:param pulumi.Input[int] backoff_limit: Specifies the number of retries before marking this job failed.
|
|
3731
|
+
:param pulumi.Input[builtins.int] backoff_limit: Specifies the number of retries before marking this job failed.
|
|
3731
3732
|
"""
|
|
3732
3733
|
pulumi.set(__self__, "job_templates", job_templates)
|
|
3733
3734
|
if backoff_limit is not None:
|
|
@@ -3747,14 +3748,14 @@ class VerificationTemplateMetricProviderJobSpecArgs:
|
|
|
3747
3748
|
|
|
3748
3749
|
@property
|
|
3749
3750
|
@pulumi.getter(name="backoffLimit")
|
|
3750
|
-
def backoff_limit(self) -> Optional[pulumi.Input[int]]:
|
|
3751
|
+
def backoff_limit(self) -> Optional[pulumi.Input[builtins.int]]:
|
|
3751
3752
|
"""
|
|
3752
3753
|
Specifies the number of retries before marking this job failed.
|
|
3753
3754
|
"""
|
|
3754
3755
|
return pulumi.get(self, "backoff_limit")
|
|
3755
3756
|
|
|
3756
3757
|
@backoff_limit.setter
|
|
3757
|
-
def backoff_limit(self, value: Optional[pulumi.Input[int]]):
|
|
3758
|
+
def backoff_limit(self, value: Optional[pulumi.Input[builtins.int]]):
|
|
3758
3759
|
pulumi.set(self, "backoff_limit", value)
|
|
3759
3760
|
|
|
3760
3761
|
|
|
@@ -3795,7 +3796,7 @@ if not MYPY:
|
|
|
3795
3796
|
"""
|
|
3796
3797
|
A list of containers belonging to the pod.
|
|
3797
3798
|
"""
|
|
3798
|
-
restart_policy: pulumi.Input[str]
|
|
3799
|
+
restart_policy: pulumi.Input[builtins.str]
|
|
3799
3800
|
"""
|
|
3800
3801
|
Restart policy for all containers within the pod. Enum: `"Never" "OnFailure"`
|
|
3801
3802
|
"""
|
|
@@ -3806,10 +3807,10 @@ elif False:
|
|
|
3806
3807
|
class VerificationTemplateMetricProviderJobSpecJobTemplateTemplateSpecArgs:
|
|
3807
3808
|
def __init__(__self__, *,
|
|
3808
3809
|
containers: pulumi.Input[Sequence[pulumi.Input['VerificationTemplateMetricProviderJobSpecJobTemplateTemplateSpecContainerArgs']]],
|
|
3809
|
-
restart_policy: pulumi.Input[str]):
|
|
3810
|
+
restart_policy: pulumi.Input[builtins.str]):
|
|
3810
3811
|
"""
|
|
3811
3812
|
:param pulumi.Input[Sequence[pulumi.Input['VerificationTemplateMetricProviderJobSpecJobTemplateTemplateSpecContainerArgs']]] containers: A list of containers belonging to the pod.
|
|
3812
|
-
:param pulumi.Input[str] restart_policy: Restart policy for all containers within the pod. Enum: `"Never" "OnFailure"`
|
|
3813
|
+
:param pulumi.Input[builtins.str] restart_policy: Restart policy for all containers within the pod. Enum: `"Never" "OnFailure"`
|
|
3813
3814
|
"""
|
|
3814
3815
|
pulumi.set(__self__, "containers", containers)
|
|
3815
3816
|
pulumi.set(__self__, "restart_policy", restart_policy)
|
|
@@ -3828,28 +3829,28 @@ class VerificationTemplateMetricProviderJobSpecJobTemplateTemplateSpecArgs:
|
|
|
3828
3829
|
|
|
3829
3830
|
@property
|
|
3830
3831
|
@pulumi.getter(name="restartPolicy")
|
|
3831
|
-
def restart_policy(self) -> pulumi.Input[str]:
|
|
3832
|
+
def restart_policy(self) -> pulumi.Input[builtins.str]:
|
|
3832
3833
|
"""
|
|
3833
3834
|
Restart policy for all containers within the pod. Enum: `"Never" "OnFailure"`
|
|
3834
3835
|
"""
|
|
3835
3836
|
return pulumi.get(self, "restart_policy")
|
|
3836
3837
|
|
|
3837
3838
|
@restart_policy.setter
|
|
3838
|
-
def restart_policy(self, value: pulumi.Input[str]):
|
|
3839
|
+
def restart_policy(self, value: pulumi.Input[builtins.str]):
|
|
3839
3840
|
pulumi.set(self, "restart_policy", value)
|
|
3840
3841
|
|
|
3841
3842
|
|
|
3842
3843
|
if not MYPY:
|
|
3843
3844
|
class VerificationTemplateMetricProviderJobSpecJobTemplateTemplateSpecContainerArgsDict(TypedDict):
|
|
3844
|
-
commands: pulumi.Input[Sequence[pulumi.Input[str]]]
|
|
3845
|
+
commands: pulumi.Input[Sequence[pulumi.Input[builtins.str]]]
|
|
3845
3846
|
"""
|
|
3846
3847
|
The entry point of a container.
|
|
3847
3848
|
"""
|
|
3848
|
-
container_name: pulumi.Input[str]
|
|
3849
|
+
container_name: pulumi.Input[builtins.str]
|
|
3849
3850
|
"""
|
|
3850
3851
|
The name of a container.
|
|
3851
3852
|
"""
|
|
3852
|
-
image: pulumi.Input[str]
|
|
3853
|
+
image: pulumi.Input[builtins.str]
|
|
3853
3854
|
"""
|
|
3854
3855
|
The image name of a container.
|
|
3855
3856
|
"""
|
|
@@ -3859,13 +3860,13 @@ elif False:
|
|
|
3859
3860
|
@pulumi.input_type
|
|
3860
3861
|
class VerificationTemplateMetricProviderJobSpecJobTemplateTemplateSpecContainerArgs:
|
|
3861
3862
|
def __init__(__self__, *,
|
|
3862
|
-
commands: pulumi.Input[Sequence[pulumi.Input[str]]],
|
|
3863
|
-
container_name: pulumi.Input[str],
|
|
3864
|
-
image: pulumi.Input[str]):
|
|
3863
|
+
commands: pulumi.Input[Sequence[pulumi.Input[builtins.str]]],
|
|
3864
|
+
container_name: pulumi.Input[builtins.str],
|
|
3865
|
+
image: pulumi.Input[builtins.str]):
|
|
3865
3866
|
"""
|
|
3866
|
-
:param pulumi.Input[Sequence[pulumi.Input[str]]] commands: The entry point of a container.
|
|
3867
|
-
:param pulumi.Input[str] container_name: The name of a container.
|
|
3868
|
-
:param pulumi.Input[str] image: The image name of a container.
|
|
3867
|
+
:param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] commands: The entry point of a container.
|
|
3868
|
+
:param pulumi.Input[builtins.str] container_name: The name of a container.
|
|
3869
|
+
:param pulumi.Input[builtins.str] image: The image name of a container.
|
|
3869
3870
|
"""
|
|
3870
3871
|
pulumi.set(__self__, "commands", commands)
|
|
3871
3872
|
pulumi.set(__self__, "container_name", container_name)
|
|
@@ -3873,48 +3874,48 @@ class VerificationTemplateMetricProviderJobSpecJobTemplateTemplateSpecContainerA
|
|
|
3873
3874
|
|
|
3874
3875
|
@property
|
|
3875
3876
|
@pulumi.getter
|
|
3876
|
-
def commands(self) -> pulumi.Input[Sequence[pulumi.Input[str]]]:
|
|
3877
|
+
def commands(self) -> pulumi.Input[Sequence[pulumi.Input[builtins.str]]]:
|
|
3877
3878
|
"""
|
|
3878
3879
|
The entry point of a container.
|
|
3879
3880
|
"""
|
|
3880
3881
|
return pulumi.get(self, "commands")
|
|
3881
3882
|
|
|
3882
3883
|
@commands.setter
|
|
3883
|
-
def commands(self, value: pulumi.Input[Sequence[pulumi.Input[str]]]):
|
|
3884
|
+
def commands(self, value: pulumi.Input[Sequence[pulumi.Input[builtins.str]]]):
|
|
3884
3885
|
pulumi.set(self, "commands", value)
|
|
3885
3886
|
|
|
3886
3887
|
@property
|
|
3887
3888
|
@pulumi.getter(name="containerName")
|
|
3888
|
-
def container_name(self) -> pulumi.Input[str]:
|
|
3889
|
+
def container_name(self) -> pulumi.Input[builtins.str]:
|
|
3889
3890
|
"""
|
|
3890
3891
|
The name of a container.
|
|
3891
3892
|
"""
|
|
3892
3893
|
return pulumi.get(self, "container_name")
|
|
3893
3894
|
|
|
3894
3895
|
@container_name.setter
|
|
3895
|
-
def container_name(self, value: pulumi.Input[str]):
|
|
3896
|
+
def container_name(self, value: pulumi.Input[builtins.str]):
|
|
3896
3897
|
pulumi.set(self, "container_name", value)
|
|
3897
3898
|
|
|
3898
3899
|
@property
|
|
3899
3900
|
@pulumi.getter
|
|
3900
|
-
def image(self) -> pulumi.Input[str]:
|
|
3901
|
+
def image(self) -> pulumi.Input[builtins.str]:
|
|
3901
3902
|
"""
|
|
3902
3903
|
The image name of a container.
|
|
3903
3904
|
"""
|
|
3904
3905
|
return pulumi.get(self, "image")
|
|
3905
3906
|
|
|
3906
3907
|
@image.setter
|
|
3907
|
-
def image(self, value: pulumi.Input[str]):
|
|
3908
|
+
def image(self, value: pulumi.Input[builtins.str]):
|
|
3908
3909
|
pulumi.set(self, "image", value)
|
|
3909
3910
|
|
|
3910
3911
|
|
|
3911
3912
|
if not MYPY:
|
|
3912
3913
|
class VerificationTemplateMetricProviderNewRelicArgsDict(TypedDict):
|
|
3913
|
-
new_relic_query: pulumi.Input[str]
|
|
3914
|
+
new_relic_query: pulumi.Input[builtins.str]
|
|
3914
3915
|
"""
|
|
3915
3916
|
A raw newrelic NRQL query to perform.
|
|
3916
3917
|
"""
|
|
3917
|
-
profile: NotRequired[pulumi.Input[str]]
|
|
3918
|
+
profile: NotRequired[pulumi.Input[builtins.str]]
|
|
3918
3919
|
"""
|
|
3919
3920
|
The name of the secret holding NR account configuration.
|
|
3920
3921
|
"""
|
|
@@ -3924,11 +3925,11 @@ elif False:
|
|
|
3924
3925
|
@pulumi.input_type
|
|
3925
3926
|
class VerificationTemplateMetricProviderNewRelicArgs:
|
|
3926
3927
|
def __init__(__self__, *,
|
|
3927
|
-
new_relic_query: pulumi.Input[str],
|
|
3928
|
-
profile: Optional[pulumi.Input[str]] = None):
|
|
3928
|
+
new_relic_query: pulumi.Input[builtins.str],
|
|
3929
|
+
profile: Optional[pulumi.Input[builtins.str]] = None):
|
|
3929
3930
|
"""
|
|
3930
|
-
:param pulumi.Input[str] new_relic_query: A raw newrelic NRQL query to perform.
|
|
3931
|
-
:param pulumi.Input[str] profile: The name of the secret holding NR account configuration.
|
|
3931
|
+
:param pulumi.Input[builtins.str] new_relic_query: A raw newrelic NRQL query to perform.
|
|
3932
|
+
:param pulumi.Input[builtins.str] profile: The name of the secret holding NR account configuration.
|
|
3932
3933
|
"""
|
|
3933
3934
|
pulumi.set(__self__, "new_relic_query", new_relic_query)
|
|
3934
3935
|
if profile is not None:
|
|
@@ -3936,32 +3937,32 @@ class VerificationTemplateMetricProviderNewRelicArgs:
|
|
|
3936
3937
|
|
|
3937
3938
|
@property
|
|
3938
3939
|
@pulumi.getter(name="newRelicQuery")
|
|
3939
|
-
def new_relic_query(self) -> pulumi.Input[str]:
|
|
3940
|
+
def new_relic_query(self) -> pulumi.Input[builtins.str]:
|
|
3940
3941
|
"""
|
|
3941
3942
|
A raw newrelic NRQL query to perform.
|
|
3942
3943
|
"""
|
|
3943
3944
|
return pulumi.get(self, "new_relic_query")
|
|
3944
3945
|
|
|
3945
3946
|
@new_relic_query.setter
|
|
3946
|
-
def new_relic_query(self, value: pulumi.Input[str]):
|
|
3947
|
+
def new_relic_query(self, value: pulumi.Input[builtins.str]):
|
|
3947
3948
|
pulumi.set(self, "new_relic_query", value)
|
|
3948
3949
|
|
|
3949
3950
|
@property
|
|
3950
3951
|
@pulumi.getter
|
|
3951
|
-
def profile(self) -> Optional[pulumi.Input[str]]:
|
|
3952
|
+
def profile(self) -> Optional[pulumi.Input[builtins.str]]:
|
|
3952
3953
|
"""
|
|
3953
3954
|
The name of the secret holding NR account configuration.
|
|
3954
3955
|
"""
|
|
3955
3956
|
return pulumi.get(self, "profile")
|
|
3956
3957
|
|
|
3957
3958
|
@profile.setter
|
|
3958
|
-
def profile(self, value: Optional[pulumi.Input[str]]):
|
|
3959
|
+
def profile(self, value: Optional[pulumi.Input[builtins.str]]):
|
|
3959
3960
|
pulumi.set(self, "profile", value)
|
|
3960
3961
|
|
|
3961
3962
|
|
|
3962
3963
|
if not MYPY:
|
|
3963
3964
|
class VerificationTemplateMetricProviderPrometheusArgsDict(TypedDict):
|
|
3964
|
-
prometheus_query: pulumi.Input[str]
|
|
3965
|
+
prometheus_query: pulumi.Input[builtins.str]
|
|
3965
3966
|
"""
|
|
3966
3967
|
A request for information retrieved from Prometheus.
|
|
3967
3968
|
"""
|
|
@@ -3971,48 +3972,48 @@ elif False:
|
|
|
3971
3972
|
@pulumi.input_type
|
|
3972
3973
|
class VerificationTemplateMetricProviderPrometheusArgs:
|
|
3973
3974
|
def __init__(__self__, *,
|
|
3974
|
-
prometheus_query: pulumi.Input[str]):
|
|
3975
|
+
prometheus_query: pulumi.Input[builtins.str]):
|
|
3975
3976
|
"""
|
|
3976
|
-
:param pulumi.Input[str] prometheus_query: A request for information retrieved from Prometheus.
|
|
3977
|
+
:param pulumi.Input[builtins.str] prometheus_query: A request for information retrieved from Prometheus.
|
|
3977
3978
|
"""
|
|
3978
3979
|
pulumi.set(__self__, "prometheus_query", prometheus_query)
|
|
3979
3980
|
|
|
3980
3981
|
@property
|
|
3981
3982
|
@pulumi.getter(name="prometheusQuery")
|
|
3982
|
-
def prometheus_query(self) -> pulumi.Input[str]:
|
|
3983
|
+
def prometheus_query(self) -> pulumi.Input[builtins.str]:
|
|
3983
3984
|
"""
|
|
3984
3985
|
A request for information retrieved from Prometheus.
|
|
3985
3986
|
"""
|
|
3986
3987
|
return pulumi.get(self, "prometheus_query")
|
|
3987
3988
|
|
|
3988
3989
|
@prometheus_query.setter
|
|
3989
|
-
def prometheus_query(self, value: pulumi.Input[str]):
|
|
3990
|
+
def prometheus_query(self, value: pulumi.Input[builtins.str]):
|
|
3990
3991
|
pulumi.set(self, "prometheus_query", value)
|
|
3991
3992
|
|
|
3992
3993
|
|
|
3993
3994
|
if not MYPY:
|
|
3994
3995
|
class VerificationTemplateMetricProviderWebArgsDict(TypedDict):
|
|
3995
|
-
url: pulumi.Input[str]
|
|
3996
|
+
url: pulumi.Input[builtins.str]
|
|
3996
3997
|
"""
|
|
3997
3998
|
The address of the web metric.
|
|
3998
3999
|
"""
|
|
3999
|
-
body: NotRequired[pulumi.Input[str]]
|
|
4000
|
+
body: NotRequired[pulumi.Input[builtins.str]]
|
|
4000
4001
|
"""
|
|
4001
4002
|
The body of the web metric.
|
|
4002
4003
|
"""
|
|
4003
|
-
insecure: NotRequired[pulumi.Input[bool]]
|
|
4004
|
+
insecure: NotRequired[pulumi.Input[builtins.bool]]
|
|
4004
4005
|
"""
|
|
4005
4006
|
Skips host TLS verification.
|
|
4006
4007
|
"""
|
|
4007
|
-
json_path: NotRequired[pulumi.Input[str]]
|
|
4008
|
+
json_path: NotRequired[pulumi.Input[builtins.str]]
|
|
4008
4009
|
"""
|
|
4009
4010
|
A JSON Path to use as the result variable. Default is "{$}"
|
|
4010
4011
|
"""
|
|
4011
|
-
method: NotRequired[pulumi.Input[str]]
|
|
4012
|
+
method: NotRequired[pulumi.Input[builtins.str]]
|
|
4012
4013
|
"""
|
|
4013
4014
|
The method of the web metric. Enum: "GET" "POST" "PUT"
|
|
4014
4015
|
"""
|
|
4015
|
-
timeout_seconds: NotRequired[pulumi.Input[int]]
|
|
4016
|
+
timeout_seconds: NotRequired[pulumi.Input[builtins.int]]
|
|
4016
4017
|
"""
|
|
4017
4018
|
The timeout for the request in seconds. Default is 10.
|
|
4018
4019
|
"""
|
|
@@ -4026,20 +4027,20 @@ elif False:
|
|
|
4026
4027
|
@pulumi.input_type
|
|
4027
4028
|
class VerificationTemplateMetricProviderWebArgs:
|
|
4028
4029
|
def __init__(__self__, *,
|
|
4029
|
-
url: pulumi.Input[str],
|
|
4030
|
-
body: Optional[pulumi.Input[str]] = None,
|
|
4031
|
-
insecure: Optional[pulumi.Input[bool]] = None,
|
|
4032
|
-
json_path: Optional[pulumi.Input[str]] = None,
|
|
4033
|
-
method: Optional[pulumi.Input[str]] = None,
|
|
4034
|
-
timeout_seconds: Optional[pulumi.Input[int]] = None,
|
|
4030
|
+
url: pulumi.Input[builtins.str],
|
|
4031
|
+
body: Optional[pulumi.Input[builtins.str]] = None,
|
|
4032
|
+
insecure: Optional[pulumi.Input[builtins.bool]] = None,
|
|
4033
|
+
json_path: Optional[pulumi.Input[builtins.str]] = None,
|
|
4034
|
+
method: Optional[pulumi.Input[builtins.str]] = None,
|
|
4035
|
+
timeout_seconds: Optional[pulumi.Input[builtins.int]] = None,
|
|
4035
4036
|
web_headers: Optional[pulumi.Input[Sequence[pulumi.Input['VerificationTemplateMetricProviderWebWebHeaderArgs']]]] = None):
|
|
4036
4037
|
"""
|
|
4037
|
-
:param pulumi.Input[str] url: The address of the web metric.
|
|
4038
|
-
:param pulumi.Input[str] body: The body of the web metric.
|
|
4039
|
-
:param pulumi.Input[bool] insecure: Skips host TLS verification.
|
|
4040
|
-
:param pulumi.Input[str] json_path: A JSON Path to use as the result variable. Default is "{$}"
|
|
4041
|
-
:param pulumi.Input[str] method: The method of the web metric. Enum: "GET" "POST" "PUT"
|
|
4042
|
-
:param pulumi.Input[int] timeout_seconds: The timeout for the request in seconds. Default is 10.
|
|
4038
|
+
:param pulumi.Input[builtins.str] url: The address of the web metric.
|
|
4039
|
+
:param pulumi.Input[builtins.str] body: The body of the web metric.
|
|
4040
|
+
:param pulumi.Input[builtins.bool] insecure: Skips host TLS verification.
|
|
4041
|
+
:param pulumi.Input[builtins.str] json_path: A JSON Path to use as the result variable. Default is "{$}"
|
|
4042
|
+
:param pulumi.Input[builtins.str] method: The method of the web metric. Enum: "GET" "POST" "PUT"
|
|
4043
|
+
:param pulumi.Input[builtins.int] timeout_seconds: The timeout for the request in seconds. Default is 10.
|
|
4043
4044
|
:param pulumi.Input[Sequence[pulumi.Input['VerificationTemplateMetricProviderWebWebHeaderArgs']]] web_headers: Optional HTTP headers to use in the request.
|
|
4044
4045
|
"""
|
|
4045
4046
|
pulumi.set(__self__, "url", url)
|
|
@@ -4058,74 +4059,74 @@ class VerificationTemplateMetricProviderWebArgs:
|
|
|
4058
4059
|
|
|
4059
4060
|
@property
|
|
4060
4061
|
@pulumi.getter
|
|
4061
|
-
def url(self) -> pulumi.Input[str]:
|
|
4062
|
+
def url(self) -> pulumi.Input[builtins.str]:
|
|
4062
4063
|
"""
|
|
4063
4064
|
The address of the web metric.
|
|
4064
4065
|
"""
|
|
4065
4066
|
return pulumi.get(self, "url")
|
|
4066
4067
|
|
|
4067
4068
|
@url.setter
|
|
4068
|
-
def url(self, value: pulumi.Input[str]):
|
|
4069
|
+
def url(self, value: pulumi.Input[builtins.str]):
|
|
4069
4070
|
pulumi.set(self, "url", value)
|
|
4070
4071
|
|
|
4071
4072
|
@property
|
|
4072
4073
|
@pulumi.getter
|
|
4073
|
-
def body(self) -> Optional[pulumi.Input[str]]:
|
|
4074
|
+
def body(self) -> Optional[pulumi.Input[builtins.str]]:
|
|
4074
4075
|
"""
|
|
4075
4076
|
The body of the web metric.
|
|
4076
4077
|
"""
|
|
4077
4078
|
return pulumi.get(self, "body")
|
|
4078
4079
|
|
|
4079
4080
|
@body.setter
|
|
4080
|
-
def body(self, value: Optional[pulumi.Input[str]]):
|
|
4081
|
+
def body(self, value: Optional[pulumi.Input[builtins.str]]):
|
|
4081
4082
|
pulumi.set(self, "body", value)
|
|
4082
4083
|
|
|
4083
4084
|
@property
|
|
4084
4085
|
@pulumi.getter
|
|
4085
|
-
def insecure(self) -> Optional[pulumi.Input[bool]]:
|
|
4086
|
+
def insecure(self) -> Optional[pulumi.Input[builtins.bool]]:
|
|
4086
4087
|
"""
|
|
4087
4088
|
Skips host TLS verification.
|
|
4088
4089
|
"""
|
|
4089
4090
|
return pulumi.get(self, "insecure")
|
|
4090
4091
|
|
|
4091
4092
|
@insecure.setter
|
|
4092
|
-
def insecure(self, value: Optional[pulumi.Input[bool]]):
|
|
4093
|
+
def insecure(self, value: Optional[pulumi.Input[builtins.bool]]):
|
|
4093
4094
|
pulumi.set(self, "insecure", value)
|
|
4094
4095
|
|
|
4095
4096
|
@property
|
|
4096
4097
|
@pulumi.getter(name="jsonPath")
|
|
4097
|
-
def json_path(self) -> Optional[pulumi.Input[str]]:
|
|
4098
|
+
def json_path(self) -> Optional[pulumi.Input[builtins.str]]:
|
|
4098
4099
|
"""
|
|
4099
4100
|
A JSON Path to use as the result variable. Default is "{$}"
|
|
4100
4101
|
"""
|
|
4101
4102
|
return pulumi.get(self, "json_path")
|
|
4102
4103
|
|
|
4103
4104
|
@json_path.setter
|
|
4104
|
-
def json_path(self, value: Optional[pulumi.Input[str]]):
|
|
4105
|
+
def json_path(self, value: Optional[pulumi.Input[builtins.str]]):
|
|
4105
4106
|
pulumi.set(self, "json_path", value)
|
|
4106
4107
|
|
|
4107
4108
|
@property
|
|
4108
4109
|
@pulumi.getter
|
|
4109
|
-
def method(self) -> Optional[pulumi.Input[str]]:
|
|
4110
|
+
def method(self) -> Optional[pulumi.Input[builtins.str]]:
|
|
4110
4111
|
"""
|
|
4111
4112
|
The method of the web metric. Enum: "GET" "POST" "PUT"
|
|
4112
4113
|
"""
|
|
4113
4114
|
return pulumi.get(self, "method")
|
|
4114
4115
|
|
|
4115
4116
|
@method.setter
|
|
4116
|
-
def method(self, value: Optional[pulumi.Input[str]]):
|
|
4117
|
+
def method(self, value: Optional[pulumi.Input[builtins.str]]):
|
|
4117
4118
|
pulumi.set(self, "method", value)
|
|
4118
4119
|
|
|
4119
4120
|
@property
|
|
4120
4121
|
@pulumi.getter(name="timeoutSeconds")
|
|
4121
|
-
def timeout_seconds(self) -> Optional[pulumi.Input[int]]:
|
|
4122
|
+
def timeout_seconds(self) -> Optional[pulumi.Input[builtins.int]]:
|
|
4122
4123
|
"""
|
|
4123
4124
|
The timeout for the request in seconds. Default is 10.
|
|
4124
4125
|
"""
|
|
4125
4126
|
return pulumi.get(self, "timeout_seconds")
|
|
4126
4127
|
|
|
4127
4128
|
@timeout_seconds.setter
|
|
4128
|
-
def timeout_seconds(self, value: Optional[pulumi.Input[int]]):
|
|
4129
|
+
def timeout_seconds(self, value: Optional[pulumi.Input[builtins.int]]):
|
|
4129
4130
|
pulumi.set(self, "timeout_seconds", value)
|
|
4130
4131
|
|
|
4131
4132
|
@property
|
|
@@ -4143,11 +4144,11 @@ class VerificationTemplateMetricProviderWebArgs:
|
|
|
4143
4144
|
|
|
4144
4145
|
if not MYPY:
|
|
4145
4146
|
class VerificationTemplateMetricProviderWebWebHeaderArgsDict(TypedDict):
|
|
4146
|
-
web_header_key: pulumi.Input[str]
|
|
4147
|
+
web_header_key: pulumi.Input[builtins.str]
|
|
4147
4148
|
"""
|
|
4148
4149
|
The name of a header
|
|
4149
4150
|
"""
|
|
4150
|
-
web_header_value: pulumi.Input[str]
|
|
4151
|
+
web_header_value: pulumi.Input[builtins.str]
|
|
4151
4152
|
"""
|
|
4152
4153
|
The value of a header
|
|
4153
4154
|
"""
|
|
@@ -4157,37 +4158,37 @@ elif False:
|
|
|
4157
4158
|
@pulumi.input_type
|
|
4158
4159
|
class VerificationTemplateMetricProviderWebWebHeaderArgs:
|
|
4159
4160
|
def __init__(__self__, *,
|
|
4160
|
-
web_header_key: pulumi.Input[str],
|
|
4161
|
-
web_header_value: pulumi.Input[str]):
|
|
4161
|
+
web_header_key: pulumi.Input[builtins.str],
|
|
4162
|
+
web_header_value: pulumi.Input[builtins.str]):
|
|
4162
4163
|
"""
|
|
4163
|
-
:param pulumi.Input[str] web_header_key: The name of a header
|
|
4164
|
-
:param pulumi.Input[str] web_header_value: The value of a header
|
|
4164
|
+
:param pulumi.Input[builtins.str] web_header_key: The name of a header
|
|
4165
|
+
:param pulumi.Input[builtins.str] web_header_value: The value of a header
|
|
4165
4166
|
"""
|
|
4166
4167
|
pulumi.set(__self__, "web_header_key", web_header_key)
|
|
4167
4168
|
pulumi.set(__self__, "web_header_value", web_header_value)
|
|
4168
4169
|
|
|
4169
4170
|
@property
|
|
4170
4171
|
@pulumi.getter(name="webHeaderKey")
|
|
4171
|
-
def web_header_key(self) -> pulumi.Input[str]:
|
|
4172
|
+
def web_header_key(self) -> pulumi.Input[builtins.str]:
|
|
4172
4173
|
"""
|
|
4173
4174
|
The name of a header
|
|
4174
4175
|
"""
|
|
4175
4176
|
return pulumi.get(self, "web_header_key")
|
|
4176
4177
|
|
|
4177
4178
|
@web_header_key.setter
|
|
4178
|
-
def web_header_key(self, value: pulumi.Input[str]):
|
|
4179
|
+
def web_header_key(self, value: pulumi.Input[builtins.str]):
|
|
4179
4180
|
pulumi.set(self, "web_header_key", value)
|
|
4180
4181
|
|
|
4181
4182
|
@property
|
|
4182
4183
|
@pulumi.getter(name="webHeaderValue")
|
|
4183
|
-
def web_header_value(self) -> pulumi.Input[str]:
|
|
4184
|
+
def web_header_value(self) -> pulumi.Input[builtins.str]:
|
|
4184
4185
|
"""
|
|
4185
4186
|
The value of a header
|
|
4186
4187
|
"""
|
|
4187
4188
|
return pulumi.get(self, "web_header_value")
|
|
4188
4189
|
|
|
4189
4190
|
@web_header_value.setter
|
|
4190
|
-
def web_header_value(self, value: pulumi.Input[str]):
|
|
4191
|
+
def web_header_value(self, value: pulumi.Input[builtins.str]):
|
|
4191
4192
|
pulumi.set(self, "web_header_value", value)
|
|
4192
4193
|
|
|
4193
4194
|
|