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,12 +1,17 @@
|
|
|
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
|
from . import outputs
|
|
12
17
|
from ._inputs import *
|
|
@@ -17,53 +22,81 @@ __all__ = ['OceanRightSizingRuleArgs', 'OceanRightSizingRule']
|
|
|
17
22
|
class OceanRightSizingRuleArgs:
|
|
18
23
|
def __init__(__self__, *,
|
|
19
24
|
recommendation_application_intervals: pulumi.Input[Sequence[pulumi.Input['OceanRightSizingRuleRecommendationApplicationIntervalArgs']]],
|
|
20
|
-
rule_name: pulumi.Input[str],
|
|
25
|
+
rule_name: pulumi.Input[_builtins.str],
|
|
21
26
|
attach_workloads: Optional[pulumi.Input[Sequence[pulumi.Input['OceanRightSizingRuleAttachWorkloadArgs']]]] = None,
|
|
27
|
+
auto_apply_definitions: Optional[pulumi.Input[Sequence[pulumi.Input['OceanRightSizingRuleAutoApplyDefinitionArgs']]]] = None,
|
|
22
28
|
detach_workloads: Optional[pulumi.Input[Sequence[pulumi.Input['OceanRightSizingRuleDetachWorkloadArgs']]]] = None,
|
|
23
|
-
|
|
29
|
+
downside_only: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
30
|
+
exclude_preliminary_recommendations: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
31
|
+
ocean_id: Optional[pulumi.Input[_builtins.str]] = None,
|
|
24
32
|
recommendation_application_boundaries: Optional[pulumi.Input[Sequence[pulumi.Input['OceanRightSizingRuleRecommendationApplicationBoundaryArgs']]]] = None,
|
|
33
|
+
recommendation_application_hpas: Optional[pulumi.Input[Sequence[pulumi.Input['OceanRightSizingRuleRecommendationApplicationHpaArgs']]]] = None,
|
|
25
34
|
recommendation_application_min_thresholds: Optional[pulumi.Input[Sequence[pulumi.Input['OceanRightSizingRuleRecommendationApplicationMinThresholdArgs']]]] = None,
|
|
26
35
|
recommendation_application_overhead_values: Optional[pulumi.Input[Sequence[pulumi.Input['OceanRightSizingRuleRecommendationApplicationOverheadValueArgs']]]] = None,
|
|
27
|
-
|
|
36
|
+
restart_replicas: Optional[pulumi.Input[_builtins.str]] = None):
|
|
28
37
|
"""
|
|
29
38
|
The set of arguments for constructing a OceanRightSizingRule resource.
|
|
39
|
+
:param pulumi.Input[Sequence[pulumi.Input['OceanRightSizingRuleRecommendationApplicationIntervalArgs']]] recommendation_application_intervals: Determines the Ocean Rightsizing rule recommendation application intervals.
|
|
40
|
+
:param pulumi.Input[_builtins.str] rule_name: The unique name of the rule.
|
|
41
|
+
:param pulumi.Input[Sequence[pulumi.Input['OceanRightSizingRuleAutoApplyDefinitionArgs']]] auto_apply_definitions: Ocean Rightsizing Rule Auto Apply Configuration.
|
|
42
|
+
:param pulumi.Input[_builtins.bool] exclude_preliminary_recommendations: Exclude preliminary recommendations (recommendations based on less than 4 full days of data).
|
|
43
|
+
:param pulumi.Input[_builtins.str] ocean_id: Identifier of the Ocean cluster.
|
|
44
|
+
:param pulumi.Input[Sequence[pulumi.Input['OceanRightSizingRuleRecommendationApplicationBoundaryArgs']]] recommendation_application_boundaries: Determines the Ocean Rightsizing rule recommendation application boundaries.
|
|
45
|
+
:param pulumi.Input[Sequence[pulumi.Input['OceanRightSizingRuleRecommendationApplicationHpaArgs']]] recommendation_application_hpas: HPA Rightsizing Rule Recommendation Configuration
|
|
46
|
+
:param pulumi.Input[Sequence[pulumi.Input['OceanRightSizingRuleRecommendationApplicationMinThresholdArgs']]] recommendation_application_min_thresholds: Determines the extent of difference between current request and recommendation to trigger a change in percentage.
|
|
47
|
+
:param pulumi.Input[Sequence[pulumi.Input['OceanRightSizingRuleRecommendationApplicationOverheadValueArgs']]] recommendation_application_overhead_values: Determines the Ocean Rightsizing rule recommendation application overhead values.
|
|
48
|
+
:param pulumi.Input[_builtins.str] restart_replicas: Valid values: "MORE_THAN_ONE_REPLICA" "ALL_MANIFEST" "NO_RESTART". Enable to sequentially restart pod batches according to recommendations, for all pods, only more than 1 replica, or not any pod.
|
|
30
49
|
"""
|
|
31
50
|
pulumi.set(__self__, "recommendation_application_intervals", recommendation_application_intervals)
|
|
32
51
|
pulumi.set(__self__, "rule_name", rule_name)
|
|
33
52
|
if attach_workloads is not None:
|
|
34
53
|
pulumi.set(__self__, "attach_workloads", attach_workloads)
|
|
54
|
+
if auto_apply_definitions is not None:
|
|
55
|
+
pulumi.set(__self__, "auto_apply_definitions", auto_apply_definitions)
|
|
35
56
|
if detach_workloads is not None:
|
|
36
57
|
pulumi.set(__self__, "detach_workloads", detach_workloads)
|
|
58
|
+
if downside_only is not None:
|
|
59
|
+
pulumi.set(__self__, "downside_only", downside_only)
|
|
60
|
+
if exclude_preliminary_recommendations is not None:
|
|
61
|
+
pulumi.set(__self__, "exclude_preliminary_recommendations", exclude_preliminary_recommendations)
|
|
37
62
|
if ocean_id is not None:
|
|
38
63
|
pulumi.set(__self__, "ocean_id", ocean_id)
|
|
39
64
|
if recommendation_application_boundaries is not None:
|
|
40
65
|
pulumi.set(__self__, "recommendation_application_boundaries", recommendation_application_boundaries)
|
|
66
|
+
if recommendation_application_hpas is not None:
|
|
67
|
+
pulumi.set(__self__, "recommendation_application_hpas", recommendation_application_hpas)
|
|
41
68
|
if recommendation_application_min_thresholds is not None:
|
|
42
69
|
pulumi.set(__self__, "recommendation_application_min_thresholds", recommendation_application_min_thresholds)
|
|
43
70
|
if recommendation_application_overhead_values is not None:
|
|
44
71
|
pulumi.set(__self__, "recommendation_application_overhead_values", recommendation_application_overhead_values)
|
|
45
|
-
if
|
|
46
|
-
pulumi.set(__self__, "
|
|
72
|
+
if restart_replicas is not None:
|
|
73
|
+
pulumi.set(__self__, "restart_replicas", restart_replicas)
|
|
47
74
|
|
|
48
|
-
@property
|
|
75
|
+
@_builtins.property
|
|
49
76
|
@pulumi.getter(name="recommendationApplicationIntervals")
|
|
50
77
|
def recommendation_application_intervals(self) -> pulumi.Input[Sequence[pulumi.Input['OceanRightSizingRuleRecommendationApplicationIntervalArgs']]]:
|
|
78
|
+
"""
|
|
79
|
+
Determines the Ocean Rightsizing rule recommendation application intervals.
|
|
80
|
+
"""
|
|
51
81
|
return pulumi.get(self, "recommendation_application_intervals")
|
|
52
82
|
|
|
53
83
|
@recommendation_application_intervals.setter
|
|
54
84
|
def recommendation_application_intervals(self, value: pulumi.Input[Sequence[pulumi.Input['OceanRightSizingRuleRecommendationApplicationIntervalArgs']]]):
|
|
55
85
|
pulumi.set(self, "recommendation_application_intervals", value)
|
|
56
86
|
|
|
57
|
-
@property
|
|
87
|
+
@_builtins.property
|
|
58
88
|
@pulumi.getter(name="ruleName")
|
|
59
|
-
def rule_name(self) -> pulumi.Input[str]:
|
|
89
|
+
def rule_name(self) -> pulumi.Input[_builtins.str]:
|
|
90
|
+
"""
|
|
91
|
+
The unique name of the rule.
|
|
92
|
+
"""
|
|
60
93
|
return pulumi.get(self, "rule_name")
|
|
61
94
|
|
|
62
95
|
@rule_name.setter
|
|
63
|
-
def rule_name(self, value: pulumi.Input[str]):
|
|
96
|
+
def rule_name(self, value: pulumi.Input[_builtins.str]):
|
|
64
97
|
pulumi.set(self, "rule_name", value)
|
|
65
98
|
|
|
66
|
-
@property
|
|
99
|
+
@_builtins.property
|
|
67
100
|
@pulumi.getter(name="attachWorkloads")
|
|
68
101
|
def attach_workloads(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['OceanRightSizingRuleAttachWorkloadArgs']]]]:
|
|
69
102
|
return pulumi.get(self, "attach_workloads")
|
|
@@ -72,7 +105,19 @@ class OceanRightSizingRuleArgs:
|
|
|
72
105
|
def attach_workloads(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['OceanRightSizingRuleAttachWorkloadArgs']]]]):
|
|
73
106
|
pulumi.set(self, "attach_workloads", value)
|
|
74
107
|
|
|
75
|
-
@property
|
|
108
|
+
@_builtins.property
|
|
109
|
+
@pulumi.getter(name="autoApplyDefinitions")
|
|
110
|
+
def auto_apply_definitions(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['OceanRightSizingRuleAutoApplyDefinitionArgs']]]]:
|
|
111
|
+
"""
|
|
112
|
+
Ocean Rightsizing Rule Auto Apply Configuration.
|
|
113
|
+
"""
|
|
114
|
+
return pulumi.get(self, "auto_apply_definitions")
|
|
115
|
+
|
|
116
|
+
@auto_apply_definitions.setter
|
|
117
|
+
def auto_apply_definitions(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['OceanRightSizingRuleAutoApplyDefinitionArgs']]]]):
|
|
118
|
+
pulumi.set(self, "auto_apply_definitions", value)
|
|
119
|
+
|
|
120
|
+
@_builtins.property
|
|
76
121
|
@pulumi.getter(name="detachWorkloads")
|
|
77
122
|
def detach_workloads(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['OceanRightSizingRuleDetachWorkloadArgs']]]]:
|
|
78
123
|
return pulumi.get(self, "detach_workloads")
|
|
@@ -81,87 +126,157 @@ class OceanRightSizingRuleArgs:
|
|
|
81
126
|
def detach_workloads(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['OceanRightSizingRuleDetachWorkloadArgs']]]]):
|
|
82
127
|
pulumi.set(self, "detach_workloads", value)
|
|
83
128
|
|
|
84
|
-
@property
|
|
129
|
+
@_builtins.property
|
|
130
|
+
@pulumi.getter(name="downsideOnly")
|
|
131
|
+
def downside_only(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
132
|
+
return pulumi.get(self, "downside_only")
|
|
133
|
+
|
|
134
|
+
@downside_only.setter
|
|
135
|
+
def downside_only(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
136
|
+
pulumi.set(self, "downside_only", value)
|
|
137
|
+
|
|
138
|
+
@_builtins.property
|
|
139
|
+
@pulumi.getter(name="excludePreliminaryRecommendations")
|
|
140
|
+
def exclude_preliminary_recommendations(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
141
|
+
"""
|
|
142
|
+
Exclude preliminary recommendations (recommendations based on less than 4 full days of data).
|
|
143
|
+
"""
|
|
144
|
+
return pulumi.get(self, "exclude_preliminary_recommendations")
|
|
145
|
+
|
|
146
|
+
@exclude_preliminary_recommendations.setter
|
|
147
|
+
def exclude_preliminary_recommendations(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
148
|
+
pulumi.set(self, "exclude_preliminary_recommendations", value)
|
|
149
|
+
|
|
150
|
+
@_builtins.property
|
|
85
151
|
@pulumi.getter(name="oceanId")
|
|
86
|
-
def ocean_id(self) -> Optional[pulumi.Input[str]]:
|
|
152
|
+
def ocean_id(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
153
|
+
"""
|
|
154
|
+
Identifier of the Ocean cluster.
|
|
155
|
+
"""
|
|
87
156
|
return pulumi.get(self, "ocean_id")
|
|
88
157
|
|
|
89
158
|
@ocean_id.setter
|
|
90
|
-
def ocean_id(self, value: Optional[pulumi.Input[str]]):
|
|
159
|
+
def ocean_id(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
91
160
|
pulumi.set(self, "ocean_id", value)
|
|
92
161
|
|
|
93
|
-
@property
|
|
162
|
+
@_builtins.property
|
|
94
163
|
@pulumi.getter(name="recommendationApplicationBoundaries")
|
|
95
164
|
def recommendation_application_boundaries(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['OceanRightSizingRuleRecommendationApplicationBoundaryArgs']]]]:
|
|
165
|
+
"""
|
|
166
|
+
Determines the Ocean Rightsizing rule recommendation application boundaries.
|
|
167
|
+
"""
|
|
96
168
|
return pulumi.get(self, "recommendation_application_boundaries")
|
|
97
169
|
|
|
98
170
|
@recommendation_application_boundaries.setter
|
|
99
171
|
def recommendation_application_boundaries(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['OceanRightSizingRuleRecommendationApplicationBoundaryArgs']]]]):
|
|
100
172
|
pulumi.set(self, "recommendation_application_boundaries", value)
|
|
101
173
|
|
|
102
|
-
@property
|
|
174
|
+
@_builtins.property
|
|
175
|
+
@pulumi.getter(name="recommendationApplicationHpas")
|
|
176
|
+
def recommendation_application_hpas(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['OceanRightSizingRuleRecommendationApplicationHpaArgs']]]]:
|
|
177
|
+
"""
|
|
178
|
+
HPA Rightsizing Rule Recommendation Configuration
|
|
179
|
+
"""
|
|
180
|
+
return pulumi.get(self, "recommendation_application_hpas")
|
|
181
|
+
|
|
182
|
+
@recommendation_application_hpas.setter
|
|
183
|
+
def recommendation_application_hpas(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['OceanRightSizingRuleRecommendationApplicationHpaArgs']]]]):
|
|
184
|
+
pulumi.set(self, "recommendation_application_hpas", value)
|
|
185
|
+
|
|
186
|
+
@_builtins.property
|
|
103
187
|
@pulumi.getter(name="recommendationApplicationMinThresholds")
|
|
104
188
|
def recommendation_application_min_thresholds(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['OceanRightSizingRuleRecommendationApplicationMinThresholdArgs']]]]:
|
|
189
|
+
"""
|
|
190
|
+
Determines the extent of difference between current request and recommendation to trigger a change in percentage.
|
|
191
|
+
"""
|
|
105
192
|
return pulumi.get(self, "recommendation_application_min_thresholds")
|
|
106
193
|
|
|
107
194
|
@recommendation_application_min_thresholds.setter
|
|
108
195
|
def recommendation_application_min_thresholds(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['OceanRightSizingRuleRecommendationApplicationMinThresholdArgs']]]]):
|
|
109
196
|
pulumi.set(self, "recommendation_application_min_thresholds", value)
|
|
110
197
|
|
|
111
|
-
@property
|
|
198
|
+
@_builtins.property
|
|
112
199
|
@pulumi.getter(name="recommendationApplicationOverheadValues")
|
|
113
200
|
def recommendation_application_overhead_values(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['OceanRightSizingRuleRecommendationApplicationOverheadValueArgs']]]]:
|
|
201
|
+
"""
|
|
202
|
+
Determines the Ocean Rightsizing rule recommendation application overhead values.
|
|
203
|
+
"""
|
|
114
204
|
return pulumi.get(self, "recommendation_application_overhead_values")
|
|
115
205
|
|
|
116
206
|
@recommendation_application_overhead_values.setter
|
|
117
207
|
def recommendation_application_overhead_values(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['OceanRightSizingRuleRecommendationApplicationOverheadValueArgs']]]]):
|
|
118
208
|
pulumi.set(self, "recommendation_application_overhead_values", value)
|
|
119
209
|
|
|
120
|
-
@property
|
|
121
|
-
@pulumi.getter(name="
|
|
122
|
-
def
|
|
123
|
-
|
|
210
|
+
@_builtins.property
|
|
211
|
+
@pulumi.getter(name="restartReplicas")
|
|
212
|
+
def restart_replicas(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
213
|
+
"""
|
|
214
|
+
Valid values: "MORE_THAN_ONE_REPLICA" "ALL_MANIFEST" "NO_RESTART". Enable to sequentially restart pod batches according to recommendations, for all pods, only more than 1 replica, or not any pod.
|
|
215
|
+
"""
|
|
216
|
+
return pulumi.get(self, "restart_replicas")
|
|
124
217
|
|
|
125
|
-
@
|
|
126
|
-
def
|
|
127
|
-
pulumi.set(self, "
|
|
218
|
+
@restart_replicas.setter
|
|
219
|
+
def restart_replicas(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
220
|
+
pulumi.set(self, "restart_replicas", value)
|
|
128
221
|
|
|
129
222
|
|
|
130
223
|
@pulumi.input_type
|
|
131
224
|
class _OceanRightSizingRuleState:
|
|
132
225
|
def __init__(__self__, *,
|
|
133
226
|
attach_workloads: Optional[pulumi.Input[Sequence[pulumi.Input['OceanRightSizingRuleAttachWorkloadArgs']]]] = None,
|
|
227
|
+
auto_apply_definitions: Optional[pulumi.Input[Sequence[pulumi.Input['OceanRightSizingRuleAutoApplyDefinitionArgs']]]] = None,
|
|
134
228
|
detach_workloads: Optional[pulumi.Input[Sequence[pulumi.Input['OceanRightSizingRuleDetachWorkloadArgs']]]] = None,
|
|
135
|
-
|
|
229
|
+
downside_only: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
230
|
+
exclude_preliminary_recommendations: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
231
|
+
ocean_id: Optional[pulumi.Input[_builtins.str]] = None,
|
|
136
232
|
recommendation_application_boundaries: Optional[pulumi.Input[Sequence[pulumi.Input['OceanRightSizingRuleRecommendationApplicationBoundaryArgs']]]] = None,
|
|
233
|
+
recommendation_application_hpas: Optional[pulumi.Input[Sequence[pulumi.Input['OceanRightSizingRuleRecommendationApplicationHpaArgs']]]] = None,
|
|
137
234
|
recommendation_application_intervals: Optional[pulumi.Input[Sequence[pulumi.Input['OceanRightSizingRuleRecommendationApplicationIntervalArgs']]]] = None,
|
|
138
235
|
recommendation_application_min_thresholds: Optional[pulumi.Input[Sequence[pulumi.Input['OceanRightSizingRuleRecommendationApplicationMinThresholdArgs']]]] = None,
|
|
139
236
|
recommendation_application_overhead_values: Optional[pulumi.Input[Sequence[pulumi.Input['OceanRightSizingRuleRecommendationApplicationOverheadValueArgs']]]] = None,
|
|
140
|
-
|
|
141
|
-
rule_name: Optional[pulumi.Input[str]] = None):
|
|
237
|
+
restart_replicas: Optional[pulumi.Input[_builtins.str]] = None,
|
|
238
|
+
rule_name: Optional[pulumi.Input[_builtins.str]] = None):
|
|
142
239
|
"""
|
|
143
240
|
Input properties used for looking up and filtering OceanRightSizingRule resources.
|
|
241
|
+
:param pulumi.Input[Sequence[pulumi.Input['OceanRightSizingRuleAutoApplyDefinitionArgs']]] auto_apply_definitions: Ocean Rightsizing Rule Auto Apply Configuration.
|
|
242
|
+
:param pulumi.Input[_builtins.bool] exclude_preliminary_recommendations: Exclude preliminary recommendations (recommendations based on less than 4 full days of data).
|
|
243
|
+
:param pulumi.Input[_builtins.str] ocean_id: Identifier of the Ocean cluster.
|
|
244
|
+
:param pulumi.Input[Sequence[pulumi.Input['OceanRightSizingRuleRecommendationApplicationBoundaryArgs']]] recommendation_application_boundaries: Determines the Ocean Rightsizing rule recommendation application boundaries.
|
|
245
|
+
:param pulumi.Input[Sequence[pulumi.Input['OceanRightSizingRuleRecommendationApplicationHpaArgs']]] recommendation_application_hpas: HPA Rightsizing Rule Recommendation Configuration
|
|
246
|
+
:param pulumi.Input[Sequence[pulumi.Input['OceanRightSizingRuleRecommendationApplicationIntervalArgs']]] recommendation_application_intervals: Determines the Ocean Rightsizing rule recommendation application intervals.
|
|
247
|
+
:param pulumi.Input[Sequence[pulumi.Input['OceanRightSizingRuleRecommendationApplicationMinThresholdArgs']]] recommendation_application_min_thresholds: Determines the extent of difference between current request and recommendation to trigger a change in percentage.
|
|
248
|
+
:param pulumi.Input[Sequence[pulumi.Input['OceanRightSizingRuleRecommendationApplicationOverheadValueArgs']]] recommendation_application_overhead_values: Determines the Ocean Rightsizing rule recommendation application overhead values.
|
|
249
|
+
:param pulumi.Input[_builtins.str] restart_replicas: Valid values: "MORE_THAN_ONE_REPLICA" "ALL_MANIFEST" "NO_RESTART". Enable to sequentially restart pod batches according to recommendations, for all pods, only more than 1 replica, or not any pod.
|
|
250
|
+
:param pulumi.Input[_builtins.str] rule_name: The unique name of the rule.
|
|
144
251
|
"""
|
|
145
252
|
if attach_workloads is not None:
|
|
146
253
|
pulumi.set(__self__, "attach_workloads", attach_workloads)
|
|
254
|
+
if auto_apply_definitions is not None:
|
|
255
|
+
pulumi.set(__self__, "auto_apply_definitions", auto_apply_definitions)
|
|
147
256
|
if detach_workloads is not None:
|
|
148
257
|
pulumi.set(__self__, "detach_workloads", detach_workloads)
|
|
258
|
+
if downside_only is not None:
|
|
259
|
+
pulumi.set(__self__, "downside_only", downside_only)
|
|
260
|
+
if exclude_preliminary_recommendations is not None:
|
|
261
|
+
pulumi.set(__self__, "exclude_preliminary_recommendations", exclude_preliminary_recommendations)
|
|
149
262
|
if ocean_id is not None:
|
|
150
263
|
pulumi.set(__self__, "ocean_id", ocean_id)
|
|
151
264
|
if recommendation_application_boundaries is not None:
|
|
152
265
|
pulumi.set(__self__, "recommendation_application_boundaries", recommendation_application_boundaries)
|
|
266
|
+
if recommendation_application_hpas is not None:
|
|
267
|
+
pulumi.set(__self__, "recommendation_application_hpas", recommendation_application_hpas)
|
|
153
268
|
if recommendation_application_intervals is not None:
|
|
154
269
|
pulumi.set(__self__, "recommendation_application_intervals", recommendation_application_intervals)
|
|
155
270
|
if recommendation_application_min_thresholds is not None:
|
|
156
271
|
pulumi.set(__self__, "recommendation_application_min_thresholds", recommendation_application_min_thresholds)
|
|
157
272
|
if recommendation_application_overhead_values is not None:
|
|
158
273
|
pulumi.set(__self__, "recommendation_application_overhead_values", recommendation_application_overhead_values)
|
|
159
|
-
if
|
|
160
|
-
pulumi.set(__self__, "
|
|
274
|
+
if restart_replicas is not None:
|
|
275
|
+
pulumi.set(__self__, "restart_replicas", restart_replicas)
|
|
161
276
|
if rule_name is not None:
|
|
162
277
|
pulumi.set(__self__, "rule_name", rule_name)
|
|
163
278
|
|
|
164
|
-
@property
|
|
279
|
+
@_builtins.property
|
|
165
280
|
@pulumi.getter(name="attachWorkloads")
|
|
166
281
|
def attach_workloads(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['OceanRightSizingRuleAttachWorkloadArgs']]]]:
|
|
167
282
|
return pulumi.get(self, "attach_workloads")
|
|
@@ -170,7 +285,19 @@ class _OceanRightSizingRuleState:
|
|
|
170
285
|
def attach_workloads(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['OceanRightSizingRuleAttachWorkloadArgs']]]]):
|
|
171
286
|
pulumi.set(self, "attach_workloads", value)
|
|
172
287
|
|
|
173
|
-
@property
|
|
288
|
+
@_builtins.property
|
|
289
|
+
@pulumi.getter(name="autoApplyDefinitions")
|
|
290
|
+
def auto_apply_definitions(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['OceanRightSizingRuleAutoApplyDefinitionArgs']]]]:
|
|
291
|
+
"""
|
|
292
|
+
Ocean Rightsizing Rule Auto Apply Configuration.
|
|
293
|
+
"""
|
|
294
|
+
return pulumi.get(self, "auto_apply_definitions")
|
|
295
|
+
|
|
296
|
+
@auto_apply_definitions.setter
|
|
297
|
+
def auto_apply_definitions(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['OceanRightSizingRuleAutoApplyDefinitionArgs']]]]):
|
|
298
|
+
pulumi.set(self, "auto_apply_definitions", value)
|
|
299
|
+
|
|
300
|
+
@_builtins.property
|
|
174
301
|
@pulumi.getter(name="detachWorkloads")
|
|
175
302
|
def detach_workloads(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['OceanRightSizingRuleDetachWorkloadArgs']]]]:
|
|
176
303
|
return pulumi.get(self, "detach_workloads")
|
|
@@ -179,89 +306,232 @@ class _OceanRightSizingRuleState:
|
|
|
179
306
|
def detach_workloads(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['OceanRightSizingRuleDetachWorkloadArgs']]]]):
|
|
180
307
|
pulumi.set(self, "detach_workloads", value)
|
|
181
308
|
|
|
182
|
-
@property
|
|
309
|
+
@_builtins.property
|
|
310
|
+
@pulumi.getter(name="downsideOnly")
|
|
311
|
+
def downside_only(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
312
|
+
return pulumi.get(self, "downside_only")
|
|
313
|
+
|
|
314
|
+
@downside_only.setter
|
|
315
|
+
def downside_only(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
316
|
+
pulumi.set(self, "downside_only", value)
|
|
317
|
+
|
|
318
|
+
@_builtins.property
|
|
319
|
+
@pulumi.getter(name="excludePreliminaryRecommendations")
|
|
320
|
+
def exclude_preliminary_recommendations(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
321
|
+
"""
|
|
322
|
+
Exclude preliminary recommendations (recommendations based on less than 4 full days of data).
|
|
323
|
+
"""
|
|
324
|
+
return pulumi.get(self, "exclude_preliminary_recommendations")
|
|
325
|
+
|
|
326
|
+
@exclude_preliminary_recommendations.setter
|
|
327
|
+
def exclude_preliminary_recommendations(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
328
|
+
pulumi.set(self, "exclude_preliminary_recommendations", value)
|
|
329
|
+
|
|
330
|
+
@_builtins.property
|
|
183
331
|
@pulumi.getter(name="oceanId")
|
|
184
|
-
def ocean_id(self) -> Optional[pulumi.Input[str]]:
|
|
332
|
+
def ocean_id(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
333
|
+
"""
|
|
334
|
+
Identifier of the Ocean cluster.
|
|
335
|
+
"""
|
|
185
336
|
return pulumi.get(self, "ocean_id")
|
|
186
337
|
|
|
187
338
|
@ocean_id.setter
|
|
188
|
-
def ocean_id(self, value: Optional[pulumi.Input[str]]):
|
|
339
|
+
def ocean_id(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
189
340
|
pulumi.set(self, "ocean_id", value)
|
|
190
341
|
|
|
191
|
-
@property
|
|
342
|
+
@_builtins.property
|
|
192
343
|
@pulumi.getter(name="recommendationApplicationBoundaries")
|
|
193
344
|
def recommendation_application_boundaries(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['OceanRightSizingRuleRecommendationApplicationBoundaryArgs']]]]:
|
|
345
|
+
"""
|
|
346
|
+
Determines the Ocean Rightsizing rule recommendation application boundaries.
|
|
347
|
+
"""
|
|
194
348
|
return pulumi.get(self, "recommendation_application_boundaries")
|
|
195
349
|
|
|
196
350
|
@recommendation_application_boundaries.setter
|
|
197
351
|
def recommendation_application_boundaries(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['OceanRightSizingRuleRecommendationApplicationBoundaryArgs']]]]):
|
|
198
352
|
pulumi.set(self, "recommendation_application_boundaries", value)
|
|
199
353
|
|
|
200
|
-
@property
|
|
354
|
+
@_builtins.property
|
|
355
|
+
@pulumi.getter(name="recommendationApplicationHpas")
|
|
356
|
+
def recommendation_application_hpas(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['OceanRightSizingRuleRecommendationApplicationHpaArgs']]]]:
|
|
357
|
+
"""
|
|
358
|
+
HPA Rightsizing Rule Recommendation Configuration
|
|
359
|
+
"""
|
|
360
|
+
return pulumi.get(self, "recommendation_application_hpas")
|
|
361
|
+
|
|
362
|
+
@recommendation_application_hpas.setter
|
|
363
|
+
def recommendation_application_hpas(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['OceanRightSizingRuleRecommendationApplicationHpaArgs']]]]):
|
|
364
|
+
pulumi.set(self, "recommendation_application_hpas", value)
|
|
365
|
+
|
|
366
|
+
@_builtins.property
|
|
201
367
|
@pulumi.getter(name="recommendationApplicationIntervals")
|
|
202
368
|
def recommendation_application_intervals(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['OceanRightSizingRuleRecommendationApplicationIntervalArgs']]]]:
|
|
369
|
+
"""
|
|
370
|
+
Determines the Ocean Rightsizing rule recommendation application intervals.
|
|
371
|
+
"""
|
|
203
372
|
return pulumi.get(self, "recommendation_application_intervals")
|
|
204
373
|
|
|
205
374
|
@recommendation_application_intervals.setter
|
|
206
375
|
def recommendation_application_intervals(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['OceanRightSizingRuleRecommendationApplicationIntervalArgs']]]]):
|
|
207
376
|
pulumi.set(self, "recommendation_application_intervals", value)
|
|
208
377
|
|
|
209
|
-
@property
|
|
378
|
+
@_builtins.property
|
|
210
379
|
@pulumi.getter(name="recommendationApplicationMinThresholds")
|
|
211
380
|
def recommendation_application_min_thresholds(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['OceanRightSizingRuleRecommendationApplicationMinThresholdArgs']]]]:
|
|
381
|
+
"""
|
|
382
|
+
Determines the extent of difference between current request and recommendation to trigger a change in percentage.
|
|
383
|
+
"""
|
|
212
384
|
return pulumi.get(self, "recommendation_application_min_thresholds")
|
|
213
385
|
|
|
214
386
|
@recommendation_application_min_thresholds.setter
|
|
215
387
|
def recommendation_application_min_thresholds(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['OceanRightSizingRuleRecommendationApplicationMinThresholdArgs']]]]):
|
|
216
388
|
pulumi.set(self, "recommendation_application_min_thresholds", value)
|
|
217
389
|
|
|
218
|
-
@property
|
|
390
|
+
@_builtins.property
|
|
219
391
|
@pulumi.getter(name="recommendationApplicationOverheadValues")
|
|
220
392
|
def recommendation_application_overhead_values(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['OceanRightSizingRuleRecommendationApplicationOverheadValueArgs']]]]:
|
|
393
|
+
"""
|
|
394
|
+
Determines the Ocean Rightsizing rule recommendation application overhead values.
|
|
395
|
+
"""
|
|
221
396
|
return pulumi.get(self, "recommendation_application_overhead_values")
|
|
222
397
|
|
|
223
398
|
@recommendation_application_overhead_values.setter
|
|
224
399
|
def recommendation_application_overhead_values(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['OceanRightSizingRuleRecommendationApplicationOverheadValueArgs']]]]):
|
|
225
400
|
pulumi.set(self, "recommendation_application_overhead_values", value)
|
|
226
401
|
|
|
227
|
-
@property
|
|
228
|
-
@pulumi.getter(name="
|
|
229
|
-
def
|
|
230
|
-
|
|
402
|
+
@_builtins.property
|
|
403
|
+
@pulumi.getter(name="restartReplicas")
|
|
404
|
+
def restart_replicas(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
405
|
+
"""
|
|
406
|
+
Valid values: "MORE_THAN_ONE_REPLICA" "ALL_MANIFEST" "NO_RESTART". Enable to sequentially restart pod batches according to recommendations, for all pods, only more than 1 replica, or not any pod.
|
|
407
|
+
"""
|
|
408
|
+
return pulumi.get(self, "restart_replicas")
|
|
231
409
|
|
|
232
|
-
@
|
|
233
|
-
def
|
|
234
|
-
pulumi.set(self, "
|
|
410
|
+
@restart_replicas.setter
|
|
411
|
+
def restart_replicas(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
412
|
+
pulumi.set(self, "restart_replicas", value)
|
|
235
413
|
|
|
236
|
-
@property
|
|
414
|
+
@_builtins.property
|
|
237
415
|
@pulumi.getter(name="ruleName")
|
|
238
|
-
def rule_name(self) -> Optional[pulumi.Input[str]]:
|
|
416
|
+
def rule_name(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
417
|
+
"""
|
|
418
|
+
The unique name of the rule.
|
|
419
|
+
"""
|
|
239
420
|
return pulumi.get(self, "rule_name")
|
|
240
421
|
|
|
241
422
|
@rule_name.setter
|
|
242
|
-
def rule_name(self, value: Optional[pulumi.Input[str]]):
|
|
423
|
+
def rule_name(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
243
424
|
pulumi.set(self, "rule_name", value)
|
|
244
425
|
|
|
245
426
|
|
|
427
|
+
@pulumi.type_token("spotinst:index/oceanRightSizingRule:OceanRightSizingRule")
|
|
246
428
|
class OceanRightSizingRule(pulumi.CustomResource):
|
|
247
429
|
@overload
|
|
248
430
|
def __init__(__self__,
|
|
249
431
|
resource_name: str,
|
|
250
432
|
opts: Optional[pulumi.ResourceOptions] = None,
|
|
251
|
-
attach_workloads: Optional[pulumi.Input[Sequence[pulumi.Input[
|
|
252
|
-
|
|
253
|
-
|
|
254
|
-
|
|
255
|
-
|
|
256
|
-
|
|
257
|
-
|
|
258
|
-
|
|
259
|
-
|
|
433
|
+
attach_workloads: Optional[pulumi.Input[Sequence[pulumi.Input[Union['OceanRightSizingRuleAttachWorkloadArgs', 'OceanRightSizingRuleAttachWorkloadArgsDict']]]]] = None,
|
|
434
|
+
auto_apply_definitions: Optional[pulumi.Input[Sequence[pulumi.Input[Union['OceanRightSizingRuleAutoApplyDefinitionArgs', 'OceanRightSizingRuleAutoApplyDefinitionArgsDict']]]]] = None,
|
|
435
|
+
detach_workloads: Optional[pulumi.Input[Sequence[pulumi.Input[Union['OceanRightSizingRuleDetachWorkloadArgs', 'OceanRightSizingRuleDetachWorkloadArgsDict']]]]] = None,
|
|
436
|
+
downside_only: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
437
|
+
exclude_preliminary_recommendations: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
438
|
+
ocean_id: Optional[pulumi.Input[_builtins.str]] = None,
|
|
439
|
+
recommendation_application_boundaries: Optional[pulumi.Input[Sequence[pulumi.Input[Union['OceanRightSizingRuleRecommendationApplicationBoundaryArgs', 'OceanRightSizingRuleRecommendationApplicationBoundaryArgsDict']]]]] = None,
|
|
440
|
+
recommendation_application_hpas: Optional[pulumi.Input[Sequence[pulumi.Input[Union['OceanRightSizingRuleRecommendationApplicationHpaArgs', 'OceanRightSizingRuleRecommendationApplicationHpaArgsDict']]]]] = None,
|
|
441
|
+
recommendation_application_intervals: Optional[pulumi.Input[Sequence[pulumi.Input[Union['OceanRightSizingRuleRecommendationApplicationIntervalArgs', 'OceanRightSizingRuleRecommendationApplicationIntervalArgsDict']]]]] = None,
|
|
442
|
+
recommendation_application_min_thresholds: Optional[pulumi.Input[Sequence[pulumi.Input[Union['OceanRightSizingRuleRecommendationApplicationMinThresholdArgs', 'OceanRightSizingRuleRecommendationApplicationMinThresholdArgsDict']]]]] = None,
|
|
443
|
+
recommendation_application_overhead_values: Optional[pulumi.Input[Sequence[pulumi.Input[Union['OceanRightSizingRuleRecommendationApplicationOverheadValueArgs', 'OceanRightSizingRuleRecommendationApplicationOverheadValueArgsDict']]]]] = None,
|
|
444
|
+
restart_replicas: Optional[pulumi.Input[_builtins.str]] = None,
|
|
445
|
+
rule_name: Optional[pulumi.Input[_builtins.str]] = None,
|
|
260
446
|
__props__=None):
|
|
261
447
|
"""
|
|
262
|
-
|
|
448
|
+
Manages a Spotinst Ocean right sizing rule resource.
|
|
449
|
+
|
|
450
|
+
## Example Usage
|
|
451
|
+
|
|
452
|
+
```python
|
|
453
|
+
import pulumi
|
|
454
|
+
import pulumi_spotinst as spotinst
|
|
455
|
+
|
|
456
|
+
example = spotinst.OceanRightSizingRule("example",
|
|
457
|
+
ocean_id="o-123456",
|
|
458
|
+
rule_name="test-rule",
|
|
459
|
+
exclude_preliminary_recommendations=True,
|
|
460
|
+
restart_replicas="ALL_MANIFEST",
|
|
461
|
+
recommendation_application_hpas=[{
|
|
462
|
+
"allow_hpa_recommendations": True,
|
|
463
|
+
}],
|
|
464
|
+
recommendation_application_intervals=[
|
|
465
|
+
{
|
|
466
|
+
"repetition_basis": "WEEKLY",
|
|
467
|
+
"weekly_repetition_bases": [{
|
|
468
|
+
"interval_days": [
|
|
469
|
+
"MONDAY",
|
|
470
|
+
"WEDNESDAY",
|
|
471
|
+
],
|
|
472
|
+
"interval_hours_start_time": "12:00",
|
|
473
|
+
"interval_hours_end_time": "14:00",
|
|
474
|
+
}],
|
|
475
|
+
},
|
|
476
|
+
{
|
|
477
|
+
"repetition_basis": "MONTHLY",
|
|
478
|
+
"monthly_repetition_bases": [{
|
|
479
|
+
"interval_months": [
|
|
480
|
+
2,
|
|
481
|
+
6,
|
|
482
|
+
9,
|
|
483
|
+
],
|
|
484
|
+
"week_of_the_months": [
|
|
485
|
+
"FIRST",
|
|
486
|
+
"LAST",
|
|
487
|
+
],
|
|
488
|
+
"weekly_repetition_bases": [{
|
|
489
|
+
"interval_days": ["MONDAY"],
|
|
490
|
+
"interval_hours_start_time": "03:00",
|
|
491
|
+
"interval_hours_end_time": "04:00",
|
|
492
|
+
}],
|
|
493
|
+
}],
|
|
494
|
+
},
|
|
495
|
+
],
|
|
496
|
+
recommendation_application_boundaries=[{
|
|
497
|
+
"cpu_min": 120,
|
|
498
|
+
"cpu_max": 190,
|
|
499
|
+
"memory_min": 160,
|
|
500
|
+
"memory_max": 190,
|
|
501
|
+
}],
|
|
502
|
+
recommendation_application_min_thresholds=[{
|
|
503
|
+
"cpu_percentage": 0.412,
|
|
504
|
+
"memory_percentage": 0.36,
|
|
505
|
+
}],
|
|
506
|
+
recommendation_application_overhead_values=[{
|
|
507
|
+
"cpu_percentage": 0.8,
|
|
508
|
+
"memory_percentage": 0.5,
|
|
509
|
+
}],
|
|
510
|
+
auto_apply_definitions=[{
|
|
511
|
+
"enabled": True,
|
|
512
|
+
"namespaces": [
|
|
513
|
+
"kube-system",
|
|
514
|
+
"spot-system",
|
|
515
|
+
],
|
|
516
|
+
"labels": {
|
|
517
|
+
"k8s-app": "kube-proxy",
|
|
518
|
+
"app.kubernetes.io/name": "metrics-server",
|
|
519
|
+
},
|
|
520
|
+
}])
|
|
521
|
+
```
|
|
522
|
+
|
|
263
523
|
:param str resource_name: The name of the resource.
|
|
264
524
|
:param pulumi.ResourceOptions opts: Options for the resource.
|
|
525
|
+
:param pulumi.Input[Sequence[pulumi.Input[Union['OceanRightSizingRuleAutoApplyDefinitionArgs', 'OceanRightSizingRuleAutoApplyDefinitionArgsDict']]]] auto_apply_definitions: Ocean Rightsizing Rule Auto Apply Configuration.
|
|
526
|
+
:param pulumi.Input[_builtins.bool] exclude_preliminary_recommendations: Exclude preliminary recommendations (recommendations based on less than 4 full days of data).
|
|
527
|
+
:param pulumi.Input[_builtins.str] ocean_id: Identifier of the Ocean cluster.
|
|
528
|
+
:param pulumi.Input[Sequence[pulumi.Input[Union['OceanRightSizingRuleRecommendationApplicationBoundaryArgs', 'OceanRightSizingRuleRecommendationApplicationBoundaryArgsDict']]]] recommendation_application_boundaries: Determines the Ocean Rightsizing rule recommendation application boundaries.
|
|
529
|
+
:param pulumi.Input[Sequence[pulumi.Input[Union['OceanRightSizingRuleRecommendationApplicationHpaArgs', 'OceanRightSizingRuleRecommendationApplicationHpaArgsDict']]]] recommendation_application_hpas: HPA Rightsizing Rule Recommendation Configuration
|
|
530
|
+
:param pulumi.Input[Sequence[pulumi.Input[Union['OceanRightSizingRuleRecommendationApplicationIntervalArgs', 'OceanRightSizingRuleRecommendationApplicationIntervalArgsDict']]]] recommendation_application_intervals: Determines the Ocean Rightsizing rule recommendation application intervals.
|
|
531
|
+
:param pulumi.Input[Sequence[pulumi.Input[Union['OceanRightSizingRuleRecommendationApplicationMinThresholdArgs', 'OceanRightSizingRuleRecommendationApplicationMinThresholdArgsDict']]]] recommendation_application_min_thresholds: Determines the extent of difference between current request and recommendation to trigger a change in percentage.
|
|
532
|
+
:param pulumi.Input[Sequence[pulumi.Input[Union['OceanRightSizingRuleRecommendationApplicationOverheadValueArgs', 'OceanRightSizingRuleRecommendationApplicationOverheadValueArgsDict']]]] recommendation_application_overhead_values: Determines the Ocean Rightsizing rule recommendation application overhead values.
|
|
533
|
+
:param pulumi.Input[_builtins.str] restart_replicas: Valid values: "MORE_THAN_ONE_REPLICA" "ALL_MANIFEST" "NO_RESTART". Enable to sequentially restart pod batches according to recommendations, for all pods, only more than 1 replica, or not any pod.
|
|
534
|
+
:param pulumi.Input[_builtins.str] rule_name: The unique name of the rule.
|
|
265
535
|
"""
|
|
266
536
|
...
|
|
267
537
|
@overload
|
|
@@ -270,7 +540,81 @@ class OceanRightSizingRule(pulumi.CustomResource):
|
|
|
270
540
|
args: OceanRightSizingRuleArgs,
|
|
271
541
|
opts: Optional[pulumi.ResourceOptions] = None):
|
|
272
542
|
"""
|
|
273
|
-
|
|
543
|
+
Manages a Spotinst Ocean right sizing rule resource.
|
|
544
|
+
|
|
545
|
+
## Example Usage
|
|
546
|
+
|
|
547
|
+
```python
|
|
548
|
+
import pulumi
|
|
549
|
+
import pulumi_spotinst as spotinst
|
|
550
|
+
|
|
551
|
+
example = spotinst.OceanRightSizingRule("example",
|
|
552
|
+
ocean_id="o-123456",
|
|
553
|
+
rule_name="test-rule",
|
|
554
|
+
exclude_preliminary_recommendations=True,
|
|
555
|
+
restart_replicas="ALL_MANIFEST",
|
|
556
|
+
recommendation_application_hpas=[{
|
|
557
|
+
"allow_hpa_recommendations": True,
|
|
558
|
+
}],
|
|
559
|
+
recommendation_application_intervals=[
|
|
560
|
+
{
|
|
561
|
+
"repetition_basis": "WEEKLY",
|
|
562
|
+
"weekly_repetition_bases": [{
|
|
563
|
+
"interval_days": [
|
|
564
|
+
"MONDAY",
|
|
565
|
+
"WEDNESDAY",
|
|
566
|
+
],
|
|
567
|
+
"interval_hours_start_time": "12:00",
|
|
568
|
+
"interval_hours_end_time": "14:00",
|
|
569
|
+
}],
|
|
570
|
+
},
|
|
571
|
+
{
|
|
572
|
+
"repetition_basis": "MONTHLY",
|
|
573
|
+
"monthly_repetition_bases": [{
|
|
574
|
+
"interval_months": [
|
|
575
|
+
2,
|
|
576
|
+
6,
|
|
577
|
+
9,
|
|
578
|
+
],
|
|
579
|
+
"week_of_the_months": [
|
|
580
|
+
"FIRST",
|
|
581
|
+
"LAST",
|
|
582
|
+
],
|
|
583
|
+
"weekly_repetition_bases": [{
|
|
584
|
+
"interval_days": ["MONDAY"],
|
|
585
|
+
"interval_hours_start_time": "03:00",
|
|
586
|
+
"interval_hours_end_time": "04:00",
|
|
587
|
+
}],
|
|
588
|
+
}],
|
|
589
|
+
},
|
|
590
|
+
],
|
|
591
|
+
recommendation_application_boundaries=[{
|
|
592
|
+
"cpu_min": 120,
|
|
593
|
+
"cpu_max": 190,
|
|
594
|
+
"memory_min": 160,
|
|
595
|
+
"memory_max": 190,
|
|
596
|
+
}],
|
|
597
|
+
recommendation_application_min_thresholds=[{
|
|
598
|
+
"cpu_percentage": 0.412,
|
|
599
|
+
"memory_percentage": 0.36,
|
|
600
|
+
}],
|
|
601
|
+
recommendation_application_overhead_values=[{
|
|
602
|
+
"cpu_percentage": 0.8,
|
|
603
|
+
"memory_percentage": 0.5,
|
|
604
|
+
}],
|
|
605
|
+
auto_apply_definitions=[{
|
|
606
|
+
"enabled": True,
|
|
607
|
+
"namespaces": [
|
|
608
|
+
"kube-system",
|
|
609
|
+
"spot-system",
|
|
610
|
+
],
|
|
611
|
+
"labels": {
|
|
612
|
+
"k8s-app": "kube-proxy",
|
|
613
|
+
"app.kubernetes.io/name": "metrics-server",
|
|
614
|
+
},
|
|
615
|
+
}])
|
|
616
|
+
```
|
|
617
|
+
|
|
274
618
|
:param str resource_name: The name of the resource.
|
|
275
619
|
:param OceanRightSizingRuleArgs args: The arguments to use to populate this resource's properties.
|
|
276
620
|
:param pulumi.ResourceOptions opts: Options for the resource.
|
|
@@ -286,15 +630,19 @@ class OceanRightSizingRule(pulumi.CustomResource):
|
|
|
286
630
|
def _internal_init(__self__,
|
|
287
631
|
resource_name: str,
|
|
288
632
|
opts: Optional[pulumi.ResourceOptions] = None,
|
|
289
|
-
attach_workloads: Optional[pulumi.Input[Sequence[pulumi.Input[
|
|
290
|
-
|
|
291
|
-
|
|
292
|
-
|
|
293
|
-
|
|
294
|
-
|
|
295
|
-
|
|
296
|
-
|
|
297
|
-
|
|
633
|
+
attach_workloads: Optional[pulumi.Input[Sequence[pulumi.Input[Union['OceanRightSizingRuleAttachWorkloadArgs', 'OceanRightSizingRuleAttachWorkloadArgsDict']]]]] = None,
|
|
634
|
+
auto_apply_definitions: Optional[pulumi.Input[Sequence[pulumi.Input[Union['OceanRightSizingRuleAutoApplyDefinitionArgs', 'OceanRightSizingRuleAutoApplyDefinitionArgsDict']]]]] = None,
|
|
635
|
+
detach_workloads: Optional[pulumi.Input[Sequence[pulumi.Input[Union['OceanRightSizingRuleDetachWorkloadArgs', 'OceanRightSizingRuleDetachWorkloadArgsDict']]]]] = None,
|
|
636
|
+
downside_only: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
637
|
+
exclude_preliminary_recommendations: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
638
|
+
ocean_id: Optional[pulumi.Input[_builtins.str]] = None,
|
|
639
|
+
recommendation_application_boundaries: Optional[pulumi.Input[Sequence[pulumi.Input[Union['OceanRightSizingRuleRecommendationApplicationBoundaryArgs', 'OceanRightSizingRuleRecommendationApplicationBoundaryArgsDict']]]]] = None,
|
|
640
|
+
recommendation_application_hpas: Optional[pulumi.Input[Sequence[pulumi.Input[Union['OceanRightSizingRuleRecommendationApplicationHpaArgs', 'OceanRightSizingRuleRecommendationApplicationHpaArgsDict']]]]] = None,
|
|
641
|
+
recommendation_application_intervals: Optional[pulumi.Input[Sequence[pulumi.Input[Union['OceanRightSizingRuleRecommendationApplicationIntervalArgs', 'OceanRightSizingRuleRecommendationApplicationIntervalArgsDict']]]]] = None,
|
|
642
|
+
recommendation_application_min_thresholds: Optional[pulumi.Input[Sequence[pulumi.Input[Union['OceanRightSizingRuleRecommendationApplicationMinThresholdArgs', 'OceanRightSizingRuleRecommendationApplicationMinThresholdArgsDict']]]]] = None,
|
|
643
|
+
recommendation_application_overhead_values: Optional[pulumi.Input[Sequence[pulumi.Input[Union['OceanRightSizingRuleRecommendationApplicationOverheadValueArgs', 'OceanRightSizingRuleRecommendationApplicationOverheadValueArgsDict']]]]] = None,
|
|
644
|
+
restart_replicas: Optional[pulumi.Input[_builtins.str]] = None,
|
|
645
|
+
rule_name: Optional[pulumi.Input[_builtins.str]] = None,
|
|
298
646
|
__props__=None):
|
|
299
647
|
opts = pulumi.ResourceOptions.merge(_utilities.get_resource_opts_defaults(), opts)
|
|
300
648
|
if not isinstance(opts, pulumi.ResourceOptions):
|
|
@@ -305,15 +653,19 @@ class OceanRightSizingRule(pulumi.CustomResource):
|
|
|
305
653
|
__props__ = OceanRightSizingRuleArgs.__new__(OceanRightSizingRuleArgs)
|
|
306
654
|
|
|
307
655
|
__props__.__dict__["attach_workloads"] = attach_workloads
|
|
656
|
+
__props__.__dict__["auto_apply_definitions"] = auto_apply_definitions
|
|
308
657
|
__props__.__dict__["detach_workloads"] = detach_workloads
|
|
658
|
+
__props__.__dict__["downside_only"] = downside_only
|
|
659
|
+
__props__.__dict__["exclude_preliminary_recommendations"] = exclude_preliminary_recommendations
|
|
309
660
|
__props__.__dict__["ocean_id"] = ocean_id
|
|
310
661
|
__props__.__dict__["recommendation_application_boundaries"] = recommendation_application_boundaries
|
|
662
|
+
__props__.__dict__["recommendation_application_hpas"] = recommendation_application_hpas
|
|
311
663
|
if recommendation_application_intervals is None and not opts.urn:
|
|
312
664
|
raise TypeError("Missing required property 'recommendation_application_intervals'")
|
|
313
665
|
__props__.__dict__["recommendation_application_intervals"] = recommendation_application_intervals
|
|
314
666
|
__props__.__dict__["recommendation_application_min_thresholds"] = recommendation_application_min_thresholds
|
|
315
667
|
__props__.__dict__["recommendation_application_overhead_values"] = recommendation_application_overhead_values
|
|
316
|
-
__props__.__dict__["
|
|
668
|
+
__props__.__dict__["restart_replicas"] = restart_replicas
|
|
317
669
|
if rule_name is None and not opts.urn:
|
|
318
670
|
raise TypeError("Missing required property 'rule_name'")
|
|
319
671
|
__props__.__dict__["rule_name"] = rule_name
|
|
@@ -327,15 +679,19 @@ class OceanRightSizingRule(pulumi.CustomResource):
|
|
|
327
679
|
def get(resource_name: str,
|
|
328
680
|
id: pulumi.Input[str],
|
|
329
681
|
opts: Optional[pulumi.ResourceOptions] = None,
|
|
330
|
-
attach_workloads: Optional[pulumi.Input[Sequence[pulumi.Input[
|
|
331
|
-
|
|
332
|
-
|
|
333
|
-
|
|
334
|
-
|
|
335
|
-
|
|
336
|
-
|
|
337
|
-
|
|
338
|
-
|
|
682
|
+
attach_workloads: Optional[pulumi.Input[Sequence[pulumi.Input[Union['OceanRightSizingRuleAttachWorkloadArgs', 'OceanRightSizingRuleAttachWorkloadArgsDict']]]]] = None,
|
|
683
|
+
auto_apply_definitions: Optional[pulumi.Input[Sequence[pulumi.Input[Union['OceanRightSizingRuleAutoApplyDefinitionArgs', 'OceanRightSizingRuleAutoApplyDefinitionArgsDict']]]]] = None,
|
|
684
|
+
detach_workloads: Optional[pulumi.Input[Sequence[pulumi.Input[Union['OceanRightSizingRuleDetachWorkloadArgs', 'OceanRightSizingRuleDetachWorkloadArgsDict']]]]] = None,
|
|
685
|
+
downside_only: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
686
|
+
exclude_preliminary_recommendations: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
687
|
+
ocean_id: Optional[pulumi.Input[_builtins.str]] = None,
|
|
688
|
+
recommendation_application_boundaries: Optional[pulumi.Input[Sequence[pulumi.Input[Union['OceanRightSizingRuleRecommendationApplicationBoundaryArgs', 'OceanRightSizingRuleRecommendationApplicationBoundaryArgsDict']]]]] = None,
|
|
689
|
+
recommendation_application_hpas: Optional[pulumi.Input[Sequence[pulumi.Input[Union['OceanRightSizingRuleRecommendationApplicationHpaArgs', 'OceanRightSizingRuleRecommendationApplicationHpaArgsDict']]]]] = None,
|
|
690
|
+
recommendation_application_intervals: Optional[pulumi.Input[Sequence[pulumi.Input[Union['OceanRightSizingRuleRecommendationApplicationIntervalArgs', 'OceanRightSizingRuleRecommendationApplicationIntervalArgsDict']]]]] = None,
|
|
691
|
+
recommendation_application_min_thresholds: Optional[pulumi.Input[Sequence[pulumi.Input[Union['OceanRightSizingRuleRecommendationApplicationMinThresholdArgs', 'OceanRightSizingRuleRecommendationApplicationMinThresholdArgsDict']]]]] = None,
|
|
692
|
+
recommendation_application_overhead_values: Optional[pulumi.Input[Sequence[pulumi.Input[Union['OceanRightSizingRuleRecommendationApplicationOverheadValueArgs', 'OceanRightSizingRuleRecommendationApplicationOverheadValueArgsDict']]]]] = None,
|
|
693
|
+
restart_replicas: Optional[pulumi.Input[_builtins.str]] = None,
|
|
694
|
+
rule_name: Optional[pulumi.Input[_builtins.str]] = None) -> 'OceanRightSizingRule':
|
|
339
695
|
"""
|
|
340
696
|
Get an existing OceanRightSizingRule resource's state with the given name, id, and optional extra
|
|
341
697
|
properties used to qualify the lookup.
|
|
@@ -343,64 +699,128 @@ class OceanRightSizingRule(pulumi.CustomResource):
|
|
|
343
699
|
:param str resource_name: The unique name of the resulting resource.
|
|
344
700
|
:param pulumi.Input[str] id: The unique provider ID of the resource to lookup.
|
|
345
701
|
:param pulumi.ResourceOptions opts: Options for the resource.
|
|
702
|
+
:param pulumi.Input[Sequence[pulumi.Input[Union['OceanRightSizingRuleAutoApplyDefinitionArgs', 'OceanRightSizingRuleAutoApplyDefinitionArgsDict']]]] auto_apply_definitions: Ocean Rightsizing Rule Auto Apply Configuration.
|
|
703
|
+
:param pulumi.Input[_builtins.bool] exclude_preliminary_recommendations: Exclude preliminary recommendations (recommendations based on less than 4 full days of data).
|
|
704
|
+
:param pulumi.Input[_builtins.str] ocean_id: Identifier of the Ocean cluster.
|
|
705
|
+
:param pulumi.Input[Sequence[pulumi.Input[Union['OceanRightSizingRuleRecommendationApplicationBoundaryArgs', 'OceanRightSizingRuleRecommendationApplicationBoundaryArgsDict']]]] recommendation_application_boundaries: Determines the Ocean Rightsizing rule recommendation application boundaries.
|
|
706
|
+
:param pulumi.Input[Sequence[pulumi.Input[Union['OceanRightSizingRuleRecommendationApplicationHpaArgs', 'OceanRightSizingRuleRecommendationApplicationHpaArgsDict']]]] recommendation_application_hpas: HPA Rightsizing Rule Recommendation Configuration
|
|
707
|
+
:param pulumi.Input[Sequence[pulumi.Input[Union['OceanRightSizingRuleRecommendationApplicationIntervalArgs', 'OceanRightSizingRuleRecommendationApplicationIntervalArgsDict']]]] recommendation_application_intervals: Determines the Ocean Rightsizing rule recommendation application intervals.
|
|
708
|
+
:param pulumi.Input[Sequence[pulumi.Input[Union['OceanRightSizingRuleRecommendationApplicationMinThresholdArgs', 'OceanRightSizingRuleRecommendationApplicationMinThresholdArgsDict']]]] recommendation_application_min_thresholds: Determines the extent of difference between current request and recommendation to trigger a change in percentage.
|
|
709
|
+
:param pulumi.Input[Sequence[pulumi.Input[Union['OceanRightSizingRuleRecommendationApplicationOverheadValueArgs', 'OceanRightSizingRuleRecommendationApplicationOverheadValueArgsDict']]]] recommendation_application_overhead_values: Determines the Ocean Rightsizing rule recommendation application overhead values.
|
|
710
|
+
:param pulumi.Input[_builtins.str] restart_replicas: Valid values: "MORE_THAN_ONE_REPLICA" "ALL_MANIFEST" "NO_RESTART". Enable to sequentially restart pod batches according to recommendations, for all pods, only more than 1 replica, or not any pod.
|
|
711
|
+
:param pulumi.Input[_builtins.str] rule_name: The unique name of the rule.
|
|
346
712
|
"""
|
|
347
713
|
opts = pulumi.ResourceOptions.merge(opts, pulumi.ResourceOptions(id=id))
|
|
348
714
|
|
|
349
715
|
__props__ = _OceanRightSizingRuleState.__new__(_OceanRightSizingRuleState)
|
|
350
716
|
|
|
351
717
|
__props__.__dict__["attach_workloads"] = attach_workloads
|
|
718
|
+
__props__.__dict__["auto_apply_definitions"] = auto_apply_definitions
|
|
352
719
|
__props__.__dict__["detach_workloads"] = detach_workloads
|
|
720
|
+
__props__.__dict__["downside_only"] = downside_only
|
|
721
|
+
__props__.__dict__["exclude_preliminary_recommendations"] = exclude_preliminary_recommendations
|
|
353
722
|
__props__.__dict__["ocean_id"] = ocean_id
|
|
354
723
|
__props__.__dict__["recommendation_application_boundaries"] = recommendation_application_boundaries
|
|
724
|
+
__props__.__dict__["recommendation_application_hpas"] = recommendation_application_hpas
|
|
355
725
|
__props__.__dict__["recommendation_application_intervals"] = recommendation_application_intervals
|
|
356
726
|
__props__.__dict__["recommendation_application_min_thresholds"] = recommendation_application_min_thresholds
|
|
357
727
|
__props__.__dict__["recommendation_application_overhead_values"] = recommendation_application_overhead_values
|
|
358
|
-
__props__.__dict__["
|
|
728
|
+
__props__.__dict__["restart_replicas"] = restart_replicas
|
|
359
729
|
__props__.__dict__["rule_name"] = rule_name
|
|
360
730
|
return OceanRightSizingRule(resource_name, opts=opts, __props__=__props__)
|
|
361
731
|
|
|
362
|
-
@property
|
|
732
|
+
@_builtins.property
|
|
363
733
|
@pulumi.getter(name="attachWorkloads")
|
|
364
734
|
def attach_workloads(self) -> pulumi.Output[Optional[Sequence['outputs.OceanRightSizingRuleAttachWorkload']]]:
|
|
365
735
|
return pulumi.get(self, "attach_workloads")
|
|
366
736
|
|
|
367
|
-
@property
|
|
737
|
+
@_builtins.property
|
|
738
|
+
@pulumi.getter(name="autoApplyDefinitions")
|
|
739
|
+
def auto_apply_definitions(self) -> pulumi.Output[Optional[Sequence['outputs.OceanRightSizingRuleAutoApplyDefinition']]]:
|
|
740
|
+
"""
|
|
741
|
+
Ocean Rightsizing Rule Auto Apply Configuration.
|
|
742
|
+
"""
|
|
743
|
+
return pulumi.get(self, "auto_apply_definitions")
|
|
744
|
+
|
|
745
|
+
@_builtins.property
|
|
368
746
|
@pulumi.getter(name="detachWorkloads")
|
|
369
747
|
def detach_workloads(self) -> pulumi.Output[Optional[Sequence['outputs.OceanRightSizingRuleDetachWorkload']]]:
|
|
370
748
|
return pulumi.get(self, "detach_workloads")
|
|
371
749
|
|
|
372
|
-
@property
|
|
750
|
+
@_builtins.property
|
|
751
|
+
@pulumi.getter(name="downsideOnly")
|
|
752
|
+
def downside_only(self) -> pulumi.Output[Optional[_builtins.bool]]:
|
|
753
|
+
return pulumi.get(self, "downside_only")
|
|
754
|
+
|
|
755
|
+
@_builtins.property
|
|
756
|
+
@pulumi.getter(name="excludePreliminaryRecommendations")
|
|
757
|
+
def exclude_preliminary_recommendations(self) -> pulumi.Output[Optional[_builtins.bool]]:
|
|
758
|
+
"""
|
|
759
|
+
Exclude preliminary recommendations (recommendations based on less than 4 full days of data).
|
|
760
|
+
"""
|
|
761
|
+
return pulumi.get(self, "exclude_preliminary_recommendations")
|
|
762
|
+
|
|
763
|
+
@_builtins.property
|
|
373
764
|
@pulumi.getter(name="oceanId")
|
|
374
|
-
def ocean_id(self) -> pulumi.Output[Optional[str]]:
|
|
765
|
+
def ocean_id(self) -> pulumi.Output[Optional[_builtins.str]]:
|
|
766
|
+
"""
|
|
767
|
+
Identifier of the Ocean cluster.
|
|
768
|
+
"""
|
|
375
769
|
return pulumi.get(self, "ocean_id")
|
|
376
770
|
|
|
377
|
-
@property
|
|
771
|
+
@_builtins.property
|
|
378
772
|
@pulumi.getter(name="recommendationApplicationBoundaries")
|
|
379
773
|
def recommendation_application_boundaries(self) -> pulumi.Output[Optional[Sequence['outputs.OceanRightSizingRuleRecommendationApplicationBoundary']]]:
|
|
774
|
+
"""
|
|
775
|
+
Determines the Ocean Rightsizing rule recommendation application boundaries.
|
|
776
|
+
"""
|
|
380
777
|
return pulumi.get(self, "recommendation_application_boundaries")
|
|
381
778
|
|
|
382
|
-
@property
|
|
779
|
+
@_builtins.property
|
|
780
|
+
@pulumi.getter(name="recommendationApplicationHpas")
|
|
781
|
+
def recommendation_application_hpas(self) -> pulumi.Output[Optional[Sequence['outputs.OceanRightSizingRuleRecommendationApplicationHpa']]]:
|
|
782
|
+
"""
|
|
783
|
+
HPA Rightsizing Rule Recommendation Configuration
|
|
784
|
+
"""
|
|
785
|
+
return pulumi.get(self, "recommendation_application_hpas")
|
|
786
|
+
|
|
787
|
+
@_builtins.property
|
|
383
788
|
@pulumi.getter(name="recommendationApplicationIntervals")
|
|
384
789
|
def recommendation_application_intervals(self) -> pulumi.Output[Sequence['outputs.OceanRightSizingRuleRecommendationApplicationInterval']]:
|
|
790
|
+
"""
|
|
791
|
+
Determines the Ocean Rightsizing rule recommendation application intervals.
|
|
792
|
+
"""
|
|
385
793
|
return pulumi.get(self, "recommendation_application_intervals")
|
|
386
794
|
|
|
387
|
-
@property
|
|
795
|
+
@_builtins.property
|
|
388
796
|
@pulumi.getter(name="recommendationApplicationMinThresholds")
|
|
389
797
|
def recommendation_application_min_thresholds(self) -> pulumi.Output[Optional[Sequence['outputs.OceanRightSizingRuleRecommendationApplicationMinThreshold']]]:
|
|
798
|
+
"""
|
|
799
|
+
Determines the extent of difference between current request and recommendation to trigger a change in percentage.
|
|
800
|
+
"""
|
|
390
801
|
return pulumi.get(self, "recommendation_application_min_thresholds")
|
|
391
802
|
|
|
392
|
-
@property
|
|
803
|
+
@_builtins.property
|
|
393
804
|
@pulumi.getter(name="recommendationApplicationOverheadValues")
|
|
394
805
|
def recommendation_application_overhead_values(self) -> pulumi.Output[Optional[Sequence['outputs.OceanRightSizingRuleRecommendationApplicationOverheadValue']]]:
|
|
806
|
+
"""
|
|
807
|
+
Determines the Ocean Rightsizing rule recommendation application overhead values.
|
|
808
|
+
"""
|
|
395
809
|
return pulumi.get(self, "recommendation_application_overhead_values")
|
|
396
810
|
|
|
397
|
-
@property
|
|
398
|
-
@pulumi.getter(name="
|
|
399
|
-
def
|
|
400
|
-
|
|
811
|
+
@_builtins.property
|
|
812
|
+
@pulumi.getter(name="restartReplicas")
|
|
813
|
+
def restart_replicas(self) -> pulumi.Output[Optional[_builtins.str]]:
|
|
814
|
+
"""
|
|
815
|
+
Valid values: "MORE_THAN_ONE_REPLICA" "ALL_MANIFEST" "NO_RESTART". Enable to sequentially restart pod batches according to recommendations, for all pods, only more than 1 replica, or not any pod.
|
|
816
|
+
"""
|
|
817
|
+
return pulumi.get(self, "restart_replicas")
|
|
401
818
|
|
|
402
|
-
@property
|
|
819
|
+
@_builtins.property
|
|
403
820
|
@pulumi.getter(name="ruleName")
|
|
404
|
-
def rule_name(self) -> pulumi.Output[str]:
|
|
821
|
+
def rule_name(self) -> pulumi.Output[_builtins.str]:
|
|
822
|
+
"""
|
|
823
|
+
The unique name of the rule.
|
|
824
|
+
"""
|
|
405
825
|
return pulumi.get(self, "rule_name")
|
|
406
826
|
|