pulumi-spotinst 3.83.0a1720524486__py3-none-any.whl → 3.128.0a1767140134__py3-none-any.whl
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- pulumi_spotinst/__init__.py +38 -1
- pulumi_spotinst/_inputs.py +4082 -846
- pulumi_spotinst/_utilities.py +15 -10
- pulumi_spotinst/account.py +171 -0
- pulumi_spotinst/aws/__init__.py +2 -1
- pulumi_spotinst/aws/_inputs.py +7292 -2871
- pulumi_spotinst/aws/account.py +25 -19
- pulumi_spotinst/aws/beanstalk.py +272 -190
- pulumi_spotinst/aws/credentials.py +42 -36
- pulumi_spotinst/aws/elastigroup.py +1321 -1176
- pulumi_spotinst/aws/managed_instance.py +633 -526
- pulumi_spotinst/aws/mr_scalar.py +827 -983
- pulumi_spotinst/aws/ocean.py +764 -570
- pulumi_spotinst/aws/ocean_extended_resource_definition.py +42 -36
- pulumi_spotinst/aws/ocean_launch_spec.py +580 -366
- pulumi_spotinst/aws/outputs.py +3421 -2205
- pulumi_spotinst/aws/suspension.py +51 -45
- pulumi_spotinst/azure/__init__.py +2 -1
- pulumi_spotinst/azure/_inputs.py +1492 -434
- pulumi_spotinst/azure/ocean_np.py +518 -464
- pulumi_spotinst/azure/ocean_np_virtual_node_group.py +479 -408
- pulumi_spotinst/azure/outputs.py +840 -345
- pulumi_spotinst/config/__init__.py +2 -1
- pulumi_spotinst/config/__init__.pyi +7 -2
- pulumi_spotinst/config/vars.py +11 -6
- pulumi_spotinst/credentials_azure.py +423 -0
- pulumi_spotinst/credentials_gcp.py +632 -0
- pulumi_spotinst/data_integration.py +58 -52
- pulumi_spotinst/ecs/__init__.py +2 -1
- pulumi_spotinst/ecs/_inputs.py +1164 -469
- pulumi_spotinst/ecs/ocean.py +711 -446
- pulumi_spotinst/ecs/ocean_launch_spec.py +367 -341
- pulumi_spotinst/ecs/outputs.py +463 -374
- pulumi_spotinst/elastigroup_azure_v3.py +985 -197
- pulumi_spotinst/gcp/__init__.py +2 -1
- pulumi_spotinst/gcp/_inputs.py +1061 -381
- pulumi_spotinst/gcp/elastigroup.py +885 -567
- pulumi_spotinst/gcp/outputs.py +542 -301
- pulumi_spotinst/gke/__init__.py +2 -1
- pulumi_spotinst/gke/_inputs.py +2071 -715
- pulumi_spotinst/gke/elastigroup.py +558 -382
- pulumi_spotinst/gke/ocean_import.py +379 -255
- pulumi_spotinst/gke/ocean_launch_spec.py +501 -384
- pulumi_spotinst/gke/ocean_launch_spec_import.py +42 -36
- pulumi_spotinst/gke/outputs.py +1063 -528
- pulumi_spotinst/health_check.py +116 -70
- pulumi_spotinst/notification_center.py +344 -0
- pulumi_spotinst/ocean_right_sizing_rule.py +515 -95
- pulumi_spotinst/oceancd/__init__.py +2 -1
- pulumi_spotinst/oceancd/_inputs.py +1709 -651
- pulumi_spotinst/oceancd/outputs.py +537 -526
- pulumi_spotinst/oceancd/rollout_spec.py +65 -59
- pulumi_spotinst/oceancd/strategy.py +37 -31
- pulumi_spotinst/oceancd/verification_provider.py +128 -122
- pulumi_spotinst/oceancd/verification_template.py +265 -259
- pulumi_spotinst/organization/__init__.py +2 -1
- pulumi_spotinst/organization/_inputs.py +151 -57
- pulumi_spotinst/organization/outputs.py +51 -46
- pulumi_spotinst/organization/policy.py +76 -70
- pulumi_spotinst/organization/programmatic_user.py +83 -77
- pulumi_spotinst/organization/user.py +126 -120
- pulumi_spotinst/organization/user_group.py +75 -69
- pulumi_spotinst/outputs.py +3005 -832
- pulumi_spotinst/provider.py +66 -40
- pulumi_spotinst/pulumi-plugin.json +1 -1
- pulumi_spotinst/spark/__init__.py +2 -1
- pulumi_spotinst/spark/_inputs.py +290 -81
- pulumi_spotinst/spark/ocean.py +169 -115
- pulumi_spotinst/spark/ocean_virtual_node_group.py +34 -28
- pulumi_spotinst/spark/outputs.py +136 -66
- pulumi_spotinst/stateful_node_azure.py +820 -784
- pulumi_spotinst/subscription.py +93 -87
- {pulumi_spotinst-3.83.0a1720524486.dist-info → pulumi_spotinst-3.128.0a1767140134.dist-info}/METADATA +7 -6
- pulumi_spotinst-3.128.0a1767140134.dist-info/RECORD +77 -0
- {pulumi_spotinst-3.83.0a1720524486.dist-info → pulumi_spotinst-3.128.0a1767140134.dist-info}/WHEEL +1 -1
- pulumi_spotinst-3.83.0a1720524486.dist-info/RECORD +0 -73
- {pulumi_spotinst-3.83.0a1720524486.dist-info → pulumi_spotinst-3.128.0a1767140134.dist-info}/top_level.txt +0 -0
|
@@ -1,112 +1,208 @@
|
|
|
1
1
|
# coding=utf-8
|
|
2
|
-
# *** WARNING: this file was generated by
|
|
2
|
+
# *** WARNING: this file was generated by pulumi-language-python. ***
|
|
3
3
|
# *** Do not edit by hand unless you're certain you know what you are doing! ***
|
|
4
4
|
|
|
5
|
-
import
|
|
5
|
+
import builtins as _builtins
|
|
6
6
|
import warnings
|
|
7
|
+
import sys
|
|
7
8
|
import pulumi
|
|
8
9
|
import pulumi.runtime
|
|
9
10
|
from typing import Any, Mapping, Optional, Sequence, Union, overload
|
|
11
|
+
if sys.version_info >= (3, 11):
|
|
12
|
+
from typing import NotRequired, TypedDict, TypeAlias
|
|
13
|
+
else:
|
|
14
|
+
from typing_extensions import NotRequired, TypedDict, TypeAlias
|
|
10
15
|
from .. import _utilities
|
|
11
16
|
|
|
12
17
|
__all__ = [
|
|
13
18
|
'RolloutSpecFailurePolicyArgs',
|
|
19
|
+
'RolloutSpecFailurePolicyArgsDict',
|
|
14
20
|
'RolloutSpecSpotDeploymentArgs',
|
|
21
|
+
'RolloutSpecSpotDeploymentArgsDict',
|
|
15
22
|
'RolloutSpecStrategyArgs',
|
|
23
|
+
'RolloutSpecStrategyArgsDict',
|
|
16
24
|
'RolloutSpecStrategyArgArgs',
|
|
25
|
+
'RolloutSpecStrategyArgArgsDict',
|
|
17
26
|
'RolloutSpecStrategyArgValueFromArgs',
|
|
27
|
+
'RolloutSpecStrategyArgValueFromArgsDict',
|
|
18
28
|
'RolloutSpecStrategyArgValueFromFieldRefArgs',
|
|
29
|
+
'RolloutSpecStrategyArgValueFromFieldRefArgsDict',
|
|
19
30
|
'RolloutSpecTrafficArgs',
|
|
31
|
+
'RolloutSpecTrafficArgsDict',
|
|
20
32
|
'RolloutSpecTrafficAlbArgs',
|
|
33
|
+
'RolloutSpecTrafficAlbArgsDict',
|
|
21
34
|
'RolloutSpecTrafficAlbStickinessConfigArgs',
|
|
35
|
+
'RolloutSpecTrafficAlbStickinessConfigArgsDict',
|
|
22
36
|
'RolloutSpecTrafficAmbassadorArgs',
|
|
37
|
+
'RolloutSpecTrafficAmbassadorArgsDict',
|
|
23
38
|
'RolloutSpecTrafficIstioArgs',
|
|
39
|
+
'RolloutSpecTrafficIstioArgsDict',
|
|
24
40
|
'RolloutSpecTrafficIstioDestinationRuleArgs',
|
|
41
|
+
'RolloutSpecTrafficIstioDestinationRuleArgsDict',
|
|
25
42
|
'RolloutSpecTrafficIstioVirtualServiceArgs',
|
|
43
|
+
'RolloutSpecTrafficIstioVirtualServiceArgsDict',
|
|
26
44
|
'RolloutSpecTrafficIstioVirtualServiceTlsRouteArgs',
|
|
45
|
+
'RolloutSpecTrafficIstioVirtualServiceTlsRouteArgsDict',
|
|
27
46
|
'RolloutSpecTrafficNginxArgs',
|
|
47
|
+
'RolloutSpecTrafficNginxArgsDict',
|
|
28
48
|
'RolloutSpecTrafficNginxAdditionalIngressAnnotationArgs',
|
|
49
|
+
'RolloutSpecTrafficNginxAdditionalIngressAnnotationArgsDict',
|
|
29
50
|
'RolloutSpecTrafficPingPongArgs',
|
|
51
|
+
'RolloutSpecTrafficPingPongArgsDict',
|
|
30
52
|
'RolloutSpecTrafficSmiArgs',
|
|
53
|
+
'RolloutSpecTrafficSmiArgsDict',
|
|
31
54
|
'StrategyCanaryArgs',
|
|
55
|
+
'StrategyCanaryArgsDict',
|
|
32
56
|
'StrategyCanaryBackgroundVerificationArgs',
|
|
57
|
+
'StrategyCanaryBackgroundVerificationArgsDict',
|
|
33
58
|
'StrategyCanaryStepArgs',
|
|
59
|
+
'StrategyCanaryStepArgsDict',
|
|
34
60
|
'StrategyCanaryStepPauseArgs',
|
|
61
|
+
'StrategyCanaryStepPauseArgsDict',
|
|
35
62
|
'StrategyCanaryStepSetCanaryScaleArgs',
|
|
63
|
+
'StrategyCanaryStepSetCanaryScaleArgsDict',
|
|
36
64
|
'StrategyCanaryStepSetHeaderRouteArgs',
|
|
65
|
+
'StrategyCanaryStepSetHeaderRouteArgsDict',
|
|
37
66
|
'StrategyCanaryStepSetHeaderRouteMatchArgs',
|
|
67
|
+
'StrategyCanaryStepSetHeaderRouteMatchArgsDict',
|
|
38
68
|
'StrategyCanaryStepSetHeaderRouteMatchHeaderValueArgs',
|
|
69
|
+
'StrategyCanaryStepSetHeaderRouteMatchHeaderValueArgsDict',
|
|
39
70
|
'StrategyCanaryStepVerificationArgs',
|
|
71
|
+
'StrategyCanaryStepVerificationArgsDict',
|
|
40
72
|
'StrategyRollingArgs',
|
|
73
|
+
'StrategyRollingArgsDict',
|
|
41
74
|
'StrategyRollingStepArgs',
|
|
75
|
+
'StrategyRollingStepArgsDict',
|
|
42
76
|
'StrategyRollingStepPauseArgs',
|
|
77
|
+
'StrategyRollingStepPauseArgsDict',
|
|
43
78
|
'StrategyRollingStepVerificationArgs',
|
|
79
|
+
'StrategyRollingStepVerificationArgsDict',
|
|
44
80
|
'VerificationProviderCloudWatchArgs',
|
|
81
|
+
'VerificationProviderCloudWatchArgsDict',
|
|
45
82
|
'VerificationProviderDatadogArgs',
|
|
83
|
+
'VerificationProviderDatadogArgsDict',
|
|
46
84
|
'VerificationProviderJenkinsArgs',
|
|
85
|
+
'VerificationProviderJenkinsArgsDict',
|
|
47
86
|
'VerificationProviderNewRelicArgs',
|
|
87
|
+
'VerificationProviderNewRelicArgsDict',
|
|
48
88
|
'VerificationProviderPrometheusArgs',
|
|
89
|
+
'VerificationProviderPrometheusArgsDict',
|
|
49
90
|
'VerificationTemplateArgArgs',
|
|
91
|
+
'VerificationTemplateArgArgsDict',
|
|
50
92
|
'VerificationTemplateArgValueFromArgs',
|
|
93
|
+
'VerificationTemplateArgValueFromArgsDict',
|
|
51
94
|
'VerificationTemplateArgValueFromSecretKeyRefArgs',
|
|
95
|
+
'VerificationTemplateArgValueFromSecretKeyRefArgsDict',
|
|
52
96
|
'VerificationTemplateMetricArgs',
|
|
97
|
+
'VerificationTemplateMetricArgsDict',
|
|
53
98
|
'VerificationTemplateMetricBaselineArgs',
|
|
99
|
+
'VerificationTemplateMetricBaselineArgsDict',
|
|
54
100
|
'VerificationTemplateMetricBaselineBaselineProviderArgs',
|
|
101
|
+
'VerificationTemplateMetricBaselineBaselineProviderArgsDict',
|
|
55
102
|
'VerificationTemplateMetricBaselineBaselineProviderDatadogArgs',
|
|
103
|
+
'VerificationTemplateMetricBaselineBaselineProviderDatadogArgsDict',
|
|
56
104
|
'VerificationTemplateMetricBaselineBaselineProviderNewRelicArgs',
|
|
105
|
+
'VerificationTemplateMetricBaselineBaselineProviderNewRelicArgsDict',
|
|
57
106
|
'VerificationTemplateMetricBaselineBaselineProviderPrometheusArgs',
|
|
107
|
+
'VerificationTemplateMetricBaselineBaselineProviderPrometheusArgsDict',
|
|
58
108
|
'VerificationTemplateMetricProviderArgs',
|
|
109
|
+
'VerificationTemplateMetricProviderArgsDict',
|
|
59
110
|
'VerificationTemplateMetricProviderCloudWatchArgs',
|
|
111
|
+
'VerificationTemplateMetricProviderCloudWatchArgsDict',
|
|
60
112
|
'VerificationTemplateMetricProviderCloudWatchMetricDataQueryArgs',
|
|
113
|
+
'VerificationTemplateMetricProviderCloudWatchMetricDataQueryArgsDict',
|
|
61
114
|
'VerificationTemplateMetricProviderCloudWatchMetricDataQueryMetricStatArgs',
|
|
115
|
+
'VerificationTemplateMetricProviderCloudWatchMetricDataQueryMetricStatArgsDict',
|
|
62
116
|
'VerificationTemplateMetricProviderCloudWatchMetricDataQueryMetricStatMetricArgs',
|
|
117
|
+
'VerificationTemplateMetricProviderCloudWatchMetricDataQueryMetricStatMetricArgsDict',
|
|
63
118
|
'VerificationTemplateMetricProviderCloudWatchMetricDataQueryMetricStatMetricDimensionArgs',
|
|
119
|
+
'VerificationTemplateMetricProviderCloudWatchMetricDataQueryMetricStatMetricDimensionArgsDict',
|
|
64
120
|
'VerificationTemplateMetricProviderDatadogArgs',
|
|
121
|
+
'VerificationTemplateMetricProviderDatadogArgsDict',
|
|
65
122
|
'VerificationTemplateMetricProviderJenkinsArgs',
|
|
123
|
+
'VerificationTemplateMetricProviderJenkinsArgsDict',
|
|
66
124
|
'VerificationTemplateMetricProviderJenkinsJenkinsParametersArgs',
|
|
125
|
+
'VerificationTemplateMetricProviderJenkinsJenkinsParametersArgsDict',
|
|
67
126
|
'VerificationTemplateMetricProviderJobArgs',
|
|
127
|
+
'VerificationTemplateMetricProviderJobArgsDict',
|
|
68
128
|
'VerificationTemplateMetricProviderJobSpecArgs',
|
|
129
|
+
'VerificationTemplateMetricProviderJobSpecArgsDict',
|
|
69
130
|
'VerificationTemplateMetricProviderJobSpecJobTemplateArgs',
|
|
131
|
+
'VerificationTemplateMetricProviderJobSpecJobTemplateArgsDict',
|
|
70
132
|
'VerificationTemplateMetricProviderJobSpecJobTemplateTemplateSpecArgs',
|
|
133
|
+
'VerificationTemplateMetricProviderJobSpecJobTemplateTemplateSpecArgsDict',
|
|
71
134
|
'VerificationTemplateMetricProviderJobSpecJobTemplateTemplateSpecContainerArgs',
|
|
135
|
+
'VerificationTemplateMetricProviderJobSpecJobTemplateTemplateSpecContainerArgsDict',
|
|
72
136
|
'VerificationTemplateMetricProviderNewRelicArgs',
|
|
137
|
+
'VerificationTemplateMetricProviderNewRelicArgsDict',
|
|
73
138
|
'VerificationTemplateMetricProviderPrometheusArgs',
|
|
139
|
+
'VerificationTemplateMetricProviderPrometheusArgsDict',
|
|
74
140
|
'VerificationTemplateMetricProviderWebArgs',
|
|
141
|
+
'VerificationTemplateMetricProviderWebArgsDict',
|
|
75
142
|
'VerificationTemplateMetricProviderWebWebHeaderArgs',
|
|
143
|
+
'VerificationTemplateMetricProviderWebWebHeaderArgsDict',
|
|
76
144
|
]
|
|
77
145
|
|
|
146
|
+
MYPY = False
|
|
147
|
+
|
|
148
|
+
if not MYPY:
|
|
149
|
+
class RolloutSpecFailurePolicyArgsDict(TypedDict):
|
|
150
|
+
action: pulumi.Input[_builtins.str]
|
|
151
|
+
"""
|
|
152
|
+
Choose an action to perform on failure. Default is `abort`. Enum: "abort" "pause" "promote".
|
|
153
|
+
"""
|
|
154
|
+
elif False:
|
|
155
|
+
RolloutSpecFailurePolicyArgsDict: TypeAlias = Mapping[str, Any]
|
|
156
|
+
|
|
78
157
|
@pulumi.input_type
|
|
79
158
|
class RolloutSpecFailurePolicyArgs:
|
|
80
159
|
def __init__(__self__, *,
|
|
81
|
-
action: pulumi.Input[str]):
|
|
160
|
+
action: pulumi.Input[_builtins.str]):
|
|
82
161
|
"""
|
|
83
|
-
:param pulumi.Input[str] action: Choose an action to perform on failure. Default is `abort`. Enum: "abort" "pause" "promote".
|
|
162
|
+
:param pulumi.Input[_builtins.str] action: Choose an action to perform on failure. Default is `abort`. Enum: "abort" "pause" "promote".
|
|
84
163
|
"""
|
|
85
164
|
pulumi.set(__self__, "action", action)
|
|
86
165
|
|
|
87
|
-
@property
|
|
166
|
+
@_builtins.property
|
|
88
167
|
@pulumi.getter
|
|
89
|
-
def action(self) -> pulumi.Input[str]:
|
|
168
|
+
def action(self) -> pulumi.Input[_builtins.str]:
|
|
90
169
|
"""
|
|
91
170
|
Choose an action to perform on failure. Default is `abort`. Enum: "abort" "pause" "promote".
|
|
92
171
|
"""
|
|
93
172
|
return pulumi.get(self, "action")
|
|
94
173
|
|
|
95
174
|
@action.setter
|
|
96
|
-
def action(self, value: pulumi.Input[str]):
|
|
175
|
+
def action(self, value: pulumi.Input[_builtins.str]):
|
|
97
176
|
pulumi.set(self, "action", value)
|
|
98
177
|
|
|
99
178
|
|
|
179
|
+
if not MYPY:
|
|
180
|
+
class RolloutSpecSpotDeploymentArgsDict(TypedDict):
|
|
181
|
+
spot_deployments_cluster_id: NotRequired[pulumi.Input[_builtins.str]]
|
|
182
|
+
"""
|
|
183
|
+
Ocean CD cluster identifier for the references `SpotDeployment`.
|
|
184
|
+
"""
|
|
185
|
+
spot_deployments_name: NotRequired[pulumi.Input[_builtins.str]]
|
|
186
|
+
"""
|
|
187
|
+
The name of the `SpotDeployment` resource
|
|
188
|
+
"""
|
|
189
|
+
spot_deployments_namespace: NotRequired[pulumi.Input[_builtins.str]]
|
|
190
|
+
"""
|
|
191
|
+
The namespace which the `SpotDeployment` resource exists within.
|
|
192
|
+
"""
|
|
193
|
+
elif False:
|
|
194
|
+
RolloutSpecSpotDeploymentArgsDict: TypeAlias = Mapping[str, Any]
|
|
195
|
+
|
|
100
196
|
@pulumi.input_type
|
|
101
197
|
class RolloutSpecSpotDeploymentArgs:
|
|
102
198
|
def __init__(__self__, *,
|
|
103
|
-
spot_deployments_cluster_id: Optional[pulumi.Input[str]] = None,
|
|
104
|
-
spot_deployments_name: Optional[pulumi.Input[str]] = None,
|
|
105
|
-
spot_deployments_namespace: Optional[pulumi.Input[str]] = None):
|
|
199
|
+
spot_deployments_cluster_id: Optional[pulumi.Input[_builtins.str]] = None,
|
|
200
|
+
spot_deployments_name: Optional[pulumi.Input[_builtins.str]] = None,
|
|
201
|
+
spot_deployments_namespace: Optional[pulumi.Input[_builtins.str]] = None):
|
|
106
202
|
"""
|
|
107
|
-
:param pulumi.Input[str] spot_deployments_cluster_id: Ocean CD cluster identifier for the references `SpotDeployment`.
|
|
108
|
-
:param pulumi.Input[str] spot_deployments_name: The name of the `SpotDeployment` resource
|
|
109
|
-
:param pulumi.Input[str] spot_deployments_namespace: The namespace which the `SpotDeployment` resource exists within.
|
|
203
|
+
:param pulumi.Input[_builtins.str] spot_deployments_cluster_id: Ocean CD cluster identifier for the references `SpotDeployment`.
|
|
204
|
+
:param pulumi.Input[_builtins.str] spot_deployments_name: The name of the `SpotDeployment` resource
|
|
205
|
+
:param pulumi.Input[_builtins.str] spot_deployments_namespace: The namespace which the `SpotDeployment` resource exists within.
|
|
110
206
|
"""
|
|
111
207
|
if spot_deployments_cluster_id is not None:
|
|
112
208
|
pulumi.set(__self__, "spot_deployments_cluster_id", spot_deployments_cluster_id)
|
|
@@ -115,69 +211,82 @@ class RolloutSpecSpotDeploymentArgs:
|
|
|
115
211
|
if spot_deployments_namespace is not None:
|
|
116
212
|
pulumi.set(__self__, "spot_deployments_namespace", spot_deployments_namespace)
|
|
117
213
|
|
|
118
|
-
@property
|
|
214
|
+
@_builtins.property
|
|
119
215
|
@pulumi.getter(name="spotDeploymentsClusterId")
|
|
120
|
-
def spot_deployments_cluster_id(self) -> Optional[pulumi.Input[str]]:
|
|
216
|
+
def spot_deployments_cluster_id(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
121
217
|
"""
|
|
122
218
|
Ocean CD cluster identifier for the references `SpotDeployment`.
|
|
123
219
|
"""
|
|
124
220
|
return pulumi.get(self, "spot_deployments_cluster_id")
|
|
125
221
|
|
|
126
222
|
@spot_deployments_cluster_id.setter
|
|
127
|
-
def spot_deployments_cluster_id(self, value: Optional[pulumi.Input[str]]):
|
|
223
|
+
def spot_deployments_cluster_id(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
128
224
|
pulumi.set(self, "spot_deployments_cluster_id", value)
|
|
129
225
|
|
|
130
|
-
@property
|
|
226
|
+
@_builtins.property
|
|
131
227
|
@pulumi.getter(name="spotDeploymentsName")
|
|
132
|
-
def spot_deployments_name(self) -> Optional[pulumi.Input[str]]:
|
|
228
|
+
def spot_deployments_name(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
133
229
|
"""
|
|
134
230
|
The name of the `SpotDeployment` resource
|
|
135
231
|
"""
|
|
136
232
|
return pulumi.get(self, "spot_deployments_name")
|
|
137
233
|
|
|
138
234
|
@spot_deployments_name.setter
|
|
139
|
-
def spot_deployments_name(self, value: Optional[pulumi.Input[str]]):
|
|
235
|
+
def spot_deployments_name(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
140
236
|
pulumi.set(self, "spot_deployments_name", value)
|
|
141
237
|
|
|
142
|
-
@property
|
|
238
|
+
@_builtins.property
|
|
143
239
|
@pulumi.getter(name="spotDeploymentsNamespace")
|
|
144
|
-
def spot_deployments_namespace(self) -> Optional[pulumi.Input[str]]:
|
|
240
|
+
def spot_deployments_namespace(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
145
241
|
"""
|
|
146
242
|
The namespace which the `SpotDeployment` resource exists within.
|
|
147
243
|
"""
|
|
148
244
|
return pulumi.get(self, "spot_deployments_namespace")
|
|
149
245
|
|
|
150
246
|
@spot_deployments_namespace.setter
|
|
151
|
-
def spot_deployments_namespace(self, value: Optional[pulumi.Input[str]]):
|
|
247
|
+
def spot_deployments_namespace(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
152
248
|
pulumi.set(self, "spot_deployments_namespace", value)
|
|
153
249
|
|
|
154
250
|
|
|
251
|
+
if not MYPY:
|
|
252
|
+
class RolloutSpecStrategyArgsDict(TypedDict):
|
|
253
|
+
strategy_name: pulumi.Input[_builtins.str]
|
|
254
|
+
"""
|
|
255
|
+
Ocean CD strategy name identifier.
|
|
256
|
+
"""
|
|
257
|
+
args: NotRequired[pulumi.Input[Sequence[pulumi.Input['RolloutSpecStrategyArgArgsDict']]]]
|
|
258
|
+
"""
|
|
259
|
+
Arguments defined in Verification Templates.
|
|
260
|
+
"""
|
|
261
|
+
elif False:
|
|
262
|
+
RolloutSpecStrategyArgsDict: TypeAlias = Mapping[str, Any]
|
|
263
|
+
|
|
155
264
|
@pulumi.input_type
|
|
156
265
|
class RolloutSpecStrategyArgs:
|
|
157
266
|
def __init__(__self__, *,
|
|
158
|
-
strategy_name: pulumi.Input[str],
|
|
267
|
+
strategy_name: pulumi.Input[_builtins.str],
|
|
159
268
|
args: Optional[pulumi.Input[Sequence[pulumi.Input['RolloutSpecStrategyArgArgs']]]] = None):
|
|
160
269
|
"""
|
|
161
|
-
:param pulumi.Input[str] strategy_name: Ocean CD strategy name identifier.
|
|
270
|
+
:param pulumi.Input[_builtins.str] strategy_name: Ocean CD strategy name identifier.
|
|
162
271
|
:param pulumi.Input[Sequence[pulumi.Input['RolloutSpecStrategyArgArgs']]] args: Arguments defined in Verification Templates.
|
|
163
272
|
"""
|
|
164
273
|
pulumi.set(__self__, "strategy_name", strategy_name)
|
|
165
274
|
if args is not None:
|
|
166
275
|
pulumi.set(__self__, "args", args)
|
|
167
276
|
|
|
168
|
-
@property
|
|
277
|
+
@_builtins.property
|
|
169
278
|
@pulumi.getter(name="strategyName")
|
|
170
|
-
def strategy_name(self) -> pulumi.Input[str]:
|
|
279
|
+
def strategy_name(self) -> pulumi.Input[_builtins.str]:
|
|
171
280
|
"""
|
|
172
281
|
Ocean CD strategy name identifier.
|
|
173
282
|
"""
|
|
174
283
|
return pulumi.get(self, "strategy_name")
|
|
175
284
|
|
|
176
285
|
@strategy_name.setter
|
|
177
|
-
def strategy_name(self, value: pulumi.Input[str]):
|
|
286
|
+
def strategy_name(self, value: pulumi.Input[_builtins.str]):
|
|
178
287
|
pulumi.set(self, "strategy_name", value)
|
|
179
288
|
|
|
180
|
-
@property
|
|
289
|
+
@_builtins.property
|
|
181
290
|
@pulumi.getter
|
|
182
291
|
def args(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['RolloutSpecStrategyArgArgs']]]]:
|
|
183
292
|
"""
|
|
@@ -190,15 +299,32 @@ class RolloutSpecStrategyArgs:
|
|
|
190
299
|
pulumi.set(self, "args", value)
|
|
191
300
|
|
|
192
301
|
|
|
302
|
+
if not MYPY:
|
|
303
|
+
class RolloutSpecStrategyArgArgsDict(TypedDict):
|
|
304
|
+
arg_name: pulumi.Input[_builtins.str]
|
|
305
|
+
"""
|
|
306
|
+
Name of an argument.
|
|
307
|
+
"""
|
|
308
|
+
arg_value: NotRequired[pulumi.Input[_builtins.str]]
|
|
309
|
+
"""
|
|
310
|
+
Value of an argument.
|
|
311
|
+
"""
|
|
312
|
+
value_from: NotRequired[pulumi.Input['RolloutSpecStrategyArgValueFromArgsDict']]
|
|
313
|
+
"""
|
|
314
|
+
Defines from where to get the value of an argument.
|
|
315
|
+
"""
|
|
316
|
+
elif False:
|
|
317
|
+
RolloutSpecStrategyArgArgsDict: TypeAlias = Mapping[str, Any]
|
|
318
|
+
|
|
193
319
|
@pulumi.input_type
|
|
194
320
|
class RolloutSpecStrategyArgArgs:
|
|
195
321
|
def __init__(__self__, *,
|
|
196
|
-
arg_name: pulumi.Input[str],
|
|
197
|
-
arg_value: Optional[pulumi.Input[str]] = None,
|
|
322
|
+
arg_name: pulumi.Input[_builtins.str],
|
|
323
|
+
arg_value: Optional[pulumi.Input[_builtins.str]] = None,
|
|
198
324
|
value_from: Optional[pulumi.Input['RolloutSpecStrategyArgValueFromArgs']] = None):
|
|
199
325
|
"""
|
|
200
|
-
:param pulumi.Input[str] arg_name: Name of an argument.
|
|
201
|
-
:param pulumi.Input[str] arg_value: Value of an argument.
|
|
326
|
+
:param pulumi.Input[_builtins.str] arg_name: Name of an argument.
|
|
327
|
+
:param pulumi.Input[_builtins.str] arg_value: Value of an argument.
|
|
202
328
|
:param pulumi.Input['RolloutSpecStrategyArgValueFromArgs'] value_from: Defines from where to get the value of an argument.
|
|
203
329
|
"""
|
|
204
330
|
pulumi.set(__self__, "arg_name", arg_name)
|
|
@@ -207,31 +333,31 @@ class RolloutSpecStrategyArgArgs:
|
|
|
207
333
|
if value_from is not None:
|
|
208
334
|
pulumi.set(__self__, "value_from", value_from)
|
|
209
335
|
|
|
210
|
-
@property
|
|
336
|
+
@_builtins.property
|
|
211
337
|
@pulumi.getter(name="argName")
|
|
212
|
-
def arg_name(self) -> pulumi.Input[str]:
|
|
338
|
+
def arg_name(self) -> pulumi.Input[_builtins.str]:
|
|
213
339
|
"""
|
|
214
340
|
Name of an argument.
|
|
215
341
|
"""
|
|
216
342
|
return pulumi.get(self, "arg_name")
|
|
217
343
|
|
|
218
344
|
@arg_name.setter
|
|
219
|
-
def arg_name(self, value: pulumi.Input[str]):
|
|
345
|
+
def arg_name(self, value: pulumi.Input[_builtins.str]):
|
|
220
346
|
pulumi.set(self, "arg_name", value)
|
|
221
347
|
|
|
222
|
-
@property
|
|
348
|
+
@_builtins.property
|
|
223
349
|
@pulumi.getter(name="argValue")
|
|
224
|
-
def arg_value(self) -> Optional[pulumi.Input[str]]:
|
|
350
|
+
def arg_value(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
225
351
|
"""
|
|
226
352
|
Value of an argument.
|
|
227
353
|
"""
|
|
228
354
|
return pulumi.get(self, "arg_value")
|
|
229
355
|
|
|
230
356
|
@arg_value.setter
|
|
231
|
-
def arg_value(self, value: Optional[pulumi.Input[str]]):
|
|
357
|
+
def arg_value(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
232
358
|
pulumi.set(self, "arg_value", value)
|
|
233
359
|
|
|
234
|
-
@property
|
|
360
|
+
@_builtins.property
|
|
235
361
|
@pulumi.getter(name="valueFrom")
|
|
236
362
|
def value_from(self) -> Optional[pulumi.Input['RolloutSpecStrategyArgValueFromArgs']]:
|
|
237
363
|
"""
|
|
@@ -244,6 +370,15 @@ class RolloutSpecStrategyArgArgs:
|
|
|
244
370
|
pulumi.set(self, "value_from", value)
|
|
245
371
|
|
|
246
372
|
|
|
373
|
+
if not MYPY:
|
|
374
|
+
class RolloutSpecStrategyArgValueFromArgsDict(TypedDict):
|
|
375
|
+
field_ref: pulumi.Input['RolloutSpecStrategyArgValueFromFieldRefArgsDict']
|
|
376
|
+
"""
|
|
377
|
+
Defines the field path from where to get the value of an argument.
|
|
378
|
+
"""
|
|
379
|
+
elif False:
|
|
380
|
+
RolloutSpecStrategyArgValueFromArgsDict: TypeAlias = Mapping[str, Any]
|
|
381
|
+
|
|
247
382
|
@pulumi.input_type
|
|
248
383
|
class RolloutSpecStrategyArgValueFromArgs:
|
|
249
384
|
def __init__(__self__, *,
|
|
@@ -253,7 +388,7 @@ class RolloutSpecStrategyArgValueFromArgs:
|
|
|
253
388
|
"""
|
|
254
389
|
pulumi.set(__self__, "field_ref", field_ref)
|
|
255
390
|
|
|
256
|
-
@property
|
|
391
|
+
@_builtins.property
|
|
257
392
|
@pulumi.getter(name="fieldRef")
|
|
258
393
|
def field_ref(self) -> pulumi.Input['RolloutSpecStrategyArgValueFromFieldRefArgs']:
|
|
259
394
|
"""
|
|
@@ -266,48 +401,94 @@ class RolloutSpecStrategyArgValueFromArgs:
|
|
|
266
401
|
pulumi.set(self, "field_ref", value)
|
|
267
402
|
|
|
268
403
|
|
|
404
|
+
if not MYPY:
|
|
405
|
+
class RolloutSpecStrategyArgValueFromFieldRefArgsDict(TypedDict):
|
|
406
|
+
field_path: pulumi.Input[_builtins.str]
|
|
407
|
+
"""
|
|
408
|
+
Path to SpotDeployment's field from where to get the value of an argument.
|
|
409
|
+
"""
|
|
410
|
+
elif False:
|
|
411
|
+
RolloutSpecStrategyArgValueFromFieldRefArgsDict: TypeAlias = Mapping[str, Any]
|
|
412
|
+
|
|
269
413
|
@pulumi.input_type
|
|
270
414
|
class RolloutSpecStrategyArgValueFromFieldRefArgs:
|
|
271
415
|
def __init__(__self__, *,
|
|
272
|
-
field_path: pulumi.Input[str]):
|
|
416
|
+
field_path: pulumi.Input[_builtins.str]):
|
|
273
417
|
"""
|
|
274
|
-
:param pulumi.Input[str] field_path: Path to SpotDeployment's field from where to get the value of an argument.
|
|
418
|
+
:param pulumi.Input[_builtins.str] field_path: Path to SpotDeployment's field from where to get the value of an argument.
|
|
275
419
|
"""
|
|
276
420
|
pulumi.set(__self__, "field_path", field_path)
|
|
277
421
|
|
|
278
|
-
@property
|
|
422
|
+
@_builtins.property
|
|
279
423
|
@pulumi.getter(name="fieldPath")
|
|
280
|
-
def field_path(self) -> pulumi.Input[str]:
|
|
424
|
+
def field_path(self) -> pulumi.Input[_builtins.str]:
|
|
281
425
|
"""
|
|
282
426
|
Path to SpotDeployment's field from where to get the value of an argument.
|
|
283
427
|
"""
|
|
284
428
|
return pulumi.get(self, "field_path")
|
|
285
429
|
|
|
286
430
|
@field_path.setter
|
|
287
|
-
def field_path(self, value: pulumi.Input[str]):
|
|
431
|
+
def field_path(self, value: pulumi.Input[_builtins.str]):
|
|
288
432
|
pulumi.set(self, "field_path", value)
|
|
289
433
|
|
|
290
434
|
|
|
435
|
+
if not MYPY:
|
|
436
|
+
class RolloutSpecTrafficArgsDict(TypedDict):
|
|
437
|
+
alb: NotRequired[pulumi.Input['RolloutSpecTrafficAlbArgsDict']]
|
|
438
|
+
"""
|
|
439
|
+
Holds ALB Ingress specific configuration to route traffic.
|
|
440
|
+
"""
|
|
441
|
+
ambassador: NotRequired[pulumi.Input['RolloutSpecTrafficAmbassadorArgsDict']]
|
|
442
|
+
"""
|
|
443
|
+
Holds specific configuration to use Ambassador to route traffic.
|
|
444
|
+
"""
|
|
445
|
+
canary_service: NotRequired[pulumi.Input[_builtins.str]]
|
|
446
|
+
"""
|
|
447
|
+
The canary service name.
|
|
448
|
+
"""
|
|
449
|
+
istio: NotRequired[pulumi.Input['RolloutSpecTrafficIstioArgsDict']]
|
|
450
|
+
"""
|
|
451
|
+
Holds Istio specific configuration to route traffic.
|
|
452
|
+
"""
|
|
453
|
+
nginx: NotRequired[pulumi.Input['RolloutSpecTrafficNginxArgsDict']]
|
|
454
|
+
"""
|
|
455
|
+
Holds Nginx Ingress specific configuration to route traffic.
|
|
456
|
+
"""
|
|
457
|
+
ping_pong: NotRequired[pulumi.Input['RolloutSpecTrafficPingPongArgsDict']]
|
|
458
|
+
"""
|
|
459
|
+
Holds the ping and pong services. You can use `pingPong` field only when using ALB as a traffic manager with the IP Mode approach.
|
|
460
|
+
"""
|
|
461
|
+
smi: NotRequired[pulumi.Input['RolloutSpecTrafficSmiArgsDict']]
|
|
462
|
+
"""
|
|
463
|
+
Holds TrafficSplit specific configuration to route traffic.
|
|
464
|
+
"""
|
|
465
|
+
stable_service: NotRequired[pulumi.Input[_builtins.str]]
|
|
466
|
+
"""
|
|
467
|
+
The stable service name.
|
|
468
|
+
"""
|
|
469
|
+
elif False:
|
|
470
|
+
RolloutSpecTrafficArgsDict: TypeAlias = Mapping[str, Any]
|
|
471
|
+
|
|
291
472
|
@pulumi.input_type
|
|
292
473
|
class RolloutSpecTrafficArgs:
|
|
293
474
|
def __init__(__self__, *,
|
|
294
475
|
alb: Optional[pulumi.Input['RolloutSpecTrafficAlbArgs']] = None,
|
|
295
476
|
ambassador: Optional[pulumi.Input['RolloutSpecTrafficAmbassadorArgs']] = None,
|
|
296
|
-
canary_service: Optional[pulumi.Input[str]] = None,
|
|
477
|
+
canary_service: Optional[pulumi.Input[_builtins.str]] = None,
|
|
297
478
|
istio: Optional[pulumi.Input['RolloutSpecTrafficIstioArgs']] = None,
|
|
298
479
|
nginx: Optional[pulumi.Input['RolloutSpecTrafficNginxArgs']] = None,
|
|
299
480
|
ping_pong: Optional[pulumi.Input['RolloutSpecTrafficPingPongArgs']] = None,
|
|
300
481
|
smi: Optional[pulumi.Input['RolloutSpecTrafficSmiArgs']] = None,
|
|
301
|
-
stable_service: Optional[pulumi.Input[str]] = None):
|
|
482
|
+
stable_service: Optional[pulumi.Input[_builtins.str]] = None):
|
|
302
483
|
"""
|
|
303
484
|
:param pulumi.Input['RolloutSpecTrafficAlbArgs'] alb: Holds ALB Ingress specific configuration to route traffic.
|
|
304
485
|
:param pulumi.Input['RolloutSpecTrafficAmbassadorArgs'] ambassador: Holds specific configuration to use Ambassador to route traffic.
|
|
305
|
-
:param pulumi.Input[str] canary_service: The canary service name.
|
|
486
|
+
:param pulumi.Input[_builtins.str] canary_service: The canary service name.
|
|
306
487
|
:param pulumi.Input['RolloutSpecTrafficIstioArgs'] istio: Holds Istio specific configuration to route traffic.
|
|
307
488
|
:param pulumi.Input['RolloutSpecTrafficNginxArgs'] nginx: Holds Nginx Ingress specific configuration to route traffic.
|
|
308
489
|
: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.
|
|
309
490
|
:param pulumi.Input['RolloutSpecTrafficSmiArgs'] smi: Holds TrafficSplit specific configuration to route traffic.
|
|
310
|
-
:param pulumi.Input[str] stable_service: The stable service name.
|
|
491
|
+
:param pulumi.Input[_builtins.str] stable_service: The stable service name.
|
|
311
492
|
"""
|
|
312
493
|
if alb is not None:
|
|
313
494
|
pulumi.set(__self__, "alb", alb)
|
|
@@ -326,7 +507,7 @@ class RolloutSpecTrafficArgs:
|
|
|
326
507
|
if stable_service is not None:
|
|
327
508
|
pulumi.set(__self__, "stable_service", stable_service)
|
|
328
509
|
|
|
329
|
-
@property
|
|
510
|
+
@_builtins.property
|
|
330
511
|
@pulumi.getter
|
|
331
512
|
def alb(self) -> Optional[pulumi.Input['RolloutSpecTrafficAlbArgs']]:
|
|
332
513
|
"""
|
|
@@ -338,7 +519,7 @@ class RolloutSpecTrafficArgs:
|
|
|
338
519
|
def alb(self, value: Optional[pulumi.Input['RolloutSpecTrafficAlbArgs']]):
|
|
339
520
|
pulumi.set(self, "alb", value)
|
|
340
521
|
|
|
341
|
-
@property
|
|
522
|
+
@_builtins.property
|
|
342
523
|
@pulumi.getter
|
|
343
524
|
def ambassador(self) -> Optional[pulumi.Input['RolloutSpecTrafficAmbassadorArgs']]:
|
|
344
525
|
"""
|
|
@@ -350,19 +531,19 @@ class RolloutSpecTrafficArgs:
|
|
|
350
531
|
def ambassador(self, value: Optional[pulumi.Input['RolloutSpecTrafficAmbassadorArgs']]):
|
|
351
532
|
pulumi.set(self, "ambassador", value)
|
|
352
533
|
|
|
353
|
-
@property
|
|
534
|
+
@_builtins.property
|
|
354
535
|
@pulumi.getter(name="canaryService")
|
|
355
|
-
def canary_service(self) -> Optional[pulumi.Input[str]]:
|
|
536
|
+
def canary_service(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
356
537
|
"""
|
|
357
538
|
The canary service name.
|
|
358
539
|
"""
|
|
359
540
|
return pulumi.get(self, "canary_service")
|
|
360
541
|
|
|
361
542
|
@canary_service.setter
|
|
362
|
-
def canary_service(self, value: Optional[pulumi.Input[str]]):
|
|
543
|
+
def canary_service(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
363
544
|
pulumi.set(self, "canary_service", value)
|
|
364
545
|
|
|
365
|
-
@property
|
|
546
|
+
@_builtins.property
|
|
366
547
|
@pulumi.getter
|
|
367
548
|
def istio(self) -> Optional[pulumi.Input['RolloutSpecTrafficIstioArgs']]:
|
|
368
549
|
"""
|
|
@@ -374,7 +555,7 @@ class RolloutSpecTrafficArgs:
|
|
|
374
555
|
def istio(self, value: Optional[pulumi.Input['RolloutSpecTrafficIstioArgs']]):
|
|
375
556
|
pulumi.set(self, "istio", value)
|
|
376
557
|
|
|
377
|
-
@property
|
|
558
|
+
@_builtins.property
|
|
378
559
|
@pulumi.getter
|
|
379
560
|
def nginx(self) -> Optional[pulumi.Input['RolloutSpecTrafficNginxArgs']]:
|
|
380
561
|
"""
|
|
@@ -386,7 +567,7 @@ class RolloutSpecTrafficArgs:
|
|
|
386
567
|
def nginx(self, value: Optional[pulumi.Input['RolloutSpecTrafficNginxArgs']]):
|
|
387
568
|
pulumi.set(self, "nginx", value)
|
|
388
569
|
|
|
389
|
-
@property
|
|
570
|
+
@_builtins.property
|
|
390
571
|
@pulumi.getter(name="pingPong")
|
|
391
572
|
def ping_pong(self) -> Optional[pulumi.Input['RolloutSpecTrafficPingPongArgs']]:
|
|
392
573
|
"""
|
|
@@ -398,7 +579,7 @@ class RolloutSpecTrafficArgs:
|
|
|
398
579
|
def ping_pong(self, value: Optional[pulumi.Input['RolloutSpecTrafficPingPongArgs']]):
|
|
399
580
|
pulumi.set(self, "ping_pong", value)
|
|
400
581
|
|
|
401
|
-
@property
|
|
582
|
+
@_builtins.property
|
|
402
583
|
@pulumi.getter
|
|
403
584
|
def smi(self) -> Optional[pulumi.Input['RolloutSpecTrafficSmiArgs']]:
|
|
404
585
|
"""
|
|
@@ -410,32 +591,57 @@ class RolloutSpecTrafficArgs:
|
|
|
410
591
|
def smi(self, value: Optional[pulumi.Input['RolloutSpecTrafficSmiArgs']]):
|
|
411
592
|
pulumi.set(self, "smi", value)
|
|
412
593
|
|
|
413
|
-
@property
|
|
594
|
+
@_builtins.property
|
|
414
595
|
@pulumi.getter(name="stableService")
|
|
415
|
-
def stable_service(self) -> Optional[pulumi.Input[str]]:
|
|
596
|
+
def stable_service(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
416
597
|
"""
|
|
417
598
|
The stable service name.
|
|
418
599
|
"""
|
|
419
600
|
return pulumi.get(self, "stable_service")
|
|
420
601
|
|
|
421
602
|
@stable_service.setter
|
|
422
|
-
def stable_service(self, value: Optional[pulumi.Input[str]]):
|
|
603
|
+
def stable_service(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
423
604
|
pulumi.set(self, "stable_service", value)
|
|
424
605
|
|
|
425
606
|
|
|
607
|
+
if not MYPY:
|
|
608
|
+
class RolloutSpecTrafficAlbArgsDict(TypedDict):
|
|
609
|
+
alb_ingress: pulumi.Input[_builtins.str]
|
|
610
|
+
"""
|
|
611
|
+
Refers to the name of an `Ingress` resource in the same namespace as the `SpotDeployment`.
|
|
612
|
+
"""
|
|
613
|
+
alb_root_service: pulumi.Input[_builtins.str]
|
|
614
|
+
"""
|
|
615
|
+
References the service in the ingress to the controller should add the action to.
|
|
616
|
+
"""
|
|
617
|
+
service_port: pulumi.Input[_builtins.int]
|
|
618
|
+
"""
|
|
619
|
+
Refers to the port that the Ingress action should route traffic to.
|
|
620
|
+
"""
|
|
621
|
+
alb_annotation_prefix: NotRequired[pulumi.Input[_builtins.str]]
|
|
622
|
+
"""
|
|
623
|
+
Has to match the configured annotation prefix on the alb ingress controller.
|
|
624
|
+
"""
|
|
625
|
+
stickiness_config: NotRequired[pulumi.Input['RolloutSpecTrafficAlbStickinessConfigArgsDict']]
|
|
626
|
+
"""
|
|
627
|
+
Allows to specify further settings on the ForwardConfig.
|
|
628
|
+
"""
|
|
629
|
+
elif False:
|
|
630
|
+
RolloutSpecTrafficAlbArgsDict: TypeAlias = Mapping[str, Any]
|
|
631
|
+
|
|
426
632
|
@pulumi.input_type
|
|
427
633
|
class RolloutSpecTrafficAlbArgs:
|
|
428
634
|
def __init__(__self__, *,
|
|
429
|
-
alb_ingress: pulumi.Input[str],
|
|
430
|
-
alb_root_service: pulumi.Input[str],
|
|
431
|
-
service_port: pulumi.Input[int],
|
|
432
|
-
alb_annotation_prefix: Optional[pulumi.Input[str]] = None,
|
|
635
|
+
alb_ingress: pulumi.Input[_builtins.str],
|
|
636
|
+
alb_root_service: pulumi.Input[_builtins.str],
|
|
637
|
+
service_port: pulumi.Input[_builtins.int],
|
|
638
|
+
alb_annotation_prefix: Optional[pulumi.Input[_builtins.str]] = None,
|
|
433
639
|
stickiness_config: Optional[pulumi.Input['RolloutSpecTrafficAlbStickinessConfigArgs']] = None):
|
|
434
640
|
"""
|
|
435
|
-
:param pulumi.Input[str] alb_ingress: Refers to the name of an `Ingress` resource in the same namespace as the `SpotDeployment`.
|
|
436
|
-
:param pulumi.Input[str] alb_root_service: References the service in the ingress to the controller should add the action to.
|
|
437
|
-
:param pulumi.Input[int] service_port: Refers to the port that the Ingress action should route traffic to.
|
|
438
|
-
:param pulumi.Input[str] alb_annotation_prefix: Has to match the configured annotation prefix on the alb ingress controller.
|
|
641
|
+
:param pulumi.Input[_builtins.str] alb_ingress: Refers to the name of an `Ingress` resource in the same namespace as the `SpotDeployment`.
|
|
642
|
+
:param pulumi.Input[_builtins.str] alb_root_service: References the service in the ingress to the controller should add the action to.
|
|
643
|
+
:param pulumi.Input[_builtins.int] service_port: Refers to the port that the Ingress action should route traffic to.
|
|
644
|
+
:param pulumi.Input[_builtins.str] alb_annotation_prefix: Has to match the configured annotation prefix on the alb ingress controller.
|
|
439
645
|
:param pulumi.Input['RolloutSpecTrafficAlbStickinessConfigArgs'] stickiness_config: Allows to specify further settings on the ForwardConfig.
|
|
440
646
|
"""
|
|
441
647
|
pulumi.set(__self__, "alb_ingress", alb_ingress)
|
|
@@ -446,55 +652,55 @@ class RolloutSpecTrafficAlbArgs:
|
|
|
446
652
|
if stickiness_config is not None:
|
|
447
653
|
pulumi.set(__self__, "stickiness_config", stickiness_config)
|
|
448
654
|
|
|
449
|
-
@property
|
|
655
|
+
@_builtins.property
|
|
450
656
|
@pulumi.getter(name="albIngress")
|
|
451
|
-
def alb_ingress(self) -> pulumi.Input[str]:
|
|
657
|
+
def alb_ingress(self) -> pulumi.Input[_builtins.str]:
|
|
452
658
|
"""
|
|
453
659
|
Refers to the name of an `Ingress` resource in the same namespace as the `SpotDeployment`.
|
|
454
660
|
"""
|
|
455
661
|
return pulumi.get(self, "alb_ingress")
|
|
456
662
|
|
|
457
663
|
@alb_ingress.setter
|
|
458
|
-
def alb_ingress(self, value: pulumi.Input[str]):
|
|
664
|
+
def alb_ingress(self, value: pulumi.Input[_builtins.str]):
|
|
459
665
|
pulumi.set(self, "alb_ingress", value)
|
|
460
666
|
|
|
461
|
-
@property
|
|
667
|
+
@_builtins.property
|
|
462
668
|
@pulumi.getter(name="albRootService")
|
|
463
|
-
def alb_root_service(self) -> pulumi.Input[str]:
|
|
669
|
+
def alb_root_service(self) -> pulumi.Input[_builtins.str]:
|
|
464
670
|
"""
|
|
465
671
|
References the service in the ingress to the controller should add the action to.
|
|
466
672
|
"""
|
|
467
673
|
return pulumi.get(self, "alb_root_service")
|
|
468
674
|
|
|
469
675
|
@alb_root_service.setter
|
|
470
|
-
def alb_root_service(self, value: pulumi.Input[str]):
|
|
676
|
+
def alb_root_service(self, value: pulumi.Input[_builtins.str]):
|
|
471
677
|
pulumi.set(self, "alb_root_service", value)
|
|
472
678
|
|
|
473
|
-
@property
|
|
679
|
+
@_builtins.property
|
|
474
680
|
@pulumi.getter(name="servicePort")
|
|
475
|
-
def service_port(self) -> pulumi.Input[int]:
|
|
681
|
+
def service_port(self) -> pulumi.Input[_builtins.int]:
|
|
476
682
|
"""
|
|
477
683
|
Refers to the port that the Ingress action should route traffic to.
|
|
478
684
|
"""
|
|
479
685
|
return pulumi.get(self, "service_port")
|
|
480
686
|
|
|
481
687
|
@service_port.setter
|
|
482
|
-
def service_port(self, value: pulumi.Input[int]):
|
|
688
|
+
def service_port(self, value: pulumi.Input[_builtins.int]):
|
|
483
689
|
pulumi.set(self, "service_port", value)
|
|
484
690
|
|
|
485
|
-
@property
|
|
691
|
+
@_builtins.property
|
|
486
692
|
@pulumi.getter(name="albAnnotationPrefix")
|
|
487
|
-
def alb_annotation_prefix(self) -> Optional[pulumi.Input[str]]:
|
|
693
|
+
def alb_annotation_prefix(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
488
694
|
"""
|
|
489
695
|
Has to match the configured annotation prefix on the alb ingress controller.
|
|
490
696
|
"""
|
|
491
697
|
return pulumi.get(self, "alb_annotation_prefix")
|
|
492
698
|
|
|
493
699
|
@alb_annotation_prefix.setter
|
|
494
|
-
def alb_annotation_prefix(self, value: Optional[pulumi.Input[str]]):
|
|
700
|
+
def alb_annotation_prefix(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
495
701
|
pulumi.set(self, "alb_annotation_prefix", value)
|
|
496
702
|
|
|
497
|
-
@property
|
|
703
|
+
@_builtins.property
|
|
498
704
|
@pulumi.getter(name="stickinessConfig")
|
|
499
705
|
def stickiness_config(self) -> Optional[pulumi.Input['RolloutSpecTrafficAlbStickinessConfigArgs']]:
|
|
500
706
|
"""
|
|
@@ -507,67 +713,102 @@ class RolloutSpecTrafficAlbArgs:
|
|
|
507
713
|
pulumi.set(self, "stickiness_config", value)
|
|
508
714
|
|
|
509
715
|
|
|
716
|
+
if not MYPY:
|
|
717
|
+
class RolloutSpecTrafficAlbStickinessConfigArgsDict(TypedDict):
|
|
718
|
+
duration_seconds: NotRequired[pulumi.Input[_builtins.int]]
|
|
719
|
+
"""
|
|
720
|
+
Defines how long the load balancer should consistently route the user's request to the same target.
|
|
721
|
+
"""
|
|
722
|
+
enabled: NotRequired[pulumi.Input[_builtins.bool]]
|
|
723
|
+
"""
|
|
724
|
+
Enables the load balancer to bind a user's session to a specific target.
|
|
725
|
+
"""
|
|
726
|
+
elif False:
|
|
727
|
+
RolloutSpecTrafficAlbStickinessConfigArgsDict: TypeAlias = Mapping[str, Any]
|
|
728
|
+
|
|
510
729
|
@pulumi.input_type
|
|
511
730
|
class RolloutSpecTrafficAlbStickinessConfigArgs:
|
|
512
731
|
def __init__(__self__, *,
|
|
513
|
-
duration_seconds: Optional[pulumi.Input[int]] = None,
|
|
514
|
-
enabled: Optional[pulumi.Input[bool]] = None):
|
|
732
|
+
duration_seconds: Optional[pulumi.Input[_builtins.int]] = None,
|
|
733
|
+
enabled: Optional[pulumi.Input[_builtins.bool]] = None):
|
|
515
734
|
"""
|
|
516
|
-
:param pulumi.Input[int] duration_seconds: Defines how long the load balancer should consistently route the user's request to the same target.
|
|
517
|
-
:param pulumi.Input[bool] enabled: Enables the load balancer to bind a user's session to a specific target.
|
|
735
|
+
:param pulumi.Input[_builtins.int] duration_seconds: Defines how long the load balancer should consistently route the user's request to the same target.
|
|
736
|
+
:param pulumi.Input[_builtins.bool] enabled: Enables the load balancer to bind a user's session to a specific target.
|
|
518
737
|
"""
|
|
519
738
|
if duration_seconds is not None:
|
|
520
739
|
pulumi.set(__self__, "duration_seconds", duration_seconds)
|
|
521
740
|
if enabled is not None:
|
|
522
741
|
pulumi.set(__self__, "enabled", enabled)
|
|
523
742
|
|
|
524
|
-
@property
|
|
743
|
+
@_builtins.property
|
|
525
744
|
@pulumi.getter(name="durationSeconds")
|
|
526
|
-
def duration_seconds(self) -> Optional[pulumi.Input[int]]:
|
|
745
|
+
def duration_seconds(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
527
746
|
"""
|
|
528
747
|
Defines how long the load balancer should consistently route the user's request to the same target.
|
|
529
748
|
"""
|
|
530
749
|
return pulumi.get(self, "duration_seconds")
|
|
531
750
|
|
|
532
751
|
@duration_seconds.setter
|
|
533
|
-
def duration_seconds(self, value: Optional[pulumi.Input[int]]):
|
|
752
|
+
def duration_seconds(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
534
753
|
pulumi.set(self, "duration_seconds", value)
|
|
535
754
|
|
|
536
|
-
@property
|
|
755
|
+
@_builtins.property
|
|
537
756
|
@pulumi.getter
|
|
538
|
-
def enabled(self) -> Optional[pulumi.Input[bool]]:
|
|
757
|
+
def enabled(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
539
758
|
"""
|
|
540
759
|
Enables the load balancer to bind a user's session to a specific target.
|
|
541
760
|
"""
|
|
542
761
|
return pulumi.get(self, "enabled")
|
|
543
762
|
|
|
544
763
|
@enabled.setter
|
|
545
|
-
def enabled(self, value: Optional[pulumi.Input[bool]]):
|
|
764
|
+
def enabled(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
546
765
|
pulumi.set(self, "enabled", value)
|
|
547
766
|
|
|
548
767
|
|
|
768
|
+
if not MYPY:
|
|
769
|
+
class RolloutSpecTrafficAmbassadorArgsDict(TypedDict):
|
|
770
|
+
mappings: pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]
|
|
771
|
+
"""
|
|
772
|
+
A list of names of the Ambassador Mappings used to route traffic to the service.
|
|
773
|
+
"""
|
|
774
|
+
elif False:
|
|
775
|
+
RolloutSpecTrafficAmbassadorArgsDict: TypeAlias = Mapping[str, Any]
|
|
776
|
+
|
|
549
777
|
@pulumi.input_type
|
|
550
778
|
class RolloutSpecTrafficAmbassadorArgs:
|
|
551
779
|
def __init__(__self__, *,
|
|
552
|
-
mappings: pulumi.Input[Sequence[pulumi.Input[str]]]):
|
|
780
|
+
mappings: pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]):
|
|
553
781
|
"""
|
|
554
|
-
:param pulumi.Input[Sequence[pulumi.Input[str]]] mappings: A list of names of the Ambassador Mappings used to route traffic to the service.
|
|
782
|
+
:param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] mappings: A list of names of the Ambassador Mappings used to route traffic to the service.
|
|
555
783
|
"""
|
|
556
784
|
pulumi.set(__self__, "mappings", mappings)
|
|
557
785
|
|
|
558
|
-
@property
|
|
786
|
+
@_builtins.property
|
|
559
787
|
@pulumi.getter
|
|
560
|
-
def mappings(self) -> pulumi.Input[Sequence[pulumi.Input[str]]]:
|
|
788
|
+
def mappings(self) -> pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]:
|
|
561
789
|
"""
|
|
562
790
|
A list of names of the Ambassador Mappings used to route traffic to the service.
|
|
563
791
|
"""
|
|
564
792
|
return pulumi.get(self, "mappings")
|
|
565
793
|
|
|
566
794
|
@mappings.setter
|
|
567
|
-
def mappings(self, value: pulumi.Input[Sequence[pulumi.Input[str]]]):
|
|
795
|
+
def mappings(self, value: pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]):
|
|
568
796
|
pulumi.set(self, "mappings", value)
|
|
569
797
|
|
|
570
798
|
|
|
799
|
+
if not MYPY:
|
|
800
|
+
class RolloutSpecTrafficIstioArgsDict(TypedDict):
|
|
801
|
+
virtual_services: pulumi.Input[Sequence[pulumi.Input['RolloutSpecTrafficIstioVirtualServiceArgsDict']]]
|
|
802
|
+
"""
|
|
803
|
+
Defines a set of traffic routing rules to apply when a host is addressed.
|
|
804
|
+
"""
|
|
805
|
+
destination_rule: NotRequired[pulumi.Input['RolloutSpecTrafficIstioDestinationRuleArgsDict']]
|
|
806
|
+
"""
|
|
807
|
+
It references to an Istio DestinationRule to modify and shape traffic. `DestinationRule` field belongs only to the Subset Level approach.
|
|
808
|
+
"""
|
|
809
|
+
elif False:
|
|
810
|
+
RolloutSpecTrafficIstioArgsDict: TypeAlias = Mapping[str, Any]
|
|
811
|
+
|
|
571
812
|
@pulumi.input_type
|
|
572
813
|
class RolloutSpecTrafficIstioArgs:
|
|
573
814
|
def __init__(__self__, *,
|
|
@@ -581,7 +822,7 @@ class RolloutSpecTrafficIstioArgs:
|
|
|
581
822
|
if destination_rule is not None:
|
|
582
823
|
pulumi.set(__self__, "destination_rule", destination_rule)
|
|
583
824
|
|
|
584
|
-
@property
|
|
825
|
+
@_builtins.property
|
|
585
826
|
@pulumi.getter(name="virtualServices")
|
|
586
827
|
def virtual_services(self) -> pulumi.Input[Sequence[pulumi.Input['RolloutSpecTrafficIstioVirtualServiceArgs']]]:
|
|
587
828
|
"""
|
|
@@ -593,7 +834,7 @@ class RolloutSpecTrafficIstioArgs:
|
|
|
593
834
|
def virtual_services(self, value: pulumi.Input[Sequence[pulumi.Input['RolloutSpecTrafficIstioVirtualServiceArgs']]]):
|
|
594
835
|
pulumi.set(self, "virtual_services", value)
|
|
595
836
|
|
|
596
|
-
@property
|
|
837
|
+
@_builtins.property
|
|
597
838
|
@pulumi.getter(name="destinationRule")
|
|
598
839
|
def destination_rule(self) -> Optional[pulumi.Input['RolloutSpecTrafficIstioDestinationRuleArgs']]:
|
|
599
840
|
"""
|
|
@@ -606,68 +847,102 @@ class RolloutSpecTrafficIstioArgs:
|
|
|
606
847
|
pulumi.set(self, "destination_rule", value)
|
|
607
848
|
|
|
608
849
|
|
|
850
|
+
if not MYPY:
|
|
851
|
+
class RolloutSpecTrafficIstioDestinationRuleArgsDict(TypedDict):
|
|
852
|
+
canary_subset_name: pulumi.Input[_builtins.str]
|
|
853
|
+
"""
|
|
854
|
+
The subset name to modify labels with the canary version.
|
|
855
|
+
"""
|
|
856
|
+
destination_rule_name: pulumi.Input[_builtins.str]
|
|
857
|
+
"""
|
|
858
|
+
Holds the name of the DestinationRule.
|
|
859
|
+
"""
|
|
860
|
+
stable_subset_name: pulumi.Input[_builtins.str]
|
|
861
|
+
"""
|
|
862
|
+
The subset name to modify labels with the stable version.
|
|
863
|
+
"""
|
|
864
|
+
elif False:
|
|
865
|
+
RolloutSpecTrafficIstioDestinationRuleArgsDict: TypeAlias = Mapping[str, Any]
|
|
866
|
+
|
|
609
867
|
@pulumi.input_type
|
|
610
868
|
class RolloutSpecTrafficIstioDestinationRuleArgs:
|
|
611
869
|
def __init__(__self__, *,
|
|
612
|
-
canary_subset_name: pulumi.Input[str],
|
|
613
|
-
destination_rule_name: pulumi.Input[str],
|
|
614
|
-
stable_subset_name: pulumi.Input[str]):
|
|
870
|
+
canary_subset_name: pulumi.Input[_builtins.str],
|
|
871
|
+
destination_rule_name: pulumi.Input[_builtins.str],
|
|
872
|
+
stable_subset_name: pulumi.Input[_builtins.str]):
|
|
615
873
|
"""
|
|
616
|
-
:param pulumi.Input[str] canary_subset_name: The subset name to modify labels with the canary version.
|
|
617
|
-
:param pulumi.Input[str] destination_rule_name: Holds the name of the DestinationRule.
|
|
618
|
-
:param pulumi.Input[str] stable_subset_name: The subset name to modify labels with the stable version.
|
|
874
|
+
:param pulumi.Input[_builtins.str] canary_subset_name: The subset name to modify labels with the canary version.
|
|
875
|
+
:param pulumi.Input[_builtins.str] destination_rule_name: Holds the name of the DestinationRule.
|
|
876
|
+
:param pulumi.Input[_builtins.str] stable_subset_name: The subset name to modify labels with the stable version.
|
|
619
877
|
"""
|
|
620
878
|
pulumi.set(__self__, "canary_subset_name", canary_subset_name)
|
|
621
879
|
pulumi.set(__self__, "destination_rule_name", destination_rule_name)
|
|
622
880
|
pulumi.set(__self__, "stable_subset_name", stable_subset_name)
|
|
623
881
|
|
|
624
|
-
@property
|
|
882
|
+
@_builtins.property
|
|
625
883
|
@pulumi.getter(name="canarySubsetName")
|
|
626
|
-
def canary_subset_name(self) -> pulumi.Input[str]:
|
|
884
|
+
def canary_subset_name(self) -> pulumi.Input[_builtins.str]:
|
|
627
885
|
"""
|
|
628
886
|
The subset name to modify labels with the canary version.
|
|
629
887
|
"""
|
|
630
888
|
return pulumi.get(self, "canary_subset_name")
|
|
631
889
|
|
|
632
890
|
@canary_subset_name.setter
|
|
633
|
-
def canary_subset_name(self, value: pulumi.Input[str]):
|
|
891
|
+
def canary_subset_name(self, value: pulumi.Input[_builtins.str]):
|
|
634
892
|
pulumi.set(self, "canary_subset_name", value)
|
|
635
893
|
|
|
636
|
-
@property
|
|
894
|
+
@_builtins.property
|
|
637
895
|
@pulumi.getter(name="destinationRuleName")
|
|
638
|
-
def destination_rule_name(self) -> pulumi.Input[str]:
|
|
896
|
+
def destination_rule_name(self) -> pulumi.Input[_builtins.str]:
|
|
639
897
|
"""
|
|
640
898
|
Holds the name of the DestinationRule.
|
|
641
899
|
"""
|
|
642
900
|
return pulumi.get(self, "destination_rule_name")
|
|
643
901
|
|
|
644
902
|
@destination_rule_name.setter
|
|
645
|
-
def destination_rule_name(self, value: pulumi.Input[str]):
|
|
903
|
+
def destination_rule_name(self, value: pulumi.Input[_builtins.str]):
|
|
646
904
|
pulumi.set(self, "destination_rule_name", value)
|
|
647
905
|
|
|
648
|
-
@property
|
|
906
|
+
@_builtins.property
|
|
649
907
|
@pulumi.getter(name="stableSubsetName")
|
|
650
|
-
def stable_subset_name(self) -> pulumi.Input[str]:
|
|
908
|
+
def stable_subset_name(self) -> pulumi.Input[_builtins.str]:
|
|
651
909
|
"""
|
|
652
910
|
The subset name to modify labels with the stable version.
|
|
653
911
|
"""
|
|
654
912
|
return pulumi.get(self, "stable_subset_name")
|
|
655
913
|
|
|
656
914
|
@stable_subset_name.setter
|
|
657
|
-
def stable_subset_name(self, value: pulumi.Input[str]):
|
|
915
|
+
def stable_subset_name(self, value: pulumi.Input[_builtins.str]):
|
|
658
916
|
pulumi.set(self, "stable_subset_name", value)
|
|
659
917
|
|
|
660
918
|
|
|
919
|
+
if not MYPY:
|
|
920
|
+
class RolloutSpecTrafficIstioVirtualServiceArgsDict(TypedDict):
|
|
921
|
+
virtual_service_name: pulumi.Input[_builtins.str]
|
|
922
|
+
"""
|
|
923
|
+
Holds the name of the VirtualService.
|
|
924
|
+
"""
|
|
925
|
+
tls_routes: NotRequired[pulumi.Input[Sequence[pulumi.Input['RolloutSpecTrafficIstioVirtualServiceTlsRouteArgsDict']]]]
|
|
926
|
+
"""
|
|
927
|
+
A list of HTTPS routes within VirtualService.
|
|
928
|
+
"""
|
|
929
|
+
virtual_service_routes: NotRequired[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]
|
|
930
|
+
"""
|
|
931
|
+
A list of HTTP routes within VirtualService.
|
|
932
|
+
"""
|
|
933
|
+
elif False:
|
|
934
|
+
RolloutSpecTrafficIstioVirtualServiceArgsDict: TypeAlias = Mapping[str, Any]
|
|
935
|
+
|
|
661
936
|
@pulumi.input_type
|
|
662
937
|
class RolloutSpecTrafficIstioVirtualServiceArgs:
|
|
663
938
|
def __init__(__self__, *,
|
|
664
|
-
virtual_service_name: pulumi.Input[str],
|
|
939
|
+
virtual_service_name: pulumi.Input[_builtins.str],
|
|
665
940
|
tls_routes: Optional[pulumi.Input[Sequence[pulumi.Input['RolloutSpecTrafficIstioVirtualServiceTlsRouteArgs']]]] = None,
|
|
666
|
-
virtual_service_routes: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None):
|
|
941
|
+
virtual_service_routes: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None):
|
|
667
942
|
"""
|
|
668
|
-
:param pulumi.Input[str] virtual_service_name: Holds the name of the VirtualService.
|
|
943
|
+
:param pulumi.Input[_builtins.str] virtual_service_name: Holds the name of the VirtualService.
|
|
669
944
|
:param pulumi.Input[Sequence[pulumi.Input['RolloutSpecTrafficIstioVirtualServiceTlsRouteArgs']]] tls_routes: A list of HTTPS routes within VirtualService.
|
|
670
|
-
:param pulumi.Input[Sequence[pulumi.Input[str]]] virtual_service_routes: A list of HTTP routes within VirtualService.
|
|
945
|
+
:param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] virtual_service_routes: A list of HTTP routes within VirtualService.
|
|
671
946
|
"""
|
|
672
947
|
pulumi.set(__self__, "virtual_service_name", virtual_service_name)
|
|
673
948
|
if tls_routes is not None:
|
|
@@ -675,19 +950,19 @@ class RolloutSpecTrafficIstioVirtualServiceArgs:
|
|
|
675
950
|
if virtual_service_routes is not None:
|
|
676
951
|
pulumi.set(__self__, "virtual_service_routes", virtual_service_routes)
|
|
677
952
|
|
|
678
|
-
@property
|
|
953
|
+
@_builtins.property
|
|
679
954
|
@pulumi.getter(name="virtualServiceName")
|
|
680
|
-
def virtual_service_name(self) -> pulumi.Input[str]:
|
|
955
|
+
def virtual_service_name(self) -> pulumi.Input[_builtins.str]:
|
|
681
956
|
"""
|
|
682
957
|
Holds the name of the VirtualService.
|
|
683
958
|
"""
|
|
684
959
|
return pulumi.get(self, "virtual_service_name")
|
|
685
960
|
|
|
686
961
|
@virtual_service_name.setter
|
|
687
|
-
def virtual_service_name(self, value: pulumi.Input[str]):
|
|
962
|
+
def virtual_service_name(self, value: pulumi.Input[_builtins.str]):
|
|
688
963
|
pulumi.set(self, "virtual_service_name", value)
|
|
689
964
|
|
|
690
|
-
@property
|
|
965
|
+
@_builtins.property
|
|
691
966
|
@pulumi.getter(name="tlsRoutes")
|
|
692
967
|
def tls_routes(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['RolloutSpecTrafficIstioVirtualServiceTlsRouteArgs']]]]:
|
|
693
968
|
"""
|
|
@@ -699,68 +974,98 @@ class RolloutSpecTrafficIstioVirtualServiceArgs:
|
|
|
699
974
|
def tls_routes(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['RolloutSpecTrafficIstioVirtualServiceTlsRouteArgs']]]]):
|
|
700
975
|
pulumi.set(self, "tls_routes", value)
|
|
701
976
|
|
|
702
|
-
@property
|
|
977
|
+
@_builtins.property
|
|
703
978
|
@pulumi.getter(name="virtualServiceRoutes")
|
|
704
|
-
def virtual_service_routes(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
|
|
979
|
+
def virtual_service_routes(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
|
|
705
980
|
"""
|
|
706
981
|
A list of HTTP routes within VirtualService.
|
|
707
982
|
"""
|
|
708
983
|
return pulumi.get(self, "virtual_service_routes")
|
|
709
984
|
|
|
710
985
|
@virtual_service_routes.setter
|
|
711
|
-
def virtual_service_routes(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
|
|
986
|
+
def virtual_service_routes(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]):
|
|
712
987
|
pulumi.set(self, "virtual_service_routes", value)
|
|
713
988
|
|
|
714
989
|
|
|
990
|
+
if not MYPY:
|
|
991
|
+
class RolloutSpecTrafficIstioVirtualServiceTlsRouteArgsDict(TypedDict):
|
|
992
|
+
port: NotRequired[pulumi.Input[_builtins.int]]
|
|
993
|
+
"""
|
|
994
|
+
The port of the TLS Route desired to be matched in the given Istio VirtualService.
|
|
995
|
+
"""
|
|
996
|
+
sni_hosts: NotRequired[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]
|
|
997
|
+
"""
|
|
998
|
+
A list of all the SNI Hosts of the TLS Route desired to be matched in the given Istio VirtualService.
|
|
999
|
+
"""
|
|
1000
|
+
elif False:
|
|
1001
|
+
RolloutSpecTrafficIstioVirtualServiceTlsRouteArgsDict: TypeAlias = Mapping[str, Any]
|
|
1002
|
+
|
|
715
1003
|
@pulumi.input_type
|
|
716
1004
|
class RolloutSpecTrafficIstioVirtualServiceTlsRouteArgs:
|
|
717
1005
|
def __init__(__self__, *,
|
|
718
|
-
port: Optional[pulumi.Input[int]] = None,
|
|
719
|
-
sni_hosts: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None):
|
|
1006
|
+
port: Optional[pulumi.Input[_builtins.int]] = None,
|
|
1007
|
+
sni_hosts: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None):
|
|
720
1008
|
"""
|
|
721
|
-
:param pulumi.Input[int] port: The port of the TLS Route desired to be matched in the given Istio VirtualService.
|
|
722
|
-
: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.
|
|
1009
|
+
:param pulumi.Input[_builtins.int] port: The port of the TLS Route desired to be matched in the given Istio VirtualService.
|
|
1010
|
+
: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.
|
|
723
1011
|
"""
|
|
724
1012
|
if port is not None:
|
|
725
1013
|
pulumi.set(__self__, "port", port)
|
|
726
1014
|
if sni_hosts is not None:
|
|
727
1015
|
pulumi.set(__self__, "sni_hosts", sni_hosts)
|
|
728
1016
|
|
|
729
|
-
@property
|
|
1017
|
+
@_builtins.property
|
|
730
1018
|
@pulumi.getter
|
|
731
|
-
def port(self) -> Optional[pulumi.Input[int]]:
|
|
1019
|
+
def port(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
732
1020
|
"""
|
|
733
1021
|
The port of the TLS Route desired to be matched in the given Istio VirtualService.
|
|
734
1022
|
"""
|
|
735
1023
|
return pulumi.get(self, "port")
|
|
736
1024
|
|
|
737
1025
|
@port.setter
|
|
738
|
-
def port(self, value: Optional[pulumi.Input[int]]):
|
|
1026
|
+
def port(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
739
1027
|
pulumi.set(self, "port", value)
|
|
740
1028
|
|
|
741
|
-
@property
|
|
1029
|
+
@_builtins.property
|
|
742
1030
|
@pulumi.getter(name="sniHosts")
|
|
743
|
-
def sni_hosts(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
|
|
1031
|
+
def sni_hosts(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
|
|
744
1032
|
"""
|
|
745
1033
|
A list of all the SNI Hosts of the TLS Route desired to be matched in the given Istio VirtualService.
|
|
746
1034
|
"""
|
|
747
1035
|
return pulumi.get(self, "sni_hosts")
|
|
748
1036
|
|
|
749
1037
|
@sni_hosts.setter
|
|
750
|
-
def sni_hosts(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
|
|
1038
|
+
def sni_hosts(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]):
|
|
751
1039
|
pulumi.set(self, "sni_hosts", value)
|
|
752
1040
|
|
|
753
1041
|
|
|
1042
|
+
if not MYPY:
|
|
1043
|
+
class RolloutSpecTrafficNginxArgsDict(TypedDict):
|
|
1044
|
+
stable_ingress: pulumi.Input[_builtins.str]
|
|
1045
|
+
"""
|
|
1046
|
+
Refers to the name of an `Ingress` resource in the same namespace as the `SpotDeployment`.
|
|
1047
|
+
"""
|
|
1048
|
+
additional_ingress_annotation: NotRequired[pulumi.Input['RolloutSpecTrafficNginxAdditionalIngressAnnotationArgsDict']]
|
|
1049
|
+
"""
|
|
1050
|
+
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
|
+
nginx_annotation_prefix: NotRequired[pulumi.Input[_builtins.str]]
|
|
1053
|
+
"""
|
|
1054
|
+
Has to match the configured annotation prefix on the Nginx ingress controller.
|
|
1055
|
+
"""
|
|
1056
|
+
elif False:
|
|
1057
|
+
RolloutSpecTrafficNginxArgsDict: TypeAlias = Mapping[str, Any]
|
|
1058
|
+
|
|
754
1059
|
@pulumi.input_type
|
|
755
1060
|
class RolloutSpecTrafficNginxArgs:
|
|
756
1061
|
def __init__(__self__, *,
|
|
757
|
-
stable_ingress: pulumi.Input[str],
|
|
1062
|
+
stable_ingress: pulumi.Input[_builtins.str],
|
|
758
1063
|
additional_ingress_annotation: Optional[pulumi.Input['RolloutSpecTrafficNginxAdditionalIngressAnnotationArgs']] = None,
|
|
759
|
-
nginx_annotation_prefix: Optional[pulumi.Input[str]] = None):
|
|
1064
|
+
nginx_annotation_prefix: Optional[pulumi.Input[_builtins.str]] = None):
|
|
760
1065
|
"""
|
|
761
|
-
:param pulumi.Input[str] stable_ingress: Refers to the name of an `Ingress` resource in the same namespace as the `SpotDeployment`.
|
|
1066
|
+
:param pulumi.Input[_builtins.str] stable_ingress: Refers to the name of an `Ingress` resource in the same namespace as the `SpotDeployment`.
|
|
762
1067
|
: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.
|
|
763
|
-
:param pulumi.Input[str] nginx_annotation_prefix: Has to match the configured annotation prefix on the Nginx ingress controller.
|
|
1068
|
+
:param pulumi.Input[_builtins.str] nginx_annotation_prefix: Has to match the configured annotation prefix on the Nginx ingress controller.
|
|
764
1069
|
"""
|
|
765
1070
|
pulumi.set(__self__, "stable_ingress", stable_ingress)
|
|
766
1071
|
if additional_ingress_annotation is not None:
|
|
@@ -768,19 +1073,19 @@ class RolloutSpecTrafficNginxArgs:
|
|
|
768
1073
|
if nginx_annotation_prefix is not None:
|
|
769
1074
|
pulumi.set(__self__, "nginx_annotation_prefix", nginx_annotation_prefix)
|
|
770
1075
|
|
|
771
|
-
@property
|
|
1076
|
+
@_builtins.property
|
|
772
1077
|
@pulumi.getter(name="stableIngress")
|
|
773
|
-
def stable_ingress(self) -> pulumi.Input[str]:
|
|
1078
|
+
def stable_ingress(self) -> pulumi.Input[_builtins.str]:
|
|
774
1079
|
"""
|
|
775
1080
|
Refers to the name of an `Ingress` resource in the same namespace as the `SpotDeployment`.
|
|
776
1081
|
"""
|
|
777
1082
|
return pulumi.get(self, "stable_ingress")
|
|
778
1083
|
|
|
779
1084
|
@stable_ingress.setter
|
|
780
|
-
def stable_ingress(self, value: pulumi.Input[str]):
|
|
1085
|
+
def stable_ingress(self, value: pulumi.Input[_builtins.str]):
|
|
781
1086
|
pulumi.set(self, "stable_ingress", value)
|
|
782
1087
|
|
|
783
|
-
@property
|
|
1088
|
+
@_builtins.property
|
|
784
1089
|
@pulumi.getter(name="additionalIngressAnnotation")
|
|
785
1090
|
def additional_ingress_annotation(self) -> Optional[pulumi.Input['RolloutSpecTrafficNginxAdditionalIngressAnnotationArgs']]:
|
|
786
1091
|
"""
|
|
@@ -792,134 +1097,186 @@ class RolloutSpecTrafficNginxArgs:
|
|
|
792
1097
|
def additional_ingress_annotation(self, value: Optional[pulumi.Input['RolloutSpecTrafficNginxAdditionalIngressAnnotationArgs']]):
|
|
793
1098
|
pulumi.set(self, "additional_ingress_annotation", value)
|
|
794
1099
|
|
|
795
|
-
@property
|
|
1100
|
+
@_builtins.property
|
|
796
1101
|
@pulumi.getter(name="nginxAnnotationPrefix")
|
|
797
|
-
def nginx_annotation_prefix(self) -> Optional[pulumi.Input[str]]:
|
|
1102
|
+
def nginx_annotation_prefix(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
798
1103
|
"""
|
|
799
1104
|
Has to match the configured annotation prefix on the Nginx ingress controller.
|
|
800
1105
|
"""
|
|
801
1106
|
return pulumi.get(self, "nginx_annotation_prefix")
|
|
802
1107
|
|
|
803
1108
|
@nginx_annotation_prefix.setter
|
|
804
|
-
def nginx_annotation_prefix(self, value: Optional[pulumi.Input[str]]):
|
|
1109
|
+
def nginx_annotation_prefix(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
805
1110
|
pulumi.set(self, "nginx_annotation_prefix", value)
|
|
806
1111
|
|
|
807
1112
|
|
|
1113
|
+
if not MYPY:
|
|
1114
|
+
class RolloutSpecTrafficNginxAdditionalIngressAnnotationArgsDict(TypedDict):
|
|
1115
|
+
canary_by_header: NotRequired[pulumi.Input[_builtins.str]]
|
|
1116
|
+
"""
|
|
1117
|
+
Allows customizing the header value instead of using hardcoded values.
|
|
1118
|
+
"""
|
|
1119
|
+
key1: NotRequired[pulumi.Input[_builtins.str]]
|
|
1120
|
+
"""
|
|
1121
|
+
Any of supported annotations.
|
|
1122
|
+
"""
|
|
1123
|
+
elif False:
|
|
1124
|
+
RolloutSpecTrafficNginxAdditionalIngressAnnotationArgsDict: TypeAlias = Mapping[str, Any]
|
|
1125
|
+
|
|
808
1126
|
@pulumi.input_type
|
|
809
1127
|
class RolloutSpecTrafficNginxAdditionalIngressAnnotationArgs:
|
|
810
1128
|
def __init__(__self__, *,
|
|
811
|
-
canary_by_header: Optional[pulumi.Input[str]] = None,
|
|
812
|
-
key1: Optional[pulumi.Input[str]] = None):
|
|
1129
|
+
canary_by_header: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1130
|
+
key1: Optional[pulumi.Input[_builtins.str]] = None):
|
|
813
1131
|
"""
|
|
814
|
-
:param pulumi.Input[str] canary_by_header: Allows customizing the header value instead of using hardcoded values.
|
|
815
|
-
:param pulumi.Input[str] key1: Any of supported annotations.
|
|
1132
|
+
:param pulumi.Input[_builtins.str] canary_by_header: Allows customizing the header value instead of using hardcoded values.
|
|
1133
|
+
:param pulumi.Input[_builtins.str] key1: Any of supported annotations.
|
|
816
1134
|
"""
|
|
817
1135
|
if canary_by_header is not None:
|
|
818
1136
|
pulumi.set(__self__, "canary_by_header", canary_by_header)
|
|
819
1137
|
if key1 is not None:
|
|
820
1138
|
pulumi.set(__self__, "key1", key1)
|
|
821
1139
|
|
|
822
|
-
@property
|
|
1140
|
+
@_builtins.property
|
|
823
1141
|
@pulumi.getter(name="canaryByHeader")
|
|
824
|
-
def canary_by_header(self) -> Optional[pulumi.Input[str]]:
|
|
1142
|
+
def canary_by_header(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
825
1143
|
"""
|
|
826
1144
|
Allows customizing the header value instead of using hardcoded values.
|
|
827
1145
|
"""
|
|
828
1146
|
return pulumi.get(self, "canary_by_header")
|
|
829
1147
|
|
|
830
1148
|
@canary_by_header.setter
|
|
831
|
-
def canary_by_header(self, value: Optional[pulumi.Input[str]]):
|
|
1149
|
+
def canary_by_header(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
832
1150
|
pulumi.set(self, "canary_by_header", value)
|
|
833
1151
|
|
|
834
|
-
@property
|
|
1152
|
+
@_builtins.property
|
|
835
1153
|
@pulumi.getter
|
|
836
|
-
def key1(self) -> Optional[pulumi.Input[str]]:
|
|
1154
|
+
def key1(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
837
1155
|
"""
|
|
838
1156
|
Any of supported annotations.
|
|
839
1157
|
"""
|
|
840
1158
|
return pulumi.get(self, "key1")
|
|
841
1159
|
|
|
842
1160
|
@key1.setter
|
|
843
|
-
def key1(self, value: Optional[pulumi.Input[str]]):
|
|
1161
|
+
def key1(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
844
1162
|
pulumi.set(self, "key1", value)
|
|
845
1163
|
|
|
846
1164
|
|
|
1165
|
+
if not MYPY:
|
|
1166
|
+
class RolloutSpecTrafficPingPongArgsDict(TypedDict):
|
|
1167
|
+
ping_service: pulumi.Input[_builtins.str]
|
|
1168
|
+
"""
|
|
1169
|
+
Holds the name of the ping service.
|
|
1170
|
+
"""
|
|
1171
|
+
pong_service: pulumi.Input[_builtins.str]
|
|
1172
|
+
"""
|
|
1173
|
+
Holds the name of the pong service.
|
|
1174
|
+
"""
|
|
1175
|
+
elif False:
|
|
1176
|
+
RolloutSpecTrafficPingPongArgsDict: TypeAlias = Mapping[str, Any]
|
|
1177
|
+
|
|
847
1178
|
@pulumi.input_type
|
|
848
1179
|
class RolloutSpecTrafficPingPongArgs:
|
|
849
1180
|
def __init__(__self__, *,
|
|
850
|
-
ping_service: pulumi.Input[str],
|
|
851
|
-
pong_service: pulumi.Input[str]):
|
|
1181
|
+
ping_service: pulumi.Input[_builtins.str],
|
|
1182
|
+
pong_service: pulumi.Input[_builtins.str]):
|
|
852
1183
|
"""
|
|
853
|
-
:param pulumi.Input[str] ping_service: Holds the name of the ping service.
|
|
854
|
-
:param pulumi.Input[str] pong_service: Holds the name of the pong service.
|
|
1184
|
+
:param pulumi.Input[_builtins.str] ping_service: Holds the name of the ping service.
|
|
1185
|
+
:param pulumi.Input[_builtins.str] pong_service: Holds the name of the pong service.
|
|
855
1186
|
"""
|
|
856
1187
|
pulumi.set(__self__, "ping_service", ping_service)
|
|
857
1188
|
pulumi.set(__self__, "pong_service", pong_service)
|
|
858
1189
|
|
|
859
|
-
@property
|
|
1190
|
+
@_builtins.property
|
|
860
1191
|
@pulumi.getter(name="pingService")
|
|
861
|
-
def ping_service(self) -> pulumi.Input[str]:
|
|
1192
|
+
def ping_service(self) -> pulumi.Input[_builtins.str]:
|
|
862
1193
|
"""
|
|
863
1194
|
Holds the name of the ping service.
|
|
864
1195
|
"""
|
|
865
1196
|
return pulumi.get(self, "ping_service")
|
|
866
1197
|
|
|
867
1198
|
@ping_service.setter
|
|
868
|
-
def ping_service(self, value: pulumi.Input[str]):
|
|
1199
|
+
def ping_service(self, value: pulumi.Input[_builtins.str]):
|
|
869
1200
|
pulumi.set(self, "ping_service", value)
|
|
870
1201
|
|
|
871
|
-
@property
|
|
1202
|
+
@_builtins.property
|
|
872
1203
|
@pulumi.getter(name="pongService")
|
|
873
|
-
def pong_service(self) -> pulumi.Input[str]:
|
|
1204
|
+
def pong_service(self) -> pulumi.Input[_builtins.str]:
|
|
874
1205
|
"""
|
|
875
1206
|
Holds the name of the pong service.
|
|
876
1207
|
"""
|
|
877
1208
|
return pulumi.get(self, "pong_service")
|
|
878
1209
|
|
|
879
1210
|
@pong_service.setter
|
|
880
|
-
def pong_service(self, value: pulumi.Input[str]):
|
|
1211
|
+
def pong_service(self, value: pulumi.Input[_builtins.str]):
|
|
881
1212
|
pulumi.set(self, "pong_service", value)
|
|
882
1213
|
|
|
883
1214
|
|
|
1215
|
+
if not MYPY:
|
|
1216
|
+
class RolloutSpecTrafficSmiArgsDict(TypedDict):
|
|
1217
|
+
smi_root_service: NotRequired[pulumi.Input[_builtins.str]]
|
|
1218
|
+
"""
|
|
1219
|
+
Holds the name of service that clients use to communicate.
|
|
1220
|
+
"""
|
|
1221
|
+
traffic_split_name: NotRequired[pulumi.Input[_builtins.str]]
|
|
1222
|
+
"""
|
|
1223
|
+
Holds the name of the TrafficSplit.
|
|
1224
|
+
"""
|
|
1225
|
+
elif False:
|
|
1226
|
+
RolloutSpecTrafficSmiArgsDict: TypeAlias = Mapping[str, Any]
|
|
1227
|
+
|
|
884
1228
|
@pulumi.input_type
|
|
885
1229
|
class RolloutSpecTrafficSmiArgs:
|
|
886
1230
|
def __init__(__self__, *,
|
|
887
|
-
smi_root_service: Optional[pulumi.Input[str]] = None,
|
|
888
|
-
traffic_split_name: Optional[pulumi.Input[str]] = None):
|
|
1231
|
+
smi_root_service: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1232
|
+
traffic_split_name: Optional[pulumi.Input[_builtins.str]] = None):
|
|
889
1233
|
"""
|
|
890
|
-
:param pulumi.Input[str] smi_root_service: Holds the name of service that clients use to communicate.
|
|
891
|
-
:param pulumi.Input[str] traffic_split_name: Holds the name of the TrafficSplit.
|
|
1234
|
+
:param pulumi.Input[_builtins.str] smi_root_service: Holds the name of service that clients use to communicate.
|
|
1235
|
+
:param pulumi.Input[_builtins.str] traffic_split_name: Holds the name of the TrafficSplit.
|
|
892
1236
|
"""
|
|
893
1237
|
if smi_root_service is not None:
|
|
894
1238
|
pulumi.set(__self__, "smi_root_service", smi_root_service)
|
|
895
1239
|
if traffic_split_name is not None:
|
|
896
1240
|
pulumi.set(__self__, "traffic_split_name", traffic_split_name)
|
|
897
1241
|
|
|
898
|
-
@property
|
|
1242
|
+
@_builtins.property
|
|
899
1243
|
@pulumi.getter(name="smiRootService")
|
|
900
|
-
def smi_root_service(self) -> Optional[pulumi.Input[str]]:
|
|
1244
|
+
def smi_root_service(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
901
1245
|
"""
|
|
902
1246
|
Holds the name of service that clients use to communicate.
|
|
903
1247
|
"""
|
|
904
1248
|
return pulumi.get(self, "smi_root_service")
|
|
905
1249
|
|
|
906
1250
|
@smi_root_service.setter
|
|
907
|
-
def smi_root_service(self, value: Optional[pulumi.Input[str]]):
|
|
1251
|
+
def smi_root_service(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
908
1252
|
pulumi.set(self, "smi_root_service", value)
|
|
909
1253
|
|
|
910
|
-
@property
|
|
1254
|
+
@_builtins.property
|
|
911
1255
|
@pulumi.getter(name="trafficSplitName")
|
|
912
|
-
def traffic_split_name(self) -> Optional[pulumi.Input[str]]:
|
|
1256
|
+
def traffic_split_name(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
913
1257
|
"""
|
|
914
1258
|
Holds the name of the TrafficSplit.
|
|
915
1259
|
"""
|
|
916
1260
|
return pulumi.get(self, "traffic_split_name")
|
|
917
1261
|
|
|
918
1262
|
@traffic_split_name.setter
|
|
919
|
-
def traffic_split_name(self, value: Optional[pulumi.Input[str]]):
|
|
1263
|
+
def traffic_split_name(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
920
1264
|
pulumi.set(self, "traffic_split_name", value)
|
|
921
1265
|
|
|
922
1266
|
|
|
1267
|
+
if not MYPY:
|
|
1268
|
+
class StrategyCanaryArgsDict(TypedDict):
|
|
1269
|
+
steps: pulumi.Input[Sequence[pulumi.Input['StrategyCanaryStepArgsDict']]]
|
|
1270
|
+
"""
|
|
1271
|
+
A set of separate conditions of rollout processing.
|
|
1272
|
+
"""
|
|
1273
|
+
background_verification: NotRequired[pulumi.Input['StrategyCanaryBackgroundVerificationArgsDict']]
|
|
1274
|
+
"""
|
|
1275
|
+
A list of background verifications.
|
|
1276
|
+
"""
|
|
1277
|
+
elif False:
|
|
1278
|
+
StrategyCanaryArgsDict: TypeAlias = Mapping[str, Any]
|
|
1279
|
+
|
|
923
1280
|
@pulumi.input_type
|
|
924
1281
|
class StrategyCanaryArgs:
|
|
925
1282
|
def __init__(__self__, *,
|
|
@@ -933,7 +1290,7 @@ class StrategyCanaryArgs:
|
|
|
933
1290
|
if background_verification is not None:
|
|
934
1291
|
pulumi.set(__self__, "background_verification", background_verification)
|
|
935
1292
|
|
|
936
|
-
@property
|
|
1293
|
+
@_builtins.property
|
|
937
1294
|
@pulumi.getter
|
|
938
1295
|
def steps(self) -> pulumi.Input[Sequence[pulumi.Input['StrategyCanaryStepArgs']]]:
|
|
939
1296
|
"""
|
|
@@ -945,7 +1302,7 @@ class StrategyCanaryArgs:
|
|
|
945
1302
|
def steps(self, value: pulumi.Input[Sequence[pulumi.Input['StrategyCanaryStepArgs']]]):
|
|
946
1303
|
pulumi.set(self, "steps", value)
|
|
947
1304
|
|
|
948
|
-
@property
|
|
1305
|
+
@_builtins.property
|
|
949
1306
|
@pulumi.getter(name="backgroundVerification")
|
|
950
1307
|
def background_verification(self) -> Optional[pulumi.Input['StrategyCanaryBackgroundVerificationArgs']]:
|
|
951
1308
|
"""
|
|
@@ -958,42 +1315,77 @@ class StrategyCanaryArgs:
|
|
|
958
1315
|
pulumi.set(self, "background_verification", value)
|
|
959
1316
|
|
|
960
1317
|
|
|
1318
|
+
if not MYPY:
|
|
1319
|
+
class StrategyCanaryBackgroundVerificationArgsDict(TypedDict):
|
|
1320
|
+
template_names: pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]
|
|
1321
|
+
"""
|
|
1322
|
+
List of Verification Template names.
|
|
1323
|
+
"""
|
|
1324
|
+
elif False:
|
|
1325
|
+
StrategyCanaryBackgroundVerificationArgsDict: TypeAlias = Mapping[str, Any]
|
|
1326
|
+
|
|
961
1327
|
@pulumi.input_type
|
|
962
1328
|
class StrategyCanaryBackgroundVerificationArgs:
|
|
963
1329
|
def __init__(__self__, *,
|
|
964
|
-
template_names: pulumi.Input[Sequence[pulumi.Input[str]]]):
|
|
1330
|
+
template_names: pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]):
|
|
965
1331
|
"""
|
|
966
|
-
:param pulumi.Input[Sequence[pulumi.Input[str]]] template_names: List of Verification Template names.
|
|
1332
|
+
:param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] template_names: List of Verification Template names.
|
|
967
1333
|
"""
|
|
968
1334
|
pulumi.set(__self__, "template_names", template_names)
|
|
969
1335
|
|
|
970
|
-
@property
|
|
1336
|
+
@_builtins.property
|
|
971
1337
|
@pulumi.getter(name="templateNames")
|
|
972
|
-
def template_names(self) -> pulumi.Input[Sequence[pulumi.Input[str]]]:
|
|
1338
|
+
def template_names(self) -> pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]:
|
|
973
1339
|
"""
|
|
974
1340
|
List of Verification Template names.
|
|
975
1341
|
"""
|
|
976
1342
|
return pulumi.get(self, "template_names")
|
|
977
1343
|
|
|
978
1344
|
@template_names.setter
|
|
979
|
-
def template_names(self, value: pulumi.Input[Sequence[pulumi.Input[str]]]):
|
|
1345
|
+
def template_names(self, value: pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]):
|
|
980
1346
|
pulumi.set(self, "template_names", value)
|
|
981
1347
|
|
|
982
1348
|
|
|
1349
|
+
if not MYPY:
|
|
1350
|
+
class StrategyCanaryStepArgsDict(TypedDict):
|
|
1351
|
+
pause: NotRequired[pulumi.Input['StrategyCanaryStepPauseArgsDict']]
|
|
1352
|
+
"""
|
|
1353
|
+
Defines the duration of time to freeze the rollout.
|
|
1354
|
+
"""
|
|
1355
|
+
set_canary_scale: NotRequired[pulumi.Input['StrategyCanaryStepSetCanaryScaleArgsDict']]
|
|
1356
|
+
"""
|
|
1357
|
+
Defines how to scale the version without traffic weight changing.
|
|
1358
|
+
"""
|
|
1359
|
+
set_header_route: NotRequired[pulumi.Input['StrategyCanaryStepSetHeaderRouteArgsDict']]
|
|
1360
|
+
"""
|
|
1361
|
+
Defines the list of HeaderRoutes to add to the Rollout.
|
|
1362
|
+
"""
|
|
1363
|
+
set_weight: NotRequired[pulumi.Input[_builtins.int]]
|
|
1364
|
+
"""
|
|
1365
|
+
Defines the percentage that the new version should receive.
|
|
1366
|
+
"""
|
|
1367
|
+
step_name: NotRequired[pulumi.Input[_builtins.str]]
|
|
1368
|
+
verification: NotRequired[pulumi.Input['StrategyCanaryStepVerificationArgsDict']]
|
|
1369
|
+
"""
|
|
1370
|
+
Represents the list of verifications to run in a step.
|
|
1371
|
+
"""
|
|
1372
|
+
elif False:
|
|
1373
|
+
StrategyCanaryStepArgsDict: TypeAlias = Mapping[str, Any]
|
|
1374
|
+
|
|
983
1375
|
@pulumi.input_type
|
|
984
1376
|
class StrategyCanaryStepArgs:
|
|
985
1377
|
def __init__(__self__, *,
|
|
986
1378
|
pause: Optional[pulumi.Input['StrategyCanaryStepPauseArgs']] = None,
|
|
987
1379
|
set_canary_scale: Optional[pulumi.Input['StrategyCanaryStepSetCanaryScaleArgs']] = None,
|
|
988
1380
|
set_header_route: Optional[pulumi.Input['StrategyCanaryStepSetHeaderRouteArgs']] = None,
|
|
989
|
-
set_weight: Optional[pulumi.Input[int]] = None,
|
|
990
|
-
step_name: Optional[pulumi.Input[str]] = None,
|
|
1381
|
+
set_weight: Optional[pulumi.Input[_builtins.int]] = None,
|
|
1382
|
+
step_name: Optional[pulumi.Input[_builtins.str]] = None,
|
|
991
1383
|
verification: Optional[pulumi.Input['StrategyCanaryStepVerificationArgs']] = None):
|
|
992
1384
|
"""
|
|
993
1385
|
:param pulumi.Input['StrategyCanaryStepPauseArgs'] pause: Defines the duration of time to freeze the rollout.
|
|
994
1386
|
:param pulumi.Input['StrategyCanaryStepSetCanaryScaleArgs'] set_canary_scale: Defines how to scale the version without traffic weight changing.
|
|
995
1387
|
:param pulumi.Input['StrategyCanaryStepSetHeaderRouteArgs'] set_header_route: Defines the list of HeaderRoutes to add to the Rollout.
|
|
996
|
-
:param pulumi.Input[int] set_weight: Defines the percentage that the new version should receive.
|
|
1388
|
+
:param pulumi.Input[_builtins.int] set_weight: Defines the percentage that the new version should receive.
|
|
997
1389
|
:param pulumi.Input['StrategyCanaryStepVerificationArgs'] verification: Represents the list of verifications to run in a step.
|
|
998
1390
|
"""
|
|
999
1391
|
if pause is not None:
|
|
@@ -1009,7 +1401,7 @@ class StrategyCanaryStepArgs:
|
|
|
1009
1401
|
if verification is not None:
|
|
1010
1402
|
pulumi.set(__self__, "verification", verification)
|
|
1011
1403
|
|
|
1012
|
-
@property
|
|
1404
|
+
@_builtins.property
|
|
1013
1405
|
@pulumi.getter
|
|
1014
1406
|
def pause(self) -> Optional[pulumi.Input['StrategyCanaryStepPauseArgs']]:
|
|
1015
1407
|
"""
|
|
@@ -1021,7 +1413,7 @@ class StrategyCanaryStepArgs:
|
|
|
1021
1413
|
def pause(self, value: Optional[pulumi.Input['StrategyCanaryStepPauseArgs']]):
|
|
1022
1414
|
pulumi.set(self, "pause", value)
|
|
1023
1415
|
|
|
1024
|
-
@property
|
|
1416
|
+
@_builtins.property
|
|
1025
1417
|
@pulumi.getter(name="setCanaryScale")
|
|
1026
1418
|
def set_canary_scale(self) -> Optional[pulumi.Input['StrategyCanaryStepSetCanaryScaleArgs']]:
|
|
1027
1419
|
"""
|
|
@@ -1033,7 +1425,7 @@ class StrategyCanaryStepArgs:
|
|
|
1033
1425
|
def set_canary_scale(self, value: Optional[pulumi.Input['StrategyCanaryStepSetCanaryScaleArgs']]):
|
|
1034
1426
|
pulumi.set(self, "set_canary_scale", value)
|
|
1035
1427
|
|
|
1036
|
-
@property
|
|
1428
|
+
@_builtins.property
|
|
1037
1429
|
@pulumi.getter(name="setHeaderRoute")
|
|
1038
1430
|
def set_header_route(self) -> Optional[pulumi.Input['StrategyCanaryStepSetHeaderRouteArgs']]:
|
|
1039
1431
|
"""
|
|
@@ -1045,28 +1437,28 @@ class StrategyCanaryStepArgs:
|
|
|
1045
1437
|
def set_header_route(self, value: Optional[pulumi.Input['StrategyCanaryStepSetHeaderRouteArgs']]):
|
|
1046
1438
|
pulumi.set(self, "set_header_route", value)
|
|
1047
1439
|
|
|
1048
|
-
@property
|
|
1440
|
+
@_builtins.property
|
|
1049
1441
|
@pulumi.getter(name="setWeight")
|
|
1050
|
-
def set_weight(self) -> Optional[pulumi.Input[int]]:
|
|
1442
|
+
def set_weight(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
1051
1443
|
"""
|
|
1052
1444
|
Defines the percentage that the new version should receive.
|
|
1053
1445
|
"""
|
|
1054
1446
|
return pulumi.get(self, "set_weight")
|
|
1055
1447
|
|
|
1056
1448
|
@set_weight.setter
|
|
1057
|
-
def set_weight(self, value: Optional[pulumi.Input[int]]):
|
|
1449
|
+
def set_weight(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
1058
1450
|
pulumi.set(self, "set_weight", value)
|
|
1059
1451
|
|
|
1060
|
-
@property
|
|
1452
|
+
@_builtins.property
|
|
1061
1453
|
@pulumi.getter(name="stepName")
|
|
1062
|
-
def step_name(self) -> Optional[pulumi.Input[str]]:
|
|
1454
|
+
def step_name(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
1063
1455
|
return pulumi.get(self, "step_name")
|
|
1064
1456
|
|
|
1065
1457
|
@step_name.setter
|
|
1066
|
-
def step_name(self, value: Optional[pulumi.Input[str]]):
|
|
1458
|
+
def step_name(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
1067
1459
|
pulumi.set(self, "step_name", value)
|
|
1068
1460
|
|
|
1069
|
-
@property
|
|
1461
|
+
@_builtins.property
|
|
1070
1462
|
@pulumi.getter
|
|
1071
1463
|
def verification(self) -> Optional[pulumi.Input['StrategyCanaryStepVerificationArgs']]:
|
|
1072
1464
|
"""
|
|
@@ -1079,39 +1471,65 @@ class StrategyCanaryStepArgs:
|
|
|
1079
1471
|
pulumi.set(self, "verification", value)
|
|
1080
1472
|
|
|
1081
1473
|
|
|
1474
|
+
if not MYPY:
|
|
1475
|
+
class StrategyCanaryStepPauseArgsDict(TypedDict):
|
|
1476
|
+
duration: NotRequired[pulumi.Input[_builtins.str]]
|
|
1477
|
+
"""
|
|
1478
|
+
The amount of time to wait before moving to the next step.
|
|
1479
|
+
"""
|
|
1480
|
+
elif False:
|
|
1481
|
+
StrategyCanaryStepPauseArgsDict: TypeAlias = Mapping[str, Any]
|
|
1482
|
+
|
|
1082
1483
|
@pulumi.input_type
|
|
1083
1484
|
class StrategyCanaryStepPauseArgs:
|
|
1084
1485
|
def __init__(__self__, *,
|
|
1085
|
-
duration: Optional[pulumi.Input[str]] = None):
|
|
1486
|
+
duration: Optional[pulumi.Input[_builtins.str]] = None):
|
|
1086
1487
|
"""
|
|
1087
|
-
:param pulumi.Input[str] duration: The amount of time to wait before moving to the next step.
|
|
1488
|
+
:param pulumi.Input[_builtins.str] duration: The amount of time to wait before moving to the next step.
|
|
1088
1489
|
"""
|
|
1089
1490
|
if duration is not None:
|
|
1090
1491
|
pulumi.set(__self__, "duration", duration)
|
|
1091
1492
|
|
|
1092
|
-
@property
|
|
1493
|
+
@_builtins.property
|
|
1093
1494
|
@pulumi.getter
|
|
1094
|
-
def duration(self) -> Optional[pulumi.Input[str]]:
|
|
1495
|
+
def duration(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
1095
1496
|
"""
|
|
1096
1497
|
The amount of time to wait before moving to the next step.
|
|
1097
1498
|
"""
|
|
1098
1499
|
return pulumi.get(self, "duration")
|
|
1099
1500
|
|
|
1100
1501
|
@duration.setter
|
|
1101
|
-
def duration(self, value: Optional[pulumi.Input[str]]):
|
|
1502
|
+
def duration(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
1102
1503
|
pulumi.set(self, "duration", value)
|
|
1103
1504
|
|
|
1104
1505
|
|
|
1506
|
+
if not MYPY:
|
|
1507
|
+
class StrategyCanaryStepSetCanaryScaleArgsDict(TypedDict):
|
|
1508
|
+
match_traffic_weight: NotRequired[pulumi.Input[_builtins.bool]]
|
|
1509
|
+
"""
|
|
1510
|
+
Defines whether a rollout should match the current canary's setWeight step.
|
|
1511
|
+
"""
|
|
1512
|
+
replicas: NotRequired[pulumi.Input[_builtins.int]]
|
|
1513
|
+
"""
|
|
1514
|
+
Sets the number of replicas the new version should have.
|
|
1515
|
+
"""
|
|
1516
|
+
weight: NotRequired[pulumi.Input[_builtins.int]]
|
|
1517
|
+
"""
|
|
1518
|
+
Sets the percentage of replicas the new version should have.
|
|
1519
|
+
"""
|
|
1520
|
+
elif False:
|
|
1521
|
+
StrategyCanaryStepSetCanaryScaleArgsDict: TypeAlias = Mapping[str, Any]
|
|
1522
|
+
|
|
1105
1523
|
@pulumi.input_type
|
|
1106
1524
|
class StrategyCanaryStepSetCanaryScaleArgs:
|
|
1107
1525
|
def __init__(__self__, *,
|
|
1108
|
-
match_traffic_weight: Optional[pulumi.Input[bool]] = None,
|
|
1109
|
-
replicas: Optional[pulumi.Input[int]] = None,
|
|
1110
|
-
weight: Optional[pulumi.Input[int]] = None):
|
|
1526
|
+
match_traffic_weight: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
1527
|
+
replicas: Optional[pulumi.Input[_builtins.int]] = None,
|
|
1528
|
+
weight: Optional[pulumi.Input[_builtins.int]] = None):
|
|
1111
1529
|
"""
|
|
1112
|
-
:param pulumi.Input[bool] match_traffic_weight: Defines whether a rollout should match the current canary's setWeight step.
|
|
1113
|
-
:param pulumi.Input[int] replicas: Sets the number of replicas the new version should have.
|
|
1114
|
-
:param pulumi.Input[int] weight: Sets the percentage of replicas the new version should have.
|
|
1530
|
+
:param pulumi.Input[_builtins.bool] match_traffic_weight: Defines whether a rollout should match the current canary's setWeight step.
|
|
1531
|
+
:param pulumi.Input[_builtins.int] replicas: Sets the number of replicas the new version should have.
|
|
1532
|
+
:param pulumi.Input[_builtins.int] weight: Sets the percentage of replicas the new version should have.
|
|
1115
1533
|
"""
|
|
1116
1534
|
if match_traffic_weight is not None:
|
|
1117
1535
|
pulumi.set(__self__, "match_traffic_weight", match_traffic_weight)
|
|
@@ -1120,68 +1538,81 @@ class StrategyCanaryStepSetCanaryScaleArgs:
|
|
|
1120
1538
|
if weight is not None:
|
|
1121
1539
|
pulumi.set(__self__, "weight", weight)
|
|
1122
1540
|
|
|
1123
|
-
@property
|
|
1541
|
+
@_builtins.property
|
|
1124
1542
|
@pulumi.getter(name="matchTrafficWeight")
|
|
1125
|
-
def match_traffic_weight(self) -> Optional[pulumi.Input[bool]]:
|
|
1543
|
+
def match_traffic_weight(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
1126
1544
|
"""
|
|
1127
1545
|
Defines whether a rollout should match the current canary's setWeight step.
|
|
1128
1546
|
"""
|
|
1129
1547
|
return pulumi.get(self, "match_traffic_weight")
|
|
1130
1548
|
|
|
1131
1549
|
@match_traffic_weight.setter
|
|
1132
|
-
def match_traffic_weight(self, value: Optional[pulumi.Input[bool]]):
|
|
1550
|
+
def match_traffic_weight(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
1133
1551
|
pulumi.set(self, "match_traffic_weight", value)
|
|
1134
1552
|
|
|
1135
|
-
@property
|
|
1553
|
+
@_builtins.property
|
|
1136
1554
|
@pulumi.getter
|
|
1137
|
-
def replicas(self) -> Optional[pulumi.Input[int]]:
|
|
1555
|
+
def replicas(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
1138
1556
|
"""
|
|
1139
1557
|
Sets the number of replicas the new version should have.
|
|
1140
1558
|
"""
|
|
1141
1559
|
return pulumi.get(self, "replicas")
|
|
1142
1560
|
|
|
1143
1561
|
@replicas.setter
|
|
1144
|
-
def replicas(self, value: Optional[pulumi.Input[int]]):
|
|
1562
|
+
def replicas(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
1145
1563
|
pulumi.set(self, "replicas", value)
|
|
1146
1564
|
|
|
1147
|
-
@property
|
|
1565
|
+
@_builtins.property
|
|
1148
1566
|
@pulumi.getter
|
|
1149
|
-
def weight(self) -> Optional[pulumi.Input[int]]:
|
|
1567
|
+
def weight(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
1150
1568
|
"""
|
|
1151
1569
|
Sets the percentage of replicas the new version should have.
|
|
1152
1570
|
"""
|
|
1153
1571
|
return pulumi.get(self, "weight")
|
|
1154
1572
|
|
|
1155
1573
|
@weight.setter
|
|
1156
|
-
def weight(self, value: Optional[pulumi.Input[int]]):
|
|
1574
|
+
def weight(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
1157
1575
|
pulumi.set(self, "weight", value)
|
|
1158
1576
|
|
|
1159
1577
|
|
|
1578
|
+
if not MYPY:
|
|
1579
|
+
class StrategyCanaryStepSetHeaderRouteArgsDict(TypedDict):
|
|
1580
|
+
header_route_name: pulumi.Input[_builtins.str]
|
|
1581
|
+
"""
|
|
1582
|
+
The name of the HeaderRoute group.
|
|
1583
|
+
"""
|
|
1584
|
+
matches: pulumi.Input[Sequence[pulumi.Input['StrategyCanaryStepSetHeaderRouteMatchArgsDict']]]
|
|
1585
|
+
"""
|
|
1586
|
+
The matching rules for the header route.
|
|
1587
|
+
"""
|
|
1588
|
+
elif False:
|
|
1589
|
+
StrategyCanaryStepSetHeaderRouteArgsDict: TypeAlias = Mapping[str, Any]
|
|
1590
|
+
|
|
1160
1591
|
@pulumi.input_type
|
|
1161
1592
|
class StrategyCanaryStepSetHeaderRouteArgs:
|
|
1162
1593
|
def __init__(__self__, *,
|
|
1163
|
-
header_route_name: pulumi.Input[str],
|
|
1594
|
+
header_route_name: pulumi.Input[_builtins.str],
|
|
1164
1595
|
matches: pulumi.Input[Sequence[pulumi.Input['StrategyCanaryStepSetHeaderRouteMatchArgs']]]):
|
|
1165
1596
|
"""
|
|
1166
|
-
:param pulumi.Input[str] header_route_name: The name of the HeaderRoute group.
|
|
1597
|
+
:param pulumi.Input[_builtins.str] header_route_name: The name of the HeaderRoute group.
|
|
1167
1598
|
:param pulumi.Input[Sequence[pulumi.Input['StrategyCanaryStepSetHeaderRouteMatchArgs']]] matches: The matching rules for the header route.
|
|
1168
1599
|
"""
|
|
1169
1600
|
pulumi.set(__self__, "header_route_name", header_route_name)
|
|
1170
1601
|
pulumi.set(__self__, "matches", matches)
|
|
1171
1602
|
|
|
1172
|
-
@property
|
|
1603
|
+
@_builtins.property
|
|
1173
1604
|
@pulumi.getter(name="headerRouteName")
|
|
1174
|
-
def header_route_name(self) -> pulumi.Input[str]:
|
|
1605
|
+
def header_route_name(self) -> pulumi.Input[_builtins.str]:
|
|
1175
1606
|
"""
|
|
1176
1607
|
The name of the HeaderRoute group.
|
|
1177
1608
|
"""
|
|
1178
1609
|
return pulumi.get(self, "header_route_name")
|
|
1179
1610
|
|
|
1180
1611
|
@header_route_name.setter
|
|
1181
|
-
def header_route_name(self, value: pulumi.Input[str]):
|
|
1612
|
+
def header_route_name(self, value: pulumi.Input[_builtins.str]):
|
|
1182
1613
|
pulumi.set(self, "header_route_name", value)
|
|
1183
1614
|
|
|
1184
|
-
@property
|
|
1615
|
+
@_builtins.property
|
|
1185
1616
|
@pulumi.getter
|
|
1186
1617
|
def matches(self) -> pulumi.Input[Sequence[pulumi.Input['StrategyCanaryStepSetHeaderRouteMatchArgs']]]:
|
|
1187
1618
|
"""
|
|
@@ -1194,31 +1625,44 @@ class StrategyCanaryStepSetHeaderRouteArgs:
|
|
|
1194
1625
|
pulumi.set(self, "matches", value)
|
|
1195
1626
|
|
|
1196
1627
|
|
|
1628
|
+
if not MYPY:
|
|
1629
|
+
class StrategyCanaryStepSetHeaderRouteMatchArgsDict(TypedDict):
|
|
1630
|
+
header_name: pulumi.Input[_builtins.str]
|
|
1631
|
+
"""
|
|
1632
|
+
The name of the header.
|
|
1633
|
+
"""
|
|
1634
|
+
header_value: pulumi.Input['StrategyCanaryStepSetHeaderRouteMatchHeaderValueArgsDict']
|
|
1635
|
+
"""
|
|
1636
|
+
Defines a single header to add to the Rollout. Must be only one initialized from the following (exact, prefix, regex).
|
|
1637
|
+
"""
|
|
1638
|
+
elif False:
|
|
1639
|
+
StrategyCanaryStepSetHeaderRouteMatchArgsDict: TypeAlias = Mapping[str, Any]
|
|
1640
|
+
|
|
1197
1641
|
@pulumi.input_type
|
|
1198
1642
|
class StrategyCanaryStepSetHeaderRouteMatchArgs:
|
|
1199
1643
|
def __init__(__self__, *,
|
|
1200
|
-
header_name: pulumi.Input[str],
|
|
1644
|
+
header_name: pulumi.Input[_builtins.str],
|
|
1201
1645
|
header_value: pulumi.Input['StrategyCanaryStepSetHeaderRouteMatchHeaderValueArgs']):
|
|
1202
1646
|
"""
|
|
1203
|
-
:param pulumi.Input[str] header_name: The name of the header.
|
|
1647
|
+
:param pulumi.Input[_builtins.str] header_name: The name of the header.
|
|
1204
1648
|
: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).
|
|
1205
1649
|
"""
|
|
1206
1650
|
pulumi.set(__self__, "header_name", header_name)
|
|
1207
1651
|
pulumi.set(__self__, "header_value", header_value)
|
|
1208
1652
|
|
|
1209
|
-
@property
|
|
1653
|
+
@_builtins.property
|
|
1210
1654
|
@pulumi.getter(name="headerName")
|
|
1211
|
-
def header_name(self) -> pulumi.Input[str]:
|
|
1655
|
+
def header_name(self) -> pulumi.Input[_builtins.str]:
|
|
1212
1656
|
"""
|
|
1213
1657
|
The name of the header.
|
|
1214
1658
|
"""
|
|
1215
1659
|
return pulumi.get(self, "header_name")
|
|
1216
1660
|
|
|
1217
1661
|
@header_name.setter
|
|
1218
|
-
def header_name(self, value: pulumi.Input[str]):
|
|
1662
|
+
def header_name(self, value: pulumi.Input[_builtins.str]):
|
|
1219
1663
|
pulumi.set(self, "header_name", value)
|
|
1220
1664
|
|
|
1221
|
-
@property
|
|
1665
|
+
@_builtins.property
|
|
1222
1666
|
@pulumi.getter(name="headerValue")
|
|
1223
1667
|
def header_value(self) -> pulumi.Input['StrategyCanaryStepSetHeaderRouteMatchHeaderValueArgs']:
|
|
1224
1668
|
"""
|
|
@@ -1231,16 +1675,33 @@ class StrategyCanaryStepSetHeaderRouteMatchArgs:
|
|
|
1231
1675
|
pulumi.set(self, "header_value", value)
|
|
1232
1676
|
|
|
1233
1677
|
|
|
1678
|
+
if not MYPY:
|
|
1679
|
+
class StrategyCanaryStepSetHeaderRouteMatchHeaderValueArgsDict(TypedDict):
|
|
1680
|
+
exact: NotRequired[pulumi.Input[_builtins.str]]
|
|
1681
|
+
"""
|
|
1682
|
+
The exact header value.
|
|
1683
|
+
"""
|
|
1684
|
+
prefix: NotRequired[pulumi.Input[_builtins.str]]
|
|
1685
|
+
"""
|
|
1686
|
+
The prefix of the value.
|
|
1687
|
+
"""
|
|
1688
|
+
regex: NotRequired[pulumi.Input[_builtins.str]]
|
|
1689
|
+
"""
|
|
1690
|
+
The value in a regex format.
|
|
1691
|
+
"""
|
|
1692
|
+
elif False:
|
|
1693
|
+
StrategyCanaryStepSetHeaderRouteMatchHeaderValueArgsDict: TypeAlias = Mapping[str, Any]
|
|
1694
|
+
|
|
1234
1695
|
@pulumi.input_type
|
|
1235
1696
|
class StrategyCanaryStepSetHeaderRouteMatchHeaderValueArgs:
|
|
1236
1697
|
def __init__(__self__, *,
|
|
1237
|
-
exact: Optional[pulumi.Input[str]] = None,
|
|
1238
|
-
prefix: Optional[pulumi.Input[str]] = None,
|
|
1239
|
-
regex: Optional[pulumi.Input[str]] = None):
|
|
1698
|
+
exact: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1699
|
+
prefix: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1700
|
+
regex: Optional[pulumi.Input[_builtins.str]] = None):
|
|
1240
1701
|
"""
|
|
1241
|
-
:param pulumi.Input[str] exact: The exact header value.
|
|
1242
|
-
:param pulumi.Input[str] prefix: The prefix of the value.
|
|
1243
|
-
:param pulumi.Input[str] regex: The value in a regex format.
|
|
1702
|
+
:param pulumi.Input[_builtins.str] exact: The exact header value.
|
|
1703
|
+
:param pulumi.Input[_builtins.str] prefix: The prefix of the value.
|
|
1704
|
+
:param pulumi.Input[_builtins.str] regex: The value in a regex format.
|
|
1244
1705
|
"""
|
|
1245
1706
|
if exact is not None:
|
|
1246
1707
|
pulumi.set(__self__, "exact", exact)
|
|
@@ -1249,65 +1710,83 @@ class StrategyCanaryStepSetHeaderRouteMatchHeaderValueArgs:
|
|
|
1249
1710
|
if regex is not None:
|
|
1250
1711
|
pulumi.set(__self__, "regex", regex)
|
|
1251
1712
|
|
|
1252
|
-
@property
|
|
1713
|
+
@_builtins.property
|
|
1253
1714
|
@pulumi.getter
|
|
1254
|
-
def exact(self) -> Optional[pulumi.Input[str]]:
|
|
1715
|
+
def exact(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
1255
1716
|
"""
|
|
1256
1717
|
The exact header value.
|
|
1257
1718
|
"""
|
|
1258
1719
|
return pulumi.get(self, "exact")
|
|
1259
1720
|
|
|
1260
1721
|
@exact.setter
|
|
1261
|
-
def exact(self, value: Optional[pulumi.Input[str]]):
|
|
1722
|
+
def exact(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
1262
1723
|
pulumi.set(self, "exact", value)
|
|
1263
1724
|
|
|
1264
|
-
@property
|
|
1725
|
+
@_builtins.property
|
|
1265
1726
|
@pulumi.getter
|
|
1266
|
-
def prefix(self) -> Optional[pulumi.Input[str]]:
|
|
1727
|
+
def prefix(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
1267
1728
|
"""
|
|
1268
1729
|
The prefix of the value.
|
|
1269
1730
|
"""
|
|
1270
1731
|
return pulumi.get(self, "prefix")
|
|
1271
1732
|
|
|
1272
1733
|
@prefix.setter
|
|
1273
|
-
def prefix(self, value: Optional[pulumi.Input[str]]):
|
|
1734
|
+
def prefix(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
1274
1735
|
pulumi.set(self, "prefix", value)
|
|
1275
1736
|
|
|
1276
|
-
@property
|
|
1737
|
+
@_builtins.property
|
|
1277
1738
|
@pulumi.getter
|
|
1278
|
-
def regex(self) -> Optional[pulumi.Input[str]]:
|
|
1739
|
+
def regex(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
1279
1740
|
"""
|
|
1280
1741
|
The value in a regex format.
|
|
1281
1742
|
"""
|
|
1282
1743
|
return pulumi.get(self, "regex")
|
|
1283
1744
|
|
|
1284
1745
|
@regex.setter
|
|
1285
|
-
def regex(self, value: Optional[pulumi.Input[str]]):
|
|
1746
|
+
def regex(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
1286
1747
|
pulumi.set(self, "regex", value)
|
|
1287
1748
|
|
|
1288
1749
|
|
|
1750
|
+
if not MYPY:
|
|
1751
|
+
class StrategyCanaryStepVerificationArgsDict(TypedDict):
|
|
1752
|
+
template_names: pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]
|
|
1753
|
+
"""
|
|
1754
|
+
List of Verification Template names.
|
|
1755
|
+
"""
|
|
1756
|
+
elif False:
|
|
1757
|
+
StrategyCanaryStepVerificationArgsDict: TypeAlias = Mapping[str, Any]
|
|
1758
|
+
|
|
1289
1759
|
@pulumi.input_type
|
|
1290
1760
|
class StrategyCanaryStepVerificationArgs:
|
|
1291
1761
|
def __init__(__self__, *,
|
|
1292
|
-
template_names: pulumi.Input[Sequence[pulumi.Input[str]]]):
|
|
1762
|
+
template_names: pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]):
|
|
1293
1763
|
"""
|
|
1294
|
-
:param pulumi.Input[Sequence[pulumi.Input[str]]] template_names: List of Verification Template names.
|
|
1764
|
+
:param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] template_names: List of Verification Template names.
|
|
1295
1765
|
"""
|
|
1296
1766
|
pulumi.set(__self__, "template_names", template_names)
|
|
1297
1767
|
|
|
1298
|
-
@property
|
|
1768
|
+
@_builtins.property
|
|
1299
1769
|
@pulumi.getter(name="templateNames")
|
|
1300
|
-
def template_names(self) -> pulumi.Input[Sequence[pulumi.Input[str]]]:
|
|
1770
|
+
def template_names(self) -> pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]:
|
|
1301
1771
|
"""
|
|
1302
1772
|
List of Verification Template names.
|
|
1303
1773
|
"""
|
|
1304
1774
|
return pulumi.get(self, "template_names")
|
|
1305
1775
|
|
|
1306
1776
|
@template_names.setter
|
|
1307
|
-
def template_names(self, value: pulumi.Input[Sequence[pulumi.Input[str]]]):
|
|
1777
|
+
def template_names(self, value: pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]):
|
|
1308
1778
|
pulumi.set(self, "template_names", value)
|
|
1309
1779
|
|
|
1310
1780
|
|
|
1781
|
+
if not MYPY:
|
|
1782
|
+
class StrategyRollingArgsDict(TypedDict):
|
|
1783
|
+
steps: pulumi.Input[Sequence[pulumi.Input['StrategyRollingStepArgsDict']]]
|
|
1784
|
+
"""
|
|
1785
|
+
A set of separate conditions of rollout processing.
|
|
1786
|
+
"""
|
|
1787
|
+
elif False:
|
|
1788
|
+
StrategyRollingArgsDict: TypeAlias = Mapping[str, Any]
|
|
1789
|
+
|
|
1311
1790
|
@pulumi.input_type
|
|
1312
1791
|
class StrategyRollingArgs:
|
|
1313
1792
|
def __init__(__self__, *,
|
|
@@ -1317,7 +1796,7 @@ class StrategyRollingArgs:
|
|
|
1317
1796
|
"""
|
|
1318
1797
|
pulumi.set(__self__, "steps", steps)
|
|
1319
1798
|
|
|
1320
|
-
@property
|
|
1799
|
+
@_builtins.property
|
|
1321
1800
|
@pulumi.getter
|
|
1322
1801
|
def steps(self) -> pulumi.Input[Sequence[pulumi.Input['StrategyRollingStepArgs']]]:
|
|
1323
1802
|
"""
|
|
@@ -1330,11 +1809,25 @@ class StrategyRollingArgs:
|
|
|
1330
1809
|
pulumi.set(self, "steps", value)
|
|
1331
1810
|
|
|
1332
1811
|
|
|
1812
|
+
if not MYPY:
|
|
1813
|
+
class StrategyRollingStepArgsDict(TypedDict):
|
|
1814
|
+
pause: NotRequired[pulumi.Input['StrategyRollingStepPauseArgsDict']]
|
|
1815
|
+
"""
|
|
1816
|
+
Defines the duration of time to freeze the rollout.
|
|
1817
|
+
"""
|
|
1818
|
+
steps_name: NotRequired[pulumi.Input[_builtins.str]]
|
|
1819
|
+
verification: NotRequired[pulumi.Input['StrategyRollingStepVerificationArgsDict']]
|
|
1820
|
+
"""
|
|
1821
|
+
Represents the list of verifications to run in a step.
|
|
1822
|
+
"""
|
|
1823
|
+
elif False:
|
|
1824
|
+
StrategyRollingStepArgsDict: TypeAlias = Mapping[str, Any]
|
|
1825
|
+
|
|
1333
1826
|
@pulumi.input_type
|
|
1334
1827
|
class StrategyRollingStepArgs:
|
|
1335
1828
|
def __init__(__self__, *,
|
|
1336
1829
|
pause: Optional[pulumi.Input['StrategyRollingStepPauseArgs']] = None,
|
|
1337
|
-
steps_name: Optional[pulumi.Input[str]] = None,
|
|
1830
|
+
steps_name: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1338
1831
|
verification: Optional[pulumi.Input['StrategyRollingStepVerificationArgs']] = None):
|
|
1339
1832
|
"""
|
|
1340
1833
|
:param pulumi.Input['StrategyRollingStepPauseArgs'] pause: Defines the duration of time to freeze the rollout.
|
|
@@ -1347,7 +1840,7 @@ class StrategyRollingStepArgs:
|
|
|
1347
1840
|
if verification is not None:
|
|
1348
1841
|
pulumi.set(__self__, "verification", verification)
|
|
1349
1842
|
|
|
1350
|
-
@property
|
|
1843
|
+
@_builtins.property
|
|
1351
1844
|
@pulumi.getter
|
|
1352
1845
|
def pause(self) -> Optional[pulumi.Input['StrategyRollingStepPauseArgs']]:
|
|
1353
1846
|
"""
|
|
@@ -1359,16 +1852,16 @@ class StrategyRollingStepArgs:
|
|
|
1359
1852
|
def pause(self, value: Optional[pulumi.Input['StrategyRollingStepPauseArgs']]):
|
|
1360
1853
|
pulumi.set(self, "pause", value)
|
|
1361
1854
|
|
|
1362
|
-
@property
|
|
1855
|
+
@_builtins.property
|
|
1363
1856
|
@pulumi.getter(name="stepsName")
|
|
1364
|
-
def steps_name(self) -> Optional[pulumi.Input[str]]:
|
|
1857
|
+
def steps_name(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
1365
1858
|
return pulumi.get(self, "steps_name")
|
|
1366
1859
|
|
|
1367
1860
|
@steps_name.setter
|
|
1368
|
-
def steps_name(self, value: Optional[pulumi.Input[str]]):
|
|
1861
|
+
def steps_name(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
1369
1862
|
pulumi.set(self, "steps_name", value)
|
|
1370
1863
|
|
|
1371
|
-
@property
|
|
1864
|
+
@_builtins.property
|
|
1372
1865
|
@pulumi.getter
|
|
1373
1866
|
def verification(self) -> Optional[pulumi.Input['StrategyRollingStepVerificationArgs']]:
|
|
1374
1867
|
"""
|
|
@@ -1381,190 +1874,273 @@ class StrategyRollingStepArgs:
|
|
|
1381
1874
|
pulumi.set(self, "verification", value)
|
|
1382
1875
|
|
|
1383
1876
|
|
|
1877
|
+
if not MYPY:
|
|
1878
|
+
class StrategyRollingStepPauseArgsDict(TypedDict):
|
|
1879
|
+
duration: NotRequired[pulumi.Input[_builtins.str]]
|
|
1880
|
+
"""
|
|
1881
|
+
The amount of time to wait before moving to the next step.
|
|
1882
|
+
"""
|
|
1883
|
+
elif False:
|
|
1884
|
+
StrategyRollingStepPauseArgsDict: TypeAlias = Mapping[str, Any]
|
|
1885
|
+
|
|
1384
1886
|
@pulumi.input_type
|
|
1385
1887
|
class StrategyRollingStepPauseArgs:
|
|
1386
1888
|
def __init__(__self__, *,
|
|
1387
|
-
duration: Optional[pulumi.Input[str]] = None):
|
|
1889
|
+
duration: Optional[pulumi.Input[_builtins.str]] = None):
|
|
1388
1890
|
"""
|
|
1389
|
-
:param pulumi.Input[str] duration: The amount of time to wait before moving to the next step.
|
|
1891
|
+
:param pulumi.Input[_builtins.str] duration: The amount of time to wait before moving to the next step.
|
|
1390
1892
|
"""
|
|
1391
1893
|
if duration is not None:
|
|
1392
1894
|
pulumi.set(__self__, "duration", duration)
|
|
1393
1895
|
|
|
1394
|
-
@property
|
|
1896
|
+
@_builtins.property
|
|
1395
1897
|
@pulumi.getter
|
|
1396
|
-
def duration(self) -> Optional[pulumi.Input[str]]:
|
|
1898
|
+
def duration(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
1397
1899
|
"""
|
|
1398
1900
|
The amount of time to wait before moving to the next step.
|
|
1399
1901
|
"""
|
|
1400
1902
|
return pulumi.get(self, "duration")
|
|
1401
1903
|
|
|
1402
1904
|
@duration.setter
|
|
1403
|
-
def duration(self, value: Optional[pulumi.Input[str]]):
|
|
1905
|
+
def duration(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
1404
1906
|
pulumi.set(self, "duration", value)
|
|
1405
1907
|
|
|
1406
1908
|
|
|
1909
|
+
if not MYPY:
|
|
1910
|
+
class StrategyRollingStepVerificationArgsDict(TypedDict):
|
|
1911
|
+
template_names: pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]
|
|
1912
|
+
"""
|
|
1913
|
+
List of Verification Template names.
|
|
1914
|
+
"""
|
|
1915
|
+
elif False:
|
|
1916
|
+
StrategyRollingStepVerificationArgsDict: TypeAlias = Mapping[str, Any]
|
|
1917
|
+
|
|
1407
1918
|
@pulumi.input_type
|
|
1408
1919
|
class StrategyRollingStepVerificationArgs:
|
|
1409
1920
|
def __init__(__self__, *,
|
|
1410
|
-
template_names: pulumi.Input[Sequence[pulumi.Input[str]]]):
|
|
1921
|
+
template_names: pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]):
|
|
1411
1922
|
"""
|
|
1412
|
-
:param pulumi.Input[Sequence[pulumi.Input[str]]] template_names: List of Verification Template names.
|
|
1923
|
+
:param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] template_names: List of Verification Template names.
|
|
1413
1924
|
"""
|
|
1414
1925
|
pulumi.set(__self__, "template_names", template_names)
|
|
1415
1926
|
|
|
1416
|
-
@property
|
|
1927
|
+
@_builtins.property
|
|
1417
1928
|
@pulumi.getter(name="templateNames")
|
|
1418
|
-
def template_names(self) -> pulumi.Input[Sequence[pulumi.Input[str]]]:
|
|
1929
|
+
def template_names(self) -> pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]:
|
|
1419
1930
|
"""
|
|
1420
1931
|
List of Verification Template names.
|
|
1421
1932
|
"""
|
|
1422
1933
|
return pulumi.get(self, "template_names")
|
|
1423
1934
|
|
|
1424
1935
|
@template_names.setter
|
|
1425
|
-
def template_names(self, value: pulumi.Input[Sequence[pulumi.Input[str]]]):
|
|
1936
|
+
def template_names(self, value: pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]):
|
|
1426
1937
|
pulumi.set(self, "template_names", value)
|
|
1427
1938
|
|
|
1428
1939
|
|
|
1940
|
+
if not MYPY:
|
|
1941
|
+
class VerificationProviderCloudWatchArgsDict(TypedDict):
|
|
1942
|
+
iam_arn: pulumi.Input[_builtins.str]
|
|
1943
|
+
"""
|
|
1944
|
+
Set label key.
|
|
1945
|
+
"""
|
|
1946
|
+
elif False:
|
|
1947
|
+
VerificationProviderCloudWatchArgsDict: TypeAlias = Mapping[str, Any]
|
|
1948
|
+
|
|
1429
1949
|
@pulumi.input_type
|
|
1430
1950
|
class VerificationProviderCloudWatchArgs:
|
|
1431
1951
|
def __init__(__self__, *,
|
|
1432
|
-
iam_arn: pulumi.Input[str]):
|
|
1952
|
+
iam_arn: pulumi.Input[_builtins.str]):
|
|
1433
1953
|
"""
|
|
1434
|
-
:param pulumi.Input[str] iam_arn: Set label key.
|
|
1954
|
+
:param pulumi.Input[_builtins.str] iam_arn: Set label key.
|
|
1435
1955
|
"""
|
|
1436
1956
|
pulumi.set(__self__, "iam_arn", iam_arn)
|
|
1437
1957
|
|
|
1438
|
-
@property
|
|
1958
|
+
@_builtins.property
|
|
1439
1959
|
@pulumi.getter(name="iamArn")
|
|
1440
|
-
def iam_arn(self) -> pulumi.Input[str]:
|
|
1960
|
+
def iam_arn(self) -> pulumi.Input[_builtins.str]:
|
|
1441
1961
|
"""
|
|
1442
1962
|
Set label key.
|
|
1443
1963
|
"""
|
|
1444
1964
|
return pulumi.get(self, "iam_arn")
|
|
1445
1965
|
|
|
1446
1966
|
@iam_arn.setter
|
|
1447
|
-
def iam_arn(self, value: pulumi.Input[str]):
|
|
1967
|
+
def iam_arn(self, value: pulumi.Input[_builtins.str]):
|
|
1448
1968
|
pulumi.set(self, "iam_arn", value)
|
|
1449
1969
|
|
|
1450
1970
|
|
|
1451
|
-
|
|
1452
|
-
class
|
|
1453
|
-
|
|
1454
|
-
address: pulumi.Input[str],
|
|
1455
|
-
api_key: pulumi.Input[str],
|
|
1456
|
-
app_key: pulumi.Input[str]):
|
|
1971
|
+
if not MYPY:
|
|
1972
|
+
class VerificationProviderDatadogArgsDict(TypedDict):
|
|
1973
|
+
address: pulumi.Input[_builtins.str]
|
|
1457
1974
|
"""
|
|
1458
|
-
|
|
1459
|
-
:param pulumi.Input[str] api_key: API key required by the Datadog Agent to submit metrics and events to Datadog.
|
|
1460
|
-
:param pulumi.Input[str] app_key: API key that gives users access to Datadog’s programmatic API.
|
|
1975
|
+
DataDog API URL.
|
|
1461
1976
|
"""
|
|
1462
|
-
pulumi.
|
|
1463
|
-
|
|
1464
|
-
|
|
1977
|
+
api_key: pulumi.Input[_builtins.str]
|
|
1978
|
+
"""
|
|
1979
|
+
API key required by the Datadog Agent to submit metrics and events to Datadog.
|
|
1980
|
+
"""
|
|
1981
|
+
app_key: pulumi.Input[_builtins.str]
|
|
1982
|
+
"""
|
|
1983
|
+
API key that gives users access to Datadog’s programmatic API.
|
|
1984
|
+
"""
|
|
1985
|
+
elif False:
|
|
1986
|
+
VerificationProviderDatadogArgsDict: TypeAlias = Mapping[str, Any]
|
|
1465
1987
|
|
|
1466
|
-
|
|
1988
|
+
@pulumi.input_type
|
|
1989
|
+
class VerificationProviderDatadogArgs:
|
|
1990
|
+
def __init__(__self__, *,
|
|
1991
|
+
address: pulumi.Input[_builtins.str],
|
|
1992
|
+
api_key: pulumi.Input[_builtins.str],
|
|
1993
|
+
app_key: pulumi.Input[_builtins.str]):
|
|
1994
|
+
"""
|
|
1995
|
+
:param pulumi.Input[_builtins.str] address: DataDog API URL.
|
|
1996
|
+
:param pulumi.Input[_builtins.str] api_key: API key required by the Datadog Agent to submit metrics and events to Datadog.
|
|
1997
|
+
:param pulumi.Input[_builtins.str] app_key: API key that gives users access to Datadog’s programmatic API.
|
|
1998
|
+
"""
|
|
1999
|
+
pulumi.set(__self__, "address", address)
|
|
2000
|
+
pulumi.set(__self__, "api_key", api_key)
|
|
2001
|
+
pulumi.set(__self__, "app_key", app_key)
|
|
2002
|
+
|
|
2003
|
+
@_builtins.property
|
|
1467
2004
|
@pulumi.getter
|
|
1468
|
-
def address(self) -> pulumi.Input[str]:
|
|
2005
|
+
def address(self) -> pulumi.Input[_builtins.str]:
|
|
1469
2006
|
"""
|
|
1470
2007
|
DataDog API URL.
|
|
1471
2008
|
"""
|
|
1472
2009
|
return pulumi.get(self, "address")
|
|
1473
2010
|
|
|
1474
2011
|
@address.setter
|
|
1475
|
-
def address(self, value: pulumi.Input[str]):
|
|
2012
|
+
def address(self, value: pulumi.Input[_builtins.str]):
|
|
1476
2013
|
pulumi.set(self, "address", value)
|
|
1477
2014
|
|
|
1478
|
-
@property
|
|
2015
|
+
@_builtins.property
|
|
1479
2016
|
@pulumi.getter(name="apiKey")
|
|
1480
|
-
def api_key(self) -> pulumi.Input[str]:
|
|
2017
|
+
def api_key(self) -> pulumi.Input[_builtins.str]:
|
|
1481
2018
|
"""
|
|
1482
2019
|
API key required by the Datadog Agent to submit metrics and events to Datadog.
|
|
1483
2020
|
"""
|
|
1484
2021
|
return pulumi.get(self, "api_key")
|
|
1485
2022
|
|
|
1486
2023
|
@api_key.setter
|
|
1487
|
-
def api_key(self, value: pulumi.Input[str]):
|
|
2024
|
+
def api_key(self, value: pulumi.Input[_builtins.str]):
|
|
1488
2025
|
pulumi.set(self, "api_key", value)
|
|
1489
2026
|
|
|
1490
|
-
@property
|
|
2027
|
+
@_builtins.property
|
|
1491
2028
|
@pulumi.getter(name="appKey")
|
|
1492
|
-
def app_key(self) -> pulumi.Input[str]:
|
|
2029
|
+
def app_key(self) -> pulumi.Input[_builtins.str]:
|
|
1493
2030
|
"""
|
|
1494
2031
|
API key that gives users access to Datadog’s programmatic API.
|
|
1495
2032
|
"""
|
|
1496
2033
|
return pulumi.get(self, "app_key")
|
|
1497
2034
|
|
|
1498
2035
|
@app_key.setter
|
|
1499
|
-
def app_key(self, value: pulumi.Input[str]):
|
|
2036
|
+
def app_key(self, value: pulumi.Input[_builtins.str]):
|
|
1500
2037
|
pulumi.set(self, "app_key", value)
|
|
1501
2038
|
|
|
1502
2039
|
|
|
2040
|
+
if not MYPY:
|
|
2041
|
+
class VerificationProviderJenkinsArgsDict(TypedDict):
|
|
2042
|
+
api_token: pulumi.Input[_builtins.str]
|
|
2043
|
+
"""
|
|
2044
|
+
The Jenkins server’s access apiToken.
|
|
2045
|
+
"""
|
|
2046
|
+
base_url: pulumi.Input[_builtins.str]
|
|
2047
|
+
"""
|
|
2048
|
+
The address of the Jenkins server within the cluster.
|
|
2049
|
+
"""
|
|
2050
|
+
username: pulumi.Input[_builtins.str]
|
|
2051
|
+
"""
|
|
2052
|
+
The Jenkins server’s access username.
|
|
2053
|
+
"""
|
|
2054
|
+
elif False:
|
|
2055
|
+
VerificationProviderJenkinsArgsDict: TypeAlias = Mapping[str, Any]
|
|
2056
|
+
|
|
1503
2057
|
@pulumi.input_type
|
|
1504
2058
|
class VerificationProviderJenkinsArgs:
|
|
1505
2059
|
def __init__(__self__, *,
|
|
1506
|
-
api_token: pulumi.Input[str],
|
|
1507
|
-
base_url: pulumi.Input[str],
|
|
1508
|
-
username: pulumi.Input[str]):
|
|
2060
|
+
api_token: pulumi.Input[_builtins.str],
|
|
2061
|
+
base_url: pulumi.Input[_builtins.str],
|
|
2062
|
+
username: pulumi.Input[_builtins.str]):
|
|
1509
2063
|
"""
|
|
1510
|
-
:param pulumi.Input[str] api_token: The Jenkins server’s access apiToken.
|
|
1511
|
-
:param pulumi.Input[str] base_url: The address of the Jenkins server within the cluster.
|
|
1512
|
-
:param pulumi.Input[str] username: The Jenkins server’s access username.
|
|
2064
|
+
:param pulumi.Input[_builtins.str] api_token: The Jenkins server’s access apiToken.
|
|
2065
|
+
:param pulumi.Input[_builtins.str] base_url: The address of the Jenkins server within the cluster.
|
|
2066
|
+
:param pulumi.Input[_builtins.str] username: The Jenkins server’s access username.
|
|
1513
2067
|
"""
|
|
1514
2068
|
pulumi.set(__self__, "api_token", api_token)
|
|
1515
2069
|
pulumi.set(__self__, "base_url", base_url)
|
|
1516
2070
|
pulumi.set(__self__, "username", username)
|
|
1517
2071
|
|
|
1518
|
-
@property
|
|
2072
|
+
@_builtins.property
|
|
1519
2073
|
@pulumi.getter(name="apiToken")
|
|
1520
|
-
def api_token(self) -> pulumi.Input[str]:
|
|
2074
|
+
def api_token(self) -> pulumi.Input[_builtins.str]:
|
|
1521
2075
|
"""
|
|
1522
2076
|
The Jenkins server’s access apiToken.
|
|
1523
2077
|
"""
|
|
1524
2078
|
return pulumi.get(self, "api_token")
|
|
1525
2079
|
|
|
1526
2080
|
@api_token.setter
|
|
1527
|
-
def api_token(self, value: pulumi.Input[str]):
|
|
2081
|
+
def api_token(self, value: pulumi.Input[_builtins.str]):
|
|
1528
2082
|
pulumi.set(self, "api_token", value)
|
|
1529
2083
|
|
|
1530
|
-
@property
|
|
2084
|
+
@_builtins.property
|
|
1531
2085
|
@pulumi.getter(name="baseUrl")
|
|
1532
|
-
def base_url(self) -> pulumi.Input[str]:
|
|
2086
|
+
def base_url(self) -> pulumi.Input[_builtins.str]:
|
|
1533
2087
|
"""
|
|
1534
2088
|
The address of the Jenkins server within the cluster.
|
|
1535
2089
|
"""
|
|
1536
2090
|
return pulumi.get(self, "base_url")
|
|
1537
2091
|
|
|
1538
2092
|
@base_url.setter
|
|
1539
|
-
def base_url(self, value: pulumi.Input[str]):
|
|
2093
|
+
def base_url(self, value: pulumi.Input[_builtins.str]):
|
|
1540
2094
|
pulumi.set(self, "base_url", value)
|
|
1541
2095
|
|
|
1542
|
-
@property
|
|
2096
|
+
@_builtins.property
|
|
1543
2097
|
@pulumi.getter
|
|
1544
|
-
def username(self) -> pulumi.Input[str]:
|
|
2098
|
+
def username(self) -> pulumi.Input[_builtins.str]:
|
|
1545
2099
|
"""
|
|
1546
2100
|
The Jenkins server’s access username.
|
|
1547
2101
|
"""
|
|
1548
2102
|
return pulumi.get(self, "username")
|
|
1549
2103
|
|
|
1550
2104
|
@username.setter
|
|
1551
|
-
def username(self, value: pulumi.Input[str]):
|
|
2105
|
+
def username(self, value: pulumi.Input[_builtins.str]):
|
|
1552
2106
|
pulumi.set(self, "username", value)
|
|
1553
2107
|
|
|
1554
2108
|
|
|
2109
|
+
if not MYPY:
|
|
2110
|
+
class VerificationProviderNewRelicArgsDict(TypedDict):
|
|
2111
|
+
account_id: pulumi.Input[_builtins.str]
|
|
2112
|
+
personal_api_key: pulumi.Input[_builtins.str]
|
|
2113
|
+
"""
|
|
2114
|
+
The NewRelic user key
|
|
2115
|
+
"""
|
|
2116
|
+
base_url_nerd_graph: NotRequired[pulumi.Input[_builtins.str]]
|
|
2117
|
+
"""
|
|
2118
|
+
The base URL for NerdGraph for a proxy.
|
|
2119
|
+
"""
|
|
2120
|
+
base_url_rest: NotRequired[pulumi.Input[_builtins.str]]
|
|
2121
|
+
"""
|
|
2122
|
+
The base URL of the New Relic REST API for a proxy.
|
|
2123
|
+
"""
|
|
2124
|
+
region: NotRequired[pulumi.Input[_builtins.str]]
|
|
2125
|
+
"""
|
|
2126
|
+
A region which the account is attached to. Default is "us".
|
|
2127
|
+
"""
|
|
2128
|
+
elif False:
|
|
2129
|
+
VerificationProviderNewRelicArgsDict: TypeAlias = Mapping[str, Any]
|
|
2130
|
+
|
|
1555
2131
|
@pulumi.input_type
|
|
1556
2132
|
class VerificationProviderNewRelicArgs:
|
|
1557
2133
|
def __init__(__self__, *,
|
|
1558
|
-
account_id: pulumi.Input[str],
|
|
1559
|
-
personal_api_key: pulumi.Input[str],
|
|
1560
|
-
base_url_nerd_graph: Optional[pulumi.Input[str]] = None,
|
|
1561
|
-
base_url_rest: Optional[pulumi.Input[str]] = None,
|
|
1562
|
-
region: Optional[pulumi.Input[str]] = None):
|
|
2134
|
+
account_id: pulumi.Input[_builtins.str],
|
|
2135
|
+
personal_api_key: pulumi.Input[_builtins.str],
|
|
2136
|
+
base_url_nerd_graph: Optional[pulumi.Input[_builtins.str]] = None,
|
|
2137
|
+
base_url_rest: Optional[pulumi.Input[_builtins.str]] = None,
|
|
2138
|
+
region: Optional[pulumi.Input[_builtins.str]] = None):
|
|
1563
2139
|
"""
|
|
1564
|
-
:param pulumi.Input[str] personal_api_key: The NewRelic user key
|
|
1565
|
-
:param pulumi.Input[str] base_url_nerd_graph: The base URL for NerdGraph for a proxy.
|
|
1566
|
-
:param pulumi.Input[str] base_url_rest: The base URL of the New Relic REST API for a proxy.
|
|
1567
|
-
:param pulumi.Input[str] region: A region which the account is attached to. Default is "us".
|
|
2140
|
+
:param pulumi.Input[_builtins.str] personal_api_key: The NewRelic user key
|
|
2141
|
+
:param pulumi.Input[_builtins.str] base_url_nerd_graph: The base URL for NerdGraph for a proxy.
|
|
2142
|
+
:param pulumi.Input[_builtins.str] base_url_rest: The base URL of the New Relic REST API for a proxy.
|
|
2143
|
+
:param pulumi.Input[_builtins.str] region: A region which the account is attached to. Default is "us".
|
|
1568
2144
|
"""
|
|
1569
2145
|
pulumi.set(__self__, "account_id", account_id)
|
|
1570
2146
|
pulumi.set(__self__, "personal_api_key", personal_api_key)
|
|
@@ -1575,95 +2151,121 @@ class VerificationProviderNewRelicArgs:
|
|
|
1575
2151
|
if region is not None:
|
|
1576
2152
|
pulumi.set(__self__, "region", region)
|
|
1577
2153
|
|
|
1578
|
-
@property
|
|
2154
|
+
@_builtins.property
|
|
1579
2155
|
@pulumi.getter(name="accountId")
|
|
1580
|
-
def account_id(self) -> pulumi.Input[str]:
|
|
2156
|
+
def account_id(self) -> pulumi.Input[_builtins.str]:
|
|
1581
2157
|
return pulumi.get(self, "account_id")
|
|
1582
2158
|
|
|
1583
2159
|
@account_id.setter
|
|
1584
|
-
def account_id(self, value: pulumi.Input[str]):
|
|
2160
|
+
def account_id(self, value: pulumi.Input[_builtins.str]):
|
|
1585
2161
|
pulumi.set(self, "account_id", value)
|
|
1586
2162
|
|
|
1587
|
-
@property
|
|
2163
|
+
@_builtins.property
|
|
1588
2164
|
@pulumi.getter(name="personalApiKey")
|
|
1589
|
-
def personal_api_key(self) -> pulumi.Input[str]:
|
|
2165
|
+
def personal_api_key(self) -> pulumi.Input[_builtins.str]:
|
|
1590
2166
|
"""
|
|
1591
2167
|
The NewRelic user key
|
|
1592
2168
|
"""
|
|
1593
2169
|
return pulumi.get(self, "personal_api_key")
|
|
1594
2170
|
|
|
1595
2171
|
@personal_api_key.setter
|
|
1596
|
-
def personal_api_key(self, value: pulumi.Input[str]):
|
|
2172
|
+
def personal_api_key(self, value: pulumi.Input[_builtins.str]):
|
|
1597
2173
|
pulumi.set(self, "personal_api_key", value)
|
|
1598
2174
|
|
|
1599
|
-
@property
|
|
2175
|
+
@_builtins.property
|
|
1600
2176
|
@pulumi.getter(name="baseUrlNerdGraph")
|
|
1601
|
-
def base_url_nerd_graph(self) -> Optional[pulumi.Input[str]]:
|
|
2177
|
+
def base_url_nerd_graph(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
1602
2178
|
"""
|
|
1603
2179
|
The base URL for NerdGraph for a proxy.
|
|
1604
2180
|
"""
|
|
1605
2181
|
return pulumi.get(self, "base_url_nerd_graph")
|
|
1606
2182
|
|
|
1607
2183
|
@base_url_nerd_graph.setter
|
|
1608
|
-
def base_url_nerd_graph(self, value: Optional[pulumi.Input[str]]):
|
|
2184
|
+
def base_url_nerd_graph(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
1609
2185
|
pulumi.set(self, "base_url_nerd_graph", value)
|
|
1610
2186
|
|
|
1611
|
-
@property
|
|
2187
|
+
@_builtins.property
|
|
1612
2188
|
@pulumi.getter(name="baseUrlRest")
|
|
1613
|
-
def base_url_rest(self) -> Optional[pulumi.Input[str]]:
|
|
2189
|
+
def base_url_rest(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
1614
2190
|
"""
|
|
1615
2191
|
The base URL of the New Relic REST API for a proxy.
|
|
1616
2192
|
"""
|
|
1617
2193
|
return pulumi.get(self, "base_url_rest")
|
|
1618
2194
|
|
|
1619
2195
|
@base_url_rest.setter
|
|
1620
|
-
def base_url_rest(self, value: Optional[pulumi.Input[str]]):
|
|
2196
|
+
def base_url_rest(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
1621
2197
|
pulumi.set(self, "base_url_rest", value)
|
|
1622
2198
|
|
|
1623
|
-
@property
|
|
2199
|
+
@_builtins.property
|
|
1624
2200
|
@pulumi.getter
|
|
1625
|
-
def region(self) -> Optional[pulumi.Input[str]]:
|
|
2201
|
+
def region(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
1626
2202
|
"""
|
|
1627
2203
|
A region which the account is attached to. Default is "us".
|
|
1628
2204
|
"""
|
|
1629
2205
|
return pulumi.get(self, "region")
|
|
1630
2206
|
|
|
1631
2207
|
@region.setter
|
|
1632
|
-
def region(self, value: Optional[pulumi.Input[str]]):
|
|
2208
|
+
def region(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
1633
2209
|
pulumi.set(self, "region", value)
|
|
1634
2210
|
|
|
1635
2211
|
|
|
2212
|
+
if not MYPY:
|
|
2213
|
+
class VerificationProviderPrometheusArgsDict(TypedDict):
|
|
2214
|
+
address: pulumi.Input[_builtins.str]
|
|
2215
|
+
"""
|
|
2216
|
+
The address which the Prometheus server available on.
|
|
2217
|
+
"""
|
|
2218
|
+
elif False:
|
|
2219
|
+
VerificationProviderPrometheusArgsDict: TypeAlias = Mapping[str, Any]
|
|
2220
|
+
|
|
1636
2221
|
@pulumi.input_type
|
|
1637
2222
|
class VerificationProviderPrometheusArgs:
|
|
1638
2223
|
def __init__(__self__, *,
|
|
1639
|
-
address: pulumi.Input[str]):
|
|
2224
|
+
address: pulumi.Input[_builtins.str]):
|
|
1640
2225
|
"""
|
|
1641
|
-
:param pulumi.Input[str] address: The address which the Prometheus server available on.
|
|
2226
|
+
:param pulumi.Input[_builtins.str] address: The address which the Prometheus server available on.
|
|
1642
2227
|
"""
|
|
1643
2228
|
pulumi.set(__self__, "address", address)
|
|
1644
2229
|
|
|
1645
|
-
@property
|
|
2230
|
+
@_builtins.property
|
|
1646
2231
|
@pulumi.getter
|
|
1647
|
-
def address(self) -> pulumi.Input[str]:
|
|
2232
|
+
def address(self) -> pulumi.Input[_builtins.str]:
|
|
1648
2233
|
"""
|
|
1649
2234
|
The address which the Prometheus server available on.
|
|
1650
2235
|
"""
|
|
1651
2236
|
return pulumi.get(self, "address")
|
|
1652
2237
|
|
|
1653
2238
|
@address.setter
|
|
1654
|
-
def address(self, value: pulumi.Input[str]):
|
|
2239
|
+
def address(self, value: pulumi.Input[_builtins.str]):
|
|
1655
2240
|
pulumi.set(self, "address", value)
|
|
1656
2241
|
|
|
1657
2242
|
|
|
2243
|
+
if not MYPY:
|
|
2244
|
+
class VerificationTemplateArgArgsDict(TypedDict):
|
|
2245
|
+
arg_name: pulumi.Input[_builtins.str]
|
|
2246
|
+
"""
|
|
2247
|
+
Name of an argument.
|
|
2248
|
+
"""
|
|
2249
|
+
value: NotRequired[pulumi.Input[_builtins.str]]
|
|
2250
|
+
"""
|
|
2251
|
+
String representation of data.
|
|
2252
|
+
"""
|
|
2253
|
+
value_from: NotRequired[pulumi.Input['VerificationTemplateArgValueFromArgsDict']]
|
|
2254
|
+
"""
|
|
2255
|
+
ValueFrom object.
|
|
2256
|
+
"""
|
|
2257
|
+
elif False:
|
|
2258
|
+
VerificationTemplateArgArgsDict: TypeAlias = Mapping[str, Any]
|
|
2259
|
+
|
|
1658
2260
|
@pulumi.input_type
|
|
1659
2261
|
class VerificationTemplateArgArgs:
|
|
1660
2262
|
def __init__(__self__, *,
|
|
1661
|
-
arg_name: pulumi.Input[str],
|
|
1662
|
-
value: Optional[pulumi.Input[str]] = None,
|
|
2263
|
+
arg_name: pulumi.Input[_builtins.str],
|
|
2264
|
+
value: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1663
2265
|
value_from: Optional[pulumi.Input['VerificationTemplateArgValueFromArgs']] = None):
|
|
1664
2266
|
"""
|
|
1665
|
-
:param pulumi.Input[str] arg_name: Name of an argument.
|
|
1666
|
-
:param pulumi.Input[str] value: String representation of data.
|
|
2267
|
+
:param pulumi.Input[_builtins.str] arg_name: Name of an argument.
|
|
2268
|
+
:param pulumi.Input[_builtins.str] value: String representation of data.
|
|
1667
2269
|
:param pulumi.Input['VerificationTemplateArgValueFromArgs'] value_from: ValueFrom object.
|
|
1668
2270
|
"""
|
|
1669
2271
|
pulumi.set(__self__, "arg_name", arg_name)
|
|
@@ -1672,31 +2274,31 @@ class VerificationTemplateArgArgs:
|
|
|
1672
2274
|
if value_from is not None:
|
|
1673
2275
|
pulumi.set(__self__, "value_from", value_from)
|
|
1674
2276
|
|
|
1675
|
-
@property
|
|
2277
|
+
@_builtins.property
|
|
1676
2278
|
@pulumi.getter(name="argName")
|
|
1677
|
-
def arg_name(self) -> pulumi.Input[str]:
|
|
2279
|
+
def arg_name(self) -> pulumi.Input[_builtins.str]:
|
|
1678
2280
|
"""
|
|
1679
2281
|
Name of an argument.
|
|
1680
2282
|
"""
|
|
1681
2283
|
return pulumi.get(self, "arg_name")
|
|
1682
2284
|
|
|
1683
2285
|
@arg_name.setter
|
|
1684
|
-
def arg_name(self, value: pulumi.Input[str]):
|
|
2286
|
+
def arg_name(self, value: pulumi.Input[_builtins.str]):
|
|
1685
2287
|
pulumi.set(self, "arg_name", value)
|
|
1686
2288
|
|
|
1687
|
-
@property
|
|
2289
|
+
@_builtins.property
|
|
1688
2290
|
@pulumi.getter
|
|
1689
|
-
def value(self) -> Optional[pulumi.Input[str]]:
|
|
2291
|
+
def value(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
1690
2292
|
"""
|
|
1691
2293
|
String representation of data.
|
|
1692
2294
|
"""
|
|
1693
2295
|
return pulumi.get(self, "value")
|
|
1694
2296
|
|
|
1695
2297
|
@value.setter
|
|
1696
|
-
def value(self, value: Optional[pulumi.Input[str]]):
|
|
2298
|
+
def value(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
1697
2299
|
pulumi.set(self, "value", value)
|
|
1698
2300
|
|
|
1699
|
-
@property
|
|
2301
|
+
@_builtins.property
|
|
1700
2302
|
@pulumi.getter(name="valueFrom")
|
|
1701
2303
|
def value_from(self) -> Optional[pulumi.Input['VerificationTemplateArgValueFromArgs']]:
|
|
1702
2304
|
"""
|
|
@@ -1709,6 +2311,15 @@ class VerificationTemplateArgArgs:
|
|
|
1709
2311
|
pulumi.set(self, "value_from", value)
|
|
1710
2312
|
|
|
1711
2313
|
|
|
2314
|
+
if not MYPY:
|
|
2315
|
+
class VerificationTemplateArgValueFromArgsDict(TypedDict):
|
|
2316
|
+
secret_key_ref: NotRequired[pulumi.Input['VerificationTemplateArgValueFromSecretKeyRefArgsDict']]
|
|
2317
|
+
"""
|
|
2318
|
+
Secret key to use.
|
|
2319
|
+
"""
|
|
2320
|
+
elif False:
|
|
2321
|
+
VerificationTemplateArgValueFromArgsDict: TypeAlias = Mapping[str, Any]
|
|
2322
|
+
|
|
1712
2323
|
@pulumi.input_type
|
|
1713
2324
|
class VerificationTemplateArgValueFromArgs:
|
|
1714
2325
|
def __init__(__self__, *,
|
|
@@ -1719,7 +2330,7 @@ class VerificationTemplateArgValueFromArgs:
|
|
|
1719
2330
|
if secret_key_ref is not None:
|
|
1720
2331
|
pulumi.set(__self__, "secret_key_ref", secret_key_ref)
|
|
1721
2332
|
|
|
1722
|
-
@property
|
|
2333
|
+
@_builtins.property
|
|
1723
2334
|
@pulumi.getter(name="secretKeyRef")
|
|
1724
2335
|
def secret_key_ref(self) -> Optional[pulumi.Input['VerificationTemplateArgValueFromSecretKeyRefArgs']]:
|
|
1725
2336
|
"""
|
|
@@ -1732,69 +2343,131 @@ class VerificationTemplateArgValueFromArgs:
|
|
|
1732
2343
|
pulumi.set(self, "secret_key_ref", value)
|
|
1733
2344
|
|
|
1734
2345
|
|
|
2346
|
+
if not MYPY:
|
|
2347
|
+
class VerificationTemplateArgValueFromSecretKeyRefArgsDict(TypedDict):
|
|
2348
|
+
key: pulumi.Input[_builtins.str]
|
|
2349
|
+
"""
|
|
2350
|
+
The name of the field inside the secret.
|
|
2351
|
+
"""
|
|
2352
|
+
name: pulumi.Input[_builtins.str]
|
|
2353
|
+
"""
|
|
2354
|
+
The name of the secret.
|
|
2355
|
+
"""
|
|
2356
|
+
elif False:
|
|
2357
|
+
VerificationTemplateArgValueFromSecretKeyRefArgsDict: TypeAlias = Mapping[str, Any]
|
|
2358
|
+
|
|
1735
2359
|
@pulumi.input_type
|
|
1736
2360
|
class VerificationTemplateArgValueFromSecretKeyRefArgs:
|
|
1737
2361
|
def __init__(__self__, *,
|
|
1738
|
-
key: pulumi.Input[str],
|
|
1739
|
-
name: pulumi.Input[str]):
|
|
2362
|
+
key: pulumi.Input[_builtins.str],
|
|
2363
|
+
name: pulumi.Input[_builtins.str]):
|
|
1740
2364
|
"""
|
|
1741
|
-
:param pulumi.Input[str] key: The name of the field inside the secret.
|
|
1742
|
-
:param pulumi.Input[str] name: The name of the secret.
|
|
2365
|
+
:param pulumi.Input[_builtins.str] key: The name of the field inside the secret.
|
|
2366
|
+
:param pulumi.Input[_builtins.str] name: The name of the secret.
|
|
1743
2367
|
"""
|
|
1744
2368
|
pulumi.set(__self__, "key", key)
|
|
1745
2369
|
pulumi.set(__self__, "name", name)
|
|
1746
2370
|
|
|
1747
|
-
@property
|
|
2371
|
+
@_builtins.property
|
|
1748
2372
|
@pulumi.getter
|
|
1749
|
-
def key(self) -> pulumi.Input[str]:
|
|
2373
|
+
def key(self) -> pulumi.Input[_builtins.str]:
|
|
1750
2374
|
"""
|
|
1751
2375
|
The name of the field inside the secret.
|
|
1752
2376
|
"""
|
|
1753
2377
|
return pulumi.get(self, "key")
|
|
1754
2378
|
|
|
1755
2379
|
@key.setter
|
|
1756
|
-
def key(self, value: pulumi.Input[str]):
|
|
2380
|
+
def key(self, value: pulumi.Input[_builtins.str]):
|
|
1757
2381
|
pulumi.set(self, "key", value)
|
|
1758
2382
|
|
|
1759
|
-
@property
|
|
2383
|
+
@_builtins.property
|
|
1760
2384
|
@pulumi.getter
|
|
1761
|
-
def name(self) -> pulumi.Input[str]:
|
|
2385
|
+
def name(self) -> pulumi.Input[_builtins.str]:
|
|
1762
2386
|
"""
|
|
1763
2387
|
The name of the secret.
|
|
1764
2388
|
"""
|
|
1765
2389
|
return pulumi.get(self, "name")
|
|
1766
2390
|
|
|
1767
2391
|
@name.setter
|
|
1768
|
-
def name(self, value: pulumi.Input[str]):
|
|
2392
|
+
def name(self, value: pulumi.Input[_builtins.str]):
|
|
1769
2393
|
pulumi.set(self, "name", value)
|
|
1770
2394
|
|
|
1771
2395
|
|
|
2396
|
+
if not MYPY:
|
|
2397
|
+
class VerificationTemplateMetricArgsDict(TypedDict):
|
|
2398
|
+
metrics_name: pulumi.Input[_builtins.str]
|
|
2399
|
+
"""
|
|
2400
|
+
The name of the verification metric.
|
|
2401
|
+
"""
|
|
2402
|
+
providers: pulumi.Input[Sequence[pulumi.Input['VerificationTemplateMetricProviderArgsDict']]]
|
|
2403
|
+
"""
|
|
2404
|
+
The name of the monitoring tool chosen for the metric.
|
|
2405
|
+
"""
|
|
2406
|
+
baseline: NotRequired[pulumi.Input['VerificationTemplateMetricBaselineArgsDict']]
|
|
2407
|
+
"""
|
|
2408
|
+
Baseline Object.
|
|
2409
|
+
"""
|
|
2410
|
+
consecutive_error_limit: NotRequired[pulumi.Input[_builtins.int]]
|
|
2411
|
+
"""
|
|
2412
|
+
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
|
+
count: NotRequired[pulumi.Input[_builtins.int]]
|
|
2415
|
+
"""
|
|
2416
|
+
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
|
+
dry_run: NotRequired[pulumi.Input[_builtins.bool]]
|
|
2419
|
+
"""
|
|
2420
|
+
Defines whether the metric should have an impact on the result of the rollout.
|
|
2421
|
+
"""
|
|
2422
|
+
failure_condition: NotRequired[pulumi.Input[_builtins.str]]
|
|
2423
|
+
"""
|
|
2424
|
+
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
|
+
failure_limit: NotRequired[pulumi.Input[_builtins.int]]
|
|
2427
|
+
"""
|
|
2428
|
+
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
|
+
initial_delay: NotRequired[pulumi.Input[_builtins.str]]
|
|
2431
|
+
"""
|
|
2432
|
+
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
|
+
interval: NotRequired[pulumi.Input[_builtins.str]]
|
|
2435
|
+
"""
|
|
2436
|
+
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
|
+
success_condition: NotRequired[pulumi.Input[_builtins.str]]
|
|
2439
|
+
"""
|
|
2440
|
+
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
|
+
elif False:
|
|
2443
|
+
VerificationTemplateMetricArgsDict: TypeAlias = Mapping[str, Any]
|
|
2444
|
+
|
|
1772
2445
|
@pulumi.input_type
|
|
1773
2446
|
class VerificationTemplateMetricArgs:
|
|
1774
2447
|
def __init__(__self__, *,
|
|
1775
|
-
metrics_name: pulumi.Input[str],
|
|
2448
|
+
metrics_name: pulumi.Input[_builtins.str],
|
|
1776
2449
|
providers: pulumi.Input[Sequence[pulumi.Input['VerificationTemplateMetricProviderArgs']]],
|
|
1777
2450
|
baseline: Optional[pulumi.Input['VerificationTemplateMetricBaselineArgs']] = None,
|
|
1778
|
-
consecutive_error_limit: Optional[pulumi.Input[int]] = None,
|
|
1779
|
-
count: Optional[pulumi.Input[int]] = None,
|
|
1780
|
-
dry_run: Optional[pulumi.Input[bool]] = None,
|
|
1781
|
-
failure_condition: Optional[pulumi.Input[str]] = None,
|
|
1782
|
-
failure_limit: Optional[pulumi.Input[int]] = None,
|
|
1783
|
-
initial_delay: Optional[pulumi.Input[str]] = None,
|
|
1784
|
-
interval: Optional[pulumi.Input[str]] = None,
|
|
1785
|
-
success_condition: Optional[pulumi.Input[str]] = None):
|
|
1786
|
-
"""
|
|
1787
|
-
:param pulumi.Input[str] metrics_name: The name of the verification metric.
|
|
2451
|
+
consecutive_error_limit: Optional[pulumi.Input[_builtins.int]] = None,
|
|
2452
|
+
count: Optional[pulumi.Input[_builtins.int]] = None,
|
|
2453
|
+
dry_run: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
2454
|
+
failure_condition: Optional[pulumi.Input[_builtins.str]] = None,
|
|
2455
|
+
failure_limit: Optional[pulumi.Input[_builtins.int]] = None,
|
|
2456
|
+
initial_delay: Optional[pulumi.Input[_builtins.str]] = None,
|
|
2457
|
+
interval: Optional[pulumi.Input[_builtins.str]] = None,
|
|
2458
|
+
success_condition: Optional[pulumi.Input[_builtins.str]] = None):
|
|
2459
|
+
"""
|
|
2460
|
+
:param pulumi.Input[_builtins.str] metrics_name: The name of the verification metric.
|
|
1788
2461
|
:param pulumi.Input[Sequence[pulumi.Input['VerificationTemplateMetricProviderArgs']]] providers: The name of the monitoring tool chosen for the metric.
|
|
1789
2462
|
:param pulumi.Input['VerificationTemplateMetricBaselineArgs'] baseline: Baseline Object.
|
|
1790
|
-
: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.
|
|
1791
|
-
: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.
|
|
1792
|
-
:param pulumi.Input[bool] dry_run: Defines whether the metric should have an impact on the result of the rollout.
|
|
1793
|
-
: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.
|
|
1794
|
-
: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.
|
|
1795
|
-
: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.
|
|
1796
|
-
: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.
|
|
1797
|
-
: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.
|
|
2463
|
+
: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.
|
|
2464
|
+
: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.
|
|
2465
|
+
:param pulumi.Input[_builtins.bool] dry_run: Defines whether the metric should have an impact on the result of the rollout.
|
|
2466
|
+
: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.
|
|
2467
|
+
: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.
|
|
2468
|
+
: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.
|
|
2469
|
+
: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.
|
|
2470
|
+
: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.
|
|
1798
2471
|
"""
|
|
1799
2472
|
pulumi.set(__self__, "metrics_name", metrics_name)
|
|
1800
2473
|
pulumi.set(__self__, "providers", providers)
|
|
@@ -1817,19 +2490,19 @@ class VerificationTemplateMetricArgs:
|
|
|
1817
2490
|
if success_condition is not None:
|
|
1818
2491
|
pulumi.set(__self__, "success_condition", success_condition)
|
|
1819
2492
|
|
|
1820
|
-
@property
|
|
2493
|
+
@_builtins.property
|
|
1821
2494
|
@pulumi.getter(name="metricsName")
|
|
1822
|
-
def metrics_name(self) -> pulumi.Input[str]:
|
|
2495
|
+
def metrics_name(self) -> pulumi.Input[_builtins.str]:
|
|
1823
2496
|
"""
|
|
1824
2497
|
The name of the verification metric.
|
|
1825
2498
|
"""
|
|
1826
2499
|
return pulumi.get(self, "metrics_name")
|
|
1827
2500
|
|
|
1828
2501
|
@metrics_name.setter
|
|
1829
|
-
def metrics_name(self, value: pulumi.Input[str]):
|
|
2502
|
+
def metrics_name(self, value: pulumi.Input[_builtins.str]):
|
|
1830
2503
|
pulumi.set(self, "metrics_name", value)
|
|
1831
2504
|
|
|
1832
|
-
@property
|
|
2505
|
+
@_builtins.property
|
|
1833
2506
|
@pulumi.getter
|
|
1834
2507
|
def providers(self) -> pulumi.Input[Sequence[pulumi.Input['VerificationTemplateMetricProviderArgs']]]:
|
|
1835
2508
|
"""
|
|
@@ -1841,7 +2514,7 @@ class VerificationTemplateMetricArgs:
|
|
|
1841
2514
|
def providers(self, value: pulumi.Input[Sequence[pulumi.Input['VerificationTemplateMetricProviderArgs']]]):
|
|
1842
2515
|
pulumi.set(self, "providers", value)
|
|
1843
2516
|
|
|
1844
|
-
@property
|
|
2517
|
+
@_builtins.property
|
|
1845
2518
|
@pulumi.getter
|
|
1846
2519
|
def baseline(self) -> Optional[pulumi.Input['VerificationTemplateMetricBaselineArgs']]:
|
|
1847
2520
|
"""
|
|
@@ -1853,115 +2526,136 @@ class VerificationTemplateMetricArgs:
|
|
|
1853
2526
|
def baseline(self, value: Optional[pulumi.Input['VerificationTemplateMetricBaselineArgs']]):
|
|
1854
2527
|
pulumi.set(self, "baseline", value)
|
|
1855
2528
|
|
|
1856
|
-
@property
|
|
2529
|
+
@_builtins.property
|
|
1857
2530
|
@pulumi.getter(name="consecutiveErrorLimit")
|
|
1858
|
-
def consecutive_error_limit(self) -> Optional[pulumi.Input[int]]:
|
|
2531
|
+
def consecutive_error_limit(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
1859
2532
|
"""
|
|
1860
2533
|
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.
|
|
1861
2534
|
"""
|
|
1862
2535
|
return pulumi.get(self, "consecutive_error_limit")
|
|
1863
2536
|
|
|
1864
2537
|
@consecutive_error_limit.setter
|
|
1865
|
-
def consecutive_error_limit(self, value: Optional[pulumi.Input[int]]):
|
|
2538
|
+
def consecutive_error_limit(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
1866
2539
|
pulumi.set(self, "consecutive_error_limit", value)
|
|
1867
2540
|
|
|
1868
|
-
@property
|
|
2541
|
+
@_builtins.property
|
|
1869
2542
|
@pulumi.getter
|
|
1870
|
-
def count(self) -> Optional[pulumi.Input[int]]:
|
|
2543
|
+
def count(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
1871
2544
|
"""
|
|
1872
2545
|
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.
|
|
1873
2546
|
"""
|
|
1874
2547
|
return pulumi.get(self, "count")
|
|
1875
2548
|
|
|
1876
2549
|
@count.setter
|
|
1877
|
-
def count(self, value: Optional[pulumi.Input[int]]):
|
|
2550
|
+
def count(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
1878
2551
|
pulumi.set(self, "count", value)
|
|
1879
2552
|
|
|
1880
|
-
@property
|
|
2553
|
+
@_builtins.property
|
|
1881
2554
|
@pulumi.getter(name="dryRun")
|
|
1882
|
-
def dry_run(self) -> Optional[pulumi.Input[bool]]:
|
|
2555
|
+
def dry_run(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
1883
2556
|
"""
|
|
1884
2557
|
Defines whether the metric should have an impact on the result of the rollout.
|
|
1885
2558
|
"""
|
|
1886
2559
|
return pulumi.get(self, "dry_run")
|
|
1887
2560
|
|
|
1888
2561
|
@dry_run.setter
|
|
1889
|
-
def dry_run(self, value: Optional[pulumi.Input[bool]]):
|
|
2562
|
+
def dry_run(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
1890
2563
|
pulumi.set(self, "dry_run", value)
|
|
1891
2564
|
|
|
1892
|
-
@property
|
|
2565
|
+
@_builtins.property
|
|
1893
2566
|
@pulumi.getter(name="failureCondition")
|
|
1894
|
-
def failure_condition(self) -> Optional[pulumi.Input[str]]:
|
|
2567
|
+
def failure_condition(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
1895
2568
|
"""
|
|
1896
2569
|
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.
|
|
1897
2570
|
"""
|
|
1898
2571
|
return pulumi.get(self, "failure_condition")
|
|
1899
2572
|
|
|
1900
2573
|
@failure_condition.setter
|
|
1901
|
-
def failure_condition(self, value: Optional[pulumi.Input[str]]):
|
|
2574
|
+
def failure_condition(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
1902
2575
|
pulumi.set(self, "failure_condition", value)
|
|
1903
2576
|
|
|
1904
|
-
@property
|
|
2577
|
+
@_builtins.property
|
|
1905
2578
|
@pulumi.getter(name="failureLimit")
|
|
1906
|
-
def failure_limit(self) -> Optional[pulumi.Input[int]]:
|
|
2579
|
+
def failure_limit(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
1907
2580
|
"""
|
|
1908
2581
|
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.
|
|
1909
2582
|
"""
|
|
1910
2583
|
return pulumi.get(self, "failure_limit")
|
|
1911
2584
|
|
|
1912
2585
|
@failure_limit.setter
|
|
1913
|
-
def failure_limit(self, value: Optional[pulumi.Input[int]]):
|
|
2586
|
+
def failure_limit(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
1914
2587
|
pulumi.set(self, "failure_limit", value)
|
|
1915
2588
|
|
|
1916
|
-
@property
|
|
2589
|
+
@_builtins.property
|
|
1917
2590
|
@pulumi.getter(name="initialDelay")
|
|
1918
|
-
def initial_delay(self) -> Optional[pulumi.Input[str]]:
|
|
2591
|
+
def initial_delay(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
1919
2592
|
"""
|
|
1920
2593
|
How long to wait before starting this metric measurements. When choosing Jenkins as the provider, there is no need to send this variable.
|
|
1921
2594
|
"""
|
|
1922
2595
|
return pulumi.get(self, "initial_delay")
|
|
1923
2596
|
|
|
1924
2597
|
@initial_delay.setter
|
|
1925
|
-
def initial_delay(self, value: Optional[pulumi.Input[str]]):
|
|
2598
|
+
def initial_delay(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
1926
2599
|
pulumi.set(self, "initial_delay", value)
|
|
1927
2600
|
|
|
1928
|
-
@property
|
|
2601
|
+
@_builtins.property
|
|
1929
2602
|
@pulumi.getter
|
|
1930
|
-
def interval(self) -> Optional[pulumi.Input[str]]:
|
|
2603
|
+
def interval(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
1931
2604
|
"""
|
|
1932
2605
|
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.
|
|
1933
2606
|
"""
|
|
1934
2607
|
return pulumi.get(self, "interval")
|
|
1935
2608
|
|
|
1936
2609
|
@interval.setter
|
|
1937
|
-
def interval(self, value: Optional[pulumi.Input[str]]):
|
|
2610
|
+
def interval(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
1938
2611
|
pulumi.set(self, "interval", value)
|
|
1939
2612
|
|
|
1940
|
-
@property
|
|
2613
|
+
@_builtins.property
|
|
1941
2614
|
@pulumi.getter(name="successCondition")
|
|
1942
|
-
def success_condition(self) -> Optional[pulumi.Input[str]]:
|
|
2615
|
+
def success_condition(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
1943
2616
|
"""
|
|
1944
2617
|
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.
|
|
1945
2618
|
"""
|
|
1946
2619
|
return pulumi.get(self, "success_condition")
|
|
1947
2620
|
|
|
1948
2621
|
@success_condition.setter
|
|
1949
|
-
def success_condition(self, value: Optional[pulumi.Input[str]]):
|
|
2622
|
+
def success_condition(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
1950
2623
|
pulumi.set(self, "success_condition", value)
|
|
1951
2624
|
|
|
1952
2625
|
|
|
2626
|
+
if not MYPY:
|
|
2627
|
+
class VerificationTemplateMetricBaselineArgsDict(TypedDict):
|
|
2628
|
+
baseline_providers: pulumi.Input[Sequence[pulumi.Input['VerificationTemplateMetricBaselineBaselineProviderArgsDict']]]
|
|
2629
|
+
"""
|
|
2630
|
+
The name of the monitoring tool chosen for the metric.
|
|
2631
|
+
"""
|
|
2632
|
+
threshold: pulumi.Input[_builtins.str]
|
|
2633
|
+
"""
|
|
2634
|
+
A mathematical expression needed for the comparison. Enum: "<" ">" "<=" ">=" "=" "range"
|
|
2635
|
+
"""
|
|
2636
|
+
max_range: NotRequired[pulumi.Input[_builtins.int]]
|
|
2637
|
+
"""
|
|
2638
|
+
Number in percent we allow the new version’s data result to be under baseline data result.
|
|
2639
|
+
"""
|
|
2640
|
+
min_range: NotRequired[pulumi.Input[_builtins.int]]
|
|
2641
|
+
"""
|
|
2642
|
+
Number in percent we allow the new version’s data result to be under baseline data result.*
|
|
2643
|
+
"""
|
|
2644
|
+
elif False:
|
|
2645
|
+
VerificationTemplateMetricBaselineArgsDict: TypeAlias = Mapping[str, Any]
|
|
2646
|
+
|
|
1953
2647
|
@pulumi.input_type
|
|
1954
2648
|
class VerificationTemplateMetricBaselineArgs:
|
|
1955
2649
|
def __init__(__self__, *,
|
|
1956
2650
|
baseline_providers: pulumi.Input[Sequence[pulumi.Input['VerificationTemplateMetricBaselineBaselineProviderArgs']]],
|
|
1957
|
-
threshold: pulumi.Input[str],
|
|
1958
|
-
max_range: Optional[pulumi.Input[int]] = None,
|
|
1959
|
-
min_range: Optional[pulumi.Input[int]] = None):
|
|
2651
|
+
threshold: pulumi.Input[_builtins.str],
|
|
2652
|
+
max_range: Optional[pulumi.Input[_builtins.int]] = None,
|
|
2653
|
+
min_range: Optional[pulumi.Input[_builtins.int]] = None):
|
|
1960
2654
|
"""
|
|
1961
2655
|
:param pulumi.Input[Sequence[pulumi.Input['VerificationTemplateMetricBaselineBaselineProviderArgs']]] baseline_providers: The name of the monitoring tool chosen for the metric.
|
|
1962
|
-
:param pulumi.Input[str] threshold: A mathematical expression needed for the comparison. Enum: "<" ">" "<=" ">=" "=" "range"
|
|
1963
|
-
:param pulumi.Input[int] max_range: Number in percent we allow the new version’s data result to be under baseline data result.
|
|
1964
|
-
:param pulumi.Input[int] min_range: Number in percent we allow the new version’s data result to be under baseline data result.*
|
|
2656
|
+
:param pulumi.Input[_builtins.str] threshold: A mathematical expression needed for the comparison. Enum: "<" ">" "<=" ">=" "=" "range"
|
|
2657
|
+
:param pulumi.Input[_builtins.int] max_range: Number in percent we allow the new version’s data result to be under baseline data result.
|
|
2658
|
+
:param pulumi.Input[_builtins.int] min_range: Number in percent we allow the new version’s data result to be under baseline data result.*
|
|
1965
2659
|
"""
|
|
1966
2660
|
pulumi.set(__self__, "baseline_providers", baseline_providers)
|
|
1967
2661
|
pulumi.set(__self__, "threshold", threshold)
|
|
@@ -1970,7 +2664,7 @@ class VerificationTemplateMetricBaselineArgs:
|
|
|
1970
2664
|
if min_range is not None:
|
|
1971
2665
|
pulumi.set(__self__, "min_range", min_range)
|
|
1972
2666
|
|
|
1973
|
-
@property
|
|
2667
|
+
@_builtins.property
|
|
1974
2668
|
@pulumi.getter(name="baselineProviders")
|
|
1975
2669
|
def baseline_providers(self) -> pulumi.Input[Sequence[pulumi.Input['VerificationTemplateMetricBaselineBaselineProviderArgs']]]:
|
|
1976
2670
|
"""
|
|
@@ -1982,43 +2676,60 @@ class VerificationTemplateMetricBaselineArgs:
|
|
|
1982
2676
|
def baseline_providers(self, value: pulumi.Input[Sequence[pulumi.Input['VerificationTemplateMetricBaselineBaselineProviderArgs']]]):
|
|
1983
2677
|
pulumi.set(self, "baseline_providers", value)
|
|
1984
2678
|
|
|
1985
|
-
@property
|
|
2679
|
+
@_builtins.property
|
|
1986
2680
|
@pulumi.getter
|
|
1987
|
-
def threshold(self) -> pulumi.Input[str]:
|
|
2681
|
+
def threshold(self) -> pulumi.Input[_builtins.str]:
|
|
1988
2682
|
"""
|
|
1989
2683
|
A mathematical expression needed for the comparison. Enum: "<" ">" "<=" ">=" "=" "range"
|
|
1990
2684
|
"""
|
|
1991
2685
|
return pulumi.get(self, "threshold")
|
|
1992
2686
|
|
|
1993
2687
|
@threshold.setter
|
|
1994
|
-
def threshold(self, value: pulumi.Input[str]):
|
|
2688
|
+
def threshold(self, value: pulumi.Input[_builtins.str]):
|
|
1995
2689
|
pulumi.set(self, "threshold", value)
|
|
1996
2690
|
|
|
1997
|
-
@property
|
|
2691
|
+
@_builtins.property
|
|
1998
2692
|
@pulumi.getter(name="maxRange")
|
|
1999
|
-
def max_range(self) -> Optional[pulumi.Input[int]]:
|
|
2693
|
+
def max_range(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
2000
2694
|
"""
|
|
2001
2695
|
Number in percent we allow the new version’s data result to be under baseline data result.
|
|
2002
2696
|
"""
|
|
2003
2697
|
return pulumi.get(self, "max_range")
|
|
2004
2698
|
|
|
2005
2699
|
@max_range.setter
|
|
2006
|
-
def max_range(self, value: Optional[pulumi.Input[int]]):
|
|
2700
|
+
def max_range(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
2007
2701
|
pulumi.set(self, "max_range", value)
|
|
2008
2702
|
|
|
2009
|
-
@property
|
|
2703
|
+
@_builtins.property
|
|
2010
2704
|
@pulumi.getter(name="minRange")
|
|
2011
|
-
def min_range(self) -> Optional[pulumi.Input[int]]:
|
|
2705
|
+
def min_range(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
2012
2706
|
"""
|
|
2013
2707
|
Number in percent we allow the new version’s data result to be under baseline data result.*
|
|
2014
2708
|
"""
|
|
2015
2709
|
return pulumi.get(self, "min_range")
|
|
2016
2710
|
|
|
2017
2711
|
@min_range.setter
|
|
2018
|
-
def min_range(self, value: Optional[pulumi.Input[int]]):
|
|
2712
|
+
def min_range(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
2019
2713
|
pulumi.set(self, "min_range", value)
|
|
2020
2714
|
|
|
2021
2715
|
|
|
2716
|
+
if not MYPY:
|
|
2717
|
+
class VerificationTemplateMetricBaselineBaselineProviderArgsDict(TypedDict):
|
|
2718
|
+
datadog: NotRequired[pulumi.Input['VerificationTemplateMetricBaselineBaselineProviderDatadogArgsDict']]
|
|
2719
|
+
"""
|
|
2720
|
+
The datadog provider.
|
|
2721
|
+
"""
|
|
2722
|
+
new_relic: NotRequired[pulumi.Input['VerificationTemplateMetricBaselineBaselineProviderNewRelicArgsDict']]
|
|
2723
|
+
"""
|
|
2724
|
+
The New Relic provider.
|
|
2725
|
+
"""
|
|
2726
|
+
prometheus: NotRequired[pulumi.Input['VerificationTemplateMetricBaselineBaselineProviderPrometheusArgsDict']]
|
|
2727
|
+
"""
|
|
2728
|
+
The Prometheus provider.
|
|
2729
|
+
"""
|
|
2730
|
+
elif False:
|
|
2731
|
+
VerificationTemplateMetricBaselineBaselineProviderArgsDict: TypeAlias = Mapping[str, Any]
|
|
2732
|
+
|
|
2022
2733
|
@pulumi.input_type
|
|
2023
2734
|
class VerificationTemplateMetricBaselineBaselineProviderArgs:
|
|
2024
2735
|
def __init__(__self__, *,
|
|
@@ -2037,7 +2748,7 @@ class VerificationTemplateMetricBaselineBaselineProviderArgs:
|
|
|
2037
2748
|
if prometheus is not None:
|
|
2038
2749
|
pulumi.set(__self__, "prometheus", prometheus)
|
|
2039
2750
|
|
|
2040
|
-
@property
|
|
2751
|
+
@_builtins.property
|
|
2041
2752
|
@pulumi.getter
|
|
2042
2753
|
def datadog(self) -> Optional[pulumi.Input['VerificationTemplateMetricBaselineBaselineProviderDatadogArgs']]:
|
|
2043
2754
|
"""
|
|
@@ -2049,7 +2760,7 @@ class VerificationTemplateMetricBaselineBaselineProviderArgs:
|
|
|
2049
2760
|
def datadog(self, value: Optional[pulumi.Input['VerificationTemplateMetricBaselineBaselineProviderDatadogArgs']]):
|
|
2050
2761
|
pulumi.set(self, "datadog", value)
|
|
2051
2762
|
|
|
2052
|
-
@property
|
|
2763
|
+
@_builtins.property
|
|
2053
2764
|
@pulumi.getter(name="newRelic")
|
|
2054
2765
|
def new_relic(self) -> Optional[pulumi.Input['VerificationTemplateMetricBaselineBaselineProviderNewRelicArgs']]:
|
|
2055
2766
|
"""
|
|
@@ -2061,7 +2772,7 @@ class VerificationTemplateMetricBaselineBaselineProviderArgs:
|
|
|
2061
2772
|
def new_relic(self, value: Optional[pulumi.Input['VerificationTemplateMetricBaselineBaselineProviderNewRelicArgs']]):
|
|
2062
2773
|
pulumi.set(self, "new_relic", value)
|
|
2063
2774
|
|
|
2064
|
-
@property
|
|
2775
|
+
@_builtins.property
|
|
2065
2776
|
@pulumi.getter
|
|
2066
2777
|
def prometheus(self) -> Optional[pulumi.Input['VerificationTemplateMetricBaselineBaselineProviderPrometheusArgs']]:
|
|
2067
2778
|
"""
|
|
@@ -2074,104 +2785,172 @@ class VerificationTemplateMetricBaselineBaselineProviderArgs:
|
|
|
2074
2785
|
pulumi.set(self, "prometheus", value)
|
|
2075
2786
|
|
|
2076
2787
|
|
|
2788
|
+
if not MYPY:
|
|
2789
|
+
class VerificationTemplateMetricBaselineBaselineProviderDatadogArgsDict(TypedDict):
|
|
2790
|
+
datadog_query: pulumi.Input[_builtins.str]
|
|
2791
|
+
"""
|
|
2792
|
+
A request for information retrieved from Datadog.
|
|
2793
|
+
"""
|
|
2794
|
+
duration: NotRequired[pulumi.Input[_builtins.str]]
|
|
2795
|
+
"""
|
|
2796
|
+
The window of time we are looking at in DataDog.
|
|
2797
|
+
"""
|
|
2798
|
+
elif False:
|
|
2799
|
+
VerificationTemplateMetricBaselineBaselineProviderDatadogArgsDict: TypeAlias = Mapping[str, Any]
|
|
2800
|
+
|
|
2077
2801
|
@pulumi.input_type
|
|
2078
2802
|
class VerificationTemplateMetricBaselineBaselineProviderDatadogArgs:
|
|
2079
2803
|
def __init__(__self__, *,
|
|
2080
|
-
datadog_query: pulumi.Input[str],
|
|
2081
|
-
duration: Optional[pulumi.Input[str]] = None):
|
|
2804
|
+
datadog_query: pulumi.Input[_builtins.str],
|
|
2805
|
+
duration: Optional[pulumi.Input[_builtins.str]] = None):
|
|
2082
2806
|
"""
|
|
2083
|
-
:param pulumi.Input[str] datadog_query: A request for information retrieved from Datadog.
|
|
2084
|
-
:param pulumi.Input[str] duration: The window of time we are looking at in DataDog.
|
|
2807
|
+
:param pulumi.Input[_builtins.str] datadog_query: A request for information retrieved from Datadog.
|
|
2808
|
+
:param pulumi.Input[_builtins.str] duration: The window of time we are looking at in DataDog.
|
|
2085
2809
|
"""
|
|
2086
2810
|
pulumi.set(__self__, "datadog_query", datadog_query)
|
|
2087
2811
|
if duration is not None:
|
|
2088
2812
|
pulumi.set(__self__, "duration", duration)
|
|
2089
2813
|
|
|
2090
|
-
@property
|
|
2814
|
+
@_builtins.property
|
|
2091
2815
|
@pulumi.getter(name="datadogQuery")
|
|
2092
|
-
def datadog_query(self) -> pulumi.Input[str]:
|
|
2816
|
+
def datadog_query(self) -> pulumi.Input[_builtins.str]:
|
|
2093
2817
|
"""
|
|
2094
2818
|
A request for information retrieved from Datadog.
|
|
2095
2819
|
"""
|
|
2096
2820
|
return pulumi.get(self, "datadog_query")
|
|
2097
2821
|
|
|
2098
2822
|
@datadog_query.setter
|
|
2099
|
-
def datadog_query(self, value: pulumi.Input[str]):
|
|
2823
|
+
def datadog_query(self, value: pulumi.Input[_builtins.str]):
|
|
2100
2824
|
pulumi.set(self, "datadog_query", value)
|
|
2101
2825
|
|
|
2102
|
-
@property
|
|
2826
|
+
@_builtins.property
|
|
2103
2827
|
@pulumi.getter
|
|
2104
|
-
def duration(self) -> Optional[pulumi.Input[str]]:
|
|
2828
|
+
def duration(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
2105
2829
|
"""
|
|
2106
2830
|
The window of time we are looking at in DataDog.
|
|
2107
2831
|
"""
|
|
2108
2832
|
return pulumi.get(self, "duration")
|
|
2109
2833
|
|
|
2110
2834
|
@duration.setter
|
|
2111
|
-
def duration(self, value: Optional[pulumi.Input[str]]):
|
|
2835
|
+
def duration(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
2112
2836
|
pulumi.set(self, "duration", value)
|
|
2113
2837
|
|
|
2114
2838
|
|
|
2839
|
+
if not MYPY:
|
|
2840
|
+
class VerificationTemplateMetricBaselineBaselineProviderNewRelicArgsDict(TypedDict):
|
|
2841
|
+
new_relic_query: pulumi.Input[_builtins.str]
|
|
2842
|
+
"""
|
|
2843
|
+
A raw newrelic NRQL query to perform.
|
|
2844
|
+
"""
|
|
2845
|
+
profile: NotRequired[pulumi.Input[_builtins.str]]
|
|
2846
|
+
"""
|
|
2847
|
+
The name of the secret holding NR account configuration.
|
|
2848
|
+
"""
|
|
2849
|
+
elif False:
|
|
2850
|
+
VerificationTemplateMetricBaselineBaselineProviderNewRelicArgsDict: TypeAlias = Mapping[str, Any]
|
|
2851
|
+
|
|
2115
2852
|
@pulumi.input_type
|
|
2116
2853
|
class VerificationTemplateMetricBaselineBaselineProviderNewRelicArgs:
|
|
2117
2854
|
def __init__(__self__, *,
|
|
2118
|
-
new_relic_query: pulumi.Input[str],
|
|
2119
|
-
profile: Optional[pulumi.Input[str]] = None):
|
|
2855
|
+
new_relic_query: pulumi.Input[_builtins.str],
|
|
2856
|
+
profile: Optional[pulumi.Input[_builtins.str]] = None):
|
|
2120
2857
|
"""
|
|
2121
|
-
:param pulumi.Input[str] new_relic_query: A raw newrelic NRQL query to perform.
|
|
2122
|
-
:param pulumi.Input[str] profile: The name of the secret holding NR account configuration.
|
|
2858
|
+
:param pulumi.Input[_builtins.str] new_relic_query: A raw newrelic NRQL query to perform.
|
|
2859
|
+
:param pulumi.Input[_builtins.str] profile: The name of the secret holding NR account configuration.
|
|
2123
2860
|
"""
|
|
2124
2861
|
pulumi.set(__self__, "new_relic_query", new_relic_query)
|
|
2125
2862
|
if profile is not None:
|
|
2126
2863
|
pulumi.set(__self__, "profile", profile)
|
|
2127
2864
|
|
|
2128
|
-
@property
|
|
2865
|
+
@_builtins.property
|
|
2129
2866
|
@pulumi.getter(name="newRelicQuery")
|
|
2130
|
-
def new_relic_query(self) -> pulumi.Input[str]:
|
|
2867
|
+
def new_relic_query(self) -> pulumi.Input[_builtins.str]:
|
|
2131
2868
|
"""
|
|
2132
2869
|
A raw newrelic NRQL query to perform.
|
|
2133
2870
|
"""
|
|
2134
2871
|
return pulumi.get(self, "new_relic_query")
|
|
2135
2872
|
|
|
2136
2873
|
@new_relic_query.setter
|
|
2137
|
-
def new_relic_query(self, value: pulumi.Input[str]):
|
|
2874
|
+
def new_relic_query(self, value: pulumi.Input[_builtins.str]):
|
|
2138
2875
|
pulumi.set(self, "new_relic_query", value)
|
|
2139
2876
|
|
|
2140
|
-
@property
|
|
2877
|
+
@_builtins.property
|
|
2141
2878
|
@pulumi.getter
|
|
2142
|
-
def profile(self) -> Optional[pulumi.Input[str]]:
|
|
2879
|
+
def profile(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
2143
2880
|
"""
|
|
2144
2881
|
The name of the secret holding NR account configuration.
|
|
2145
2882
|
"""
|
|
2146
2883
|
return pulumi.get(self, "profile")
|
|
2147
2884
|
|
|
2148
2885
|
@profile.setter
|
|
2149
|
-
def profile(self, value: Optional[pulumi.Input[str]]):
|
|
2886
|
+
def profile(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
2150
2887
|
pulumi.set(self, "profile", value)
|
|
2151
2888
|
|
|
2152
2889
|
|
|
2890
|
+
if not MYPY:
|
|
2891
|
+
class VerificationTemplateMetricBaselineBaselineProviderPrometheusArgsDict(TypedDict):
|
|
2892
|
+
prometheus_query: pulumi.Input[_builtins.str]
|
|
2893
|
+
"""
|
|
2894
|
+
A request for information retrieved from Prometheus.
|
|
2895
|
+
"""
|
|
2896
|
+
elif False:
|
|
2897
|
+
VerificationTemplateMetricBaselineBaselineProviderPrometheusArgsDict: TypeAlias = Mapping[str, Any]
|
|
2898
|
+
|
|
2153
2899
|
@pulumi.input_type
|
|
2154
2900
|
class VerificationTemplateMetricBaselineBaselineProviderPrometheusArgs:
|
|
2155
2901
|
def __init__(__self__, *,
|
|
2156
|
-
prometheus_query: pulumi.Input[str]):
|
|
2902
|
+
prometheus_query: pulumi.Input[_builtins.str]):
|
|
2157
2903
|
"""
|
|
2158
|
-
:param pulumi.Input[str] prometheus_query: A request for information retrieved from Prometheus.
|
|
2904
|
+
:param pulumi.Input[_builtins.str] prometheus_query: A request for information retrieved from Prometheus.
|
|
2159
2905
|
"""
|
|
2160
2906
|
pulumi.set(__self__, "prometheus_query", prometheus_query)
|
|
2161
2907
|
|
|
2162
|
-
@property
|
|
2908
|
+
@_builtins.property
|
|
2163
2909
|
@pulumi.getter(name="prometheusQuery")
|
|
2164
|
-
def prometheus_query(self) -> pulumi.Input[str]:
|
|
2910
|
+
def prometheus_query(self) -> pulumi.Input[_builtins.str]:
|
|
2165
2911
|
"""
|
|
2166
2912
|
A request for information retrieved from Prometheus.
|
|
2167
2913
|
"""
|
|
2168
2914
|
return pulumi.get(self, "prometheus_query")
|
|
2169
2915
|
|
|
2170
2916
|
@prometheus_query.setter
|
|
2171
|
-
def prometheus_query(self, value: pulumi.Input[str]):
|
|
2917
|
+
def prometheus_query(self, value: pulumi.Input[_builtins.str]):
|
|
2172
2918
|
pulumi.set(self, "prometheus_query", value)
|
|
2173
2919
|
|
|
2174
2920
|
|
|
2921
|
+
if not MYPY:
|
|
2922
|
+
class VerificationTemplateMetricProviderArgsDict(TypedDict):
|
|
2923
|
+
cloud_watch: NotRequired[pulumi.Input['VerificationTemplateMetricProviderCloudWatchArgsDict']]
|
|
2924
|
+
"""
|
|
2925
|
+
The CloudWatch provider.
|
|
2926
|
+
"""
|
|
2927
|
+
datadog: NotRequired[pulumi.Input['VerificationTemplateMetricProviderDatadogArgsDict']]
|
|
2928
|
+
"""
|
|
2929
|
+
The datadog provider.
|
|
2930
|
+
"""
|
|
2931
|
+
jenkins: NotRequired[pulumi.Input['VerificationTemplateMetricProviderJenkinsArgsDict']]
|
|
2932
|
+
"""
|
|
2933
|
+
The Jenkins provider. Default is "{$}"
|
|
2934
|
+
"""
|
|
2935
|
+
job: NotRequired[pulumi.Input['VerificationTemplateMetricProviderJobArgsDict']]
|
|
2936
|
+
"""
|
|
2937
|
+
The Job provider.
|
|
2938
|
+
"""
|
|
2939
|
+
new_relic: NotRequired[pulumi.Input['VerificationTemplateMetricProviderNewRelicArgsDict']]
|
|
2940
|
+
"""
|
|
2941
|
+
The New Relic provider.
|
|
2942
|
+
"""
|
|
2943
|
+
prometheus: NotRequired[pulumi.Input['VerificationTemplateMetricProviderPrometheusArgsDict']]
|
|
2944
|
+
"""
|
|
2945
|
+
The Prometheus provider.
|
|
2946
|
+
"""
|
|
2947
|
+
web: NotRequired[pulumi.Input['VerificationTemplateMetricProviderWebArgsDict']]
|
|
2948
|
+
"""
|
|
2949
|
+
The Web provider.
|
|
2950
|
+
"""
|
|
2951
|
+
elif False:
|
|
2952
|
+
VerificationTemplateMetricProviderArgsDict: TypeAlias = Mapping[str, Any]
|
|
2953
|
+
|
|
2175
2954
|
@pulumi.input_type
|
|
2176
2955
|
class VerificationTemplateMetricProviderArgs:
|
|
2177
2956
|
def __init__(__self__, *,
|
|
@@ -2206,7 +2985,7 @@ class VerificationTemplateMetricProviderArgs:
|
|
|
2206
2985
|
if web is not None:
|
|
2207
2986
|
pulumi.set(__self__, "web", web)
|
|
2208
2987
|
|
|
2209
|
-
@property
|
|
2988
|
+
@_builtins.property
|
|
2210
2989
|
@pulumi.getter(name="cloudWatch")
|
|
2211
2990
|
def cloud_watch(self) -> Optional[pulumi.Input['VerificationTemplateMetricProviderCloudWatchArgs']]:
|
|
2212
2991
|
"""
|
|
@@ -2218,7 +2997,7 @@ class VerificationTemplateMetricProviderArgs:
|
|
|
2218
2997
|
def cloud_watch(self, value: Optional[pulumi.Input['VerificationTemplateMetricProviderCloudWatchArgs']]):
|
|
2219
2998
|
pulumi.set(self, "cloud_watch", value)
|
|
2220
2999
|
|
|
2221
|
-
@property
|
|
3000
|
+
@_builtins.property
|
|
2222
3001
|
@pulumi.getter
|
|
2223
3002
|
def datadog(self) -> Optional[pulumi.Input['VerificationTemplateMetricProviderDatadogArgs']]:
|
|
2224
3003
|
"""
|
|
@@ -2230,7 +3009,7 @@ class VerificationTemplateMetricProviderArgs:
|
|
|
2230
3009
|
def datadog(self, value: Optional[pulumi.Input['VerificationTemplateMetricProviderDatadogArgs']]):
|
|
2231
3010
|
pulumi.set(self, "datadog", value)
|
|
2232
3011
|
|
|
2233
|
-
@property
|
|
3012
|
+
@_builtins.property
|
|
2234
3013
|
@pulumi.getter
|
|
2235
3014
|
def jenkins(self) -> Optional[pulumi.Input['VerificationTemplateMetricProviderJenkinsArgs']]:
|
|
2236
3015
|
"""
|
|
@@ -2242,7 +3021,7 @@ class VerificationTemplateMetricProviderArgs:
|
|
|
2242
3021
|
def jenkins(self, value: Optional[pulumi.Input['VerificationTemplateMetricProviderJenkinsArgs']]):
|
|
2243
3022
|
pulumi.set(self, "jenkins", value)
|
|
2244
3023
|
|
|
2245
|
-
@property
|
|
3024
|
+
@_builtins.property
|
|
2246
3025
|
@pulumi.getter
|
|
2247
3026
|
def job(self) -> Optional[pulumi.Input['VerificationTemplateMetricProviderJobArgs']]:
|
|
2248
3027
|
"""
|
|
@@ -2254,7 +3033,7 @@ class VerificationTemplateMetricProviderArgs:
|
|
|
2254
3033
|
def job(self, value: Optional[pulumi.Input['VerificationTemplateMetricProviderJobArgs']]):
|
|
2255
3034
|
pulumi.set(self, "job", value)
|
|
2256
3035
|
|
|
2257
|
-
@property
|
|
3036
|
+
@_builtins.property
|
|
2258
3037
|
@pulumi.getter(name="newRelic")
|
|
2259
3038
|
def new_relic(self) -> Optional[pulumi.Input['VerificationTemplateMetricProviderNewRelicArgs']]:
|
|
2260
3039
|
"""
|
|
@@ -2266,7 +3045,7 @@ class VerificationTemplateMetricProviderArgs:
|
|
|
2266
3045
|
def new_relic(self, value: Optional[pulumi.Input['VerificationTemplateMetricProviderNewRelicArgs']]):
|
|
2267
3046
|
pulumi.set(self, "new_relic", value)
|
|
2268
3047
|
|
|
2269
|
-
@property
|
|
3048
|
+
@_builtins.property
|
|
2270
3049
|
@pulumi.getter
|
|
2271
3050
|
def prometheus(self) -> Optional[pulumi.Input['VerificationTemplateMetricProviderPrometheusArgs']]:
|
|
2272
3051
|
"""
|
|
@@ -2278,7 +3057,7 @@ class VerificationTemplateMetricProviderArgs:
|
|
|
2278
3057
|
def prometheus(self, value: Optional[pulumi.Input['VerificationTemplateMetricProviderPrometheusArgs']]):
|
|
2279
3058
|
pulumi.set(self, "prometheus", value)
|
|
2280
3059
|
|
|
2281
|
-
@property
|
|
3060
|
+
@_builtins.property
|
|
2282
3061
|
@pulumi.getter
|
|
2283
3062
|
def web(self) -> Optional[pulumi.Input['VerificationTemplateMetricProviderWebArgs']]:
|
|
2284
3063
|
"""
|
|
@@ -2291,20 +3070,33 @@ class VerificationTemplateMetricProviderArgs:
|
|
|
2291
3070
|
pulumi.set(self, "web", value)
|
|
2292
3071
|
|
|
2293
3072
|
|
|
3073
|
+
if not MYPY:
|
|
3074
|
+
class VerificationTemplateMetricProviderCloudWatchArgsDict(TypedDict):
|
|
3075
|
+
metric_data_queries: pulumi.Input[Sequence[pulumi.Input['VerificationTemplateMetricProviderCloudWatchMetricDataQueryArgsDict']]]
|
|
3076
|
+
"""
|
|
3077
|
+
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
|
+
duration: NotRequired[pulumi.Input[_builtins.str]]
|
|
3080
|
+
"""
|
|
3081
|
+
The window of time we are looking at in CloudWatch.
|
|
3082
|
+
"""
|
|
3083
|
+
elif False:
|
|
3084
|
+
VerificationTemplateMetricProviderCloudWatchArgsDict: TypeAlias = Mapping[str, Any]
|
|
3085
|
+
|
|
2294
3086
|
@pulumi.input_type
|
|
2295
3087
|
class VerificationTemplateMetricProviderCloudWatchArgs:
|
|
2296
3088
|
def __init__(__self__, *,
|
|
2297
3089
|
metric_data_queries: pulumi.Input[Sequence[pulumi.Input['VerificationTemplateMetricProviderCloudWatchMetricDataQueryArgs']]],
|
|
2298
|
-
duration: Optional[pulumi.Input[str]] = None):
|
|
3090
|
+
duration: Optional[pulumi.Input[_builtins.str]] = None):
|
|
2299
3091
|
"""
|
|
2300
3092
|
: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.
|
|
2301
|
-
:param pulumi.Input[str] duration: The window of time we are looking at in CloudWatch.
|
|
3093
|
+
:param pulumi.Input[_builtins.str] duration: The window of time we are looking at in CloudWatch.
|
|
2302
3094
|
"""
|
|
2303
3095
|
pulumi.set(__self__, "metric_data_queries", metric_data_queries)
|
|
2304
3096
|
if duration is not None:
|
|
2305
3097
|
pulumi.set(__self__, "duration", duration)
|
|
2306
3098
|
|
|
2307
|
-
@property
|
|
3099
|
+
@_builtins.property
|
|
2308
3100
|
@pulumi.getter(name="metricDataQueries")
|
|
2309
3101
|
def metric_data_queries(self) -> pulumi.Input[Sequence[pulumi.Input['VerificationTemplateMetricProviderCloudWatchMetricDataQueryArgs']]]:
|
|
2310
3102
|
"""
|
|
@@ -2316,35 +3108,64 @@ class VerificationTemplateMetricProviderCloudWatchArgs:
|
|
|
2316
3108
|
def metric_data_queries(self, value: pulumi.Input[Sequence[pulumi.Input['VerificationTemplateMetricProviderCloudWatchMetricDataQueryArgs']]]):
|
|
2317
3109
|
pulumi.set(self, "metric_data_queries", value)
|
|
2318
3110
|
|
|
2319
|
-
@property
|
|
3111
|
+
@_builtins.property
|
|
2320
3112
|
@pulumi.getter
|
|
2321
|
-
def duration(self) -> Optional[pulumi.Input[str]]:
|
|
3113
|
+
def duration(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
2322
3114
|
"""
|
|
2323
3115
|
The window of time we are looking at in CloudWatch.
|
|
2324
3116
|
"""
|
|
2325
3117
|
return pulumi.get(self, "duration")
|
|
2326
3118
|
|
|
2327
3119
|
@duration.setter
|
|
2328
|
-
def duration(self, value: Optional[pulumi.Input[str]]):
|
|
3120
|
+
def duration(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
2329
3121
|
pulumi.set(self, "duration", value)
|
|
2330
3122
|
|
|
2331
3123
|
|
|
3124
|
+
if not MYPY:
|
|
3125
|
+
class VerificationTemplateMetricProviderCloudWatchMetricDataQueryArgsDict(TypedDict):
|
|
3126
|
+
id: pulumi.Input[_builtins.str]
|
|
3127
|
+
"""
|
|
3128
|
+
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
|
+
expression: NotRequired[pulumi.Input[_builtins.str]]
|
|
3131
|
+
"""
|
|
3132
|
+
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
|
+
label: NotRequired[pulumi.Input[_builtins.str]]
|
|
3135
|
+
"""
|
|
3136
|
+
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
|
+
metric_stat: NotRequired[pulumi.Input['VerificationTemplateMetricProviderCloudWatchMetricDataQueryMetricStatArgsDict']]
|
|
3139
|
+
"""
|
|
3140
|
+
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
|
+
period: NotRequired[pulumi.Input[_builtins.int]]
|
|
3143
|
+
"""
|
|
3144
|
+
The granularity, in seconds, of the returned data points.
|
|
3145
|
+
"""
|
|
3146
|
+
return_data: NotRequired[pulumi.Input[_builtins.bool]]
|
|
3147
|
+
"""
|
|
3148
|
+
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
|
+
elif False:
|
|
3151
|
+
VerificationTemplateMetricProviderCloudWatchMetricDataQueryArgsDict: TypeAlias = Mapping[str, Any]
|
|
3152
|
+
|
|
2332
3153
|
@pulumi.input_type
|
|
2333
3154
|
class VerificationTemplateMetricProviderCloudWatchMetricDataQueryArgs:
|
|
2334
3155
|
def __init__(__self__, *,
|
|
2335
|
-
id: pulumi.Input[str],
|
|
2336
|
-
expression: Optional[pulumi.Input[str]] = None,
|
|
2337
|
-
label: Optional[pulumi.Input[str]] = None,
|
|
3156
|
+
id: pulumi.Input[_builtins.str],
|
|
3157
|
+
expression: Optional[pulumi.Input[_builtins.str]] = None,
|
|
3158
|
+
label: Optional[pulumi.Input[_builtins.str]] = None,
|
|
2338
3159
|
metric_stat: Optional[pulumi.Input['VerificationTemplateMetricProviderCloudWatchMetricDataQueryMetricStatArgs']] = None,
|
|
2339
|
-
period: Optional[pulumi.Input[int]] = None,
|
|
2340
|
-
return_data: Optional[pulumi.Input[bool]] = None):
|
|
3160
|
+
period: Optional[pulumi.Input[_builtins.int]] = None,
|
|
3161
|
+
return_data: Optional[pulumi.Input[_builtins.bool]] = None):
|
|
2341
3162
|
"""
|
|
2342
|
-
: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.
|
|
2343
|
-
: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.
|
|
2344
|
-
: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
|
|
3163
|
+
: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.
|
|
3164
|
+
: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.
|
|
3165
|
+
: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
|
|
2345
3166
|
: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.
|
|
2346
|
-
:param pulumi.Input[int] period: The granularity, in seconds, of the returned data points.
|
|
2347
|
-
: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
|
|
3167
|
+
:param pulumi.Input[_builtins.int] period: The granularity, in seconds, of the returned data points.
|
|
3168
|
+
: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.
|
|
2348
3169
|
"""
|
|
2349
3170
|
pulumi.set(__self__, "id", id)
|
|
2350
3171
|
if expression is not None:
|
|
@@ -2358,43 +3179,43 @@ class VerificationTemplateMetricProviderCloudWatchMetricDataQueryArgs:
|
|
|
2358
3179
|
if return_data is not None:
|
|
2359
3180
|
pulumi.set(__self__, "return_data", return_data)
|
|
2360
3181
|
|
|
2361
|
-
@property
|
|
3182
|
+
@_builtins.property
|
|
2362
3183
|
@pulumi.getter
|
|
2363
|
-
def id(self) -> pulumi.Input[str]:
|
|
3184
|
+
def id(self) -> pulumi.Input[_builtins.str]:
|
|
2364
3185
|
"""
|
|
2365
3186
|
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.
|
|
2366
3187
|
"""
|
|
2367
3188
|
return pulumi.get(self, "id")
|
|
2368
3189
|
|
|
2369
3190
|
@id.setter
|
|
2370
|
-
def id(self, value: pulumi.Input[str]):
|
|
3191
|
+
def id(self, value: pulumi.Input[_builtins.str]):
|
|
2371
3192
|
pulumi.set(self, "id", value)
|
|
2372
3193
|
|
|
2373
|
-
@property
|
|
3194
|
+
@_builtins.property
|
|
2374
3195
|
@pulumi.getter
|
|
2375
|
-
def expression(self) -> Optional[pulumi.Input[str]]:
|
|
3196
|
+
def expression(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
2376
3197
|
"""
|
|
2377
3198
|
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.
|
|
2378
3199
|
"""
|
|
2379
3200
|
return pulumi.get(self, "expression")
|
|
2380
3201
|
|
|
2381
3202
|
@expression.setter
|
|
2382
|
-
def expression(self, value: Optional[pulumi.Input[str]]):
|
|
3203
|
+
def expression(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
2383
3204
|
pulumi.set(self, "expression", value)
|
|
2384
3205
|
|
|
2385
|
-
@property
|
|
3206
|
+
@_builtins.property
|
|
2386
3207
|
@pulumi.getter
|
|
2387
|
-
def label(self) -> Optional[pulumi.Input[str]]:
|
|
3208
|
+
def label(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
2388
3209
|
"""
|
|
2389
3210
|
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
|
|
2390
3211
|
"""
|
|
2391
3212
|
return pulumi.get(self, "label")
|
|
2392
3213
|
|
|
2393
3214
|
@label.setter
|
|
2394
|
-
def label(self, value: Optional[pulumi.Input[str]]):
|
|
3215
|
+
def label(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
2395
3216
|
pulumi.set(self, "label", value)
|
|
2396
3217
|
|
|
2397
|
-
@property
|
|
3218
|
+
@_builtins.property
|
|
2398
3219
|
@pulumi.getter(name="metricStat")
|
|
2399
3220
|
def metric_stat(self) -> Optional[pulumi.Input['VerificationTemplateMetricProviderCloudWatchMetricDataQueryMetricStatArgs']]:
|
|
2400
3221
|
"""
|
|
@@ -2406,43 +3227,64 @@ class VerificationTemplateMetricProviderCloudWatchMetricDataQueryArgs:
|
|
|
2406
3227
|
def metric_stat(self, value: Optional[pulumi.Input['VerificationTemplateMetricProviderCloudWatchMetricDataQueryMetricStatArgs']]):
|
|
2407
3228
|
pulumi.set(self, "metric_stat", value)
|
|
2408
3229
|
|
|
2409
|
-
@property
|
|
3230
|
+
@_builtins.property
|
|
2410
3231
|
@pulumi.getter
|
|
2411
|
-
def period(self) -> Optional[pulumi.Input[int]]:
|
|
3232
|
+
def period(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
2412
3233
|
"""
|
|
2413
3234
|
The granularity, in seconds, of the returned data points.
|
|
2414
3235
|
"""
|
|
2415
3236
|
return pulumi.get(self, "period")
|
|
2416
3237
|
|
|
2417
3238
|
@period.setter
|
|
2418
|
-
def period(self, value: Optional[pulumi.Input[int]]):
|
|
3239
|
+
def period(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
2419
3240
|
pulumi.set(self, "period", value)
|
|
2420
3241
|
|
|
2421
|
-
@property
|
|
3242
|
+
@_builtins.property
|
|
2422
3243
|
@pulumi.getter(name="returnData")
|
|
2423
|
-
def return_data(self) -> Optional[pulumi.Input[bool]]:
|
|
3244
|
+
def return_data(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
2424
3245
|
"""
|
|
2425
|
-
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
|
|
3246
|
+
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.
|
|
2426
3247
|
"""
|
|
2427
3248
|
return pulumi.get(self, "return_data")
|
|
2428
3249
|
|
|
2429
3250
|
@return_data.setter
|
|
2430
|
-
def return_data(self, value: Optional[pulumi.Input[bool]]):
|
|
3251
|
+
def return_data(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
2431
3252
|
pulumi.set(self, "return_data", value)
|
|
2432
3253
|
|
|
2433
3254
|
|
|
3255
|
+
if not MYPY:
|
|
3256
|
+
class VerificationTemplateMetricProviderCloudWatchMetricDataQueryMetricStatArgsDict(TypedDict):
|
|
3257
|
+
metric: NotRequired[pulumi.Input['VerificationTemplateMetricProviderCloudWatchMetricDataQueryMetricStatMetricArgsDict']]
|
|
3258
|
+
"""
|
|
3259
|
+
The metric to return, including the metric name, namespace, and dimensions.
|
|
3260
|
+
"""
|
|
3261
|
+
metric_period: NotRequired[pulumi.Input[_builtins.int]]
|
|
3262
|
+
"""
|
|
3263
|
+
The granularity, in seconds, of the returned data points.
|
|
3264
|
+
"""
|
|
3265
|
+
stat: NotRequired[pulumi.Input[_builtins.str]]
|
|
3266
|
+
"""
|
|
3267
|
+
The statistic to return. It can include any CloudWatch statistic or extended statistic.
|
|
3268
|
+
"""
|
|
3269
|
+
unit: NotRequired[pulumi.Input[_builtins.str]]
|
|
3270
|
+
"""
|
|
3271
|
+
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
|
+
elif False:
|
|
3274
|
+
VerificationTemplateMetricProviderCloudWatchMetricDataQueryMetricStatArgsDict: TypeAlias = Mapping[str, Any]
|
|
3275
|
+
|
|
2434
3276
|
@pulumi.input_type
|
|
2435
3277
|
class VerificationTemplateMetricProviderCloudWatchMetricDataQueryMetricStatArgs:
|
|
2436
3278
|
def __init__(__self__, *,
|
|
2437
3279
|
metric: Optional[pulumi.Input['VerificationTemplateMetricProviderCloudWatchMetricDataQueryMetricStatMetricArgs']] = None,
|
|
2438
|
-
metric_period: Optional[pulumi.Input[int]] = None,
|
|
2439
|
-
stat: Optional[pulumi.Input[str]] = None,
|
|
2440
|
-
unit: Optional[pulumi.Input[str]] = None):
|
|
3280
|
+
metric_period: Optional[pulumi.Input[_builtins.int]] = None,
|
|
3281
|
+
stat: Optional[pulumi.Input[_builtins.str]] = None,
|
|
3282
|
+
unit: Optional[pulumi.Input[_builtins.str]] = None):
|
|
2441
3283
|
"""
|
|
2442
3284
|
:param pulumi.Input['VerificationTemplateMetricProviderCloudWatchMetricDataQueryMetricStatMetricArgs'] metric: The metric to return, including the metric name, namespace, and dimensions.
|
|
2443
|
-
:param pulumi.Input[int] metric_period: The granularity, in seconds, of the returned data points.
|
|
2444
|
-
:param pulumi.Input[str] stat: The statistic to return. It can include any CloudWatch statistic or extended statistic.
|
|
2445
|
-
: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"`
|
|
3285
|
+
:param pulumi.Input[_builtins.int] metric_period: The granularity, in seconds, of the returned data points.
|
|
3286
|
+
:param pulumi.Input[_builtins.str] stat: The statistic to return. It can include any CloudWatch statistic or extended statistic.
|
|
3287
|
+
: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"`
|
|
2446
3288
|
"""
|
|
2447
3289
|
if metric is not None:
|
|
2448
3290
|
pulumi.set(__self__, "metric", metric)
|
|
@@ -2453,7 +3295,7 @@ class VerificationTemplateMetricProviderCloudWatchMetricDataQueryMetricStatArgs:
|
|
|
2453
3295
|
if unit is not None:
|
|
2454
3296
|
pulumi.set(__self__, "unit", unit)
|
|
2455
3297
|
|
|
2456
|
-
@property
|
|
3298
|
+
@_builtins.property
|
|
2457
3299
|
@pulumi.getter
|
|
2458
3300
|
def metric(self) -> Optional[pulumi.Input['VerificationTemplateMetricProviderCloudWatchMetricDataQueryMetricStatMetricArgs']]:
|
|
2459
3301
|
"""
|
|
@@ -2465,53 +3307,70 @@ class VerificationTemplateMetricProviderCloudWatchMetricDataQueryMetricStatArgs:
|
|
|
2465
3307
|
def metric(self, value: Optional[pulumi.Input['VerificationTemplateMetricProviderCloudWatchMetricDataQueryMetricStatMetricArgs']]):
|
|
2466
3308
|
pulumi.set(self, "metric", value)
|
|
2467
3309
|
|
|
2468
|
-
@property
|
|
3310
|
+
@_builtins.property
|
|
2469
3311
|
@pulumi.getter(name="metricPeriod")
|
|
2470
|
-
def metric_period(self) -> Optional[pulumi.Input[int]]:
|
|
3312
|
+
def metric_period(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
2471
3313
|
"""
|
|
2472
3314
|
The granularity, in seconds, of the returned data points.
|
|
2473
3315
|
"""
|
|
2474
3316
|
return pulumi.get(self, "metric_period")
|
|
2475
3317
|
|
|
2476
3318
|
@metric_period.setter
|
|
2477
|
-
def metric_period(self, value: Optional[pulumi.Input[int]]):
|
|
3319
|
+
def metric_period(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
2478
3320
|
pulumi.set(self, "metric_period", value)
|
|
2479
3321
|
|
|
2480
|
-
@property
|
|
3322
|
+
@_builtins.property
|
|
2481
3323
|
@pulumi.getter
|
|
2482
|
-
def stat(self) -> Optional[pulumi.Input[str]]:
|
|
3324
|
+
def stat(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
2483
3325
|
"""
|
|
2484
3326
|
The statistic to return. It can include any CloudWatch statistic or extended statistic.
|
|
2485
3327
|
"""
|
|
2486
3328
|
return pulumi.get(self, "stat")
|
|
2487
3329
|
|
|
2488
3330
|
@stat.setter
|
|
2489
|
-
def stat(self, value: Optional[pulumi.Input[str]]):
|
|
3331
|
+
def stat(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
2490
3332
|
pulumi.set(self, "stat", value)
|
|
2491
3333
|
|
|
2492
|
-
@property
|
|
3334
|
+
@_builtins.property
|
|
2493
3335
|
@pulumi.getter
|
|
2494
|
-
def unit(self) -> Optional[pulumi.Input[str]]:
|
|
3336
|
+
def unit(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
2495
3337
|
"""
|
|
2496
3338
|
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"`
|
|
2497
3339
|
"""
|
|
2498
3340
|
return pulumi.get(self, "unit")
|
|
2499
3341
|
|
|
2500
3342
|
@unit.setter
|
|
2501
|
-
def unit(self, value: Optional[pulumi.Input[str]]):
|
|
3343
|
+
def unit(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
2502
3344
|
pulumi.set(self, "unit", value)
|
|
2503
3345
|
|
|
2504
3346
|
|
|
3347
|
+
if not MYPY:
|
|
3348
|
+
class VerificationTemplateMetricProviderCloudWatchMetricDataQueryMetricStatMetricArgsDict(TypedDict):
|
|
3349
|
+
metric_name: pulumi.Input[_builtins.str]
|
|
3350
|
+
"""
|
|
3351
|
+
The name of the metric.
|
|
3352
|
+
"""
|
|
3353
|
+
dimensions: NotRequired[pulumi.Input[Sequence[pulumi.Input['VerificationTemplateMetricProviderCloudWatchMetricDataQueryMetricStatMetricDimensionArgsDict']]]]
|
|
3354
|
+
"""
|
|
3355
|
+
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
|
+
namespace: NotRequired[pulumi.Input[_builtins.str]]
|
|
3358
|
+
"""
|
|
3359
|
+
The namespace of the metric.
|
|
3360
|
+
"""
|
|
3361
|
+
elif False:
|
|
3362
|
+
VerificationTemplateMetricProviderCloudWatchMetricDataQueryMetricStatMetricArgsDict: TypeAlias = Mapping[str, Any]
|
|
3363
|
+
|
|
2505
3364
|
@pulumi.input_type
|
|
2506
3365
|
class VerificationTemplateMetricProviderCloudWatchMetricDataQueryMetricStatMetricArgs:
|
|
2507
3366
|
def __init__(__self__, *,
|
|
2508
|
-
metric_name: pulumi.Input[str],
|
|
3367
|
+
metric_name: pulumi.Input[_builtins.str],
|
|
2509
3368
|
dimensions: Optional[pulumi.Input[Sequence[pulumi.Input['VerificationTemplateMetricProviderCloudWatchMetricDataQueryMetricStatMetricDimensionArgs']]]] = None,
|
|
2510
|
-
namespace: Optional[pulumi.Input[str]] = None):
|
|
3369
|
+
namespace: Optional[pulumi.Input[_builtins.str]] = None):
|
|
2511
3370
|
"""
|
|
2512
|
-
:param pulumi.Input[str] metric_name: The name of the metric.
|
|
3371
|
+
:param pulumi.Input[_builtins.str] metric_name: The name of the metric.
|
|
2513
3372
|
: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
|
|
2514
|
-
:param pulumi.Input[str] namespace: The namespace of the metric.
|
|
3373
|
+
:param pulumi.Input[_builtins.str] namespace: The namespace of the metric.
|
|
2515
3374
|
"""
|
|
2516
3375
|
pulumi.set(__self__, "metric_name", metric_name)
|
|
2517
3376
|
if dimensions is not None:
|
|
@@ -2519,19 +3378,19 @@ class VerificationTemplateMetricProviderCloudWatchMetricDataQueryMetricStatMetri
|
|
|
2519
3378
|
if namespace is not None:
|
|
2520
3379
|
pulumi.set(__self__, "namespace", namespace)
|
|
2521
3380
|
|
|
2522
|
-
@property
|
|
3381
|
+
@_builtins.property
|
|
2523
3382
|
@pulumi.getter(name="metricName")
|
|
2524
|
-
def metric_name(self) -> pulumi.Input[str]:
|
|
3383
|
+
def metric_name(self) -> pulumi.Input[_builtins.str]:
|
|
2525
3384
|
"""
|
|
2526
3385
|
The name of the metric.
|
|
2527
3386
|
"""
|
|
2528
3387
|
return pulumi.get(self, "metric_name")
|
|
2529
3388
|
|
|
2530
3389
|
@metric_name.setter
|
|
2531
|
-
def metric_name(self, value: pulumi.Input[str]):
|
|
3390
|
+
def metric_name(self, value: pulumi.Input[_builtins.str]):
|
|
2532
3391
|
pulumi.set(self, "metric_name", value)
|
|
2533
3392
|
|
|
2534
|
-
@property
|
|
3393
|
+
@_builtins.property
|
|
2535
3394
|
@pulumi.getter
|
|
2536
3395
|
def dimensions(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['VerificationTemplateMetricProviderCloudWatchMetricDataQueryMetricStatMetricDimensionArgs']]]]:
|
|
2537
3396
|
"""
|
|
@@ -2543,109 +3402,160 @@ class VerificationTemplateMetricProviderCloudWatchMetricDataQueryMetricStatMetri
|
|
|
2543
3402
|
def dimensions(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['VerificationTemplateMetricProviderCloudWatchMetricDataQueryMetricStatMetricDimensionArgs']]]]):
|
|
2544
3403
|
pulumi.set(self, "dimensions", value)
|
|
2545
3404
|
|
|
2546
|
-
@property
|
|
3405
|
+
@_builtins.property
|
|
2547
3406
|
@pulumi.getter
|
|
2548
|
-
def namespace(self) -> Optional[pulumi.Input[str]]:
|
|
3407
|
+
def namespace(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
2549
3408
|
"""
|
|
2550
3409
|
The namespace of the metric.
|
|
2551
3410
|
"""
|
|
2552
3411
|
return pulumi.get(self, "namespace")
|
|
2553
3412
|
|
|
2554
3413
|
@namespace.setter
|
|
2555
|
-
def namespace(self, value: Optional[pulumi.Input[str]]):
|
|
3414
|
+
def namespace(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
2556
3415
|
pulumi.set(self, "namespace", value)
|
|
2557
3416
|
|
|
2558
3417
|
|
|
3418
|
+
if not MYPY:
|
|
3419
|
+
class VerificationTemplateMetricProviderCloudWatchMetricDataQueryMetricStatMetricDimensionArgsDict(TypedDict):
|
|
3420
|
+
dimension_name: pulumi.Input[_builtins.str]
|
|
3421
|
+
"""
|
|
3422
|
+
The name of the dimensions. These values must contain only ASCII characters and must include at least one non-whitespace characte
|
|
3423
|
+
"""
|
|
3424
|
+
dimension_value: pulumi.Input[_builtins.str]
|
|
3425
|
+
"""
|
|
3426
|
+
The value of the dimensions.These values must contain only ASCII characters and must include at least one non-whitespace characte
|
|
3427
|
+
"""
|
|
3428
|
+
elif False:
|
|
3429
|
+
VerificationTemplateMetricProviderCloudWatchMetricDataQueryMetricStatMetricDimensionArgsDict: TypeAlias = Mapping[str, Any]
|
|
3430
|
+
|
|
2559
3431
|
@pulumi.input_type
|
|
2560
3432
|
class VerificationTemplateMetricProviderCloudWatchMetricDataQueryMetricStatMetricDimensionArgs:
|
|
2561
3433
|
def __init__(__self__, *,
|
|
2562
|
-
dimension_name: pulumi.Input[str],
|
|
2563
|
-
dimension_value: pulumi.Input[str]):
|
|
3434
|
+
dimension_name: pulumi.Input[_builtins.str],
|
|
3435
|
+
dimension_value: pulumi.Input[_builtins.str]):
|
|
2564
3436
|
"""
|
|
2565
|
-
: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
|
|
2566
|
-
: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
|
|
3437
|
+
: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
|
|
3438
|
+
: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
|
|
2567
3439
|
"""
|
|
2568
3440
|
pulumi.set(__self__, "dimension_name", dimension_name)
|
|
2569
3441
|
pulumi.set(__self__, "dimension_value", dimension_value)
|
|
2570
3442
|
|
|
2571
|
-
@property
|
|
3443
|
+
@_builtins.property
|
|
2572
3444
|
@pulumi.getter(name="dimensionName")
|
|
2573
|
-
def dimension_name(self) -> pulumi.Input[str]:
|
|
3445
|
+
def dimension_name(self) -> pulumi.Input[_builtins.str]:
|
|
2574
3446
|
"""
|
|
2575
3447
|
The name of the dimensions. These values must contain only ASCII characters and must include at least one non-whitespace characte
|
|
2576
3448
|
"""
|
|
2577
3449
|
return pulumi.get(self, "dimension_name")
|
|
2578
3450
|
|
|
2579
3451
|
@dimension_name.setter
|
|
2580
|
-
def dimension_name(self, value: pulumi.Input[str]):
|
|
3452
|
+
def dimension_name(self, value: pulumi.Input[_builtins.str]):
|
|
2581
3453
|
pulumi.set(self, "dimension_name", value)
|
|
2582
3454
|
|
|
2583
|
-
@property
|
|
3455
|
+
@_builtins.property
|
|
2584
3456
|
@pulumi.getter(name="dimensionValue")
|
|
2585
|
-
def dimension_value(self) -> pulumi.Input[str]:
|
|
3457
|
+
def dimension_value(self) -> pulumi.Input[_builtins.str]:
|
|
2586
3458
|
"""
|
|
2587
3459
|
The value of the dimensions.These values must contain only ASCII characters and must include at least one non-whitespace characte
|
|
2588
3460
|
"""
|
|
2589
3461
|
return pulumi.get(self, "dimension_value")
|
|
2590
3462
|
|
|
2591
3463
|
@dimension_value.setter
|
|
2592
|
-
def dimension_value(self, value: pulumi.Input[str]):
|
|
3464
|
+
def dimension_value(self, value: pulumi.Input[_builtins.str]):
|
|
2593
3465
|
pulumi.set(self, "dimension_value", value)
|
|
2594
3466
|
|
|
2595
3467
|
|
|
3468
|
+
if not MYPY:
|
|
3469
|
+
class VerificationTemplateMetricProviderDatadogArgsDict(TypedDict):
|
|
3470
|
+
datadog_query: NotRequired[pulumi.Input[_builtins.str]]
|
|
3471
|
+
"""
|
|
3472
|
+
A request for information retrieved from Datadog.
|
|
3473
|
+
"""
|
|
3474
|
+
duration: NotRequired[pulumi.Input[_builtins.str]]
|
|
3475
|
+
"""
|
|
3476
|
+
The window of time we are looking at in DataDog.
|
|
3477
|
+
"""
|
|
3478
|
+
elif False:
|
|
3479
|
+
VerificationTemplateMetricProviderDatadogArgsDict: TypeAlias = Mapping[str, Any]
|
|
3480
|
+
|
|
2596
3481
|
@pulumi.input_type
|
|
2597
3482
|
class VerificationTemplateMetricProviderDatadogArgs:
|
|
2598
3483
|
def __init__(__self__, *,
|
|
2599
|
-
datadog_query: Optional[pulumi.Input[str]] = None,
|
|
2600
|
-
duration: Optional[pulumi.Input[str]] = None):
|
|
3484
|
+
datadog_query: Optional[pulumi.Input[_builtins.str]] = None,
|
|
3485
|
+
duration: Optional[pulumi.Input[_builtins.str]] = None):
|
|
2601
3486
|
"""
|
|
2602
|
-
:param pulumi.Input[str] datadog_query: A request for information retrieved from Datadog.
|
|
2603
|
-
:param pulumi.Input[str] duration: The window of time we are looking at in DataDog.
|
|
3487
|
+
:param pulumi.Input[_builtins.str] datadog_query: A request for information retrieved from Datadog.
|
|
3488
|
+
:param pulumi.Input[_builtins.str] duration: The window of time we are looking at in DataDog.
|
|
2604
3489
|
"""
|
|
2605
3490
|
if datadog_query is not None:
|
|
2606
3491
|
pulumi.set(__self__, "datadog_query", datadog_query)
|
|
2607
3492
|
if duration is not None:
|
|
2608
3493
|
pulumi.set(__self__, "duration", duration)
|
|
2609
3494
|
|
|
2610
|
-
@property
|
|
3495
|
+
@_builtins.property
|
|
2611
3496
|
@pulumi.getter(name="datadogQuery")
|
|
2612
|
-
def datadog_query(self) -> Optional[pulumi.Input[str]]:
|
|
3497
|
+
def datadog_query(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
2613
3498
|
"""
|
|
2614
3499
|
A request for information retrieved from Datadog.
|
|
2615
3500
|
"""
|
|
2616
3501
|
return pulumi.get(self, "datadog_query")
|
|
2617
3502
|
|
|
2618
3503
|
@datadog_query.setter
|
|
2619
|
-
def datadog_query(self, value: Optional[pulumi.Input[str]]):
|
|
3504
|
+
def datadog_query(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
2620
3505
|
pulumi.set(self, "datadog_query", value)
|
|
2621
3506
|
|
|
2622
|
-
@property
|
|
3507
|
+
@_builtins.property
|
|
2623
3508
|
@pulumi.getter
|
|
2624
|
-
def duration(self) -> Optional[pulumi.Input[str]]:
|
|
3509
|
+
def duration(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
2625
3510
|
"""
|
|
2626
3511
|
The window of time we are looking at in DataDog.
|
|
2627
3512
|
"""
|
|
2628
3513
|
return pulumi.get(self, "duration")
|
|
2629
3514
|
|
|
2630
3515
|
@duration.setter
|
|
2631
|
-
def duration(self, value: Optional[pulumi.Input[str]]):
|
|
3516
|
+
def duration(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
2632
3517
|
pulumi.set(self, "duration", value)
|
|
2633
3518
|
|
|
2634
3519
|
|
|
3520
|
+
if not MYPY:
|
|
3521
|
+
class VerificationTemplateMetricProviderJenkinsArgsDict(TypedDict):
|
|
3522
|
+
jenkins_interval: pulumi.Input[_builtins.str]
|
|
3523
|
+
"""
|
|
3524
|
+
The interval time to poll status.
|
|
3525
|
+
"""
|
|
3526
|
+
pipeline_name: pulumi.Input[_builtins.str]
|
|
3527
|
+
"""
|
|
3528
|
+
The Jenkins pipeline name.
|
|
3529
|
+
"""
|
|
3530
|
+
timeout: pulumi.Input[_builtins.str]
|
|
3531
|
+
"""
|
|
3532
|
+
The total jenkins timeout.
|
|
3533
|
+
"""
|
|
3534
|
+
jenkins_parameters: NotRequired[pulumi.Input['VerificationTemplateMetricProviderJenkinsJenkinsParametersArgsDict']]
|
|
3535
|
+
"""
|
|
3536
|
+
List of parameters.
|
|
3537
|
+
"""
|
|
3538
|
+
tls_verification: NotRequired[pulumi.Input[_builtins.bool]]
|
|
3539
|
+
"""
|
|
3540
|
+
Host TLS verification.
|
|
3541
|
+
"""
|
|
3542
|
+
elif False:
|
|
3543
|
+
VerificationTemplateMetricProviderJenkinsArgsDict: TypeAlias = Mapping[str, Any]
|
|
3544
|
+
|
|
2635
3545
|
@pulumi.input_type
|
|
2636
3546
|
class VerificationTemplateMetricProviderJenkinsArgs:
|
|
2637
3547
|
def __init__(__self__, *,
|
|
2638
|
-
jenkins_interval: pulumi.Input[str],
|
|
2639
|
-
pipeline_name: pulumi.Input[str],
|
|
2640
|
-
timeout: pulumi.Input[str],
|
|
3548
|
+
jenkins_interval: pulumi.Input[_builtins.str],
|
|
3549
|
+
pipeline_name: pulumi.Input[_builtins.str],
|
|
3550
|
+
timeout: pulumi.Input[_builtins.str],
|
|
2641
3551
|
jenkins_parameters: Optional[pulumi.Input['VerificationTemplateMetricProviderJenkinsJenkinsParametersArgs']] = None,
|
|
2642
|
-
tls_verification: Optional[pulumi.Input[bool]] = None):
|
|
3552
|
+
tls_verification: Optional[pulumi.Input[_builtins.bool]] = None):
|
|
2643
3553
|
"""
|
|
2644
|
-
:param pulumi.Input[str] jenkins_interval: The interval time to poll status.
|
|
2645
|
-
:param pulumi.Input[str] pipeline_name: The Jenkins pipeline name.
|
|
2646
|
-
:param pulumi.Input[str] timeout: The total jenkins timeout.
|
|
3554
|
+
:param pulumi.Input[_builtins.str] jenkins_interval: The interval time to poll status.
|
|
3555
|
+
:param pulumi.Input[_builtins.str] pipeline_name: The Jenkins pipeline name.
|
|
3556
|
+
:param pulumi.Input[_builtins.str] timeout: The total jenkins timeout.
|
|
2647
3557
|
:param pulumi.Input['VerificationTemplateMetricProviderJenkinsJenkinsParametersArgs'] jenkins_parameters: List of parameters.
|
|
2648
|
-
:param pulumi.Input[bool] tls_verification: Host TLS verification.
|
|
3558
|
+
:param pulumi.Input[_builtins.bool] tls_verification: Host TLS verification.
|
|
2649
3559
|
"""
|
|
2650
3560
|
pulumi.set(__self__, "jenkins_interval", jenkins_interval)
|
|
2651
3561
|
pulumi.set(__self__, "pipeline_name", pipeline_name)
|
|
@@ -2655,43 +3565,43 @@ class VerificationTemplateMetricProviderJenkinsArgs:
|
|
|
2655
3565
|
if tls_verification is not None:
|
|
2656
3566
|
pulumi.set(__self__, "tls_verification", tls_verification)
|
|
2657
3567
|
|
|
2658
|
-
@property
|
|
3568
|
+
@_builtins.property
|
|
2659
3569
|
@pulumi.getter(name="jenkinsInterval")
|
|
2660
|
-
def jenkins_interval(self) -> pulumi.Input[str]:
|
|
3570
|
+
def jenkins_interval(self) -> pulumi.Input[_builtins.str]:
|
|
2661
3571
|
"""
|
|
2662
3572
|
The interval time to poll status.
|
|
2663
3573
|
"""
|
|
2664
3574
|
return pulumi.get(self, "jenkins_interval")
|
|
2665
3575
|
|
|
2666
3576
|
@jenkins_interval.setter
|
|
2667
|
-
def jenkins_interval(self, value: pulumi.Input[str]):
|
|
3577
|
+
def jenkins_interval(self, value: pulumi.Input[_builtins.str]):
|
|
2668
3578
|
pulumi.set(self, "jenkins_interval", value)
|
|
2669
3579
|
|
|
2670
|
-
@property
|
|
3580
|
+
@_builtins.property
|
|
2671
3581
|
@pulumi.getter(name="pipelineName")
|
|
2672
|
-
def pipeline_name(self) -> pulumi.Input[str]:
|
|
3582
|
+
def pipeline_name(self) -> pulumi.Input[_builtins.str]:
|
|
2673
3583
|
"""
|
|
2674
3584
|
The Jenkins pipeline name.
|
|
2675
3585
|
"""
|
|
2676
3586
|
return pulumi.get(self, "pipeline_name")
|
|
2677
3587
|
|
|
2678
3588
|
@pipeline_name.setter
|
|
2679
|
-
def pipeline_name(self, value: pulumi.Input[str]):
|
|
3589
|
+
def pipeline_name(self, value: pulumi.Input[_builtins.str]):
|
|
2680
3590
|
pulumi.set(self, "pipeline_name", value)
|
|
2681
3591
|
|
|
2682
|
-
@property
|
|
3592
|
+
@_builtins.property
|
|
2683
3593
|
@pulumi.getter
|
|
2684
|
-
def timeout(self) -> pulumi.Input[str]:
|
|
3594
|
+
def timeout(self) -> pulumi.Input[_builtins.str]:
|
|
2685
3595
|
"""
|
|
2686
3596
|
The total jenkins timeout.
|
|
2687
3597
|
"""
|
|
2688
3598
|
return pulumi.get(self, "timeout")
|
|
2689
3599
|
|
|
2690
3600
|
@timeout.setter
|
|
2691
|
-
def timeout(self, value: pulumi.Input[str]):
|
|
3601
|
+
def timeout(self, value: pulumi.Input[_builtins.str]):
|
|
2692
3602
|
pulumi.set(self, "timeout", value)
|
|
2693
3603
|
|
|
2694
|
-
@property
|
|
3604
|
+
@_builtins.property
|
|
2695
3605
|
@pulumi.getter(name="jenkinsParameters")
|
|
2696
3606
|
def jenkins_parameters(self) -> Optional[pulumi.Input['VerificationTemplateMetricProviderJenkinsJenkinsParametersArgs']]:
|
|
2697
3607
|
"""
|
|
@@ -2703,56 +3613,78 @@ class VerificationTemplateMetricProviderJenkinsArgs:
|
|
|
2703
3613
|
def jenkins_parameters(self, value: Optional[pulumi.Input['VerificationTemplateMetricProviderJenkinsJenkinsParametersArgs']]):
|
|
2704
3614
|
pulumi.set(self, "jenkins_parameters", value)
|
|
2705
3615
|
|
|
2706
|
-
@property
|
|
3616
|
+
@_builtins.property
|
|
2707
3617
|
@pulumi.getter(name="tlsVerification")
|
|
2708
|
-
def tls_verification(self) -> Optional[pulumi.Input[bool]]:
|
|
3618
|
+
def tls_verification(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
2709
3619
|
"""
|
|
2710
3620
|
Host TLS verification.
|
|
2711
3621
|
"""
|
|
2712
3622
|
return pulumi.get(self, "tls_verification")
|
|
2713
3623
|
|
|
2714
3624
|
@tls_verification.setter
|
|
2715
|
-
def tls_verification(self, value: Optional[pulumi.Input[bool]]):
|
|
3625
|
+
def tls_verification(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
2716
3626
|
pulumi.set(self, "tls_verification", value)
|
|
2717
3627
|
|
|
2718
3628
|
|
|
3629
|
+
if not MYPY:
|
|
3630
|
+
class VerificationTemplateMetricProviderJenkinsJenkinsParametersArgsDict(TypedDict):
|
|
3631
|
+
parameter_key: pulumi.Input[_builtins.str]
|
|
3632
|
+
"""
|
|
3633
|
+
Key of an argument.
|
|
3634
|
+
"""
|
|
3635
|
+
parameter_value: pulumi.Input[_builtins.str]
|
|
3636
|
+
"""
|
|
3637
|
+
Value of an argument.
|
|
3638
|
+
"""
|
|
3639
|
+
elif False:
|
|
3640
|
+
VerificationTemplateMetricProviderJenkinsJenkinsParametersArgsDict: TypeAlias = Mapping[str, Any]
|
|
3641
|
+
|
|
2719
3642
|
@pulumi.input_type
|
|
2720
3643
|
class VerificationTemplateMetricProviderJenkinsJenkinsParametersArgs:
|
|
2721
3644
|
def __init__(__self__, *,
|
|
2722
|
-
parameter_key: pulumi.Input[str],
|
|
2723
|
-
parameter_value: pulumi.Input[str]):
|
|
3645
|
+
parameter_key: pulumi.Input[_builtins.str],
|
|
3646
|
+
parameter_value: pulumi.Input[_builtins.str]):
|
|
2724
3647
|
"""
|
|
2725
|
-
:param pulumi.Input[str] parameter_key: Key of an argument.
|
|
2726
|
-
:param pulumi.Input[str] parameter_value: Value of an argument.
|
|
3648
|
+
:param pulumi.Input[_builtins.str] parameter_key: Key of an argument.
|
|
3649
|
+
:param pulumi.Input[_builtins.str] parameter_value: Value of an argument.
|
|
2727
3650
|
"""
|
|
2728
3651
|
pulumi.set(__self__, "parameter_key", parameter_key)
|
|
2729
3652
|
pulumi.set(__self__, "parameter_value", parameter_value)
|
|
2730
3653
|
|
|
2731
|
-
@property
|
|
3654
|
+
@_builtins.property
|
|
2732
3655
|
@pulumi.getter(name="parameterKey")
|
|
2733
|
-
def parameter_key(self) -> pulumi.Input[str]:
|
|
3656
|
+
def parameter_key(self) -> pulumi.Input[_builtins.str]:
|
|
2734
3657
|
"""
|
|
2735
3658
|
Key of an argument.
|
|
2736
3659
|
"""
|
|
2737
3660
|
return pulumi.get(self, "parameter_key")
|
|
2738
3661
|
|
|
2739
3662
|
@parameter_key.setter
|
|
2740
|
-
def parameter_key(self, value: pulumi.Input[str]):
|
|
3663
|
+
def parameter_key(self, value: pulumi.Input[_builtins.str]):
|
|
2741
3664
|
pulumi.set(self, "parameter_key", value)
|
|
2742
3665
|
|
|
2743
|
-
@property
|
|
3666
|
+
@_builtins.property
|
|
2744
3667
|
@pulumi.getter(name="parameterValue")
|
|
2745
|
-
def parameter_value(self) -> pulumi.Input[str]:
|
|
3668
|
+
def parameter_value(self) -> pulumi.Input[_builtins.str]:
|
|
2746
3669
|
"""
|
|
2747
3670
|
Value of an argument.
|
|
2748
3671
|
"""
|
|
2749
3672
|
return pulumi.get(self, "parameter_value")
|
|
2750
3673
|
|
|
2751
3674
|
@parameter_value.setter
|
|
2752
|
-
def parameter_value(self, value: pulumi.Input[str]):
|
|
3675
|
+
def parameter_value(self, value: pulumi.Input[_builtins.str]):
|
|
2753
3676
|
pulumi.set(self, "parameter_value", value)
|
|
2754
3677
|
|
|
2755
3678
|
|
|
3679
|
+
if not MYPY:
|
|
3680
|
+
class VerificationTemplateMetricProviderJobArgsDict(TypedDict):
|
|
3681
|
+
specs: pulumi.Input[Sequence[pulumi.Input['VerificationTemplateMetricProviderJobSpecArgsDict']]]
|
|
3682
|
+
"""
|
|
3683
|
+
The job spec require to run the metric.
|
|
3684
|
+
"""
|
|
3685
|
+
elif False:
|
|
3686
|
+
VerificationTemplateMetricProviderJobArgsDict: TypeAlias = Mapping[str, Any]
|
|
3687
|
+
|
|
2756
3688
|
@pulumi.input_type
|
|
2757
3689
|
class VerificationTemplateMetricProviderJobArgs:
|
|
2758
3690
|
def __init__(__self__, *,
|
|
@@ -2762,7 +3694,7 @@ class VerificationTemplateMetricProviderJobArgs:
|
|
|
2762
3694
|
"""
|
|
2763
3695
|
pulumi.set(__self__, "specs", specs)
|
|
2764
3696
|
|
|
2765
|
-
@property
|
|
3697
|
+
@_builtins.property
|
|
2766
3698
|
@pulumi.getter
|
|
2767
3699
|
def specs(self) -> pulumi.Input[Sequence[pulumi.Input['VerificationTemplateMetricProviderJobSpecArgs']]]:
|
|
2768
3700
|
"""
|
|
@@ -2775,20 +3707,33 @@ class VerificationTemplateMetricProviderJobArgs:
|
|
|
2775
3707
|
pulumi.set(self, "specs", value)
|
|
2776
3708
|
|
|
2777
3709
|
|
|
3710
|
+
if not MYPY:
|
|
3711
|
+
class VerificationTemplateMetricProviderJobSpecArgsDict(TypedDict):
|
|
3712
|
+
job_templates: pulumi.Input[Sequence[pulumi.Input['VerificationTemplateMetricProviderJobSpecJobTemplateArgsDict']]]
|
|
3713
|
+
"""
|
|
3714
|
+
Describes the pod that will be created when executing a job.
|
|
3715
|
+
"""
|
|
3716
|
+
backoff_limit: NotRequired[pulumi.Input[_builtins.int]]
|
|
3717
|
+
"""
|
|
3718
|
+
Specifies the number of retries before marking this job failed.
|
|
3719
|
+
"""
|
|
3720
|
+
elif False:
|
|
3721
|
+
VerificationTemplateMetricProviderJobSpecArgsDict: TypeAlias = Mapping[str, Any]
|
|
3722
|
+
|
|
2778
3723
|
@pulumi.input_type
|
|
2779
3724
|
class VerificationTemplateMetricProviderJobSpecArgs:
|
|
2780
3725
|
def __init__(__self__, *,
|
|
2781
3726
|
job_templates: pulumi.Input[Sequence[pulumi.Input['VerificationTemplateMetricProviderJobSpecJobTemplateArgs']]],
|
|
2782
|
-
backoff_limit: Optional[pulumi.Input[int]] = None):
|
|
3727
|
+
backoff_limit: Optional[pulumi.Input[_builtins.int]] = None):
|
|
2783
3728
|
"""
|
|
2784
3729
|
:param pulumi.Input[Sequence[pulumi.Input['VerificationTemplateMetricProviderJobSpecJobTemplateArgs']]] job_templates: Describes the pod that will be created when executing a job.
|
|
2785
|
-
:param pulumi.Input[int] backoff_limit: Specifies the number of retries before marking this job failed.
|
|
3730
|
+
:param pulumi.Input[_builtins.int] backoff_limit: Specifies the number of retries before marking this job failed.
|
|
2786
3731
|
"""
|
|
2787
3732
|
pulumi.set(__self__, "job_templates", job_templates)
|
|
2788
3733
|
if backoff_limit is not None:
|
|
2789
3734
|
pulumi.set(__self__, "backoff_limit", backoff_limit)
|
|
2790
3735
|
|
|
2791
|
-
@property
|
|
3736
|
+
@_builtins.property
|
|
2792
3737
|
@pulumi.getter(name="jobTemplates")
|
|
2793
3738
|
def job_templates(self) -> pulumi.Input[Sequence[pulumi.Input['VerificationTemplateMetricProviderJobSpecJobTemplateArgs']]]:
|
|
2794
3739
|
"""
|
|
@@ -2800,19 +3745,28 @@ class VerificationTemplateMetricProviderJobSpecArgs:
|
|
|
2800
3745
|
def job_templates(self, value: pulumi.Input[Sequence[pulumi.Input['VerificationTemplateMetricProviderJobSpecJobTemplateArgs']]]):
|
|
2801
3746
|
pulumi.set(self, "job_templates", value)
|
|
2802
3747
|
|
|
2803
|
-
@property
|
|
3748
|
+
@_builtins.property
|
|
2804
3749
|
@pulumi.getter(name="backoffLimit")
|
|
2805
|
-
def backoff_limit(self) -> Optional[pulumi.Input[int]]:
|
|
3750
|
+
def backoff_limit(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
2806
3751
|
"""
|
|
2807
3752
|
Specifies the number of retries before marking this job failed.
|
|
2808
3753
|
"""
|
|
2809
3754
|
return pulumi.get(self, "backoff_limit")
|
|
2810
3755
|
|
|
2811
3756
|
@backoff_limit.setter
|
|
2812
|
-
def backoff_limit(self, value: Optional[pulumi.Input[int]]):
|
|
3757
|
+
def backoff_limit(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
2813
3758
|
pulumi.set(self, "backoff_limit", value)
|
|
2814
3759
|
|
|
2815
3760
|
|
|
3761
|
+
if not MYPY:
|
|
3762
|
+
class VerificationTemplateMetricProviderJobSpecJobTemplateArgsDict(TypedDict):
|
|
3763
|
+
template_specs: pulumi.Input[Sequence[pulumi.Input['VerificationTemplateMetricProviderJobSpecJobTemplateTemplateSpecArgsDict']]]
|
|
3764
|
+
"""
|
|
3765
|
+
Specification of the desired behavior of the pod.
|
|
3766
|
+
"""
|
|
3767
|
+
elif False:
|
|
3768
|
+
VerificationTemplateMetricProviderJobSpecJobTemplateArgsDict: TypeAlias = Mapping[str, Any]
|
|
3769
|
+
|
|
2816
3770
|
@pulumi.input_type
|
|
2817
3771
|
class VerificationTemplateMetricProviderJobSpecJobTemplateArgs:
|
|
2818
3772
|
def __init__(__self__, *,
|
|
@@ -2822,7 +3776,7 @@ class VerificationTemplateMetricProviderJobSpecJobTemplateArgs:
|
|
|
2822
3776
|
"""
|
|
2823
3777
|
pulumi.set(__self__, "template_specs", template_specs)
|
|
2824
3778
|
|
|
2825
|
-
@property
|
|
3779
|
+
@_builtins.property
|
|
2826
3780
|
@pulumi.getter(name="templateSpecs")
|
|
2827
3781
|
def template_specs(self) -> pulumi.Input[Sequence[pulumi.Input['VerificationTemplateMetricProviderJobSpecJobTemplateTemplateSpecArgs']]]:
|
|
2828
3782
|
"""
|
|
@@ -2835,19 +3789,32 @@ class VerificationTemplateMetricProviderJobSpecJobTemplateArgs:
|
|
|
2835
3789
|
pulumi.set(self, "template_specs", value)
|
|
2836
3790
|
|
|
2837
3791
|
|
|
3792
|
+
if not MYPY:
|
|
3793
|
+
class VerificationTemplateMetricProviderJobSpecJobTemplateTemplateSpecArgsDict(TypedDict):
|
|
3794
|
+
containers: pulumi.Input[Sequence[pulumi.Input['VerificationTemplateMetricProviderJobSpecJobTemplateTemplateSpecContainerArgsDict']]]
|
|
3795
|
+
"""
|
|
3796
|
+
A list of containers belonging to the pod.
|
|
3797
|
+
"""
|
|
3798
|
+
restart_policy: pulumi.Input[_builtins.str]
|
|
3799
|
+
"""
|
|
3800
|
+
Restart policy for all containers within the pod. Enum: `"Never" "OnFailure"`
|
|
3801
|
+
"""
|
|
3802
|
+
elif False:
|
|
3803
|
+
VerificationTemplateMetricProviderJobSpecJobTemplateTemplateSpecArgsDict: TypeAlias = Mapping[str, Any]
|
|
3804
|
+
|
|
2838
3805
|
@pulumi.input_type
|
|
2839
3806
|
class VerificationTemplateMetricProviderJobSpecJobTemplateTemplateSpecArgs:
|
|
2840
3807
|
def __init__(__self__, *,
|
|
2841
3808
|
containers: pulumi.Input[Sequence[pulumi.Input['VerificationTemplateMetricProviderJobSpecJobTemplateTemplateSpecContainerArgs']]],
|
|
2842
|
-
restart_policy: pulumi.Input[str]):
|
|
3809
|
+
restart_policy: pulumi.Input[_builtins.str]):
|
|
2843
3810
|
"""
|
|
2844
3811
|
:param pulumi.Input[Sequence[pulumi.Input['VerificationTemplateMetricProviderJobSpecJobTemplateTemplateSpecContainerArgs']]] containers: A list of containers belonging to the pod.
|
|
2845
|
-
:param pulumi.Input[str] restart_policy: Restart policy for all containers within the pod. Enum: `"Never" "OnFailure"`
|
|
3812
|
+
:param pulumi.Input[_builtins.str] restart_policy: Restart policy for all containers within the pod. Enum: `"Never" "OnFailure"`
|
|
2846
3813
|
"""
|
|
2847
3814
|
pulumi.set(__self__, "containers", containers)
|
|
2848
3815
|
pulumi.set(__self__, "restart_policy", restart_policy)
|
|
2849
3816
|
|
|
2850
|
-
@property
|
|
3817
|
+
@_builtins.property
|
|
2851
3818
|
@pulumi.getter
|
|
2852
3819
|
def containers(self) -> pulumi.Input[Sequence[pulumi.Input['VerificationTemplateMetricProviderJobSpecJobTemplateTemplateSpecContainerArgs']]]:
|
|
2853
3820
|
"""
|
|
@@ -2859,142 +3826,220 @@ class VerificationTemplateMetricProviderJobSpecJobTemplateTemplateSpecArgs:
|
|
|
2859
3826
|
def containers(self, value: pulumi.Input[Sequence[pulumi.Input['VerificationTemplateMetricProviderJobSpecJobTemplateTemplateSpecContainerArgs']]]):
|
|
2860
3827
|
pulumi.set(self, "containers", value)
|
|
2861
3828
|
|
|
2862
|
-
@property
|
|
3829
|
+
@_builtins.property
|
|
2863
3830
|
@pulumi.getter(name="restartPolicy")
|
|
2864
|
-
def restart_policy(self) -> pulumi.Input[str]:
|
|
3831
|
+
def restart_policy(self) -> pulumi.Input[_builtins.str]:
|
|
2865
3832
|
"""
|
|
2866
3833
|
Restart policy for all containers within the pod. Enum: `"Never" "OnFailure"`
|
|
2867
3834
|
"""
|
|
2868
3835
|
return pulumi.get(self, "restart_policy")
|
|
2869
3836
|
|
|
2870
3837
|
@restart_policy.setter
|
|
2871
|
-
def restart_policy(self, value: pulumi.Input[str]):
|
|
3838
|
+
def restart_policy(self, value: pulumi.Input[_builtins.str]):
|
|
2872
3839
|
pulumi.set(self, "restart_policy", value)
|
|
2873
3840
|
|
|
2874
3841
|
|
|
3842
|
+
if not MYPY:
|
|
3843
|
+
class VerificationTemplateMetricProviderJobSpecJobTemplateTemplateSpecContainerArgsDict(TypedDict):
|
|
3844
|
+
commands: pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]
|
|
3845
|
+
"""
|
|
3846
|
+
The entry point of a container.
|
|
3847
|
+
"""
|
|
3848
|
+
container_name: pulumi.Input[_builtins.str]
|
|
3849
|
+
"""
|
|
3850
|
+
The name of a container.
|
|
3851
|
+
"""
|
|
3852
|
+
image: pulumi.Input[_builtins.str]
|
|
3853
|
+
"""
|
|
3854
|
+
The image name of a container.
|
|
3855
|
+
"""
|
|
3856
|
+
elif False:
|
|
3857
|
+
VerificationTemplateMetricProviderJobSpecJobTemplateTemplateSpecContainerArgsDict: TypeAlias = Mapping[str, Any]
|
|
3858
|
+
|
|
2875
3859
|
@pulumi.input_type
|
|
2876
3860
|
class VerificationTemplateMetricProviderJobSpecJobTemplateTemplateSpecContainerArgs:
|
|
2877
3861
|
def __init__(__self__, *,
|
|
2878
|
-
commands: pulumi.Input[Sequence[pulumi.Input[str]]],
|
|
2879
|
-
container_name: pulumi.Input[str],
|
|
2880
|
-
image: pulumi.Input[str]):
|
|
3862
|
+
commands: pulumi.Input[Sequence[pulumi.Input[_builtins.str]]],
|
|
3863
|
+
container_name: pulumi.Input[_builtins.str],
|
|
3864
|
+
image: pulumi.Input[_builtins.str]):
|
|
2881
3865
|
"""
|
|
2882
|
-
:param pulumi.Input[Sequence[pulumi.Input[str]]] commands: The entry point of a container.
|
|
2883
|
-
:param pulumi.Input[str] container_name: The name of a container.
|
|
2884
|
-
:param pulumi.Input[str] image: The image name of a container.
|
|
3866
|
+
:param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] commands: The entry point of a container.
|
|
3867
|
+
:param pulumi.Input[_builtins.str] container_name: The name of a container.
|
|
3868
|
+
:param pulumi.Input[_builtins.str] image: The image name of a container.
|
|
2885
3869
|
"""
|
|
2886
3870
|
pulumi.set(__self__, "commands", commands)
|
|
2887
3871
|
pulumi.set(__self__, "container_name", container_name)
|
|
2888
3872
|
pulumi.set(__self__, "image", image)
|
|
2889
3873
|
|
|
2890
|
-
@property
|
|
3874
|
+
@_builtins.property
|
|
2891
3875
|
@pulumi.getter
|
|
2892
|
-
def commands(self) -> pulumi.Input[Sequence[pulumi.Input[str]]]:
|
|
3876
|
+
def commands(self) -> pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]:
|
|
2893
3877
|
"""
|
|
2894
3878
|
The entry point of a container.
|
|
2895
3879
|
"""
|
|
2896
3880
|
return pulumi.get(self, "commands")
|
|
2897
3881
|
|
|
2898
3882
|
@commands.setter
|
|
2899
|
-
def commands(self, value: pulumi.Input[Sequence[pulumi.Input[str]]]):
|
|
3883
|
+
def commands(self, value: pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]):
|
|
2900
3884
|
pulumi.set(self, "commands", value)
|
|
2901
3885
|
|
|
2902
|
-
@property
|
|
3886
|
+
@_builtins.property
|
|
2903
3887
|
@pulumi.getter(name="containerName")
|
|
2904
|
-
def container_name(self) -> pulumi.Input[str]:
|
|
3888
|
+
def container_name(self) -> pulumi.Input[_builtins.str]:
|
|
2905
3889
|
"""
|
|
2906
3890
|
The name of a container.
|
|
2907
3891
|
"""
|
|
2908
3892
|
return pulumi.get(self, "container_name")
|
|
2909
3893
|
|
|
2910
3894
|
@container_name.setter
|
|
2911
|
-
def container_name(self, value: pulumi.Input[str]):
|
|
3895
|
+
def container_name(self, value: pulumi.Input[_builtins.str]):
|
|
2912
3896
|
pulumi.set(self, "container_name", value)
|
|
2913
3897
|
|
|
2914
|
-
@property
|
|
3898
|
+
@_builtins.property
|
|
2915
3899
|
@pulumi.getter
|
|
2916
|
-
def image(self) -> pulumi.Input[str]:
|
|
3900
|
+
def image(self) -> pulumi.Input[_builtins.str]:
|
|
2917
3901
|
"""
|
|
2918
3902
|
The image name of a container.
|
|
2919
3903
|
"""
|
|
2920
3904
|
return pulumi.get(self, "image")
|
|
2921
3905
|
|
|
2922
3906
|
@image.setter
|
|
2923
|
-
def image(self, value: pulumi.Input[str]):
|
|
3907
|
+
def image(self, value: pulumi.Input[_builtins.str]):
|
|
2924
3908
|
pulumi.set(self, "image", value)
|
|
2925
3909
|
|
|
2926
3910
|
|
|
3911
|
+
if not MYPY:
|
|
3912
|
+
class VerificationTemplateMetricProviderNewRelicArgsDict(TypedDict):
|
|
3913
|
+
new_relic_query: pulumi.Input[_builtins.str]
|
|
3914
|
+
"""
|
|
3915
|
+
A raw newrelic NRQL query to perform.
|
|
3916
|
+
"""
|
|
3917
|
+
profile: NotRequired[pulumi.Input[_builtins.str]]
|
|
3918
|
+
"""
|
|
3919
|
+
The name of the secret holding NR account configuration.
|
|
3920
|
+
"""
|
|
3921
|
+
elif False:
|
|
3922
|
+
VerificationTemplateMetricProviderNewRelicArgsDict: TypeAlias = Mapping[str, Any]
|
|
3923
|
+
|
|
2927
3924
|
@pulumi.input_type
|
|
2928
3925
|
class VerificationTemplateMetricProviderNewRelicArgs:
|
|
2929
3926
|
def __init__(__self__, *,
|
|
2930
|
-
new_relic_query: pulumi.Input[str],
|
|
2931
|
-
profile: Optional[pulumi.Input[str]] = None):
|
|
3927
|
+
new_relic_query: pulumi.Input[_builtins.str],
|
|
3928
|
+
profile: Optional[pulumi.Input[_builtins.str]] = None):
|
|
2932
3929
|
"""
|
|
2933
|
-
:param pulumi.Input[str] new_relic_query: A raw newrelic NRQL query to perform.
|
|
2934
|
-
:param pulumi.Input[str] profile: The name of the secret holding NR account configuration.
|
|
3930
|
+
:param pulumi.Input[_builtins.str] new_relic_query: A raw newrelic NRQL query to perform.
|
|
3931
|
+
:param pulumi.Input[_builtins.str] profile: The name of the secret holding NR account configuration.
|
|
2935
3932
|
"""
|
|
2936
3933
|
pulumi.set(__self__, "new_relic_query", new_relic_query)
|
|
2937
3934
|
if profile is not None:
|
|
2938
3935
|
pulumi.set(__self__, "profile", profile)
|
|
2939
3936
|
|
|
2940
|
-
@property
|
|
3937
|
+
@_builtins.property
|
|
2941
3938
|
@pulumi.getter(name="newRelicQuery")
|
|
2942
|
-
def new_relic_query(self) -> pulumi.Input[str]:
|
|
3939
|
+
def new_relic_query(self) -> pulumi.Input[_builtins.str]:
|
|
2943
3940
|
"""
|
|
2944
3941
|
A raw newrelic NRQL query to perform.
|
|
2945
3942
|
"""
|
|
2946
3943
|
return pulumi.get(self, "new_relic_query")
|
|
2947
3944
|
|
|
2948
3945
|
@new_relic_query.setter
|
|
2949
|
-
def new_relic_query(self, value: pulumi.Input[str]):
|
|
3946
|
+
def new_relic_query(self, value: pulumi.Input[_builtins.str]):
|
|
2950
3947
|
pulumi.set(self, "new_relic_query", value)
|
|
2951
3948
|
|
|
2952
|
-
@property
|
|
3949
|
+
@_builtins.property
|
|
2953
3950
|
@pulumi.getter
|
|
2954
|
-
def profile(self) -> Optional[pulumi.Input[str]]:
|
|
3951
|
+
def profile(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
2955
3952
|
"""
|
|
2956
3953
|
The name of the secret holding NR account configuration.
|
|
2957
3954
|
"""
|
|
2958
3955
|
return pulumi.get(self, "profile")
|
|
2959
3956
|
|
|
2960
3957
|
@profile.setter
|
|
2961
|
-
def profile(self, value: Optional[pulumi.Input[str]]):
|
|
3958
|
+
def profile(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
2962
3959
|
pulumi.set(self, "profile", value)
|
|
2963
3960
|
|
|
2964
3961
|
|
|
3962
|
+
if not MYPY:
|
|
3963
|
+
class VerificationTemplateMetricProviderPrometheusArgsDict(TypedDict):
|
|
3964
|
+
prometheus_query: pulumi.Input[_builtins.str]
|
|
3965
|
+
"""
|
|
3966
|
+
A request for information retrieved from Prometheus.
|
|
3967
|
+
"""
|
|
3968
|
+
elif False:
|
|
3969
|
+
VerificationTemplateMetricProviderPrometheusArgsDict: TypeAlias = Mapping[str, Any]
|
|
3970
|
+
|
|
2965
3971
|
@pulumi.input_type
|
|
2966
3972
|
class VerificationTemplateMetricProviderPrometheusArgs:
|
|
2967
3973
|
def __init__(__self__, *,
|
|
2968
|
-
prometheus_query: pulumi.Input[str]):
|
|
3974
|
+
prometheus_query: pulumi.Input[_builtins.str]):
|
|
3975
|
+
"""
|
|
3976
|
+
:param pulumi.Input[_builtins.str] prometheus_query: A request for information retrieved from Prometheus.
|
|
3977
|
+
"""
|
|
2969
3978
|
pulumi.set(__self__, "prometheus_query", prometheus_query)
|
|
2970
3979
|
|
|
2971
|
-
@property
|
|
3980
|
+
@_builtins.property
|
|
2972
3981
|
@pulumi.getter(name="prometheusQuery")
|
|
2973
|
-
def prometheus_query(self) -> pulumi.Input[str]:
|
|
3982
|
+
def prometheus_query(self) -> pulumi.Input[_builtins.str]:
|
|
3983
|
+
"""
|
|
3984
|
+
A request for information retrieved from Prometheus.
|
|
3985
|
+
"""
|
|
2974
3986
|
return pulumi.get(self, "prometheus_query")
|
|
2975
3987
|
|
|
2976
3988
|
@prometheus_query.setter
|
|
2977
|
-
def prometheus_query(self, value: pulumi.Input[str]):
|
|
3989
|
+
def prometheus_query(self, value: pulumi.Input[_builtins.str]):
|
|
2978
3990
|
pulumi.set(self, "prometheus_query", value)
|
|
2979
3991
|
|
|
2980
3992
|
|
|
3993
|
+
if not MYPY:
|
|
3994
|
+
class VerificationTemplateMetricProviderWebArgsDict(TypedDict):
|
|
3995
|
+
url: pulumi.Input[_builtins.str]
|
|
3996
|
+
"""
|
|
3997
|
+
The address of the web metric.
|
|
3998
|
+
"""
|
|
3999
|
+
body: NotRequired[pulumi.Input[_builtins.str]]
|
|
4000
|
+
"""
|
|
4001
|
+
The body of the web metric.
|
|
4002
|
+
"""
|
|
4003
|
+
insecure: NotRequired[pulumi.Input[_builtins.bool]]
|
|
4004
|
+
"""
|
|
4005
|
+
Skips host TLS verification.
|
|
4006
|
+
"""
|
|
4007
|
+
json_path: NotRequired[pulumi.Input[_builtins.str]]
|
|
4008
|
+
"""
|
|
4009
|
+
A JSON Path to use as the result variable. Default is "{$}"
|
|
4010
|
+
"""
|
|
4011
|
+
method: NotRequired[pulumi.Input[_builtins.str]]
|
|
4012
|
+
"""
|
|
4013
|
+
The method of the web metric. Enum: "GET" "POST" "PUT"
|
|
4014
|
+
"""
|
|
4015
|
+
timeout_seconds: NotRequired[pulumi.Input[_builtins.int]]
|
|
4016
|
+
"""
|
|
4017
|
+
The timeout for the request in seconds. Default is 10.
|
|
4018
|
+
"""
|
|
4019
|
+
web_headers: NotRequired[pulumi.Input[Sequence[pulumi.Input['VerificationTemplateMetricProviderWebWebHeaderArgsDict']]]]
|
|
4020
|
+
"""
|
|
4021
|
+
Optional HTTP headers to use in the request.
|
|
4022
|
+
"""
|
|
4023
|
+
elif False:
|
|
4024
|
+
VerificationTemplateMetricProviderWebArgsDict: TypeAlias = Mapping[str, Any]
|
|
4025
|
+
|
|
2981
4026
|
@pulumi.input_type
|
|
2982
4027
|
class VerificationTemplateMetricProviderWebArgs:
|
|
2983
4028
|
def __init__(__self__, *,
|
|
2984
|
-
url: pulumi.Input[str],
|
|
2985
|
-
body: Optional[pulumi.Input[str]] = None,
|
|
2986
|
-
insecure: Optional[pulumi.Input[bool]] = None,
|
|
2987
|
-
json_path: Optional[pulumi.Input[str]] = None,
|
|
2988
|
-
method: Optional[pulumi.Input[str]] = None,
|
|
2989
|
-
timeout_seconds: Optional[pulumi.Input[int]] = None,
|
|
4029
|
+
url: pulumi.Input[_builtins.str],
|
|
4030
|
+
body: Optional[pulumi.Input[_builtins.str]] = None,
|
|
4031
|
+
insecure: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
4032
|
+
json_path: Optional[pulumi.Input[_builtins.str]] = None,
|
|
4033
|
+
method: Optional[pulumi.Input[_builtins.str]] = None,
|
|
4034
|
+
timeout_seconds: Optional[pulumi.Input[_builtins.int]] = None,
|
|
2990
4035
|
web_headers: Optional[pulumi.Input[Sequence[pulumi.Input['VerificationTemplateMetricProviderWebWebHeaderArgs']]]] = None):
|
|
2991
4036
|
"""
|
|
2992
|
-
:param pulumi.Input[str] url: The address of the web metric.
|
|
2993
|
-
:param pulumi.Input[str] body: The body of the web metric.
|
|
2994
|
-
:param pulumi.Input[bool] insecure: Skips host TLS verification.
|
|
2995
|
-
:param pulumi.Input[str] json_path: A JSON Path to use as the result variable. Default is "{$}"
|
|
2996
|
-
:param pulumi.Input[str] method: The method of the web metric. Enum: "GET" "POST" "PUT"
|
|
2997
|
-
:param pulumi.Input[int] timeout_seconds: The timeout for the request in seconds. Default is 10.
|
|
4037
|
+
:param pulumi.Input[_builtins.str] url: The address of the web metric.
|
|
4038
|
+
:param pulumi.Input[_builtins.str] body: The body of the web metric.
|
|
4039
|
+
:param pulumi.Input[_builtins.bool] insecure: Skips host TLS verification.
|
|
4040
|
+
:param pulumi.Input[_builtins.str] json_path: A JSON Path to use as the result variable. Default is "{$}"
|
|
4041
|
+
:param pulumi.Input[_builtins.str] method: The method of the web metric. Enum: "GET" "POST" "PUT"
|
|
4042
|
+
:param pulumi.Input[_builtins.int] timeout_seconds: The timeout for the request in seconds. Default is 10.
|
|
2998
4043
|
:param pulumi.Input[Sequence[pulumi.Input['VerificationTemplateMetricProviderWebWebHeaderArgs']]] web_headers: Optional HTTP headers to use in the request.
|
|
2999
4044
|
"""
|
|
3000
4045
|
pulumi.set(__self__, "url", url)
|
|
@@ -3011,79 +4056,79 @@ class VerificationTemplateMetricProviderWebArgs:
|
|
|
3011
4056
|
if web_headers is not None:
|
|
3012
4057
|
pulumi.set(__self__, "web_headers", web_headers)
|
|
3013
4058
|
|
|
3014
|
-
@property
|
|
4059
|
+
@_builtins.property
|
|
3015
4060
|
@pulumi.getter
|
|
3016
|
-
def url(self) -> pulumi.Input[str]:
|
|
4061
|
+
def url(self) -> pulumi.Input[_builtins.str]:
|
|
3017
4062
|
"""
|
|
3018
4063
|
The address of the web metric.
|
|
3019
4064
|
"""
|
|
3020
4065
|
return pulumi.get(self, "url")
|
|
3021
4066
|
|
|
3022
4067
|
@url.setter
|
|
3023
|
-
def url(self, value: pulumi.Input[str]):
|
|
4068
|
+
def url(self, value: pulumi.Input[_builtins.str]):
|
|
3024
4069
|
pulumi.set(self, "url", value)
|
|
3025
4070
|
|
|
3026
|
-
@property
|
|
4071
|
+
@_builtins.property
|
|
3027
4072
|
@pulumi.getter
|
|
3028
|
-
def body(self) -> Optional[pulumi.Input[str]]:
|
|
4073
|
+
def body(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
3029
4074
|
"""
|
|
3030
4075
|
The body of the web metric.
|
|
3031
4076
|
"""
|
|
3032
4077
|
return pulumi.get(self, "body")
|
|
3033
4078
|
|
|
3034
4079
|
@body.setter
|
|
3035
|
-
def body(self, value: Optional[pulumi.Input[str]]):
|
|
4080
|
+
def body(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
3036
4081
|
pulumi.set(self, "body", value)
|
|
3037
4082
|
|
|
3038
|
-
@property
|
|
4083
|
+
@_builtins.property
|
|
3039
4084
|
@pulumi.getter
|
|
3040
|
-
def insecure(self) -> Optional[pulumi.Input[bool]]:
|
|
4085
|
+
def insecure(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
3041
4086
|
"""
|
|
3042
4087
|
Skips host TLS verification.
|
|
3043
4088
|
"""
|
|
3044
4089
|
return pulumi.get(self, "insecure")
|
|
3045
4090
|
|
|
3046
4091
|
@insecure.setter
|
|
3047
|
-
def insecure(self, value: Optional[pulumi.Input[bool]]):
|
|
4092
|
+
def insecure(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
3048
4093
|
pulumi.set(self, "insecure", value)
|
|
3049
4094
|
|
|
3050
|
-
@property
|
|
4095
|
+
@_builtins.property
|
|
3051
4096
|
@pulumi.getter(name="jsonPath")
|
|
3052
|
-
def json_path(self) -> Optional[pulumi.Input[str]]:
|
|
4097
|
+
def json_path(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
3053
4098
|
"""
|
|
3054
4099
|
A JSON Path to use as the result variable. Default is "{$}"
|
|
3055
4100
|
"""
|
|
3056
4101
|
return pulumi.get(self, "json_path")
|
|
3057
4102
|
|
|
3058
4103
|
@json_path.setter
|
|
3059
|
-
def json_path(self, value: Optional[pulumi.Input[str]]):
|
|
4104
|
+
def json_path(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
3060
4105
|
pulumi.set(self, "json_path", value)
|
|
3061
4106
|
|
|
3062
|
-
@property
|
|
4107
|
+
@_builtins.property
|
|
3063
4108
|
@pulumi.getter
|
|
3064
|
-
def method(self) -> Optional[pulumi.Input[str]]:
|
|
4109
|
+
def method(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
3065
4110
|
"""
|
|
3066
4111
|
The method of the web metric. Enum: "GET" "POST" "PUT"
|
|
3067
4112
|
"""
|
|
3068
4113
|
return pulumi.get(self, "method")
|
|
3069
4114
|
|
|
3070
4115
|
@method.setter
|
|
3071
|
-
def method(self, value: Optional[pulumi.Input[str]]):
|
|
4116
|
+
def method(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
3072
4117
|
pulumi.set(self, "method", value)
|
|
3073
4118
|
|
|
3074
|
-
@property
|
|
4119
|
+
@_builtins.property
|
|
3075
4120
|
@pulumi.getter(name="timeoutSeconds")
|
|
3076
|
-
def timeout_seconds(self) -> Optional[pulumi.Input[int]]:
|
|
4121
|
+
def timeout_seconds(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
3077
4122
|
"""
|
|
3078
4123
|
The timeout for the request in seconds. Default is 10.
|
|
3079
4124
|
"""
|
|
3080
4125
|
return pulumi.get(self, "timeout_seconds")
|
|
3081
4126
|
|
|
3082
4127
|
@timeout_seconds.setter
|
|
3083
|
-
def timeout_seconds(self, value: Optional[pulumi.Input[int]]):
|
|
4128
|
+
def timeout_seconds(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
3084
4129
|
pulumi.set(self, "timeout_seconds", value)
|
|
3085
4130
|
|
|
3086
|
-
@property
|
|
4131
|
+
@_builtins.property
|
|
3087
4132
|
@pulumi.getter(name="webHeaders")
|
|
3088
4133
|
def web_headers(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['VerificationTemplateMetricProviderWebWebHeaderArgs']]]]:
|
|
3089
4134
|
"""
|
|
@@ -3096,40 +4141,53 @@ class VerificationTemplateMetricProviderWebArgs:
|
|
|
3096
4141
|
pulumi.set(self, "web_headers", value)
|
|
3097
4142
|
|
|
3098
4143
|
|
|
4144
|
+
if not MYPY:
|
|
4145
|
+
class VerificationTemplateMetricProviderWebWebHeaderArgsDict(TypedDict):
|
|
4146
|
+
web_header_key: pulumi.Input[_builtins.str]
|
|
4147
|
+
"""
|
|
4148
|
+
The name of a header
|
|
4149
|
+
"""
|
|
4150
|
+
web_header_value: pulumi.Input[_builtins.str]
|
|
4151
|
+
"""
|
|
4152
|
+
The value of a header
|
|
4153
|
+
"""
|
|
4154
|
+
elif False:
|
|
4155
|
+
VerificationTemplateMetricProviderWebWebHeaderArgsDict: TypeAlias = Mapping[str, Any]
|
|
4156
|
+
|
|
3099
4157
|
@pulumi.input_type
|
|
3100
4158
|
class VerificationTemplateMetricProviderWebWebHeaderArgs:
|
|
3101
4159
|
def __init__(__self__, *,
|
|
3102
|
-
web_header_key: pulumi.Input[str],
|
|
3103
|
-
web_header_value: pulumi.Input[str]):
|
|
4160
|
+
web_header_key: pulumi.Input[_builtins.str],
|
|
4161
|
+
web_header_value: pulumi.Input[_builtins.str]):
|
|
3104
4162
|
"""
|
|
3105
|
-
:param pulumi.Input[str] web_header_key: The name of a header
|
|
3106
|
-
:param pulumi.Input[str] web_header_value: The value of a header
|
|
4163
|
+
:param pulumi.Input[_builtins.str] web_header_key: The name of a header
|
|
4164
|
+
:param pulumi.Input[_builtins.str] web_header_value: The value of a header
|
|
3107
4165
|
"""
|
|
3108
4166
|
pulumi.set(__self__, "web_header_key", web_header_key)
|
|
3109
4167
|
pulumi.set(__self__, "web_header_value", web_header_value)
|
|
3110
4168
|
|
|
3111
|
-
@property
|
|
4169
|
+
@_builtins.property
|
|
3112
4170
|
@pulumi.getter(name="webHeaderKey")
|
|
3113
|
-
def web_header_key(self) -> pulumi.Input[str]:
|
|
4171
|
+
def web_header_key(self) -> pulumi.Input[_builtins.str]:
|
|
3114
4172
|
"""
|
|
3115
4173
|
The name of a header
|
|
3116
4174
|
"""
|
|
3117
4175
|
return pulumi.get(self, "web_header_key")
|
|
3118
4176
|
|
|
3119
4177
|
@web_header_key.setter
|
|
3120
|
-
def web_header_key(self, value: pulumi.Input[str]):
|
|
4178
|
+
def web_header_key(self, value: pulumi.Input[_builtins.str]):
|
|
3121
4179
|
pulumi.set(self, "web_header_key", value)
|
|
3122
4180
|
|
|
3123
|
-
@property
|
|
4181
|
+
@_builtins.property
|
|
3124
4182
|
@pulumi.getter(name="webHeaderValue")
|
|
3125
|
-
def web_header_value(self) -> pulumi.Input[str]:
|
|
4183
|
+
def web_header_value(self) -> pulumi.Input[_builtins.str]:
|
|
3126
4184
|
"""
|
|
3127
4185
|
The value of a header
|
|
3128
4186
|
"""
|
|
3129
4187
|
return pulumi.get(self, "web_header_value")
|
|
3130
4188
|
|
|
3131
4189
|
@web_header_value.setter
|
|
3132
|
-
def web_header_value(self, value: pulumi.Input[str]):
|
|
4190
|
+
def web_header_value(self, value: pulumi.Input[_builtins.str]):
|
|
3133
4191
|
pulumi.set(self, "web_header_value", value)
|
|
3134
4192
|
|
|
3135
4193
|
|