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,61 +21,65 @@ __all__ = ['OceanNpArgs', 'OceanNp']
|
|
|
16
21
|
@pulumi.input_type
|
|
17
22
|
class OceanNpArgs:
|
|
18
23
|
def __init__(__self__, *,
|
|
19
|
-
aks_cluster_name: pulumi.Input[str],
|
|
20
|
-
aks_infrastructure_resource_group_name: pulumi.Input[str],
|
|
21
|
-
aks_region: pulumi.Input[str],
|
|
22
|
-
aks_resource_group_name: pulumi.Input[str],
|
|
23
|
-
availability_zones: pulumi.Input[Sequence[pulumi.Input[str]]],
|
|
24
|
-
controller_cluster_id: pulumi.Input[str],
|
|
24
|
+
aks_cluster_name: pulumi.Input[_builtins.str],
|
|
25
|
+
aks_infrastructure_resource_group_name: pulumi.Input[_builtins.str],
|
|
26
|
+
aks_region: pulumi.Input[_builtins.str],
|
|
27
|
+
aks_resource_group_name: pulumi.Input[_builtins.str],
|
|
28
|
+
availability_zones: pulumi.Input[Sequence[pulumi.Input[_builtins.str]]],
|
|
29
|
+
controller_cluster_id: pulumi.Input[_builtins.str],
|
|
25
30
|
autoscaler: Optional[pulumi.Input['OceanNpAutoscalerArgs']] = None,
|
|
26
|
-
enable_node_public_ip: Optional[pulumi.Input[bool]] = None,
|
|
27
|
-
fallback_to_ondemand: Optional[pulumi.Input[bool]] = None,
|
|
31
|
+
enable_node_public_ip: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
32
|
+
fallback_to_ondemand: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
28
33
|
filters: Optional[pulumi.Input['OceanNpFiltersArgs']] = None,
|
|
29
34
|
headrooms: Optional[pulumi.Input[Sequence[pulumi.Input['OceanNpHeadroomArgs']]]] = None,
|
|
30
35
|
health: Optional[pulumi.Input['OceanNpHealthArgs']] = None,
|
|
31
|
-
kubernetes_version: Optional[pulumi.Input[str]] = None,
|
|
32
|
-
labels: Optional[pulumi.Input[Mapping[str,
|
|
36
|
+
kubernetes_version: Optional[pulumi.Input[_builtins.str]] = None,
|
|
37
|
+
labels: Optional[pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]]] = None,
|
|
33
38
|
linux_os_configs: Optional[pulumi.Input[Sequence[pulumi.Input['OceanNpLinuxOsConfigArgs']]]] = None,
|
|
34
|
-
|
|
35
|
-
|
|
36
|
-
|
|
37
|
-
|
|
38
|
-
|
|
39
|
-
|
|
40
|
-
|
|
41
|
-
|
|
42
|
-
|
|
39
|
+
logging: Optional[pulumi.Input['OceanNpLoggingArgs']] = None,
|
|
40
|
+
max_count: Optional[pulumi.Input[_builtins.int]] = None,
|
|
41
|
+
max_pods_per_node: Optional[pulumi.Input[_builtins.int]] = None,
|
|
42
|
+
min_count: Optional[pulumi.Input[_builtins.int]] = None,
|
|
43
|
+
name: Optional[pulumi.Input[_builtins.str]] = None,
|
|
44
|
+
os_disk_size_gb: Optional[pulumi.Input[_builtins.int]] = None,
|
|
45
|
+
os_disk_type: Optional[pulumi.Input[_builtins.str]] = None,
|
|
46
|
+
os_sku: Optional[pulumi.Input[_builtins.str]] = None,
|
|
47
|
+
os_type: Optional[pulumi.Input[_builtins.str]] = None,
|
|
48
|
+
pod_subnet_ids: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
43
49
|
scheduling: Optional[pulumi.Input['OceanNpSchedulingArgs']] = None,
|
|
44
|
-
spot_percentage: Optional[pulumi.Input[int]] = None,
|
|
45
|
-
tags: Optional[pulumi.Input[Mapping[str,
|
|
50
|
+
spot_percentage: Optional[pulumi.Input[_builtins.int]] = None,
|
|
51
|
+
tags: Optional[pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]]] = None,
|
|
46
52
|
taints: Optional[pulumi.Input[Sequence[pulumi.Input['OceanNpTaintArgs']]]] = None,
|
|
47
53
|
update_policy: Optional[pulumi.Input['OceanNpUpdatePolicyArgs']] = None,
|
|
48
|
-
vnet_subnet_ids: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None
|
|
54
|
+
vnet_subnet_ids: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
55
|
+
vng_template_scheduling: Optional[pulumi.Input['OceanNpVngTemplateSchedulingArgs']] = None):
|
|
49
56
|
"""
|
|
50
57
|
The set of arguments for constructing a OceanNp resource.
|
|
51
|
-
: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.
|
|
52
|
-
:param pulumi.Input[str] controller_cluster_id: Enter a unique Ocean cluster identifier. Cannot be updated. This needs to match with string that was used to install the controller in the cluster, typically clusterName + 8 digit string.
|
|
58
|
+
: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.
|
|
59
|
+
:param pulumi.Input[_builtins.str] controller_cluster_id: Enter a unique Ocean cluster identifier. Cannot be updated. This needs to match with string that was used to install the controller in the cluster, typically clusterName + 8 digit string.
|
|
53
60
|
:param pulumi.Input['OceanNpAutoscalerArgs'] autoscaler: The Ocean Kubernetes Autoscaler object.
|
|
54
|
-
:param pulumi.Input[bool] enable_node_public_ip: Enable node public IP.
|
|
55
|
-
:param pulumi.Input[bool] fallback_to_ondemand: If no spot VM markets are available, enable Ocean to launch regular (pay-as-you-go) nodes instead.
|
|
61
|
+
:param pulumi.Input[_builtins.bool] enable_node_public_ip: Enable node public IP.
|
|
62
|
+
:param pulumi.Input[_builtins.bool] fallback_to_ondemand: If no spot VM markets are available, enable Ocean to launch regular (pay-as-you-go) nodes instead.
|
|
56
63
|
:param pulumi.Input['OceanNpFiltersArgs'] filters: Filters for the VM sizes that can be launched from the virtual node group.
|
|
57
64
|
:param pulumi.Input[Sequence[pulumi.Input['OceanNpHeadroomArgs']]] headrooms: Specify the custom headroom per VNG. Provide a list of headroom objects.
|
|
58
65
|
:param pulumi.Input['OceanNpHealthArgs'] health: The Ocean AKS Health object.
|
|
59
|
-
: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.
|
|
60
|
-
:param pulumi.Input[Mapping[str,
|
|
66
|
+
: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.
|
|
67
|
+
: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 well-known labels](https://kubernetes.io/docs/reference/labels-annotations-taints/) or [ Azure AKS labels](https://learn.microsoft.com/en-us/azure/aks/use-labels) or [Spot labels](https://docs.spot.io/ocean/features/labels-and-taints?id=spot-labels).
|
|
61
68
|
:param pulumi.Input[Sequence[pulumi.Input['OceanNpLinuxOsConfigArgs']]] linux_os_configs: Custom Linux OS configuration.
|
|
62
|
-
:param pulumi.Input[
|
|
63
|
-
:param pulumi.Input[int]
|
|
64
|
-
:param pulumi.Input[int]
|
|
65
|
-
:param pulumi.Input[
|
|
66
|
-
:param pulumi.Input[
|
|
67
|
-
:param pulumi.Input[
|
|
68
|
-
:param pulumi.Input[str]
|
|
69
|
-
:param pulumi.Input[str]
|
|
70
|
-
:param pulumi.Input[
|
|
71
|
-
:param pulumi.Input[
|
|
69
|
+
:param pulumi.Input['OceanNpLoggingArgs'] logging: The Ocean AKS Logging Object.
|
|
70
|
+
:param pulumi.Input[_builtins.int] max_count: Maximum node count limit.
|
|
71
|
+
:param pulumi.Input[_builtins.int] max_pods_per_node: The maximum number of pods per node in the node pools.
|
|
72
|
+
:param pulumi.Input[_builtins.int] min_count: Minimum node count limit.
|
|
73
|
+
:param pulumi.Input[_builtins.str] name: Add a name for the Ocean cluster.
|
|
74
|
+
:param pulumi.Input[_builtins.int] os_disk_size_gb: The size of the OS disk in GB.
|
|
75
|
+
:param pulumi.Input[_builtins.str] os_disk_type: The type of the OS disk.
|
|
76
|
+
:param pulumi.Input[_builtins.str] os_sku: The OS SKU of the OS type. Must correlate with the os type.
|
|
77
|
+
:param pulumi.Input[_builtins.str] os_type: The OS type of the OS disk. Can't be modified once set.
|
|
78
|
+
: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).
|
|
79
|
+
:param pulumi.Input[_builtins.int] spot_percentage: Percentage of spot VMs to maintain.
|
|
72
80
|
:param pulumi.Input[Sequence[pulumi.Input['OceanNpTaintArgs']]] taints: Add taints to a virtual node group. Only custom user taints are allowed, and not [Kubernetes well-known taints](https://kubernetes.io/docs/reference/labels-annotations-taints/) or Azure AKS [ScaleSetPrioirty (Spot VM) taint](https://learn.microsoft.com/en-us/azure/aks/spot-node-pool). For all Spot VMs, AKS injects a taint kubernetes.azure.com/scalesetpriority=spot:NoSchedule, to ensure that only workloads that can handle interruptions are scheduled on Spot nodes. To [schedule a pod to run on Spot node](https://learn.microsoft.com/en-us/azure/aks/spot-node-pool#schedule-a-pod-to-run-on-the-spot-node), add a toleration but dont include the nodeAffinity (not supported for Spot Ocean), this will prevent the pod from being scheduled using Spot Ocean.
|
|
73
|
-
: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).
|
|
81
|
+
: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).
|
|
82
|
+
:param pulumi.Input['OceanNpVngTemplateSchedulingArgs'] vng_template_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.
|
|
74
83
|
"""
|
|
75
84
|
pulumi.set(__self__, "aks_cluster_name", aks_cluster_name)
|
|
76
85
|
pulumi.set(__self__, "aks_infrastructure_resource_group_name", aks_infrastructure_resource_group_name)
|
|
@@ -96,6 +105,8 @@ class OceanNpArgs:
|
|
|
96
105
|
pulumi.set(__self__, "labels", labels)
|
|
97
106
|
if linux_os_configs is not None:
|
|
98
107
|
pulumi.set(__self__, "linux_os_configs", linux_os_configs)
|
|
108
|
+
if logging is not None:
|
|
109
|
+
pulumi.set(__self__, "logging", logging)
|
|
99
110
|
if max_count is not None:
|
|
100
111
|
pulumi.set(__self__, "max_count", max_count)
|
|
101
112
|
if max_pods_per_node is not None:
|
|
@@ -126,68 +137,70 @@ class OceanNpArgs:
|
|
|
126
137
|
pulumi.set(__self__, "update_policy", update_policy)
|
|
127
138
|
if vnet_subnet_ids is not None:
|
|
128
139
|
pulumi.set(__self__, "vnet_subnet_ids", vnet_subnet_ids)
|
|
140
|
+
if vng_template_scheduling is not None:
|
|
141
|
+
pulumi.set(__self__, "vng_template_scheduling", vng_template_scheduling)
|
|
129
142
|
|
|
130
|
-
@property
|
|
143
|
+
@_builtins.property
|
|
131
144
|
@pulumi.getter(name="aksClusterName")
|
|
132
|
-
def aks_cluster_name(self) -> pulumi.Input[str]:
|
|
145
|
+
def aks_cluster_name(self) -> pulumi.Input[_builtins.str]:
|
|
133
146
|
return pulumi.get(self, "aks_cluster_name")
|
|
134
147
|
|
|
135
148
|
@aks_cluster_name.setter
|
|
136
|
-
def aks_cluster_name(self, value: pulumi.Input[str]):
|
|
149
|
+
def aks_cluster_name(self, value: pulumi.Input[_builtins.str]):
|
|
137
150
|
pulumi.set(self, "aks_cluster_name", value)
|
|
138
151
|
|
|
139
|
-
@property
|
|
152
|
+
@_builtins.property
|
|
140
153
|
@pulumi.getter(name="aksInfrastructureResourceGroupName")
|
|
141
|
-
def aks_infrastructure_resource_group_name(self) -> pulumi.Input[str]:
|
|
154
|
+
def aks_infrastructure_resource_group_name(self) -> pulumi.Input[_builtins.str]:
|
|
142
155
|
return pulumi.get(self, "aks_infrastructure_resource_group_name")
|
|
143
156
|
|
|
144
157
|
@aks_infrastructure_resource_group_name.setter
|
|
145
|
-
def aks_infrastructure_resource_group_name(self, value: pulumi.Input[str]):
|
|
158
|
+
def aks_infrastructure_resource_group_name(self, value: pulumi.Input[_builtins.str]):
|
|
146
159
|
pulumi.set(self, "aks_infrastructure_resource_group_name", value)
|
|
147
160
|
|
|
148
|
-
@property
|
|
161
|
+
@_builtins.property
|
|
149
162
|
@pulumi.getter(name="aksRegion")
|
|
150
|
-
def aks_region(self) -> pulumi.Input[str]:
|
|
163
|
+
def aks_region(self) -> pulumi.Input[_builtins.str]:
|
|
151
164
|
return pulumi.get(self, "aks_region")
|
|
152
165
|
|
|
153
166
|
@aks_region.setter
|
|
154
|
-
def aks_region(self, value: pulumi.Input[str]):
|
|
167
|
+
def aks_region(self, value: pulumi.Input[_builtins.str]):
|
|
155
168
|
pulumi.set(self, "aks_region", value)
|
|
156
169
|
|
|
157
|
-
@property
|
|
170
|
+
@_builtins.property
|
|
158
171
|
@pulumi.getter(name="aksResourceGroupName")
|
|
159
|
-
def aks_resource_group_name(self) -> pulumi.Input[str]:
|
|
172
|
+
def aks_resource_group_name(self) -> pulumi.Input[_builtins.str]:
|
|
160
173
|
return pulumi.get(self, "aks_resource_group_name")
|
|
161
174
|
|
|
162
175
|
@aks_resource_group_name.setter
|
|
163
|
-
def aks_resource_group_name(self, value: pulumi.Input[str]):
|
|
176
|
+
def aks_resource_group_name(self, value: pulumi.Input[_builtins.str]):
|
|
164
177
|
pulumi.set(self, "aks_resource_group_name", value)
|
|
165
178
|
|
|
166
|
-
@property
|
|
179
|
+
@_builtins.property
|
|
167
180
|
@pulumi.getter(name="availabilityZones")
|
|
168
|
-
def availability_zones(self) -> pulumi.Input[Sequence[pulumi.Input[str]]]:
|
|
181
|
+
def availability_zones(self) -> pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]:
|
|
169
182
|
"""
|
|
170
183
|
An Array holding Availability Zones, this configures the availability zones the Ocean may launch instances in per VNG.
|
|
171
184
|
"""
|
|
172
185
|
return pulumi.get(self, "availability_zones")
|
|
173
186
|
|
|
174
187
|
@availability_zones.setter
|
|
175
|
-
def availability_zones(self, value: pulumi.Input[Sequence[pulumi.Input[str]]]):
|
|
188
|
+
def availability_zones(self, value: pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]):
|
|
176
189
|
pulumi.set(self, "availability_zones", value)
|
|
177
190
|
|
|
178
|
-
@property
|
|
191
|
+
@_builtins.property
|
|
179
192
|
@pulumi.getter(name="controllerClusterId")
|
|
180
|
-
def controller_cluster_id(self) -> pulumi.Input[str]:
|
|
193
|
+
def controller_cluster_id(self) -> pulumi.Input[_builtins.str]:
|
|
181
194
|
"""
|
|
182
195
|
Enter a unique Ocean cluster identifier. Cannot be updated. This needs to match with string that was used to install the controller in the cluster, typically clusterName + 8 digit string.
|
|
183
196
|
"""
|
|
184
197
|
return pulumi.get(self, "controller_cluster_id")
|
|
185
198
|
|
|
186
199
|
@controller_cluster_id.setter
|
|
187
|
-
def controller_cluster_id(self, value: pulumi.Input[str]):
|
|
200
|
+
def controller_cluster_id(self, value: pulumi.Input[_builtins.str]):
|
|
188
201
|
pulumi.set(self, "controller_cluster_id", value)
|
|
189
202
|
|
|
190
|
-
@property
|
|
203
|
+
@_builtins.property
|
|
191
204
|
@pulumi.getter
|
|
192
205
|
def autoscaler(self) -> Optional[pulumi.Input['OceanNpAutoscalerArgs']]:
|
|
193
206
|
"""
|
|
@@ -199,31 +212,31 @@ class OceanNpArgs:
|
|
|
199
212
|
def autoscaler(self, value: Optional[pulumi.Input['OceanNpAutoscalerArgs']]):
|
|
200
213
|
pulumi.set(self, "autoscaler", value)
|
|
201
214
|
|
|
202
|
-
@property
|
|
215
|
+
@_builtins.property
|
|
203
216
|
@pulumi.getter(name="enableNodePublicIp")
|
|
204
|
-
def enable_node_public_ip(self) -> Optional[pulumi.Input[bool]]:
|
|
217
|
+
def enable_node_public_ip(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
205
218
|
"""
|
|
206
219
|
Enable node public IP.
|
|
207
220
|
"""
|
|
208
221
|
return pulumi.get(self, "enable_node_public_ip")
|
|
209
222
|
|
|
210
223
|
@enable_node_public_ip.setter
|
|
211
|
-
def enable_node_public_ip(self, value: Optional[pulumi.Input[bool]]):
|
|
224
|
+
def enable_node_public_ip(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
212
225
|
pulumi.set(self, "enable_node_public_ip", value)
|
|
213
226
|
|
|
214
|
-
@property
|
|
227
|
+
@_builtins.property
|
|
215
228
|
@pulumi.getter(name="fallbackToOndemand")
|
|
216
|
-
def fallback_to_ondemand(self) -> Optional[pulumi.Input[bool]]:
|
|
229
|
+
def fallback_to_ondemand(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
217
230
|
"""
|
|
218
231
|
If no spot VM markets are available, enable Ocean to launch regular (pay-as-you-go) nodes instead.
|
|
219
232
|
"""
|
|
220
233
|
return pulumi.get(self, "fallback_to_ondemand")
|
|
221
234
|
|
|
222
235
|
@fallback_to_ondemand.setter
|
|
223
|
-
def fallback_to_ondemand(self, value: Optional[pulumi.Input[bool]]):
|
|
236
|
+
def fallback_to_ondemand(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
224
237
|
pulumi.set(self, "fallback_to_ondemand", value)
|
|
225
238
|
|
|
226
|
-
@property
|
|
239
|
+
@_builtins.property
|
|
227
240
|
@pulumi.getter
|
|
228
241
|
def filters(self) -> Optional[pulumi.Input['OceanNpFiltersArgs']]:
|
|
229
242
|
"""
|
|
@@ -235,7 +248,7 @@ class OceanNpArgs:
|
|
|
235
248
|
def filters(self, value: Optional[pulumi.Input['OceanNpFiltersArgs']]):
|
|
236
249
|
pulumi.set(self, "filters", value)
|
|
237
250
|
|
|
238
|
-
@property
|
|
251
|
+
@_builtins.property
|
|
239
252
|
@pulumi.getter
|
|
240
253
|
def headrooms(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['OceanNpHeadroomArgs']]]]:
|
|
241
254
|
"""
|
|
@@ -247,7 +260,7 @@ class OceanNpArgs:
|
|
|
247
260
|
def headrooms(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['OceanNpHeadroomArgs']]]]):
|
|
248
261
|
pulumi.set(self, "headrooms", value)
|
|
249
262
|
|
|
250
|
-
@property
|
|
263
|
+
@_builtins.property
|
|
251
264
|
@pulumi.getter
|
|
252
265
|
def health(self) -> Optional[pulumi.Input['OceanNpHealthArgs']]:
|
|
253
266
|
"""
|
|
@@ -259,31 +272,31 @@ class OceanNpArgs:
|
|
|
259
272
|
def health(self, value: Optional[pulumi.Input['OceanNpHealthArgs']]):
|
|
260
273
|
pulumi.set(self, "health", value)
|
|
261
274
|
|
|
262
|
-
@property
|
|
275
|
+
@_builtins.property
|
|
263
276
|
@pulumi.getter(name="kubernetesVersion")
|
|
264
|
-
def kubernetes_version(self) -> Optional[pulumi.Input[str]]:
|
|
277
|
+
def kubernetes_version(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
265
278
|
"""
|
|
266
279
|
The desired Kubernetes version of the launched nodes. In case the value is null, the Kubernetes version of the control plane is used.
|
|
267
280
|
"""
|
|
268
281
|
return pulumi.get(self, "kubernetes_version")
|
|
269
282
|
|
|
270
283
|
@kubernetes_version.setter
|
|
271
|
-
def kubernetes_version(self, value: Optional[pulumi.Input[str]]):
|
|
284
|
+
def kubernetes_version(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
272
285
|
pulumi.set(self, "kubernetes_version", value)
|
|
273
286
|
|
|
274
|
-
@property
|
|
287
|
+
@_builtins.property
|
|
275
288
|
@pulumi.getter
|
|
276
|
-
def labels(self) -> Optional[pulumi.Input[Mapping[str,
|
|
289
|
+
def labels(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]]]:
|
|
277
290
|
"""
|
|
278
291
|
An array of labels to add to the virtual node group. Only custom user labels are allowed, and not [Kubernetes well-known labels](https://kubernetes.io/docs/reference/labels-annotations-taints/) or [ Azure AKS labels](https://learn.microsoft.com/en-us/azure/aks/use-labels) or [Spot labels](https://docs.spot.io/ocean/features/labels-and-taints?id=spot-labels).
|
|
279
292
|
"""
|
|
280
293
|
return pulumi.get(self, "labels")
|
|
281
294
|
|
|
282
295
|
@labels.setter
|
|
283
|
-
def labels(self, value: Optional[pulumi.Input[Mapping[str,
|
|
296
|
+
def labels(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]]]):
|
|
284
297
|
pulumi.set(self, "labels", value)
|
|
285
298
|
|
|
286
|
-
@property
|
|
299
|
+
@_builtins.property
|
|
287
300
|
@pulumi.getter(name="linuxOsConfigs")
|
|
288
301
|
def linux_os_configs(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['OceanNpLinuxOsConfigArgs']]]]:
|
|
289
302
|
"""
|
|
@@ -295,115 +308,127 @@ class OceanNpArgs:
|
|
|
295
308
|
def linux_os_configs(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['OceanNpLinuxOsConfigArgs']]]]):
|
|
296
309
|
pulumi.set(self, "linux_os_configs", value)
|
|
297
310
|
|
|
298
|
-
@property
|
|
311
|
+
@_builtins.property
|
|
312
|
+
@pulumi.getter
|
|
313
|
+
def logging(self) -> Optional[pulumi.Input['OceanNpLoggingArgs']]:
|
|
314
|
+
"""
|
|
315
|
+
The Ocean AKS Logging Object.
|
|
316
|
+
"""
|
|
317
|
+
return pulumi.get(self, "logging")
|
|
318
|
+
|
|
319
|
+
@logging.setter
|
|
320
|
+
def logging(self, value: Optional[pulumi.Input['OceanNpLoggingArgs']]):
|
|
321
|
+
pulumi.set(self, "logging", value)
|
|
322
|
+
|
|
323
|
+
@_builtins.property
|
|
299
324
|
@pulumi.getter(name="maxCount")
|
|
300
|
-
def max_count(self) -> Optional[pulumi.Input[int]]:
|
|
325
|
+
def max_count(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
301
326
|
"""
|
|
302
327
|
Maximum node count limit.
|
|
303
328
|
"""
|
|
304
329
|
return pulumi.get(self, "max_count")
|
|
305
330
|
|
|
306
331
|
@max_count.setter
|
|
307
|
-
def max_count(self, value: Optional[pulumi.Input[int]]):
|
|
332
|
+
def max_count(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
308
333
|
pulumi.set(self, "max_count", value)
|
|
309
334
|
|
|
310
|
-
@property
|
|
335
|
+
@_builtins.property
|
|
311
336
|
@pulumi.getter(name="maxPodsPerNode")
|
|
312
|
-
def max_pods_per_node(self) -> Optional[pulumi.Input[int]]:
|
|
337
|
+
def max_pods_per_node(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
313
338
|
"""
|
|
314
339
|
The maximum number of pods per node in the node pools.
|
|
315
340
|
"""
|
|
316
341
|
return pulumi.get(self, "max_pods_per_node")
|
|
317
342
|
|
|
318
343
|
@max_pods_per_node.setter
|
|
319
|
-
def max_pods_per_node(self, value: Optional[pulumi.Input[int]]):
|
|
344
|
+
def max_pods_per_node(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
320
345
|
pulumi.set(self, "max_pods_per_node", value)
|
|
321
346
|
|
|
322
|
-
@property
|
|
347
|
+
@_builtins.property
|
|
323
348
|
@pulumi.getter(name="minCount")
|
|
324
|
-
def min_count(self) -> Optional[pulumi.Input[int]]:
|
|
349
|
+
def min_count(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
325
350
|
"""
|
|
326
351
|
Minimum node count limit.
|
|
327
352
|
"""
|
|
328
353
|
return pulumi.get(self, "min_count")
|
|
329
354
|
|
|
330
355
|
@min_count.setter
|
|
331
|
-
def min_count(self, value: Optional[pulumi.Input[int]]):
|
|
356
|
+
def min_count(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
332
357
|
pulumi.set(self, "min_count", value)
|
|
333
358
|
|
|
334
|
-
@property
|
|
359
|
+
@_builtins.property
|
|
335
360
|
@pulumi.getter
|
|
336
|
-
def name(self) -> Optional[pulumi.Input[str]]:
|
|
361
|
+
def name(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
337
362
|
"""
|
|
338
363
|
Add a name for the Ocean cluster.
|
|
339
364
|
"""
|
|
340
365
|
return pulumi.get(self, "name")
|
|
341
366
|
|
|
342
367
|
@name.setter
|
|
343
|
-
def name(self, value: Optional[pulumi.Input[str]]):
|
|
368
|
+
def name(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
344
369
|
pulumi.set(self, "name", value)
|
|
345
370
|
|
|
346
|
-
@property
|
|
371
|
+
@_builtins.property
|
|
347
372
|
@pulumi.getter(name="osDiskSizeGb")
|
|
348
|
-
def os_disk_size_gb(self) -> Optional[pulumi.Input[int]]:
|
|
373
|
+
def os_disk_size_gb(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
349
374
|
"""
|
|
350
375
|
The size of the OS disk in GB.
|
|
351
376
|
"""
|
|
352
377
|
return pulumi.get(self, "os_disk_size_gb")
|
|
353
378
|
|
|
354
379
|
@os_disk_size_gb.setter
|
|
355
|
-
def os_disk_size_gb(self, value: Optional[pulumi.Input[int]]):
|
|
380
|
+
def os_disk_size_gb(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
356
381
|
pulumi.set(self, "os_disk_size_gb", value)
|
|
357
382
|
|
|
358
|
-
@property
|
|
383
|
+
@_builtins.property
|
|
359
384
|
@pulumi.getter(name="osDiskType")
|
|
360
|
-
def os_disk_type(self) -> Optional[pulumi.Input[str]]:
|
|
385
|
+
def os_disk_type(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
361
386
|
"""
|
|
362
387
|
The type of the OS disk.
|
|
363
388
|
"""
|
|
364
389
|
return pulumi.get(self, "os_disk_type")
|
|
365
390
|
|
|
366
391
|
@os_disk_type.setter
|
|
367
|
-
def os_disk_type(self, value: Optional[pulumi.Input[str]]):
|
|
392
|
+
def os_disk_type(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
368
393
|
pulumi.set(self, "os_disk_type", value)
|
|
369
394
|
|
|
370
|
-
@property
|
|
395
|
+
@_builtins.property
|
|
371
396
|
@pulumi.getter(name="osSku")
|
|
372
|
-
def os_sku(self) -> Optional[pulumi.Input[str]]:
|
|
397
|
+
def os_sku(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
373
398
|
"""
|
|
374
399
|
The OS SKU of the OS type. Must correlate with the os type.
|
|
375
400
|
"""
|
|
376
401
|
return pulumi.get(self, "os_sku")
|
|
377
402
|
|
|
378
403
|
@os_sku.setter
|
|
379
|
-
def os_sku(self, value: Optional[pulumi.Input[str]]):
|
|
404
|
+
def os_sku(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
380
405
|
pulumi.set(self, "os_sku", value)
|
|
381
406
|
|
|
382
|
-
@property
|
|
407
|
+
@_builtins.property
|
|
383
408
|
@pulumi.getter(name="osType")
|
|
384
|
-
def os_type(self) -> Optional[pulumi.Input[str]]:
|
|
409
|
+
def os_type(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
385
410
|
"""
|
|
386
411
|
The OS type of the OS disk. Can't be modified once set.
|
|
387
412
|
"""
|
|
388
413
|
return pulumi.get(self, "os_type")
|
|
389
414
|
|
|
390
415
|
@os_type.setter
|
|
391
|
-
def os_type(self, value: Optional[pulumi.Input[str]]):
|
|
416
|
+
def os_type(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
392
417
|
pulumi.set(self, "os_type", value)
|
|
393
418
|
|
|
394
|
-
@property
|
|
419
|
+
@_builtins.property
|
|
395
420
|
@pulumi.getter(name="podSubnetIds")
|
|
396
|
-
def pod_subnet_ids(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
|
|
421
|
+
def pod_subnet_ids(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
|
|
397
422
|
"""
|
|
398
423
|
The IDs of subnets in an existing VNet into which to assign pods in the cluster (requires azure network-plugin).
|
|
399
424
|
"""
|
|
400
425
|
return pulumi.get(self, "pod_subnet_ids")
|
|
401
426
|
|
|
402
427
|
@pod_subnet_ids.setter
|
|
403
|
-
def pod_subnet_ids(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
|
|
428
|
+
def pod_subnet_ids(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]):
|
|
404
429
|
pulumi.set(self, "pod_subnet_ids", value)
|
|
405
430
|
|
|
406
|
-
@property
|
|
431
|
+
@_builtins.property
|
|
407
432
|
@pulumi.getter
|
|
408
433
|
def scheduling(self) -> Optional[pulumi.Input['OceanNpSchedulingArgs']]:
|
|
409
434
|
return pulumi.get(self, "scheduling")
|
|
@@ -412,28 +437,28 @@ class OceanNpArgs:
|
|
|
412
437
|
def scheduling(self, value: Optional[pulumi.Input['OceanNpSchedulingArgs']]):
|
|
413
438
|
pulumi.set(self, "scheduling", value)
|
|
414
439
|
|
|
415
|
-
@property
|
|
440
|
+
@_builtins.property
|
|
416
441
|
@pulumi.getter(name="spotPercentage")
|
|
417
|
-
def spot_percentage(self) -> Optional[pulumi.Input[int]]:
|
|
442
|
+
def spot_percentage(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
418
443
|
"""
|
|
419
444
|
Percentage of spot VMs to maintain.
|
|
420
445
|
"""
|
|
421
446
|
return pulumi.get(self, "spot_percentage")
|
|
422
447
|
|
|
423
448
|
@spot_percentage.setter
|
|
424
|
-
def spot_percentage(self, value: Optional[pulumi.Input[int]]):
|
|
449
|
+
def spot_percentage(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
425
450
|
pulumi.set(self, "spot_percentage", value)
|
|
426
451
|
|
|
427
|
-
@property
|
|
452
|
+
@_builtins.property
|
|
428
453
|
@pulumi.getter
|
|
429
|
-
def tags(self) -> Optional[pulumi.Input[Mapping[str,
|
|
454
|
+
def tags(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]]]:
|
|
430
455
|
return pulumi.get(self, "tags")
|
|
431
456
|
|
|
432
457
|
@tags.setter
|
|
433
|
-
def tags(self, value: Optional[pulumi.Input[Mapping[str,
|
|
458
|
+
def tags(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]]]):
|
|
434
459
|
pulumi.set(self, "tags", value)
|
|
435
460
|
|
|
436
|
-
@property
|
|
461
|
+
@_builtins.property
|
|
437
462
|
@pulumi.getter
|
|
438
463
|
def taints(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['OceanNpTaintArgs']]]]:
|
|
439
464
|
"""
|
|
@@ -445,7 +470,7 @@ class OceanNpArgs:
|
|
|
445
470
|
def taints(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['OceanNpTaintArgs']]]]):
|
|
446
471
|
pulumi.set(self, "taints", value)
|
|
447
472
|
|
|
448
|
-
@property
|
|
473
|
+
@_builtins.property
|
|
449
474
|
@pulumi.getter(name="updatePolicy")
|
|
450
475
|
def update_policy(self) -> Optional[pulumi.Input['OceanNpUpdatePolicyArgs']]:
|
|
451
476
|
return pulumi.get(self, "update_policy")
|
|
@@ -454,77 +479,93 @@ class OceanNpArgs:
|
|
|
454
479
|
def update_policy(self, value: Optional[pulumi.Input['OceanNpUpdatePolicyArgs']]):
|
|
455
480
|
pulumi.set(self, "update_policy", value)
|
|
456
481
|
|
|
457
|
-
@property
|
|
482
|
+
@_builtins.property
|
|
458
483
|
@pulumi.getter(name="vnetSubnetIds")
|
|
459
|
-
def vnet_subnet_ids(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
|
|
484
|
+
def vnet_subnet_ids(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
|
|
460
485
|
"""
|
|
461
486
|
The IDs of subnets in an existing VNet into which to assign nodes in the cluster (requires azure network-plugin).
|
|
462
487
|
"""
|
|
463
488
|
return pulumi.get(self, "vnet_subnet_ids")
|
|
464
489
|
|
|
465
490
|
@vnet_subnet_ids.setter
|
|
466
|
-
def vnet_subnet_ids(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
|
|
491
|
+
def vnet_subnet_ids(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]):
|
|
467
492
|
pulumi.set(self, "vnet_subnet_ids", value)
|
|
468
493
|
|
|
494
|
+
@_builtins.property
|
|
495
|
+
@pulumi.getter(name="vngTemplateScheduling")
|
|
496
|
+
def vng_template_scheduling(self) -> Optional[pulumi.Input['OceanNpVngTemplateSchedulingArgs']]:
|
|
497
|
+
"""
|
|
498
|
+
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.
|
|
499
|
+
"""
|
|
500
|
+
return pulumi.get(self, "vng_template_scheduling")
|
|
501
|
+
|
|
502
|
+
@vng_template_scheduling.setter
|
|
503
|
+
def vng_template_scheduling(self, value: Optional[pulumi.Input['OceanNpVngTemplateSchedulingArgs']]):
|
|
504
|
+
pulumi.set(self, "vng_template_scheduling", value)
|
|
505
|
+
|
|
469
506
|
|
|
470
507
|
@pulumi.input_type
|
|
471
508
|
class _OceanNpState:
|
|
472
509
|
def __init__(__self__, *,
|
|
473
|
-
aks_cluster_name: Optional[pulumi.Input[str]] = None,
|
|
474
|
-
aks_infrastructure_resource_group_name: Optional[pulumi.Input[str]] = None,
|
|
475
|
-
aks_region: Optional[pulumi.Input[str]] = None,
|
|
476
|
-
aks_resource_group_name: Optional[pulumi.Input[str]] = None,
|
|
510
|
+
aks_cluster_name: Optional[pulumi.Input[_builtins.str]] = None,
|
|
511
|
+
aks_infrastructure_resource_group_name: Optional[pulumi.Input[_builtins.str]] = None,
|
|
512
|
+
aks_region: Optional[pulumi.Input[_builtins.str]] = None,
|
|
513
|
+
aks_resource_group_name: Optional[pulumi.Input[_builtins.str]] = None,
|
|
477
514
|
autoscaler: Optional[pulumi.Input['OceanNpAutoscalerArgs']] = None,
|
|
478
|
-
availability_zones: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
|
|
479
|
-
controller_cluster_id: Optional[pulumi.Input[str]] = None,
|
|
480
|
-
enable_node_public_ip: Optional[pulumi.Input[bool]] = None,
|
|
481
|
-
fallback_to_ondemand: Optional[pulumi.Input[bool]] = None,
|
|
515
|
+
availability_zones: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
516
|
+
controller_cluster_id: Optional[pulumi.Input[_builtins.str]] = None,
|
|
517
|
+
enable_node_public_ip: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
518
|
+
fallback_to_ondemand: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
482
519
|
filters: Optional[pulumi.Input['OceanNpFiltersArgs']] = None,
|
|
483
520
|
headrooms: Optional[pulumi.Input[Sequence[pulumi.Input['OceanNpHeadroomArgs']]]] = None,
|
|
484
521
|
health: Optional[pulumi.Input['OceanNpHealthArgs']] = None,
|
|
485
|
-
kubernetes_version: Optional[pulumi.Input[str]] = None,
|
|
486
|
-
labels: Optional[pulumi.Input[Mapping[str,
|
|
522
|
+
kubernetes_version: Optional[pulumi.Input[_builtins.str]] = None,
|
|
523
|
+
labels: Optional[pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]]] = None,
|
|
487
524
|
linux_os_configs: Optional[pulumi.Input[Sequence[pulumi.Input['OceanNpLinuxOsConfigArgs']]]] = None,
|
|
488
|
-
|
|
489
|
-
|
|
490
|
-
|
|
491
|
-
|
|
492
|
-
|
|
493
|
-
|
|
494
|
-
|
|
495
|
-
|
|
496
|
-
|
|
525
|
+
logging: Optional[pulumi.Input['OceanNpLoggingArgs']] = None,
|
|
526
|
+
max_count: Optional[pulumi.Input[_builtins.int]] = None,
|
|
527
|
+
max_pods_per_node: Optional[pulumi.Input[_builtins.int]] = None,
|
|
528
|
+
min_count: Optional[pulumi.Input[_builtins.int]] = None,
|
|
529
|
+
name: Optional[pulumi.Input[_builtins.str]] = None,
|
|
530
|
+
os_disk_size_gb: Optional[pulumi.Input[_builtins.int]] = None,
|
|
531
|
+
os_disk_type: Optional[pulumi.Input[_builtins.str]] = None,
|
|
532
|
+
os_sku: Optional[pulumi.Input[_builtins.str]] = None,
|
|
533
|
+
os_type: Optional[pulumi.Input[_builtins.str]] = None,
|
|
534
|
+
pod_subnet_ids: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
497
535
|
scheduling: Optional[pulumi.Input['OceanNpSchedulingArgs']] = None,
|
|
498
|
-
spot_percentage: Optional[pulumi.Input[int]] = None,
|
|
499
|
-
tags: Optional[pulumi.Input[Mapping[str,
|
|
536
|
+
spot_percentage: Optional[pulumi.Input[_builtins.int]] = None,
|
|
537
|
+
tags: Optional[pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]]] = None,
|
|
500
538
|
taints: Optional[pulumi.Input[Sequence[pulumi.Input['OceanNpTaintArgs']]]] = None,
|
|
501
539
|
update_policy: Optional[pulumi.Input['OceanNpUpdatePolicyArgs']] = None,
|
|
502
|
-
vnet_subnet_ids: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None
|
|
540
|
+
vnet_subnet_ids: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
541
|
+
vng_template_scheduling: Optional[pulumi.Input['OceanNpVngTemplateSchedulingArgs']] = None):
|
|
503
542
|
"""
|
|
504
543
|
Input properties used for looking up and filtering OceanNp resources.
|
|
505
544
|
:param pulumi.Input['OceanNpAutoscalerArgs'] autoscaler: The Ocean Kubernetes Autoscaler object.
|
|
506
|
-
: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.
|
|
507
|
-
:param pulumi.Input[str] controller_cluster_id: Enter a unique Ocean cluster identifier. Cannot be updated. This needs to match with string that was used to install the controller in the cluster, typically clusterName + 8 digit string.
|
|
508
|
-
:param pulumi.Input[bool] enable_node_public_ip: Enable node public IP.
|
|
509
|
-
:param pulumi.Input[bool] fallback_to_ondemand: If no spot VM markets are available, enable Ocean to launch regular (pay-as-you-go) nodes instead.
|
|
545
|
+
: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.
|
|
546
|
+
:param pulumi.Input[_builtins.str] controller_cluster_id: Enter a unique Ocean cluster identifier. Cannot be updated. This needs to match with string that was used to install the controller in the cluster, typically clusterName + 8 digit string.
|
|
547
|
+
:param pulumi.Input[_builtins.bool] enable_node_public_ip: Enable node public IP.
|
|
548
|
+
:param pulumi.Input[_builtins.bool] fallback_to_ondemand: If no spot VM markets are available, enable Ocean to launch regular (pay-as-you-go) nodes instead.
|
|
510
549
|
:param pulumi.Input['OceanNpFiltersArgs'] filters: Filters for the VM sizes that can be launched from the virtual node group.
|
|
511
550
|
:param pulumi.Input[Sequence[pulumi.Input['OceanNpHeadroomArgs']]] headrooms: Specify the custom headroom per VNG. Provide a list of headroom objects.
|
|
512
551
|
:param pulumi.Input['OceanNpHealthArgs'] health: The Ocean AKS Health object.
|
|
513
|
-
: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.
|
|
514
|
-
:param pulumi.Input[Mapping[str,
|
|
552
|
+
: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.
|
|
553
|
+
: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 well-known labels](https://kubernetes.io/docs/reference/labels-annotations-taints/) or [ Azure AKS labels](https://learn.microsoft.com/en-us/azure/aks/use-labels) or [Spot labels](https://docs.spot.io/ocean/features/labels-and-taints?id=spot-labels).
|
|
515
554
|
:param pulumi.Input[Sequence[pulumi.Input['OceanNpLinuxOsConfigArgs']]] linux_os_configs: Custom Linux OS configuration.
|
|
516
|
-
:param pulumi.Input[
|
|
517
|
-
:param pulumi.Input[int]
|
|
518
|
-
:param pulumi.Input[int]
|
|
519
|
-
:param pulumi.Input[
|
|
520
|
-
:param pulumi.Input[
|
|
521
|
-
:param pulumi.Input[
|
|
522
|
-
:param pulumi.Input[str]
|
|
523
|
-
:param pulumi.Input[str]
|
|
524
|
-
:param pulumi.Input[
|
|
525
|
-
:param pulumi.Input[
|
|
555
|
+
:param pulumi.Input['OceanNpLoggingArgs'] logging: The Ocean AKS Logging Object.
|
|
556
|
+
:param pulumi.Input[_builtins.int] max_count: Maximum node count limit.
|
|
557
|
+
:param pulumi.Input[_builtins.int] max_pods_per_node: The maximum number of pods per node in the node pools.
|
|
558
|
+
:param pulumi.Input[_builtins.int] min_count: Minimum node count limit.
|
|
559
|
+
:param pulumi.Input[_builtins.str] name: Add a name for the Ocean cluster.
|
|
560
|
+
:param pulumi.Input[_builtins.int] os_disk_size_gb: The size of the OS disk in GB.
|
|
561
|
+
:param pulumi.Input[_builtins.str] os_disk_type: The type of the OS disk.
|
|
562
|
+
:param pulumi.Input[_builtins.str] os_sku: The OS SKU of the OS type. Must correlate with the os type.
|
|
563
|
+
:param pulumi.Input[_builtins.str] os_type: The OS type of the OS disk. Can't be modified once set.
|
|
564
|
+
: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).
|
|
565
|
+
:param pulumi.Input[_builtins.int] spot_percentage: Percentage of spot VMs to maintain.
|
|
526
566
|
:param pulumi.Input[Sequence[pulumi.Input['OceanNpTaintArgs']]] taints: Add taints to a virtual node group. Only custom user taints are allowed, and not [Kubernetes well-known taints](https://kubernetes.io/docs/reference/labels-annotations-taints/) or Azure AKS [ScaleSetPrioirty (Spot VM) taint](https://learn.microsoft.com/en-us/azure/aks/spot-node-pool). For all Spot VMs, AKS injects a taint kubernetes.azure.com/scalesetpriority=spot:NoSchedule, to ensure that only workloads that can handle interruptions are scheduled on Spot nodes. To [schedule a pod to run on Spot node](https://learn.microsoft.com/en-us/azure/aks/spot-node-pool#schedule-a-pod-to-run-on-the-spot-node), add a toleration but dont include the nodeAffinity (not supported for Spot Ocean), this will prevent the pod from being scheduled using Spot Ocean.
|
|
527
|
-
: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).
|
|
567
|
+
: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).
|
|
568
|
+
:param pulumi.Input['OceanNpVngTemplateSchedulingArgs'] vng_template_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.
|
|
528
569
|
"""
|
|
529
570
|
if aks_cluster_name is not None:
|
|
530
571
|
pulumi.set(__self__, "aks_cluster_name", aks_cluster_name)
|
|
@@ -556,6 +597,8 @@ class _OceanNpState:
|
|
|
556
597
|
pulumi.set(__self__, "labels", labels)
|
|
557
598
|
if linux_os_configs is not None:
|
|
558
599
|
pulumi.set(__self__, "linux_os_configs", linux_os_configs)
|
|
600
|
+
if logging is not None:
|
|
601
|
+
pulumi.set(__self__, "logging", logging)
|
|
559
602
|
if max_count is not None:
|
|
560
603
|
pulumi.set(__self__, "max_count", max_count)
|
|
561
604
|
if max_pods_per_node is not None:
|
|
@@ -586,44 +629,46 @@ class _OceanNpState:
|
|
|
586
629
|
pulumi.set(__self__, "update_policy", update_policy)
|
|
587
630
|
if vnet_subnet_ids is not None:
|
|
588
631
|
pulumi.set(__self__, "vnet_subnet_ids", vnet_subnet_ids)
|
|
632
|
+
if vng_template_scheduling is not None:
|
|
633
|
+
pulumi.set(__self__, "vng_template_scheduling", vng_template_scheduling)
|
|
589
634
|
|
|
590
|
-
@property
|
|
635
|
+
@_builtins.property
|
|
591
636
|
@pulumi.getter(name="aksClusterName")
|
|
592
|
-
def aks_cluster_name(self) -> Optional[pulumi.Input[str]]:
|
|
637
|
+
def aks_cluster_name(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
593
638
|
return pulumi.get(self, "aks_cluster_name")
|
|
594
639
|
|
|
595
640
|
@aks_cluster_name.setter
|
|
596
|
-
def aks_cluster_name(self, value: Optional[pulumi.Input[str]]):
|
|
641
|
+
def aks_cluster_name(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
597
642
|
pulumi.set(self, "aks_cluster_name", value)
|
|
598
643
|
|
|
599
|
-
@property
|
|
644
|
+
@_builtins.property
|
|
600
645
|
@pulumi.getter(name="aksInfrastructureResourceGroupName")
|
|
601
|
-
def aks_infrastructure_resource_group_name(self) -> Optional[pulumi.Input[str]]:
|
|
646
|
+
def aks_infrastructure_resource_group_name(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
602
647
|
return pulumi.get(self, "aks_infrastructure_resource_group_name")
|
|
603
648
|
|
|
604
649
|
@aks_infrastructure_resource_group_name.setter
|
|
605
|
-
def aks_infrastructure_resource_group_name(self, value: Optional[pulumi.Input[str]]):
|
|
650
|
+
def aks_infrastructure_resource_group_name(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
606
651
|
pulumi.set(self, "aks_infrastructure_resource_group_name", value)
|
|
607
652
|
|
|
608
|
-
@property
|
|
653
|
+
@_builtins.property
|
|
609
654
|
@pulumi.getter(name="aksRegion")
|
|
610
|
-
def aks_region(self) -> Optional[pulumi.Input[str]]:
|
|
655
|
+
def aks_region(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
611
656
|
return pulumi.get(self, "aks_region")
|
|
612
657
|
|
|
613
658
|
@aks_region.setter
|
|
614
|
-
def aks_region(self, value: Optional[pulumi.Input[str]]):
|
|
659
|
+
def aks_region(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
615
660
|
pulumi.set(self, "aks_region", value)
|
|
616
661
|
|
|
617
|
-
@property
|
|
662
|
+
@_builtins.property
|
|
618
663
|
@pulumi.getter(name="aksResourceGroupName")
|
|
619
|
-
def aks_resource_group_name(self) -> Optional[pulumi.Input[str]]:
|
|
664
|
+
def aks_resource_group_name(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
620
665
|
return pulumi.get(self, "aks_resource_group_name")
|
|
621
666
|
|
|
622
667
|
@aks_resource_group_name.setter
|
|
623
|
-
def aks_resource_group_name(self, value: Optional[pulumi.Input[str]]):
|
|
668
|
+
def aks_resource_group_name(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
624
669
|
pulumi.set(self, "aks_resource_group_name", value)
|
|
625
670
|
|
|
626
|
-
@property
|
|
671
|
+
@_builtins.property
|
|
627
672
|
@pulumi.getter
|
|
628
673
|
def autoscaler(self) -> Optional[pulumi.Input['OceanNpAutoscalerArgs']]:
|
|
629
674
|
"""
|
|
@@ -635,55 +680,55 @@ class _OceanNpState:
|
|
|
635
680
|
def autoscaler(self, value: Optional[pulumi.Input['OceanNpAutoscalerArgs']]):
|
|
636
681
|
pulumi.set(self, "autoscaler", value)
|
|
637
682
|
|
|
638
|
-
@property
|
|
683
|
+
@_builtins.property
|
|
639
684
|
@pulumi.getter(name="availabilityZones")
|
|
640
|
-
def availability_zones(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
|
|
685
|
+
def availability_zones(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
|
|
641
686
|
"""
|
|
642
687
|
An Array holding Availability Zones, this configures the availability zones the Ocean may launch instances in per VNG.
|
|
643
688
|
"""
|
|
644
689
|
return pulumi.get(self, "availability_zones")
|
|
645
690
|
|
|
646
691
|
@availability_zones.setter
|
|
647
|
-
def availability_zones(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
|
|
692
|
+
def availability_zones(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]):
|
|
648
693
|
pulumi.set(self, "availability_zones", value)
|
|
649
694
|
|
|
650
|
-
@property
|
|
695
|
+
@_builtins.property
|
|
651
696
|
@pulumi.getter(name="controllerClusterId")
|
|
652
|
-
def controller_cluster_id(self) -> Optional[pulumi.Input[str]]:
|
|
697
|
+
def controller_cluster_id(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
653
698
|
"""
|
|
654
699
|
Enter a unique Ocean cluster identifier. Cannot be updated. This needs to match with string that was used to install the controller in the cluster, typically clusterName + 8 digit string.
|
|
655
700
|
"""
|
|
656
701
|
return pulumi.get(self, "controller_cluster_id")
|
|
657
702
|
|
|
658
703
|
@controller_cluster_id.setter
|
|
659
|
-
def controller_cluster_id(self, value: Optional[pulumi.Input[str]]):
|
|
704
|
+
def controller_cluster_id(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
660
705
|
pulumi.set(self, "controller_cluster_id", value)
|
|
661
706
|
|
|
662
|
-
@property
|
|
707
|
+
@_builtins.property
|
|
663
708
|
@pulumi.getter(name="enableNodePublicIp")
|
|
664
|
-
def enable_node_public_ip(self) -> Optional[pulumi.Input[bool]]:
|
|
709
|
+
def enable_node_public_ip(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
665
710
|
"""
|
|
666
711
|
Enable node public IP.
|
|
667
712
|
"""
|
|
668
713
|
return pulumi.get(self, "enable_node_public_ip")
|
|
669
714
|
|
|
670
715
|
@enable_node_public_ip.setter
|
|
671
|
-
def enable_node_public_ip(self, value: Optional[pulumi.Input[bool]]):
|
|
716
|
+
def enable_node_public_ip(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
672
717
|
pulumi.set(self, "enable_node_public_ip", value)
|
|
673
718
|
|
|
674
|
-
@property
|
|
719
|
+
@_builtins.property
|
|
675
720
|
@pulumi.getter(name="fallbackToOndemand")
|
|
676
|
-
def fallback_to_ondemand(self) -> Optional[pulumi.Input[bool]]:
|
|
721
|
+
def fallback_to_ondemand(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
677
722
|
"""
|
|
678
723
|
If no spot VM markets are available, enable Ocean to launch regular (pay-as-you-go) nodes instead.
|
|
679
724
|
"""
|
|
680
725
|
return pulumi.get(self, "fallback_to_ondemand")
|
|
681
726
|
|
|
682
727
|
@fallback_to_ondemand.setter
|
|
683
|
-
def fallback_to_ondemand(self, value: Optional[pulumi.Input[bool]]):
|
|
728
|
+
def fallback_to_ondemand(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
684
729
|
pulumi.set(self, "fallback_to_ondemand", value)
|
|
685
730
|
|
|
686
|
-
@property
|
|
731
|
+
@_builtins.property
|
|
687
732
|
@pulumi.getter
|
|
688
733
|
def filters(self) -> Optional[pulumi.Input['OceanNpFiltersArgs']]:
|
|
689
734
|
"""
|
|
@@ -695,7 +740,7 @@ class _OceanNpState:
|
|
|
695
740
|
def filters(self, value: Optional[pulumi.Input['OceanNpFiltersArgs']]):
|
|
696
741
|
pulumi.set(self, "filters", value)
|
|
697
742
|
|
|
698
|
-
@property
|
|
743
|
+
@_builtins.property
|
|
699
744
|
@pulumi.getter
|
|
700
745
|
def headrooms(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['OceanNpHeadroomArgs']]]]:
|
|
701
746
|
"""
|
|
@@ -707,7 +752,7 @@ class _OceanNpState:
|
|
|
707
752
|
def headrooms(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['OceanNpHeadroomArgs']]]]):
|
|
708
753
|
pulumi.set(self, "headrooms", value)
|
|
709
754
|
|
|
710
|
-
@property
|
|
755
|
+
@_builtins.property
|
|
711
756
|
@pulumi.getter
|
|
712
757
|
def health(self) -> Optional[pulumi.Input['OceanNpHealthArgs']]:
|
|
713
758
|
"""
|
|
@@ -719,31 +764,31 @@ class _OceanNpState:
|
|
|
719
764
|
def health(self, value: Optional[pulumi.Input['OceanNpHealthArgs']]):
|
|
720
765
|
pulumi.set(self, "health", value)
|
|
721
766
|
|
|
722
|
-
@property
|
|
767
|
+
@_builtins.property
|
|
723
768
|
@pulumi.getter(name="kubernetesVersion")
|
|
724
|
-
def kubernetes_version(self) -> Optional[pulumi.Input[str]]:
|
|
769
|
+
def kubernetes_version(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
725
770
|
"""
|
|
726
771
|
The desired Kubernetes version of the launched nodes. In case the value is null, the Kubernetes version of the control plane is used.
|
|
727
772
|
"""
|
|
728
773
|
return pulumi.get(self, "kubernetes_version")
|
|
729
774
|
|
|
730
775
|
@kubernetes_version.setter
|
|
731
|
-
def kubernetes_version(self, value: Optional[pulumi.Input[str]]):
|
|
776
|
+
def kubernetes_version(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
732
777
|
pulumi.set(self, "kubernetes_version", value)
|
|
733
778
|
|
|
734
|
-
@property
|
|
779
|
+
@_builtins.property
|
|
735
780
|
@pulumi.getter
|
|
736
|
-
def labels(self) -> Optional[pulumi.Input[Mapping[str,
|
|
781
|
+
def labels(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]]]:
|
|
737
782
|
"""
|
|
738
783
|
An array of labels to add to the virtual node group. Only custom user labels are allowed, and not [Kubernetes well-known labels](https://kubernetes.io/docs/reference/labels-annotations-taints/) or [ Azure AKS labels](https://learn.microsoft.com/en-us/azure/aks/use-labels) or [Spot labels](https://docs.spot.io/ocean/features/labels-and-taints?id=spot-labels).
|
|
739
784
|
"""
|
|
740
785
|
return pulumi.get(self, "labels")
|
|
741
786
|
|
|
742
787
|
@labels.setter
|
|
743
|
-
def labels(self, value: Optional[pulumi.Input[Mapping[str,
|
|
788
|
+
def labels(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]]]):
|
|
744
789
|
pulumi.set(self, "labels", value)
|
|
745
790
|
|
|
746
|
-
@property
|
|
791
|
+
@_builtins.property
|
|
747
792
|
@pulumi.getter(name="linuxOsConfigs")
|
|
748
793
|
def linux_os_configs(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['OceanNpLinuxOsConfigArgs']]]]:
|
|
749
794
|
"""
|
|
@@ -755,115 +800,127 @@ class _OceanNpState:
|
|
|
755
800
|
def linux_os_configs(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['OceanNpLinuxOsConfigArgs']]]]):
|
|
756
801
|
pulumi.set(self, "linux_os_configs", value)
|
|
757
802
|
|
|
758
|
-
@property
|
|
803
|
+
@_builtins.property
|
|
804
|
+
@pulumi.getter
|
|
805
|
+
def logging(self) -> Optional[pulumi.Input['OceanNpLoggingArgs']]:
|
|
806
|
+
"""
|
|
807
|
+
The Ocean AKS Logging Object.
|
|
808
|
+
"""
|
|
809
|
+
return pulumi.get(self, "logging")
|
|
810
|
+
|
|
811
|
+
@logging.setter
|
|
812
|
+
def logging(self, value: Optional[pulumi.Input['OceanNpLoggingArgs']]):
|
|
813
|
+
pulumi.set(self, "logging", value)
|
|
814
|
+
|
|
815
|
+
@_builtins.property
|
|
759
816
|
@pulumi.getter(name="maxCount")
|
|
760
|
-
def max_count(self) -> Optional[pulumi.Input[int]]:
|
|
817
|
+
def max_count(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
761
818
|
"""
|
|
762
819
|
Maximum node count limit.
|
|
763
820
|
"""
|
|
764
821
|
return pulumi.get(self, "max_count")
|
|
765
822
|
|
|
766
823
|
@max_count.setter
|
|
767
|
-
def max_count(self, value: Optional[pulumi.Input[int]]):
|
|
824
|
+
def max_count(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
768
825
|
pulumi.set(self, "max_count", value)
|
|
769
826
|
|
|
770
|
-
@property
|
|
827
|
+
@_builtins.property
|
|
771
828
|
@pulumi.getter(name="maxPodsPerNode")
|
|
772
|
-
def max_pods_per_node(self) -> Optional[pulumi.Input[int]]:
|
|
829
|
+
def max_pods_per_node(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
773
830
|
"""
|
|
774
831
|
The maximum number of pods per node in the node pools.
|
|
775
832
|
"""
|
|
776
833
|
return pulumi.get(self, "max_pods_per_node")
|
|
777
834
|
|
|
778
835
|
@max_pods_per_node.setter
|
|
779
|
-
def max_pods_per_node(self, value: Optional[pulumi.Input[int]]):
|
|
836
|
+
def max_pods_per_node(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
780
837
|
pulumi.set(self, "max_pods_per_node", value)
|
|
781
838
|
|
|
782
|
-
@property
|
|
839
|
+
@_builtins.property
|
|
783
840
|
@pulumi.getter(name="minCount")
|
|
784
|
-
def min_count(self) -> Optional[pulumi.Input[int]]:
|
|
841
|
+
def min_count(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
785
842
|
"""
|
|
786
843
|
Minimum node count limit.
|
|
787
844
|
"""
|
|
788
845
|
return pulumi.get(self, "min_count")
|
|
789
846
|
|
|
790
847
|
@min_count.setter
|
|
791
|
-
def min_count(self, value: Optional[pulumi.Input[int]]):
|
|
848
|
+
def min_count(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
792
849
|
pulumi.set(self, "min_count", value)
|
|
793
850
|
|
|
794
|
-
@property
|
|
851
|
+
@_builtins.property
|
|
795
852
|
@pulumi.getter
|
|
796
|
-
def name(self) -> Optional[pulumi.Input[str]]:
|
|
853
|
+
def name(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
797
854
|
"""
|
|
798
855
|
Add a name for the Ocean cluster.
|
|
799
856
|
"""
|
|
800
857
|
return pulumi.get(self, "name")
|
|
801
858
|
|
|
802
859
|
@name.setter
|
|
803
|
-
def name(self, value: Optional[pulumi.Input[str]]):
|
|
860
|
+
def name(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
804
861
|
pulumi.set(self, "name", value)
|
|
805
862
|
|
|
806
|
-
@property
|
|
863
|
+
@_builtins.property
|
|
807
864
|
@pulumi.getter(name="osDiskSizeGb")
|
|
808
|
-
def os_disk_size_gb(self) -> Optional[pulumi.Input[int]]:
|
|
865
|
+
def os_disk_size_gb(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
809
866
|
"""
|
|
810
867
|
The size of the OS disk in GB.
|
|
811
868
|
"""
|
|
812
869
|
return pulumi.get(self, "os_disk_size_gb")
|
|
813
870
|
|
|
814
871
|
@os_disk_size_gb.setter
|
|
815
|
-
def os_disk_size_gb(self, value: Optional[pulumi.Input[int]]):
|
|
872
|
+
def os_disk_size_gb(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
816
873
|
pulumi.set(self, "os_disk_size_gb", value)
|
|
817
874
|
|
|
818
|
-
@property
|
|
875
|
+
@_builtins.property
|
|
819
876
|
@pulumi.getter(name="osDiskType")
|
|
820
|
-
def os_disk_type(self) -> Optional[pulumi.Input[str]]:
|
|
877
|
+
def os_disk_type(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
821
878
|
"""
|
|
822
879
|
The type of the OS disk.
|
|
823
880
|
"""
|
|
824
881
|
return pulumi.get(self, "os_disk_type")
|
|
825
882
|
|
|
826
883
|
@os_disk_type.setter
|
|
827
|
-
def os_disk_type(self, value: Optional[pulumi.Input[str]]):
|
|
884
|
+
def os_disk_type(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
828
885
|
pulumi.set(self, "os_disk_type", value)
|
|
829
886
|
|
|
830
|
-
@property
|
|
887
|
+
@_builtins.property
|
|
831
888
|
@pulumi.getter(name="osSku")
|
|
832
|
-
def os_sku(self) -> Optional[pulumi.Input[str]]:
|
|
889
|
+
def os_sku(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
833
890
|
"""
|
|
834
891
|
The OS SKU of the OS type. Must correlate with the os type.
|
|
835
892
|
"""
|
|
836
893
|
return pulumi.get(self, "os_sku")
|
|
837
894
|
|
|
838
895
|
@os_sku.setter
|
|
839
|
-
def os_sku(self, value: Optional[pulumi.Input[str]]):
|
|
896
|
+
def os_sku(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
840
897
|
pulumi.set(self, "os_sku", value)
|
|
841
898
|
|
|
842
|
-
@property
|
|
899
|
+
@_builtins.property
|
|
843
900
|
@pulumi.getter(name="osType")
|
|
844
|
-
def os_type(self) -> Optional[pulumi.Input[str]]:
|
|
901
|
+
def os_type(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
845
902
|
"""
|
|
846
903
|
The OS type of the OS disk. Can't be modified once set.
|
|
847
904
|
"""
|
|
848
905
|
return pulumi.get(self, "os_type")
|
|
849
906
|
|
|
850
907
|
@os_type.setter
|
|
851
|
-
def os_type(self, value: Optional[pulumi.Input[str]]):
|
|
908
|
+
def os_type(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
852
909
|
pulumi.set(self, "os_type", value)
|
|
853
910
|
|
|
854
|
-
@property
|
|
911
|
+
@_builtins.property
|
|
855
912
|
@pulumi.getter(name="podSubnetIds")
|
|
856
|
-
def pod_subnet_ids(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
|
|
913
|
+
def pod_subnet_ids(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
|
|
857
914
|
"""
|
|
858
915
|
The IDs of subnets in an existing VNet into which to assign pods in the cluster (requires azure network-plugin).
|
|
859
916
|
"""
|
|
860
917
|
return pulumi.get(self, "pod_subnet_ids")
|
|
861
918
|
|
|
862
919
|
@pod_subnet_ids.setter
|
|
863
|
-
def pod_subnet_ids(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
|
|
920
|
+
def pod_subnet_ids(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]):
|
|
864
921
|
pulumi.set(self, "pod_subnet_ids", value)
|
|
865
922
|
|
|
866
|
-
@property
|
|
923
|
+
@_builtins.property
|
|
867
924
|
@pulumi.getter
|
|
868
925
|
def scheduling(self) -> Optional[pulumi.Input['OceanNpSchedulingArgs']]:
|
|
869
926
|
return pulumi.get(self, "scheduling")
|
|
@@ -872,28 +929,28 @@ class _OceanNpState:
|
|
|
872
929
|
def scheduling(self, value: Optional[pulumi.Input['OceanNpSchedulingArgs']]):
|
|
873
930
|
pulumi.set(self, "scheduling", value)
|
|
874
931
|
|
|
875
|
-
@property
|
|
932
|
+
@_builtins.property
|
|
876
933
|
@pulumi.getter(name="spotPercentage")
|
|
877
|
-
def spot_percentage(self) -> Optional[pulumi.Input[int]]:
|
|
934
|
+
def spot_percentage(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
878
935
|
"""
|
|
879
936
|
Percentage of spot VMs to maintain.
|
|
880
937
|
"""
|
|
881
938
|
return pulumi.get(self, "spot_percentage")
|
|
882
939
|
|
|
883
940
|
@spot_percentage.setter
|
|
884
|
-
def spot_percentage(self, value: Optional[pulumi.Input[int]]):
|
|
941
|
+
def spot_percentage(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
885
942
|
pulumi.set(self, "spot_percentage", value)
|
|
886
943
|
|
|
887
|
-
@property
|
|
944
|
+
@_builtins.property
|
|
888
945
|
@pulumi.getter
|
|
889
|
-
def tags(self) -> Optional[pulumi.Input[Mapping[str,
|
|
946
|
+
def tags(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]]]:
|
|
890
947
|
return pulumi.get(self, "tags")
|
|
891
948
|
|
|
892
949
|
@tags.setter
|
|
893
|
-
def tags(self, value: Optional[pulumi.Input[Mapping[str,
|
|
950
|
+
def tags(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]]]):
|
|
894
951
|
pulumi.set(self, "tags", value)
|
|
895
952
|
|
|
896
|
-
@property
|
|
953
|
+
@_builtins.property
|
|
897
954
|
@pulumi.getter
|
|
898
955
|
def taints(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['OceanNpTaintArgs']]]]:
|
|
899
956
|
"""
|
|
@@ -905,7 +962,7 @@ class _OceanNpState:
|
|
|
905
962
|
def taints(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['OceanNpTaintArgs']]]]):
|
|
906
963
|
pulumi.set(self, "taints", value)
|
|
907
964
|
|
|
908
|
-
@property
|
|
965
|
+
@_builtins.property
|
|
909
966
|
@pulumi.getter(name="updatePolicy")
|
|
910
967
|
def update_policy(self) -> Optional[pulumi.Input['OceanNpUpdatePolicyArgs']]:
|
|
911
968
|
return pulumi.get(self, "update_policy")
|
|
@@ -914,105 +971,99 @@ class _OceanNpState:
|
|
|
914
971
|
def update_policy(self, value: Optional[pulumi.Input['OceanNpUpdatePolicyArgs']]):
|
|
915
972
|
pulumi.set(self, "update_policy", value)
|
|
916
973
|
|
|
917
|
-
@property
|
|
974
|
+
@_builtins.property
|
|
918
975
|
@pulumi.getter(name="vnetSubnetIds")
|
|
919
|
-
def vnet_subnet_ids(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
|
|
976
|
+
def vnet_subnet_ids(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
|
|
920
977
|
"""
|
|
921
978
|
The IDs of subnets in an existing VNet into which to assign nodes in the cluster (requires azure network-plugin).
|
|
922
979
|
"""
|
|
923
980
|
return pulumi.get(self, "vnet_subnet_ids")
|
|
924
981
|
|
|
925
982
|
@vnet_subnet_ids.setter
|
|
926
|
-
def vnet_subnet_ids(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
|
|
983
|
+
def vnet_subnet_ids(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]):
|
|
927
984
|
pulumi.set(self, "vnet_subnet_ids", value)
|
|
928
985
|
|
|
986
|
+
@_builtins.property
|
|
987
|
+
@pulumi.getter(name="vngTemplateScheduling")
|
|
988
|
+
def vng_template_scheduling(self) -> Optional[pulumi.Input['OceanNpVngTemplateSchedulingArgs']]:
|
|
989
|
+
"""
|
|
990
|
+
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.
|
|
991
|
+
"""
|
|
992
|
+
return pulumi.get(self, "vng_template_scheduling")
|
|
993
|
+
|
|
994
|
+
@vng_template_scheduling.setter
|
|
995
|
+
def vng_template_scheduling(self, value: Optional[pulumi.Input['OceanNpVngTemplateSchedulingArgs']]):
|
|
996
|
+
pulumi.set(self, "vng_template_scheduling", value)
|
|
997
|
+
|
|
929
998
|
|
|
999
|
+
@pulumi.type_token("spotinst:azure/oceanNp:OceanNp")
|
|
930
1000
|
class OceanNp(pulumi.CustomResource):
|
|
931
1001
|
@overload
|
|
932
1002
|
def __init__(__self__,
|
|
933
1003
|
resource_name: str,
|
|
934
1004
|
opts: Optional[pulumi.ResourceOptions] = None,
|
|
935
|
-
aks_cluster_name: Optional[pulumi.Input[str]] = None,
|
|
936
|
-
aks_infrastructure_resource_group_name: Optional[pulumi.Input[str]] = None,
|
|
937
|
-
aks_region: Optional[pulumi.Input[str]] = None,
|
|
938
|
-
aks_resource_group_name: Optional[pulumi.Input[str]] = None,
|
|
939
|
-
autoscaler: Optional[pulumi.Input[
|
|
940
|
-
availability_zones: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
|
|
941
|
-
controller_cluster_id: Optional[pulumi.Input[str]] = None,
|
|
942
|
-
enable_node_public_ip: Optional[pulumi.Input[bool]] = None,
|
|
943
|
-
fallback_to_ondemand: Optional[pulumi.Input[bool]] = None,
|
|
944
|
-
filters: Optional[pulumi.Input[
|
|
945
|
-
headrooms: Optional[pulumi.Input[Sequence[pulumi.Input[
|
|
946
|
-
health: Optional[pulumi.Input[
|
|
947
|
-
kubernetes_version: Optional[pulumi.Input[str]] = None,
|
|
948
|
-
labels: Optional[pulumi.Input[Mapping[str,
|
|
949
|
-
linux_os_configs: Optional[pulumi.Input[Sequence[pulumi.Input[
|
|
950
|
-
|
|
951
|
-
|
|
952
|
-
|
|
953
|
-
|
|
954
|
-
|
|
955
|
-
|
|
956
|
-
|
|
957
|
-
|
|
958
|
-
|
|
959
|
-
|
|
960
|
-
|
|
961
|
-
|
|
962
|
-
|
|
963
|
-
|
|
964
|
-
|
|
1005
|
+
aks_cluster_name: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1006
|
+
aks_infrastructure_resource_group_name: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1007
|
+
aks_region: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1008
|
+
aks_resource_group_name: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1009
|
+
autoscaler: Optional[pulumi.Input[Union['OceanNpAutoscalerArgs', 'OceanNpAutoscalerArgsDict']]] = None,
|
|
1010
|
+
availability_zones: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
1011
|
+
controller_cluster_id: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1012
|
+
enable_node_public_ip: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
1013
|
+
fallback_to_ondemand: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
1014
|
+
filters: Optional[pulumi.Input[Union['OceanNpFiltersArgs', 'OceanNpFiltersArgsDict']]] = None,
|
|
1015
|
+
headrooms: Optional[pulumi.Input[Sequence[pulumi.Input[Union['OceanNpHeadroomArgs', 'OceanNpHeadroomArgsDict']]]]] = None,
|
|
1016
|
+
health: Optional[pulumi.Input[Union['OceanNpHealthArgs', 'OceanNpHealthArgsDict']]] = None,
|
|
1017
|
+
kubernetes_version: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1018
|
+
labels: Optional[pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]]] = None,
|
|
1019
|
+
linux_os_configs: Optional[pulumi.Input[Sequence[pulumi.Input[Union['OceanNpLinuxOsConfigArgs', 'OceanNpLinuxOsConfigArgsDict']]]]] = None,
|
|
1020
|
+
logging: Optional[pulumi.Input[Union['OceanNpLoggingArgs', 'OceanNpLoggingArgsDict']]] = None,
|
|
1021
|
+
max_count: Optional[pulumi.Input[_builtins.int]] = None,
|
|
1022
|
+
max_pods_per_node: Optional[pulumi.Input[_builtins.int]] = None,
|
|
1023
|
+
min_count: Optional[pulumi.Input[_builtins.int]] = None,
|
|
1024
|
+
name: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1025
|
+
os_disk_size_gb: Optional[pulumi.Input[_builtins.int]] = None,
|
|
1026
|
+
os_disk_type: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1027
|
+
os_sku: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1028
|
+
os_type: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1029
|
+
pod_subnet_ids: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
1030
|
+
scheduling: Optional[pulumi.Input[Union['OceanNpSchedulingArgs', 'OceanNpSchedulingArgsDict']]] = None,
|
|
1031
|
+
spot_percentage: Optional[pulumi.Input[_builtins.int]] = None,
|
|
1032
|
+
tags: Optional[pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]]] = None,
|
|
1033
|
+
taints: Optional[pulumi.Input[Sequence[pulumi.Input[Union['OceanNpTaintArgs', 'OceanNpTaintArgsDict']]]]] = None,
|
|
1034
|
+
update_policy: Optional[pulumi.Input[Union['OceanNpUpdatePolicyArgs', 'OceanNpUpdatePolicyArgsDict']]] = None,
|
|
1035
|
+
vnet_subnet_ids: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
1036
|
+
vng_template_scheduling: Optional[pulumi.Input[Union['OceanNpVngTemplateSchedulingArgs', 'OceanNpVngTemplateSchedulingArgsDict']]] = None,
|
|
965
1037
|
__props__=None):
|
|
966
1038
|
"""
|
|
967
|
-
|
|
968
|
-
|
|
969
|
-
## Basic Ocean Cluster Creation Usage Example - using minimum configuration with only required parameters
|
|
970
|
-
|
|
971
|
-
```python
|
|
972
|
-
import pulumi
|
|
973
|
-
import pulumi_spotinst as spotinst
|
|
974
|
-
|
|
975
|
-
example = spotinst.azure.OceanNp("example",
|
|
976
|
-
name="test",
|
|
977
|
-
aks_region="eastus",
|
|
978
|
-
aks_cluster_name="test-cluster",
|
|
979
|
-
aks_infrastructure_resource_group_name="MC_TestResourceGroup_test-cluster_eastus",
|
|
980
|
-
aks_resource_group_name="TestResourceGroup",
|
|
981
|
-
controller_cluster_id="test-123124",
|
|
982
|
-
availability_zones=[
|
|
983
|
-
"1",
|
|
984
|
-
"2",
|
|
985
|
-
"3",
|
|
986
|
-
])
|
|
987
|
-
```
|
|
988
|
-
|
|
989
|
-
## Detailed Ocean Cluster Creation Usage Example - using all available parameters with sample values
|
|
990
|
-
|
|
1039
|
+
Create a OceanNp resource with the given unique name, props, and options.
|
|
991
1040
|
:param str resource_name: The name of the resource.
|
|
992
1041
|
:param pulumi.ResourceOptions opts: Options for the resource.
|
|
993
|
-
:param pulumi.Input[
|
|
994
|
-
: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.
|
|
995
|
-
:param pulumi.Input[str] controller_cluster_id: Enter a unique Ocean cluster identifier. Cannot be updated. This needs to match with string that was used to install the controller in the cluster, typically clusterName + 8 digit string.
|
|
996
|
-
:param pulumi.Input[bool] enable_node_public_ip: Enable node public IP.
|
|
997
|
-
:param pulumi.Input[bool] fallback_to_ondemand: If no spot VM markets are available, enable Ocean to launch regular (pay-as-you-go) nodes instead.
|
|
998
|
-
:param pulumi.Input[
|
|
999
|
-
:param pulumi.Input[Sequence[pulumi.Input[
|
|
1000
|
-
:param pulumi.Input[
|
|
1001
|
-
: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.
|
|
1002
|
-
:param pulumi.Input[Mapping[str,
|
|
1003
|
-
:param pulumi.Input[Sequence[pulumi.Input[
|
|
1004
|
-
:param pulumi.Input[
|
|
1005
|
-
:param pulumi.Input[int]
|
|
1006
|
-
:param pulumi.Input[int]
|
|
1007
|
-
:param pulumi.Input[
|
|
1008
|
-
:param pulumi.Input[
|
|
1009
|
-
:param pulumi.Input[
|
|
1010
|
-
:param pulumi.Input[str]
|
|
1011
|
-
:param pulumi.Input[str]
|
|
1012
|
-
:param pulumi.Input[
|
|
1013
|
-
:param pulumi.Input[
|
|
1014
|
-
:param pulumi.Input[
|
|
1015
|
-
:param pulumi.Input[Sequence[pulumi.Input[
|
|
1042
|
+
:param pulumi.Input[Union['OceanNpAutoscalerArgs', 'OceanNpAutoscalerArgsDict']] autoscaler: The Ocean Kubernetes Autoscaler object.
|
|
1043
|
+
: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.
|
|
1044
|
+
:param pulumi.Input[_builtins.str] controller_cluster_id: Enter a unique Ocean cluster identifier. Cannot be updated. This needs to match with string that was used to install the controller in the cluster, typically clusterName + 8 digit string.
|
|
1045
|
+
:param pulumi.Input[_builtins.bool] enable_node_public_ip: Enable node public IP.
|
|
1046
|
+
:param pulumi.Input[_builtins.bool] fallback_to_ondemand: If no spot VM markets are available, enable Ocean to launch regular (pay-as-you-go) nodes instead.
|
|
1047
|
+
:param pulumi.Input[Union['OceanNpFiltersArgs', 'OceanNpFiltersArgsDict']] filters: Filters for the VM sizes that can be launched from the virtual node group.
|
|
1048
|
+
:param pulumi.Input[Sequence[pulumi.Input[Union['OceanNpHeadroomArgs', 'OceanNpHeadroomArgsDict']]]] headrooms: Specify the custom headroom per VNG. Provide a list of headroom objects.
|
|
1049
|
+
:param pulumi.Input[Union['OceanNpHealthArgs', 'OceanNpHealthArgsDict']] health: The Ocean AKS Health object.
|
|
1050
|
+
: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.
|
|
1051
|
+
: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 well-known labels](https://kubernetes.io/docs/reference/labels-annotations-taints/) or [ Azure AKS labels](https://learn.microsoft.com/en-us/azure/aks/use-labels) or [Spot labels](https://docs.spot.io/ocean/features/labels-and-taints?id=spot-labels).
|
|
1052
|
+
:param pulumi.Input[Sequence[pulumi.Input[Union['OceanNpLinuxOsConfigArgs', 'OceanNpLinuxOsConfigArgsDict']]]] linux_os_configs: Custom Linux OS configuration.
|
|
1053
|
+
:param pulumi.Input[Union['OceanNpLoggingArgs', 'OceanNpLoggingArgsDict']] logging: The Ocean AKS Logging Object.
|
|
1054
|
+
:param pulumi.Input[_builtins.int] max_count: Maximum node count limit.
|
|
1055
|
+
:param pulumi.Input[_builtins.int] max_pods_per_node: The maximum number of pods per node in the node pools.
|
|
1056
|
+
:param pulumi.Input[_builtins.int] min_count: Minimum node count limit.
|
|
1057
|
+
:param pulumi.Input[_builtins.str] name: Add a name for the Ocean cluster.
|
|
1058
|
+
:param pulumi.Input[_builtins.int] os_disk_size_gb: The size of the OS disk in GB.
|
|
1059
|
+
:param pulumi.Input[_builtins.str] os_disk_type: The type of the OS disk.
|
|
1060
|
+
:param pulumi.Input[_builtins.str] os_sku: The OS SKU of the OS type. Must correlate with the os type.
|
|
1061
|
+
:param pulumi.Input[_builtins.str] os_type: The OS type of the OS disk. Can't be modified once set.
|
|
1062
|
+
: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).
|
|
1063
|
+
:param pulumi.Input[_builtins.int] spot_percentage: Percentage of spot VMs to maintain.
|
|
1064
|
+
:param pulumi.Input[Sequence[pulumi.Input[Union['OceanNpTaintArgs', 'OceanNpTaintArgsDict']]]] taints: Add taints to a virtual node group. Only custom user taints are allowed, and not [Kubernetes well-known taints](https://kubernetes.io/docs/reference/labels-annotations-taints/) or Azure AKS [ScaleSetPrioirty (Spot VM) taint](https://learn.microsoft.com/en-us/azure/aks/spot-node-pool). For all Spot VMs, AKS injects a taint kubernetes.azure.com/scalesetpriority=spot:NoSchedule, to ensure that only workloads that can handle interruptions are scheduled on Spot nodes. To [schedule a pod to run on Spot node](https://learn.microsoft.com/en-us/azure/aks/spot-node-pool#schedule-a-pod-to-run-on-the-spot-node), add a toleration but dont include the nodeAffinity (not supported for Spot Ocean), this will prevent the pod from being scheduled using Spot Ocean.
|
|
1065
|
+
: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).
|
|
1066
|
+
:param pulumi.Input[Union['OceanNpVngTemplateSchedulingArgs', 'OceanNpVngTemplateSchedulingArgsDict']] vng_template_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.
|
|
1016
1067
|
"""
|
|
1017
1068
|
...
|
|
1018
1069
|
@overload
|
|
@@ -1021,30 +1072,7 @@ class OceanNp(pulumi.CustomResource):
|
|
|
1021
1072
|
args: OceanNpArgs,
|
|
1022
1073
|
opts: Optional[pulumi.ResourceOptions] = None):
|
|
1023
1074
|
"""
|
|
1024
|
-
|
|
1025
|
-
|
|
1026
|
-
## Basic Ocean Cluster Creation Usage Example - using minimum configuration with only required parameters
|
|
1027
|
-
|
|
1028
|
-
```python
|
|
1029
|
-
import pulumi
|
|
1030
|
-
import pulumi_spotinst as spotinst
|
|
1031
|
-
|
|
1032
|
-
example = spotinst.azure.OceanNp("example",
|
|
1033
|
-
name="test",
|
|
1034
|
-
aks_region="eastus",
|
|
1035
|
-
aks_cluster_name="test-cluster",
|
|
1036
|
-
aks_infrastructure_resource_group_name="MC_TestResourceGroup_test-cluster_eastus",
|
|
1037
|
-
aks_resource_group_name="TestResourceGroup",
|
|
1038
|
-
controller_cluster_id="test-123124",
|
|
1039
|
-
availability_zones=[
|
|
1040
|
-
"1",
|
|
1041
|
-
"2",
|
|
1042
|
-
"3",
|
|
1043
|
-
])
|
|
1044
|
-
```
|
|
1045
|
-
|
|
1046
|
-
## Detailed Ocean Cluster Creation Usage Example - using all available parameters with sample values
|
|
1047
|
-
|
|
1075
|
+
Create a OceanNp resource with the given unique name, props, and options.
|
|
1048
1076
|
:param str resource_name: The name of the resource.
|
|
1049
1077
|
:param OceanNpArgs args: The arguments to use to populate this resource's properties.
|
|
1050
1078
|
:param pulumi.ResourceOptions opts: Options for the resource.
|
|
@@ -1060,36 +1088,38 @@ class OceanNp(pulumi.CustomResource):
|
|
|
1060
1088
|
def _internal_init(__self__,
|
|
1061
1089
|
resource_name: str,
|
|
1062
1090
|
opts: Optional[pulumi.ResourceOptions] = None,
|
|
1063
|
-
aks_cluster_name: Optional[pulumi.Input[str]] = None,
|
|
1064
|
-
aks_infrastructure_resource_group_name: Optional[pulumi.Input[str]] = None,
|
|
1065
|
-
aks_region: Optional[pulumi.Input[str]] = None,
|
|
1066
|
-
aks_resource_group_name: Optional[pulumi.Input[str]] = None,
|
|
1067
|
-
autoscaler: Optional[pulumi.Input[
|
|
1068
|
-
availability_zones: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
|
|
1069
|
-
controller_cluster_id: Optional[pulumi.Input[str]] = None,
|
|
1070
|
-
enable_node_public_ip: Optional[pulumi.Input[bool]] = None,
|
|
1071
|
-
fallback_to_ondemand: Optional[pulumi.Input[bool]] = None,
|
|
1072
|
-
filters: Optional[pulumi.Input[
|
|
1073
|
-
headrooms: Optional[pulumi.Input[Sequence[pulumi.Input[
|
|
1074
|
-
health: Optional[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
|
-
|
|
1079
|
-
|
|
1080
|
-
|
|
1081
|
-
|
|
1082
|
-
|
|
1083
|
-
|
|
1084
|
-
|
|
1085
|
-
|
|
1086
|
-
|
|
1087
|
-
|
|
1088
|
-
|
|
1089
|
-
|
|
1090
|
-
|
|
1091
|
-
|
|
1092
|
-
|
|
1091
|
+
aks_cluster_name: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1092
|
+
aks_infrastructure_resource_group_name: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1093
|
+
aks_region: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1094
|
+
aks_resource_group_name: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1095
|
+
autoscaler: Optional[pulumi.Input[Union['OceanNpAutoscalerArgs', 'OceanNpAutoscalerArgsDict']]] = None,
|
|
1096
|
+
availability_zones: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
1097
|
+
controller_cluster_id: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1098
|
+
enable_node_public_ip: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
1099
|
+
fallback_to_ondemand: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
1100
|
+
filters: Optional[pulumi.Input[Union['OceanNpFiltersArgs', 'OceanNpFiltersArgsDict']]] = None,
|
|
1101
|
+
headrooms: Optional[pulumi.Input[Sequence[pulumi.Input[Union['OceanNpHeadroomArgs', 'OceanNpHeadroomArgsDict']]]]] = None,
|
|
1102
|
+
health: Optional[pulumi.Input[Union['OceanNpHealthArgs', 'OceanNpHealthArgsDict']]] = None,
|
|
1103
|
+
kubernetes_version: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1104
|
+
labels: Optional[pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]]] = None,
|
|
1105
|
+
linux_os_configs: Optional[pulumi.Input[Sequence[pulumi.Input[Union['OceanNpLinuxOsConfigArgs', 'OceanNpLinuxOsConfigArgsDict']]]]] = None,
|
|
1106
|
+
logging: Optional[pulumi.Input[Union['OceanNpLoggingArgs', 'OceanNpLoggingArgsDict']]] = None,
|
|
1107
|
+
max_count: Optional[pulumi.Input[_builtins.int]] = None,
|
|
1108
|
+
max_pods_per_node: Optional[pulumi.Input[_builtins.int]] = None,
|
|
1109
|
+
min_count: Optional[pulumi.Input[_builtins.int]] = None,
|
|
1110
|
+
name: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1111
|
+
os_disk_size_gb: Optional[pulumi.Input[_builtins.int]] = None,
|
|
1112
|
+
os_disk_type: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1113
|
+
os_sku: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1114
|
+
os_type: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1115
|
+
pod_subnet_ids: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
1116
|
+
scheduling: Optional[pulumi.Input[Union['OceanNpSchedulingArgs', 'OceanNpSchedulingArgsDict']]] = None,
|
|
1117
|
+
spot_percentage: Optional[pulumi.Input[_builtins.int]] = None,
|
|
1118
|
+
tags: Optional[pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]]] = None,
|
|
1119
|
+
taints: Optional[pulumi.Input[Sequence[pulumi.Input[Union['OceanNpTaintArgs', 'OceanNpTaintArgsDict']]]]] = None,
|
|
1120
|
+
update_policy: Optional[pulumi.Input[Union['OceanNpUpdatePolicyArgs', 'OceanNpUpdatePolicyArgsDict']]] = None,
|
|
1121
|
+
vnet_subnet_ids: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
1122
|
+
vng_template_scheduling: Optional[pulumi.Input[Union['OceanNpVngTemplateSchedulingArgs', 'OceanNpVngTemplateSchedulingArgsDict']]] = None,
|
|
1093
1123
|
__props__=None):
|
|
1094
1124
|
opts = pulumi.ResourceOptions.merge(_utilities.get_resource_opts_defaults(), opts)
|
|
1095
1125
|
if not isinstance(opts, pulumi.ResourceOptions):
|
|
@@ -1126,6 +1156,7 @@ class OceanNp(pulumi.CustomResource):
|
|
|
1126
1156
|
__props__.__dict__["kubernetes_version"] = kubernetes_version
|
|
1127
1157
|
__props__.__dict__["labels"] = labels
|
|
1128
1158
|
__props__.__dict__["linux_os_configs"] = linux_os_configs
|
|
1159
|
+
__props__.__dict__["logging"] = logging
|
|
1129
1160
|
__props__.__dict__["max_count"] = max_count
|
|
1130
1161
|
__props__.__dict__["max_pods_per_node"] = max_pods_per_node
|
|
1131
1162
|
__props__.__dict__["min_count"] = min_count
|
|
@@ -1141,6 +1172,7 @@ class OceanNp(pulumi.CustomResource):
|
|
|
1141
1172
|
__props__.__dict__["taints"] = taints
|
|
1142
1173
|
__props__.__dict__["update_policy"] = update_policy
|
|
1143
1174
|
__props__.__dict__["vnet_subnet_ids"] = vnet_subnet_ids
|
|
1175
|
+
__props__.__dict__["vng_template_scheduling"] = vng_template_scheduling
|
|
1144
1176
|
super(OceanNp, __self__).__init__(
|
|
1145
1177
|
'spotinst:azure/oceanNp:OceanNp',
|
|
1146
1178
|
resource_name,
|
|
@@ -1151,36 +1183,38 @@ class OceanNp(pulumi.CustomResource):
|
|
|
1151
1183
|
def get(resource_name: str,
|
|
1152
1184
|
id: pulumi.Input[str],
|
|
1153
1185
|
opts: Optional[pulumi.ResourceOptions] = None,
|
|
1154
|
-
aks_cluster_name: Optional[pulumi.Input[str]] = None,
|
|
1155
|
-
aks_infrastructure_resource_group_name: Optional[pulumi.Input[str]] = None,
|
|
1156
|
-
aks_region: Optional[pulumi.Input[str]] = None,
|
|
1157
|
-
aks_resource_group_name: Optional[pulumi.Input[str]] = None,
|
|
1158
|
-
autoscaler: Optional[pulumi.Input[
|
|
1159
|
-
availability_zones: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
|
|
1160
|
-
controller_cluster_id: Optional[pulumi.Input[str]] = None,
|
|
1161
|
-
enable_node_public_ip: Optional[pulumi.Input[bool]] = None,
|
|
1162
|
-
fallback_to_ondemand: Optional[pulumi.Input[bool]] = None,
|
|
1163
|
-
filters: Optional[pulumi.Input[
|
|
1164
|
-
headrooms: Optional[pulumi.Input[Sequence[pulumi.Input[
|
|
1165
|
-
health: Optional[pulumi.Input[
|
|
1166
|
-
kubernetes_version: Optional[pulumi.Input[str]] = None,
|
|
1167
|
-
labels: Optional[pulumi.Input[Mapping[str,
|
|
1168
|
-
linux_os_configs: Optional[pulumi.Input[Sequence[pulumi.Input[
|
|
1169
|
-
|
|
1170
|
-
|
|
1171
|
-
|
|
1172
|
-
|
|
1173
|
-
|
|
1174
|
-
|
|
1175
|
-
|
|
1176
|
-
|
|
1177
|
-
|
|
1178
|
-
|
|
1179
|
-
|
|
1180
|
-
|
|
1181
|
-
|
|
1182
|
-
|
|
1183
|
-
|
|
1186
|
+
aks_cluster_name: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1187
|
+
aks_infrastructure_resource_group_name: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1188
|
+
aks_region: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1189
|
+
aks_resource_group_name: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1190
|
+
autoscaler: Optional[pulumi.Input[Union['OceanNpAutoscalerArgs', 'OceanNpAutoscalerArgsDict']]] = None,
|
|
1191
|
+
availability_zones: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
1192
|
+
controller_cluster_id: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1193
|
+
enable_node_public_ip: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
1194
|
+
fallback_to_ondemand: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
1195
|
+
filters: Optional[pulumi.Input[Union['OceanNpFiltersArgs', 'OceanNpFiltersArgsDict']]] = None,
|
|
1196
|
+
headrooms: Optional[pulumi.Input[Sequence[pulumi.Input[Union['OceanNpHeadroomArgs', 'OceanNpHeadroomArgsDict']]]]] = None,
|
|
1197
|
+
health: Optional[pulumi.Input[Union['OceanNpHealthArgs', 'OceanNpHealthArgsDict']]] = None,
|
|
1198
|
+
kubernetes_version: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1199
|
+
labels: Optional[pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]]] = None,
|
|
1200
|
+
linux_os_configs: Optional[pulumi.Input[Sequence[pulumi.Input[Union['OceanNpLinuxOsConfigArgs', 'OceanNpLinuxOsConfigArgsDict']]]]] = None,
|
|
1201
|
+
logging: Optional[pulumi.Input[Union['OceanNpLoggingArgs', 'OceanNpLoggingArgsDict']]] = None,
|
|
1202
|
+
max_count: Optional[pulumi.Input[_builtins.int]] = None,
|
|
1203
|
+
max_pods_per_node: Optional[pulumi.Input[_builtins.int]] = None,
|
|
1204
|
+
min_count: Optional[pulumi.Input[_builtins.int]] = None,
|
|
1205
|
+
name: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1206
|
+
os_disk_size_gb: Optional[pulumi.Input[_builtins.int]] = None,
|
|
1207
|
+
os_disk_type: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1208
|
+
os_sku: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1209
|
+
os_type: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1210
|
+
pod_subnet_ids: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
1211
|
+
scheduling: Optional[pulumi.Input[Union['OceanNpSchedulingArgs', 'OceanNpSchedulingArgsDict']]] = None,
|
|
1212
|
+
spot_percentage: Optional[pulumi.Input[_builtins.int]] = None,
|
|
1213
|
+
tags: Optional[pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]]] = None,
|
|
1214
|
+
taints: Optional[pulumi.Input[Sequence[pulumi.Input[Union['OceanNpTaintArgs', 'OceanNpTaintArgsDict']]]]] = None,
|
|
1215
|
+
update_policy: Optional[pulumi.Input[Union['OceanNpUpdatePolicyArgs', 'OceanNpUpdatePolicyArgsDict']]] = None,
|
|
1216
|
+
vnet_subnet_ids: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
1217
|
+
vng_template_scheduling: Optional[pulumi.Input[Union['OceanNpVngTemplateSchedulingArgs', 'OceanNpVngTemplateSchedulingArgsDict']]] = None) -> 'OceanNp':
|
|
1184
1218
|
"""
|
|
1185
1219
|
Get an existing OceanNp resource's state with the given name, id, and optional extra
|
|
1186
1220
|
properties used to qualify the lookup.
|
|
@@ -1188,29 +1222,31 @@ class OceanNp(pulumi.CustomResource):
|
|
|
1188
1222
|
:param str resource_name: The unique name of the resulting resource.
|
|
1189
1223
|
:param pulumi.Input[str] id: The unique provider ID of the resource to lookup.
|
|
1190
1224
|
:param pulumi.ResourceOptions opts: Options for the resource.
|
|
1191
|
-
:param pulumi.Input[
|
|
1192
|
-
: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.
|
|
1193
|
-
:param pulumi.Input[str] controller_cluster_id: Enter a unique Ocean cluster identifier. Cannot be updated. This needs to match with string that was used to install the controller in the cluster, typically clusterName + 8 digit string.
|
|
1194
|
-
:param pulumi.Input[bool] enable_node_public_ip: Enable node public IP.
|
|
1195
|
-
:param pulumi.Input[bool] fallback_to_ondemand: If no spot VM markets are available, enable Ocean to launch regular (pay-as-you-go) nodes instead.
|
|
1196
|
-
:param pulumi.Input[
|
|
1197
|
-
:param pulumi.Input[Sequence[pulumi.Input[
|
|
1198
|
-
:param pulumi.Input[
|
|
1199
|
-
: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.
|
|
1200
|
-
:param pulumi.Input[Mapping[str,
|
|
1201
|
-
:param pulumi.Input[Sequence[pulumi.Input[
|
|
1202
|
-
:param pulumi.Input[
|
|
1203
|
-
:param pulumi.Input[int]
|
|
1204
|
-
:param pulumi.Input[int]
|
|
1205
|
-
:param pulumi.Input[
|
|
1206
|
-
:param pulumi.Input[
|
|
1207
|
-
:param pulumi.Input[
|
|
1208
|
-
:param pulumi.Input[str]
|
|
1209
|
-
:param pulumi.Input[str]
|
|
1210
|
-
:param pulumi.Input[
|
|
1211
|
-
:param pulumi.Input[
|
|
1212
|
-
:param pulumi.Input[
|
|
1213
|
-
:param pulumi.Input[Sequence[pulumi.Input[
|
|
1225
|
+
:param pulumi.Input[Union['OceanNpAutoscalerArgs', 'OceanNpAutoscalerArgsDict']] autoscaler: The Ocean Kubernetes Autoscaler object.
|
|
1226
|
+
: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.
|
|
1227
|
+
:param pulumi.Input[_builtins.str] controller_cluster_id: Enter a unique Ocean cluster identifier. Cannot be updated. This needs to match with string that was used to install the controller in the cluster, typically clusterName + 8 digit string.
|
|
1228
|
+
:param pulumi.Input[_builtins.bool] enable_node_public_ip: Enable node public IP.
|
|
1229
|
+
:param pulumi.Input[_builtins.bool] fallback_to_ondemand: If no spot VM markets are available, enable Ocean to launch regular (pay-as-you-go) nodes instead.
|
|
1230
|
+
:param pulumi.Input[Union['OceanNpFiltersArgs', 'OceanNpFiltersArgsDict']] filters: Filters for the VM sizes that can be launched from the virtual node group.
|
|
1231
|
+
:param pulumi.Input[Sequence[pulumi.Input[Union['OceanNpHeadroomArgs', 'OceanNpHeadroomArgsDict']]]] headrooms: Specify the custom headroom per VNG. Provide a list of headroom objects.
|
|
1232
|
+
:param pulumi.Input[Union['OceanNpHealthArgs', 'OceanNpHealthArgsDict']] health: The Ocean AKS Health object.
|
|
1233
|
+
: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.
|
|
1234
|
+
: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 well-known labels](https://kubernetes.io/docs/reference/labels-annotations-taints/) or [ Azure AKS labels](https://learn.microsoft.com/en-us/azure/aks/use-labels) or [Spot labels](https://docs.spot.io/ocean/features/labels-and-taints?id=spot-labels).
|
|
1235
|
+
:param pulumi.Input[Sequence[pulumi.Input[Union['OceanNpLinuxOsConfigArgs', 'OceanNpLinuxOsConfigArgsDict']]]] linux_os_configs: Custom Linux OS configuration.
|
|
1236
|
+
:param pulumi.Input[Union['OceanNpLoggingArgs', 'OceanNpLoggingArgsDict']] logging: The Ocean AKS Logging Object.
|
|
1237
|
+
:param pulumi.Input[_builtins.int] max_count: Maximum node count limit.
|
|
1238
|
+
:param pulumi.Input[_builtins.int] max_pods_per_node: The maximum number of pods per node in the node pools.
|
|
1239
|
+
:param pulumi.Input[_builtins.int] min_count: Minimum node count limit.
|
|
1240
|
+
:param pulumi.Input[_builtins.str] name: Add a name for the Ocean cluster.
|
|
1241
|
+
:param pulumi.Input[_builtins.int] os_disk_size_gb: The size of the OS disk in GB.
|
|
1242
|
+
:param pulumi.Input[_builtins.str] os_disk_type: The type of the OS disk.
|
|
1243
|
+
:param pulumi.Input[_builtins.str] os_sku: The OS SKU of the OS type. Must correlate with the os type.
|
|
1244
|
+
:param pulumi.Input[_builtins.str] os_type: The OS type of the OS disk. Can't be modified once set.
|
|
1245
|
+
: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).
|
|
1246
|
+
:param pulumi.Input[_builtins.int] spot_percentage: Percentage of spot VMs to maintain.
|
|
1247
|
+
:param pulumi.Input[Sequence[pulumi.Input[Union['OceanNpTaintArgs', 'OceanNpTaintArgsDict']]]] taints: Add taints to a virtual node group. Only custom user taints are allowed, and not [Kubernetes well-known taints](https://kubernetes.io/docs/reference/labels-annotations-taints/) or Azure AKS [ScaleSetPrioirty (Spot VM) taint](https://learn.microsoft.com/en-us/azure/aks/spot-node-pool). For all Spot VMs, AKS injects a taint kubernetes.azure.com/scalesetpriority=spot:NoSchedule, to ensure that only workloads that can handle interruptions are scheduled on Spot nodes. To [schedule a pod to run on Spot node](https://learn.microsoft.com/en-us/azure/aks/spot-node-pool#schedule-a-pod-to-run-on-the-spot-node), add a toleration but dont include the nodeAffinity (not supported for Spot Ocean), this will prevent the pod from being scheduled using Spot Ocean.
|
|
1248
|
+
: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).
|
|
1249
|
+
:param pulumi.Input[Union['OceanNpVngTemplateSchedulingArgs', 'OceanNpVngTemplateSchedulingArgsDict']] vng_template_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.
|
|
1214
1250
|
"""
|
|
1215
1251
|
opts = pulumi.ResourceOptions.merge(opts, pulumi.ResourceOptions(id=id))
|
|
1216
1252
|
|
|
@@ -1231,6 +1267,7 @@ class OceanNp(pulumi.CustomResource):
|
|
|
1231
1267
|
__props__.__dict__["kubernetes_version"] = kubernetes_version
|
|
1232
1268
|
__props__.__dict__["labels"] = labels
|
|
1233
1269
|
__props__.__dict__["linux_os_configs"] = linux_os_configs
|
|
1270
|
+
__props__.__dict__["logging"] = logging
|
|
1234
1271
|
__props__.__dict__["max_count"] = max_count
|
|
1235
1272
|
__props__.__dict__["max_pods_per_node"] = max_pods_per_node
|
|
1236
1273
|
__props__.__dict__["min_count"] = min_count
|
|
@@ -1246,29 +1283,30 @@ class OceanNp(pulumi.CustomResource):
|
|
|
1246
1283
|
__props__.__dict__["taints"] = taints
|
|
1247
1284
|
__props__.__dict__["update_policy"] = update_policy
|
|
1248
1285
|
__props__.__dict__["vnet_subnet_ids"] = vnet_subnet_ids
|
|
1286
|
+
__props__.__dict__["vng_template_scheduling"] = vng_template_scheduling
|
|
1249
1287
|
return OceanNp(resource_name, opts=opts, __props__=__props__)
|
|
1250
1288
|
|
|
1251
|
-
@property
|
|
1289
|
+
@_builtins.property
|
|
1252
1290
|
@pulumi.getter(name="aksClusterName")
|
|
1253
|
-
def aks_cluster_name(self) -> pulumi.Output[str]:
|
|
1291
|
+
def aks_cluster_name(self) -> pulumi.Output[_builtins.str]:
|
|
1254
1292
|
return pulumi.get(self, "aks_cluster_name")
|
|
1255
1293
|
|
|
1256
|
-
@property
|
|
1294
|
+
@_builtins.property
|
|
1257
1295
|
@pulumi.getter(name="aksInfrastructureResourceGroupName")
|
|
1258
|
-
def aks_infrastructure_resource_group_name(self) -> pulumi.Output[str]:
|
|
1296
|
+
def aks_infrastructure_resource_group_name(self) -> pulumi.Output[_builtins.str]:
|
|
1259
1297
|
return pulumi.get(self, "aks_infrastructure_resource_group_name")
|
|
1260
1298
|
|
|
1261
|
-
@property
|
|
1299
|
+
@_builtins.property
|
|
1262
1300
|
@pulumi.getter(name="aksRegion")
|
|
1263
|
-
def aks_region(self) -> pulumi.Output[str]:
|
|
1301
|
+
def aks_region(self) -> pulumi.Output[_builtins.str]:
|
|
1264
1302
|
return pulumi.get(self, "aks_region")
|
|
1265
1303
|
|
|
1266
|
-
@property
|
|
1304
|
+
@_builtins.property
|
|
1267
1305
|
@pulumi.getter(name="aksResourceGroupName")
|
|
1268
|
-
def aks_resource_group_name(self) -> pulumi.Output[str]:
|
|
1306
|
+
def aks_resource_group_name(self) -> pulumi.Output[_builtins.str]:
|
|
1269
1307
|
return pulumi.get(self, "aks_resource_group_name")
|
|
1270
1308
|
|
|
1271
|
-
@property
|
|
1309
|
+
@_builtins.property
|
|
1272
1310
|
@pulumi.getter
|
|
1273
1311
|
def autoscaler(self) -> pulumi.Output[Optional['outputs.OceanNpAutoscaler']]:
|
|
1274
1312
|
"""
|
|
@@ -1276,39 +1314,39 @@ class OceanNp(pulumi.CustomResource):
|
|
|
1276
1314
|
"""
|
|
1277
1315
|
return pulumi.get(self, "autoscaler")
|
|
1278
1316
|
|
|
1279
|
-
@property
|
|
1317
|
+
@_builtins.property
|
|
1280
1318
|
@pulumi.getter(name="availabilityZones")
|
|
1281
|
-
def availability_zones(self) -> pulumi.Output[Sequence[str]]:
|
|
1319
|
+
def availability_zones(self) -> pulumi.Output[Sequence[_builtins.str]]:
|
|
1282
1320
|
"""
|
|
1283
1321
|
An Array holding Availability Zones, this configures the availability zones the Ocean may launch instances in per VNG.
|
|
1284
1322
|
"""
|
|
1285
1323
|
return pulumi.get(self, "availability_zones")
|
|
1286
1324
|
|
|
1287
|
-
@property
|
|
1325
|
+
@_builtins.property
|
|
1288
1326
|
@pulumi.getter(name="controllerClusterId")
|
|
1289
|
-
def controller_cluster_id(self) -> pulumi.Output[str]:
|
|
1327
|
+
def controller_cluster_id(self) -> pulumi.Output[_builtins.str]:
|
|
1290
1328
|
"""
|
|
1291
1329
|
Enter a unique Ocean cluster identifier. Cannot be updated. This needs to match with string that was used to install the controller in the cluster, typically clusterName + 8 digit string.
|
|
1292
1330
|
"""
|
|
1293
1331
|
return pulumi.get(self, "controller_cluster_id")
|
|
1294
1332
|
|
|
1295
|
-
@property
|
|
1333
|
+
@_builtins.property
|
|
1296
1334
|
@pulumi.getter(name="enableNodePublicIp")
|
|
1297
|
-
def enable_node_public_ip(self) -> pulumi.Output[Optional[bool]]:
|
|
1335
|
+
def enable_node_public_ip(self) -> pulumi.Output[Optional[_builtins.bool]]:
|
|
1298
1336
|
"""
|
|
1299
1337
|
Enable node public IP.
|
|
1300
1338
|
"""
|
|
1301
1339
|
return pulumi.get(self, "enable_node_public_ip")
|
|
1302
1340
|
|
|
1303
|
-
@property
|
|
1341
|
+
@_builtins.property
|
|
1304
1342
|
@pulumi.getter(name="fallbackToOndemand")
|
|
1305
|
-
def fallback_to_ondemand(self) -> pulumi.Output[Optional[bool]]:
|
|
1343
|
+
def fallback_to_ondemand(self) -> pulumi.Output[Optional[_builtins.bool]]:
|
|
1306
1344
|
"""
|
|
1307
1345
|
If no spot VM markets are available, enable Ocean to launch regular (pay-as-you-go) nodes instead.
|
|
1308
1346
|
"""
|
|
1309
1347
|
return pulumi.get(self, "fallback_to_ondemand")
|
|
1310
1348
|
|
|
1311
|
-
@property
|
|
1349
|
+
@_builtins.property
|
|
1312
1350
|
@pulumi.getter
|
|
1313
1351
|
def filters(self) -> pulumi.Output[Optional['outputs.OceanNpFilters']]:
|
|
1314
1352
|
"""
|
|
@@ -1316,7 +1354,7 @@ class OceanNp(pulumi.CustomResource):
|
|
|
1316
1354
|
"""
|
|
1317
1355
|
return pulumi.get(self, "filters")
|
|
1318
1356
|
|
|
1319
|
-
@property
|
|
1357
|
+
@_builtins.property
|
|
1320
1358
|
@pulumi.getter
|
|
1321
1359
|
def headrooms(self) -> pulumi.Output[Optional[Sequence['outputs.OceanNpHeadroom']]]:
|
|
1322
1360
|
"""
|
|
@@ -1324,7 +1362,7 @@ class OceanNp(pulumi.CustomResource):
|
|
|
1324
1362
|
"""
|
|
1325
1363
|
return pulumi.get(self, "headrooms")
|
|
1326
1364
|
|
|
1327
|
-
@property
|
|
1365
|
+
@_builtins.property
|
|
1328
1366
|
@pulumi.getter
|
|
1329
1367
|
def health(self) -> pulumi.Output[Optional['outputs.OceanNpHealth']]:
|
|
1330
1368
|
"""
|
|
@@ -1332,23 +1370,23 @@ class OceanNp(pulumi.CustomResource):
|
|
|
1332
1370
|
"""
|
|
1333
1371
|
return pulumi.get(self, "health")
|
|
1334
1372
|
|
|
1335
|
-
@property
|
|
1373
|
+
@_builtins.property
|
|
1336
1374
|
@pulumi.getter(name="kubernetesVersion")
|
|
1337
|
-
def kubernetes_version(self) -> pulumi.Output[Optional[str]]:
|
|
1375
|
+
def kubernetes_version(self) -> pulumi.Output[Optional[_builtins.str]]:
|
|
1338
1376
|
"""
|
|
1339
1377
|
The desired Kubernetes version of the launched nodes. In case the value is null, the Kubernetes version of the control plane is used.
|
|
1340
1378
|
"""
|
|
1341
1379
|
return pulumi.get(self, "kubernetes_version")
|
|
1342
1380
|
|
|
1343
|
-
@property
|
|
1381
|
+
@_builtins.property
|
|
1344
1382
|
@pulumi.getter
|
|
1345
|
-
def labels(self) -> pulumi.Output[Optional[Mapping[str,
|
|
1383
|
+
def labels(self) -> pulumi.Output[Optional[Mapping[str, _builtins.str]]]:
|
|
1346
1384
|
"""
|
|
1347
1385
|
An array of labels to add to the virtual node group. Only custom user labels are allowed, and not [Kubernetes well-known labels](https://kubernetes.io/docs/reference/labels-annotations-taints/) or [ Azure AKS labels](https://learn.microsoft.com/en-us/azure/aks/use-labels) or [Spot labels](https://docs.spot.io/ocean/features/labels-and-taints?id=spot-labels).
|
|
1348
1386
|
"""
|
|
1349
1387
|
return pulumi.get(self, "labels")
|
|
1350
1388
|
|
|
1351
|
-
@property
|
|
1389
|
+
@_builtins.property
|
|
1352
1390
|
@pulumi.getter(name="linuxOsConfigs")
|
|
1353
1391
|
def linux_os_configs(self) -> pulumi.Output[Optional[Sequence['outputs.OceanNpLinuxOsConfig']]]:
|
|
1354
1392
|
"""
|
|
@@ -1356,97 +1394,105 @@ class OceanNp(pulumi.CustomResource):
|
|
|
1356
1394
|
"""
|
|
1357
1395
|
return pulumi.get(self, "linux_os_configs")
|
|
1358
1396
|
|
|
1359
|
-
@property
|
|
1397
|
+
@_builtins.property
|
|
1398
|
+
@pulumi.getter
|
|
1399
|
+
def logging(self) -> pulumi.Output[Optional['outputs.OceanNpLogging']]:
|
|
1400
|
+
"""
|
|
1401
|
+
The Ocean AKS Logging Object.
|
|
1402
|
+
"""
|
|
1403
|
+
return pulumi.get(self, "logging")
|
|
1404
|
+
|
|
1405
|
+
@_builtins.property
|
|
1360
1406
|
@pulumi.getter(name="maxCount")
|
|
1361
|
-
def max_count(self) -> pulumi.Output[Optional[int]]:
|
|
1407
|
+
def max_count(self) -> pulumi.Output[Optional[_builtins.int]]:
|
|
1362
1408
|
"""
|
|
1363
1409
|
Maximum node count limit.
|
|
1364
1410
|
"""
|
|
1365
1411
|
return pulumi.get(self, "max_count")
|
|
1366
1412
|
|
|
1367
|
-
@property
|
|
1413
|
+
@_builtins.property
|
|
1368
1414
|
@pulumi.getter(name="maxPodsPerNode")
|
|
1369
|
-
def max_pods_per_node(self) -> pulumi.Output[Optional[int]]:
|
|
1415
|
+
def max_pods_per_node(self) -> pulumi.Output[Optional[_builtins.int]]:
|
|
1370
1416
|
"""
|
|
1371
1417
|
The maximum number of pods per node in the node pools.
|
|
1372
1418
|
"""
|
|
1373
1419
|
return pulumi.get(self, "max_pods_per_node")
|
|
1374
1420
|
|
|
1375
|
-
@property
|
|
1421
|
+
@_builtins.property
|
|
1376
1422
|
@pulumi.getter(name="minCount")
|
|
1377
|
-
def min_count(self) -> pulumi.Output[Optional[int]]:
|
|
1423
|
+
def min_count(self) -> pulumi.Output[Optional[_builtins.int]]:
|
|
1378
1424
|
"""
|
|
1379
1425
|
Minimum node count limit.
|
|
1380
1426
|
"""
|
|
1381
1427
|
return pulumi.get(self, "min_count")
|
|
1382
1428
|
|
|
1383
|
-
@property
|
|
1429
|
+
@_builtins.property
|
|
1384
1430
|
@pulumi.getter
|
|
1385
|
-
def name(self) -> pulumi.Output[str]:
|
|
1431
|
+
def name(self) -> pulumi.Output[_builtins.str]:
|
|
1386
1432
|
"""
|
|
1387
1433
|
Add a name for the Ocean cluster.
|
|
1388
1434
|
"""
|
|
1389
1435
|
return pulumi.get(self, "name")
|
|
1390
1436
|
|
|
1391
|
-
@property
|
|
1437
|
+
@_builtins.property
|
|
1392
1438
|
@pulumi.getter(name="osDiskSizeGb")
|
|
1393
|
-
def os_disk_size_gb(self) -> pulumi.Output[Optional[int]]:
|
|
1439
|
+
def os_disk_size_gb(self) -> pulumi.Output[Optional[_builtins.int]]:
|
|
1394
1440
|
"""
|
|
1395
1441
|
The size of the OS disk in GB.
|
|
1396
1442
|
"""
|
|
1397
1443
|
return pulumi.get(self, "os_disk_size_gb")
|
|
1398
1444
|
|
|
1399
|
-
@property
|
|
1445
|
+
@_builtins.property
|
|
1400
1446
|
@pulumi.getter(name="osDiskType")
|
|
1401
|
-
def os_disk_type(self) -> pulumi.Output[Optional[str]]:
|
|
1447
|
+
def os_disk_type(self) -> pulumi.Output[Optional[_builtins.str]]:
|
|
1402
1448
|
"""
|
|
1403
1449
|
The type of the OS disk.
|
|
1404
1450
|
"""
|
|
1405
1451
|
return pulumi.get(self, "os_disk_type")
|
|
1406
1452
|
|
|
1407
|
-
@property
|
|
1453
|
+
@_builtins.property
|
|
1408
1454
|
@pulumi.getter(name="osSku")
|
|
1409
|
-
def os_sku(self) -> pulumi.Output[Optional[str]]:
|
|
1455
|
+
def os_sku(self) -> pulumi.Output[Optional[_builtins.str]]:
|
|
1410
1456
|
"""
|
|
1411
1457
|
The OS SKU of the OS type. Must correlate with the os type.
|
|
1412
1458
|
"""
|
|
1413
1459
|
return pulumi.get(self, "os_sku")
|
|
1414
1460
|
|
|
1415
|
-
@property
|
|
1461
|
+
@_builtins.property
|
|
1416
1462
|
@pulumi.getter(name="osType")
|
|
1417
|
-
def os_type(self) -> pulumi.Output[Optional[str]]:
|
|
1463
|
+
def os_type(self) -> pulumi.Output[Optional[_builtins.str]]:
|
|
1418
1464
|
"""
|
|
1419
1465
|
The OS type of the OS disk. Can't be modified once set.
|
|
1420
1466
|
"""
|
|
1421
1467
|
return pulumi.get(self, "os_type")
|
|
1422
1468
|
|
|
1423
|
-
@property
|
|
1469
|
+
@_builtins.property
|
|
1424
1470
|
@pulumi.getter(name="podSubnetIds")
|
|
1425
|
-
def pod_subnet_ids(self) -> pulumi.Output[Optional[Sequence[str]]]:
|
|
1471
|
+
def pod_subnet_ids(self) -> pulumi.Output[Optional[Sequence[_builtins.str]]]:
|
|
1426
1472
|
"""
|
|
1427
1473
|
The IDs of subnets in an existing VNet into which to assign pods in the cluster (requires azure network-plugin).
|
|
1428
1474
|
"""
|
|
1429
1475
|
return pulumi.get(self, "pod_subnet_ids")
|
|
1430
1476
|
|
|
1431
|
-
@property
|
|
1477
|
+
@_builtins.property
|
|
1432
1478
|
@pulumi.getter
|
|
1433
1479
|
def scheduling(self) -> pulumi.Output[Optional['outputs.OceanNpScheduling']]:
|
|
1434
1480
|
return pulumi.get(self, "scheduling")
|
|
1435
1481
|
|
|
1436
|
-
@property
|
|
1482
|
+
@_builtins.property
|
|
1437
1483
|
@pulumi.getter(name="spotPercentage")
|
|
1438
|
-
def spot_percentage(self) -> pulumi.Output[Optional[int]]:
|
|
1484
|
+
def spot_percentage(self) -> pulumi.Output[Optional[_builtins.int]]:
|
|
1439
1485
|
"""
|
|
1440
1486
|
Percentage of spot VMs to maintain.
|
|
1441
1487
|
"""
|
|
1442
1488
|
return pulumi.get(self, "spot_percentage")
|
|
1443
1489
|
|
|
1444
|
-
@property
|
|
1490
|
+
@_builtins.property
|
|
1445
1491
|
@pulumi.getter
|
|
1446
|
-
def tags(self) -> pulumi.Output[Optional[Mapping[str,
|
|
1492
|
+
def tags(self) -> pulumi.Output[Optional[Mapping[str, _builtins.str]]]:
|
|
1447
1493
|
return pulumi.get(self, "tags")
|
|
1448
1494
|
|
|
1449
|
-
@property
|
|
1495
|
+
@_builtins.property
|
|
1450
1496
|
@pulumi.getter
|
|
1451
1497
|
def taints(self) -> pulumi.Output[Optional[Sequence['outputs.OceanNpTaint']]]:
|
|
1452
1498
|
"""
|
|
@@ -1454,16 +1500,24 @@ class OceanNp(pulumi.CustomResource):
|
|
|
1454
1500
|
"""
|
|
1455
1501
|
return pulumi.get(self, "taints")
|
|
1456
1502
|
|
|
1457
|
-
@property
|
|
1503
|
+
@_builtins.property
|
|
1458
1504
|
@pulumi.getter(name="updatePolicy")
|
|
1459
1505
|
def update_policy(self) -> pulumi.Output[Optional['outputs.OceanNpUpdatePolicy']]:
|
|
1460
1506
|
return pulumi.get(self, "update_policy")
|
|
1461
1507
|
|
|
1462
|
-
@property
|
|
1508
|
+
@_builtins.property
|
|
1463
1509
|
@pulumi.getter(name="vnetSubnetIds")
|
|
1464
|
-
def vnet_subnet_ids(self) -> pulumi.Output[Optional[Sequence[str]]]:
|
|
1510
|
+
def vnet_subnet_ids(self) -> pulumi.Output[Optional[Sequence[_builtins.str]]]:
|
|
1465
1511
|
"""
|
|
1466
1512
|
The IDs of subnets in an existing VNet into which to assign nodes in the cluster (requires azure network-plugin).
|
|
1467
1513
|
"""
|
|
1468
1514
|
return pulumi.get(self, "vnet_subnet_ids")
|
|
1469
1515
|
|
|
1516
|
+
@_builtins.property
|
|
1517
|
+
@pulumi.getter(name="vngTemplateScheduling")
|
|
1518
|
+
def vng_template_scheduling(self) -> pulumi.Output[Optional['outputs.OceanNpVngTemplateScheduling']]:
|
|
1519
|
+
"""
|
|
1520
|
+
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.
|
|
1521
|
+
"""
|
|
1522
|
+
return pulumi.get(self, "vng_template_scheduling")
|
|
1523
|
+
|