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 *
|
|
@@ -16,52 +21,54 @@ __all__ = ['OceanNpVirtualNodeGroupArgs', 'OceanNpVirtualNodeGroup']
|
|
|
16
21
|
@pulumi.input_type
|
|
17
22
|
class OceanNpVirtualNodeGroupArgs:
|
|
18
23
|
def __init__(__self__, *,
|
|
19
|
-
ocean_id: pulumi.Input[str],
|
|
20
|
-
availability_zones: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
|
|
21
|
-
enable_node_public_ip: Optional[pulumi.Input[bool]] = None,
|
|
22
|
-
fallback_to_ondemand: Optional[pulumi.Input[bool]] = None,
|
|
24
|
+
ocean_id: pulumi.Input[_builtins.str],
|
|
25
|
+
availability_zones: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
26
|
+
enable_node_public_ip: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
27
|
+
fallback_to_ondemand: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
23
28
|
filters: Optional[pulumi.Input['OceanNpVirtualNodeGroupFiltersArgs']] = None,
|
|
24
29
|
headrooms: Optional[pulumi.Input[Sequence[pulumi.Input['OceanNpVirtualNodeGroupHeadroomArgs']]]] = None,
|
|
25
|
-
kubernetes_version: Optional[pulumi.Input[str]] = None,
|
|
26
|
-
labels: Optional[pulumi.Input[Mapping[str,
|
|
30
|
+
kubernetes_version: Optional[pulumi.Input[_builtins.str]] = None,
|
|
31
|
+
labels: Optional[pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]]] = None,
|
|
27
32
|
linux_os_configs: Optional[pulumi.Input[Sequence[pulumi.Input['OceanNpVirtualNodeGroupLinuxOsConfigArgs']]]] = None,
|
|
28
|
-
max_count: Optional[pulumi.Input[int]] = None,
|
|
29
|
-
max_pods_per_node: Optional[pulumi.Input[int]] = None,
|
|
30
|
-
min_count: Optional[pulumi.Input[int]] = None,
|
|
31
|
-
name: Optional[pulumi.Input[str]] = None,
|
|
32
|
-
os_disk_size_gb: Optional[pulumi.Input[int]] = None,
|
|
33
|
-
os_disk_type: Optional[pulumi.Input[str]] = None,
|
|
34
|
-
os_sku: Optional[pulumi.Input[str]] = None,
|
|
35
|
-
os_type: Optional[pulumi.Input[str]] = None,
|
|
36
|
-
pod_subnet_ids: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
|
|
37
|
-
|
|
38
|
-
|
|
33
|
+
max_count: Optional[pulumi.Input[_builtins.int]] = None,
|
|
34
|
+
max_pods_per_node: Optional[pulumi.Input[_builtins.int]] = None,
|
|
35
|
+
min_count: Optional[pulumi.Input[_builtins.int]] = None,
|
|
36
|
+
name: Optional[pulumi.Input[_builtins.str]] = None,
|
|
37
|
+
os_disk_size_gb: Optional[pulumi.Input[_builtins.int]] = None,
|
|
38
|
+
os_disk_type: Optional[pulumi.Input[_builtins.str]] = None,
|
|
39
|
+
os_sku: Optional[pulumi.Input[_builtins.str]] = None,
|
|
40
|
+
os_type: Optional[pulumi.Input[_builtins.str]] = None,
|
|
41
|
+
pod_subnet_ids: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
42
|
+
scheduling: Optional[pulumi.Input['OceanNpVirtualNodeGroupSchedulingArgs']] = None,
|
|
43
|
+
spot_percentage: Optional[pulumi.Input[_builtins.int]] = None,
|
|
44
|
+
tags: Optional[pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]]] = None,
|
|
39
45
|
taints: Optional[pulumi.Input[Sequence[pulumi.Input['OceanNpVirtualNodeGroupTaintArgs']]]] = None,
|
|
40
46
|
update_policy: Optional[pulumi.Input['OceanNpVirtualNodeGroupUpdatePolicyArgs']] = None,
|
|
41
|
-
vnet_subnet_ids: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None):
|
|
47
|
+
vnet_subnet_ids: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None):
|
|
42
48
|
"""
|
|
43
49
|
The set of arguments for constructing a OceanNpVirtualNodeGroup resource.
|
|
44
|
-
:param pulumi.Input[str] ocean_id: The Ocean cluster identifier. Required for Launch Spec creation.
|
|
45
|
-
:param pulumi.Input[Sequence[pulumi.Input[str]]] availability_zones: An Array holding Availability Zones, this configures the availability zones the Ocean may launch instances in per VNG.
|
|
46
|
-
:param pulumi.Input[bool] enable_node_public_ip: Enable node public IP.
|
|
47
|
-
:param pulumi.Input[bool] fallback_to_ondemand: If no spot instance markets are available, enable Ocean to launch on-demand instances instead.
|
|
50
|
+
:param pulumi.Input[_builtins.str] ocean_id: The Ocean cluster identifier. Required for Launch Spec creation.
|
|
51
|
+
:param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] availability_zones: An Array holding Availability Zones, this configures the availability zones the Ocean may launch instances in per VNG.
|
|
52
|
+
:param pulumi.Input[_builtins.bool] enable_node_public_ip: Enable node public IP.
|
|
53
|
+
:param pulumi.Input[_builtins.bool] fallback_to_ondemand: If no spot instance markets are available, enable Ocean to launch on-demand instances instead.
|
|
48
54
|
:param pulumi.Input['OceanNpVirtualNodeGroupFiltersArgs'] filters: Filters for the VM sizes that can be launched from the virtual node group.
|
|
49
55
|
:param pulumi.Input[Sequence[pulumi.Input['OceanNpVirtualNodeGroupHeadroomArgs']]] headrooms: Specify the custom headroom per VNG. Provide a list of headroom objects.
|
|
50
|
-
:param pulumi.Input[str] kubernetes_version: The desired Kubernetes version of the launched nodes. In case the value is null, the Kubernetes version of the control plane is used.
|
|
51
|
-
:param pulumi.Input[Mapping[str,
|
|
56
|
+
:param pulumi.Input[_builtins.str] kubernetes_version: The desired Kubernetes version of the launched nodes. In case the value is null, the Kubernetes version of the control plane is used.
|
|
57
|
+
:param pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]] labels: An array of labels to add to the virtual node group.Only custom user labels are allowed, and not Kubernetes built-in labels or Spot internal labels.
|
|
52
58
|
:param pulumi.Input[Sequence[pulumi.Input['OceanNpVirtualNodeGroupLinuxOsConfigArgs']]] linux_os_configs: Custom Linux OS configuration.
|
|
53
|
-
:param pulumi.Input[int] max_count: Maximum node count limit.
|
|
54
|
-
:param pulumi.Input[int] max_pods_per_node: The maximum number of pods per node in the node pools.
|
|
55
|
-
:param pulumi.Input[int] min_count: Minimum node count limit.
|
|
56
|
-
:param pulumi.Input[str] name: Enter a name for the virtual node group.
|
|
57
|
-
:param pulumi.Input[int] os_disk_size_gb: The size of the OS disk in GB.
|
|
58
|
-
:param pulumi.Input[str] os_disk_type: The type of the OS disk.
|
|
59
|
-
:param pulumi.Input[str] os_sku: The OS SKU of the OS type. Must correlate with the os type.
|
|
60
|
-
:param pulumi.Input[str] os_type: The OS type of the OS disk. Can't be modified once set.
|
|
61
|
-
:param pulumi.Input[Sequence[pulumi.Input[str]]] pod_subnet_ids: The IDs of subnets in an existing VNet into which to assign pods in the cluster (requires azure network-plugin).
|
|
62
|
-
:param pulumi.Input[
|
|
59
|
+
:param pulumi.Input[_builtins.int] max_count: Maximum node count limit.
|
|
60
|
+
:param pulumi.Input[_builtins.int] max_pods_per_node: The maximum number of pods per node in the node pools.
|
|
61
|
+
:param pulumi.Input[_builtins.int] min_count: Minimum node count limit.
|
|
62
|
+
:param pulumi.Input[_builtins.str] name: Enter a name for the virtual node group.
|
|
63
|
+
:param pulumi.Input[_builtins.int] os_disk_size_gb: The size of the OS disk in GB.
|
|
64
|
+
:param pulumi.Input[_builtins.str] os_disk_type: The type of the OS disk.
|
|
65
|
+
:param pulumi.Input[_builtins.str] os_sku: The OS SKU of the OS type. Must correlate with the os type.
|
|
66
|
+
:param pulumi.Input[_builtins.str] os_type: The OS type of the OS disk. Can't be modified once set.
|
|
67
|
+
:param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] pod_subnet_ids: The IDs of subnets in an existing VNet into which to assign pods in the cluster (requires azure network-plugin).
|
|
68
|
+
:param pulumi.Input['OceanNpVirtualNodeGroupSchedulingArgs'] scheduling: An object used to specify times when the virtual node group will turn off all its node pools. Once the shutdown time will be over, the virtual node group will return to its previous state.
|
|
69
|
+
:param pulumi.Input[_builtins.int] spot_percentage: Percentage of spot VMs to maintain.
|
|
63
70
|
:param pulumi.Input[Sequence[pulumi.Input['OceanNpVirtualNodeGroupTaintArgs']]] taints: Add taints to a virtual node group.
|
|
64
|
-
:param pulumi.Input[Sequence[pulumi.Input[str]]] vnet_subnet_ids: The IDs of subnets in an existing VNet into which to assign nodes in the cluster (requires azure network-plugin).
|
|
71
|
+
:param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] vnet_subnet_ids: The IDs of subnets in an existing VNet into which to assign nodes in the cluster (requires azure network-plugin).
|
|
65
72
|
"""
|
|
66
73
|
pulumi.set(__self__, "ocean_id", ocean_id)
|
|
67
74
|
if availability_zones is not None:
|
|
@@ -98,6 +105,8 @@ class OceanNpVirtualNodeGroupArgs:
|
|
|
98
105
|
pulumi.set(__self__, "os_type", os_type)
|
|
99
106
|
if pod_subnet_ids is not None:
|
|
100
107
|
pulumi.set(__self__, "pod_subnet_ids", pod_subnet_ids)
|
|
108
|
+
if scheduling is not None:
|
|
109
|
+
pulumi.set(__self__, "scheduling", scheduling)
|
|
101
110
|
if spot_percentage is not None:
|
|
102
111
|
pulumi.set(__self__, "spot_percentage", spot_percentage)
|
|
103
112
|
if tags is not None:
|
|
@@ -109,55 +118,55 @@ class OceanNpVirtualNodeGroupArgs:
|
|
|
109
118
|
if vnet_subnet_ids is not None:
|
|
110
119
|
pulumi.set(__self__, "vnet_subnet_ids", vnet_subnet_ids)
|
|
111
120
|
|
|
112
|
-
@property
|
|
121
|
+
@_builtins.property
|
|
113
122
|
@pulumi.getter(name="oceanId")
|
|
114
|
-
def ocean_id(self) -> pulumi.Input[str]:
|
|
123
|
+
def ocean_id(self) -> pulumi.Input[_builtins.str]:
|
|
115
124
|
"""
|
|
116
125
|
The Ocean cluster identifier. Required for Launch Spec creation.
|
|
117
126
|
"""
|
|
118
127
|
return pulumi.get(self, "ocean_id")
|
|
119
128
|
|
|
120
129
|
@ocean_id.setter
|
|
121
|
-
def ocean_id(self, value: pulumi.Input[str]):
|
|
130
|
+
def ocean_id(self, value: pulumi.Input[_builtins.str]):
|
|
122
131
|
pulumi.set(self, "ocean_id", value)
|
|
123
132
|
|
|
124
|
-
@property
|
|
133
|
+
@_builtins.property
|
|
125
134
|
@pulumi.getter(name="availabilityZones")
|
|
126
|
-
def availability_zones(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
|
|
135
|
+
def availability_zones(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
|
|
127
136
|
"""
|
|
128
137
|
An Array holding Availability Zones, this configures the availability zones the Ocean may launch instances in per VNG.
|
|
129
138
|
"""
|
|
130
139
|
return pulumi.get(self, "availability_zones")
|
|
131
140
|
|
|
132
141
|
@availability_zones.setter
|
|
133
|
-
def availability_zones(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
|
|
142
|
+
def availability_zones(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]):
|
|
134
143
|
pulumi.set(self, "availability_zones", value)
|
|
135
144
|
|
|
136
|
-
@property
|
|
145
|
+
@_builtins.property
|
|
137
146
|
@pulumi.getter(name="enableNodePublicIp")
|
|
138
|
-
def enable_node_public_ip(self) -> Optional[pulumi.Input[bool]]:
|
|
147
|
+
def enable_node_public_ip(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
139
148
|
"""
|
|
140
149
|
Enable node public IP.
|
|
141
150
|
"""
|
|
142
151
|
return pulumi.get(self, "enable_node_public_ip")
|
|
143
152
|
|
|
144
153
|
@enable_node_public_ip.setter
|
|
145
|
-
def enable_node_public_ip(self, value: Optional[pulumi.Input[bool]]):
|
|
154
|
+
def enable_node_public_ip(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
146
155
|
pulumi.set(self, "enable_node_public_ip", value)
|
|
147
156
|
|
|
148
|
-
@property
|
|
157
|
+
@_builtins.property
|
|
149
158
|
@pulumi.getter(name="fallbackToOndemand")
|
|
150
|
-
def fallback_to_ondemand(self) -> Optional[pulumi.Input[bool]]:
|
|
159
|
+
def fallback_to_ondemand(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
151
160
|
"""
|
|
152
161
|
If no spot instance markets are available, enable Ocean to launch on-demand instances instead.
|
|
153
162
|
"""
|
|
154
163
|
return pulumi.get(self, "fallback_to_ondemand")
|
|
155
164
|
|
|
156
165
|
@fallback_to_ondemand.setter
|
|
157
|
-
def fallback_to_ondemand(self, value: Optional[pulumi.Input[bool]]):
|
|
166
|
+
def fallback_to_ondemand(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
158
167
|
pulumi.set(self, "fallback_to_ondemand", value)
|
|
159
168
|
|
|
160
|
-
@property
|
|
169
|
+
@_builtins.property
|
|
161
170
|
@pulumi.getter
|
|
162
171
|
def filters(self) -> Optional[pulumi.Input['OceanNpVirtualNodeGroupFiltersArgs']]:
|
|
163
172
|
"""
|
|
@@ -169,7 +178,7 @@ class OceanNpVirtualNodeGroupArgs:
|
|
|
169
178
|
def filters(self, value: Optional[pulumi.Input['OceanNpVirtualNodeGroupFiltersArgs']]):
|
|
170
179
|
pulumi.set(self, "filters", value)
|
|
171
180
|
|
|
172
|
-
@property
|
|
181
|
+
@_builtins.property
|
|
173
182
|
@pulumi.getter
|
|
174
183
|
def headrooms(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['OceanNpVirtualNodeGroupHeadroomArgs']]]]:
|
|
175
184
|
"""
|
|
@@ -181,31 +190,31 @@ class OceanNpVirtualNodeGroupArgs:
|
|
|
181
190
|
def headrooms(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['OceanNpVirtualNodeGroupHeadroomArgs']]]]):
|
|
182
191
|
pulumi.set(self, "headrooms", value)
|
|
183
192
|
|
|
184
|
-
@property
|
|
193
|
+
@_builtins.property
|
|
185
194
|
@pulumi.getter(name="kubernetesVersion")
|
|
186
|
-
def kubernetes_version(self) -> Optional[pulumi.Input[str]]:
|
|
195
|
+
def kubernetes_version(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
187
196
|
"""
|
|
188
197
|
The desired Kubernetes version of the launched nodes. In case the value is null, the Kubernetes version of the control plane is used.
|
|
189
198
|
"""
|
|
190
199
|
return pulumi.get(self, "kubernetes_version")
|
|
191
200
|
|
|
192
201
|
@kubernetes_version.setter
|
|
193
|
-
def kubernetes_version(self, value: Optional[pulumi.Input[str]]):
|
|
202
|
+
def kubernetes_version(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
194
203
|
pulumi.set(self, "kubernetes_version", value)
|
|
195
204
|
|
|
196
|
-
@property
|
|
205
|
+
@_builtins.property
|
|
197
206
|
@pulumi.getter
|
|
198
|
-
def labels(self) -> Optional[pulumi.Input[Mapping[str,
|
|
207
|
+
def labels(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]]]:
|
|
199
208
|
"""
|
|
200
209
|
An array of labels to add to the virtual node group.Only custom user labels are allowed, and not Kubernetes built-in labels or Spot internal labels.
|
|
201
210
|
"""
|
|
202
211
|
return pulumi.get(self, "labels")
|
|
203
212
|
|
|
204
213
|
@labels.setter
|
|
205
|
-
def labels(self, value: Optional[pulumi.Input[Mapping[str,
|
|
214
|
+
def labels(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]]]):
|
|
206
215
|
pulumi.set(self, "labels", value)
|
|
207
216
|
|
|
208
|
-
@property
|
|
217
|
+
@_builtins.property
|
|
209
218
|
@pulumi.getter(name="linuxOsConfigs")
|
|
210
219
|
def linux_os_configs(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['OceanNpVirtualNodeGroupLinuxOsConfigArgs']]]]:
|
|
211
220
|
"""
|
|
@@ -217,136 +226,148 @@ class OceanNpVirtualNodeGroupArgs:
|
|
|
217
226
|
def linux_os_configs(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['OceanNpVirtualNodeGroupLinuxOsConfigArgs']]]]):
|
|
218
227
|
pulumi.set(self, "linux_os_configs", value)
|
|
219
228
|
|
|
220
|
-
@property
|
|
229
|
+
@_builtins.property
|
|
221
230
|
@pulumi.getter(name="maxCount")
|
|
222
|
-
def max_count(self) -> Optional[pulumi.Input[int]]:
|
|
231
|
+
def max_count(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
223
232
|
"""
|
|
224
233
|
Maximum node count limit.
|
|
225
234
|
"""
|
|
226
235
|
return pulumi.get(self, "max_count")
|
|
227
236
|
|
|
228
237
|
@max_count.setter
|
|
229
|
-
def max_count(self, value: Optional[pulumi.Input[int]]):
|
|
238
|
+
def max_count(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
230
239
|
pulumi.set(self, "max_count", value)
|
|
231
240
|
|
|
232
|
-
@property
|
|
241
|
+
@_builtins.property
|
|
233
242
|
@pulumi.getter(name="maxPodsPerNode")
|
|
234
|
-
def max_pods_per_node(self) -> Optional[pulumi.Input[int]]:
|
|
243
|
+
def max_pods_per_node(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
235
244
|
"""
|
|
236
245
|
The maximum number of pods per node in the node pools.
|
|
237
246
|
"""
|
|
238
247
|
return pulumi.get(self, "max_pods_per_node")
|
|
239
248
|
|
|
240
249
|
@max_pods_per_node.setter
|
|
241
|
-
def max_pods_per_node(self, value: Optional[pulumi.Input[int]]):
|
|
250
|
+
def max_pods_per_node(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
242
251
|
pulumi.set(self, "max_pods_per_node", value)
|
|
243
252
|
|
|
244
|
-
@property
|
|
253
|
+
@_builtins.property
|
|
245
254
|
@pulumi.getter(name="minCount")
|
|
246
|
-
def min_count(self) -> Optional[pulumi.Input[int]]:
|
|
255
|
+
def min_count(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
247
256
|
"""
|
|
248
257
|
Minimum node count limit.
|
|
249
258
|
"""
|
|
250
259
|
return pulumi.get(self, "min_count")
|
|
251
260
|
|
|
252
261
|
@min_count.setter
|
|
253
|
-
def min_count(self, value: Optional[pulumi.Input[int]]):
|
|
262
|
+
def min_count(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
254
263
|
pulumi.set(self, "min_count", value)
|
|
255
264
|
|
|
256
|
-
@property
|
|
265
|
+
@_builtins.property
|
|
257
266
|
@pulumi.getter
|
|
258
|
-
def name(self) -> Optional[pulumi.Input[str]]:
|
|
267
|
+
def name(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
259
268
|
"""
|
|
260
269
|
Enter a name for the virtual node group.
|
|
261
270
|
"""
|
|
262
271
|
return pulumi.get(self, "name")
|
|
263
272
|
|
|
264
273
|
@name.setter
|
|
265
|
-
def name(self, value: Optional[pulumi.Input[str]]):
|
|
274
|
+
def name(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
266
275
|
pulumi.set(self, "name", value)
|
|
267
276
|
|
|
268
|
-
@property
|
|
277
|
+
@_builtins.property
|
|
269
278
|
@pulumi.getter(name="osDiskSizeGb")
|
|
270
|
-
def os_disk_size_gb(self) -> Optional[pulumi.Input[int]]:
|
|
279
|
+
def os_disk_size_gb(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
271
280
|
"""
|
|
272
281
|
The size of the OS disk in GB.
|
|
273
282
|
"""
|
|
274
283
|
return pulumi.get(self, "os_disk_size_gb")
|
|
275
284
|
|
|
276
285
|
@os_disk_size_gb.setter
|
|
277
|
-
def os_disk_size_gb(self, value: Optional[pulumi.Input[int]]):
|
|
286
|
+
def os_disk_size_gb(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
278
287
|
pulumi.set(self, "os_disk_size_gb", value)
|
|
279
288
|
|
|
280
|
-
@property
|
|
289
|
+
@_builtins.property
|
|
281
290
|
@pulumi.getter(name="osDiskType")
|
|
282
|
-
def os_disk_type(self) -> Optional[pulumi.Input[str]]:
|
|
291
|
+
def os_disk_type(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
283
292
|
"""
|
|
284
293
|
The type of the OS disk.
|
|
285
294
|
"""
|
|
286
295
|
return pulumi.get(self, "os_disk_type")
|
|
287
296
|
|
|
288
297
|
@os_disk_type.setter
|
|
289
|
-
def os_disk_type(self, value: Optional[pulumi.Input[str]]):
|
|
298
|
+
def os_disk_type(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
290
299
|
pulumi.set(self, "os_disk_type", value)
|
|
291
300
|
|
|
292
|
-
@property
|
|
301
|
+
@_builtins.property
|
|
293
302
|
@pulumi.getter(name="osSku")
|
|
294
|
-
def os_sku(self) -> Optional[pulumi.Input[str]]:
|
|
303
|
+
def os_sku(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
295
304
|
"""
|
|
296
305
|
The OS SKU of the OS type. Must correlate with the os type.
|
|
297
306
|
"""
|
|
298
307
|
return pulumi.get(self, "os_sku")
|
|
299
308
|
|
|
300
309
|
@os_sku.setter
|
|
301
|
-
def os_sku(self, value: Optional[pulumi.Input[str]]):
|
|
310
|
+
def os_sku(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
302
311
|
pulumi.set(self, "os_sku", value)
|
|
303
312
|
|
|
304
|
-
@property
|
|
313
|
+
@_builtins.property
|
|
305
314
|
@pulumi.getter(name="osType")
|
|
306
|
-
def os_type(self) -> Optional[pulumi.Input[str]]:
|
|
315
|
+
def os_type(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
307
316
|
"""
|
|
308
317
|
The OS type of the OS disk. Can't be modified once set.
|
|
309
318
|
"""
|
|
310
319
|
return pulumi.get(self, "os_type")
|
|
311
320
|
|
|
312
321
|
@os_type.setter
|
|
313
|
-
def os_type(self, value: Optional[pulumi.Input[str]]):
|
|
322
|
+
def os_type(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
314
323
|
pulumi.set(self, "os_type", value)
|
|
315
324
|
|
|
316
|
-
@property
|
|
325
|
+
@_builtins.property
|
|
317
326
|
@pulumi.getter(name="podSubnetIds")
|
|
318
|
-
def pod_subnet_ids(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
|
|
327
|
+
def pod_subnet_ids(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
|
|
319
328
|
"""
|
|
320
329
|
The IDs of subnets in an existing VNet into which to assign pods in the cluster (requires azure network-plugin).
|
|
321
330
|
"""
|
|
322
331
|
return pulumi.get(self, "pod_subnet_ids")
|
|
323
332
|
|
|
324
333
|
@pod_subnet_ids.setter
|
|
325
|
-
def pod_subnet_ids(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
|
|
334
|
+
def pod_subnet_ids(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]):
|
|
326
335
|
pulumi.set(self, "pod_subnet_ids", value)
|
|
327
336
|
|
|
328
|
-
@property
|
|
337
|
+
@_builtins.property
|
|
338
|
+
@pulumi.getter
|
|
339
|
+
def scheduling(self) -> Optional[pulumi.Input['OceanNpVirtualNodeGroupSchedulingArgs']]:
|
|
340
|
+
"""
|
|
341
|
+
An object used to specify times when the virtual node group will turn off all its node pools. Once the shutdown time will be over, the virtual node group will return to its previous state.
|
|
342
|
+
"""
|
|
343
|
+
return pulumi.get(self, "scheduling")
|
|
344
|
+
|
|
345
|
+
@scheduling.setter
|
|
346
|
+
def scheduling(self, value: Optional[pulumi.Input['OceanNpVirtualNodeGroupSchedulingArgs']]):
|
|
347
|
+
pulumi.set(self, "scheduling", value)
|
|
348
|
+
|
|
349
|
+
@_builtins.property
|
|
329
350
|
@pulumi.getter(name="spotPercentage")
|
|
330
|
-
def spot_percentage(self) -> Optional[pulumi.Input[int]]:
|
|
351
|
+
def spot_percentage(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
331
352
|
"""
|
|
332
353
|
Percentage of spot VMs to maintain.
|
|
333
354
|
"""
|
|
334
355
|
return pulumi.get(self, "spot_percentage")
|
|
335
356
|
|
|
336
357
|
@spot_percentage.setter
|
|
337
|
-
def spot_percentage(self, value: Optional[pulumi.Input[int]]):
|
|
358
|
+
def spot_percentage(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
338
359
|
pulumi.set(self, "spot_percentage", value)
|
|
339
360
|
|
|
340
|
-
@property
|
|
361
|
+
@_builtins.property
|
|
341
362
|
@pulumi.getter
|
|
342
|
-
def tags(self) -> Optional[pulumi.Input[Mapping[str,
|
|
363
|
+
def tags(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]]]:
|
|
343
364
|
return pulumi.get(self, "tags")
|
|
344
365
|
|
|
345
366
|
@tags.setter
|
|
346
|
-
def tags(self, value: Optional[pulumi.Input[Mapping[str,
|
|
367
|
+
def tags(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]]]):
|
|
347
368
|
pulumi.set(self, "tags", value)
|
|
348
369
|
|
|
349
|
-
@property
|
|
370
|
+
@_builtins.property
|
|
350
371
|
@pulumi.getter
|
|
351
372
|
def taints(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['OceanNpVirtualNodeGroupTaintArgs']]]]:
|
|
352
373
|
"""
|
|
@@ -358,7 +379,7 @@ class OceanNpVirtualNodeGroupArgs:
|
|
|
358
379
|
def taints(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['OceanNpVirtualNodeGroupTaintArgs']]]]):
|
|
359
380
|
pulumi.set(self, "taints", value)
|
|
360
381
|
|
|
361
|
-
@property
|
|
382
|
+
@_builtins.property
|
|
362
383
|
@pulumi.getter(name="updatePolicy")
|
|
363
384
|
def update_policy(self) -> Optional[pulumi.Input['OceanNpVirtualNodeGroupUpdatePolicyArgs']]:
|
|
364
385
|
return pulumi.get(self, "update_policy")
|
|
@@ -367,68 +388,70 @@ class OceanNpVirtualNodeGroupArgs:
|
|
|
367
388
|
def update_policy(self, value: Optional[pulumi.Input['OceanNpVirtualNodeGroupUpdatePolicyArgs']]):
|
|
368
389
|
pulumi.set(self, "update_policy", value)
|
|
369
390
|
|
|
370
|
-
@property
|
|
391
|
+
@_builtins.property
|
|
371
392
|
@pulumi.getter(name="vnetSubnetIds")
|
|
372
|
-
def vnet_subnet_ids(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
|
|
393
|
+
def vnet_subnet_ids(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
|
|
373
394
|
"""
|
|
374
395
|
The IDs of subnets in an existing VNet into which to assign nodes in the cluster (requires azure network-plugin).
|
|
375
396
|
"""
|
|
376
397
|
return pulumi.get(self, "vnet_subnet_ids")
|
|
377
398
|
|
|
378
399
|
@vnet_subnet_ids.setter
|
|
379
|
-
def vnet_subnet_ids(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
|
|
400
|
+
def vnet_subnet_ids(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]):
|
|
380
401
|
pulumi.set(self, "vnet_subnet_ids", value)
|
|
381
402
|
|
|
382
403
|
|
|
383
404
|
@pulumi.input_type
|
|
384
405
|
class _OceanNpVirtualNodeGroupState:
|
|
385
406
|
def __init__(__self__, *,
|
|
386
|
-
availability_zones: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
|
|
387
|
-
enable_node_public_ip: Optional[pulumi.Input[bool]] = None,
|
|
388
|
-
fallback_to_ondemand: Optional[pulumi.Input[bool]] = None,
|
|
407
|
+
availability_zones: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
408
|
+
enable_node_public_ip: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
409
|
+
fallback_to_ondemand: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
389
410
|
filters: Optional[pulumi.Input['OceanNpVirtualNodeGroupFiltersArgs']] = None,
|
|
390
411
|
headrooms: Optional[pulumi.Input[Sequence[pulumi.Input['OceanNpVirtualNodeGroupHeadroomArgs']]]] = None,
|
|
391
|
-
kubernetes_version: Optional[pulumi.Input[str]] = None,
|
|
392
|
-
labels: Optional[pulumi.Input[Mapping[str,
|
|
412
|
+
kubernetes_version: Optional[pulumi.Input[_builtins.str]] = None,
|
|
413
|
+
labels: Optional[pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]]] = None,
|
|
393
414
|
linux_os_configs: Optional[pulumi.Input[Sequence[pulumi.Input['OceanNpVirtualNodeGroupLinuxOsConfigArgs']]]] = None,
|
|
394
|
-
max_count: Optional[pulumi.Input[int]] = None,
|
|
395
|
-
max_pods_per_node: Optional[pulumi.Input[int]] = None,
|
|
396
|
-
min_count: Optional[pulumi.Input[int]] = None,
|
|
397
|
-
name: Optional[pulumi.Input[str]] = None,
|
|
398
|
-
ocean_id: Optional[pulumi.Input[str]] = None,
|
|
399
|
-
os_disk_size_gb: Optional[pulumi.Input[int]] = None,
|
|
400
|
-
os_disk_type: Optional[pulumi.Input[str]] = None,
|
|
401
|
-
os_sku: Optional[pulumi.Input[str]] = None,
|
|
402
|
-
os_type: Optional[pulumi.Input[str]] = None,
|
|
403
|
-
pod_subnet_ids: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
|
|
404
|
-
|
|
405
|
-
|
|
415
|
+
max_count: Optional[pulumi.Input[_builtins.int]] = None,
|
|
416
|
+
max_pods_per_node: Optional[pulumi.Input[_builtins.int]] = None,
|
|
417
|
+
min_count: Optional[pulumi.Input[_builtins.int]] = None,
|
|
418
|
+
name: Optional[pulumi.Input[_builtins.str]] = None,
|
|
419
|
+
ocean_id: Optional[pulumi.Input[_builtins.str]] = None,
|
|
420
|
+
os_disk_size_gb: Optional[pulumi.Input[_builtins.int]] = None,
|
|
421
|
+
os_disk_type: Optional[pulumi.Input[_builtins.str]] = None,
|
|
422
|
+
os_sku: Optional[pulumi.Input[_builtins.str]] = None,
|
|
423
|
+
os_type: Optional[pulumi.Input[_builtins.str]] = None,
|
|
424
|
+
pod_subnet_ids: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
425
|
+
scheduling: Optional[pulumi.Input['OceanNpVirtualNodeGroupSchedulingArgs']] = None,
|
|
426
|
+
spot_percentage: Optional[pulumi.Input[_builtins.int]] = None,
|
|
427
|
+
tags: Optional[pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]]] = None,
|
|
406
428
|
taints: Optional[pulumi.Input[Sequence[pulumi.Input['OceanNpVirtualNodeGroupTaintArgs']]]] = None,
|
|
407
429
|
update_policy: Optional[pulumi.Input['OceanNpVirtualNodeGroupUpdatePolicyArgs']] = None,
|
|
408
|
-
vnet_subnet_ids: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None):
|
|
430
|
+
vnet_subnet_ids: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None):
|
|
409
431
|
"""
|
|
410
432
|
Input properties used for looking up and filtering OceanNpVirtualNodeGroup resources.
|
|
411
|
-
:param pulumi.Input[Sequence[pulumi.Input[str]]] availability_zones: An Array holding Availability Zones, this configures the availability zones the Ocean may launch instances in per VNG.
|
|
412
|
-
:param pulumi.Input[bool] enable_node_public_ip: Enable node public IP.
|
|
413
|
-
:param pulumi.Input[bool] fallback_to_ondemand: If no spot instance markets are available, enable Ocean to launch on-demand instances instead.
|
|
433
|
+
:param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] availability_zones: An Array holding Availability Zones, this configures the availability zones the Ocean may launch instances in per VNG.
|
|
434
|
+
:param pulumi.Input[_builtins.bool] enable_node_public_ip: Enable node public IP.
|
|
435
|
+
:param pulumi.Input[_builtins.bool] fallback_to_ondemand: If no spot instance markets are available, enable Ocean to launch on-demand instances instead.
|
|
414
436
|
:param pulumi.Input['OceanNpVirtualNodeGroupFiltersArgs'] filters: Filters for the VM sizes that can be launched from the virtual node group.
|
|
415
437
|
:param pulumi.Input[Sequence[pulumi.Input['OceanNpVirtualNodeGroupHeadroomArgs']]] headrooms: Specify the custom headroom per VNG. Provide a list of headroom objects.
|
|
416
|
-
:param pulumi.Input[str] kubernetes_version: The desired Kubernetes version of the launched nodes. In case the value is null, the Kubernetes version of the control plane is used.
|
|
417
|
-
:param pulumi.Input[Mapping[str,
|
|
438
|
+
:param pulumi.Input[_builtins.str] kubernetes_version: The desired Kubernetes version of the launched nodes. In case the value is null, the Kubernetes version of the control plane is used.
|
|
439
|
+
:param pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]] labels: An array of labels to add to the virtual node group.Only custom user labels are allowed, and not Kubernetes built-in labels or Spot internal labels.
|
|
418
440
|
:param pulumi.Input[Sequence[pulumi.Input['OceanNpVirtualNodeGroupLinuxOsConfigArgs']]] linux_os_configs: Custom Linux OS configuration.
|
|
419
|
-
:param pulumi.Input[int] max_count: Maximum node count limit.
|
|
420
|
-
:param pulumi.Input[int] max_pods_per_node: The maximum number of pods per node in the node pools.
|
|
421
|
-
:param pulumi.Input[int] min_count: Minimum node count limit.
|
|
422
|
-
:param pulumi.Input[str] name: Enter a name for the virtual node group.
|
|
423
|
-
:param pulumi.Input[str] ocean_id: The Ocean cluster identifier. Required for Launch Spec creation.
|
|
424
|
-
:param pulumi.Input[int] os_disk_size_gb: The size of the OS disk in GB.
|
|
425
|
-
:param pulumi.Input[str] os_disk_type: The type of the OS disk.
|
|
426
|
-
:param pulumi.Input[str] os_sku: The OS SKU of the OS type. Must correlate with the os type.
|
|
427
|
-
:param pulumi.Input[str] os_type: The OS type of the OS disk. Can't be modified once set.
|
|
428
|
-
:param pulumi.Input[Sequence[pulumi.Input[str]]] pod_subnet_ids: The IDs of subnets in an existing VNet into which to assign pods in the cluster (requires azure network-plugin).
|
|
429
|
-
:param pulumi.Input[
|
|
441
|
+
:param pulumi.Input[_builtins.int] max_count: Maximum node count limit.
|
|
442
|
+
:param pulumi.Input[_builtins.int] max_pods_per_node: The maximum number of pods per node in the node pools.
|
|
443
|
+
:param pulumi.Input[_builtins.int] min_count: Minimum node count limit.
|
|
444
|
+
:param pulumi.Input[_builtins.str] name: Enter a name for the virtual node group.
|
|
445
|
+
:param pulumi.Input[_builtins.str] ocean_id: The Ocean cluster identifier. Required for Launch Spec creation.
|
|
446
|
+
:param pulumi.Input[_builtins.int] os_disk_size_gb: The size of the OS disk in GB.
|
|
447
|
+
:param pulumi.Input[_builtins.str] os_disk_type: The type of the OS disk.
|
|
448
|
+
:param pulumi.Input[_builtins.str] os_sku: The OS SKU of the OS type. Must correlate with the os type.
|
|
449
|
+
:param pulumi.Input[_builtins.str] os_type: The OS type of the OS disk. Can't be modified once set.
|
|
450
|
+
:param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] pod_subnet_ids: The IDs of subnets in an existing VNet into which to assign pods in the cluster (requires azure network-plugin).
|
|
451
|
+
:param pulumi.Input['OceanNpVirtualNodeGroupSchedulingArgs'] scheduling: An object used to specify times when the virtual node group will turn off all its node pools. Once the shutdown time will be over, the virtual node group will return to its previous state.
|
|
452
|
+
:param pulumi.Input[_builtins.int] spot_percentage: Percentage of spot VMs to maintain.
|
|
430
453
|
:param pulumi.Input[Sequence[pulumi.Input['OceanNpVirtualNodeGroupTaintArgs']]] taints: Add taints to a virtual node group.
|
|
431
|
-
:param pulumi.Input[Sequence[pulumi.Input[str]]] vnet_subnet_ids: The IDs of subnets in an existing VNet into which to assign nodes in the cluster (requires azure network-plugin).
|
|
454
|
+
:param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] vnet_subnet_ids: The IDs of subnets in an existing VNet into which to assign nodes in the cluster (requires azure network-plugin).
|
|
432
455
|
"""
|
|
433
456
|
if availability_zones is not None:
|
|
434
457
|
pulumi.set(__self__, "availability_zones", availability_zones)
|
|
@@ -466,6 +489,8 @@ class _OceanNpVirtualNodeGroupState:
|
|
|
466
489
|
pulumi.set(__self__, "os_type", os_type)
|
|
467
490
|
if pod_subnet_ids is not None:
|
|
468
491
|
pulumi.set(__self__, "pod_subnet_ids", pod_subnet_ids)
|
|
492
|
+
if scheduling is not None:
|
|
493
|
+
pulumi.set(__self__, "scheduling", scheduling)
|
|
469
494
|
if spot_percentage is not None:
|
|
470
495
|
pulumi.set(__self__, "spot_percentage", spot_percentage)
|
|
471
496
|
if tags is not None:
|
|
@@ -477,43 +502,43 @@ class _OceanNpVirtualNodeGroupState:
|
|
|
477
502
|
if vnet_subnet_ids is not None:
|
|
478
503
|
pulumi.set(__self__, "vnet_subnet_ids", vnet_subnet_ids)
|
|
479
504
|
|
|
480
|
-
@property
|
|
505
|
+
@_builtins.property
|
|
481
506
|
@pulumi.getter(name="availabilityZones")
|
|
482
|
-
def availability_zones(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
|
|
507
|
+
def availability_zones(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
|
|
483
508
|
"""
|
|
484
509
|
An Array holding Availability Zones, this configures the availability zones the Ocean may launch instances in per VNG.
|
|
485
510
|
"""
|
|
486
511
|
return pulumi.get(self, "availability_zones")
|
|
487
512
|
|
|
488
513
|
@availability_zones.setter
|
|
489
|
-
def availability_zones(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
|
|
514
|
+
def availability_zones(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]):
|
|
490
515
|
pulumi.set(self, "availability_zones", value)
|
|
491
516
|
|
|
492
|
-
@property
|
|
517
|
+
@_builtins.property
|
|
493
518
|
@pulumi.getter(name="enableNodePublicIp")
|
|
494
|
-
def enable_node_public_ip(self) -> Optional[pulumi.Input[bool]]:
|
|
519
|
+
def enable_node_public_ip(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
495
520
|
"""
|
|
496
521
|
Enable node public IP.
|
|
497
522
|
"""
|
|
498
523
|
return pulumi.get(self, "enable_node_public_ip")
|
|
499
524
|
|
|
500
525
|
@enable_node_public_ip.setter
|
|
501
|
-
def enable_node_public_ip(self, value: Optional[pulumi.Input[bool]]):
|
|
526
|
+
def enable_node_public_ip(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
502
527
|
pulumi.set(self, "enable_node_public_ip", value)
|
|
503
528
|
|
|
504
|
-
@property
|
|
529
|
+
@_builtins.property
|
|
505
530
|
@pulumi.getter(name="fallbackToOndemand")
|
|
506
|
-
def fallback_to_ondemand(self) -> Optional[pulumi.Input[bool]]:
|
|
531
|
+
def fallback_to_ondemand(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
507
532
|
"""
|
|
508
533
|
If no spot instance markets are available, enable Ocean to launch on-demand instances instead.
|
|
509
534
|
"""
|
|
510
535
|
return pulumi.get(self, "fallback_to_ondemand")
|
|
511
536
|
|
|
512
537
|
@fallback_to_ondemand.setter
|
|
513
|
-
def fallback_to_ondemand(self, value: Optional[pulumi.Input[bool]]):
|
|
538
|
+
def fallback_to_ondemand(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
514
539
|
pulumi.set(self, "fallback_to_ondemand", value)
|
|
515
540
|
|
|
516
|
-
@property
|
|
541
|
+
@_builtins.property
|
|
517
542
|
@pulumi.getter
|
|
518
543
|
def filters(self) -> Optional[pulumi.Input['OceanNpVirtualNodeGroupFiltersArgs']]:
|
|
519
544
|
"""
|
|
@@ -525,7 +550,7 @@ class _OceanNpVirtualNodeGroupState:
|
|
|
525
550
|
def filters(self, value: Optional[pulumi.Input['OceanNpVirtualNodeGroupFiltersArgs']]):
|
|
526
551
|
pulumi.set(self, "filters", value)
|
|
527
552
|
|
|
528
|
-
@property
|
|
553
|
+
@_builtins.property
|
|
529
554
|
@pulumi.getter
|
|
530
555
|
def headrooms(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['OceanNpVirtualNodeGroupHeadroomArgs']]]]:
|
|
531
556
|
"""
|
|
@@ -537,31 +562,31 @@ class _OceanNpVirtualNodeGroupState:
|
|
|
537
562
|
def headrooms(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['OceanNpVirtualNodeGroupHeadroomArgs']]]]):
|
|
538
563
|
pulumi.set(self, "headrooms", value)
|
|
539
564
|
|
|
540
|
-
@property
|
|
565
|
+
@_builtins.property
|
|
541
566
|
@pulumi.getter(name="kubernetesVersion")
|
|
542
|
-
def kubernetes_version(self) -> Optional[pulumi.Input[str]]:
|
|
567
|
+
def kubernetes_version(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
543
568
|
"""
|
|
544
569
|
The desired Kubernetes version of the launched nodes. In case the value is null, the Kubernetes version of the control plane is used.
|
|
545
570
|
"""
|
|
546
571
|
return pulumi.get(self, "kubernetes_version")
|
|
547
572
|
|
|
548
573
|
@kubernetes_version.setter
|
|
549
|
-
def kubernetes_version(self, value: Optional[pulumi.Input[str]]):
|
|
574
|
+
def kubernetes_version(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
550
575
|
pulumi.set(self, "kubernetes_version", value)
|
|
551
576
|
|
|
552
|
-
@property
|
|
577
|
+
@_builtins.property
|
|
553
578
|
@pulumi.getter
|
|
554
|
-
def labels(self) -> Optional[pulumi.Input[Mapping[str,
|
|
579
|
+
def labels(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]]]:
|
|
555
580
|
"""
|
|
556
581
|
An array of labels to add to the virtual node group.Only custom user labels are allowed, and not Kubernetes built-in labels or Spot internal labels.
|
|
557
582
|
"""
|
|
558
583
|
return pulumi.get(self, "labels")
|
|
559
584
|
|
|
560
585
|
@labels.setter
|
|
561
|
-
def labels(self, value: Optional[pulumi.Input[Mapping[str,
|
|
586
|
+
def labels(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]]]):
|
|
562
587
|
pulumi.set(self, "labels", value)
|
|
563
588
|
|
|
564
|
-
@property
|
|
589
|
+
@_builtins.property
|
|
565
590
|
@pulumi.getter(name="linuxOsConfigs")
|
|
566
591
|
def linux_os_configs(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['OceanNpVirtualNodeGroupLinuxOsConfigArgs']]]]:
|
|
567
592
|
"""
|
|
@@ -573,148 +598,160 @@ class _OceanNpVirtualNodeGroupState:
|
|
|
573
598
|
def linux_os_configs(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['OceanNpVirtualNodeGroupLinuxOsConfigArgs']]]]):
|
|
574
599
|
pulumi.set(self, "linux_os_configs", value)
|
|
575
600
|
|
|
576
|
-
@property
|
|
601
|
+
@_builtins.property
|
|
577
602
|
@pulumi.getter(name="maxCount")
|
|
578
|
-
def max_count(self) -> Optional[pulumi.Input[int]]:
|
|
603
|
+
def max_count(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
579
604
|
"""
|
|
580
605
|
Maximum node count limit.
|
|
581
606
|
"""
|
|
582
607
|
return pulumi.get(self, "max_count")
|
|
583
608
|
|
|
584
609
|
@max_count.setter
|
|
585
|
-
def max_count(self, value: Optional[pulumi.Input[int]]):
|
|
610
|
+
def max_count(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
586
611
|
pulumi.set(self, "max_count", value)
|
|
587
612
|
|
|
588
|
-
@property
|
|
613
|
+
@_builtins.property
|
|
589
614
|
@pulumi.getter(name="maxPodsPerNode")
|
|
590
|
-
def max_pods_per_node(self) -> Optional[pulumi.Input[int]]:
|
|
615
|
+
def max_pods_per_node(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
591
616
|
"""
|
|
592
617
|
The maximum number of pods per node in the node pools.
|
|
593
618
|
"""
|
|
594
619
|
return pulumi.get(self, "max_pods_per_node")
|
|
595
620
|
|
|
596
621
|
@max_pods_per_node.setter
|
|
597
|
-
def max_pods_per_node(self, value: Optional[pulumi.Input[int]]):
|
|
622
|
+
def max_pods_per_node(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
598
623
|
pulumi.set(self, "max_pods_per_node", value)
|
|
599
624
|
|
|
600
|
-
@property
|
|
625
|
+
@_builtins.property
|
|
601
626
|
@pulumi.getter(name="minCount")
|
|
602
|
-
def min_count(self) -> Optional[pulumi.Input[int]]:
|
|
627
|
+
def min_count(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
603
628
|
"""
|
|
604
629
|
Minimum node count limit.
|
|
605
630
|
"""
|
|
606
631
|
return pulumi.get(self, "min_count")
|
|
607
632
|
|
|
608
633
|
@min_count.setter
|
|
609
|
-
def min_count(self, value: Optional[pulumi.Input[int]]):
|
|
634
|
+
def min_count(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
610
635
|
pulumi.set(self, "min_count", value)
|
|
611
636
|
|
|
612
|
-
@property
|
|
637
|
+
@_builtins.property
|
|
613
638
|
@pulumi.getter
|
|
614
|
-
def name(self) -> Optional[pulumi.Input[str]]:
|
|
639
|
+
def name(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
615
640
|
"""
|
|
616
641
|
Enter a name for the virtual node group.
|
|
617
642
|
"""
|
|
618
643
|
return pulumi.get(self, "name")
|
|
619
644
|
|
|
620
645
|
@name.setter
|
|
621
|
-
def name(self, value: Optional[pulumi.Input[str]]):
|
|
646
|
+
def name(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
622
647
|
pulumi.set(self, "name", value)
|
|
623
648
|
|
|
624
|
-
@property
|
|
649
|
+
@_builtins.property
|
|
625
650
|
@pulumi.getter(name="oceanId")
|
|
626
|
-
def ocean_id(self) -> Optional[pulumi.Input[str]]:
|
|
651
|
+
def ocean_id(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
627
652
|
"""
|
|
628
653
|
The Ocean cluster identifier. Required for Launch Spec creation.
|
|
629
654
|
"""
|
|
630
655
|
return pulumi.get(self, "ocean_id")
|
|
631
656
|
|
|
632
657
|
@ocean_id.setter
|
|
633
|
-
def ocean_id(self, value: Optional[pulumi.Input[str]]):
|
|
658
|
+
def ocean_id(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
634
659
|
pulumi.set(self, "ocean_id", value)
|
|
635
660
|
|
|
636
|
-
@property
|
|
661
|
+
@_builtins.property
|
|
637
662
|
@pulumi.getter(name="osDiskSizeGb")
|
|
638
|
-
def os_disk_size_gb(self) -> Optional[pulumi.Input[int]]:
|
|
663
|
+
def os_disk_size_gb(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
639
664
|
"""
|
|
640
665
|
The size of the OS disk in GB.
|
|
641
666
|
"""
|
|
642
667
|
return pulumi.get(self, "os_disk_size_gb")
|
|
643
668
|
|
|
644
669
|
@os_disk_size_gb.setter
|
|
645
|
-
def os_disk_size_gb(self, value: Optional[pulumi.Input[int]]):
|
|
670
|
+
def os_disk_size_gb(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
646
671
|
pulumi.set(self, "os_disk_size_gb", value)
|
|
647
672
|
|
|
648
|
-
@property
|
|
673
|
+
@_builtins.property
|
|
649
674
|
@pulumi.getter(name="osDiskType")
|
|
650
|
-
def os_disk_type(self) -> Optional[pulumi.Input[str]]:
|
|
675
|
+
def os_disk_type(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
651
676
|
"""
|
|
652
677
|
The type of the OS disk.
|
|
653
678
|
"""
|
|
654
679
|
return pulumi.get(self, "os_disk_type")
|
|
655
680
|
|
|
656
681
|
@os_disk_type.setter
|
|
657
|
-
def os_disk_type(self, value: Optional[pulumi.Input[str]]):
|
|
682
|
+
def os_disk_type(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
658
683
|
pulumi.set(self, "os_disk_type", value)
|
|
659
684
|
|
|
660
|
-
@property
|
|
685
|
+
@_builtins.property
|
|
661
686
|
@pulumi.getter(name="osSku")
|
|
662
|
-
def os_sku(self) -> Optional[pulumi.Input[str]]:
|
|
687
|
+
def os_sku(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
663
688
|
"""
|
|
664
689
|
The OS SKU of the OS type. Must correlate with the os type.
|
|
665
690
|
"""
|
|
666
691
|
return pulumi.get(self, "os_sku")
|
|
667
692
|
|
|
668
693
|
@os_sku.setter
|
|
669
|
-
def os_sku(self, value: Optional[pulumi.Input[str]]):
|
|
694
|
+
def os_sku(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
670
695
|
pulumi.set(self, "os_sku", value)
|
|
671
696
|
|
|
672
|
-
@property
|
|
697
|
+
@_builtins.property
|
|
673
698
|
@pulumi.getter(name="osType")
|
|
674
|
-
def os_type(self) -> Optional[pulumi.Input[str]]:
|
|
699
|
+
def os_type(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
675
700
|
"""
|
|
676
701
|
The OS type of the OS disk. Can't be modified once set.
|
|
677
702
|
"""
|
|
678
703
|
return pulumi.get(self, "os_type")
|
|
679
704
|
|
|
680
705
|
@os_type.setter
|
|
681
|
-
def os_type(self, value: Optional[pulumi.Input[str]]):
|
|
706
|
+
def os_type(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
682
707
|
pulumi.set(self, "os_type", value)
|
|
683
708
|
|
|
684
|
-
@property
|
|
709
|
+
@_builtins.property
|
|
685
710
|
@pulumi.getter(name="podSubnetIds")
|
|
686
|
-
def pod_subnet_ids(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
|
|
711
|
+
def pod_subnet_ids(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
|
|
687
712
|
"""
|
|
688
713
|
The IDs of subnets in an existing VNet into which to assign pods in the cluster (requires azure network-plugin).
|
|
689
714
|
"""
|
|
690
715
|
return pulumi.get(self, "pod_subnet_ids")
|
|
691
716
|
|
|
692
717
|
@pod_subnet_ids.setter
|
|
693
|
-
def pod_subnet_ids(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
|
|
718
|
+
def pod_subnet_ids(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]):
|
|
694
719
|
pulumi.set(self, "pod_subnet_ids", value)
|
|
695
720
|
|
|
696
|
-
@property
|
|
721
|
+
@_builtins.property
|
|
722
|
+
@pulumi.getter
|
|
723
|
+
def scheduling(self) -> Optional[pulumi.Input['OceanNpVirtualNodeGroupSchedulingArgs']]:
|
|
724
|
+
"""
|
|
725
|
+
An object used to specify times when the virtual node group will turn off all its node pools. Once the shutdown time will be over, the virtual node group will return to its previous state.
|
|
726
|
+
"""
|
|
727
|
+
return pulumi.get(self, "scheduling")
|
|
728
|
+
|
|
729
|
+
@scheduling.setter
|
|
730
|
+
def scheduling(self, value: Optional[pulumi.Input['OceanNpVirtualNodeGroupSchedulingArgs']]):
|
|
731
|
+
pulumi.set(self, "scheduling", value)
|
|
732
|
+
|
|
733
|
+
@_builtins.property
|
|
697
734
|
@pulumi.getter(name="spotPercentage")
|
|
698
|
-
def spot_percentage(self) -> Optional[pulumi.Input[int]]:
|
|
735
|
+
def spot_percentage(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
699
736
|
"""
|
|
700
737
|
Percentage of spot VMs to maintain.
|
|
701
738
|
"""
|
|
702
739
|
return pulumi.get(self, "spot_percentage")
|
|
703
740
|
|
|
704
741
|
@spot_percentage.setter
|
|
705
|
-
def spot_percentage(self, value: Optional[pulumi.Input[int]]):
|
|
742
|
+
def spot_percentage(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
706
743
|
pulumi.set(self, "spot_percentage", value)
|
|
707
744
|
|
|
708
|
-
@property
|
|
745
|
+
@_builtins.property
|
|
709
746
|
@pulumi.getter
|
|
710
|
-
def tags(self) -> Optional[pulumi.Input[Mapping[str,
|
|
747
|
+
def tags(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]]]:
|
|
711
748
|
return pulumi.get(self, "tags")
|
|
712
749
|
|
|
713
750
|
@tags.setter
|
|
714
|
-
def tags(self, value: Optional[pulumi.Input[Mapping[str,
|
|
751
|
+
def tags(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]]]):
|
|
715
752
|
pulumi.set(self, "tags", value)
|
|
716
753
|
|
|
717
|
-
@property
|
|
754
|
+
@_builtins.property
|
|
718
755
|
@pulumi.getter
|
|
719
756
|
def taints(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['OceanNpVirtualNodeGroupTaintArgs']]]]:
|
|
720
757
|
"""
|
|
@@ -726,7 +763,7 @@ class _OceanNpVirtualNodeGroupState:
|
|
|
726
763
|
def taints(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['OceanNpVirtualNodeGroupTaintArgs']]]]):
|
|
727
764
|
pulumi.set(self, "taints", value)
|
|
728
765
|
|
|
729
|
-
@property
|
|
766
|
+
@_builtins.property
|
|
730
767
|
@pulumi.getter(name="updatePolicy")
|
|
731
768
|
def update_policy(self) -> Optional[pulumi.Input['OceanNpVirtualNodeGroupUpdatePolicyArgs']]:
|
|
732
769
|
return pulumi.get(self, "update_policy")
|
|
@@ -735,47 +772,49 @@ class _OceanNpVirtualNodeGroupState:
|
|
|
735
772
|
def update_policy(self, value: Optional[pulumi.Input['OceanNpVirtualNodeGroupUpdatePolicyArgs']]):
|
|
736
773
|
pulumi.set(self, "update_policy", value)
|
|
737
774
|
|
|
738
|
-
@property
|
|
775
|
+
@_builtins.property
|
|
739
776
|
@pulumi.getter(name="vnetSubnetIds")
|
|
740
|
-
def vnet_subnet_ids(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
|
|
777
|
+
def vnet_subnet_ids(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
|
|
741
778
|
"""
|
|
742
779
|
The IDs of subnets in an existing VNet into which to assign nodes in the cluster (requires azure network-plugin).
|
|
743
780
|
"""
|
|
744
781
|
return pulumi.get(self, "vnet_subnet_ids")
|
|
745
782
|
|
|
746
783
|
@vnet_subnet_ids.setter
|
|
747
|
-
def vnet_subnet_ids(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
|
|
784
|
+
def vnet_subnet_ids(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]):
|
|
748
785
|
pulumi.set(self, "vnet_subnet_ids", value)
|
|
749
786
|
|
|
750
787
|
|
|
788
|
+
@pulumi.type_token("spotinst:azure/oceanNpVirtualNodeGroup:OceanNpVirtualNodeGroup")
|
|
751
789
|
class OceanNpVirtualNodeGroup(pulumi.CustomResource):
|
|
752
790
|
@overload
|
|
753
791
|
def __init__(__self__,
|
|
754
792
|
resource_name: str,
|
|
755
793
|
opts: Optional[pulumi.ResourceOptions] = None,
|
|
756
|
-
availability_zones: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
|
|
757
|
-
enable_node_public_ip: Optional[pulumi.Input[bool]] = None,
|
|
758
|
-
fallback_to_ondemand: Optional[pulumi.Input[bool]] = None,
|
|
759
|
-
filters: Optional[pulumi.Input[
|
|
760
|
-
headrooms: Optional[pulumi.Input[Sequence[pulumi.Input[
|
|
761
|
-
kubernetes_version: Optional[pulumi.Input[str]] = None,
|
|
762
|
-
labels: Optional[pulumi.Input[Mapping[str,
|
|
763
|
-
linux_os_configs: Optional[pulumi.Input[Sequence[pulumi.Input[
|
|
764
|
-
max_count: Optional[pulumi.Input[int]] = None,
|
|
765
|
-
max_pods_per_node: Optional[pulumi.Input[int]] = None,
|
|
766
|
-
min_count: Optional[pulumi.Input[int]] = None,
|
|
767
|
-
name: Optional[pulumi.Input[str]] = None,
|
|
768
|
-
ocean_id: Optional[pulumi.Input[str]] = None,
|
|
769
|
-
os_disk_size_gb: Optional[pulumi.Input[int]] = None,
|
|
770
|
-
os_disk_type: Optional[pulumi.Input[str]] = None,
|
|
771
|
-
os_sku: Optional[pulumi.Input[str]] = None,
|
|
772
|
-
os_type: Optional[pulumi.Input[str]] = None,
|
|
773
|
-
pod_subnet_ids: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
|
|
774
|
-
|
|
775
|
-
|
|
776
|
-
|
|
777
|
-
|
|
778
|
-
|
|
794
|
+
availability_zones: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
795
|
+
enable_node_public_ip: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
796
|
+
fallback_to_ondemand: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
797
|
+
filters: Optional[pulumi.Input[Union['OceanNpVirtualNodeGroupFiltersArgs', 'OceanNpVirtualNodeGroupFiltersArgsDict']]] = None,
|
|
798
|
+
headrooms: Optional[pulumi.Input[Sequence[pulumi.Input[Union['OceanNpVirtualNodeGroupHeadroomArgs', 'OceanNpVirtualNodeGroupHeadroomArgsDict']]]]] = None,
|
|
799
|
+
kubernetes_version: Optional[pulumi.Input[_builtins.str]] = None,
|
|
800
|
+
labels: Optional[pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]]] = None,
|
|
801
|
+
linux_os_configs: Optional[pulumi.Input[Sequence[pulumi.Input[Union['OceanNpVirtualNodeGroupLinuxOsConfigArgs', 'OceanNpVirtualNodeGroupLinuxOsConfigArgsDict']]]]] = None,
|
|
802
|
+
max_count: Optional[pulumi.Input[_builtins.int]] = None,
|
|
803
|
+
max_pods_per_node: Optional[pulumi.Input[_builtins.int]] = None,
|
|
804
|
+
min_count: Optional[pulumi.Input[_builtins.int]] = None,
|
|
805
|
+
name: Optional[pulumi.Input[_builtins.str]] = None,
|
|
806
|
+
ocean_id: Optional[pulumi.Input[_builtins.str]] = None,
|
|
807
|
+
os_disk_size_gb: Optional[pulumi.Input[_builtins.int]] = None,
|
|
808
|
+
os_disk_type: Optional[pulumi.Input[_builtins.str]] = None,
|
|
809
|
+
os_sku: Optional[pulumi.Input[_builtins.str]] = None,
|
|
810
|
+
os_type: Optional[pulumi.Input[_builtins.str]] = None,
|
|
811
|
+
pod_subnet_ids: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
812
|
+
scheduling: Optional[pulumi.Input[Union['OceanNpVirtualNodeGroupSchedulingArgs', 'OceanNpVirtualNodeGroupSchedulingArgsDict']]] = None,
|
|
813
|
+
spot_percentage: Optional[pulumi.Input[_builtins.int]] = None,
|
|
814
|
+
tags: Optional[pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]]] = None,
|
|
815
|
+
taints: Optional[pulumi.Input[Sequence[pulumi.Input[Union['OceanNpVirtualNodeGroupTaintArgs', 'OceanNpVirtualNodeGroupTaintArgsDict']]]]] = None,
|
|
816
|
+
update_policy: Optional[pulumi.Input[Union['OceanNpVirtualNodeGroupUpdatePolicyArgs', 'OceanNpVirtualNodeGroupUpdatePolicyArgsDict']]] = None,
|
|
817
|
+
vnet_subnet_ids: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
779
818
|
__props__=None):
|
|
780
819
|
"""
|
|
781
820
|
Manages a Spotinst Ocean AKS Virtual Node Groups resource.
|
|
@@ -789,12 +828,12 @@ class OceanNpVirtualNodeGroup(pulumi.CustomResource):
|
|
|
789
828
|
example = spotinst.azure.OceanNpVirtualNodeGroup("example",
|
|
790
829
|
name="testVng",
|
|
791
830
|
ocean_id="o-134abcd",
|
|
792
|
-
headrooms=[
|
|
793
|
-
cpu_per_unit
|
|
794
|
-
memory_per_unit
|
|
795
|
-
gpu_per_unit
|
|
796
|
-
num_of_units
|
|
797
|
-
|
|
831
|
+
headrooms=[{
|
|
832
|
+
"cpu_per_unit": 1024,
|
|
833
|
+
"memory_per_unit": 512,
|
|
834
|
+
"gpu_per_unit": 0,
|
|
835
|
+
"num_of_units": 2,
|
|
836
|
+
}],
|
|
798
837
|
availability_zones=[
|
|
799
838
|
"1",
|
|
800
839
|
"2",
|
|
@@ -815,80 +854,90 @@ class OceanNpVirtualNodeGroup(pulumi.CustomResource):
|
|
|
815
854
|
kubernetes_version="1.26",
|
|
816
855
|
pod_subnet_ids=["/subscriptions/123456-1234-1234-1234-123456789/resourceGroups/ExampleResourceGroup/providers/Microsoft.Network/virtualNetworks/ExampleVirtualNetwork/subnets/default"],
|
|
817
856
|
vnet_subnet_ids=["/subscriptions/123456-1234-1234-1234-123456789/resourceGroups/ExampleResourceGroup/providers/Microsoft.Network/virtualNetworks/ExampleVirtualNetwork/subnets/default"],
|
|
818
|
-
linux_os_configs=[
|
|
819
|
-
sysctls
|
|
820
|
-
vm_max_map_count
|
|
821
|
-
|
|
822
|
-
|
|
857
|
+
linux_os_configs=[{
|
|
858
|
+
"sysctls": [{
|
|
859
|
+
"vm_max_map_count": 79550,
|
|
860
|
+
}],
|
|
861
|
+
}],
|
|
823
862
|
spot_percentage=50,
|
|
824
863
|
fallback_to_ondemand=True,
|
|
825
|
-
taints=[
|
|
826
|
-
key
|
|
827
|
-
value
|
|
828
|
-
effect
|
|
829
|
-
|
|
864
|
+
taints=[{
|
|
865
|
+
"key": "taintKey",
|
|
866
|
+
"value": "taintValue",
|
|
867
|
+
"effect": "NoSchedule",
|
|
868
|
+
}],
|
|
830
869
|
tags={
|
|
831
870
|
"tagKey": "env",
|
|
832
871
|
"tagValue": "staging",
|
|
833
872
|
},
|
|
834
|
-
filters=
|
|
835
|
-
min_vcpu
|
|
836
|
-
max_vcpu
|
|
837
|
-
min_memory_gib
|
|
838
|
-
max_memory_gib
|
|
839
|
-
architectures
|
|
873
|
+
filters={
|
|
874
|
+
"min_vcpu": 2,
|
|
875
|
+
"max_vcpu": 16,
|
|
876
|
+
"min_memory_gib": 8,
|
|
877
|
+
"max_memory_gib": 128,
|
|
878
|
+
"architectures": [
|
|
840
879
|
"x86_64",
|
|
841
880
|
"arm64",
|
|
842
881
|
],
|
|
843
|
-
series
|
|
882
|
+
"series": [
|
|
844
883
|
"D v3",
|
|
845
884
|
"Dds_v4",
|
|
846
885
|
"Dsv2",
|
|
847
886
|
],
|
|
848
|
-
exclude_series
|
|
887
|
+
"exclude_series": [
|
|
849
888
|
"Av2",
|
|
850
889
|
"A",
|
|
851
890
|
"Bs",
|
|
852
891
|
"D",
|
|
853
892
|
"E",
|
|
854
893
|
],
|
|
855
|
-
accelerated_networking
|
|
856
|
-
disk_performance
|
|
857
|
-
min_gpu
|
|
858
|
-
max_gpu
|
|
859
|
-
min_nics
|
|
860
|
-
vm_types
|
|
894
|
+
"accelerated_networking": "Enabled",
|
|
895
|
+
"disk_performance": "Premium",
|
|
896
|
+
"min_gpu": 1,
|
|
897
|
+
"max_gpu": 2,
|
|
898
|
+
"min_nics": 1,
|
|
899
|
+
"vm_types": [
|
|
861
900
|
"generalPurpose",
|
|
862
901
|
"GPU",
|
|
863
902
|
],
|
|
864
|
-
min_disk
|
|
865
|
-
gpu_types
|
|
866
|
-
|
|
903
|
+
"min_disk": 1,
|
|
904
|
+
"gpu_types": ["nvidia-tesla-t4"],
|
|
905
|
+
},
|
|
906
|
+
scheduling={
|
|
907
|
+
"shutdown_hours": {
|
|
908
|
+
"is_enabled": True,
|
|
909
|
+
"time_windows": [
|
|
910
|
+
"Fri:15:30-Sat:20:30",
|
|
911
|
+
"Sun:08:30-Mon:08:30",
|
|
912
|
+
],
|
|
913
|
+
},
|
|
914
|
+
})
|
|
867
915
|
```
|
|
868
916
|
|
|
869
917
|
:param str resource_name: The name of the resource.
|
|
870
918
|
:param pulumi.ResourceOptions opts: Options for the resource.
|
|
871
|
-
:param pulumi.Input[Sequence[pulumi.Input[str]]] availability_zones: An Array holding Availability Zones, this configures the availability zones the Ocean may launch instances in per VNG.
|
|
872
|
-
:param pulumi.Input[bool] enable_node_public_ip: Enable node public IP.
|
|
873
|
-
:param pulumi.Input[bool] fallback_to_ondemand: If no spot instance markets are available, enable Ocean to launch on-demand instances instead.
|
|
874
|
-
:param pulumi.Input[
|
|
875
|
-
:param pulumi.Input[Sequence[pulumi.Input[
|
|
876
|
-
:param pulumi.Input[str] kubernetes_version: The desired Kubernetes version of the launched nodes. In case the value is null, the Kubernetes version of the control plane is used.
|
|
877
|
-
:param pulumi.Input[Mapping[str,
|
|
878
|
-
:param pulumi.Input[Sequence[pulumi.Input[
|
|
879
|
-
:param pulumi.Input[int] max_count: Maximum node count limit.
|
|
880
|
-
:param pulumi.Input[int] max_pods_per_node: The maximum number of pods per node in the node pools.
|
|
881
|
-
:param pulumi.Input[int] min_count: Minimum node count limit.
|
|
882
|
-
:param pulumi.Input[str] name: Enter a name for the virtual node group.
|
|
883
|
-
:param pulumi.Input[str] ocean_id: The Ocean cluster identifier. Required for Launch Spec creation.
|
|
884
|
-
:param pulumi.Input[int] os_disk_size_gb: The size of the OS disk in GB.
|
|
885
|
-
:param pulumi.Input[str] os_disk_type: The type of the OS disk.
|
|
886
|
-
:param pulumi.Input[str] os_sku: The OS SKU of the OS type. Must correlate with the os type.
|
|
887
|
-
:param pulumi.Input[str] os_type: The OS type of the OS disk. Can't be modified once set.
|
|
888
|
-
:param pulumi.Input[Sequence[pulumi.Input[str]]] pod_subnet_ids: The IDs of subnets in an existing VNet into which to assign pods in the cluster (requires azure network-plugin).
|
|
889
|
-
:param pulumi.Input[
|
|
890
|
-
:param pulumi.Input[
|
|
891
|
-
:param pulumi.Input[Sequence[pulumi.Input[
|
|
919
|
+
:param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] availability_zones: An Array holding Availability Zones, this configures the availability zones the Ocean may launch instances in per VNG.
|
|
920
|
+
:param pulumi.Input[_builtins.bool] enable_node_public_ip: Enable node public IP.
|
|
921
|
+
:param pulumi.Input[_builtins.bool] fallback_to_ondemand: If no spot instance markets are available, enable Ocean to launch on-demand instances instead.
|
|
922
|
+
:param pulumi.Input[Union['OceanNpVirtualNodeGroupFiltersArgs', 'OceanNpVirtualNodeGroupFiltersArgsDict']] filters: Filters for the VM sizes that can be launched from the virtual node group.
|
|
923
|
+
:param pulumi.Input[Sequence[pulumi.Input[Union['OceanNpVirtualNodeGroupHeadroomArgs', 'OceanNpVirtualNodeGroupHeadroomArgsDict']]]] headrooms: Specify the custom headroom per VNG. Provide a list of headroom objects.
|
|
924
|
+
:param pulumi.Input[_builtins.str] kubernetes_version: The desired Kubernetes version of the launched nodes. In case the value is null, the Kubernetes version of the control plane is used.
|
|
925
|
+
:param pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]] labels: An array of labels to add to the virtual node group.Only custom user labels are allowed, and not Kubernetes built-in labels or Spot internal labels.
|
|
926
|
+
:param pulumi.Input[Sequence[pulumi.Input[Union['OceanNpVirtualNodeGroupLinuxOsConfigArgs', 'OceanNpVirtualNodeGroupLinuxOsConfigArgsDict']]]] linux_os_configs: Custom Linux OS configuration.
|
|
927
|
+
:param pulumi.Input[_builtins.int] max_count: Maximum node count limit.
|
|
928
|
+
:param pulumi.Input[_builtins.int] max_pods_per_node: The maximum number of pods per node in the node pools.
|
|
929
|
+
:param pulumi.Input[_builtins.int] min_count: Minimum node count limit.
|
|
930
|
+
:param pulumi.Input[_builtins.str] name: Enter a name for the virtual node group.
|
|
931
|
+
:param pulumi.Input[_builtins.str] ocean_id: The Ocean cluster identifier. Required for Launch Spec creation.
|
|
932
|
+
:param pulumi.Input[_builtins.int] os_disk_size_gb: The size of the OS disk in GB.
|
|
933
|
+
:param pulumi.Input[_builtins.str] os_disk_type: The type of the OS disk.
|
|
934
|
+
:param pulumi.Input[_builtins.str] os_sku: The OS SKU of the OS type. Must correlate with the os type.
|
|
935
|
+
:param pulumi.Input[_builtins.str] os_type: The OS type of the OS disk. Can't be modified once set.
|
|
936
|
+
:param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] pod_subnet_ids: The IDs of subnets in an existing VNet into which to assign pods in the cluster (requires azure network-plugin).
|
|
937
|
+
:param pulumi.Input[Union['OceanNpVirtualNodeGroupSchedulingArgs', 'OceanNpVirtualNodeGroupSchedulingArgsDict']] scheduling: An object used to specify times when the virtual node group will turn off all its node pools. Once the shutdown time will be over, the virtual node group will return to its previous state.
|
|
938
|
+
:param pulumi.Input[_builtins.int] spot_percentage: Percentage of spot VMs to maintain.
|
|
939
|
+
:param pulumi.Input[Sequence[pulumi.Input[Union['OceanNpVirtualNodeGroupTaintArgs', 'OceanNpVirtualNodeGroupTaintArgsDict']]]] taints: Add taints to a virtual node group.
|
|
940
|
+
:param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] vnet_subnet_ids: The IDs of subnets in an existing VNet into which to assign nodes in the cluster (requires azure network-plugin).
|
|
892
941
|
"""
|
|
893
942
|
...
|
|
894
943
|
@overload
|
|
@@ -908,12 +957,12 @@ class OceanNpVirtualNodeGroup(pulumi.CustomResource):
|
|
|
908
957
|
example = spotinst.azure.OceanNpVirtualNodeGroup("example",
|
|
909
958
|
name="testVng",
|
|
910
959
|
ocean_id="o-134abcd",
|
|
911
|
-
headrooms=[
|
|
912
|
-
cpu_per_unit
|
|
913
|
-
memory_per_unit
|
|
914
|
-
gpu_per_unit
|
|
915
|
-
num_of_units
|
|
916
|
-
|
|
960
|
+
headrooms=[{
|
|
961
|
+
"cpu_per_unit": 1024,
|
|
962
|
+
"memory_per_unit": 512,
|
|
963
|
+
"gpu_per_unit": 0,
|
|
964
|
+
"num_of_units": 2,
|
|
965
|
+
}],
|
|
917
966
|
availability_zones=[
|
|
918
967
|
"1",
|
|
919
968
|
"2",
|
|
@@ -934,55 +983,64 @@ class OceanNpVirtualNodeGroup(pulumi.CustomResource):
|
|
|
934
983
|
kubernetes_version="1.26",
|
|
935
984
|
pod_subnet_ids=["/subscriptions/123456-1234-1234-1234-123456789/resourceGroups/ExampleResourceGroup/providers/Microsoft.Network/virtualNetworks/ExampleVirtualNetwork/subnets/default"],
|
|
936
985
|
vnet_subnet_ids=["/subscriptions/123456-1234-1234-1234-123456789/resourceGroups/ExampleResourceGroup/providers/Microsoft.Network/virtualNetworks/ExampleVirtualNetwork/subnets/default"],
|
|
937
|
-
linux_os_configs=[
|
|
938
|
-
sysctls
|
|
939
|
-
vm_max_map_count
|
|
940
|
-
|
|
941
|
-
|
|
986
|
+
linux_os_configs=[{
|
|
987
|
+
"sysctls": [{
|
|
988
|
+
"vm_max_map_count": 79550,
|
|
989
|
+
}],
|
|
990
|
+
}],
|
|
942
991
|
spot_percentage=50,
|
|
943
992
|
fallback_to_ondemand=True,
|
|
944
|
-
taints=[
|
|
945
|
-
key
|
|
946
|
-
value
|
|
947
|
-
effect
|
|
948
|
-
|
|
993
|
+
taints=[{
|
|
994
|
+
"key": "taintKey",
|
|
995
|
+
"value": "taintValue",
|
|
996
|
+
"effect": "NoSchedule",
|
|
997
|
+
}],
|
|
949
998
|
tags={
|
|
950
999
|
"tagKey": "env",
|
|
951
1000
|
"tagValue": "staging",
|
|
952
1001
|
},
|
|
953
|
-
filters=
|
|
954
|
-
min_vcpu
|
|
955
|
-
max_vcpu
|
|
956
|
-
min_memory_gib
|
|
957
|
-
max_memory_gib
|
|
958
|
-
architectures
|
|
1002
|
+
filters={
|
|
1003
|
+
"min_vcpu": 2,
|
|
1004
|
+
"max_vcpu": 16,
|
|
1005
|
+
"min_memory_gib": 8,
|
|
1006
|
+
"max_memory_gib": 128,
|
|
1007
|
+
"architectures": [
|
|
959
1008
|
"x86_64",
|
|
960
1009
|
"arm64",
|
|
961
1010
|
],
|
|
962
|
-
series
|
|
1011
|
+
"series": [
|
|
963
1012
|
"D v3",
|
|
964
1013
|
"Dds_v4",
|
|
965
1014
|
"Dsv2",
|
|
966
1015
|
],
|
|
967
|
-
exclude_series
|
|
1016
|
+
"exclude_series": [
|
|
968
1017
|
"Av2",
|
|
969
1018
|
"A",
|
|
970
1019
|
"Bs",
|
|
971
1020
|
"D",
|
|
972
1021
|
"E",
|
|
973
1022
|
],
|
|
974
|
-
accelerated_networking
|
|
975
|
-
disk_performance
|
|
976
|
-
min_gpu
|
|
977
|
-
max_gpu
|
|
978
|
-
min_nics
|
|
979
|
-
vm_types
|
|
1023
|
+
"accelerated_networking": "Enabled",
|
|
1024
|
+
"disk_performance": "Premium",
|
|
1025
|
+
"min_gpu": 1,
|
|
1026
|
+
"max_gpu": 2,
|
|
1027
|
+
"min_nics": 1,
|
|
1028
|
+
"vm_types": [
|
|
980
1029
|
"generalPurpose",
|
|
981
1030
|
"GPU",
|
|
982
1031
|
],
|
|
983
|
-
min_disk
|
|
984
|
-
gpu_types
|
|
985
|
-
|
|
1032
|
+
"min_disk": 1,
|
|
1033
|
+
"gpu_types": ["nvidia-tesla-t4"],
|
|
1034
|
+
},
|
|
1035
|
+
scheduling={
|
|
1036
|
+
"shutdown_hours": {
|
|
1037
|
+
"is_enabled": True,
|
|
1038
|
+
"time_windows": [
|
|
1039
|
+
"Fri:15:30-Sat:20:30",
|
|
1040
|
+
"Sun:08:30-Mon:08:30",
|
|
1041
|
+
],
|
|
1042
|
+
},
|
|
1043
|
+
})
|
|
986
1044
|
```
|
|
987
1045
|
|
|
988
1046
|
:param str resource_name: The name of the resource.
|
|
@@ -1000,29 +1058,30 @@ class OceanNpVirtualNodeGroup(pulumi.CustomResource):
|
|
|
1000
1058
|
def _internal_init(__self__,
|
|
1001
1059
|
resource_name: str,
|
|
1002
1060
|
opts: Optional[pulumi.ResourceOptions] = None,
|
|
1003
|
-
availability_zones: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
|
|
1004
|
-
enable_node_public_ip: Optional[pulumi.Input[bool]] = None,
|
|
1005
|
-
fallback_to_ondemand: Optional[pulumi.Input[bool]] = None,
|
|
1006
|
-
filters: Optional[pulumi.Input[
|
|
1007
|
-
headrooms: Optional[pulumi.Input[Sequence[pulumi.Input[
|
|
1008
|
-
kubernetes_version: Optional[pulumi.Input[str]] = None,
|
|
1009
|
-
labels: Optional[pulumi.Input[Mapping[str,
|
|
1010
|
-
linux_os_configs: Optional[pulumi.Input[Sequence[pulumi.Input[
|
|
1011
|
-
max_count: Optional[pulumi.Input[int]] = None,
|
|
1012
|
-
max_pods_per_node: Optional[pulumi.Input[int]] = None,
|
|
1013
|
-
min_count: Optional[pulumi.Input[int]] = None,
|
|
1014
|
-
name: Optional[pulumi.Input[str]] = None,
|
|
1015
|
-
ocean_id: Optional[pulumi.Input[str]] = None,
|
|
1016
|
-
os_disk_size_gb: Optional[pulumi.Input[int]] = None,
|
|
1017
|
-
os_disk_type: Optional[pulumi.Input[str]] = None,
|
|
1018
|
-
os_sku: Optional[pulumi.Input[str]] = None,
|
|
1019
|
-
os_type: Optional[pulumi.Input[str]] = None,
|
|
1020
|
-
pod_subnet_ids: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
|
|
1021
|
-
|
|
1022
|
-
|
|
1023
|
-
|
|
1024
|
-
|
|
1025
|
-
|
|
1061
|
+
availability_zones: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
1062
|
+
enable_node_public_ip: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
1063
|
+
fallback_to_ondemand: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
1064
|
+
filters: Optional[pulumi.Input[Union['OceanNpVirtualNodeGroupFiltersArgs', 'OceanNpVirtualNodeGroupFiltersArgsDict']]] = None,
|
|
1065
|
+
headrooms: Optional[pulumi.Input[Sequence[pulumi.Input[Union['OceanNpVirtualNodeGroupHeadroomArgs', 'OceanNpVirtualNodeGroupHeadroomArgsDict']]]]] = None,
|
|
1066
|
+
kubernetes_version: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1067
|
+
labels: Optional[pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]]] = None,
|
|
1068
|
+
linux_os_configs: Optional[pulumi.Input[Sequence[pulumi.Input[Union['OceanNpVirtualNodeGroupLinuxOsConfigArgs', 'OceanNpVirtualNodeGroupLinuxOsConfigArgsDict']]]]] = None,
|
|
1069
|
+
max_count: Optional[pulumi.Input[_builtins.int]] = None,
|
|
1070
|
+
max_pods_per_node: Optional[pulumi.Input[_builtins.int]] = None,
|
|
1071
|
+
min_count: Optional[pulumi.Input[_builtins.int]] = None,
|
|
1072
|
+
name: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1073
|
+
ocean_id: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1074
|
+
os_disk_size_gb: Optional[pulumi.Input[_builtins.int]] = None,
|
|
1075
|
+
os_disk_type: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1076
|
+
os_sku: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1077
|
+
os_type: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1078
|
+
pod_subnet_ids: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
1079
|
+
scheduling: Optional[pulumi.Input[Union['OceanNpVirtualNodeGroupSchedulingArgs', 'OceanNpVirtualNodeGroupSchedulingArgsDict']]] = None,
|
|
1080
|
+
spot_percentage: Optional[pulumi.Input[_builtins.int]] = None,
|
|
1081
|
+
tags: Optional[pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]]] = None,
|
|
1082
|
+
taints: Optional[pulumi.Input[Sequence[pulumi.Input[Union['OceanNpVirtualNodeGroupTaintArgs', 'OceanNpVirtualNodeGroupTaintArgsDict']]]]] = None,
|
|
1083
|
+
update_policy: Optional[pulumi.Input[Union['OceanNpVirtualNodeGroupUpdatePolicyArgs', 'OceanNpVirtualNodeGroupUpdatePolicyArgsDict']]] = None,
|
|
1084
|
+
vnet_subnet_ids: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
1026
1085
|
__props__=None):
|
|
1027
1086
|
opts = pulumi.ResourceOptions.merge(_utilities.get_resource_opts_defaults(), opts)
|
|
1028
1087
|
if not isinstance(opts, pulumi.ResourceOptions):
|
|
@@ -1052,6 +1111,7 @@ class OceanNpVirtualNodeGroup(pulumi.CustomResource):
|
|
|
1052
1111
|
__props__.__dict__["os_sku"] = os_sku
|
|
1053
1112
|
__props__.__dict__["os_type"] = os_type
|
|
1054
1113
|
__props__.__dict__["pod_subnet_ids"] = pod_subnet_ids
|
|
1114
|
+
__props__.__dict__["scheduling"] = scheduling
|
|
1055
1115
|
__props__.__dict__["spot_percentage"] = spot_percentage
|
|
1056
1116
|
__props__.__dict__["tags"] = tags
|
|
1057
1117
|
__props__.__dict__["taints"] = taints
|
|
@@ -1067,29 +1127,30 @@ class OceanNpVirtualNodeGroup(pulumi.CustomResource):
|
|
|
1067
1127
|
def get(resource_name: str,
|
|
1068
1128
|
id: pulumi.Input[str],
|
|
1069
1129
|
opts: Optional[pulumi.ResourceOptions] = None,
|
|
1070
|
-
availability_zones: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
|
|
1071
|
-
enable_node_public_ip: Optional[pulumi.Input[bool]] = None,
|
|
1072
|
-
fallback_to_ondemand: Optional[pulumi.Input[bool]] = None,
|
|
1073
|
-
filters: Optional[pulumi.Input[
|
|
1074
|
-
headrooms: Optional[pulumi.Input[Sequence[pulumi.Input[
|
|
1075
|
-
kubernetes_version: Optional[pulumi.Input[str]] = None,
|
|
1076
|
-
labels: Optional[pulumi.Input[Mapping[str,
|
|
1077
|
-
linux_os_configs: Optional[pulumi.Input[Sequence[pulumi.Input[
|
|
1078
|
-
max_count: Optional[pulumi.Input[int]] = None,
|
|
1079
|
-
max_pods_per_node: Optional[pulumi.Input[int]] = None,
|
|
1080
|
-
min_count: Optional[pulumi.Input[int]] = None,
|
|
1081
|
-
name: Optional[pulumi.Input[str]] = None,
|
|
1082
|
-
ocean_id: Optional[pulumi.Input[str]] = None,
|
|
1083
|
-
os_disk_size_gb: Optional[pulumi.Input[int]] = None,
|
|
1084
|
-
os_disk_type: Optional[pulumi.Input[str]] = None,
|
|
1085
|
-
os_sku: Optional[pulumi.Input[str]] = None,
|
|
1086
|
-
os_type: Optional[pulumi.Input[str]] = None,
|
|
1087
|
-
pod_subnet_ids: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
|
|
1088
|
-
|
|
1089
|
-
|
|
1090
|
-
|
|
1091
|
-
|
|
1092
|
-
|
|
1130
|
+
availability_zones: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
1131
|
+
enable_node_public_ip: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
1132
|
+
fallback_to_ondemand: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
1133
|
+
filters: Optional[pulumi.Input[Union['OceanNpVirtualNodeGroupFiltersArgs', 'OceanNpVirtualNodeGroupFiltersArgsDict']]] = None,
|
|
1134
|
+
headrooms: Optional[pulumi.Input[Sequence[pulumi.Input[Union['OceanNpVirtualNodeGroupHeadroomArgs', 'OceanNpVirtualNodeGroupHeadroomArgsDict']]]]] = None,
|
|
1135
|
+
kubernetes_version: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1136
|
+
labels: Optional[pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]]] = None,
|
|
1137
|
+
linux_os_configs: Optional[pulumi.Input[Sequence[pulumi.Input[Union['OceanNpVirtualNodeGroupLinuxOsConfigArgs', 'OceanNpVirtualNodeGroupLinuxOsConfigArgsDict']]]]] = None,
|
|
1138
|
+
max_count: Optional[pulumi.Input[_builtins.int]] = None,
|
|
1139
|
+
max_pods_per_node: Optional[pulumi.Input[_builtins.int]] = None,
|
|
1140
|
+
min_count: Optional[pulumi.Input[_builtins.int]] = None,
|
|
1141
|
+
name: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1142
|
+
ocean_id: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1143
|
+
os_disk_size_gb: Optional[pulumi.Input[_builtins.int]] = None,
|
|
1144
|
+
os_disk_type: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1145
|
+
os_sku: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1146
|
+
os_type: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1147
|
+
pod_subnet_ids: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
1148
|
+
scheduling: Optional[pulumi.Input[Union['OceanNpVirtualNodeGroupSchedulingArgs', 'OceanNpVirtualNodeGroupSchedulingArgsDict']]] = None,
|
|
1149
|
+
spot_percentage: Optional[pulumi.Input[_builtins.int]] = None,
|
|
1150
|
+
tags: Optional[pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]]] = None,
|
|
1151
|
+
taints: Optional[pulumi.Input[Sequence[pulumi.Input[Union['OceanNpVirtualNodeGroupTaintArgs', 'OceanNpVirtualNodeGroupTaintArgsDict']]]]] = None,
|
|
1152
|
+
update_policy: Optional[pulumi.Input[Union['OceanNpVirtualNodeGroupUpdatePolicyArgs', 'OceanNpVirtualNodeGroupUpdatePolicyArgsDict']]] = None,
|
|
1153
|
+
vnet_subnet_ids: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None) -> 'OceanNpVirtualNodeGroup':
|
|
1093
1154
|
"""
|
|
1094
1155
|
Get an existing OceanNpVirtualNodeGroup resource's state with the given name, id, and optional extra
|
|
1095
1156
|
properties used to qualify the lookup.
|
|
@@ -1097,27 +1158,28 @@ class OceanNpVirtualNodeGroup(pulumi.CustomResource):
|
|
|
1097
1158
|
:param str resource_name: The unique name of the resulting resource.
|
|
1098
1159
|
:param pulumi.Input[str] id: The unique provider ID of the resource to lookup.
|
|
1099
1160
|
:param pulumi.ResourceOptions opts: Options for the resource.
|
|
1100
|
-
:param pulumi.Input[Sequence[pulumi.Input[str]]] availability_zones: An Array holding Availability Zones, this configures the availability zones the Ocean may launch instances in per VNG.
|
|
1101
|
-
:param pulumi.Input[bool] enable_node_public_ip: Enable node public IP.
|
|
1102
|
-
:param pulumi.Input[bool] fallback_to_ondemand: If no spot instance markets are available, enable Ocean to launch on-demand instances instead.
|
|
1103
|
-
:param pulumi.Input[
|
|
1104
|
-
:param pulumi.Input[Sequence[pulumi.Input[
|
|
1105
|
-
:param pulumi.Input[str] kubernetes_version: The desired Kubernetes version of the launched nodes. In case the value is null, the Kubernetes version of the control plane is used.
|
|
1106
|
-
:param pulumi.Input[Mapping[str,
|
|
1107
|
-
:param pulumi.Input[Sequence[pulumi.Input[
|
|
1108
|
-
:param pulumi.Input[int] max_count: Maximum node count limit.
|
|
1109
|
-
:param pulumi.Input[int] max_pods_per_node: The maximum number of pods per node in the node pools.
|
|
1110
|
-
:param pulumi.Input[int] min_count: Minimum node count limit.
|
|
1111
|
-
:param pulumi.Input[str] name: Enter a name for the virtual node group.
|
|
1112
|
-
:param pulumi.Input[str] ocean_id: The Ocean cluster identifier. Required for Launch Spec creation.
|
|
1113
|
-
:param pulumi.Input[int] os_disk_size_gb: The size of the OS disk in GB.
|
|
1114
|
-
:param pulumi.Input[str] os_disk_type: The type of the OS disk.
|
|
1115
|
-
:param pulumi.Input[str] os_sku: The OS SKU of the OS type. Must correlate with the os type.
|
|
1116
|
-
:param pulumi.Input[str] os_type: The OS type of the OS disk. Can't be modified once set.
|
|
1117
|
-
:param pulumi.Input[Sequence[pulumi.Input[str]]] pod_subnet_ids: The IDs of subnets in an existing VNet into which to assign pods in the cluster (requires azure network-plugin).
|
|
1118
|
-
:param pulumi.Input[
|
|
1119
|
-
:param pulumi.Input[
|
|
1120
|
-
:param pulumi.Input[Sequence[pulumi.Input[
|
|
1161
|
+
:param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] availability_zones: An Array holding Availability Zones, this configures the availability zones the Ocean may launch instances in per VNG.
|
|
1162
|
+
:param pulumi.Input[_builtins.bool] enable_node_public_ip: Enable node public IP.
|
|
1163
|
+
:param pulumi.Input[_builtins.bool] fallback_to_ondemand: If no spot instance markets are available, enable Ocean to launch on-demand instances instead.
|
|
1164
|
+
:param pulumi.Input[Union['OceanNpVirtualNodeGroupFiltersArgs', 'OceanNpVirtualNodeGroupFiltersArgsDict']] filters: Filters for the VM sizes that can be launched from the virtual node group.
|
|
1165
|
+
:param pulumi.Input[Sequence[pulumi.Input[Union['OceanNpVirtualNodeGroupHeadroomArgs', 'OceanNpVirtualNodeGroupHeadroomArgsDict']]]] headrooms: Specify the custom headroom per VNG. Provide a list of headroom objects.
|
|
1166
|
+
:param pulumi.Input[_builtins.str] kubernetes_version: The desired Kubernetes version of the launched nodes. In case the value is null, the Kubernetes version of the control plane is used.
|
|
1167
|
+
:param pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]] labels: An array of labels to add to the virtual node group.Only custom user labels are allowed, and not Kubernetes built-in labels or Spot internal labels.
|
|
1168
|
+
:param pulumi.Input[Sequence[pulumi.Input[Union['OceanNpVirtualNodeGroupLinuxOsConfigArgs', 'OceanNpVirtualNodeGroupLinuxOsConfigArgsDict']]]] linux_os_configs: Custom Linux OS configuration.
|
|
1169
|
+
:param pulumi.Input[_builtins.int] max_count: Maximum node count limit.
|
|
1170
|
+
:param pulumi.Input[_builtins.int] max_pods_per_node: The maximum number of pods per node in the node pools.
|
|
1171
|
+
:param pulumi.Input[_builtins.int] min_count: Minimum node count limit.
|
|
1172
|
+
:param pulumi.Input[_builtins.str] name: Enter a name for the virtual node group.
|
|
1173
|
+
:param pulumi.Input[_builtins.str] ocean_id: The Ocean cluster identifier. Required for Launch Spec creation.
|
|
1174
|
+
:param pulumi.Input[_builtins.int] os_disk_size_gb: The size of the OS disk in GB.
|
|
1175
|
+
:param pulumi.Input[_builtins.str] os_disk_type: The type of the OS disk.
|
|
1176
|
+
:param pulumi.Input[_builtins.str] os_sku: The OS SKU of the OS type. Must correlate with the os type.
|
|
1177
|
+
:param pulumi.Input[_builtins.str] os_type: The OS type of the OS disk. Can't be modified once set.
|
|
1178
|
+
:param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] pod_subnet_ids: The IDs of subnets in an existing VNet into which to assign pods in the cluster (requires azure network-plugin).
|
|
1179
|
+
:param pulumi.Input[Union['OceanNpVirtualNodeGroupSchedulingArgs', 'OceanNpVirtualNodeGroupSchedulingArgsDict']] scheduling: An object used to specify times when the virtual node group will turn off all its node pools. Once the shutdown time will be over, the virtual node group will return to its previous state.
|
|
1180
|
+
:param pulumi.Input[_builtins.int] spot_percentage: Percentage of spot VMs to maintain.
|
|
1181
|
+
:param pulumi.Input[Sequence[pulumi.Input[Union['OceanNpVirtualNodeGroupTaintArgs', 'OceanNpVirtualNodeGroupTaintArgsDict']]]] taints: Add taints to a virtual node group.
|
|
1182
|
+
:param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] vnet_subnet_ids: The IDs of subnets in an existing VNet into which to assign nodes in the cluster (requires azure network-plugin).
|
|
1121
1183
|
"""
|
|
1122
1184
|
opts = pulumi.ResourceOptions.merge(opts, pulumi.ResourceOptions(id=id))
|
|
1123
1185
|
|
|
@@ -1141,6 +1203,7 @@ class OceanNpVirtualNodeGroup(pulumi.CustomResource):
|
|
|
1141
1203
|
__props__.__dict__["os_sku"] = os_sku
|
|
1142
1204
|
__props__.__dict__["os_type"] = os_type
|
|
1143
1205
|
__props__.__dict__["pod_subnet_ids"] = pod_subnet_ids
|
|
1206
|
+
__props__.__dict__["scheduling"] = scheduling
|
|
1144
1207
|
__props__.__dict__["spot_percentage"] = spot_percentage
|
|
1145
1208
|
__props__.__dict__["tags"] = tags
|
|
1146
1209
|
__props__.__dict__["taints"] = taints
|
|
@@ -1148,31 +1211,31 @@ class OceanNpVirtualNodeGroup(pulumi.CustomResource):
|
|
|
1148
1211
|
__props__.__dict__["vnet_subnet_ids"] = vnet_subnet_ids
|
|
1149
1212
|
return OceanNpVirtualNodeGroup(resource_name, opts=opts, __props__=__props__)
|
|
1150
1213
|
|
|
1151
|
-
@property
|
|
1214
|
+
@_builtins.property
|
|
1152
1215
|
@pulumi.getter(name="availabilityZones")
|
|
1153
|
-
def availability_zones(self) -> pulumi.Output[Optional[Sequence[str]]]:
|
|
1216
|
+
def availability_zones(self) -> pulumi.Output[Optional[Sequence[_builtins.str]]]:
|
|
1154
1217
|
"""
|
|
1155
1218
|
An Array holding Availability Zones, this configures the availability zones the Ocean may launch instances in per VNG.
|
|
1156
1219
|
"""
|
|
1157
1220
|
return pulumi.get(self, "availability_zones")
|
|
1158
1221
|
|
|
1159
|
-
@property
|
|
1222
|
+
@_builtins.property
|
|
1160
1223
|
@pulumi.getter(name="enableNodePublicIp")
|
|
1161
|
-
def enable_node_public_ip(self) -> pulumi.Output[Optional[bool]]:
|
|
1224
|
+
def enable_node_public_ip(self) -> pulumi.Output[Optional[_builtins.bool]]:
|
|
1162
1225
|
"""
|
|
1163
1226
|
Enable node public IP.
|
|
1164
1227
|
"""
|
|
1165
1228
|
return pulumi.get(self, "enable_node_public_ip")
|
|
1166
1229
|
|
|
1167
|
-
@property
|
|
1230
|
+
@_builtins.property
|
|
1168
1231
|
@pulumi.getter(name="fallbackToOndemand")
|
|
1169
|
-
def fallback_to_ondemand(self) -> pulumi.Output[Optional[bool]]:
|
|
1232
|
+
def fallback_to_ondemand(self) -> pulumi.Output[Optional[_builtins.bool]]:
|
|
1170
1233
|
"""
|
|
1171
1234
|
If no spot instance markets are available, enable Ocean to launch on-demand instances instead.
|
|
1172
1235
|
"""
|
|
1173
1236
|
return pulumi.get(self, "fallback_to_ondemand")
|
|
1174
1237
|
|
|
1175
|
-
@property
|
|
1238
|
+
@_builtins.property
|
|
1176
1239
|
@pulumi.getter
|
|
1177
1240
|
def filters(self) -> pulumi.Output[Optional['outputs.OceanNpVirtualNodeGroupFilters']]:
|
|
1178
1241
|
"""
|
|
@@ -1180,7 +1243,7 @@ class OceanNpVirtualNodeGroup(pulumi.CustomResource):
|
|
|
1180
1243
|
"""
|
|
1181
1244
|
return pulumi.get(self, "filters")
|
|
1182
1245
|
|
|
1183
|
-
@property
|
|
1246
|
+
@_builtins.property
|
|
1184
1247
|
@pulumi.getter
|
|
1185
1248
|
def headrooms(self) -> pulumi.Output[Optional[Sequence['outputs.OceanNpVirtualNodeGroupHeadroom']]]:
|
|
1186
1249
|
"""
|
|
@@ -1188,23 +1251,23 @@ class OceanNpVirtualNodeGroup(pulumi.CustomResource):
|
|
|
1188
1251
|
"""
|
|
1189
1252
|
return pulumi.get(self, "headrooms")
|
|
1190
1253
|
|
|
1191
|
-
@property
|
|
1254
|
+
@_builtins.property
|
|
1192
1255
|
@pulumi.getter(name="kubernetesVersion")
|
|
1193
|
-
def kubernetes_version(self) -> pulumi.Output[Optional[str]]:
|
|
1256
|
+
def kubernetes_version(self) -> pulumi.Output[Optional[_builtins.str]]:
|
|
1194
1257
|
"""
|
|
1195
1258
|
The desired Kubernetes version of the launched nodes. In case the value is null, the Kubernetes version of the control plane is used.
|
|
1196
1259
|
"""
|
|
1197
1260
|
return pulumi.get(self, "kubernetes_version")
|
|
1198
1261
|
|
|
1199
|
-
@property
|
|
1262
|
+
@_builtins.property
|
|
1200
1263
|
@pulumi.getter
|
|
1201
|
-
def labels(self) -> pulumi.Output[Optional[Mapping[str,
|
|
1264
|
+
def labels(self) -> pulumi.Output[Optional[Mapping[str, _builtins.str]]]:
|
|
1202
1265
|
"""
|
|
1203
1266
|
An array of labels to add to the virtual node group.Only custom user labels are allowed, and not Kubernetes built-in labels or Spot internal labels.
|
|
1204
1267
|
"""
|
|
1205
1268
|
return pulumi.get(self, "labels")
|
|
1206
1269
|
|
|
1207
|
-
@property
|
|
1270
|
+
@_builtins.property
|
|
1208
1271
|
@pulumi.getter(name="linuxOsConfigs")
|
|
1209
1272
|
def linux_os_configs(self) -> pulumi.Output[Optional[Sequence['outputs.OceanNpVirtualNodeGroupLinuxOsConfig']]]:
|
|
1210
1273
|
"""
|
|
@@ -1212,100 +1275,108 @@ class OceanNpVirtualNodeGroup(pulumi.CustomResource):
|
|
|
1212
1275
|
"""
|
|
1213
1276
|
return pulumi.get(self, "linux_os_configs")
|
|
1214
1277
|
|
|
1215
|
-
@property
|
|
1278
|
+
@_builtins.property
|
|
1216
1279
|
@pulumi.getter(name="maxCount")
|
|
1217
|
-
def max_count(self) -> pulumi.Output[Optional[int]]:
|
|
1280
|
+
def max_count(self) -> pulumi.Output[Optional[_builtins.int]]:
|
|
1218
1281
|
"""
|
|
1219
1282
|
Maximum node count limit.
|
|
1220
1283
|
"""
|
|
1221
1284
|
return pulumi.get(self, "max_count")
|
|
1222
1285
|
|
|
1223
|
-
@property
|
|
1286
|
+
@_builtins.property
|
|
1224
1287
|
@pulumi.getter(name="maxPodsPerNode")
|
|
1225
|
-
def max_pods_per_node(self) -> pulumi.Output[Optional[int]]:
|
|
1288
|
+
def max_pods_per_node(self) -> pulumi.Output[Optional[_builtins.int]]:
|
|
1226
1289
|
"""
|
|
1227
1290
|
The maximum number of pods per node in the node pools.
|
|
1228
1291
|
"""
|
|
1229
1292
|
return pulumi.get(self, "max_pods_per_node")
|
|
1230
1293
|
|
|
1231
|
-
@property
|
|
1294
|
+
@_builtins.property
|
|
1232
1295
|
@pulumi.getter(name="minCount")
|
|
1233
|
-
def min_count(self) -> pulumi.Output[Optional[int]]:
|
|
1296
|
+
def min_count(self) -> pulumi.Output[Optional[_builtins.int]]:
|
|
1234
1297
|
"""
|
|
1235
1298
|
Minimum node count limit.
|
|
1236
1299
|
"""
|
|
1237
1300
|
return pulumi.get(self, "min_count")
|
|
1238
1301
|
|
|
1239
|
-
@property
|
|
1302
|
+
@_builtins.property
|
|
1240
1303
|
@pulumi.getter
|
|
1241
|
-
def name(self) -> pulumi.Output[str]:
|
|
1304
|
+
def name(self) -> pulumi.Output[_builtins.str]:
|
|
1242
1305
|
"""
|
|
1243
1306
|
Enter a name for the virtual node group.
|
|
1244
1307
|
"""
|
|
1245
1308
|
return pulumi.get(self, "name")
|
|
1246
1309
|
|
|
1247
|
-
@property
|
|
1310
|
+
@_builtins.property
|
|
1248
1311
|
@pulumi.getter(name="oceanId")
|
|
1249
|
-
def ocean_id(self) -> pulumi.Output[str]:
|
|
1312
|
+
def ocean_id(self) -> pulumi.Output[_builtins.str]:
|
|
1250
1313
|
"""
|
|
1251
1314
|
The Ocean cluster identifier. Required for Launch Spec creation.
|
|
1252
1315
|
"""
|
|
1253
1316
|
return pulumi.get(self, "ocean_id")
|
|
1254
1317
|
|
|
1255
|
-
@property
|
|
1318
|
+
@_builtins.property
|
|
1256
1319
|
@pulumi.getter(name="osDiskSizeGb")
|
|
1257
|
-
def os_disk_size_gb(self) -> pulumi.Output[Optional[int]]:
|
|
1320
|
+
def os_disk_size_gb(self) -> pulumi.Output[Optional[_builtins.int]]:
|
|
1258
1321
|
"""
|
|
1259
1322
|
The size of the OS disk in GB.
|
|
1260
1323
|
"""
|
|
1261
1324
|
return pulumi.get(self, "os_disk_size_gb")
|
|
1262
1325
|
|
|
1263
|
-
@property
|
|
1326
|
+
@_builtins.property
|
|
1264
1327
|
@pulumi.getter(name="osDiskType")
|
|
1265
|
-
def os_disk_type(self) -> pulumi.Output[Optional[str]]:
|
|
1328
|
+
def os_disk_type(self) -> pulumi.Output[Optional[_builtins.str]]:
|
|
1266
1329
|
"""
|
|
1267
1330
|
The type of the OS disk.
|
|
1268
1331
|
"""
|
|
1269
1332
|
return pulumi.get(self, "os_disk_type")
|
|
1270
1333
|
|
|
1271
|
-
@property
|
|
1334
|
+
@_builtins.property
|
|
1272
1335
|
@pulumi.getter(name="osSku")
|
|
1273
|
-
def os_sku(self) -> pulumi.Output[Optional[str]]:
|
|
1336
|
+
def os_sku(self) -> pulumi.Output[Optional[_builtins.str]]:
|
|
1274
1337
|
"""
|
|
1275
1338
|
The OS SKU of the OS type. Must correlate with the os type.
|
|
1276
1339
|
"""
|
|
1277
1340
|
return pulumi.get(self, "os_sku")
|
|
1278
1341
|
|
|
1279
|
-
@property
|
|
1342
|
+
@_builtins.property
|
|
1280
1343
|
@pulumi.getter(name="osType")
|
|
1281
|
-
def os_type(self) -> pulumi.Output[Optional[str]]:
|
|
1344
|
+
def os_type(self) -> pulumi.Output[Optional[_builtins.str]]:
|
|
1282
1345
|
"""
|
|
1283
1346
|
The OS type of the OS disk. Can't be modified once set.
|
|
1284
1347
|
"""
|
|
1285
1348
|
return pulumi.get(self, "os_type")
|
|
1286
1349
|
|
|
1287
|
-
@property
|
|
1350
|
+
@_builtins.property
|
|
1288
1351
|
@pulumi.getter(name="podSubnetIds")
|
|
1289
|
-
def pod_subnet_ids(self) -> pulumi.Output[Optional[Sequence[str]]]:
|
|
1352
|
+
def pod_subnet_ids(self) -> pulumi.Output[Optional[Sequence[_builtins.str]]]:
|
|
1290
1353
|
"""
|
|
1291
1354
|
The IDs of subnets in an existing VNet into which to assign pods in the cluster (requires azure network-plugin).
|
|
1292
1355
|
"""
|
|
1293
1356
|
return pulumi.get(self, "pod_subnet_ids")
|
|
1294
1357
|
|
|
1295
|
-
@property
|
|
1358
|
+
@_builtins.property
|
|
1359
|
+
@pulumi.getter
|
|
1360
|
+
def scheduling(self) -> pulumi.Output[Optional['outputs.OceanNpVirtualNodeGroupScheduling']]:
|
|
1361
|
+
"""
|
|
1362
|
+
An object used to specify times when the virtual node group will turn off all its node pools. Once the shutdown time will be over, the virtual node group will return to its previous state.
|
|
1363
|
+
"""
|
|
1364
|
+
return pulumi.get(self, "scheduling")
|
|
1365
|
+
|
|
1366
|
+
@_builtins.property
|
|
1296
1367
|
@pulumi.getter(name="spotPercentage")
|
|
1297
|
-
def spot_percentage(self) -> pulumi.Output[Optional[int]]:
|
|
1368
|
+
def spot_percentage(self) -> pulumi.Output[Optional[_builtins.int]]:
|
|
1298
1369
|
"""
|
|
1299
1370
|
Percentage of spot VMs to maintain.
|
|
1300
1371
|
"""
|
|
1301
1372
|
return pulumi.get(self, "spot_percentage")
|
|
1302
1373
|
|
|
1303
|
-
@property
|
|
1374
|
+
@_builtins.property
|
|
1304
1375
|
@pulumi.getter
|
|
1305
|
-
def tags(self) -> pulumi.Output[Optional[Mapping[str,
|
|
1376
|
+
def tags(self) -> pulumi.Output[Optional[Mapping[str, _builtins.str]]]:
|
|
1306
1377
|
return pulumi.get(self, "tags")
|
|
1307
1378
|
|
|
1308
|
-
@property
|
|
1379
|
+
@_builtins.property
|
|
1309
1380
|
@pulumi.getter
|
|
1310
1381
|
def taints(self) -> pulumi.Output[Optional[Sequence['outputs.OceanNpVirtualNodeGroupTaint']]]:
|
|
1311
1382
|
"""
|
|
@@ -1313,14 +1384,14 @@ class OceanNpVirtualNodeGroup(pulumi.CustomResource):
|
|
|
1313
1384
|
"""
|
|
1314
1385
|
return pulumi.get(self, "taints")
|
|
1315
1386
|
|
|
1316
|
-
@property
|
|
1387
|
+
@_builtins.property
|
|
1317
1388
|
@pulumi.getter(name="updatePolicy")
|
|
1318
1389
|
def update_policy(self) -> pulumi.Output[Optional['outputs.OceanNpVirtualNodeGroupUpdatePolicy']]:
|
|
1319
1390
|
return pulumi.get(self, "update_policy")
|
|
1320
1391
|
|
|
1321
|
-
@property
|
|
1392
|
+
@_builtins.property
|
|
1322
1393
|
@pulumi.getter(name="vnetSubnetIds")
|
|
1323
|
-
def vnet_subnet_ids(self) -> pulumi.Output[Optional[Sequence[str]]]:
|
|
1394
|
+
def vnet_subnet_ids(self) -> pulumi.Output[Optional[Sequence[_builtins.str]]]:
|
|
1324
1395
|
"""
|
|
1325
1396
|
The IDs of subnets in an existing VNet into which to assign nodes in the cluster (requires azure network-plugin).
|
|
1326
1397
|
"""
|