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,68 +21,80 @@ __all__ = ['ElastigroupArgs', 'Elastigroup']
|
|
|
16
21
|
@pulumi.input_type
|
|
17
22
|
class ElastigroupArgs:
|
|
18
23
|
def __init__(__self__, *,
|
|
19
|
-
desired_capacity: pulumi.Input[int],
|
|
20
|
-
auto_healing: Optional[pulumi.Input[bool]] = None,
|
|
21
|
-
availability_zones: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
|
|
24
|
+
desired_capacity: pulumi.Input[_builtins.int],
|
|
25
|
+
auto_healing: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
26
|
+
availability_zones: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
22
27
|
backend_services: Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupBackendServiceArgs']]]] = None,
|
|
23
|
-
description: Optional[pulumi.Input[str]] = None,
|
|
28
|
+
description: Optional[pulumi.Input[_builtins.str]] = None,
|
|
24
29
|
disks: Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupDiskArgs']]]] = None,
|
|
25
|
-
draining_timeout: Optional[pulumi.Input[int]] = None,
|
|
26
|
-
fallback_to_ondemand: Optional[pulumi.Input[bool]] = None,
|
|
30
|
+
draining_timeout: Optional[pulumi.Input[_builtins.int]] = None,
|
|
31
|
+
fallback_to_ondemand: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
27
32
|
gpu: Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupGpuArgs']]]] = None,
|
|
28
|
-
health_check_grace_period: Optional[pulumi.Input[int]] = None,
|
|
29
|
-
health_check_type: Optional[pulumi.Input[str]] = None,
|
|
30
|
-
instance_name_prefix: Optional[pulumi.Input[str]] = None,
|
|
33
|
+
health_check_grace_period: Optional[pulumi.Input[_builtins.int]] = None,
|
|
34
|
+
health_check_type: Optional[pulumi.Input[_builtins.str]] = None,
|
|
35
|
+
instance_name_prefix: Optional[pulumi.Input[_builtins.str]] = None,
|
|
31
36
|
instance_types_customs: Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupInstanceTypesCustomArgs']]]] = None,
|
|
32
|
-
instance_types_ondemand: Optional[pulumi.Input[str]] = None,
|
|
33
|
-
instance_types_preemptibles: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
|
|
37
|
+
instance_types_ondemand: Optional[pulumi.Input[_builtins.str]] = None,
|
|
38
|
+
instance_types_preemptibles: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
34
39
|
integration_docker_swarm: Optional[pulumi.Input['ElastigroupIntegrationDockerSwarmArgs']] = None,
|
|
35
40
|
integration_gke: Optional[pulumi.Input['ElastigroupIntegrationGkeArgs']] = None,
|
|
36
|
-
ip_forwarding: Optional[pulumi.Input[bool]] = None,
|
|
41
|
+
ip_forwarding: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
37
42
|
labels: Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupLabelArgs']]]] = None,
|
|
38
|
-
max_size: Optional[pulumi.Input[int]] = None,
|
|
43
|
+
max_size: Optional[pulumi.Input[_builtins.int]] = None,
|
|
39
44
|
metadatas: Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupMetadataArgs']]]] = None,
|
|
40
|
-
|
|
41
|
-
|
|
45
|
+
min_cpu_platform: Optional[pulumi.Input[_builtins.str]] = None,
|
|
46
|
+
min_size: Optional[pulumi.Input[_builtins.int]] = None,
|
|
47
|
+
name: Optional[pulumi.Input[_builtins.str]] = None,
|
|
42
48
|
network_interfaces: Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupNetworkInterfaceArgs']]]] = None,
|
|
43
|
-
ondemand_count: Optional[pulumi.Input[int]] = None,
|
|
44
|
-
|
|
45
|
-
|
|
49
|
+
ondemand_count: Optional[pulumi.Input[_builtins.int]] = None,
|
|
50
|
+
optimization_windows: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
51
|
+
preemptible_percentage: Optional[pulumi.Input[_builtins.int]] = None,
|
|
52
|
+
preferred_availability_zones: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
53
|
+
provisioning_model: Optional[pulumi.Input[_builtins.str]] = None,
|
|
54
|
+
revert_to_preemptibles: Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupRevertToPreemptibleArgs']]]] = None,
|
|
46
55
|
scaling_down_policies: Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupScalingDownPolicyArgs']]]] = None,
|
|
47
56
|
scaling_up_policies: Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupScalingUpPolicyArgs']]]] = None,
|
|
48
57
|
scheduled_tasks: Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupScheduledTaskArgs']]]] = None,
|
|
49
|
-
service_account: Optional[pulumi.Input[str]] = None,
|
|
50
|
-
|
|
51
|
-
|
|
58
|
+
service_account: Optional[pulumi.Input[_builtins.str]] = None,
|
|
59
|
+
shielded_instance_config: Optional[pulumi.Input['ElastigroupShieldedInstanceConfigArgs']] = None,
|
|
60
|
+
should_utilize_commitments: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
61
|
+
shutdown_script: Optional[pulumi.Input[_builtins.str]] = None,
|
|
62
|
+
startup_script: Optional[pulumi.Input[_builtins.str]] = None,
|
|
52
63
|
subnets: Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupSubnetArgs']]]] = None,
|
|
53
|
-
tags: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
|
|
54
|
-
unhealthy_duration: Optional[pulumi.Input[int]] = None):
|
|
64
|
+
tags: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
65
|
+
unhealthy_duration: Optional[pulumi.Input[_builtins.int]] = None):
|
|
55
66
|
"""
|
|
56
67
|
The set of arguments for constructing a Elastigroup resource.
|
|
57
|
-
:param pulumi.Input[int] desired_capacity: The desired number of instances the group should have at any time.
|
|
58
|
-
:param pulumi.Input[Sequence[pulumi.Input[str]]] availability_zones: List of availability zones for the group.
|
|
59
|
-
:param pulumi.Input[str] description: The region your GCP group will be created in.
|
|
60
|
-
:param pulumi.Input[int] draining_timeout: Time (seconds) the instance is allowed to run after it is detached from the group. This is to allow the instance time to drain all the current TCP connections before terminating it.
|
|
61
|
-
:param pulumi.Input[bool] fallback_to_ondemand: Activate fallback-to-on-demand. When provisioning an instance, if no Preemptible market is available, fallback-to-on-demand will provision an On-Demand instance to maintain the group capacity.
|
|
62
|
-
:param pulumi.Input[str] instance_name_prefix: Set an instance name prefix to be used for all launched instances and their boot disk. The prefix value should comply with the following limitations:
|
|
68
|
+
:param pulumi.Input[_builtins.int] desired_capacity: The desired number of instances the group should have at any time.
|
|
69
|
+
:param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] availability_zones: List of availability zones for the group.
|
|
70
|
+
:param pulumi.Input[_builtins.str] description: The region your GCP group will be created in.
|
|
71
|
+
:param pulumi.Input[_builtins.int] draining_timeout: Time (seconds) the instance is allowed to run after it is detached from the group. This is to allow the instance time to drain all the current TCP connections before terminating it.
|
|
72
|
+
:param pulumi.Input[_builtins.bool] fallback_to_ondemand: Activate fallback-to-on-demand. When provisioning an instance, if no Preemptible market is available, fallback-to-on-demand will provision an On-Demand instance to maintain the group capacity.
|
|
73
|
+
:param pulumi.Input[_builtins.str] instance_name_prefix: Set an instance name prefix to be used for all launched instances and their boot disk. The prefix value should comply with the following limitations:
|
|
63
74
|
* A maximal length of 25 characters.
|
|
64
75
|
* The first character must be a lowercase letter, and all the following characters must be hyphens, lowercase letters, or digits, except the last character, which cannot be a hyphen.
|
|
65
76
|
:param pulumi.Input[Sequence[pulumi.Input['ElastigroupInstanceTypesCustomArgs']]] instance_types_customs: Defines a set of custom instance types. Required if instance_types_preemptible and instance_types_ondemand are not set.
|
|
66
77
|
* `vCPU` - (Optional) The number of vCPUs in the custom instance type. GCP has a number of limitations on accepted vCPU values. For more information, see the GCP documentation (here.)[https://cloud.google.com/compute/docs/instances/creating-instance-with-custom-machine-type#specifications]
|
|
67
|
-
:param pulumi.Input[str] instance_types_ondemand: The regular VM instance type to use for mixed-type groups and when falling back to on-demand. Required if instance_types_preemptible is not set.
|
|
68
|
-
:param pulumi.Input[Sequence[pulumi.Input[str]]] instance_types_preemptibles: The preemptible VMs instance type. To maximize cost savings and market availability, select as many types as possible. Required if instance_types_ondemand is not set.
|
|
78
|
+
:param pulumi.Input[_builtins.str] instance_types_ondemand: The regular VM instance type to use for mixed-type groups and when falling back to on-demand. Required if instance_types_preemptible is not set.
|
|
79
|
+
:param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] instance_types_preemptibles: The preemptible VMs instance type. To maximize cost savings and market availability, select as many types as possible. Required if instance_types_ondemand is not set.
|
|
69
80
|
:param pulumi.Input[Sequence[pulumi.Input['ElastigroupLabelArgs']]] labels: Array of objects with key-value pairs.
|
|
70
|
-
:param pulumi.Input[int] max_size: The maximum number of instances the group should have at any time.
|
|
81
|
+
:param pulumi.Input[_builtins.int] max_size: The maximum number of instances the group should have at any time.
|
|
71
82
|
:param pulumi.Input[Sequence[pulumi.Input['ElastigroupMetadataArgs']]] metadatas: Array of objects with key-value pairs.
|
|
72
|
-
:param pulumi.Input[
|
|
73
|
-
:param pulumi.Input[
|
|
74
|
-
:param pulumi.Input[
|
|
75
|
-
:param pulumi.Input[str]
|
|
76
|
-
:param pulumi.Input[
|
|
77
|
-
:param pulumi.Input[str]
|
|
78
|
-
:param pulumi.Input[str]
|
|
83
|
+
:param pulumi.Input[_builtins.str] min_cpu_platform: Select a minimum CPU platform for the compute instance.
|
|
84
|
+
:param pulumi.Input[_builtins.int] min_size: The minimum number of instances the group should have at any time.
|
|
85
|
+
:param pulumi.Input[_builtins.str] name: The group name.
|
|
86
|
+
:param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] optimization_windows: Set time window to perform the revert to preemptible. Time windows must be at least 120 minutes. Format: DayInWeek:HH-DayInWeek:HH. Required when strategy.revertToPreemptible.performAt is 'timeWindow'.
|
|
87
|
+
:param pulumi.Input[_builtins.int] preemptible_percentage: Percentage of Preemptible VMs to spin up from the "desired_capacity".
|
|
88
|
+
:param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] preferred_availability_zones: prioritize availability zones when launching instances for the group. Must be a sublist of `availability_zones`.
|
|
89
|
+
:param pulumi.Input[_builtins.str] provisioning_model: Valid values: "SPOT", "PREEMPTIBLE". Define the provisioning model of the launched instances. Default value is "PREEMPTIBLE".
|
|
90
|
+
:param pulumi.Input[Sequence[pulumi.Input['ElastigroupRevertToPreemptibleArgs']]] revert_to_preemptibles: Setting for revert to preemptible option.
|
|
91
|
+
:param pulumi.Input[_builtins.str] service_account: The email of the service account in which the group instances will be launched.
|
|
92
|
+
:param pulumi.Input['ElastigroupShieldedInstanceConfigArgs'] shielded_instance_config: You can use secure boot when you launch VMs using Elastigroup. This helps you comply with your security policies. In the instance configuration, use ‘secureBootEnabled’ set to True to enforce UEFI with secure boot. Elastigroup provisions VMs with secure boot, as long as the images supports UEFI.
|
|
93
|
+
:param pulumi.Input[_builtins.bool] should_utilize_commitments: Enable committed use discounts utilization.
|
|
94
|
+
:param pulumi.Input[_builtins.str] shutdown_script: The Base64-encoded shutdown script that executes prior to instance termination, for more information please see: [Shutdown Script](https://api.spotinst.com/integration-docs/elastigroup/concepts/compute-concepts/shutdown-scripts/)
|
|
95
|
+
:param pulumi.Input[_builtins.str] startup_script: Create and run your own startup scripts on your virtual machines to perform automated tasks every time your instance boots up.
|
|
79
96
|
:param pulumi.Input[Sequence[pulumi.Input['ElastigroupSubnetArgs']]] subnets: A list of regions and subnets.
|
|
80
|
-
:param pulumi.Input[Sequence[pulumi.Input[str]]] tags: Tags to mark created instances.
|
|
97
|
+
:param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] tags: Tags to mark created instances.
|
|
81
98
|
"""
|
|
82
99
|
pulumi.set(__self__, "desired_capacity", desired_capacity)
|
|
83
100
|
if auto_healing is not None:
|
|
@@ -123,6 +140,8 @@ class ElastigroupArgs:
|
|
|
123
140
|
pulumi.set(__self__, "max_size", max_size)
|
|
124
141
|
if metadatas is not None:
|
|
125
142
|
pulumi.set(__self__, "metadatas", metadatas)
|
|
143
|
+
if min_cpu_platform is not None:
|
|
144
|
+
pulumi.set(__self__, "min_cpu_platform", min_cpu_platform)
|
|
126
145
|
if min_size is not None:
|
|
127
146
|
pulumi.set(__self__, "min_size", min_size)
|
|
128
147
|
if name is not None:
|
|
@@ -131,10 +150,16 @@ class ElastigroupArgs:
|
|
|
131
150
|
pulumi.set(__self__, "network_interfaces", network_interfaces)
|
|
132
151
|
if ondemand_count is not None:
|
|
133
152
|
pulumi.set(__self__, "ondemand_count", ondemand_count)
|
|
153
|
+
if optimization_windows is not None:
|
|
154
|
+
pulumi.set(__self__, "optimization_windows", optimization_windows)
|
|
134
155
|
if preemptible_percentage is not None:
|
|
135
156
|
pulumi.set(__self__, "preemptible_percentage", preemptible_percentage)
|
|
157
|
+
if preferred_availability_zones is not None:
|
|
158
|
+
pulumi.set(__self__, "preferred_availability_zones", preferred_availability_zones)
|
|
136
159
|
if provisioning_model is not None:
|
|
137
160
|
pulumi.set(__self__, "provisioning_model", provisioning_model)
|
|
161
|
+
if revert_to_preemptibles is not None:
|
|
162
|
+
pulumi.set(__self__, "revert_to_preemptibles", revert_to_preemptibles)
|
|
138
163
|
if scaling_down_policies is not None:
|
|
139
164
|
pulumi.set(__self__, "scaling_down_policies", scaling_down_policies)
|
|
140
165
|
if scaling_up_policies is not None:
|
|
@@ -143,6 +168,10 @@ class ElastigroupArgs:
|
|
|
143
168
|
pulumi.set(__self__, "scheduled_tasks", scheduled_tasks)
|
|
144
169
|
if service_account is not None:
|
|
145
170
|
pulumi.set(__self__, "service_account", service_account)
|
|
171
|
+
if shielded_instance_config is not None:
|
|
172
|
+
pulumi.set(__self__, "shielded_instance_config", shielded_instance_config)
|
|
173
|
+
if should_utilize_commitments is not None:
|
|
174
|
+
pulumi.set(__self__, "should_utilize_commitments", should_utilize_commitments)
|
|
146
175
|
if shutdown_script is not None:
|
|
147
176
|
pulumi.set(__self__, "shutdown_script", shutdown_script)
|
|
148
177
|
if startup_script is not None:
|
|
@@ -154,41 +183,41 @@ class ElastigroupArgs:
|
|
|
154
183
|
if unhealthy_duration is not None:
|
|
155
184
|
pulumi.set(__self__, "unhealthy_duration", unhealthy_duration)
|
|
156
185
|
|
|
157
|
-
@property
|
|
186
|
+
@_builtins.property
|
|
158
187
|
@pulumi.getter(name="desiredCapacity")
|
|
159
|
-
def desired_capacity(self) -> pulumi.Input[int]:
|
|
188
|
+
def desired_capacity(self) -> pulumi.Input[_builtins.int]:
|
|
160
189
|
"""
|
|
161
190
|
The desired number of instances the group should have at any time.
|
|
162
191
|
"""
|
|
163
192
|
return pulumi.get(self, "desired_capacity")
|
|
164
193
|
|
|
165
194
|
@desired_capacity.setter
|
|
166
|
-
def desired_capacity(self, value: pulumi.Input[int]):
|
|
195
|
+
def desired_capacity(self, value: pulumi.Input[_builtins.int]):
|
|
167
196
|
pulumi.set(self, "desired_capacity", value)
|
|
168
197
|
|
|
169
|
-
@property
|
|
198
|
+
@_builtins.property
|
|
170
199
|
@pulumi.getter(name="autoHealing")
|
|
171
|
-
def auto_healing(self) -> Optional[pulumi.Input[bool]]:
|
|
200
|
+
def auto_healing(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
172
201
|
return pulumi.get(self, "auto_healing")
|
|
173
202
|
|
|
174
203
|
@auto_healing.setter
|
|
175
|
-
def auto_healing(self, value: Optional[pulumi.Input[bool]]):
|
|
204
|
+
def auto_healing(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
176
205
|
pulumi.set(self, "auto_healing", value)
|
|
177
206
|
|
|
178
|
-
@property
|
|
207
|
+
@_builtins.property
|
|
179
208
|
@pulumi.getter(name="availabilityZones")
|
|
180
209
|
@_utilities.deprecated("""This field will soon be handled by Region in Subnets""")
|
|
181
|
-
def availability_zones(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
|
|
210
|
+
def availability_zones(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
|
|
182
211
|
"""
|
|
183
212
|
List of availability zones for the group.
|
|
184
213
|
"""
|
|
185
214
|
return pulumi.get(self, "availability_zones")
|
|
186
215
|
|
|
187
216
|
@availability_zones.setter
|
|
188
|
-
def availability_zones(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
|
|
217
|
+
def availability_zones(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]):
|
|
189
218
|
pulumi.set(self, "availability_zones", value)
|
|
190
219
|
|
|
191
|
-
@property
|
|
220
|
+
@_builtins.property
|
|
192
221
|
@pulumi.getter(name="backendServices")
|
|
193
222
|
def backend_services(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupBackendServiceArgs']]]]:
|
|
194
223
|
return pulumi.get(self, "backend_services")
|
|
@@ -197,19 +226,19 @@ class ElastigroupArgs:
|
|
|
197
226
|
def backend_services(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupBackendServiceArgs']]]]):
|
|
198
227
|
pulumi.set(self, "backend_services", value)
|
|
199
228
|
|
|
200
|
-
@property
|
|
229
|
+
@_builtins.property
|
|
201
230
|
@pulumi.getter
|
|
202
|
-
def description(self) -> Optional[pulumi.Input[str]]:
|
|
231
|
+
def description(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
203
232
|
"""
|
|
204
233
|
The region your GCP group will be created in.
|
|
205
234
|
"""
|
|
206
235
|
return pulumi.get(self, "description")
|
|
207
236
|
|
|
208
237
|
@description.setter
|
|
209
|
-
def description(self, value: Optional[pulumi.Input[str]]):
|
|
238
|
+
def description(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
210
239
|
pulumi.set(self, "description", value)
|
|
211
240
|
|
|
212
|
-
@property
|
|
241
|
+
@_builtins.property
|
|
213
242
|
@pulumi.getter
|
|
214
243
|
def disks(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupDiskArgs']]]]:
|
|
215
244
|
return pulumi.get(self, "disks")
|
|
@@ -218,31 +247,31 @@ class ElastigroupArgs:
|
|
|
218
247
|
def disks(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupDiskArgs']]]]):
|
|
219
248
|
pulumi.set(self, "disks", value)
|
|
220
249
|
|
|
221
|
-
@property
|
|
250
|
+
@_builtins.property
|
|
222
251
|
@pulumi.getter(name="drainingTimeout")
|
|
223
|
-
def draining_timeout(self) -> Optional[pulumi.Input[int]]:
|
|
252
|
+
def draining_timeout(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
224
253
|
"""
|
|
225
254
|
Time (seconds) the instance is allowed to run after it is detached from the group. This is to allow the instance time to drain all the current TCP connections before terminating it.
|
|
226
255
|
"""
|
|
227
256
|
return pulumi.get(self, "draining_timeout")
|
|
228
257
|
|
|
229
258
|
@draining_timeout.setter
|
|
230
|
-
def draining_timeout(self, value: Optional[pulumi.Input[int]]):
|
|
259
|
+
def draining_timeout(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
231
260
|
pulumi.set(self, "draining_timeout", value)
|
|
232
261
|
|
|
233
|
-
@property
|
|
262
|
+
@_builtins.property
|
|
234
263
|
@pulumi.getter(name="fallbackToOndemand")
|
|
235
|
-
def fallback_to_ondemand(self) -> Optional[pulumi.Input[bool]]:
|
|
264
|
+
def fallback_to_ondemand(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
236
265
|
"""
|
|
237
266
|
Activate fallback-to-on-demand. When provisioning an instance, if no Preemptible market is available, fallback-to-on-demand will provision an On-Demand instance to maintain the group capacity.
|
|
238
267
|
"""
|
|
239
268
|
return pulumi.get(self, "fallback_to_ondemand")
|
|
240
269
|
|
|
241
270
|
@fallback_to_ondemand.setter
|
|
242
|
-
def fallback_to_ondemand(self, value: Optional[pulumi.Input[bool]]):
|
|
271
|
+
def fallback_to_ondemand(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
243
272
|
pulumi.set(self, "fallback_to_ondemand", value)
|
|
244
273
|
|
|
245
|
-
@property
|
|
274
|
+
@_builtins.property
|
|
246
275
|
@pulumi.getter
|
|
247
276
|
def gpu(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupGpuArgs']]]]:
|
|
248
277
|
return pulumi.get(self, "gpu")
|
|
@@ -251,27 +280,27 @@ class ElastigroupArgs:
|
|
|
251
280
|
def gpu(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupGpuArgs']]]]):
|
|
252
281
|
pulumi.set(self, "gpu", value)
|
|
253
282
|
|
|
254
|
-
@property
|
|
283
|
+
@_builtins.property
|
|
255
284
|
@pulumi.getter(name="healthCheckGracePeriod")
|
|
256
|
-
def health_check_grace_period(self) -> Optional[pulumi.Input[int]]:
|
|
285
|
+
def health_check_grace_period(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
257
286
|
return pulumi.get(self, "health_check_grace_period")
|
|
258
287
|
|
|
259
288
|
@health_check_grace_period.setter
|
|
260
|
-
def health_check_grace_period(self, value: Optional[pulumi.Input[int]]):
|
|
289
|
+
def health_check_grace_period(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
261
290
|
pulumi.set(self, "health_check_grace_period", value)
|
|
262
291
|
|
|
263
|
-
@property
|
|
292
|
+
@_builtins.property
|
|
264
293
|
@pulumi.getter(name="healthCheckType")
|
|
265
|
-
def health_check_type(self) -> Optional[pulumi.Input[str]]:
|
|
294
|
+
def health_check_type(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
266
295
|
return pulumi.get(self, "health_check_type")
|
|
267
296
|
|
|
268
297
|
@health_check_type.setter
|
|
269
|
-
def health_check_type(self, value: Optional[pulumi.Input[str]]):
|
|
298
|
+
def health_check_type(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
270
299
|
pulumi.set(self, "health_check_type", value)
|
|
271
300
|
|
|
272
|
-
@property
|
|
301
|
+
@_builtins.property
|
|
273
302
|
@pulumi.getter(name="instanceNamePrefix")
|
|
274
|
-
def instance_name_prefix(self) -> Optional[pulumi.Input[str]]:
|
|
303
|
+
def instance_name_prefix(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
275
304
|
"""
|
|
276
305
|
Set an instance name prefix to be used for all launched instances and their boot disk. The prefix value should comply with the following limitations:
|
|
277
306
|
* A maximal length of 25 characters.
|
|
@@ -280,10 +309,10 @@ class ElastigroupArgs:
|
|
|
280
309
|
return pulumi.get(self, "instance_name_prefix")
|
|
281
310
|
|
|
282
311
|
@instance_name_prefix.setter
|
|
283
|
-
def instance_name_prefix(self, value: Optional[pulumi.Input[str]]):
|
|
312
|
+
def instance_name_prefix(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
284
313
|
pulumi.set(self, "instance_name_prefix", value)
|
|
285
314
|
|
|
286
|
-
@property
|
|
315
|
+
@_builtins.property
|
|
287
316
|
@pulumi.getter(name="instanceTypesCustoms")
|
|
288
317
|
def instance_types_customs(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupInstanceTypesCustomArgs']]]]:
|
|
289
318
|
"""
|
|
@@ -296,31 +325,31 @@ class ElastigroupArgs:
|
|
|
296
325
|
def instance_types_customs(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupInstanceTypesCustomArgs']]]]):
|
|
297
326
|
pulumi.set(self, "instance_types_customs", value)
|
|
298
327
|
|
|
299
|
-
@property
|
|
328
|
+
@_builtins.property
|
|
300
329
|
@pulumi.getter(name="instanceTypesOndemand")
|
|
301
|
-
def instance_types_ondemand(self) -> Optional[pulumi.Input[str]]:
|
|
330
|
+
def instance_types_ondemand(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
302
331
|
"""
|
|
303
332
|
The regular VM instance type to use for mixed-type groups and when falling back to on-demand. Required if instance_types_preemptible is not set.
|
|
304
333
|
"""
|
|
305
334
|
return pulumi.get(self, "instance_types_ondemand")
|
|
306
335
|
|
|
307
336
|
@instance_types_ondemand.setter
|
|
308
|
-
def instance_types_ondemand(self, value: Optional[pulumi.Input[str]]):
|
|
337
|
+
def instance_types_ondemand(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
309
338
|
pulumi.set(self, "instance_types_ondemand", value)
|
|
310
339
|
|
|
311
|
-
@property
|
|
340
|
+
@_builtins.property
|
|
312
341
|
@pulumi.getter(name="instanceTypesPreemptibles")
|
|
313
|
-
def instance_types_preemptibles(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
|
|
342
|
+
def instance_types_preemptibles(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
|
|
314
343
|
"""
|
|
315
344
|
The preemptible VMs instance type. To maximize cost savings and market availability, select as many types as possible. Required if instance_types_ondemand is not set.
|
|
316
345
|
"""
|
|
317
346
|
return pulumi.get(self, "instance_types_preemptibles")
|
|
318
347
|
|
|
319
348
|
@instance_types_preemptibles.setter
|
|
320
|
-
def instance_types_preemptibles(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
|
|
349
|
+
def instance_types_preemptibles(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]):
|
|
321
350
|
pulumi.set(self, "instance_types_preemptibles", value)
|
|
322
351
|
|
|
323
|
-
@property
|
|
352
|
+
@_builtins.property
|
|
324
353
|
@pulumi.getter(name="integrationDockerSwarm")
|
|
325
354
|
def integration_docker_swarm(self) -> Optional[pulumi.Input['ElastigroupIntegrationDockerSwarmArgs']]:
|
|
326
355
|
return pulumi.get(self, "integration_docker_swarm")
|
|
@@ -329,7 +358,7 @@ class ElastigroupArgs:
|
|
|
329
358
|
def integration_docker_swarm(self, value: Optional[pulumi.Input['ElastigroupIntegrationDockerSwarmArgs']]):
|
|
330
359
|
pulumi.set(self, "integration_docker_swarm", value)
|
|
331
360
|
|
|
332
|
-
@property
|
|
361
|
+
@_builtins.property
|
|
333
362
|
@pulumi.getter(name="integrationGke")
|
|
334
363
|
def integration_gke(self) -> Optional[pulumi.Input['ElastigroupIntegrationGkeArgs']]:
|
|
335
364
|
return pulumi.get(self, "integration_gke")
|
|
@@ -338,16 +367,16 @@ class ElastigroupArgs:
|
|
|
338
367
|
def integration_gke(self, value: Optional[pulumi.Input['ElastigroupIntegrationGkeArgs']]):
|
|
339
368
|
pulumi.set(self, "integration_gke", value)
|
|
340
369
|
|
|
341
|
-
@property
|
|
370
|
+
@_builtins.property
|
|
342
371
|
@pulumi.getter(name="ipForwarding")
|
|
343
|
-
def ip_forwarding(self) -> Optional[pulumi.Input[bool]]:
|
|
372
|
+
def ip_forwarding(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
344
373
|
return pulumi.get(self, "ip_forwarding")
|
|
345
374
|
|
|
346
375
|
@ip_forwarding.setter
|
|
347
|
-
def ip_forwarding(self, value: Optional[pulumi.Input[bool]]):
|
|
376
|
+
def ip_forwarding(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
348
377
|
pulumi.set(self, "ip_forwarding", value)
|
|
349
378
|
|
|
350
|
-
@property
|
|
379
|
+
@_builtins.property
|
|
351
380
|
@pulumi.getter
|
|
352
381
|
def labels(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupLabelArgs']]]]:
|
|
353
382
|
"""
|
|
@@ -359,19 +388,19 @@ class ElastigroupArgs:
|
|
|
359
388
|
def labels(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupLabelArgs']]]]):
|
|
360
389
|
pulumi.set(self, "labels", value)
|
|
361
390
|
|
|
362
|
-
@property
|
|
391
|
+
@_builtins.property
|
|
363
392
|
@pulumi.getter(name="maxSize")
|
|
364
|
-
def max_size(self) -> Optional[pulumi.Input[int]]:
|
|
393
|
+
def max_size(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
365
394
|
"""
|
|
366
395
|
The maximum number of instances the group should have at any time.
|
|
367
396
|
"""
|
|
368
397
|
return pulumi.get(self, "max_size")
|
|
369
398
|
|
|
370
399
|
@max_size.setter
|
|
371
|
-
def max_size(self, value: Optional[pulumi.Input[int]]):
|
|
400
|
+
def max_size(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
372
401
|
pulumi.set(self, "max_size", value)
|
|
373
402
|
|
|
374
|
-
@property
|
|
403
|
+
@_builtins.property
|
|
375
404
|
@pulumi.getter
|
|
376
405
|
def metadatas(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupMetadataArgs']]]]:
|
|
377
406
|
"""
|
|
@@ -383,31 +412,43 @@ class ElastigroupArgs:
|
|
|
383
412
|
def metadatas(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupMetadataArgs']]]]):
|
|
384
413
|
pulumi.set(self, "metadatas", value)
|
|
385
414
|
|
|
386
|
-
@property
|
|
415
|
+
@_builtins.property
|
|
416
|
+
@pulumi.getter(name="minCpuPlatform")
|
|
417
|
+
def min_cpu_platform(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
418
|
+
"""
|
|
419
|
+
Select a minimum CPU platform for the compute instance.
|
|
420
|
+
"""
|
|
421
|
+
return pulumi.get(self, "min_cpu_platform")
|
|
422
|
+
|
|
423
|
+
@min_cpu_platform.setter
|
|
424
|
+
def min_cpu_platform(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
425
|
+
pulumi.set(self, "min_cpu_platform", value)
|
|
426
|
+
|
|
427
|
+
@_builtins.property
|
|
387
428
|
@pulumi.getter(name="minSize")
|
|
388
|
-
def min_size(self) -> Optional[pulumi.Input[int]]:
|
|
429
|
+
def min_size(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
389
430
|
"""
|
|
390
431
|
The minimum number of instances the group should have at any time.
|
|
391
432
|
"""
|
|
392
433
|
return pulumi.get(self, "min_size")
|
|
393
434
|
|
|
394
435
|
@min_size.setter
|
|
395
|
-
def min_size(self, value: Optional[pulumi.Input[int]]):
|
|
436
|
+
def min_size(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
396
437
|
pulumi.set(self, "min_size", value)
|
|
397
438
|
|
|
398
|
-
@property
|
|
439
|
+
@_builtins.property
|
|
399
440
|
@pulumi.getter
|
|
400
|
-
def name(self) -> Optional[pulumi.Input[str]]:
|
|
441
|
+
def name(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
401
442
|
"""
|
|
402
443
|
The group name.
|
|
403
444
|
"""
|
|
404
445
|
return pulumi.get(self, "name")
|
|
405
446
|
|
|
406
447
|
@name.setter
|
|
407
|
-
def name(self, value: Optional[pulumi.Input[str]]):
|
|
448
|
+
def name(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
408
449
|
pulumi.set(self, "name", value)
|
|
409
450
|
|
|
410
|
-
@property
|
|
451
|
+
@_builtins.property
|
|
411
452
|
@pulumi.getter(name="networkInterfaces")
|
|
412
453
|
def network_interfaces(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupNetworkInterfaceArgs']]]]:
|
|
413
454
|
return pulumi.get(self, "network_interfaces")
|
|
@@ -416,40 +457,76 @@ class ElastigroupArgs:
|
|
|
416
457
|
def network_interfaces(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupNetworkInterfaceArgs']]]]):
|
|
417
458
|
pulumi.set(self, "network_interfaces", value)
|
|
418
459
|
|
|
419
|
-
@property
|
|
460
|
+
@_builtins.property
|
|
420
461
|
@pulumi.getter(name="ondemandCount")
|
|
421
|
-
def ondemand_count(self) -> Optional[pulumi.Input[int]]:
|
|
462
|
+
def ondemand_count(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
422
463
|
return pulumi.get(self, "ondemand_count")
|
|
423
464
|
|
|
424
465
|
@ondemand_count.setter
|
|
425
|
-
def ondemand_count(self, value: Optional[pulumi.Input[int]]):
|
|
466
|
+
def ondemand_count(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
426
467
|
pulumi.set(self, "ondemand_count", value)
|
|
427
468
|
|
|
428
|
-
@property
|
|
469
|
+
@_builtins.property
|
|
470
|
+
@pulumi.getter(name="optimizationWindows")
|
|
471
|
+
def optimization_windows(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
|
|
472
|
+
"""
|
|
473
|
+
Set time window to perform the revert to preemptible. Time windows must be at least 120 minutes. Format: DayInWeek:HH-DayInWeek:HH. Required when strategy.revertToPreemptible.performAt is 'timeWindow'.
|
|
474
|
+
"""
|
|
475
|
+
return pulumi.get(self, "optimization_windows")
|
|
476
|
+
|
|
477
|
+
@optimization_windows.setter
|
|
478
|
+
def optimization_windows(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]):
|
|
479
|
+
pulumi.set(self, "optimization_windows", value)
|
|
480
|
+
|
|
481
|
+
@_builtins.property
|
|
429
482
|
@pulumi.getter(name="preemptiblePercentage")
|
|
430
|
-
def preemptible_percentage(self) -> Optional[pulumi.Input[int]]:
|
|
483
|
+
def preemptible_percentage(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
431
484
|
"""
|
|
432
485
|
Percentage of Preemptible VMs to spin up from the "desired_capacity".
|
|
433
486
|
"""
|
|
434
487
|
return pulumi.get(self, "preemptible_percentage")
|
|
435
488
|
|
|
436
489
|
@preemptible_percentage.setter
|
|
437
|
-
def preemptible_percentage(self, value: Optional[pulumi.Input[int]]):
|
|
490
|
+
def preemptible_percentage(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
438
491
|
pulumi.set(self, "preemptible_percentage", value)
|
|
439
492
|
|
|
440
|
-
@property
|
|
493
|
+
@_builtins.property
|
|
494
|
+
@pulumi.getter(name="preferredAvailabilityZones")
|
|
495
|
+
def preferred_availability_zones(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
|
|
496
|
+
"""
|
|
497
|
+
prioritize availability zones when launching instances for the group. Must be a sublist of `availability_zones`.
|
|
498
|
+
"""
|
|
499
|
+
return pulumi.get(self, "preferred_availability_zones")
|
|
500
|
+
|
|
501
|
+
@preferred_availability_zones.setter
|
|
502
|
+
def preferred_availability_zones(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]):
|
|
503
|
+
pulumi.set(self, "preferred_availability_zones", value)
|
|
504
|
+
|
|
505
|
+
@_builtins.property
|
|
441
506
|
@pulumi.getter(name="provisioningModel")
|
|
442
|
-
def provisioning_model(self) -> Optional[pulumi.Input[str]]:
|
|
507
|
+
def provisioning_model(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
443
508
|
"""
|
|
444
509
|
Valid values: "SPOT", "PREEMPTIBLE". Define the provisioning model of the launched instances. Default value is "PREEMPTIBLE".
|
|
445
510
|
"""
|
|
446
511
|
return pulumi.get(self, "provisioning_model")
|
|
447
512
|
|
|
448
513
|
@provisioning_model.setter
|
|
449
|
-
def provisioning_model(self, value: Optional[pulumi.Input[str]]):
|
|
514
|
+
def provisioning_model(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
450
515
|
pulumi.set(self, "provisioning_model", value)
|
|
451
516
|
|
|
452
|
-
@property
|
|
517
|
+
@_builtins.property
|
|
518
|
+
@pulumi.getter(name="revertToPreemptibles")
|
|
519
|
+
def revert_to_preemptibles(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupRevertToPreemptibleArgs']]]]:
|
|
520
|
+
"""
|
|
521
|
+
Setting for revert to preemptible option.
|
|
522
|
+
"""
|
|
523
|
+
return pulumi.get(self, "revert_to_preemptibles")
|
|
524
|
+
|
|
525
|
+
@revert_to_preemptibles.setter
|
|
526
|
+
def revert_to_preemptibles(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupRevertToPreemptibleArgs']]]]):
|
|
527
|
+
pulumi.set(self, "revert_to_preemptibles", value)
|
|
528
|
+
|
|
529
|
+
@_builtins.property
|
|
453
530
|
@pulumi.getter(name="scalingDownPolicies")
|
|
454
531
|
def scaling_down_policies(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupScalingDownPolicyArgs']]]]:
|
|
455
532
|
return pulumi.get(self, "scaling_down_policies")
|
|
@@ -458,7 +535,7 @@ class ElastigroupArgs:
|
|
|
458
535
|
def scaling_down_policies(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupScalingDownPolicyArgs']]]]):
|
|
459
536
|
pulumi.set(self, "scaling_down_policies", value)
|
|
460
537
|
|
|
461
|
-
@property
|
|
538
|
+
@_builtins.property
|
|
462
539
|
@pulumi.getter(name="scalingUpPolicies")
|
|
463
540
|
def scaling_up_policies(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupScalingUpPolicyArgs']]]]:
|
|
464
541
|
return pulumi.get(self, "scaling_up_policies")
|
|
@@ -467,7 +544,7 @@ class ElastigroupArgs:
|
|
|
467
544
|
def scaling_up_policies(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupScalingUpPolicyArgs']]]]):
|
|
468
545
|
pulumi.set(self, "scaling_up_policies", value)
|
|
469
546
|
|
|
470
|
-
@property
|
|
547
|
+
@_builtins.property
|
|
471
548
|
@pulumi.getter(name="scheduledTasks")
|
|
472
549
|
def scheduled_tasks(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupScheduledTaskArgs']]]]:
|
|
473
550
|
return pulumi.get(self, "scheduled_tasks")
|
|
@@ -476,43 +553,67 @@ class ElastigroupArgs:
|
|
|
476
553
|
def scheduled_tasks(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupScheduledTaskArgs']]]]):
|
|
477
554
|
pulumi.set(self, "scheduled_tasks", value)
|
|
478
555
|
|
|
479
|
-
@property
|
|
556
|
+
@_builtins.property
|
|
480
557
|
@pulumi.getter(name="serviceAccount")
|
|
481
|
-
def service_account(self) -> Optional[pulumi.Input[str]]:
|
|
558
|
+
def service_account(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
482
559
|
"""
|
|
483
560
|
The email of the service account in which the group instances will be launched.
|
|
484
561
|
"""
|
|
485
562
|
return pulumi.get(self, "service_account")
|
|
486
563
|
|
|
487
564
|
@service_account.setter
|
|
488
|
-
def service_account(self, value: Optional[pulumi.Input[str]]):
|
|
565
|
+
def service_account(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
489
566
|
pulumi.set(self, "service_account", value)
|
|
490
567
|
|
|
491
|
-
@property
|
|
568
|
+
@_builtins.property
|
|
569
|
+
@pulumi.getter(name="shieldedInstanceConfig")
|
|
570
|
+
def shielded_instance_config(self) -> Optional[pulumi.Input['ElastigroupShieldedInstanceConfigArgs']]:
|
|
571
|
+
"""
|
|
572
|
+
You can use secure boot when you launch VMs using Elastigroup. This helps you comply with your security policies. In the instance configuration, use ‘secureBootEnabled’ set to True to enforce UEFI with secure boot. Elastigroup provisions VMs with secure boot, as long as the images supports UEFI.
|
|
573
|
+
"""
|
|
574
|
+
return pulumi.get(self, "shielded_instance_config")
|
|
575
|
+
|
|
576
|
+
@shielded_instance_config.setter
|
|
577
|
+
def shielded_instance_config(self, value: Optional[pulumi.Input['ElastigroupShieldedInstanceConfigArgs']]):
|
|
578
|
+
pulumi.set(self, "shielded_instance_config", value)
|
|
579
|
+
|
|
580
|
+
@_builtins.property
|
|
581
|
+
@pulumi.getter(name="shouldUtilizeCommitments")
|
|
582
|
+
def should_utilize_commitments(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
583
|
+
"""
|
|
584
|
+
Enable committed use discounts utilization.
|
|
585
|
+
"""
|
|
586
|
+
return pulumi.get(self, "should_utilize_commitments")
|
|
587
|
+
|
|
588
|
+
@should_utilize_commitments.setter
|
|
589
|
+
def should_utilize_commitments(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
590
|
+
pulumi.set(self, "should_utilize_commitments", value)
|
|
591
|
+
|
|
592
|
+
@_builtins.property
|
|
492
593
|
@pulumi.getter(name="shutdownScript")
|
|
493
|
-
def shutdown_script(self) -> Optional[pulumi.Input[str]]:
|
|
594
|
+
def shutdown_script(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
494
595
|
"""
|
|
495
596
|
The Base64-encoded shutdown script that executes prior to instance termination, for more information please see: [Shutdown Script](https://api.spotinst.com/integration-docs/elastigroup/concepts/compute-concepts/shutdown-scripts/)
|
|
496
597
|
"""
|
|
497
598
|
return pulumi.get(self, "shutdown_script")
|
|
498
599
|
|
|
499
600
|
@shutdown_script.setter
|
|
500
|
-
def shutdown_script(self, value: Optional[pulumi.Input[str]]):
|
|
601
|
+
def shutdown_script(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
501
602
|
pulumi.set(self, "shutdown_script", value)
|
|
502
603
|
|
|
503
|
-
@property
|
|
604
|
+
@_builtins.property
|
|
504
605
|
@pulumi.getter(name="startupScript")
|
|
505
|
-
def startup_script(self) -> Optional[pulumi.Input[str]]:
|
|
606
|
+
def startup_script(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
506
607
|
"""
|
|
507
608
|
Create and run your own startup scripts on your virtual machines to perform automated tasks every time your instance boots up.
|
|
508
609
|
"""
|
|
509
610
|
return pulumi.get(self, "startup_script")
|
|
510
611
|
|
|
511
612
|
@startup_script.setter
|
|
512
|
-
def startup_script(self, value: Optional[pulumi.Input[str]]):
|
|
613
|
+
def startup_script(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
513
614
|
pulumi.set(self, "startup_script", value)
|
|
514
615
|
|
|
515
|
-
@property
|
|
616
|
+
@_builtins.property
|
|
516
617
|
@pulumi.getter
|
|
517
618
|
def subnets(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupSubnetArgs']]]]:
|
|
518
619
|
"""
|
|
@@ -524,93 +625,105 @@ class ElastigroupArgs:
|
|
|
524
625
|
def subnets(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupSubnetArgs']]]]):
|
|
525
626
|
pulumi.set(self, "subnets", value)
|
|
526
627
|
|
|
527
|
-
@property
|
|
628
|
+
@_builtins.property
|
|
528
629
|
@pulumi.getter
|
|
529
|
-
def tags(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
|
|
630
|
+
def tags(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
|
|
530
631
|
"""
|
|
531
632
|
Tags to mark created instances.
|
|
532
633
|
"""
|
|
533
634
|
return pulumi.get(self, "tags")
|
|
534
635
|
|
|
535
636
|
@tags.setter
|
|
536
|
-
def tags(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
|
|
637
|
+
def tags(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]):
|
|
537
638
|
pulumi.set(self, "tags", value)
|
|
538
639
|
|
|
539
|
-
@property
|
|
640
|
+
@_builtins.property
|
|
540
641
|
@pulumi.getter(name="unhealthyDuration")
|
|
541
|
-
def unhealthy_duration(self) -> Optional[pulumi.Input[int]]:
|
|
642
|
+
def unhealthy_duration(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
542
643
|
return pulumi.get(self, "unhealthy_duration")
|
|
543
644
|
|
|
544
645
|
@unhealthy_duration.setter
|
|
545
|
-
def unhealthy_duration(self, value: Optional[pulumi.Input[int]]):
|
|
646
|
+
def unhealthy_duration(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
546
647
|
pulumi.set(self, "unhealthy_duration", value)
|
|
547
648
|
|
|
548
649
|
|
|
549
650
|
@pulumi.input_type
|
|
550
651
|
class _ElastigroupState:
|
|
551
652
|
def __init__(__self__, *,
|
|
552
|
-
auto_healing: Optional[pulumi.Input[bool]] = None,
|
|
553
|
-
availability_zones: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
|
|
653
|
+
auto_healing: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
654
|
+
availability_zones: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
554
655
|
backend_services: Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupBackendServiceArgs']]]] = None,
|
|
555
|
-
description: Optional[pulumi.Input[str]] = None,
|
|
556
|
-
desired_capacity: Optional[pulumi.Input[int]] = None,
|
|
656
|
+
description: Optional[pulumi.Input[_builtins.str]] = None,
|
|
657
|
+
desired_capacity: Optional[pulumi.Input[_builtins.int]] = None,
|
|
557
658
|
disks: Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupDiskArgs']]]] = None,
|
|
558
|
-
draining_timeout: Optional[pulumi.Input[int]] = None,
|
|
559
|
-
fallback_to_ondemand: Optional[pulumi.Input[bool]] = None,
|
|
659
|
+
draining_timeout: Optional[pulumi.Input[_builtins.int]] = None,
|
|
660
|
+
fallback_to_ondemand: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
560
661
|
gpu: Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupGpuArgs']]]] = None,
|
|
561
|
-
health_check_grace_period: Optional[pulumi.Input[int]] = None,
|
|
562
|
-
health_check_type: Optional[pulumi.Input[str]] = None,
|
|
563
|
-
instance_name_prefix: Optional[pulumi.Input[str]] = None,
|
|
662
|
+
health_check_grace_period: Optional[pulumi.Input[_builtins.int]] = None,
|
|
663
|
+
health_check_type: Optional[pulumi.Input[_builtins.str]] = None,
|
|
664
|
+
instance_name_prefix: Optional[pulumi.Input[_builtins.str]] = None,
|
|
564
665
|
instance_types_customs: Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupInstanceTypesCustomArgs']]]] = None,
|
|
565
|
-
instance_types_ondemand: Optional[pulumi.Input[str]] = None,
|
|
566
|
-
instance_types_preemptibles: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
|
|
666
|
+
instance_types_ondemand: Optional[pulumi.Input[_builtins.str]] = None,
|
|
667
|
+
instance_types_preemptibles: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
567
668
|
integration_docker_swarm: Optional[pulumi.Input['ElastigroupIntegrationDockerSwarmArgs']] = None,
|
|
568
669
|
integration_gke: Optional[pulumi.Input['ElastigroupIntegrationGkeArgs']] = None,
|
|
569
|
-
ip_forwarding: Optional[pulumi.Input[bool]] = None,
|
|
670
|
+
ip_forwarding: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
570
671
|
labels: Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupLabelArgs']]]] = None,
|
|
571
|
-
max_size: Optional[pulumi.Input[int]] = None,
|
|
672
|
+
max_size: Optional[pulumi.Input[_builtins.int]] = None,
|
|
572
673
|
metadatas: Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupMetadataArgs']]]] = None,
|
|
573
|
-
|
|
574
|
-
|
|
674
|
+
min_cpu_platform: Optional[pulumi.Input[_builtins.str]] = None,
|
|
675
|
+
min_size: Optional[pulumi.Input[_builtins.int]] = None,
|
|
676
|
+
name: Optional[pulumi.Input[_builtins.str]] = None,
|
|
575
677
|
network_interfaces: Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupNetworkInterfaceArgs']]]] = None,
|
|
576
|
-
ondemand_count: Optional[pulumi.Input[int]] = None,
|
|
577
|
-
|
|
578
|
-
|
|
678
|
+
ondemand_count: Optional[pulumi.Input[_builtins.int]] = None,
|
|
679
|
+
optimization_windows: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
680
|
+
preemptible_percentage: Optional[pulumi.Input[_builtins.int]] = None,
|
|
681
|
+
preferred_availability_zones: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
682
|
+
provisioning_model: Optional[pulumi.Input[_builtins.str]] = None,
|
|
683
|
+
revert_to_preemptibles: Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupRevertToPreemptibleArgs']]]] = None,
|
|
579
684
|
scaling_down_policies: Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupScalingDownPolicyArgs']]]] = None,
|
|
580
685
|
scaling_up_policies: Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupScalingUpPolicyArgs']]]] = None,
|
|
581
686
|
scheduled_tasks: Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupScheduledTaskArgs']]]] = None,
|
|
582
|
-
service_account: Optional[pulumi.Input[str]] = None,
|
|
583
|
-
|
|
584
|
-
|
|
687
|
+
service_account: Optional[pulumi.Input[_builtins.str]] = None,
|
|
688
|
+
shielded_instance_config: Optional[pulumi.Input['ElastigroupShieldedInstanceConfigArgs']] = None,
|
|
689
|
+
should_utilize_commitments: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
690
|
+
shutdown_script: Optional[pulumi.Input[_builtins.str]] = None,
|
|
691
|
+
startup_script: Optional[pulumi.Input[_builtins.str]] = None,
|
|
585
692
|
subnets: Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupSubnetArgs']]]] = None,
|
|
586
|
-
tags: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
|
|
587
|
-
unhealthy_duration: Optional[pulumi.Input[int]] = None):
|
|
693
|
+
tags: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
694
|
+
unhealthy_duration: Optional[pulumi.Input[_builtins.int]] = None):
|
|
588
695
|
"""
|
|
589
696
|
Input properties used for looking up and filtering Elastigroup resources.
|
|
590
|
-
:param pulumi.Input[Sequence[pulumi.Input[str]]] availability_zones: List of availability zones for the group.
|
|
591
|
-
:param pulumi.Input[str] description: The region your GCP group will be created in.
|
|
592
|
-
:param pulumi.Input[int] desired_capacity: The desired number of instances the group should have at any time.
|
|
593
|
-
:param pulumi.Input[int] draining_timeout: Time (seconds) the instance is allowed to run after it is detached from the group. This is to allow the instance time to drain all the current TCP connections before terminating it.
|
|
594
|
-
:param pulumi.Input[bool] fallback_to_ondemand: Activate fallback-to-on-demand. When provisioning an instance, if no Preemptible market is available, fallback-to-on-demand will provision an On-Demand instance to maintain the group capacity.
|
|
595
|
-
:param pulumi.Input[str] instance_name_prefix: Set an instance name prefix to be used for all launched instances and their boot disk. The prefix value should comply with the following limitations:
|
|
697
|
+
:param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] availability_zones: List of availability zones for the group.
|
|
698
|
+
:param pulumi.Input[_builtins.str] description: The region your GCP group will be created in.
|
|
699
|
+
:param pulumi.Input[_builtins.int] desired_capacity: The desired number of instances the group should have at any time.
|
|
700
|
+
:param pulumi.Input[_builtins.int] draining_timeout: Time (seconds) the instance is allowed to run after it is detached from the group. This is to allow the instance time to drain all the current TCP connections before terminating it.
|
|
701
|
+
:param pulumi.Input[_builtins.bool] fallback_to_ondemand: Activate fallback-to-on-demand. When provisioning an instance, if no Preemptible market is available, fallback-to-on-demand will provision an On-Demand instance to maintain the group capacity.
|
|
702
|
+
:param pulumi.Input[_builtins.str] instance_name_prefix: Set an instance name prefix to be used for all launched instances and their boot disk. The prefix value should comply with the following limitations:
|
|
596
703
|
* A maximal length of 25 characters.
|
|
597
704
|
* The first character must be a lowercase letter, and all the following characters must be hyphens, lowercase letters, or digits, except the last character, which cannot be a hyphen.
|
|
598
705
|
:param pulumi.Input[Sequence[pulumi.Input['ElastigroupInstanceTypesCustomArgs']]] instance_types_customs: Defines a set of custom instance types. Required if instance_types_preemptible and instance_types_ondemand are not set.
|
|
599
706
|
* `vCPU` - (Optional) The number of vCPUs in the custom instance type. GCP has a number of limitations on accepted vCPU values. For more information, see the GCP documentation (here.)[https://cloud.google.com/compute/docs/instances/creating-instance-with-custom-machine-type#specifications]
|
|
600
|
-
:param pulumi.Input[str] instance_types_ondemand: The regular VM instance type to use for mixed-type groups and when falling back to on-demand. Required if instance_types_preemptible is not set.
|
|
601
|
-
:param pulumi.Input[Sequence[pulumi.Input[str]]] instance_types_preemptibles: The preemptible VMs instance type. To maximize cost savings and market availability, select as many types as possible. Required if instance_types_ondemand is not set.
|
|
707
|
+
:param pulumi.Input[_builtins.str] instance_types_ondemand: The regular VM instance type to use for mixed-type groups and when falling back to on-demand. Required if instance_types_preemptible is not set.
|
|
708
|
+
:param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] instance_types_preemptibles: The preemptible VMs instance type. To maximize cost savings and market availability, select as many types as possible. Required if instance_types_ondemand is not set.
|
|
602
709
|
:param pulumi.Input[Sequence[pulumi.Input['ElastigroupLabelArgs']]] labels: Array of objects with key-value pairs.
|
|
603
|
-
:param pulumi.Input[int] max_size: The maximum number of instances the group should have at any time.
|
|
710
|
+
:param pulumi.Input[_builtins.int] max_size: The maximum number of instances the group should have at any time.
|
|
604
711
|
:param pulumi.Input[Sequence[pulumi.Input['ElastigroupMetadataArgs']]] metadatas: Array of objects with key-value pairs.
|
|
605
|
-
:param pulumi.Input[
|
|
606
|
-
:param pulumi.Input[
|
|
607
|
-
:param pulumi.Input[
|
|
608
|
-
:param pulumi.Input[str]
|
|
609
|
-
:param pulumi.Input[
|
|
610
|
-
:param pulumi.Input[str]
|
|
611
|
-
:param pulumi.Input[str]
|
|
712
|
+
:param pulumi.Input[_builtins.str] min_cpu_platform: Select a minimum CPU platform for the compute instance.
|
|
713
|
+
:param pulumi.Input[_builtins.int] min_size: The minimum number of instances the group should have at any time.
|
|
714
|
+
:param pulumi.Input[_builtins.str] name: The group name.
|
|
715
|
+
:param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] optimization_windows: Set time window to perform the revert to preemptible. Time windows must be at least 120 minutes. Format: DayInWeek:HH-DayInWeek:HH. Required when strategy.revertToPreemptible.performAt is 'timeWindow'.
|
|
716
|
+
:param pulumi.Input[_builtins.int] preemptible_percentage: Percentage of Preemptible VMs to spin up from the "desired_capacity".
|
|
717
|
+
:param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] preferred_availability_zones: prioritize availability zones when launching instances for the group. Must be a sublist of `availability_zones`.
|
|
718
|
+
:param pulumi.Input[_builtins.str] provisioning_model: Valid values: "SPOT", "PREEMPTIBLE". Define the provisioning model of the launched instances. Default value is "PREEMPTIBLE".
|
|
719
|
+
:param pulumi.Input[Sequence[pulumi.Input['ElastigroupRevertToPreemptibleArgs']]] revert_to_preemptibles: Setting for revert to preemptible option.
|
|
720
|
+
:param pulumi.Input[_builtins.str] service_account: The email of the service account in which the group instances will be launched.
|
|
721
|
+
:param pulumi.Input['ElastigroupShieldedInstanceConfigArgs'] shielded_instance_config: You can use secure boot when you launch VMs using Elastigroup. This helps you comply with your security policies. In the instance configuration, use ‘secureBootEnabled’ set to True to enforce UEFI with secure boot. Elastigroup provisions VMs with secure boot, as long as the images supports UEFI.
|
|
722
|
+
:param pulumi.Input[_builtins.bool] should_utilize_commitments: Enable committed use discounts utilization.
|
|
723
|
+
:param pulumi.Input[_builtins.str] shutdown_script: The Base64-encoded shutdown script that executes prior to instance termination, for more information please see: [Shutdown Script](https://api.spotinst.com/integration-docs/elastigroup/concepts/compute-concepts/shutdown-scripts/)
|
|
724
|
+
:param pulumi.Input[_builtins.str] startup_script: Create and run your own startup scripts on your virtual machines to perform automated tasks every time your instance boots up.
|
|
612
725
|
:param pulumi.Input[Sequence[pulumi.Input['ElastigroupSubnetArgs']]] subnets: A list of regions and subnets.
|
|
613
|
-
:param pulumi.Input[Sequence[pulumi.Input[str]]] tags: Tags to mark created instances.
|
|
726
|
+
:param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] tags: Tags to mark created instances.
|
|
614
727
|
"""
|
|
615
728
|
if auto_healing is not None:
|
|
616
729
|
pulumi.set(__self__, "auto_healing", auto_healing)
|
|
@@ -657,6 +770,8 @@ class _ElastigroupState:
|
|
|
657
770
|
pulumi.set(__self__, "max_size", max_size)
|
|
658
771
|
if metadatas is not None:
|
|
659
772
|
pulumi.set(__self__, "metadatas", metadatas)
|
|
773
|
+
if min_cpu_platform is not None:
|
|
774
|
+
pulumi.set(__self__, "min_cpu_platform", min_cpu_platform)
|
|
660
775
|
if min_size is not None:
|
|
661
776
|
pulumi.set(__self__, "min_size", min_size)
|
|
662
777
|
if name is not None:
|
|
@@ -665,10 +780,16 @@ class _ElastigroupState:
|
|
|
665
780
|
pulumi.set(__self__, "network_interfaces", network_interfaces)
|
|
666
781
|
if ondemand_count is not None:
|
|
667
782
|
pulumi.set(__self__, "ondemand_count", ondemand_count)
|
|
783
|
+
if optimization_windows is not None:
|
|
784
|
+
pulumi.set(__self__, "optimization_windows", optimization_windows)
|
|
668
785
|
if preemptible_percentage is not None:
|
|
669
786
|
pulumi.set(__self__, "preemptible_percentage", preemptible_percentage)
|
|
787
|
+
if preferred_availability_zones is not None:
|
|
788
|
+
pulumi.set(__self__, "preferred_availability_zones", preferred_availability_zones)
|
|
670
789
|
if provisioning_model is not None:
|
|
671
790
|
pulumi.set(__self__, "provisioning_model", provisioning_model)
|
|
791
|
+
if revert_to_preemptibles is not None:
|
|
792
|
+
pulumi.set(__self__, "revert_to_preemptibles", revert_to_preemptibles)
|
|
672
793
|
if scaling_down_policies is not None:
|
|
673
794
|
pulumi.set(__self__, "scaling_down_policies", scaling_down_policies)
|
|
674
795
|
if scaling_up_policies is not None:
|
|
@@ -677,6 +798,10 @@ class _ElastigroupState:
|
|
|
677
798
|
pulumi.set(__self__, "scheduled_tasks", scheduled_tasks)
|
|
678
799
|
if service_account is not None:
|
|
679
800
|
pulumi.set(__self__, "service_account", service_account)
|
|
801
|
+
if shielded_instance_config is not None:
|
|
802
|
+
pulumi.set(__self__, "shielded_instance_config", shielded_instance_config)
|
|
803
|
+
if should_utilize_commitments is not None:
|
|
804
|
+
pulumi.set(__self__, "should_utilize_commitments", should_utilize_commitments)
|
|
680
805
|
if shutdown_script is not None:
|
|
681
806
|
pulumi.set(__self__, "shutdown_script", shutdown_script)
|
|
682
807
|
if startup_script is not None:
|
|
@@ -688,29 +813,29 @@ class _ElastigroupState:
|
|
|
688
813
|
if unhealthy_duration is not None:
|
|
689
814
|
pulumi.set(__self__, "unhealthy_duration", unhealthy_duration)
|
|
690
815
|
|
|
691
|
-
@property
|
|
816
|
+
@_builtins.property
|
|
692
817
|
@pulumi.getter(name="autoHealing")
|
|
693
|
-
def auto_healing(self) -> Optional[pulumi.Input[bool]]:
|
|
818
|
+
def auto_healing(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
694
819
|
return pulumi.get(self, "auto_healing")
|
|
695
820
|
|
|
696
821
|
@auto_healing.setter
|
|
697
|
-
def auto_healing(self, value: Optional[pulumi.Input[bool]]):
|
|
822
|
+
def auto_healing(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
698
823
|
pulumi.set(self, "auto_healing", value)
|
|
699
824
|
|
|
700
|
-
@property
|
|
825
|
+
@_builtins.property
|
|
701
826
|
@pulumi.getter(name="availabilityZones")
|
|
702
827
|
@_utilities.deprecated("""This field will soon be handled by Region in Subnets""")
|
|
703
|
-
def availability_zones(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
|
|
828
|
+
def availability_zones(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
|
|
704
829
|
"""
|
|
705
830
|
List of availability zones for the group.
|
|
706
831
|
"""
|
|
707
832
|
return pulumi.get(self, "availability_zones")
|
|
708
833
|
|
|
709
834
|
@availability_zones.setter
|
|
710
|
-
def availability_zones(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
|
|
835
|
+
def availability_zones(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]):
|
|
711
836
|
pulumi.set(self, "availability_zones", value)
|
|
712
837
|
|
|
713
|
-
@property
|
|
838
|
+
@_builtins.property
|
|
714
839
|
@pulumi.getter(name="backendServices")
|
|
715
840
|
def backend_services(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupBackendServiceArgs']]]]:
|
|
716
841
|
return pulumi.get(self, "backend_services")
|
|
@@ -719,31 +844,31 @@ class _ElastigroupState:
|
|
|
719
844
|
def backend_services(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupBackendServiceArgs']]]]):
|
|
720
845
|
pulumi.set(self, "backend_services", value)
|
|
721
846
|
|
|
722
|
-
@property
|
|
847
|
+
@_builtins.property
|
|
723
848
|
@pulumi.getter
|
|
724
|
-
def description(self) -> Optional[pulumi.Input[str]]:
|
|
849
|
+
def description(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
725
850
|
"""
|
|
726
851
|
The region your GCP group will be created in.
|
|
727
852
|
"""
|
|
728
853
|
return pulumi.get(self, "description")
|
|
729
854
|
|
|
730
855
|
@description.setter
|
|
731
|
-
def description(self, value: Optional[pulumi.Input[str]]):
|
|
856
|
+
def description(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
732
857
|
pulumi.set(self, "description", value)
|
|
733
858
|
|
|
734
|
-
@property
|
|
859
|
+
@_builtins.property
|
|
735
860
|
@pulumi.getter(name="desiredCapacity")
|
|
736
|
-
def desired_capacity(self) -> Optional[pulumi.Input[int]]:
|
|
861
|
+
def desired_capacity(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
737
862
|
"""
|
|
738
863
|
The desired number of instances the group should have at any time.
|
|
739
864
|
"""
|
|
740
865
|
return pulumi.get(self, "desired_capacity")
|
|
741
866
|
|
|
742
867
|
@desired_capacity.setter
|
|
743
|
-
def desired_capacity(self, value: Optional[pulumi.Input[int]]):
|
|
868
|
+
def desired_capacity(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
744
869
|
pulumi.set(self, "desired_capacity", value)
|
|
745
870
|
|
|
746
|
-
@property
|
|
871
|
+
@_builtins.property
|
|
747
872
|
@pulumi.getter
|
|
748
873
|
def disks(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupDiskArgs']]]]:
|
|
749
874
|
return pulumi.get(self, "disks")
|
|
@@ -752,31 +877,31 @@ class _ElastigroupState:
|
|
|
752
877
|
def disks(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupDiskArgs']]]]):
|
|
753
878
|
pulumi.set(self, "disks", value)
|
|
754
879
|
|
|
755
|
-
@property
|
|
880
|
+
@_builtins.property
|
|
756
881
|
@pulumi.getter(name="drainingTimeout")
|
|
757
|
-
def draining_timeout(self) -> Optional[pulumi.Input[int]]:
|
|
882
|
+
def draining_timeout(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
758
883
|
"""
|
|
759
884
|
Time (seconds) the instance is allowed to run after it is detached from the group. This is to allow the instance time to drain all the current TCP connections before terminating it.
|
|
760
885
|
"""
|
|
761
886
|
return pulumi.get(self, "draining_timeout")
|
|
762
887
|
|
|
763
888
|
@draining_timeout.setter
|
|
764
|
-
def draining_timeout(self, value: Optional[pulumi.Input[int]]):
|
|
889
|
+
def draining_timeout(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
765
890
|
pulumi.set(self, "draining_timeout", value)
|
|
766
891
|
|
|
767
|
-
@property
|
|
892
|
+
@_builtins.property
|
|
768
893
|
@pulumi.getter(name="fallbackToOndemand")
|
|
769
|
-
def fallback_to_ondemand(self) -> Optional[pulumi.Input[bool]]:
|
|
894
|
+
def fallback_to_ondemand(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
770
895
|
"""
|
|
771
896
|
Activate fallback-to-on-demand. When provisioning an instance, if no Preemptible market is available, fallback-to-on-demand will provision an On-Demand instance to maintain the group capacity.
|
|
772
897
|
"""
|
|
773
898
|
return pulumi.get(self, "fallback_to_ondemand")
|
|
774
899
|
|
|
775
900
|
@fallback_to_ondemand.setter
|
|
776
|
-
def fallback_to_ondemand(self, value: Optional[pulumi.Input[bool]]):
|
|
901
|
+
def fallback_to_ondemand(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
777
902
|
pulumi.set(self, "fallback_to_ondemand", value)
|
|
778
903
|
|
|
779
|
-
@property
|
|
904
|
+
@_builtins.property
|
|
780
905
|
@pulumi.getter
|
|
781
906
|
def gpu(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupGpuArgs']]]]:
|
|
782
907
|
return pulumi.get(self, "gpu")
|
|
@@ -785,27 +910,27 @@ class _ElastigroupState:
|
|
|
785
910
|
def gpu(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupGpuArgs']]]]):
|
|
786
911
|
pulumi.set(self, "gpu", value)
|
|
787
912
|
|
|
788
|
-
@property
|
|
913
|
+
@_builtins.property
|
|
789
914
|
@pulumi.getter(name="healthCheckGracePeriod")
|
|
790
|
-
def health_check_grace_period(self) -> Optional[pulumi.Input[int]]:
|
|
915
|
+
def health_check_grace_period(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
791
916
|
return pulumi.get(self, "health_check_grace_period")
|
|
792
917
|
|
|
793
918
|
@health_check_grace_period.setter
|
|
794
|
-
def health_check_grace_period(self, value: Optional[pulumi.Input[int]]):
|
|
919
|
+
def health_check_grace_period(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
795
920
|
pulumi.set(self, "health_check_grace_period", value)
|
|
796
921
|
|
|
797
|
-
@property
|
|
922
|
+
@_builtins.property
|
|
798
923
|
@pulumi.getter(name="healthCheckType")
|
|
799
|
-
def health_check_type(self) -> Optional[pulumi.Input[str]]:
|
|
924
|
+
def health_check_type(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
800
925
|
return pulumi.get(self, "health_check_type")
|
|
801
926
|
|
|
802
927
|
@health_check_type.setter
|
|
803
|
-
def health_check_type(self, value: Optional[pulumi.Input[str]]):
|
|
928
|
+
def health_check_type(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
804
929
|
pulumi.set(self, "health_check_type", value)
|
|
805
930
|
|
|
806
|
-
@property
|
|
931
|
+
@_builtins.property
|
|
807
932
|
@pulumi.getter(name="instanceNamePrefix")
|
|
808
|
-
def instance_name_prefix(self) -> Optional[pulumi.Input[str]]:
|
|
933
|
+
def instance_name_prefix(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
809
934
|
"""
|
|
810
935
|
Set an instance name prefix to be used for all launched instances and their boot disk. The prefix value should comply with the following limitations:
|
|
811
936
|
* A maximal length of 25 characters.
|
|
@@ -814,10 +939,10 @@ class _ElastigroupState:
|
|
|
814
939
|
return pulumi.get(self, "instance_name_prefix")
|
|
815
940
|
|
|
816
941
|
@instance_name_prefix.setter
|
|
817
|
-
def instance_name_prefix(self, value: Optional[pulumi.Input[str]]):
|
|
942
|
+
def instance_name_prefix(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
818
943
|
pulumi.set(self, "instance_name_prefix", value)
|
|
819
944
|
|
|
820
|
-
@property
|
|
945
|
+
@_builtins.property
|
|
821
946
|
@pulumi.getter(name="instanceTypesCustoms")
|
|
822
947
|
def instance_types_customs(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupInstanceTypesCustomArgs']]]]:
|
|
823
948
|
"""
|
|
@@ -830,31 +955,31 @@ class _ElastigroupState:
|
|
|
830
955
|
def instance_types_customs(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupInstanceTypesCustomArgs']]]]):
|
|
831
956
|
pulumi.set(self, "instance_types_customs", value)
|
|
832
957
|
|
|
833
|
-
@property
|
|
958
|
+
@_builtins.property
|
|
834
959
|
@pulumi.getter(name="instanceTypesOndemand")
|
|
835
|
-
def instance_types_ondemand(self) -> Optional[pulumi.Input[str]]:
|
|
960
|
+
def instance_types_ondemand(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
836
961
|
"""
|
|
837
962
|
The regular VM instance type to use for mixed-type groups and when falling back to on-demand. Required if instance_types_preemptible is not set.
|
|
838
963
|
"""
|
|
839
964
|
return pulumi.get(self, "instance_types_ondemand")
|
|
840
965
|
|
|
841
966
|
@instance_types_ondemand.setter
|
|
842
|
-
def instance_types_ondemand(self, value: Optional[pulumi.Input[str]]):
|
|
967
|
+
def instance_types_ondemand(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
843
968
|
pulumi.set(self, "instance_types_ondemand", value)
|
|
844
969
|
|
|
845
|
-
@property
|
|
970
|
+
@_builtins.property
|
|
846
971
|
@pulumi.getter(name="instanceTypesPreemptibles")
|
|
847
|
-
def instance_types_preemptibles(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
|
|
972
|
+
def instance_types_preemptibles(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
|
|
848
973
|
"""
|
|
849
974
|
The preemptible VMs instance type. To maximize cost savings and market availability, select as many types as possible. Required if instance_types_ondemand is not set.
|
|
850
975
|
"""
|
|
851
976
|
return pulumi.get(self, "instance_types_preemptibles")
|
|
852
977
|
|
|
853
978
|
@instance_types_preemptibles.setter
|
|
854
|
-
def instance_types_preemptibles(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
|
|
979
|
+
def instance_types_preemptibles(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]):
|
|
855
980
|
pulumi.set(self, "instance_types_preemptibles", value)
|
|
856
981
|
|
|
857
|
-
@property
|
|
982
|
+
@_builtins.property
|
|
858
983
|
@pulumi.getter(name="integrationDockerSwarm")
|
|
859
984
|
def integration_docker_swarm(self) -> Optional[pulumi.Input['ElastigroupIntegrationDockerSwarmArgs']]:
|
|
860
985
|
return pulumi.get(self, "integration_docker_swarm")
|
|
@@ -863,7 +988,7 @@ class _ElastigroupState:
|
|
|
863
988
|
def integration_docker_swarm(self, value: Optional[pulumi.Input['ElastigroupIntegrationDockerSwarmArgs']]):
|
|
864
989
|
pulumi.set(self, "integration_docker_swarm", value)
|
|
865
990
|
|
|
866
|
-
@property
|
|
991
|
+
@_builtins.property
|
|
867
992
|
@pulumi.getter(name="integrationGke")
|
|
868
993
|
def integration_gke(self) -> Optional[pulumi.Input['ElastigroupIntegrationGkeArgs']]:
|
|
869
994
|
return pulumi.get(self, "integration_gke")
|
|
@@ -872,16 +997,16 @@ class _ElastigroupState:
|
|
|
872
997
|
def integration_gke(self, value: Optional[pulumi.Input['ElastigroupIntegrationGkeArgs']]):
|
|
873
998
|
pulumi.set(self, "integration_gke", value)
|
|
874
999
|
|
|
875
|
-
@property
|
|
1000
|
+
@_builtins.property
|
|
876
1001
|
@pulumi.getter(name="ipForwarding")
|
|
877
|
-
def ip_forwarding(self) -> Optional[pulumi.Input[bool]]:
|
|
1002
|
+
def ip_forwarding(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
878
1003
|
return pulumi.get(self, "ip_forwarding")
|
|
879
1004
|
|
|
880
1005
|
@ip_forwarding.setter
|
|
881
|
-
def ip_forwarding(self, value: Optional[pulumi.Input[bool]]):
|
|
1006
|
+
def ip_forwarding(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
882
1007
|
pulumi.set(self, "ip_forwarding", value)
|
|
883
1008
|
|
|
884
|
-
@property
|
|
1009
|
+
@_builtins.property
|
|
885
1010
|
@pulumi.getter
|
|
886
1011
|
def labels(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupLabelArgs']]]]:
|
|
887
1012
|
"""
|
|
@@ -893,19 +1018,19 @@ class _ElastigroupState:
|
|
|
893
1018
|
def labels(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupLabelArgs']]]]):
|
|
894
1019
|
pulumi.set(self, "labels", value)
|
|
895
1020
|
|
|
896
|
-
@property
|
|
1021
|
+
@_builtins.property
|
|
897
1022
|
@pulumi.getter(name="maxSize")
|
|
898
|
-
def max_size(self) -> Optional[pulumi.Input[int]]:
|
|
1023
|
+
def max_size(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
899
1024
|
"""
|
|
900
1025
|
The maximum number of instances the group should have at any time.
|
|
901
1026
|
"""
|
|
902
1027
|
return pulumi.get(self, "max_size")
|
|
903
1028
|
|
|
904
1029
|
@max_size.setter
|
|
905
|
-
def max_size(self, value: Optional[pulumi.Input[int]]):
|
|
1030
|
+
def max_size(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
906
1031
|
pulumi.set(self, "max_size", value)
|
|
907
1032
|
|
|
908
|
-
@property
|
|
1033
|
+
@_builtins.property
|
|
909
1034
|
@pulumi.getter
|
|
910
1035
|
def metadatas(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupMetadataArgs']]]]:
|
|
911
1036
|
"""
|
|
@@ -917,31 +1042,43 @@ class _ElastigroupState:
|
|
|
917
1042
|
def metadatas(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupMetadataArgs']]]]):
|
|
918
1043
|
pulumi.set(self, "metadatas", value)
|
|
919
1044
|
|
|
920
|
-
@property
|
|
1045
|
+
@_builtins.property
|
|
1046
|
+
@pulumi.getter(name="minCpuPlatform")
|
|
1047
|
+
def min_cpu_platform(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
1048
|
+
"""
|
|
1049
|
+
Select a minimum CPU platform for the compute instance.
|
|
1050
|
+
"""
|
|
1051
|
+
return pulumi.get(self, "min_cpu_platform")
|
|
1052
|
+
|
|
1053
|
+
@min_cpu_platform.setter
|
|
1054
|
+
def min_cpu_platform(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
1055
|
+
pulumi.set(self, "min_cpu_platform", value)
|
|
1056
|
+
|
|
1057
|
+
@_builtins.property
|
|
921
1058
|
@pulumi.getter(name="minSize")
|
|
922
|
-
def min_size(self) -> Optional[pulumi.Input[int]]:
|
|
1059
|
+
def min_size(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
923
1060
|
"""
|
|
924
1061
|
The minimum number of instances the group should have at any time.
|
|
925
1062
|
"""
|
|
926
1063
|
return pulumi.get(self, "min_size")
|
|
927
1064
|
|
|
928
1065
|
@min_size.setter
|
|
929
|
-
def min_size(self, value: Optional[pulumi.Input[int]]):
|
|
1066
|
+
def min_size(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
930
1067
|
pulumi.set(self, "min_size", value)
|
|
931
1068
|
|
|
932
|
-
@property
|
|
1069
|
+
@_builtins.property
|
|
933
1070
|
@pulumi.getter
|
|
934
|
-
def name(self) -> Optional[pulumi.Input[str]]:
|
|
1071
|
+
def name(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
935
1072
|
"""
|
|
936
1073
|
The group name.
|
|
937
1074
|
"""
|
|
938
1075
|
return pulumi.get(self, "name")
|
|
939
1076
|
|
|
940
1077
|
@name.setter
|
|
941
|
-
def name(self, value: Optional[pulumi.Input[str]]):
|
|
1078
|
+
def name(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
942
1079
|
pulumi.set(self, "name", value)
|
|
943
1080
|
|
|
944
|
-
@property
|
|
1081
|
+
@_builtins.property
|
|
945
1082
|
@pulumi.getter(name="networkInterfaces")
|
|
946
1083
|
def network_interfaces(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupNetworkInterfaceArgs']]]]:
|
|
947
1084
|
return pulumi.get(self, "network_interfaces")
|
|
@@ -950,40 +1087,76 @@ class _ElastigroupState:
|
|
|
950
1087
|
def network_interfaces(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupNetworkInterfaceArgs']]]]):
|
|
951
1088
|
pulumi.set(self, "network_interfaces", value)
|
|
952
1089
|
|
|
953
|
-
@property
|
|
1090
|
+
@_builtins.property
|
|
954
1091
|
@pulumi.getter(name="ondemandCount")
|
|
955
|
-
def ondemand_count(self) -> Optional[pulumi.Input[int]]:
|
|
1092
|
+
def ondemand_count(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
956
1093
|
return pulumi.get(self, "ondemand_count")
|
|
957
1094
|
|
|
958
1095
|
@ondemand_count.setter
|
|
959
|
-
def ondemand_count(self, value: Optional[pulumi.Input[int]]):
|
|
1096
|
+
def ondemand_count(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
960
1097
|
pulumi.set(self, "ondemand_count", value)
|
|
961
1098
|
|
|
962
|
-
@property
|
|
1099
|
+
@_builtins.property
|
|
1100
|
+
@pulumi.getter(name="optimizationWindows")
|
|
1101
|
+
def optimization_windows(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
|
|
1102
|
+
"""
|
|
1103
|
+
Set time window to perform the revert to preemptible. Time windows must be at least 120 minutes. Format: DayInWeek:HH-DayInWeek:HH. Required when strategy.revertToPreemptible.performAt is 'timeWindow'.
|
|
1104
|
+
"""
|
|
1105
|
+
return pulumi.get(self, "optimization_windows")
|
|
1106
|
+
|
|
1107
|
+
@optimization_windows.setter
|
|
1108
|
+
def optimization_windows(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]):
|
|
1109
|
+
pulumi.set(self, "optimization_windows", value)
|
|
1110
|
+
|
|
1111
|
+
@_builtins.property
|
|
963
1112
|
@pulumi.getter(name="preemptiblePercentage")
|
|
964
|
-
def preemptible_percentage(self) -> Optional[pulumi.Input[int]]:
|
|
1113
|
+
def preemptible_percentage(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
965
1114
|
"""
|
|
966
1115
|
Percentage of Preemptible VMs to spin up from the "desired_capacity".
|
|
967
1116
|
"""
|
|
968
1117
|
return pulumi.get(self, "preemptible_percentage")
|
|
969
1118
|
|
|
970
1119
|
@preemptible_percentage.setter
|
|
971
|
-
def preemptible_percentage(self, value: Optional[pulumi.Input[int]]):
|
|
1120
|
+
def preemptible_percentage(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
972
1121
|
pulumi.set(self, "preemptible_percentage", value)
|
|
973
1122
|
|
|
974
|
-
@property
|
|
1123
|
+
@_builtins.property
|
|
1124
|
+
@pulumi.getter(name="preferredAvailabilityZones")
|
|
1125
|
+
def preferred_availability_zones(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
|
|
1126
|
+
"""
|
|
1127
|
+
prioritize availability zones when launching instances for the group. Must be a sublist of `availability_zones`.
|
|
1128
|
+
"""
|
|
1129
|
+
return pulumi.get(self, "preferred_availability_zones")
|
|
1130
|
+
|
|
1131
|
+
@preferred_availability_zones.setter
|
|
1132
|
+
def preferred_availability_zones(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]):
|
|
1133
|
+
pulumi.set(self, "preferred_availability_zones", value)
|
|
1134
|
+
|
|
1135
|
+
@_builtins.property
|
|
975
1136
|
@pulumi.getter(name="provisioningModel")
|
|
976
|
-
def provisioning_model(self) -> Optional[pulumi.Input[str]]:
|
|
1137
|
+
def provisioning_model(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
977
1138
|
"""
|
|
978
1139
|
Valid values: "SPOT", "PREEMPTIBLE". Define the provisioning model of the launched instances. Default value is "PREEMPTIBLE".
|
|
979
1140
|
"""
|
|
980
1141
|
return pulumi.get(self, "provisioning_model")
|
|
981
1142
|
|
|
982
1143
|
@provisioning_model.setter
|
|
983
|
-
def provisioning_model(self, value: Optional[pulumi.Input[str]]):
|
|
1144
|
+
def provisioning_model(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
984
1145
|
pulumi.set(self, "provisioning_model", value)
|
|
985
1146
|
|
|
986
|
-
@property
|
|
1147
|
+
@_builtins.property
|
|
1148
|
+
@pulumi.getter(name="revertToPreemptibles")
|
|
1149
|
+
def revert_to_preemptibles(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupRevertToPreemptibleArgs']]]]:
|
|
1150
|
+
"""
|
|
1151
|
+
Setting for revert to preemptible option.
|
|
1152
|
+
"""
|
|
1153
|
+
return pulumi.get(self, "revert_to_preemptibles")
|
|
1154
|
+
|
|
1155
|
+
@revert_to_preemptibles.setter
|
|
1156
|
+
def revert_to_preemptibles(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupRevertToPreemptibleArgs']]]]):
|
|
1157
|
+
pulumi.set(self, "revert_to_preemptibles", value)
|
|
1158
|
+
|
|
1159
|
+
@_builtins.property
|
|
987
1160
|
@pulumi.getter(name="scalingDownPolicies")
|
|
988
1161
|
def scaling_down_policies(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupScalingDownPolicyArgs']]]]:
|
|
989
1162
|
return pulumi.get(self, "scaling_down_policies")
|
|
@@ -992,7 +1165,7 @@ class _ElastigroupState:
|
|
|
992
1165
|
def scaling_down_policies(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupScalingDownPolicyArgs']]]]):
|
|
993
1166
|
pulumi.set(self, "scaling_down_policies", value)
|
|
994
1167
|
|
|
995
|
-
@property
|
|
1168
|
+
@_builtins.property
|
|
996
1169
|
@pulumi.getter(name="scalingUpPolicies")
|
|
997
1170
|
def scaling_up_policies(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupScalingUpPolicyArgs']]]]:
|
|
998
1171
|
return pulumi.get(self, "scaling_up_policies")
|
|
@@ -1001,7 +1174,7 @@ class _ElastigroupState:
|
|
|
1001
1174
|
def scaling_up_policies(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupScalingUpPolicyArgs']]]]):
|
|
1002
1175
|
pulumi.set(self, "scaling_up_policies", value)
|
|
1003
1176
|
|
|
1004
|
-
@property
|
|
1177
|
+
@_builtins.property
|
|
1005
1178
|
@pulumi.getter(name="scheduledTasks")
|
|
1006
1179
|
def scheduled_tasks(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupScheduledTaskArgs']]]]:
|
|
1007
1180
|
return pulumi.get(self, "scheduled_tasks")
|
|
@@ -1010,43 +1183,67 @@ class _ElastigroupState:
|
|
|
1010
1183
|
def scheduled_tasks(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupScheduledTaskArgs']]]]):
|
|
1011
1184
|
pulumi.set(self, "scheduled_tasks", value)
|
|
1012
1185
|
|
|
1013
|
-
@property
|
|
1186
|
+
@_builtins.property
|
|
1014
1187
|
@pulumi.getter(name="serviceAccount")
|
|
1015
|
-
def service_account(self) -> Optional[pulumi.Input[str]]:
|
|
1188
|
+
def service_account(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
1016
1189
|
"""
|
|
1017
1190
|
The email of the service account in which the group instances will be launched.
|
|
1018
1191
|
"""
|
|
1019
1192
|
return pulumi.get(self, "service_account")
|
|
1020
1193
|
|
|
1021
1194
|
@service_account.setter
|
|
1022
|
-
def service_account(self, value: Optional[pulumi.Input[str]]):
|
|
1195
|
+
def service_account(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
1023
1196
|
pulumi.set(self, "service_account", value)
|
|
1024
1197
|
|
|
1025
|
-
@property
|
|
1198
|
+
@_builtins.property
|
|
1199
|
+
@pulumi.getter(name="shieldedInstanceConfig")
|
|
1200
|
+
def shielded_instance_config(self) -> Optional[pulumi.Input['ElastigroupShieldedInstanceConfigArgs']]:
|
|
1201
|
+
"""
|
|
1202
|
+
You can use secure boot when you launch VMs using Elastigroup. This helps you comply with your security policies. In the instance configuration, use ‘secureBootEnabled’ set to True to enforce UEFI with secure boot. Elastigroup provisions VMs with secure boot, as long as the images supports UEFI.
|
|
1203
|
+
"""
|
|
1204
|
+
return pulumi.get(self, "shielded_instance_config")
|
|
1205
|
+
|
|
1206
|
+
@shielded_instance_config.setter
|
|
1207
|
+
def shielded_instance_config(self, value: Optional[pulumi.Input['ElastigroupShieldedInstanceConfigArgs']]):
|
|
1208
|
+
pulumi.set(self, "shielded_instance_config", value)
|
|
1209
|
+
|
|
1210
|
+
@_builtins.property
|
|
1211
|
+
@pulumi.getter(name="shouldUtilizeCommitments")
|
|
1212
|
+
def should_utilize_commitments(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
1213
|
+
"""
|
|
1214
|
+
Enable committed use discounts utilization.
|
|
1215
|
+
"""
|
|
1216
|
+
return pulumi.get(self, "should_utilize_commitments")
|
|
1217
|
+
|
|
1218
|
+
@should_utilize_commitments.setter
|
|
1219
|
+
def should_utilize_commitments(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
1220
|
+
pulumi.set(self, "should_utilize_commitments", value)
|
|
1221
|
+
|
|
1222
|
+
@_builtins.property
|
|
1026
1223
|
@pulumi.getter(name="shutdownScript")
|
|
1027
|
-
def shutdown_script(self) -> Optional[pulumi.Input[str]]:
|
|
1224
|
+
def shutdown_script(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
1028
1225
|
"""
|
|
1029
1226
|
The Base64-encoded shutdown script that executes prior to instance termination, for more information please see: [Shutdown Script](https://api.spotinst.com/integration-docs/elastigroup/concepts/compute-concepts/shutdown-scripts/)
|
|
1030
1227
|
"""
|
|
1031
1228
|
return pulumi.get(self, "shutdown_script")
|
|
1032
1229
|
|
|
1033
1230
|
@shutdown_script.setter
|
|
1034
|
-
def shutdown_script(self, value: Optional[pulumi.Input[str]]):
|
|
1231
|
+
def shutdown_script(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
1035
1232
|
pulumi.set(self, "shutdown_script", value)
|
|
1036
1233
|
|
|
1037
|
-
@property
|
|
1234
|
+
@_builtins.property
|
|
1038
1235
|
@pulumi.getter(name="startupScript")
|
|
1039
|
-
def startup_script(self) -> Optional[pulumi.Input[str]]:
|
|
1236
|
+
def startup_script(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
1040
1237
|
"""
|
|
1041
1238
|
Create and run your own startup scripts on your virtual machines to perform automated tasks every time your instance boots up.
|
|
1042
1239
|
"""
|
|
1043
1240
|
return pulumi.get(self, "startup_script")
|
|
1044
1241
|
|
|
1045
1242
|
@startup_script.setter
|
|
1046
|
-
def startup_script(self, value: Optional[pulumi.Input[str]]):
|
|
1243
|
+
def startup_script(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
1047
1244
|
pulumi.set(self, "startup_script", value)
|
|
1048
1245
|
|
|
1049
|
-
@property
|
|
1246
|
+
@_builtins.property
|
|
1050
1247
|
@pulumi.getter
|
|
1051
1248
|
def subnets(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupSubnetArgs']]]]:
|
|
1052
1249
|
"""
|
|
@@ -1058,69 +1255,76 @@ class _ElastigroupState:
|
|
|
1058
1255
|
def subnets(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupSubnetArgs']]]]):
|
|
1059
1256
|
pulumi.set(self, "subnets", value)
|
|
1060
1257
|
|
|
1061
|
-
@property
|
|
1258
|
+
@_builtins.property
|
|
1062
1259
|
@pulumi.getter
|
|
1063
|
-
def tags(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
|
|
1260
|
+
def tags(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
|
|
1064
1261
|
"""
|
|
1065
1262
|
Tags to mark created instances.
|
|
1066
1263
|
"""
|
|
1067
1264
|
return pulumi.get(self, "tags")
|
|
1068
1265
|
|
|
1069
1266
|
@tags.setter
|
|
1070
|
-
def tags(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
|
|
1267
|
+
def tags(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]):
|
|
1071
1268
|
pulumi.set(self, "tags", value)
|
|
1072
1269
|
|
|
1073
|
-
@property
|
|
1270
|
+
@_builtins.property
|
|
1074
1271
|
@pulumi.getter(name="unhealthyDuration")
|
|
1075
|
-
def unhealthy_duration(self) -> Optional[pulumi.Input[int]]:
|
|
1272
|
+
def unhealthy_duration(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
1076
1273
|
return pulumi.get(self, "unhealthy_duration")
|
|
1077
1274
|
|
|
1078
1275
|
@unhealthy_duration.setter
|
|
1079
|
-
def unhealthy_duration(self, value: Optional[pulumi.Input[int]]):
|
|
1276
|
+
def unhealthy_duration(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
1080
1277
|
pulumi.set(self, "unhealthy_duration", value)
|
|
1081
1278
|
|
|
1082
1279
|
|
|
1280
|
+
@pulumi.type_token("spotinst:gcp/elastigroup:Elastigroup")
|
|
1083
1281
|
class Elastigroup(pulumi.CustomResource):
|
|
1084
1282
|
@overload
|
|
1085
1283
|
def __init__(__self__,
|
|
1086
1284
|
resource_name: str,
|
|
1087
1285
|
opts: Optional[pulumi.ResourceOptions] = None,
|
|
1088
|
-
auto_healing: Optional[pulumi.Input[bool]] = None,
|
|
1089
|
-
availability_zones: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
|
|
1090
|
-
backend_services: Optional[pulumi.Input[Sequence[pulumi.Input[
|
|
1091
|
-
description: Optional[pulumi.Input[str]] = None,
|
|
1092
|
-
desired_capacity: Optional[pulumi.Input[int]] = None,
|
|
1093
|
-
disks: Optional[pulumi.Input[Sequence[pulumi.Input[
|
|
1094
|
-
draining_timeout: Optional[pulumi.Input[int]] = None,
|
|
1095
|
-
fallback_to_ondemand: Optional[pulumi.Input[bool]] = None,
|
|
1096
|
-
gpu: Optional[pulumi.Input[Sequence[pulumi.Input[
|
|
1097
|
-
health_check_grace_period: Optional[pulumi.Input[int]] = None,
|
|
1098
|
-
health_check_type: Optional[pulumi.Input[str]] = None,
|
|
1099
|
-
instance_name_prefix: Optional[pulumi.Input[str]] = None,
|
|
1100
|
-
instance_types_customs: Optional[pulumi.Input[Sequence[pulumi.Input[
|
|
1101
|
-
instance_types_ondemand: Optional[pulumi.Input[str]] = None,
|
|
1102
|
-
instance_types_preemptibles: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
|
|
1103
|
-
integration_docker_swarm: Optional[pulumi.Input[
|
|
1104
|
-
integration_gke: Optional[pulumi.Input[
|
|
1105
|
-
ip_forwarding: Optional[pulumi.Input[bool]] = None,
|
|
1106
|
-
labels: Optional[pulumi.Input[Sequence[pulumi.Input[
|
|
1107
|
-
max_size: Optional[pulumi.Input[int]] = None,
|
|
1108
|
-
metadatas: Optional[pulumi.Input[Sequence[pulumi.Input[
|
|
1109
|
-
|
|
1110
|
-
|
|
1111
|
-
|
|
1112
|
-
|
|
1113
|
-
|
|
1114
|
-
|
|
1115
|
-
|
|
1116
|
-
|
|
1117
|
-
|
|
1118
|
-
|
|
1119
|
-
|
|
1120
|
-
|
|
1121
|
-
|
|
1122
|
-
|
|
1123
|
-
|
|
1286
|
+
auto_healing: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
1287
|
+
availability_zones: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
1288
|
+
backend_services: Optional[pulumi.Input[Sequence[pulumi.Input[Union['ElastigroupBackendServiceArgs', 'ElastigroupBackendServiceArgsDict']]]]] = None,
|
|
1289
|
+
description: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1290
|
+
desired_capacity: Optional[pulumi.Input[_builtins.int]] = None,
|
|
1291
|
+
disks: Optional[pulumi.Input[Sequence[pulumi.Input[Union['ElastigroupDiskArgs', 'ElastigroupDiskArgsDict']]]]] = None,
|
|
1292
|
+
draining_timeout: Optional[pulumi.Input[_builtins.int]] = None,
|
|
1293
|
+
fallback_to_ondemand: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
1294
|
+
gpu: Optional[pulumi.Input[Sequence[pulumi.Input[Union['ElastigroupGpuArgs', 'ElastigroupGpuArgsDict']]]]] = None,
|
|
1295
|
+
health_check_grace_period: Optional[pulumi.Input[_builtins.int]] = None,
|
|
1296
|
+
health_check_type: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1297
|
+
instance_name_prefix: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1298
|
+
instance_types_customs: Optional[pulumi.Input[Sequence[pulumi.Input[Union['ElastigroupInstanceTypesCustomArgs', 'ElastigroupInstanceTypesCustomArgsDict']]]]] = None,
|
|
1299
|
+
instance_types_ondemand: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1300
|
+
instance_types_preemptibles: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
1301
|
+
integration_docker_swarm: Optional[pulumi.Input[Union['ElastigroupIntegrationDockerSwarmArgs', 'ElastigroupIntegrationDockerSwarmArgsDict']]] = None,
|
|
1302
|
+
integration_gke: Optional[pulumi.Input[Union['ElastigroupIntegrationGkeArgs', 'ElastigroupIntegrationGkeArgsDict']]] = None,
|
|
1303
|
+
ip_forwarding: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
1304
|
+
labels: Optional[pulumi.Input[Sequence[pulumi.Input[Union['ElastigroupLabelArgs', 'ElastigroupLabelArgsDict']]]]] = None,
|
|
1305
|
+
max_size: Optional[pulumi.Input[_builtins.int]] = None,
|
|
1306
|
+
metadatas: Optional[pulumi.Input[Sequence[pulumi.Input[Union['ElastigroupMetadataArgs', 'ElastigroupMetadataArgsDict']]]]] = None,
|
|
1307
|
+
min_cpu_platform: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1308
|
+
min_size: Optional[pulumi.Input[_builtins.int]] = None,
|
|
1309
|
+
name: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1310
|
+
network_interfaces: Optional[pulumi.Input[Sequence[pulumi.Input[Union['ElastigroupNetworkInterfaceArgs', 'ElastigroupNetworkInterfaceArgsDict']]]]] = None,
|
|
1311
|
+
ondemand_count: Optional[pulumi.Input[_builtins.int]] = None,
|
|
1312
|
+
optimization_windows: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
1313
|
+
preemptible_percentage: Optional[pulumi.Input[_builtins.int]] = None,
|
|
1314
|
+
preferred_availability_zones: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
1315
|
+
provisioning_model: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1316
|
+
revert_to_preemptibles: Optional[pulumi.Input[Sequence[pulumi.Input[Union['ElastigroupRevertToPreemptibleArgs', 'ElastigroupRevertToPreemptibleArgsDict']]]]] = None,
|
|
1317
|
+
scaling_down_policies: Optional[pulumi.Input[Sequence[pulumi.Input[Union['ElastigroupScalingDownPolicyArgs', 'ElastigroupScalingDownPolicyArgsDict']]]]] = None,
|
|
1318
|
+
scaling_up_policies: Optional[pulumi.Input[Sequence[pulumi.Input[Union['ElastigroupScalingUpPolicyArgs', 'ElastigroupScalingUpPolicyArgsDict']]]]] = None,
|
|
1319
|
+
scheduled_tasks: Optional[pulumi.Input[Sequence[pulumi.Input[Union['ElastigroupScheduledTaskArgs', 'ElastigroupScheduledTaskArgsDict']]]]] = None,
|
|
1320
|
+
service_account: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1321
|
+
shielded_instance_config: Optional[pulumi.Input[Union['ElastigroupShieldedInstanceConfigArgs', 'ElastigroupShieldedInstanceConfigArgsDict']]] = None,
|
|
1322
|
+
should_utilize_commitments: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
1323
|
+
shutdown_script: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1324
|
+
startup_script: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1325
|
+
subnets: Optional[pulumi.Input[Sequence[pulumi.Input[Union['ElastigroupSubnetArgs', 'ElastigroupSubnetArgsDict']]]]] = None,
|
|
1326
|
+
tags: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
1327
|
+
unhealthy_duration: Optional[pulumi.Input[_builtins.int]] = None,
|
|
1124
1328
|
__props__=None):
|
|
1125
1329
|
"""
|
|
1126
1330
|
Provides a Spotinst elastigroup GCP resource.
|
|
@@ -1137,6 +1341,7 @@ class Elastigroup(pulumi.CustomResource):
|
|
|
1137
1341
|
service_account="example@myProject.iam.gservicecct.com",
|
|
1138
1342
|
startup_script="",
|
|
1139
1343
|
instance_name_prefix="test-123a",
|
|
1344
|
+
min_cpu_platform="Intel Sandy Bridge",
|
|
1140
1345
|
min_size=0,
|
|
1141
1346
|
max_size=1,
|
|
1142
1347
|
desired_capacity=1,
|
|
@@ -1144,106 +1349,126 @@ class Elastigroup(pulumi.CustomResource):
|
|
|
1144
1349
|
"asia-east1-c",
|
|
1145
1350
|
"us-central1-a",
|
|
1146
1351
|
],
|
|
1352
|
+
preferred_availability_zones=["us-central1-a"],
|
|
1147
1353
|
preemptible_percentage=50,
|
|
1354
|
+
revert_to_preemptibles=[{
|
|
1355
|
+
"perform_at": "timeWindow",
|
|
1356
|
+
}],
|
|
1357
|
+
optimization_windows=["Mon:01:00-Mon:03:00"],
|
|
1148
1358
|
fallback_to_ondemand=True,
|
|
1149
1359
|
draining_timeout=180,
|
|
1150
1360
|
provisioning_model="SPOT",
|
|
1151
|
-
|
|
1152
|
-
|
|
1153
|
-
|
|
1154
|
-
|
|
1361
|
+
should_utilize_commitments=True,
|
|
1362
|
+
labels=[{
|
|
1363
|
+
"key": "test_key",
|
|
1364
|
+
"value": "test_value",
|
|
1365
|
+
}],
|
|
1155
1366
|
tags=[
|
|
1156
1367
|
"http",
|
|
1157
1368
|
"https",
|
|
1158
1369
|
],
|
|
1159
|
-
backend_services=[
|
|
1160
|
-
service_name
|
|
1161
|
-
location_type
|
|
1162
|
-
scheme
|
|
1163
|
-
named_ports
|
|
1164
|
-
name
|
|
1165
|
-
ports
|
|
1370
|
+
backend_services=[{
|
|
1371
|
+
"service_name": "spotinst-elb-backend-service",
|
|
1372
|
+
"location_type": "regional",
|
|
1373
|
+
"scheme": "INTERNAL",
|
|
1374
|
+
"named_ports": [{
|
|
1375
|
+
"name": "port-name",
|
|
1376
|
+
"ports": [
|
|
1166
1377
|
"8000",
|
|
1167
1378
|
"6000",
|
|
1168
1379
|
],
|
|
1169
|
-
|
|
1170
|
-
|
|
1171
|
-
|
|
1172
|
-
|
|
1173
|
-
|
|
1174
|
-
|
|
1175
|
-
|
|
1176
|
-
|
|
1177
|
-
|
|
1178
|
-
|
|
1179
|
-
|
|
1180
|
-
|
|
1181
|
-
|
|
1182
|
-
|
|
1183
|
-
|
|
1184
|
-
|
|
1185
|
-
|
|
1186
|
-
|
|
1380
|
+
}],
|
|
1381
|
+
"backend_balancing": {
|
|
1382
|
+
"backend_balancing_mode": "RATE",
|
|
1383
|
+
"max_rate_per_instance": 500,
|
|
1384
|
+
},
|
|
1385
|
+
}],
|
|
1386
|
+
disks=[{
|
|
1387
|
+
"device_name": "device",
|
|
1388
|
+
"mode": "READ_WRITE",
|
|
1389
|
+
"type": "PERSISTENT",
|
|
1390
|
+
"auto_delete": True,
|
|
1391
|
+
"boot": True,
|
|
1392
|
+
"interface": "SCSI",
|
|
1393
|
+
"initialize_params": [{
|
|
1394
|
+
"disk_size_gb": "10",
|
|
1395
|
+
"disk_type": "pd-standard",
|
|
1396
|
+
"source_image": "",
|
|
1397
|
+
}],
|
|
1398
|
+
}],
|
|
1399
|
+
shielded_instance_config={
|
|
1400
|
+
"enable_secure_boot": True,
|
|
1401
|
+
"enable_integrity_monitoring": False,
|
|
1402
|
+
},
|
|
1403
|
+
network_interfaces=[{
|
|
1404
|
+
"network": "spot-network",
|
|
1405
|
+
}],
|
|
1187
1406
|
instance_types_ondemand="n1-standard-1",
|
|
1188
1407
|
instance_types_preemptibles=[
|
|
1189
1408
|
"n1-standard-1",
|
|
1190
1409
|
"n1-standard-2",
|
|
1191
1410
|
],
|
|
1192
|
-
instance_types_customs=[
|
|
1193
|
-
vcpu
|
|
1194
|
-
memory_gib
|
|
1195
|
-
|
|
1196
|
-
subnets=[
|
|
1197
|
-
region
|
|
1198
|
-
subnet_names
|
|
1199
|
-
|
|
1200
|
-
scaling_up_policies=[
|
|
1201
|
-
policy_name
|
|
1202
|
-
source
|
|
1203
|
-
metric_name
|
|
1204
|
-
namespace
|
|
1205
|
-
statistic
|
|
1206
|
-
unit
|
|
1207
|
-
threshold
|
|
1208
|
-
period
|
|
1209
|
-
cooldown
|
|
1210
|
-
operator
|
|
1211
|
-
evaluation_periods
|
|
1212
|
-
action_type
|
|
1213
|
-
adjustment
|
|
1214
|
-
dimensions
|
|
1215
|
-
name
|
|
1216
|
-
value
|
|
1217
|
-
|
|
1218
|
-
|
|
1411
|
+
instance_types_customs=[{
|
|
1412
|
+
"vcpu": 2,
|
|
1413
|
+
"memory_gib": 7,
|
|
1414
|
+
}],
|
|
1415
|
+
subnets=[{
|
|
1416
|
+
"region": "asia-east1",
|
|
1417
|
+
"subnet_names": ["default"],
|
|
1418
|
+
}],
|
|
1419
|
+
scaling_up_policies=[{
|
|
1420
|
+
"policy_name": "scale_up_1",
|
|
1421
|
+
"source": "stackdriver",
|
|
1422
|
+
"metric_name": "instance/disk/read_ops_count",
|
|
1423
|
+
"namespace": "compute",
|
|
1424
|
+
"statistic": "average",
|
|
1425
|
+
"unit": "percent",
|
|
1426
|
+
"threshold": 10000,
|
|
1427
|
+
"period": 300,
|
|
1428
|
+
"cooldown": 300,
|
|
1429
|
+
"operator": "gte",
|
|
1430
|
+
"evaluation_periods": 1,
|
|
1431
|
+
"action_type": "adjustment",
|
|
1432
|
+
"adjustment": 1,
|
|
1433
|
+
"dimensions": [{
|
|
1434
|
+
"name": "storage_type",
|
|
1435
|
+
"value": "pd-ssd",
|
|
1436
|
+
}],
|
|
1437
|
+
}])
|
|
1219
1438
|
```
|
|
1220
1439
|
|
|
1221
1440
|
:param str resource_name: The name of the resource.
|
|
1222
1441
|
:param pulumi.ResourceOptions opts: Options for the resource.
|
|
1223
|
-
:param pulumi.Input[Sequence[pulumi.Input[str]]] availability_zones: List of availability zones for the group.
|
|
1224
|
-
:param pulumi.Input[str] description: The region your GCP group will be created in.
|
|
1225
|
-
:param pulumi.Input[int] desired_capacity: The desired number of instances the group should have at any time.
|
|
1226
|
-
:param pulumi.Input[int] draining_timeout: Time (seconds) the instance is allowed to run after it is detached from the group. This is to allow the instance time to drain all the current TCP connections before terminating it.
|
|
1227
|
-
:param pulumi.Input[bool] fallback_to_ondemand: Activate fallback-to-on-demand. When provisioning an instance, if no Preemptible market is available, fallback-to-on-demand will provision an On-Demand instance to maintain the group capacity.
|
|
1228
|
-
:param pulumi.Input[str] instance_name_prefix: Set an instance name prefix to be used for all launched instances and their boot disk. The prefix value should comply with the following limitations:
|
|
1442
|
+
:param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] availability_zones: List of availability zones for the group.
|
|
1443
|
+
:param pulumi.Input[_builtins.str] description: The region your GCP group will be created in.
|
|
1444
|
+
:param pulumi.Input[_builtins.int] desired_capacity: The desired number of instances the group should have at any time.
|
|
1445
|
+
:param pulumi.Input[_builtins.int] draining_timeout: Time (seconds) the instance is allowed to run after it is detached from the group. This is to allow the instance time to drain all the current TCP connections before terminating it.
|
|
1446
|
+
:param pulumi.Input[_builtins.bool] fallback_to_ondemand: Activate fallback-to-on-demand. When provisioning an instance, if no Preemptible market is available, fallback-to-on-demand will provision an On-Demand instance to maintain the group capacity.
|
|
1447
|
+
:param pulumi.Input[_builtins.str] instance_name_prefix: Set an instance name prefix to be used for all launched instances and their boot disk. The prefix value should comply with the following limitations:
|
|
1229
1448
|
* A maximal length of 25 characters.
|
|
1230
1449
|
* The first character must be a lowercase letter, and all the following characters must be hyphens, lowercase letters, or digits, except the last character, which cannot be a hyphen.
|
|
1231
|
-
:param pulumi.Input[Sequence[pulumi.Input[
|
|
1450
|
+
:param pulumi.Input[Sequence[pulumi.Input[Union['ElastigroupInstanceTypesCustomArgs', 'ElastigroupInstanceTypesCustomArgsDict']]]] instance_types_customs: Defines a set of custom instance types. Required if instance_types_preemptible and instance_types_ondemand are not set.
|
|
1232
1451
|
* `vCPU` - (Optional) The number of vCPUs in the custom instance type. GCP has a number of limitations on accepted vCPU values. For more information, see the GCP documentation (here.)[https://cloud.google.com/compute/docs/instances/creating-instance-with-custom-machine-type#specifications]
|
|
1233
|
-
:param pulumi.Input[str] instance_types_ondemand: The regular VM instance type to use for mixed-type groups and when falling back to on-demand. Required if instance_types_preemptible is not set.
|
|
1234
|
-
:param pulumi.Input[Sequence[pulumi.Input[str]]] instance_types_preemptibles: The preemptible VMs instance type. To maximize cost savings and market availability, select as many types as possible. Required if instance_types_ondemand is not set.
|
|
1235
|
-
:param pulumi.Input[Sequence[pulumi.Input[
|
|
1236
|
-
:param pulumi.Input[int] max_size: The maximum number of instances the group should have at any time.
|
|
1237
|
-
:param pulumi.Input[Sequence[pulumi.Input[
|
|
1238
|
-
:param pulumi.Input[
|
|
1239
|
-
:param pulumi.Input[
|
|
1240
|
-
:param pulumi.Input[
|
|
1241
|
-
:param pulumi.Input[str]
|
|
1242
|
-
:param pulumi.Input[
|
|
1243
|
-
:param pulumi.Input[str]
|
|
1244
|
-
:param pulumi.Input[str]
|
|
1245
|
-
:param pulumi.Input[Sequence[pulumi.Input[
|
|
1246
|
-
:param pulumi.Input[
|
|
1452
|
+
:param pulumi.Input[_builtins.str] instance_types_ondemand: The regular VM instance type to use for mixed-type groups and when falling back to on-demand. Required if instance_types_preemptible is not set.
|
|
1453
|
+
:param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] instance_types_preemptibles: The preemptible VMs instance type. To maximize cost savings and market availability, select as many types as possible. Required if instance_types_ondemand is not set.
|
|
1454
|
+
:param pulumi.Input[Sequence[pulumi.Input[Union['ElastigroupLabelArgs', 'ElastigroupLabelArgsDict']]]] labels: Array of objects with key-value pairs.
|
|
1455
|
+
:param pulumi.Input[_builtins.int] max_size: The maximum number of instances the group should have at any time.
|
|
1456
|
+
:param pulumi.Input[Sequence[pulumi.Input[Union['ElastigroupMetadataArgs', 'ElastigroupMetadataArgsDict']]]] metadatas: Array of objects with key-value pairs.
|
|
1457
|
+
:param pulumi.Input[_builtins.str] min_cpu_platform: Select a minimum CPU platform for the compute instance.
|
|
1458
|
+
:param pulumi.Input[_builtins.int] min_size: The minimum number of instances the group should have at any time.
|
|
1459
|
+
:param pulumi.Input[_builtins.str] name: The group name.
|
|
1460
|
+
:param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] optimization_windows: Set time window to perform the revert to preemptible. Time windows must be at least 120 minutes. Format: DayInWeek:HH-DayInWeek:HH. Required when strategy.revertToPreemptible.performAt is 'timeWindow'.
|
|
1461
|
+
:param pulumi.Input[_builtins.int] preemptible_percentage: Percentage of Preemptible VMs to spin up from the "desired_capacity".
|
|
1462
|
+
:param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] preferred_availability_zones: prioritize availability zones when launching instances for the group. Must be a sublist of `availability_zones`.
|
|
1463
|
+
:param pulumi.Input[_builtins.str] provisioning_model: Valid values: "SPOT", "PREEMPTIBLE". Define the provisioning model of the launched instances. Default value is "PREEMPTIBLE".
|
|
1464
|
+
:param pulumi.Input[Sequence[pulumi.Input[Union['ElastigroupRevertToPreemptibleArgs', 'ElastigroupRevertToPreemptibleArgsDict']]]] revert_to_preemptibles: Setting for revert to preemptible option.
|
|
1465
|
+
:param pulumi.Input[_builtins.str] service_account: The email of the service account in which the group instances will be launched.
|
|
1466
|
+
:param pulumi.Input[Union['ElastigroupShieldedInstanceConfigArgs', 'ElastigroupShieldedInstanceConfigArgsDict']] shielded_instance_config: You can use secure boot when you launch VMs using Elastigroup. This helps you comply with your security policies. In the instance configuration, use ‘secureBootEnabled’ set to True to enforce UEFI with secure boot. Elastigroup provisions VMs with secure boot, as long as the images supports UEFI.
|
|
1467
|
+
:param pulumi.Input[_builtins.bool] should_utilize_commitments: Enable committed use discounts utilization.
|
|
1468
|
+
:param pulumi.Input[_builtins.str] shutdown_script: The Base64-encoded shutdown script that executes prior to instance termination, for more information please see: [Shutdown Script](https://api.spotinst.com/integration-docs/elastigroup/concepts/compute-concepts/shutdown-scripts/)
|
|
1469
|
+
:param pulumi.Input[_builtins.str] startup_script: Create and run your own startup scripts on your virtual machines to perform automated tasks every time your instance boots up.
|
|
1470
|
+
:param pulumi.Input[Sequence[pulumi.Input[Union['ElastigroupSubnetArgs', 'ElastigroupSubnetArgsDict']]]] subnets: A list of regions and subnets.
|
|
1471
|
+
:param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] tags: Tags to mark created instances.
|
|
1247
1472
|
"""
|
|
1248
1473
|
...
|
|
1249
1474
|
@overload
|
|
@@ -1266,6 +1491,7 @@ class Elastigroup(pulumi.CustomResource):
|
|
|
1266
1491
|
service_account="example@myProject.iam.gservicecct.com",
|
|
1267
1492
|
startup_script="",
|
|
1268
1493
|
instance_name_prefix="test-123a",
|
|
1494
|
+
min_cpu_platform="Intel Sandy Bridge",
|
|
1269
1495
|
min_size=0,
|
|
1270
1496
|
max_size=1,
|
|
1271
1497
|
desired_capacity=1,
|
|
@@ -1273,78 +1499,92 @@ class Elastigroup(pulumi.CustomResource):
|
|
|
1273
1499
|
"asia-east1-c",
|
|
1274
1500
|
"us-central1-a",
|
|
1275
1501
|
],
|
|
1502
|
+
preferred_availability_zones=["us-central1-a"],
|
|
1276
1503
|
preemptible_percentage=50,
|
|
1504
|
+
revert_to_preemptibles=[{
|
|
1505
|
+
"perform_at": "timeWindow",
|
|
1506
|
+
}],
|
|
1507
|
+
optimization_windows=["Mon:01:00-Mon:03:00"],
|
|
1277
1508
|
fallback_to_ondemand=True,
|
|
1278
1509
|
draining_timeout=180,
|
|
1279
1510
|
provisioning_model="SPOT",
|
|
1280
|
-
|
|
1281
|
-
|
|
1282
|
-
|
|
1283
|
-
|
|
1511
|
+
should_utilize_commitments=True,
|
|
1512
|
+
labels=[{
|
|
1513
|
+
"key": "test_key",
|
|
1514
|
+
"value": "test_value",
|
|
1515
|
+
}],
|
|
1284
1516
|
tags=[
|
|
1285
1517
|
"http",
|
|
1286
1518
|
"https",
|
|
1287
1519
|
],
|
|
1288
|
-
backend_services=[
|
|
1289
|
-
service_name
|
|
1290
|
-
location_type
|
|
1291
|
-
scheme
|
|
1292
|
-
named_ports
|
|
1293
|
-
name
|
|
1294
|
-
ports
|
|
1520
|
+
backend_services=[{
|
|
1521
|
+
"service_name": "spotinst-elb-backend-service",
|
|
1522
|
+
"location_type": "regional",
|
|
1523
|
+
"scheme": "INTERNAL",
|
|
1524
|
+
"named_ports": [{
|
|
1525
|
+
"name": "port-name",
|
|
1526
|
+
"ports": [
|
|
1295
1527
|
"8000",
|
|
1296
1528
|
"6000",
|
|
1297
1529
|
],
|
|
1298
|
-
|
|
1299
|
-
|
|
1300
|
-
|
|
1301
|
-
|
|
1302
|
-
|
|
1303
|
-
|
|
1304
|
-
|
|
1305
|
-
|
|
1306
|
-
|
|
1307
|
-
|
|
1308
|
-
|
|
1309
|
-
|
|
1310
|
-
|
|
1311
|
-
|
|
1312
|
-
|
|
1313
|
-
|
|
1314
|
-
|
|
1315
|
-
|
|
1530
|
+
}],
|
|
1531
|
+
"backend_balancing": {
|
|
1532
|
+
"backend_balancing_mode": "RATE",
|
|
1533
|
+
"max_rate_per_instance": 500,
|
|
1534
|
+
},
|
|
1535
|
+
}],
|
|
1536
|
+
disks=[{
|
|
1537
|
+
"device_name": "device",
|
|
1538
|
+
"mode": "READ_WRITE",
|
|
1539
|
+
"type": "PERSISTENT",
|
|
1540
|
+
"auto_delete": True,
|
|
1541
|
+
"boot": True,
|
|
1542
|
+
"interface": "SCSI",
|
|
1543
|
+
"initialize_params": [{
|
|
1544
|
+
"disk_size_gb": "10",
|
|
1545
|
+
"disk_type": "pd-standard",
|
|
1546
|
+
"source_image": "",
|
|
1547
|
+
}],
|
|
1548
|
+
}],
|
|
1549
|
+
shielded_instance_config={
|
|
1550
|
+
"enable_secure_boot": True,
|
|
1551
|
+
"enable_integrity_monitoring": False,
|
|
1552
|
+
},
|
|
1553
|
+
network_interfaces=[{
|
|
1554
|
+
"network": "spot-network",
|
|
1555
|
+
}],
|
|
1316
1556
|
instance_types_ondemand="n1-standard-1",
|
|
1317
1557
|
instance_types_preemptibles=[
|
|
1318
1558
|
"n1-standard-1",
|
|
1319
1559
|
"n1-standard-2",
|
|
1320
1560
|
],
|
|
1321
|
-
instance_types_customs=[
|
|
1322
|
-
vcpu
|
|
1323
|
-
memory_gib
|
|
1324
|
-
|
|
1325
|
-
subnets=[
|
|
1326
|
-
region
|
|
1327
|
-
subnet_names
|
|
1328
|
-
|
|
1329
|
-
scaling_up_policies=[
|
|
1330
|
-
policy_name
|
|
1331
|
-
source
|
|
1332
|
-
metric_name
|
|
1333
|
-
namespace
|
|
1334
|
-
statistic
|
|
1335
|
-
unit
|
|
1336
|
-
threshold
|
|
1337
|
-
period
|
|
1338
|
-
cooldown
|
|
1339
|
-
operator
|
|
1340
|
-
evaluation_periods
|
|
1341
|
-
action_type
|
|
1342
|
-
adjustment
|
|
1343
|
-
dimensions
|
|
1344
|
-
name
|
|
1345
|
-
value
|
|
1346
|
-
|
|
1347
|
-
|
|
1561
|
+
instance_types_customs=[{
|
|
1562
|
+
"vcpu": 2,
|
|
1563
|
+
"memory_gib": 7,
|
|
1564
|
+
}],
|
|
1565
|
+
subnets=[{
|
|
1566
|
+
"region": "asia-east1",
|
|
1567
|
+
"subnet_names": ["default"],
|
|
1568
|
+
}],
|
|
1569
|
+
scaling_up_policies=[{
|
|
1570
|
+
"policy_name": "scale_up_1",
|
|
1571
|
+
"source": "stackdriver",
|
|
1572
|
+
"metric_name": "instance/disk/read_ops_count",
|
|
1573
|
+
"namespace": "compute",
|
|
1574
|
+
"statistic": "average",
|
|
1575
|
+
"unit": "percent",
|
|
1576
|
+
"threshold": 10000,
|
|
1577
|
+
"period": 300,
|
|
1578
|
+
"cooldown": 300,
|
|
1579
|
+
"operator": "gte",
|
|
1580
|
+
"evaluation_periods": 1,
|
|
1581
|
+
"action_type": "adjustment",
|
|
1582
|
+
"adjustment": 1,
|
|
1583
|
+
"dimensions": [{
|
|
1584
|
+
"name": "storage_type",
|
|
1585
|
+
"value": "pd-ssd",
|
|
1586
|
+
}],
|
|
1587
|
+
}])
|
|
1348
1588
|
```
|
|
1349
1589
|
|
|
1350
1590
|
:param str resource_name: The name of the resource.
|
|
@@ -1362,42 +1602,48 @@ class Elastigroup(pulumi.CustomResource):
|
|
|
1362
1602
|
def _internal_init(__self__,
|
|
1363
1603
|
resource_name: str,
|
|
1364
1604
|
opts: Optional[pulumi.ResourceOptions] = None,
|
|
1365
|
-
auto_healing: Optional[pulumi.Input[bool]] = None,
|
|
1366
|
-
availability_zones: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
|
|
1367
|
-
backend_services: Optional[pulumi.Input[Sequence[pulumi.Input[
|
|
1368
|
-
description: Optional[pulumi.Input[str]] = None,
|
|
1369
|
-
desired_capacity: Optional[pulumi.Input[int]] = None,
|
|
1370
|
-
disks: Optional[pulumi.Input[Sequence[pulumi.Input[
|
|
1371
|
-
draining_timeout: Optional[pulumi.Input[int]] = None,
|
|
1372
|
-
fallback_to_ondemand: Optional[pulumi.Input[bool]] = None,
|
|
1373
|
-
gpu: Optional[pulumi.Input[Sequence[pulumi.Input[
|
|
1374
|
-
health_check_grace_period: Optional[pulumi.Input[int]] = None,
|
|
1375
|
-
health_check_type: Optional[pulumi.Input[str]] = None,
|
|
1376
|
-
instance_name_prefix: Optional[pulumi.Input[str]] = None,
|
|
1377
|
-
instance_types_customs: Optional[pulumi.Input[Sequence[pulumi.Input[
|
|
1378
|
-
instance_types_ondemand: Optional[pulumi.Input[str]] = None,
|
|
1379
|
-
instance_types_preemptibles: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
|
|
1380
|
-
integration_docker_swarm: Optional[pulumi.Input[
|
|
1381
|
-
integration_gke: Optional[pulumi.Input[
|
|
1382
|
-
ip_forwarding: Optional[pulumi.Input[bool]] = None,
|
|
1383
|
-
labels: Optional[pulumi.Input[Sequence[pulumi.Input[
|
|
1384
|
-
max_size: Optional[pulumi.Input[int]] = None,
|
|
1385
|
-
metadatas: Optional[pulumi.Input[Sequence[pulumi.Input[
|
|
1386
|
-
|
|
1387
|
-
|
|
1388
|
-
|
|
1389
|
-
|
|
1390
|
-
|
|
1391
|
-
|
|
1392
|
-
|
|
1393
|
-
|
|
1394
|
-
|
|
1395
|
-
|
|
1396
|
-
|
|
1397
|
-
|
|
1398
|
-
|
|
1399
|
-
|
|
1400
|
-
|
|
1605
|
+
auto_healing: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
1606
|
+
availability_zones: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
1607
|
+
backend_services: Optional[pulumi.Input[Sequence[pulumi.Input[Union['ElastigroupBackendServiceArgs', 'ElastigroupBackendServiceArgsDict']]]]] = None,
|
|
1608
|
+
description: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1609
|
+
desired_capacity: Optional[pulumi.Input[_builtins.int]] = None,
|
|
1610
|
+
disks: Optional[pulumi.Input[Sequence[pulumi.Input[Union['ElastigroupDiskArgs', 'ElastigroupDiskArgsDict']]]]] = None,
|
|
1611
|
+
draining_timeout: Optional[pulumi.Input[_builtins.int]] = None,
|
|
1612
|
+
fallback_to_ondemand: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
1613
|
+
gpu: Optional[pulumi.Input[Sequence[pulumi.Input[Union['ElastigroupGpuArgs', 'ElastigroupGpuArgsDict']]]]] = None,
|
|
1614
|
+
health_check_grace_period: Optional[pulumi.Input[_builtins.int]] = None,
|
|
1615
|
+
health_check_type: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1616
|
+
instance_name_prefix: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1617
|
+
instance_types_customs: Optional[pulumi.Input[Sequence[pulumi.Input[Union['ElastigroupInstanceTypesCustomArgs', 'ElastigroupInstanceTypesCustomArgsDict']]]]] = None,
|
|
1618
|
+
instance_types_ondemand: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1619
|
+
instance_types_preemptibles: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
1620
|
+
integration_docker_swarm: Optional[pulumi.Input[Union['ElastigroupIntegrationDockerSwarmArgs', 'ElastigroupIntegrationDockerSwarmArgsDict']]] = None,
|
|
1621
|
+
integration_gke: Optional[pulumi.Input[Union['ElastigroupIntegrationGkeArgs', 'ElastigroupIntegrationGkeArgsDict']]] = None,
|
|
1622
|
+
ip_forwarding: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
1623
|
+
labels: Optional[pulumi.Input[Sequence[pulumi.Input[Union['ElastigroupLabelArgs', 'ElastigroupLabelArgsDict']]]]] = None,
|
|
1624
|
+
max_size: Optional[pulumi.Input[_builtins.int]] = None,
|
|
1625
|
+
metadatas: Optional[pulumi.Input[Sequence[pulumi.Input[Union['ElastigroupMetadataArgs', 'ElastigroupMetadataArgsDict']]]]] = None,
|
|
1626
|
+
min_cpu_platform: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1627
|
+
min_size: Optional[pulumi.Input[_builtins.int]] = None,
|
|
1628
|
+
name: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1629
|
+
network_interfaces: Optional[pulumi.Input[Sequence[pulumi.Input[Union['ElastigroupNetworkInterfaceArgs', 'ElastigroupNetworkInterfaceArgsDict']]]]] = None,
|
|
1630
|
+
ondemand_count: Optional[pulumi.Input[_builtins.int]] = None,
|
|
1631
|
+
optimization_windows: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
1632
|
+
preemptible_percentage: Optional[pulumi.Input[_builtins.int]] = None,
|
|
1633
|
+
preferred_availability_zones: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
1634
|
+
provisioning_model: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1635
|
+
revert_to_preemptibles: Optional[pulumi.Input[Sequence[pulumi.Input[Union['ElastigroupRevertToPreemptibleArgs', 'ElastigroupRevertToPreemptibleArgsDict']]]]] = None,
|
|
1636
|
+
scaling_down_policies: Optional[pulumi.Input[Sequence[pulumi.Input[Union['ElastigroupScalingDownPolicyArgs', 'ElastigroupScalingDownPolicyArgsDict']]]]] = None,
|
|
1637
|
+
scaling_up_policies: Optional[pulumi.Input[Sequence[pulumi.Input[Union['ElastigroupScalingUpPolicyArgs', 'ElastigroupScalingUpPolicyArgsDict']]]]] = None,
|
|
1638
|
+
scheduled_tasks: Optional[pulumi.Input[Sequence[pulumi.Input[Union['ElastigroupScheduledTaskArgs', 'ElastigroupScheduledTaskArgsDict']]]]] = None,
|
|
1639
|
+
service_account: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1640
|
+
shielded_instance_config: Optional[pulumi.Input[Union['ElastigroupShieldedInstanceConfigArgs', 'ElastigroupShieldedInstanceConfigArgsDict']]] = None,
|
|
1641
|
+
should_utilize_commitments: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
1642
|
+
shutdown_script: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1643
|
+
startup_script: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1644
|
+
subnets: Optional[pulumi.Input[Sequence[pulumi.Input[Union['ElastigroupSubnetArgs', 'ElastigroupSubnetArgsDict']]]]] = None,
|
|
1645
|
+
tags: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
1646
|
+
unhealthy_duration: Optional[pulumi.Input[_builtins.int]] = None,
|
|
1401
1647
|
__props__=None):
|
|
1402
1648
|
opts = pulumi.ResourceOptions.merge(_utilities.get_resource_opts_defaults(), opts)
|
|
1403
1649
|
if not isinstance(opts, pulumi.ResourceOptions):
|
|
@@ -1430,16 +1676,22 @@ class Elastigroup(pulumi.CustomResource):
|
|
|
1430
1676
|
__props__.__dict__["labels"] = labels
|
|
1431
1677
|
__props__.__dict__["max_size"] = max_size
|
|
1432
1678
|
__props__.__dict__["metadatas"] = metadatas
|
|
1679
|
+
__props__.__dict__["min_cpu_platform"] = min_cpu_platform
|
|
1433
1680
|
__props__.__dict__["min_size"] = min_size
|
|
1434
1681
|
__props__.__dict__["name"] = name
|
|
1435
1682
|
__props__.__dict__["network_interfaces"] = network_interfaces
|
|
1436
1683
|
__props__.__dict__["ondemand_count"] = ondemand_count
|
|
1684
|
+
__props__.__dict__["optimization_windows"] = optimization_windows
|
|
1437
1685
|
__props__.__dict__["preemptible_percentage"] = preemptible_percentage
|
|
1686
|
+
__props__.__dict__["preferred_availability_zones"] = preferred_availability_zones
|
|
1438
1687
|
__props__.__dict__["provisioning_model"] = provisioning_model
|
|
1688
|
+
__props__.__dict__["revert_to_preemptibles"] = revert_to_preemptibles
|
|
1439
1689
|
__props__.__dict__["scaling_down_policies"] = scaling_down_policies
|
|
1440
1690
|
__props__.__dict__["scaling_up_policies"] = scaling_up_policies
|
|
1441
1691
|
__props__.__dict__["scheduled_tasks"] = scheduled_tasks
|
|
1442
1692
|
__props__.__dict__["service_account"] = service_account
|
|
1693
|
+
__props__.__dict__["shielded_instance_config"] = shielded_instance_config
|
|
1694
|
+
__props__.__dict__["should_utilize_commitments"] = should_utilize_commitments
|
|
1443
1695
|
__props__.__dict__["shutdown_script"] = shutdown_script
|
|
1444
1696
|
__props__.__dict__["startup_script"] = startup_script
|
|
1445
1697
|
__props__.__dict__["subnets"] = subnets
|
|
@@ -1455,42 +1707,48 @@ class Elastigroup(pulumi.CustomResource):
|
|
|
1455
1707
|
def get(resource_name: str,
|
|
1456
1708
|
id: pulumi.Input[str],
|
|
1457
1709
|
opts: Optional[pulumi.ResourceOptions] = None,
|
|
1458
|
-
auto_healing: Optional[pulumi.Input[bool]] = None,
|
|
1459
|
-
availability_zones: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
|
|
1460
|
-
backend_services: Optional[pulumi.Input[Sequence[pulumi.Input[
|
|
1461
|
-
description: Optional[pulumi.Input[str]] = None,
|
|
1462
|
-
desired_capacity: Optional[pulumi.Input[int]] = None,
|
|
1463
|
-
disks: Optional[pulumi.Input[Sequence[pulumi.Input[
|
|
1464
|
-
draining_timeout: Optional[pulumi.Input[int]] = None,
|
|
1465
|
-
fallback_to_ondemand: Optional[pulumi.Input[bool]] = None,
|
|
1466
|
-
gpu: Optional[pulumi.Input[Sequence[pulumi.Input[
|
|
1467
|
-
health_check_grace_period: Optional[pulumi.Input[int]] = None,
|
|
1468
|
-
health_check_type: Optional[pulumi.Input[str]] = None,
|
|
1469
|
-
instance_name_prefix: Optional[pulumi.Input[str]] = None,
|
|
1470
|
-
instance_types_customs: Optional[pulumi.Input[Sequence[pulumi.Input[
|
|
1471
|
-
instance_types_ondemand: Optional[pulumi.Input[str]] = None,
|
|
1472
|
-
instance_types_preemptibles: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
|
|
1473
|
-
integration_docker_swarm: Optional[pulumi.Input[
|
|
1474
|
-
integration_gke: Optional[pulumi.Input[
|
|
1475
|
-
ip_forwarding: Optional[pulumi.Input[bool]] = None,
|
|
1476
|
-
labels: Optional[pulumi.Input[Sequence[pulumi.Input[
|
|
1477
|
-
max_size: Optional[pulumi.Input[int]] = None,
|
|
1478
|
-
metadatas: Optional[pulumi.Input[Sequence[pulumi.Input[
|
|
1479
|
-
|
|
1480
|
-
|
|
1481
|
-
|
|
1482
|
-
|
|
1483
|
-
|
|
1484
|
-
|
|
1485
|
-
|
|
1486
|
-
|
|
1487
|
-
|
|
1488
|
-
|
|
1489
|
-
|
|
1490
|
-
|
|
1491
|
-
|
|
1492
|
-
|
|
1493
|
-
|
|
1710
|
+
auto_healing: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
1711
|
+
availability_zones: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
1712
|
+
backend_services: Optional[pulumi.Input[Sequence[pulumi.Input[Union['ElastigroupBackendServiceArgs', 'ElastigroupBackendServiceArgsDict']]]]] = None,
|
|
1713
|
+
description: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1714
|
+
desired_capacity: Optional[pulumi.Input[_builtins.int]] = None,
|
|
1715
|
+
disks: Optional[pulumi.Input[Sequence[pulumi.Input[Union['ElastigroupDiskArgs', 'ElastigroupDiskArgsDict']]]]] = None,
|
|
1716
|
+
draining_timeout: Optional[pulumi.Input[_builtins.int]] = None,
|
|
1717
|
+
fallback_to_ondemand: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
1718
|
+
gpu: Optional[pulumi.Input[Sequence[pulumi.Input[Union['ElastigroupGpuArgs', 'ElastigroupGpuArgsDict']]]]] = None,
|
|
1719
|
+
health_check_grace_period: Optional[pulumi.Input[_builtins.int]] = None,
|
|
1720
|
+
health_check_type: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1721
|
+
instance_name_prefix: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1722
|
+
instance_types_customs: Optional[pulumi.Input[Sequence[pulumi.Input[Union['ElastigroupInstanceTypesCustomArgs', 'ElastigroupInstanceTypesCustomArgsDict']]]]] = None,
|
|
1723
|
+
instance_types_ondemand: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1724
|
+
instance_types_preemptibles: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
1725
|
+
integration_docker_swarm: Optional[pulumi.Input[Union['ElastigroupIntegrationDockerSwarmArgs', 'ElastigroupIntegrationDockerSwarmArgsDict']]] = None,
|
|
1726
|
+
integration_gke: Optional[pulumi.Input[Union['ElastigroupIntegrationGkeArgs', 'ElastigroupIntegrationGkeArgsDict']]] = None,
|
|
1727
|
+
ip_forwarding: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
1728
|
+
labels: Optional[pulumi.Input[Sequence[pulumi.Input[Union['ElastigroupLabelArgs', 'ElastigroupLabelArgsDict']]]]] = None,
|
|
1729
|
+
max_size: Optional[pulumi.Input[_builtins.int]] = None,
|
|
1730
|
+
metadatas: Optional[pulumi.Input[Sequence[pulumi.Input[Union['ElastigroupMetadataArgs', 'ElastigroupMetadataArgsDict']]]]] = None,
|
|
1731
|
+
min_cpu_platform: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1732
|
+
min_size: Optional[pulumi.Input[_builtins.int]] = None,
|
|
1733
|
+
name: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1734
|
+
network_interfaces: Optional[pulumi.Input[Sequence[pulumi.Input[Union['ElastigroupNetworkInterfaceArgs', 'ElastigroupNetworkInterfaceArgsDict']]]]] = None,
|
|
1735
|
+
ondemand_count: Optional[pulumi.Input[_builtins.int]] = None,
|
|
1736
|
+
optimization_windows: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
1737
|
+
preemptible_percentage: Optional[pulumi.Input[_builtins.int]] = None,
|
|
1738
|
+
preferred_availability_zones: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
1739
|
+
provisioning_model: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1740
|
+
revert_to_preemptibles: Optional[pulumi.Input[Sequence[pulumi.Input[Union['ElastigroupRevertToPreemptibleArgs', 'ElastigroupRevertToPreemptibleArgsDict']]]]] = None,
|
|
1741
|
+
scaling_down_policies: Optional[pulumi.Input[Sequence[pulumi.Input[Union['ElastigroupScalingDownPolicyArgs', 'ElastigroupScalingDownPolicyArgsDict']]]]] = None,
|
|
1742
|
+
scaling_up_policies: Optional[pulumi.Input[Sequence[pulumi.Input[Union['ElastigroupScalingUpPolicyArgs', 'ElastigroupScalingUpPolicyArgsDict']]]]] = None,
|
|
1743
|
+
scheduled_tasks: Optional[pulumi.Input[Sequence[pulumi.Input[Union['ElastigroupScheduledTaskArgs', 'ElastigroupScheduledTaskArgsDict']]]]] = None,
|
|
1744
|
+
service_account: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1745
|
+
shielded_instance_config: Optional[pulumi.Input[Union['ElastigroupShieldedInstanceConfigArgs', 'ElastigroupShieldedInstanceConfigArgsDict']]] = None,
|
|
1746
|
+
should_utilize_commitments: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
1747
|
+
shutdown_script: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1748
|
+
startup_script: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1749
|
+
subnets: Optional[pulumi.Input[Sequence[pulumi.Input[Union['ElastigroupSubnetArgs', 'ElastigroupSubnetArgsDict']]]]] = None,
|
|
1750
|
+
tags: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
1751
|
+
unhealthy_duration: Optional[pulumi.Input[_builtins.int]] = None) -> 'Elastigroup':
|
|
1494
1752
|
"""
|
|
1495
1753
|
Get an existing Elastigroup resource's state with the given name, id, and optional extra
|
|
1496
1754
|
properties used to qualify the lookup.
|
|
@@ -1498,30 +1756,36 @@ class Elastigroup(pulumi.CustomResource):
|
|
|
1498
1756
|
:param str resource_name: The unique name of the resulting resource.
|
|
1499
1757
|
:param pulumi.Input[str] id: The unique provider ID of the resource to lookup.
|
|
1500
1758
|
:param pulumi.ResourceOptions opts: Options for the resource.
|
|
1501
|
-
:param pulumi.Input[Sequence[pulumi.Input[str]]] availability_zones: List of availability zones for the group.
|
|
1502
|
-
:param pulumi.Input[str] description: The region your GCP group will be created in.
|
|
1503
|
-
:param pulumi.Input[int] desired_capacity: The desired number of instances the group should have at any time.
|
|
1504
|
-
:param pulumi.Input[int] draining_timeout: Time (seconds) the instance is allowed to run after it is detached from the group. This is to allow the instance time to drain all the current TCP connections before terminating it.
|
|
1505
|
-
:param pulumi.Input[bool] fallback_to_ondemand: Activate fallback-to-on-demand. When provisioning an instance, if no Preemptible market is available, fallback-to-on-demand will provision an On-Demand instance to maintain the group capacity.
|
|
1506
|
-
:param pulumi.Input[str] instance_name_prefix: Set an instance name prefix to be used for all launched instances and their boot disk. The prefix value should comply with the following limitations:
|
|
1759
|
+
:param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] availability_zones: List of availability zones for the group.
|
|
1760
|
+
:param pulumi.Input[_builtins.str] description: The region your GCP group will be created in.
|
|
1761
|
+
:param pulumi.Input[_builtins.int] desired_capacity: The desired number of instances the group should have at any time.
|
|
1762
|
+
:param pulumi.Input[_builtins.int] draining_timeout: Time (seconds) the instance is allowed to run after it is detached from the group. This is to allow the instance time to drain all the current TCP connections before terminating it.
|
|
1763
|
+
:param pulumi.Input[_builtins.bool] fallback_to_ondemand: Activate fallback-to-on-demand. When provisioning an instance, if no Preemptible market is available, fallback-to-on-demand will provision an On-Demand instance to maintain the group capacity.
|
|
1764
|
+
:param pulumi.Input[_builtins.str] instance_name_prefix: Set an instance name prefix to be used for all launched instances and their boot disk. The prefix value should comply with the following limitations:
|
|
1507
1765
|
* A maximal length of 25 characters.
|
|
1508
1766
|
* The first character must be a lowercase letter, and all the following characters must be hyphens, lowercase letters, or digits, except the last character, which cannot be a hyphen.
|
|
1509
|
-
:param pulumi.Input[Sequence[pulumi.Input[
|
|
1767
|
+
:param pulumi.Input[Sequence[pulumi.Input[Union['ElastigroupInstanceTypesCustomArgs', 'ElastigroupInstanceTypesCustomArgsDict']]]] instance_types_customs: Defines a set of custom instance types. Required if instance_types_preemptible and instance_types_ondemand are not set.
|
|
1510
1768
|
* `vCPU` - (Optional) The number of vCPUs in the custom instance type. GCP has a number of limitations on accepted vCPU values. For more information, see the GCP documentation (here.)[https://cloud.google.com/compute/docs/instances/creating-instance-with-custom-machine-type#specifications]
|
|
1511
|
-
:param pulumi.Input[str] instance_types_ondemand: The regular VM instance type to use for mixed-type groups and when falling back to on-demand. Required if instance_types_preemptible is not set.
|
|
1512
|
-
:param pulumi.Input[Sequence[pulumi.Input[str]]] instance_types_preemptibles: The preemptible VMs instance type. To maximize cost savings and market availability, select as many types as possible. Required if instance_types_ondemand is not set.
|
|
1513
|
-
:param pulumi.Input[Sequence[pulumi.Input[
|
|
1514
|
-
:param pulumi.Input[int] max_size: The maximum number of instances the group should have at any time.
|
|
1515
|
-
:param pulumi.Input[Sequence[pulumi.Input[
|
|
1516
|
-
:param pulumi.Input[
|
|
1517
|
-
:param pulumi.Input[
|
|
1518
|
-
:param pulumi.Input[
|
|
1519
|
-
:param pulumi.Input[str]
|
|
1520
|
-
:param pulumi.Input[
|
|
1521
|
-
:param pulumi.Input[str]
|
|
1522
|
-
:param pulumi.Input[str]
|
|
1523
|
-
:param pulumi.Input[Sequence[pulumi.Input[
|
|
1524
|
-
:param pulumi.Input[
|
|
1769
|
+
:param pulumi.Input[_builtins.str] instance_types_ondemand: The regular VM instance type to use for mixed-type groups and when falling back to on-demand. Required if instance_types_preemptible is not set.
|
|
1770
|
+
:param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] instance_types_preemptibles: The preemptible VMs instance type. To maximize cost savings and market availability, select as many types as possible. Required if instance_types_ondemand is not set.
|
|
1771
|
+
:param pulumi.Input[Sequence[pulumi.Input[Union['ElastigroupLabelArgs', 'ElastigroupLabelArgsDict']]]] labels: Array of objects with key-value pairs.
|
|
1772
|
+
:param pulumi.Input[_builtins.int] max_size: The maximum number of instances the group should have at any time.
|
|
1773
|
+
:param pulumi.Input[Sequence[pulumi.Input[Union['ElastigroupMetadataArgs', 'ElastigroupMetadataArgsDict']]]] metadatas: Array of objects with key-value pairs.
|
|
1774
|
+
:param pulumi.Input[_builtins.str] min_cpu_platform: Select a minimum CPU platform for the compute instance.
|
|
1775
|
+
:param pulumi.Input[_builtins.int] min_size: The minimum number of instances the group should have at any time.
|
|
1776
|
+
:param pulumi.Input[_builtins.str] name: The group name.
|
|
1777
|
+
:param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] optimization_windows: Set time window to perform the revert to preemptible. Time windows must be at least 120 minutes. Format: DayInWeek:HH-DayInWeek:HH. Required when strategy.revertToPreemptible.performAt is 'timeWindow'.
|
|
1778
|
+
:param pulumi.Input[_builtins.int] preemptible_percentage: Percentage of Preemptible VMs to spin up from the "desired_capacity".
|
|
1779
|
+
:param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] preferred_availability_zones: prioritize availability zones when launching instances for the group. Must be a sublist of `availability_zones`.
|
|
1780
|
+
:param pulumi.Input[_builtins.str] provisioning_model: Valid values: "SPOT", "PREEMPTIBLE". Define the provisioning model of the launched instances. Default value is "PREEMPTIBLE".
|
|
1781
|
+
:param pulumi.Input[Sequence[pulumi.Input[Union['ElastigroupRevertToPreemptibleArgs', 'ElastigroupRevertToPreemptibleArgsDict']]]] revert_to_preemptibles: Setting for revert to preemptible option.
|
|
1782
|
+
:param pulumi.Input[_builtins.str] service_account: The email of the service account in which the group instances will be launched.
|
|
1783
|
+
:param pulumi.Input[Union['ElastigroupShieldedInstanceConfigArgs', 'ElastigroupShieldedInstanceConfigArgsDict']] shielded_instance_config: You can use secure boot when you launch VMs using Elastigroup. This helps you comply with your security policies. In the instance configuration, use ‘secureBootEnabled’ set to True to enforce UEFI with secure boot. Elastigroup provisions VMs with secure boot, as long as the images supports UEFI.
|
|
1784
|
+
:param pulumi.Input[_builtins.bool] should_utilize_commitments: Enable committed use discounts utilization.
|
|
1785
|
+
:param pulumi.Input[_builtins.str] shutdown_script: The Base64-encoded shutdown script that executes prior to instance termination, for more information please see: [Shutdown Script](https://api.spotinst.com/integration-docs/elastigroup/concepts/compute-concepts/shutdown-scripts/)
|
|
1786
|
+
:param pulumi.Input[_builtins.str] startup_script: Create and run your own startup scripts on your virtual machines to perform automated tasks every time your instance boots up.
|
|
1787
|
+
:param pulumi.Input[Sequence[pulumi.Input[Union['ElastigroupSubnetArgs', 'ElastigroupSubnetArgsDict']]]] subnets: A list of regions and subnets.
|
|
1788
|
+
:param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] tags: Tags to mark created instances.
|
|
1525
1789
|
"""
|
|
1526
1790
|
opts = pulumi.ResourceOptions.merge(opts, pulumi.ResourceOptions(id=id))
|
|
1527
1791
|
|
|
@@ -1548,16 +1812,22 @@ class Elastigroup(pulumi.CustomResource):
|
|
|
1548
1812
|
__props__.__dict__["labels"] = labels
|
|
1549
1813
|
__props__.__dict__["max_size"] = max_size
|
|
1550
1814
|
__props__.__dict__["metadatas"] = metadatas
|
|
1815
|
+
__props__.__dict__["min_cpu_platform"] = min_cpu_platform
|
|
1551
1816
|
__props__.__dict__["min_size"] = min_size
|
|
1552
1817
|
__props__.__dict__["name"] = name
|
|
1553
1818
|
__props__.__dict__["network_interfaces"] = network_interfaces
|
|
1554
1819
|
__props__.__dict__["ondemand_count"] = ondemand_count
|
|
1820
|
+
__props__.__dict__["optimization_windows"] = optimization_windows
|
|
1555
1821
|
__props__.__dict__["preemptible_percentage"] = preemptible_percentage
|
|
1822
|
+
__props__.__dict__["preferred_availability_zones"] = preferred_availability_zones
|
|
1556
1823
|
__props__.__dict__["provisioning_model"] = provisioning_model
|
|
1824
|
+
__props__.__dict__["revert_to_preemptibles"] = revert_to_preemptibles
|
|
1557
1825
|
__props__.__dict__["scaling_down_policies"] = scaling_down_policies
|
|
1558
1826
|
__props__.__dict__["scaling_up_policies"] = scaling_up_policies
|
|
1559
1827
|
__props__.__dict__["scheduled_tasks"] = scheduled_tasks
|
|
1560
1828
|
__props__.__dict__["service_account"] = service_account
|
|
1829
|
+
__props__.__dict__["shielded_instance_config"] = shielded_instance_config
|
|
1830
|
+
__props__.__dict__["should_utilize_commitments"] = should_utilize_commitments
|
|
1561
1831
|
__props__.__dict__["shutdown_script"] = shutdown_script
|
|
1562
1832
|
__props__.__dict__["startup_script"] = startup_script
|
|
1563
1833
|
__props__.__dict__["subnets"] = subnets
|
|
@@ -1565,80 +1835,80 @@ class Elastigroup(pulumi.CustomResource):
|
|
|
1565
1835
|
__props__.__dict__["unhealthy_duration"] = unhealthy_duration
|
|
1566
1836
|
return Elastigroup(resource_name, opts=opts, __props__=__props__)
|
|
1567
1837
|
|
|
1568
|
-
@property
|
|
1838
|
+
@_builtins.property
|
|
1569
1839
|
@pulumi.getter(name="autoHealing")
|
|
1570
|
-
def auto_healing(self) -> pulumi.Output[Optional[bool]]:
|
|
1840
|
+
def auto_healing(self) -> pulumi.Output[Optional[_builtins.bool]]:
|
|
1571
1841
|
return pulumi.get(self, "auto_healing")
|
|
1572
1842
|
|
|
1573
|
-
@property
|
|
1843
|
+
@_builtins.property
|
|
1574
1844
|
@pulumi.getter(name="availabilityZones")
|
|
1575
1845
|
@_utilities.deprecated("""This field will soon be handled by Region in Subnets""")
|
|
1576
|
-
def availability_zones(self) -> pulumi.Output[Optional[Sequence[str]]]:
|
|
1846
|
+
def availability_zones(self) -> pulumi.Output[Optional[Sequence[_builtins.str]]]:
|
|
1577
1847
|
"""
|
|
1578
1848
|
List of availability zones for the group.
|
|
1579
1849
|
"""
|
|
1580
1850
|
return pulumi.get(self, "availability_zones")
|
|
1581
1851
|
|
|
1582
|
-
@property
|
|
1852
|
+
@_builtins.property
|
|
1583
1853
|
@pulumi.getter(name="backendServices")
|
|
1584
1854
|
def backend_services(self) -> pulumi.Output[Optional[Sequence['outputs.ElastigroupBackendService']]]:
|
|
1585
1855
|
return pulumi.get(self, "backend_services")
|
|
1586
1856
|
|
|
1587
|
-
@property
|
|
1857
|
+
@_builtins.property
|
|
1588
1858
|
@pulumi.getter
|
|
1589
|
-
def description(self) -> pulumi.Output[Optional[str]]:
|
|
1859
|
+
def description(self) -> pulumi.Output[Optional[_builtins.str]]:
|
|
1590
1860
|
"""
|
|
1591
1861
|
The region your GCP group will be created in.
|
|
1592
1862
|
"""
|
|
1593
1863
|
return pulumi.get(self, "description")
|
|
1594
1864
|
|
|
1595
|
-
@property
|
|
1865
|
+
@_builtins.property
|
|
1596
1866
|
@pulumi.getter(name="desiredCapacity")
|
|
1597
|
-
def desired_capacity(self) -> pulumi.Output[int]:
|
|
1867
|
+
def desired_capacity(self) -> pulumi.Output[_builtins.int]:
|
|
1598
1868
|
"""
|
|
1599
1869
|
The desired number of instances the group should have at any time.
|
|
1600
1870
|
"""
|
|
1601
1871
|
return pulumi.get(self, "desired_capacity")
|
|
1602
1872
|
|
|
1603
|
-
@property
|
|
1873
|
+
@_builtins.property
|
|
1604
1874
|
@pulumi.getter
|
|
1605
1875
|
def disks(self) -> pulumi.Output[Optional[Sequence['outputs.ElastigroupDisk']]]:
|
|
1606
1876
|
return pulumi.get(self, "disks")
|
|
1607
1877
|
|
|
1608
|
-
@property
|
|
1878
|
+
@_builtins.property
|
|
1609
1879
|
@pulumi.getter(name="drainingTimeout")
|
|
1610
|
-
def draining_timeout(self) -> pulumi.Output[Optional[int]]:
|
|
1880
|
+
def draining_timeout(self) -> pulumi.Output[Optional[_builtins.int]]:
|
|
1611
1881
|
"""
|
|
1612
1882
|
Time (seconds) the instance is allowed to run after it is detached from the group. This is to allow the instance time to drain all the current TCP connections before terminating it.
|
|
1613
1883
|
"""
|
|
1614
1884
|
return pulumi.get(self, "draining_timeout")
|
|
1615
1885
|
|
|
1616
|
-
@property
|
|
1886
|
+
@_builtins.property
|
|
1617
1887
|
@pulumi.getter(name="fallbackToOndemand")
|
|
1618
|
-
def fallback_to_ondemand(self) -> pulumi.Output[Optional[bool]]:
|
|
1888
|
+
def fallback_to_ondemand(self) -> pulumi.Output[Optional[_builtins.bool]]:
|
|
1619
1889
|
"""
|
|
1620
1890
|
Activate fallback-to-on-demand. When provisioning an instance, if no Preemptible market is available, fallback-to-on-demand will provision an On-Demand instance to maintain the group capacity.
|
|
1621
1891
|
"""
|
|
1622
1892
|
return pulumi.get(self, "fallback_to_ondemand")
|
|
1623
1893
|
|
|
1624
|
-
@property
|
|
1894
|
+
@_builtins.property
|
|
1625
1895
|
@pulumi.getter
|
|
1626
1896
|
def gpu(self) -> pulumi.Output[Optional[Sequence['outputs.ElastigroupGpu']]]:
|
|
1627
1897
|
return pulumi.get(self, "gpu")
|
|
1628
1898
|
|
|
1629
|
-
@property
|
|
1899
|
+
@_builtins.property
|
|
1630
1900
|
@pulumi.getter(name="healthCheckGracePeriod")
|
|
1631
|
-
def health_check_grace_period(self) -> pulumi.Output[Optional[int]]:
|
|
1901
|
+
def health_check_grace_period(self) -> pulumi.Output[Optional[_builtins.int]]:
|
|
1632
1902
|
return pulumi.get(self, "health_check_grace_period")
|
|
1633
1903
|
|
|
1634
|
-
@property
|
|
1904
|
+
@_builtins.property
|
|
1635
1905
|
@pulumi.getter(name="healthCheckType")
|
|
1636
|
-
def health_check_type(self) -> pulumi.Output[Optional[str]]:
|
|
1906
|
+
def health_check_type(self) -> pulumi.Output[Optional[_builtins.str]]:
|
|
1637
1907
|
return pulumi.get(self, "health_check_type")
|
|
1638
1908
|
|
|
1639
|
-
@property
|
|
1909
|
+
@_builtins.property
|
|
1640
1910
|
@pulumi.getter(name="instanceNamePrefix")
|
|
1641
|
-
def instance_name_prefix(self) -> pulumi.Output[Optional[str]]:
|
|
1911
|
+
def instance_name_prefix(self) -> pulumi.Output[Optional[_builtins.str]]:
|
|
1642
1912
|
"""
|
|
1643
1913
|
Set an instance name prefix to be used for all launched instances and their boot disk. The prefix value should comply with the following limitations:
|
|
1644
1914
|
* A maximal length of 25 characters.
|
|
@@ -1646,7 +1916,7 @@ class Elastigroup(pulumi.CustomResource):
|
|
|
1646
1916
|
"""
|
|
1647
1917
|
return pulumi.get(self, "instance_name_prefix")
|
|
1648
1918
|
|
|
1649
|
-
@property
|
|
1919
|
+
@_builtins.property
|
|
1650
1920
|
@pulumi.getter(name="instanceTypesCustoms")
|
|
1651
1921
|
def instance_types_customs(self) -> pulumi.Output[Optional[Sequence['outputs.ElastigroupInstanceTypesCustom']]]:
|
|
1652
1922
|
"""
|
|
@@ -1655,38 +1925,38 @@ class Elastigroup(pulumi.CustomResource):
|
|
|
1655
1925
|
"""
|
|
1656
1926
|
return pulumi.get(self, "instance_types_customs")
|
|
1657
1927
|
|
|
1658
|
-
@property
|
|
1928
|
+
@_builtins.property
|
|
1659
1929
|
@pulumi.getter(name="instanceTypesOndemand")
|
|
1660
|
-
def instance_types_ondemand(self) -> pulumi.Output[Optional[str]]:
|
|
1930
|
+
def instance_types_ondemand(self) -> pulumi.Output[Optional[_builtins.str]]:
|
|
1661
1931
|
"""
|
|
1662
1932
|
The regular VM instance type to use for mixed-type groups and when falling back to on-demand. Required if instance_types_preemptible is not set.
|
|
1663
1933
|
"""
|
|
1664
1934
|
return pulumi.get(self, "instance_types_ondemand")
|
|
1665
1935
|
|
|
1666
|
-
@property
|
|
1936
|
+
@_builtins.property
|
|
1667
1937
|
@pulumi.getter(name="instanceTypesPreemptibles")
|
|
1668
|
-
def instance_types_preemptibles(self) -> pulumi.Output[Optional[Sequence[str]]]:
|
|
1938
|
+
def instance_types_preemptibles(self) -> pulumi.Output[Optional[Sequence[_builtins.str]]]:
|
|
1669
1939
|
"""
|
|
1670
1940
|
The preemptible VMs instance type. To maximize cost savings and market availability, select as many types as possible. Required if instance_types_ondemand is not set.
|
|
1671
1941
|
"""
|
|
1672
1942
|
return pulumi.get(self, "instance_types_preemptibles")
|
|
1673
1943
|
|
|
1674
|
-
@property
|
|
1944
|
+
@_builtins.property
|
|
1675
1945
|
@pulumi.getter(name="integrationDockerSwarm")
|
|
1676
1946
|
def integration_docker_swarm(self) -> pulumi.Output[Optional['outputs.ElastigroupIntegrationDockerSwarm']]:
|
|
1677
1947
|
return pulumi.get(self, "integration_docker_swarm")
|
|
1678
1948
|
|
|
1679
|
-
@property
|
|
1949
|
+
@_builtins.property
|
|
1680
1950
|
@pulumi.getter(name="integrationGke")
|
|
1681
1951
|
def integration_gke(self) -> pulumi.Output[Optional['outputs.ElastigroupIntegrationGke']]:
|
|
1682
1952
|
return pulumi.get(self, "integration_gke")
|
|
1683
1953
|
|
|
1684
|
-
@property
|
|
1954
|
+
@_builtins.property
|
|
1685
1955
|
@pulumi.getter(name="ipForwarding")
|
|
1686
|
-
def ip_forwarding(self) -> pulumi.Output[Optional[bool]]:
|
|
1956
|
+
def ip_forwarding(self) -> pulumi.Output[Optional[_builtins.bool]]:
|
|
1687
1957
|
return pulumi.get(self, "ip_forwarding")
|
|
1688
1958
|
|
|
1689
|
-
@property
|
|
1959
|
+
@_builtins.property
|
|
1690
1960
|
@pulumi.getter
|
|
1691
1961
|
def labels(self) -> pulumi.Output[Optional[Sequence['outputs.ElastigroupLabel']]]:
|
|
1692
1962
|
"""
|
|
@@ -1694,15 +1964,15 @@ class Elastigroup(pulumi.CustomResource):
|
|
|
1694
1964
|
"""
|
|
1695
1965
|
return pulumi.get(self, "labels")
|
|
1696
1966
|
|
|
1697
|
-
@property
|
|
1967
|
+
@_builtins.property
|
|
1698
1968
|
@pulumi.getter(name="maxSize")
|
|
1699
|
-
def max_size(self) -> pulumi.Output[int]:
|
|
1969
|
+
def max_size(self) -> pulumi.Output[_builtins.int]:
|
|
1700
1970
|
"""
|
|
1701
1971
|
The maximum number of instances the group should have at any time.
|
|
1702
1972
|
"""
|
|
1703
1973
|
return pulumi.get(self, "max_size")
|
|
1704
1974
|
|
|
1705
|
-
@property
|
|
1975
|
+
@_builtins.property
|
|
1706
1976
|
@pulumi.getter
|
|
1707
1977
|
def metadatas(self) -> pulumi.Output[Optional[Sequence['outputs.ElastigroupMetadata']]]:
|
|
1708
1978
|
"""
|
|
@@ -1710,88 +1980,136 @@ class Elastigroup(pulumi.CustomResource):
|
|
|
1710
1980
|
"""
|
|
1711
1981
|
return pulumi.get(self, "metadatas")
|
|
1712
1982
|
|
|
1713
|
-
@property
|
|
1983
|
+
@_builtins.property
|
|
1984
|
+
@pulumi.getter(name="minCpuPlatform")
|
|
1985
|
+
def min_cpu_platform(self) -> pulumi.Output[Optional[_builtins.str]]:
|
|
1986
|
+
"""
|
|
1987
|
+
Select a minimum CPU platform for the compute instance.
|
|
1988
|
+
"""
|
|
1989
|
+
return pulumi.get(self, "min_cpu_platform")
|
|
1990
|
+
|
|
1991
|
+
@_builtins.property
|
|
1714
1992
|
@pulumi.getter(name="minSize")
|
|
1715
|
-
def min_size(self) -> pulumi.Output[int]:
|
|
1993
|
+
def min_size(self) -> pulumi.Output[_builtins.int]:
|
|
1716
1994
|
"""
|
|
1717
1995
|
The minimum number of instances the group should have at any time.
|
|
1718
1996
|
"""
|
|
1719
1997
|
return pulumi.get(self, "min_size")
|
|
1720
1998
|
|
|
1721
|
-
@property
|
|
1999
|
+
@_builtins.property
|
|
1722
2000
|
@pulumi.getter
|
|
1723
|
-
def name(self) -> pulumi.Output[str]:
|
|
2001
|
+
def name(self) -> pulumi.Output[_builtins.str]:
|
|
1724
2002
|
"""
|
|
1725
2003
|
The group name.
|
|
1726
2004
|
"""
|
|
1727
2005
|
return pulumi.get(self, "name")
|
|
1728
2006
|
|
|
1729
|
-
@property
|
|
2007
|
+
@_builtins.property
|
|
1730
2008
|
@pulumi.getter(name="networkInterfaces")
|
|
1731
2009
|
def network_interfaces(self) -> pulumi.Output[Optional[Sequence['outputs.ElastigroupNetworkInterface']]]:
|
|
1732
2010
|
return pulumi.get(self, "network_interfaces")
|
|
1733
2011
|
|
|
1734
|
-
@property
|
|
2012
|
+
@_builtins.property
|
|
1735
2013
|
@pulumi.getter(name="ondemandCount")
|
|
1736
|
-
def ondemand_count(self) -> pulumi.Output[Optional[int]]:
|
|
2014
|
+
def ondemand_count(self) -> pulumi.Output[Optional[_builtins.int]]:
|
|
1737
2015
|
return pulumi.get(self, "ondemand_count")
|
|
1738
2016
|
|
|
1739
|
-
@property
|
|
2017
|
+
@_builtins.property
|
|
2018
|
+
@pulumi.getter(name="optimizationWindows")
|
|
2019
|
+
def optimization_windows(self) -> pulumi.Output[Optional[Sequence[_builtins.str]]]:
|
|
2020
|
+
"""
|
|
2021
|
+
Set time window to perform the revert to preemptible. Time windows must be at least 120 minutes. Format: DayInWeek:HH-DayInWeek:HH. Required when strategy.revertToPreemptible.performAt is 'timeWindow'.
|
|
2022
|
+
"""
|
|
2023
|
+
return pulumi.get(self, "optimization_windows")
|
|
2024
|
+
|
|
2025
|
+
@_builtins.property
|
|
1740
2026
|
@pulumi.getter(name="preemptiblePercentage")
|
|
1741
|
-
def preemptible_percentage(self) -> pulumi.Output[Optional[int]]:
|
|
2027
|
+
def preemptible_percentage(self) -> pulumi.Output[Optional[_builtins.int]]:
|
|
1742
2028
|
"""
|
|
1743
2029
|
Percentage of Preemptible VMs to spin up from the "desired_capacity".
|
|
1744
2030
|
"""
|
|
1745
2031
|
return pulumi.get(self, "preemptible_percentage")
|
|
1746
2032
|
|
|
1747
|
-
@property
|
|
2033
|
+
@_builtins.property
|
|
2034
|
+
@pulumi.getter(name="preferredAvailabilityZones")
|
|
2035
|
+
def preferred_availability_zones(self) -> pulumi.Output[Optional[Sequence[_builtins.str]]]:
|
|
2036
|
+
"""
|
|
2037
|
+
prioritize availability zones when launching instances for the group. Must be a sublist of `availability_zones`.
|
|
2038
|
+
"""
|
|
2039
|
+
return pulumi.get(self, "preferred_availability_zones")
|
|
2040
|
+
|
|
2041
|
+
@_builtins.property
|
|
1748
2042
|
@pulumi.getter(name="provisioningModel")
|
|
1749
|
-
def provisioning_model(self) -> pulumi.Output[Optional[str]]:
|
|
2043
|
+
def provisioning_model(self) -> pulumi.Output[Optional[_builtins.str]]:
|
|
1750
2044
|
"""
|
|
1751
2045
|
Valid values: "SPOT", "PREEMPTIBLE". Define the provisioning model of the launched instances. Default value is "PREEMPTIBLE".
|
|
1752
2046
|
"""
|
|
1753
2047
|
return pulumi.get(self, "provisioning_model")
|
|
1754
2048
|
|
|
1755
|
-
@property
|
|
2049
|
+
@_builtins.property
|
|
2050
|
+
@pulumi.getter(name="revertToPreemptibles")
|
|
2051
|
+
def revert_to_preemptibles(self) -> pulumi.Output[Optional[Sequence['outputs.ElastigroupRevertToPreemptible']]]:
|
|
2052
|
+
"""
|
|
2053
|
+
Setting for revert to preemptible option.
|
|
2054
|
+
"""
|
|
2055
|
+
return pulumi.get(self, "revert_to_preemptibles")
|
|
2056
|
+
|
|
2057
|
+
@_builtins.property
|
|
1756
2058
|
@pulumi.getter(name="scalingDownPolicies")
|
|
1757
2059
|
def scaling_down_policies(self) -> pulumi.Output[Optional[Sequence['outputs.ElastigroupScalingDownPolicy']]]:
|
|
1758
2060
|
return pulumi.get(self, "scaling_down_policies")
|
|
1759
2061
|
|
|
1760
|
-
@property
|
|
2062
|
+
@_builtins.property
|
|
1761
2063
|
@pulumi.getter(name="scalingUpPolicies")
|
|
1762
2064
|
def scaling_up_policies(self) -> pulumi.Output[Optional[Sequence['outputs.ElastigroupScalingUpPolicy']]]:
|
|
1763
2065
|
return pulumi.get(self, "scaling_up_policies")
|
|
1764
2066
|
|
|
1765
|
-
@property
|
|
2067
|
+
@_builtins.property
|
|
1766
2068
|
@pulumi.getter(name="scheduledTasks")
|
|
1767
2069
|
def scheduled_tasks(self) -> pulumi.Output[Optional[Sequence['outputs.ElastigroupScheduledTask']]]:
|
|
1768
2070
|
return pulumi.get(self, "scheduled_tasks")
|
|
1769
2071
|
|
|
1770
|
-
@property
|
|
2072
|
+
@_builtins.property
|
|
1771
2073
|
@pulumi.getter(name="serviceAccount")
|
|
1772
|
-
def service_account(self) -> pulumi.Output[Optional[str]]:
|
|
2074
|
+
def service_account(self) -> pulumi.Output[Optional[_builtins.str]]:
|
|
1773
2075
|
"""
|
|
1774
2076
|
The email of the service account in which the group instances will be launched.
|
|
1775
2077
|
"""
|
|
1776
2078
|
return pulumi.get(self, "service_account")
|
|
1777
2079
|
|
|
1778
|
-
@property
|
|
2080
|
+
@_builtins.property
|
|
2081
|
+
@pulumi.getter(name="shieldedInstanceConfig")
|
|
2082
|
+
def shielded_instance_config(self) -> pulumi.Output[Optional['outputs.ElastigroupShieldedInstanceConfig']]:
|
|
2083
|
+
"""
|
|
2084
|
+
You can use secure boot when you launch VMs using Elastigroup. This helps you comply with your security policies. In the instance configuration, use ‘secureBootEnabled’ set to True to enforce UEFI with secure boot. Elastigroup provisions VMs with secure boot, as long as the images supports UEFI.
|
|
2085
|
+
"""
|
|
2086
|
+
return pulumi.get(self, "shielded_instance_config")
|
|
2087
|
+
|
|
2088
|
+
@_builtins.property
|
|
2089
|
+
@pulumi.getter(name="shouldUtilizeCommitments")
|
|
2090
|
+
def should_utilize_commitments(self) -> pulumi.Output[Optional[_builtins.bool]]:
|
|
2091
|
+
"""
|
|
2092
|
+
Enable committed use discounts utilization.
|
|
2093
|
+
"""
|
|
2094
|
+
return pulumi.get(self, "should_utilize_commitments")
|
|
2095
|
+
|
|
2096
|
+
@_builtins.property
|
|
1779
2097
|
@pulumi.getter(name="shutdownScript")
|
|
1780
|
-
def shutdown_script(self) -> pulumi.Output[Optional[str]]:
|
|
2098
|
+
def shutdown_script(self) -> pulumi.Output[Optional[_builtins.str]]:
|
|
1781
2099
|
"""
|
|
1782
2100
|
The Base64-encoded shutdown script that executes prior to instance termination, for more information please see: [Shutdown Script](https://api.spotinst.com/integration-docs/elastigroup/concepts/compute-concepts/shutdown-scripts/)
|
|
1783
2101
|
"""
|
|
1784
2102
|
return pulumi.get(self, "shutdown_script")
|
|
1785
2103
|
|
|
1786
|
-
@property
|
|
2104
|
+
@_builtins.property
|
|
1787
2105
|
@pulumi.getter(name="startupScript")
|
|
1788
|
-
def startup_script(self) -> pulumi.Output[Optional[str]]:
|
|
2106
|
+
def startup_script(self) -> pulumi.Output[Optional[_builtins.str]]:
|
|
1789
2107
|
"""
|
|
1790
2108
|
Create and run your own startup scripts on your virtual machines to perform automated tasks every time your instance boots up.
|
|
1791
2109
|
"""
|
|
1792
2110
|
return pulumi.get(self, "startup_script")
|
|
1793
2111
|
|
|
1794
|
-
@property
|
|
2112
|
+
@_builtins.property
|
|
1795
2113
|
@pulumi.getter
|
|
1796
2114
|
def subnets(self) -> pulumi.Output[Optional[Sequence['outputs.ElastigroupSubnet']]]:
|
|
1797
2115
|
"""
|
|
@@ -1799,16 +2117,16 @@ class Elastigroup(pulumi.CustomResource):
|
|
|
1799
2117
|
"""
|
|
1800
2118
|
return pulumi.get(self, "subnets")
|
|
1801
2119
|
|
|
1802
|
-
@property
|
|
2120
|
+
@_builtins.property
|
|
1803
2121
|
@pulumi.getter
|
|
1804
|
-
def tags(self) -> pulumi.Output[Optional[Sequence[str]]]:
|
|
2122
|
+
def tags(self) -> pulumi.Output[Optional[Sequence[_builtins.str]]]:
|
|
1805
2123
|
"""
|
|
1806
2124
|
Tags to mark created instances.
|
|
1807
2125
|
"""
|
|
1808
2126
|
return pulumi.get(self, "tags")
|
|
1809
2127
|
|
|
1810
|
-
@property
|
|
2128
|
+
@_builtins.property
|
|
1811
2129
|
@pulumi.getter(name="unhealthyDuration")
|
|
1812
|
-
def unhealthy_duration(self) -> pulumi.Output[Optional[int]]:
|
|
2130
|
+
def unhealthy_duration(self) -> pulumi.Output[Optional[_builtins.int]]:
|
|
1813
2131
|
return pulumi.get(self, "unhealthy_duration")
|
|
1814
2132
|
|