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
pulumi_spotinst/spark/_inputs.py
CHANGED
|
@@ -1,65 +1,113 @@
|
|
|
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
|
'OceanComputeArgs',
|
|
19
|
+
'OceanComputeArgsDict',
|
|
14
20
|
'OceanIngressArgs',
|
|
21
|
+
'OceanIngressArgsDict',
|
|
15
22
|
'OceanIngressControllerArgs',
|
|
23
|
+
'OceanIngressControllerArgsDict',
|
|
16
24
|
'OceanIngressCustomEndpointArgs',
|
|
25
|
+
'OceanIngressCustomEndpointArgsDict',
|
|
17
26
|
'OceanIngressLoadBalancerArgs',
|
|
27
|
+
'OceanIngressLoadBalancerArgsDict',
|
|
18
28
|
'OceanIngressPrivateLinkArgs',
|
|
29
|
+
'OceanIngressPrivateLinkArgsDict',
|
|
19
30
|
'OceanLogCollectionArgs',
|
|
31
|
+
'OceanLogCollectionArgsDict',
|
|
20
32
|
'OceanSparkArgs',
|
|
33
|
+
'OceanSparkArgsDict',
|
|
21
34
|
'OceanWebhookArgs',
|
|
35
|
+
'OceanWebhookArgsDict',
|
|
36
|
+
'OceanWorkspacesArgs',
|
|
37
|
+
'OceanWorkspacesArgsDict',
|
|
38
|
+
'OceanWorkspacesStorageArgs',
|
|
39
|
+
'OceanWorkspacesStorageArgsDict',
|
|
40
|
+
'OceanWorkspacesStorageDefaultsArgs',
|
|
41
|
+
'OceanWorkspacesStorageDefaultsArgsDict',
|
|
22
42
|
]
|
|
23
43
|
|
|
44
|
+
MYPY = False
|
|
45
|
+
|
|
46
|
+
if not MYPY:
|
|
47
|
+
class OceanComputeArgsDict(TypedDict):
|
|
48
|
+
create_vngs: NotRequired[pulumi.Input[_builtins.bool]]
|
|
49
|
+
"""
|
|
50
|
+
- Enable/disable the creation of Ocean Spark VNGs during cluster creation.
|
|
51
|
+
"""
|
|
52
|
+
use_taints: NotRequired[pulumi.Input[_builtins.bool]]
|
|
53
|
+
"""
|
|
54
|
+
- Enable/disable Ocean Spark taints on the Ocean Spark VNGs. By default, Ocean Spark uses taints to prevent non-Spark workloads from running on Ocean Spark VNGs.
|
|
55
|
+
"""
|
|
56
|
+
elif False:
|
|
57
|
+
OceanComputeArgsDict: TypeAlias = Mapping[str, Any]
|
|
58
|
+
|
|
24
59
|
@pulumi.input_type
|
|
25
60
|
class OceanComputeArgs:
|
|
26
61
|
def __init__(__self__, *,
|
|
27
|
-
create_vngs: Optional[pulumi.Input[bool]] = None,
|
|
28
|
-
use_taints: Optional[pulumi.Input[bool]] = None):
|
|
62
|
+
create_vngs: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
63
|
+
use_taints: Optional[pulumi.Input[_builtins.bool]] = None):
|
|
29
64
|
"""
|
|
30
|
-
:param pulumi.Input[bool] create_vngs: - Enable/disable the creation of Ocean Spark VNGs during cluster creation.
|
|
31
|
-
:param pulumi.Input[bool] use_taints: - Enable/disable Ocean Spark taints on the Ocean Spark VNGs. By default, Ocean Spark uses taints to prevent non-Spark workloads from running on Ocean Spark VNGs.
|
|
65
|
+
:param pulumi.Input[_builtins.bool] create_vngs: - Enable/disable the creation of Ocean Spark VNGs during cluster creation.
|
|
66
|
+
:param pulumi.Input[_builtins.bool] use_taints: - Enable/disable Ocean Spark taints on the Ocean Spark VNGs. By default, Ocean Spark uses taints to prevent non-Spark workloads from running on Ocean Spark VNGs.
|
|
32
67
|
"""
|
|
33
68
|
if create_vngs is not None:
|
|
34
69
|
pulumi.set(__self__, "create_vngs", create_vngs)
|
|
35
70
|
if use_taints is not None:
|
|
36
71
|
pulumi.set(__self__, "use_taints", use_taints)
|
|
37
72
|
|
|
38
|
-
@property
|
|
73
|
+
@_builtins.property
|
|
39
74
|
@pulumi.getter(name="createVngs")
|
|
40
|
-
def create_vngs(self) -> Optional[pulumi.Input[bool]]:
|
|
75
|
+
def create_vngs(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
41
76
|
"""
|
|
42
77
|
- Enable/disable the creation of Ocean Spark VNGs during cluster creation.
|
|
43
78
|
"""
|
|
44
79
|
return pulumi.get(self, "create_vngs")
|
|
45
80
|
|
|
46
81
|
@create_vngs.setter
|
|
47
|
-
def create_vngs(self, value: Optional[pulumi.Input[bool]]):
|
|
82
|
+
def create_vngs(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
48
83
|
pulumi.set(self, "create_vngs", value)
|
|
49
84
|
|
|
50
|
-
@property
|
|
85
|
+
@_builtins.property
|
|
51
86
|
@pulumi.getter(name="useTaints")
|
|
52
|
-
def use_taints(self) -> Optional[pulumi.Input[bool]]:
|
|
87
|
+
def use_taints(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
53
88
|
"""
|
|
54
89
|
- Enable/disable Ocean Spark taints on the Ocean Spark VNGs. By default, Ocean Spark uses taints to prevent non-Spark workloads from running on Ocean Spark VNGs.
|
|
55
90
|
"""
|
|
56
91
|
return pulumi.get(self, "use_taints")
|
|
57
92
|
|
|
58
93
|
@use_taints.setter
|
|
59
|
-
def use_taints(self, value: Optional[pulumi.Input[bool]]):
|
|
94
|
+
def use_taints(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
60
95
|
pulumi.set(self, "use_taints", value)
|
|
61
96
|
|
|
62
97
|
|
|
98
|
+
if not MYPY:
|
|
99
|
+
class OceanIngressArgsDict(TypedDict):
|
|
100
|
+
controller: NotRequired[pulumi.Input['OceanIngressControllerArgsDict']]
|
|
101
|
+
custom_endpoint: NotRequired[pulumi.Input['OceanIngressCustomEndpointArgsDict']]
|
|
102
|
+
load_balancer: NotRequired[pulumi.Input['OceanIngressLoadBalancerArgsDict']]
|
|
103
|
+
private_link: NotRequired[pulumi.Input['OceanIngressPrivateLinkArgsDict']]
|
|
104
|
+
service_annotations: NotRequired[pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]]]
|
|
105
|
+
"""
|
|
106
|
+
- **DEPRECATED**: Use `load_balancer.service_annotations` instead.
|
|
107
|
+
"""
|
|
108
|
+
elif False:
|
|
109
|
+
OceanIngressArgsDict: TypeAlias = Mapping[str, Any]
|
|
110
|
+
|
|
63
111
|
@pulumi.input_type
|
|
64
112
|
class OceanIngressArgs:
|
|
65
113
|
def __init__(__self__, *,
|
|
@@ -67,9 +115,9 @@ class OceanIngressArgs:
|
|
|
67
115
|
custom_endpoint: Optional[pulumi.Input['OceanIngressCustomEndpointArgs']] = None,
|
|
68
116
|
load_balancer: Optional[pulumi.Input['OceanIngressLoadBalancerArgs']] = None,
|
|
69
117
|
private_link: Optional[pulumi.Input['OceanIngressPrivateLinkArgs']] = None,
|
|
70
|
-
service_annotations: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None):
|
|
118
|
+
service_annotations: Optional[pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]]] = None):
|
|
71
119
|
"""
|
|
72
|
-
:param pulumi.Input[Mapping[str, pulumi.Input[str]]] service_annotations: - **DEPRECATED**: Use `load_balancer.service_annotations` instead.
|
|
120
|
+
:param pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]] service_annotations: - **DEPRECATED**: Use `load_balancer.service_annotations` instead.
|
|
73
121
|
"""
|
|
74
122
|
if controller is not None:
|
|
75
123
|
pulumi.set(__self__, "controller", controller)
|
|
@@ -82,7 +130,7 @@ class OceanIngressArgs:
|
|
|
82
130
|
if service_annotations is not None:
|
|
83
131
|
pulumi.set(__self__, "service_annotations", service_annotations)
|
|
84
132
|
|
|
85
|
-
@property
|
|
133
|
+
@_builtins.property
|
|
86
134
|
@pulumi.getter
|
|
87
135
|
def controller(self) -> Optional[pulumi.Input['OceanIngressControllerArgs']]:
|
|
88
136
|
return pulumi.get(self, "controller")
|
|
@@ -91,7 +139,7 @@ class OceanIngressArgs:
|
|
|
91
139
|
def controller(self, value: Optional[pulumi.Input['OceanIngressControllerArgs']]):
|
|
92
140
|
pulumi.set(self, "controller", value)
|
|
93
141
|
|
|
94
|
-
@property
|
|
142
|
+
@_builtins.property
|
|
95
143
|
@pulumi.getter(name="customEndpoint")
|
|
96
144
|
def custom_endpoint(self) -> Optional[pulumi.Input['OceanIngressCustomEndpointArgs']]:
|
|
97
145
|
return pulumi.get(self, "custom_endpoint")
|
|
@@ -100,7 +148,7 @@ class OceanIngressArgs:
|
|
|
100
148
|
def custom_endpoint(self, value: Optional[pulumi.Input['OceanIngressCustomEndpointArgs']]):
|
|
101
149
|
pulumi.set(self, "custom_endpoint", value)
|
|
102
150
|
|
|
103
|
-
@property
|
|
151
|
+
@_builtins.property
|
|
104
152
|
@pulumi.getter(name="loadBalancer")
|
|
105
153
|
def load_balancer(self) -> Optional[pulumi.Input['OceanIngressLoadBalancerArgs']]:
|
|
106
154
|
return pulumi.get(self, "load_balancer")
|
|
@@ -109,7 +157,7 @@ class OceanIngressArgs:
|
|
|
109
157
|
def load_balancer(self, value: Optional[pulumi.Input['OceanIngressLoadBalancerArgs']]):
|
|
110
158
|
pulumi.set(self, "load_balancer", value)
|
|
111
159
|
|
|
112
|
-
@property
|
|
160
|
+
@_builtins.property
|
|
113
161
|
@pulumi.getter(name="privateLink")
|
|
114
162
|
def private_link(self) -> Optional[pulumi.Input['OceanIngressPrivateLinkArgs']]:
|
|
115
163
|
return pulumi.get(self, "private_link")
|
|
@@ -118,91 +166,130 @@ class OceanIngressArgs:
|
|
|
118
166
|
def private_link(self, value: Optional[pulumi.Input['OceanIngressPrivateLinkArgs']]):
|
|
119
167
|
pulumi.set(self, "private_link", value)
|
|
120
168
|
|
|
121
|
-
@property
|
|
169
|
+
@_builtins.property
|
|
122
170
|
@pulumi.getter(name="serviceAnnotations")
|
|
123
|
-
def service_annotations(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]:
|
|
171
|
+
def service_annotations(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]]]:
|
|
124
172
|
"""
|
|
125
173
|
- **DEPRECATED**: Use `load_balancer.service_annotations` instead.
|
|
126
174
|
"""
|
|
127
175
|
return pulumi.get(self, "service_annotations")
|
|
128
176
|
|
|
129
177
|
@service_annotations.setter
|
|
130
|
-
def service_annotations(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]):
|
|
178
|
+
def service_annotations(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]]]):
|
|
131
179
|
pulumi.set(self, "service_annotations", value)
|
|
132
180
|
|
|
133
181
|
|
|
182
|
+
if not MYPY:
|
|
183
|
+
class OceanIngressControllerArgsDict(TypedDict):
|
|
184
|
+
managed: NotRequired[pulumi.Input[_builtins.bool]]
|
|
185
|
+
"""
|
|
186
|
+
- Should an ingress controller managed by Ocean for Apache Spark be installed on the cluster.
|
|
187
|
+
"""
|
|
188
|
+
elif False:
|
|
189
|
+
OceanIngressControllerArgsDict: TypeAlias = Mapping[str, Any]
|
|
190
|
+
|
|
134
191
|
@pulumi.input_type
|
|
135
192
|
class OceanIngressControllerArgs:
|
|
136
193
|
def __init__(__self__, *,
|
|
137
|
-
managed: Optional[pulumi.Input[bool]] = None):
|
|
194
|
+
managed: Optional[pulumi.Input[_builtins.bool]] = None):
|
|
138
195
|
"""
|
|
139
|
-
:param pulumi.Input[bool] managed: - Should an ingress controller managed by Ocean for Apache Spark be installed on the cluster.
|
|
196
|
+
:param pulumi.Input[_builtins.bool] managed: - Should an ingress controller managed by Ocean for Apache Spark be installed on the cluster.
|
|
140
197
|
"""
|
|
141
198
|
if managed is not None:
|
|
142
199
|
pulumi.set(__self__, "managed", managed)
|
|
143
200
|
|
|
144
|
-
@property
|
|
201
|
+
@_builtins.property
|
|
145
202
|
@pulumi.getter
|
|
146
|
-
def managed(self) -> Optional[pulumi.Input[bool]]:
|
|
203
|
+
def managed(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
147
204
|
"""
|
|
148
205
|
- Should an ingress controller managed by Ocean for Apache Spark be installed on the cluster.
|
|
149
206
|
"""
|
|
150
207
|
return pulumi.get(self, "managed")
|
|
151
208
|
|
|
152
209
|
@managed.setter
|
|
153
|
-
def managed(self, value: Optional[pulumi.Input[bool]]):
|
|
210
|
+
def managed(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
154
211
|
pulumi.set(self, "managed", value)
|
|
155
212
|
|
|
156
213
|
|
|
214
|
+
if not MYPY:
|
|
215
|
+
class OceanIngressCustomEndpointArgsDict(TypedDict):
|
|
216
|
+
address: NotRequired[pulumi.Input[_builtins.str]]
|
|
217
|
+
"""
|
|
218
|
+
- The address the Ocean for Apache Spark control plane will use when addressing the cluster.
|
|
219
|
+
"""
|
|
220
|
+
enabled: NotRequired[pulumi.Input[_builtins.bool]]
|
|
221
|
+
"""
|
|
222
|
+
- Should the Ocean for Apache Spark control plane address the cluster using a custom endpoint. Use this to specify the DNS address of an externally provisioned (unmanaged) load balancer.
|
|
223
|
+
"""
|
|
224
|
+
elif False:
|
|
225
|
+
OceanIngressCustomEndpointArgsDict: TypeAlias = Mapping[str, Any]
|
|
226
|
+
|
|
157
227
|
@pulumi.input_type
|
|
158
228
|
class OceanIngressCustomEndpointArgs:
|
|
159
229
|
def __init__(__self__, *,
|
|
160
|
-
address: Optional[pulumi.Input[str]] = None,
|
|
161
|
-
enabled: Optional[pulumi.Input[bool]] = None):
|
|
230
|
+
address: Optional[pulumi.Input[_builtins.str]] = None,
|
|
231
|
+
enabled: Optional[pulumi.Input[_builtins.bool]] = None):
|
|
162
232
|
"""
|
|
163
|
-
:param pulumi.Input[str] address: - The address the Ocean for Apache Spark control plane will use when addressing the cluster.
|
|
164
|
-
:param pulumi.Input[bool] enabled: - Should the Ocean for Apache Spark control plane address the cluster using a custom endpoint. Use this to specify the DNS address of an externally provisioned (unmanaged) load balancer.
|
|
233
|
+
:param pulumi.Input[_builtins.str] address: - The address the Ocean for Apache Spark control plane will use when addressing the cluster.
|
|
234
|
+
:param pulumi.Input[_builtins.bool] enabled: - Should the Ocean for Apache Spark control plane address the cluster using a custom endpoint. Use this to specify the DNS address of an externally provisioned (unmanaged) load balancer.
|
|
165
235
|
"""
|
|
166
236
|
if address is not None:
|
|
167
237
|
pulumi.set(__self__, "address", address)
|
|
168
238
|
if enabled is not None:
|
|
169
239
|
pulumi.set(__self__, "enabled", enabled)
|
|
170
240
|
|
|
171
|
-
@property
|
|
241
|
+
@_builtins.property
|
|
172
242
|
@pulumi.getter
|
|
173
|
-
def address(self) -> Optional[pulumi.Input[str]]:
|
|
243
|
+
def address(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
174
244
|
"""
|
|
175
245
|
- The address the Ocean for Apache Spark control plane will use when addressing the cluster.
|
|
176
246
|
"""
|
|
177
247
|
return pulumi.get(self, "address")
|
|
178
248
|
|
|
179
249
|
@address.setter
|
|
180
|
-
def address(self, value: Optional[pulumi.Input[str]]):
|
|
250
|
+
def address(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
181
251
|
pulumi.set(self, "address", value)
|
|
182
252
|
|
|
183
|
-
@property
|
|
253
|
+
@_builtins.property
|
|
184
254
|
@pulumi.getter
|
|
185
|
-
def enabled(self) -> Optional[pulumi.Input[bool]]:
|
|
255
|
+
def enabled(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
186
256
|
"""
|
|
187
257
|
- Should the Ocean for Apache Spark control plane address the cluster using a custom endpoint. Use this to specify the DNS address of an externally provisioned (unmanaged) load balancer.
|
|
188
258
|
"""
|
|
189
259
|
return pulumi.get(self, "enabled")
|
|
190
260
|
|
|
191
261
|
@enabled.setter
|
|
192
|
-
def enabled(self, value: Optional[pulumi.Input[bool]]):
|
|
262
|
+
def enabled(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
193
263
|
pulumi.set(self, "enabled", value)
|
|
194
264
|
|
|
195
265
|
|
|
266
|
+
if not MYPY:
|
|
267
|
+
class OceanIngressLoadBalancerArgsDict(TypedDict):
|
|
268
|
+
managed: NotRequired[pulumi.Input[_builtins.bool]]
|
|
269
|
+
"""
|
|
270
|
+
- Should a load balancer managed by Ocean for Apache Spark be provisioned for the cluster. Set this to false if you want to use an existing load balancer (only available on AWS).
|
|
271
|
+
"""
|
|
272
|
+
service_annotations: NotRequired[pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]]]
|
|
273
|
+
"""
|
|
274
|
+
- Annotations to add to the ingress controller load balancer service. This is useful to configure properties of the managed load balancer, like the nature of the load balancer (e.g. ELB, NLB, ALB on AWS), the security groups, or various timeouts.
|
|
275
|
+
"""
|
|
276
|
+
target_group_arn: NotRequired[pulumi.Input[_builtins.str]]
|
|
277
|
+
"""
|
|
278
|
+
- The ARN of a target group that the Ocean for Apache Spark ingress controller will be bound to. Set this to use an existing load balancer with Ocean for Apache Spark. Has no effect if using a managed load balancer. Only available on AWS.
|
|
279
|
+
"""
|
|
280
|
+
elif False:
|
|
281
|
+
OceanIngressLoadBalancerArgsDict: TypeAlias = Mapping[str, Any]
|
|
282
|
+
|
|
196
283
|
@pulumi.input_type
|
|
197
284
|
class OceanIngressLoadBalancerArgs:
|
|
198
285
|
def __init__(__self__, *,
|
|
199
|
-
managed: Optional[pulumi.Input[bool]] = None,
|
|
200
|
-
service_annotations: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None,
|
|
201
|
-
target_group_arn: Optional[pulumi.Input[str]] = None):
|
|
286
|
+
managed: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
287
|
+
service_annotations: Optional[pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]]] = None,
|
|
288
|
+
target_group_arn: Optional[pulumi.Input[_builtins.str]] = None):
|
|
202
289
|
"""
|
|
203
|
-
:param pulumi.Input[bool] managed: - Should a load balancer managed by Ocean for Apache Spark be provisioned for the cluster. Set this to false if you want to use an existing load balancer (only available on AWS).
|
|
204
|
-
:param pulumi.Input[Mapping[str, pulumi.Input[str]]] service_annotations: - Annotations to add to the ingress controller load balancer service. This is useful to configure properties of the managed load balancer, like the nature of the load balancer (e.g. ELB, NLB, ALB on AWS), the security groups, or various timeouts.
|
|
205
|
-
:param pulumi.Input[str] target_group_arn: - The ARN of a target group that the Ocean for Apache Spark ingress controller will be bound to. Set this to use an existing load balancer with Ocean for Apache Spark. Has no effect if using a managed load balancer. Only available on AWS.
|
|
290
|
+
:param pulumi.Input[_builtins.bool] managed: - Should a load balancer managed by Ocean for Apache Spark be provisioned for the cluster. Set this to false if you want to use an existing load balancer (only available on AWS).
|
|
291
|
+
:param pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]] service_annotations: - Annotations to add to the ingress controller load balancer service. This is useful to configure properties of the managed load balancer, like the nature of the load balancer (e.g. ELB, NLB, ALB on AWS), the security groups, or various timeouts.
|
|
292
|
+
:param pulumi.Input[_builtins.str] target_group_arn: - The ARN of a target group that the Ocean for Apache Spark ingress controller will be bound to. Set this to use an existing load balancer with Ocean for Apache Spark. Has no effect if using a managed load balancer. Only available on AWS.
|
|
206
293
|
"""
|
|
207
294
|
if managed is not None:
|
|
208
295
|
pulumi.set(__self__, "managed", managed)
|
|
@@ -211,164 +298,286 @@ class OceanIngressLoadBalancerArgs:
|
|
|
211
298
|
if target_group_arn is not None:
|
|
212
299
|
pulumi.set(__self__, "target_group_arn", target_group_arn)
|
|
213
300
|
|
|
214
|
-
@property
|
|
301
|
+
@_builtins.property
|
|
215
302
|
@pulumi.getter
|
|
216
|
-
def managed(self) -> Optional[pulumi.Input[bool]]:
|
|
303
|
+
def managed(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
217
304
|
"""
|
|
218
305
|
- Should a load balancer managed by Ocean for Apache Spark be provisioned for the cluster. Set this to false if you want to use an existing load balancer (only available on AWS).
|
|
219
306
|
"""
|
|
220
307
|
return pulumi.get(self, "managed")
|
|
221
308
|
|
|
222
309
|
@managed.setter
|
|
223
|
-
def managed(self, value: Optional[pulumi.Input[bool]]):
|
|
310
|
+
def managed(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
224
311
|
pulumi.set(self, "managed", value)
|
|
225
312
|
|
|
226
|
-
@property
|
|
313
|
+
@_builtins.property
|
|
227
314
|
@pulumi.getter(name="serviceAnnotations")
|
|
228
|
-
def service_annotations(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]:
|
|
315
|
+
def service_annotations(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]]]:
|
|
229
316
|
"""
|
|
230
317
|
- Annotations to add to the ingress controller load balancer service. This is useful to configure properties of the managed load balancer, like the nature of the load balancer (e.g. ELB, NLB, ALB on AWS), the security groups, or various timeouts.
|
|
231
318
|
"""
|
|
232
319
|
return pulumi.get(self, "service_annotations")
|
|
233
320
|
|
|
234
321
|
@service_annotations.setter
|
|
235
|
-
def service_annotations(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]):
|
|
322
|
+
def service_annotations(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]]]):
|
|
236
323
|
pulumi.set(self, "service_annotations", value)
|
|
237
324
|
|
|
238
|
-
@property
|
|
325
|
+
@_builtins.property
|
|
239
326
|
@pulumi.getter(name="targetGroupArn")
|
|
240
|
-
def target_group_arn(self) -> Optional[pulumi.Input[str]]:
|
|
327
|
+
def target_group_arn(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
241
328
|
"""
|
|
242
329
|
- The ARN of a target group that the Ocean for Apache Spark ingress controller will be bound to. Set this to use an existing load balancer with Ocean for Apache Spark. Has no effect if using a managed load balancer. Only available on AWS.
|
|
243
330
|
"""
|
|
244
331
|
return pulumi.get(self, "target_group_arn")
|
|
245
332
|
|
|
246
333
|
@target_group_arn.setter
|
|
247
|
-
def target_group_arn(self, value: Optional[pulumi.Input[str]]):
|
|
334
|
+
def target_group_arn(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
248
335
|
pulumi.set(self, "target_group_arn", value)
|
|
249
336
|
|
|
250
337
|
|
|
338
|
+
if not MYPY:
|
|
339
|
+
class OceanIngressPrivateLinkArgsDict(TypedDict):
|
|
340
|
+
enabled: NotRequired[pulumi.Input[_builtins.bool]]
|
|
341
|
+
"""
|
|
342
|
+
- Should the Ocean for Apache Spark control plane address the cluster via an AWS Private Link. Only available on AWS.
|
|
343
|
+
"""
|
|
344
|
+
vpc_endpoint_service: NotRequired[pulumi.Input[_builtins.str]]
|
|
345
|
+
"""
|
|
346
|
+
- The name of the VPC Endpoint Service the Ocean for Apache Spark control plane should bind to.
|
|
347
|
+
"""
|
|
348
|
+
elif False:
|
|
349
|
+
OceanIngressPrivateLinkArgsDict: TypeAlias = Mapping[str, Any]
|
|
350
|
+
|
|
251
351
|
@pulumi.input_type
|
|
252
352
|
class OceanIngressPrivateLinkArgs:
|
|
253
353
|
def __init__(__self__, *,
|
|
254
|
-
enabled: Optional[pulumi.Input[bool]] = None,
|
|
255
|
-
vpc_endpoint_service: Optional[pulumi.Input[str]] = None):
|
|
354
|
+
enabled: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
355
|
+
vpc_endpoint_service: Optional[pulumi.Input[_builtins.str]] = None):
|
|
256
356
|
"""
|
|
257
|
-
:param pulumi.Input[bool] enabled: - Should the Ocean for Apache Spark control plane address the cluster via an AWS Private Link. Only available on AWS.
|
|
258
|
-
:param pulumi.Input[str] vpc_endpoint_service: - The name of the VPC Endpoint Service the Ocean for Apache Spark control plane should bind to.
|
|
357
|
+
:param pulumi.Input[_builtins.bool] enabled: - Should the Ocean for Apache Spark control plane address the cluster via an AWS Private Link. Only available on AWS.
|
|
358
|
+
:param pulumi.Input[_builtins.str] vpc_endpoint_service: - The name of the VPC Endpoint Service the Ocean for Apache Spark control plane should bind to.
|
|
259
359
|
"""
|
|
260
360
|
if enabled is not None:
|
|
261
361
|
pulumi.set(__self__, "enabled", enabled)
|
|
262
362
|
if vpc_endpoint_service is not None:
|
|
263
363
|
pulumi.set(__self__, "vpc_endpoint_service", vpc_endpoint_service)
|
|
264
364
|
|
|
265
|
-
@property
|
|
365
|
+
@_builtins.property
|
|
266
366
|
@pulumi.getter
|
|
267
|
-
def enabled(self) -> Optional[pulumi.Input[bool]]:
|
|
367
|
+
def enabled(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
268
368
|
"""
|
|
269
369
|
- Should the Ocean for Apache Spark control plane address the cluster via an AWS Private Link. Only available on AWS.
|
|
270
370
|
"""
|
|
271
371
|
return pulumi.get(self, "enabled")
|
|
272
372
|
|
|
273
373
|
@enabled.setter
|
|
274
|
-
def enabled(self, value: Optional[pulumi.Input[bool]]):
|
|
374
|
+
def enabled(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
275
375
|
pulumi.set(self, "enabled", value)
|
|
276
376
|
|
|
277
|
-
@property
|
|
377
|
+
@_builtins.property
|
|
278
378
|
@pulumi.getter(name="vpcEndpointService")
|
|
279
|
-
def vpc_endpoint_service(self) -> Optional[pulumi.Input[str]]:
|
|
379
|
+
def vpc_endpoint_service(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
280
380
|
"""
|
|
281
381
|
- The name of the VPC Endpoint Service the Ocean for Apache Spark control plane should bind to.
|
|
282
382
|
"""
|
|
283
383
|
return pulumi.get(self, "vpc_endpoint_service")
|
|
284
384
|
|
|
285
385
|
@vpc_endpoint_service.setter
|
|
286
|
-
def vpc_endpoint_service(self, value: Optional[pulumi.Input[str]]):
|
|
386
|
+
def vpc_endpoint_service(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
287
387
|
pulumi.set(self, "vpc_endpoint_service", value)
|
|
288
388
|
|
|
289
389
|
|
|
390
|
+
if not MYPY:
|
|
391
|
+
class OceanLogCollectionArgsDict(TypedDict):
|
|
392
|
+
collect_app_logs: NotRequired[pulumi.Input[_builtins.bool]]
|
|
393
|
+
"""
|
|
394
|
+
- Enable/Disable collecting driver and executor logs. When enabled, logs are stored by NetApp and can be downloaded from the Spot console web interface. The logs are deleted after 30 days.
|
|
395
|
+
"""
|
|
396
|
+
elif False:
|
|
397
|
+
OceanLogCollectionArgsDict: TypeAlias = Mapping[str, Any]
|
|
398
|
+
|
|
290
399
|
@pulumi.input_type
|
|
291
400
|
class OceanLogCollectionArgs:
|
|
292
401
|
def __init__(__self__, *,
|
|
293
|
-
collect_app_logs: Optional[pulumi.Input[bool]] = None):
|
|
402
|
+
collect_app_logs: Optional[pulumi.Input[_builtins.bool]] = None):
|
|
294
403
|
"""
|
|
295
|
-
:param pulumi.Input[bool] collect_app_logs: - Enable/Disable collecting driver and executor logs. When enabled, logs are stored by NetApp and can be downloaded from the Spot console web interface. The logs are deleted after 30 days.
|
|
404
|
+
:param pulumi.Input[_builtins.bool] collect_app_logs: - Enable/Disable collecting driver and executor logs. When enabled, logs are stored by NetApp and can be downloaded from the Spot console web interface. The logs are deleted after 30 days.
|
|
296
405
|
"""
|
|
297
406
|
if collect_app_logs is not None:
|
|
298
407
|
pulumi.set(__self__, "collect_app_logs", collect_app_logs)
|
|
299
408
|
|
|
300
|
-
@property
|
|
409
|
+
@_builtins.property
|
|
301
410
|
@pulumi.getter(name="collectAppLogs")
|
|
302
|
-
def collect_app_logs(self) -> Optional[pulumi.Input[bool]]:
|
|
411
|
+
def collect_app_logs(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
303
412
|
"""
|
|
304
413
|
- Enable/Disable collecting driver and executor logs. When enabled, logs are stored by NetApp and can be downloaded from the Spot console web interface. The logs are deleted after 30 days.
|
|
305
414
|
"""
|
|
306
415
|
return pulumi.get(self, "collect_app_logs")
|
|
307
416
|
|
|
308
417
|
@collect_app_logs.setter
|
|
309
|
-
def collect_app_logs(self, value: Optional[pulumi.Input[bool]]):
|
|
418
|
+
def collect_app_logs(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
310
419
|
pulumi.set(self, "collect_app_logs", value)
|
|
311
420
|
|
|
312
421
|
|
|
422
|
+
if not MYPY:
|
|
423
|
+
class OceanSparkArgsDict(TypedDict):
|
|
424
|
+
additional_app_namespaces: NotRequired[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]
|
|
425
|
+
"""
|
|
426
|
+
- List of Kubernetes namespaces that should be configured to run Spark applications, in addition to the default Spark application namespace `spark-apps`.
|
|
427
|
+
"""
|
|
428
|
+
elif False:
|
|
429
|
+
OceanSparkArgsDict: TypeAlias = Mapping[str, Any]
|
|
430
|
+
|
|
313
431
|
@pulumi.input_type
|
|
314
432
|
class OceanSparkArgs:
|
|
315
433
|
def __init__(__self__, *,
|
|
316
|
-
additional_app_namespaces: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None):
|
|
434
|
+
additional_app_namespaces: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None):
|
|
317
435
|
"""
|
|
318
|
-
:param pulumi.Input[Sequence[pulumi.Input[str]]] additional_app_namespaces: - List of Kubernetes namespaces that should be configured to run Spark applications, in addition to the default Spark application namespace `spark-apps`.
|
|
436
|
+
:param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] additional_app_namespaces: - List of Kubernetes namespaces that should be configured to run Spark applications, in addition to the default Spark application namespace `spark-apps`.
|
|
319
437
|
"""
|
|
320
438
|
if additional_app_namespaces is not None:
|
|
321
439
|
pulumi.set(__self__, "additional_app_namespaces", additional_app_namespaces)
|
|
322
440
|
|
|
323
|
-
@property
|
|
441
|
+
@_builtins.property
|
|
324
442
|
@pulumi.getter(name="additionalAppNamespaces")
|
|
325
|
-
def additional_app_namespaces(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
|
|
443
|
+
def additional_app_namespaces(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
|
|
326
444
|
"""
|
|
327
445
|
- List of Kubernetes namespaces that should be configured to run Spark applications, in addition to the default Spark application namespace `spark-apps`.
|
|
328
446
|
"""
|
|
329
447
|
return pulumi.get(self, "additional_app_namespaces")
|
|
330
448
|
|
|
331
449
|
@additional_app_namespaces.setter
|
|
332
|
-
def additional_app_namespaces(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
|
|
450
|
+
def additional_app_namespaces(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]):
|
|
333
451
|
pulumi.set(self, "additional_app_namespaces", value)
|
|
334
452
|
|
|
335
453
|
|
|
454
|
+
if not MYPY:
|
|
455
|
+
class OceanWebhookArgsDict(TypedDict):
|
|
456
|
+
host_network_ports: NotRequired[pulumi.Input[Sequence[pulumi.Input[_builtins.int]]]]
|
|
457
|
+
"""
|
|
458
|
+
- List of ports allowed to use on the host network - if empty default is `25554`.
|
|
459
|
+
"""
|
|
460
|
+
use_host_network: NotRequired[pulumi.Input[_builtins.bool]]
|
|
461
|
+
"""
|
|
462
|
+
- Enable/disable host networking for the Spark Operator. Host networking can be useful when using custom CNI plugins like Calico on EKS.
|
|
463
|
+
"""
|
|
464
|
+
elif False:
|
|
465
|
+
OceanWebhookArgsDict: TypeAlias = Mapping[str, Any]
|
|
466
|
+
|
|
336
467
|
@pulumi.input_type
|
|
337
468
|
class OceanWebhookArgs:
|
|
338
469
|
def __init__(__self__, *,
|
|
339
|
-
host_network_ports: Optional[pulumi.Input[Sequence[pulumi.Input[int]]]] = None,
|
|
340
|
-
use_host_network: Optional[pulumi.Input[bool]] = None):
|
|
470
|
+
host_network_ports: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.int]]]] = None,
|
|
471
|
+
use_host_network: Optional[pulumi.Input[_builtins.bool]] = None):
|
|
341
472
|
"""
|
|
342
|
-
:param pulumi.Input[Sequence[pulumi.Input[int]]] host_network_ports: - List of ports allowed to use on the host network - if empty default is `25554`.
|
|
343
|
-
:param pulumi.Input[bool] use_host_network: - Enable/disable host networking for the Spark Operator. Host networking can be useful when using custom CNI plugins like Calico on EKS.
|
|
473
|
+
:param pulumi.Input[Sequence[pulumi.Input[_builtins.int]]] host_network_ports: - List of ports allowed to use on the host network - if empty default is `25554`.
|
|
474
|
+
:param pulumi.Input[_builtins.bool] use_host_network: - Enable/disable host networking for the Spark Operator. Host networking can be useful when using custom CNI plugins like Calico on EKS.
|
|
344
475
|
"""
|
|
345
476
|
if host_network_ports is not None:
|
|
346
477
|
pulumi.set(__self__, "host_network_ports", host_network_ports)
|
|
347
478
|
if use_host_network is not None:
|
|
348
479
|
pulumi.set(__self__, "use_host_network", use_host_network)
|
|
349
480
|
|
|
350
|
-
@property
|
|
481
|
+
@_builtins.property
|
|
351
482
|
@pulumi.getter(name="hostNetworkPorts")
|
|
352
|
-
def host_network_ports(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[int]]]]:
|
|
483
|
+
def host_network_ports(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.int]]]]:
|
|
353
484
|
"""
|
|
354
485
|
- List of ports allowed to use on the host network - if empty default is `25554`.
|
|
355
486
|
"""
|
|
356
487
|
return pulumi.get(self, "host_network_ports")
|
|
357
488
|
|
|
358
489
|
@host_network_ports.setter
|
|
359
|
-
def host_network_ports(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[int]]]]):
|
|
490
|
+
def host_network_ports(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.int]]]]):
|
|
360
491
|
pulumi.set(self, "host_network_ports", value)
|
|
361
492
|
|
|
362
|
-
@property
|
|
493
|
+
@_builtins.property
|
|
363
494
|
@pulumi.getter(name="useHostNetwork")
|
|
364
|
-
def use_host_network(self) -> Optional[pulumi.Input[bool]]:
|
|
495
|
+
def use_host_network(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
365
496
|
"""
|
|
366
497
|
- Enable/disable host networking for the Spark Operator. Host networking can be useful when using custom CNI plugins like Calico on EKS.
|
|
367
498
|
"""
|
|
368
499
|
return pulumi.get(self, "use_host_network")
|
|
369
500
|
|
|
370
501
|
@use_host_network.setter
|
|
371
|
-
def use_host_network(self, value: Optional[pulumi.Input[bool]]):
|
|
502
|
+
def use_host_network(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
372
503
|
pulumi.set(self, "use_host_network", value)
|
|
373
504
|
|
|
374
505
|
|
|
506
|
+
if not MYPY:
|
|
507
|
+
class OceanWorkspacesArgsDict(TypedDict):
|
|
508
|
+
storage: NotRequired[pulumi.Input['OceanWorkspacesStorageArgsDict']]
|
|
509
|
+
elif False:
|
|
510
|
+
OceanWorkspacesArgsDict: TypeAlias = Mapping[str, Any]
|
|
511
|
+
|
|
512
|
+
@pulumi.input_type
|
|
513
|
+
class OceanWorkspacesArgs:
|
|
514
|
+
def __init__(__self__, *,
|
|
515
|
+
storage: Optional[pulumi.Input['OceanWorkspacesStorageArgs']] = None):
|
|
516
|
+
if storage is not None:
|
|
517
|
+
pulumi.set(__self__, "storage", storage)
|
|
518
|
+
|
|
519
|
+
@_builtins.property
|
|
520
|
+
@pulumi.getter
|
|
521
|
+
def storage(self) -> Optional[pulumi.Input['OceanWorkspacesStorageArgs']]:
|
|
522
|
+
return pulumi.get(self, "storage")
|
|
523
|
+
|
|
524
|
+
@storage.setter
|
|
525
|
+
def storage(self, value: Optional[pulumi.Input['OceanWorkspacesStorageArgs']]):
|
|
526
|
+
pulumi.set(self, "storage", value)
|
|
527
|
+
|
|
528
|
+
|
|
529
|
+
if not MYPY:
|
|
530
|
+
class OceanWorkspacesStorageArgsDict(TypedDict):
|
|
531
|
+
defaults: NotRequired[pulumi.Input['OceanWorkspacesStorageDefaultsArgsDict']]
|
|
532
|
+
elif False:
|
|
533
|
+
OceanWorkspacesStorageArgsDict: TypeAlias = Mapping[str, Any]
|
|
534
|
+
|
|
535
|
+
@pulumi.input_type
|
|
536
|
+
class OceanWorkspacesStorageArgs:
|
|
537
|
+
def __init__(__self__, *,
|
|
538
|
+
defaults: Optional[pulumi.Input['OceanWorkspacesStorageDefaultsArgs']] = None):
|
|
539
|
+
if defaults is not None:
|
|
540
|
+
pulumi.set(__self__, "defaults", defaults)
|
|
541
|
+
|
|
542
|
+
@_builtins.property
|
|
543
|
+
@pulumi.getter
|
|
544
|
+
def defaults(self) -> Optional[pulumi.Input['OceanWorkspacesStorageDefaultsArgs']]:
|
|
545
|
+
return pulumi.get(self, "defaults")
|
|
546
|
+
|
|
547
|
+
@defaults.setter
|
|
548
|
+
def defaults(self, value: Optional[pulumi.Input['OceanWorkspacesStorageDefaultsArgs']]):
|
|
549
|
+
pulumi.set(self, "defaults", value)
|
|
550
|
+
|
|
551
|
+
|
|
552
|
+
if not MYPY:
|
|
553
|
+
class OceanWorkspacesStorageDefaultsArgsDict(TypedDict):
|
|
554
|
+
storage_class_name: NotRequired[pulumi.Input[_builtins.str]]
|
|
555
|
+
"""
|
|
556
|
+
- The name of the default storage class to use for new workspaces. If not specified, the default storage class of the Kubernetes cluster will be used.
|
|
557
|
+
"""
|
|
558
|
+
elif False:
|
|
559
|
+
OceanWorkspacesStorageDefaultsArgsDict: TypeAlias = Mapping[str, Any]
|
|
560
|
+
|
|
561
|
+
@pulumi.input_type
|
|
562
|
+
class OceanWorkspacesStorageDefaultsArgs:
|
|
563
|
+
def __init__(__self__, *,
|
|
564
|
+
storage_class_name: Optional[pulumi.Input[_builtins.str]] = None):
|
|
565
|
+
"""
|
|
566
|
+
:param pulumi.Input[_builtins.str] storage_class_name: - The name of the default storage class to use for new workspaces. If not specified, the default storage class of the Kubernetes cluster will be used.
|
|
567
|
+
"""
|
|
568
|
+
if storage_class_name is not None:
|
|
569
|
+
pulumi.set(__self__, "storage_class_name", storage_class_name)
|
|
570
|
+
|
|
571
|
+
@_builtins.property
|
|
572
|
+
@pulumi.getter(name="storageClassName")
|
|
573
|
+
def storage_class_name(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
574
|
+
"""
|
|
575
|
+
- The name of the default storage class to use for new workspaces. If not specified, the default storage class of the Kubernetes cluster will be used.
|
|
576
|
+
"""
|
|
577
|
+
return pulumi.get(self, "storage_class_name")
|
|
578
|
+
|
|
579
|
+
@storage_class_name.setter
|
|
580
|
+
def storage_class_name(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
581
|
+
pulumi.set(self, "storage_class_name", value)
|
|
582
|
+
|
|
583
|
+
|