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,35 +21,36 @@ __all__ = ['ElastigroupArgs', 'Elastigroup']
|
|
|
16
21
|
@pulumi.input_type
|
|
17
22
|
class ElastigroupArgs:
|
|
18
23
|
def __init__(__self__, *,
|
|
19
|
-
fallback_to_ondemand: pulumi.Input[bool],
|
|
20
|
-
orientation: pulumi.Input[str],
|
|
21
|
-
product: pulumi.Input[str],
|
|
22
|
-
security_groups: pulumi.Input[Sequence[pulumi.Input[str]]],
|
|
23
|
-
|
|
24
|
-
|
|
25
|
-
|
|
26
|
-
|
|
27
|
-
|
|
24
|
+
fallback_to_ondemand: pulumi.Input[_builtins.bool],
|
|
25
|
+
orientation: pulumi.Input[_builtins.str],
|
|
26
|
+
product: pulumi.Input[_builtins.str],
|
|
27
|
+
security_groups: pulumi.Input[Sequence[pulumi.Input[_builtins.str]]],
|
|
28
|
+
auto_healing: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
29
|
+
availability_zones: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
30
|
+
block_devices_mode: Optional[pulumi.Input[_builtins.str]] = None,
|
|
31
|
+
capacity_unit: Optional[pulumi.Input[_builtins.str]] = None,
|
|
32
|
+
consider_od_pricing: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
33
|
+
cpu_credits: Optional[pulumi.Input[_builtins.str]] = None,
|
|
28
34
|
cpu_options: Optional[pulumi.Input['ElastigroupCpuOptionsArgs']] = None,
|
|
29
|
-
description: Optional[pulumi.Input[str]] = None,
|
|
30
|
-
desired_capacity: Optional[pulumi.Input[int]] = None,
|
|
31
|
-
draining_timeout: Optional[pulumi.Input[int]] = None,
|
|
35
|
+
description: Optional[pulumi.Input[_builtins.str]] = None,
|
|
36
|
+
desired_capacity: Optional[pulumi.Input[_builtins.int]] = None,
|
|
37
|
+
draining_timeout: Optional[pulumi.Input[_builtins.int]] = None,
|
|
32
38
|
ebs_block_devices: Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupEbsBlockDeviceArgs']]]] = None,
|
|
33
|
-
ebs_optimized: Optional[pulumi.Input[bool]] = None,
|
|
34
|
-
elastic_ips: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
|
|
35
|
-
elastic_load_balancers: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
|
|
36
|
-
enable_monitoring: Optional[pulumi.Input[bool]] = None,
|
|
39
|
+
ebs_optimized: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
40
|
+
elastic_ips: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
41
|
+
elastic_load_balancers: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
42
|
+
enable_monitoring: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
37
43
|
ephemeral_block_devices: Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupEphemeralBlockDeviceArgs']]]] = None,
|
|
38
|
-
health_check_grace_period: Optional[pulumi.Input[int]] = None,
|
|
39
|
-
health_check_type: Optional[pulumi.Input[str]] = None,
|
|
40
|
-
health_check_unhealthy_duration_before_replacement: Optional[pulumi.Input[int]] = None,
|
|
41
|
-
iam_instance_profile: Optional[pulumi.Input[str]] = None,
|
|
42
|
-
image_id: Optional[pulumi.Input[str]] = None,
|
|
44
|
+
health_check_grace_period: Optional[pulumi.Input[_builtins.int]] = None,
|
|
45
|
+
health_check_type: Optional[pulumi.Input[_builtins.str]] = None,
|
|
46
|
+
health_check_unhealthy_duration_before_replacement: Optional[pulumi.Input[_builtins.int]] = None,
|
|
47
|
+
iam_instance_profile: Optional[pulumi.Input[_builtins.str]] = None,
|
|
48
|
+
image_id: Optional[pulumi.Input[_builtins.str]] = None,
|
|
43
49
|
images: Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupImageArgs']]]] = None,
|
|
44
|
-
immediate_od_recover_threshold: Optional[pulumi.Input[int]] = None,
|
|
45
|
-
instance_types_ondemand: Optional[pulumi.Input[str]] = None,
|
|
46
|
-
instance_types_preferred_spots: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
|
|
47
|
-
instance_types_spots: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
|
|
50
|
+
immediate_od_recover_threshold: Optional[pulumi.Input[_builtins.int]] = None,
|
|
51
|
+
instance_types_ondemand: Optional[pulumi.Input[_builtins.str]] = None,
|
|
52
|
+
instance_types_preferred_spots: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
53
|
+
instance_types_spots: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
48
54
|
instance_types_weights: Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupInstanceTypesWeightArgs']]]] = None,
|
|
49
55
|
integration_beanstalk: Optional[pulumi.Input['ElastigroupIntegrationBeanstalkArgs']] = None,
|
|
50
56
|
integration_codedeploy: Optional[pulumi.Input['ElastigroupIntegrationCodedeployArgs']] = None,
|
|
@@ -57,109 +63,115 @@ class ElastigroupArgs:
|
|
|
57
63
|
integration_rancher: Optional[pulumi.Input['ElastigroupIntegrationRancherArgs']] = None,
|
|
58
64
|
integration_route53: Optional[pulumi.Input['ElastigroupIntegrationRoute53Args']] = None,
|
|
59
65
|
itfs: Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupItfArgs']]]] = None,
|
|
60
|
-
key_name: Optional[pulumi.Input[str]] = None,
|
|
61
|
-
lifetime_period: Optional[pulumi.Input[str]] = None,
|
|
66
|
+
key_name: Optional[pulumi.Input[_builtins.str]] = None,
|
|
67
|
+
lifetime_period: Optional[pulumi.Input[_builtins.str]] = None,
|
|
62
68
|
logging: Optional[pulumi.Input['ElastigroupLoggingArgs']] = None,
|
|
63
|
-
|
|
69
|
+
max_replacements_percentage: Optional[pulumi.Input[_builtins.int]] = None,
|
|
70
|
+
max_size: Optional[pulumi.Input[_builtins.int]] = None,
|
|
64
71
|
metadata_options: Optional[pulumi.Input['ElastigroupMetadataOptionsArgs']] = None,
|
|
65
|
-
min_size: Optional[pulumi.Input[int]] = None,
|
|
66
|
-
minimum_instance_lifetime: Optional[pulumi.Input[int]] = None,
|
|
72
|
+
min_size: Optional[pulumi.Input[_builtins.int]] = None,
|
|
73
|
+
minimum_instance_lifetime: Optional[pulumi.Input[_builtins.int]] = None,
|
|
67
74
|
multiple_metrics: Optional[pulumi.Input['ElastigroupMultipleMetricsArgs']] = None,
|
|
68
|
-
name: Optional[pulumi.Input[str]] = None,
|
|
75
|
+
name: Optional[pulumi.Input[_builtins.str]] = None,
|
|
69
76
|
network_interfaces: Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupNetworkInterfaceArgs']]]] = None,
|
|
70
|
-
on_demand_types: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
|
|
71
|
-
ondemand_count: Optional[pulumi.Input[int]] = None,
|
|
72
|
-
persist_block_devices: Optional[pulumi.Input[bool]] = None,
|
|
73
|
-
persist_private_ip: Optional[pulumi.Input[bool]] = None,
|
|
74
|
-
persist_root_device: Optional[pulumi.Input[bool]] = None,
|
|
75
|
-
placement_tenancy: Optional[pulumi.Input[str]] = None,
|
|
76
|
-
preferred_availability_zones: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
|
|
77
|
-
private_ips: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
|
|
78
|
-
region: Optional[pulumi.Input[str]] = None,
|
|
77
|
+
on_demand_types: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
78
|
+
ondemand_count: Optional[pulumi.Input[_builtins.int]] = None,
|
|
79
|
+
persist_block_devices: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
80
|
+
persist_private_ip: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
81
|
+
persist_root_device: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
82
|
+
placement_tenancy: Optional[pulumi.Input[_builtins.str]] = None,
|
|
83
|
+
preferred_availability_zones: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
84
|
+
private_ips: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
85
|
+
region: Optional[pulumi.Input[_builtins.str]] = None,
|
|
79
86
|
resource_requirements: Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupResourceRequirementArgs']]]] = None,
|
|
80
87
|
resource_tag_specifications: Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupResourceTagSpecificationArgs']]]] = None,
|
|
88
|
+
restrict_single_az: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
81
89
|
revert_to_spot: Optional[pulumi.Input['ElastigroupRevertToSpotArgs']] = None,
|
|
82
90
|
scaling_down_policies: Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupScalingDownPolicyArgs']]]] = None,
|
|
83
91
|
scaling_strategies: Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupScalingStrategyArgs']]]] = None,
|
|
84
92
|
scaling_target_policies: Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupScalingTargetPolicyArgs']]]] = None,
|
|
85
93
|
scaling_up_policies: Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupScalingUpPolicyArgs']]]] = None,
|
|
86
94
|
scheduled_tasks: Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupScheduledTaskArgs']]]] = None,
|
|
87
|
-
shutdown_script: Optional[pulumi.Input[str]] = None,
|
|
95
|
+
shutdown_script: Optional[pulumi.Input[_builtins.str]] = None,
|
|
88
96
|
signals: Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupSignalArgs']]]] = None,
|
|
89
|
-
spot_percentage: Optional[pulumi.Input[int]] = None,
|
|
97
|
+
spot_percentage: Optional[pulumi.Input[_builtins.int]] = None,
|
|
90
98
|
stateful_deallocation: Optional[pulumi.Input['ElastigroupStatefulDeallocationArgs']] = None,
|
|
91
99
|
stateful_instance_actions: Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupStatefulInstanceActionArgs']]]] = None,
|
|
92
|
-
subnet_ids: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
|
|
100
|
+
subnet_ids: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
93
101
|
tags: Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupTagArgs']]]] = None,
|
|
94
|
-
target_group_arns: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
|
|
102
|
+
target_group_arns: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
95
103
|
update_policy: Optional[pulumi.Input['ElastigroupUpdatePolicyArgs']] = None,
|
|
96
|
-
user_data: Optional[pulumi.Input[str]] = None,
|
|
97
|
-
utilize_commitments: Optional[pulumi.Input[bool]] = None,
|
|
98
|
-
utilize_reserved_instances: Optional[pulumi.Input[bool]] = None,
|
|
99
|
-
wait_for_capacity: Optional[pulumi.Input[int]] = None,
|
|
100
|
-
wait_for_capacity_timeout: Optional[pulumi.Input[int]] = None):
|
|
104
|
+
user_data: Optional[pulumi.Input[_builtins.str]] = None,
|
|
105
|
+
utilize_commitments: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
106
|
+
utilize_reserved_instances: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
107
|
+
wait_for_capacity: Optional[pulumi.Input[_builtins.int]] = None,
|
|
108
|
+
wait_for_capacity_timeout: Optional[pulumi.Input[_builtins.int]] = None):
|
|
101
109
|
"""
|
|
102
110
|
The set of arguments for constructing a Elastigroup resource.
|
|
103
|
-
:param pulumi.Input[bool] fallback_to_ondemand: In a case of no Spot instances available, Elastigroup will launch on-demand instances instead.
|
|
104
|
-
:param pulumi.Input[str] orientation: Select a prediction strategy. Valid values: `balanced`, `costOriented`, `equalAzDistribution`, `availabilityOriented`. You can read more in our documentation.
|
|
105
|
-
:param pulumi.Input[str] product: Operation system type. Valid values: `"Linux/UNIX"`, `"SUSE Linux"`, `"Windows"`.
|
|
106
|
-
For EC2 Classic instances:
|
|
107
|
-
:param pulumi.Input[Sequence[pulumi.Input[str]]] security_groups: A list of associated security group IDS.
|
|
108
|
-
:param pulumi.Input[
|
|
111
|
+
:param pulumi.Input[_builtins.bool] fallback_to_ondemand: In a case of no Spot instances available, Elastigroup will launch on-demand instances instead.
|
|
112
|
+
:param pulumi.Input[_builtins.str] orientation: Select a prediction strategy. Valid values: `balanced`, `costOriented`, `equalAzDistribution`, `availabilityOriented`. You can read more in our documentation.
|
|
113
|
+
:param pulumi.Input[_builtins.str] product: Operation system type. Valid values: `"Linux/UNIX"`, `"SUSE Linux"`, `"Windows"`.
|
|
114
|
+
For EC2 Classic instances: `"SUSE Linux (Amazon VPC)"`, `"Windows (Amazon VPC)"`.
|
|
115
|
+
:param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] security_groups: A list of associated security group IDS.
|
|
116
|
+
:param pulumi.Input[_builtins.bool] auto_healing: Auto-healing replacement won't be triggered if this parameter value is "false". In a case of a stateful group - no recycling will start if this parameter value is "false".
|
|
117
|
+
:param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] availability_zones: List of Strings of availability zones. When this parameter is set, `subnet_ids` should be left unused.
|
|
109
118
|
Note: `availability_zones` naming syntax follows the convention `availability-zone:subnet:placement-group-name`. For example, to set an AZ in `us-east-1` with subnet `subnet-123456` and placement group `ClusterI03`, you would set:
|
|
110
119
|
`availability_zones = ["us-east-1a:subnet-123456:ClusterI03"]`
|
|
111
|
-
:param pulumi.Input[str] capacity_unit: The capacity unit to launch instances by. If not specified, when choosing the weight unit, each instance will weight as the number of its vCPUs. Valid values: `instance`, `weight`.
|
|
112
|
-
:param pulumi.Input[str] cpu_credits: Controls how T3 instances are launched. Valid values: `standard`, `unlimited`.
|
|
120
|
+
:param pulumi.Input[_builtins.str] capacity_unit: The capacity unit to launch instances by. If not specified, when choosing the weight unit, each instance will weight as the number of its vCPUs. Valid values: `instance`, `weight`.
|
|
121
|
+
:param pulumi.Input[_builtins.str] cpu_credits: Controls how T3 instances are launched. Valid values: `standard`, `unlimited`.
|
|
113
122
|
:param pulumi.Input['ElastigroupCpuOptionsArgs'] cpu_options: The CPU options for the instances that are launched within the group:
|
|
114
|
-
:param pulumi.Input[str] description: The group description.
|
|
115
|
-
:param pulumi.Input[int] desired_capacity: The desired number of instances the group should have at any time.
|
|
116
|
-
:param pulumi.Input[int] draining_timeout: The time in seconds, the instance is allowed to run while detached from the ELB. This is to allow the instance time to be drained from incoming TCP connections before terminating it, during a scale down operation.
|
|
117
|
-
:param pulumi.Input[bool] ebs_optimized: Enable high bandwidth connectivity between instances and AWS’s Elastic Block Store (EBS). For instance types that are EBS-optimized by default this parameter will be ignored.
|
|
118
|
-
:param pulumi.Input[Sequence[pulumi.Input[str]]] elastic_ips: A list of [AWS Elastic IP](http://docs.aws.amazon.com/AWSEC2/latest/UserGuide/elastic-ip-addresses-eip.html) allocation IDs to associate to the group instances.
|
|
119
|
-
:param pulumi.Input[bool] enable_monitoring: Indicates whether monitoring is enabled for the instance.
|
|
120
|
-
:param pulumi.Input[int] health_check_grace_period: The amount of time, in seconds, after the instance has launched to starts and check its health.
|
|
121
|
-
:param pulumi.Input[str] health_check_type: The service that will perform health checks for the instance. Valid values: `"ELB"`, `"HCS"`, `"TARGET_GROUP"`, `"EC2"`, `"K8S_NODE"`, `"NOMAD_NODE"`, `"ECS_CLUSTER_INSTANCE"`.
|
|
122
|
-
:param pulumi.Input[int] health_check_unhealthy_duration_before_replacement: The amount of time, in seconds, that we will wait before replacing an instance that is running and became unhealthy (this is only applicable for instances that were once healthy).
|
|
123
|
-
:param pulumi.Input[str] iam_instance_profile: The ARN or name of an IAM instance profile to associate with launched instances.
|
|
124
|
-
:param pulumi.Input[str] image_id: The ID of the AMI used to launch the instance.
|
|
123
|
+
:param pulumi.Input[_builtins.str] description: The group description.
|
|
124
|
+
:param pulumi.Input[_builtins.int] desired_capacity: The desired number of instances the group should have at any time.
|
|
125
|
+
:param pulumi.Input[_builtins.int] draining_timeout: The time in seconds, the instance is allowed to run while detached from the ELB. This is to allow the instance time to be drained from incoming TCP connections before terminating it, during a scale down operation.
|
|
126
|
+
:param pulumi.Input[_builtins.bool] ebs_optimized: Enable high bandwidth connectivity between instances and AWS’s Elastic Block Store (EBS). For instance types that are EBS-optimized by default this parameter will be ignored.
|
|
127
|
+
:param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] elastic_ips: A list of [AWS Elastic IP](http://docs.aws.amazon.com/AWSEC2/latest/UserGuide/elastic-ip-addresses-eip.html) allocation IDs to associate to the group instances.
|
|
128
|
+
:param pulumi.Input[_builtins.bool] enable_monitoring: Indicates whether monitoring is enabled for the instance.
|
|
129
|
+
:param pulumi.Input[_builtins.int] health_check_grace_period: The amount of time, in seconds, after the instance has launched to starts and check its health.
|
|
130
|
+
:param pulumi.Input[_builtins.str] health_check_type: The service that will perform health checks for the instance. Valid values: `"ELB"`, `"HCS"`, `"TARGET_GROUP"`, `"EC2"`, `"K8S_NODE"`, `"NOMAD_NODE"`, `"ECS_CLUSTER_INSTANCE"`.
|
|
131
|
+
:param pulumi.Input[_builtins.int] health_check_unhealthy_duration_before_replacement: The amount of time, in seconds, that we will wait before replacing an instance that is running and became unhealthy (this is only applicable for instances that were once healthy).
|
|
132
|
+
:param pulumi.Input[_builtins.str] iam_instance_profile: The ARN or name of an IAM instance profile to associate with launched instances.
|
|
133
|
+
:param pulumi.Input[_builtins.str] image_id: The ID of the AMI used to launch the instance.
|
|
125
134
|
:param pulumi.Input[Sequence[pulumi.Input['ElastigroupImageArgs']]] images: An array of image objects.
|
|
126
135
|
Note: Elastigroup can be configured with either imageId or images, but not both.
|
|
127
|
-
:param pulumi.Input[str] instance_types_ondemand: The type of instance determines your instance's CPU capacity, memory and storage (e.g., m1.small, c1.xlarge).
|
|
128
|
-
:param pulumi.Input[Sequence[pulumi.Input[str]]] instance_types_preferred_spots: Prioritize a subset of spot instance types. Must be a subset of the selected spot instance types.
|
|
129
|
-
:param pulumi.Input[Sequence[pulumi.Input[str]]] instance_types_spots: One or more instance types. Note: Cannot be defined if 'resourceRequirements' is defined.
|
|
136
|
+
:param pulumi.Input[_builtins.str] instance_types_ondemand: The type of instance determines your instance's CPU capacity, memory and storage (e.g., m1.small, c1.xlarge).
|
|
137
|
+
:param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] instance_types_preferred_spots: Prioritize a subset of spot instance types. Must be a subset of the selected spot instance types.
|
|
138
|
+
:param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] instance_types_spots: One or more instance types. Note: Cannot be defined if 'resourceRequirements' is defined.
|
|
130
139
|
:param pulumi.Input[Sequence[pulumi.Input['ElastigroupInstanceTypesWeightArgs']]] instance_types_weights: List of weights per instance type for weighted groups. Each object in the list should have the following attributes:
|
|
131
|
-
:param pulumi.Input[str] key_name: The key name that should be used for the instance.
|
|
140
|
+
:param pulumi.Input[_builtins.str] key_name: The key name that should be used for the instance.
|
|
132
141
|
:param pulumi.Input['ElastigroupLoggingArgs'] logging: Logging configuration.
|
|
133
|
-
:param pulumi.Input[int] max_size: The maximum number of instances the group should have at any time.
|
|
142
|
+
:param pulumi.Input[_builtins.int] max_size: The maximum number of instances the group should have at any time.
|
|
134
143
|
:param pulumi.Input['ElastigroupMetadataOptionsArgs'] metadata_options: Data that used to configure or manage the running instances:
|
|
135
|
-
:param pulumi.Input[int] min_size: The minimum number of instances the group should have at any time.
|
|
136
|
-
:param pulumi.Input[int] minimum_instance_lifetime: Defines the preferred minimum instance lifetime in hours. Markets which comply with this preference will be prioritized. Optional values: 1, 3, 6, 12, 24.
|
|
137
|
-
:param pulumi.Input[str] name: The group name.
|
|
138
|
-
:param pulumi.Input[Sequence[pulumi.Input[str]]] on_demand_types: Available ondemand instance types. Note: Either ondemand or onDemandTypes must be defined, but not both.
|
|
139
|
-
:param pulumi.Input[int] ondemand_count: Number of on demand instances to launch in the group. All other instances will be spot instances. When this parameter is set the `spot_percentage` parameter is being ignored.
|
|
140
|
-
:param pulumi.Input[str] placement_tenancy: Enable dedicated tenancy. Note: There is a flat hourly fee for each region in which dedicated tenancy is used. Valid values: "default", "dedicated" .
|
|
141
|
-
:param pulumi.Input[Sequence[pulumi.Input[str]]] preferred_availability_zones: The AZs to prioritize when launching Spot instances. If no markets are available in the Preferred AZs, Spot instances are launched in the non-preferred AZs.
|
|
144
|
+
:param pulumi.Input[_builtins.int] min_size: The minimum number of instances the group should have at any time.
|
|
145
|
+
:param pulumi.Input[_builtins.int] minimum_instance_lifetime: Defines the preferred minimum instance lifetime in hours. Markets which comply with this preference will be prioritized. Optional values: 1, 3, 6, 12, 24.
|
|
146
|
+
:param pulumi.Input[_builtins.str] name: The group name.
|
|
147
|
+
:param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] on_demand_types: Available ondemand instance types. Note: Either ondemand or onDemandTypes must be defined, but not both.
|
|
148
|
+
:param pulumi.Input[_builtins.int] ondemand_count: Number of on demand instances to launch in the group. All other instances will be spot instances. When this parameter is set the `spot_percentage` parameter is being ignored.
|
|
149
|
+
:param pulumi.Input[_builtins.str] placement_tenancy: Enable dedicated tenancy. Note: There is a flat hourly fee for each region in which dedicated tenancy is used. Valid values: "default", "dedicated" .
|
|
150
|
+
:param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] preferred_availability_zones: The AZs to prioritize when launching Spot instances. If no markets are available in the Preferred AZs, Spot instances are launched in the non-preferred AZs.
|
|
142
151
|
Note: Must be a sublist of `availability_zones` and `orientation` value must not be `"equalAzDistribution"`.
|
|
143
|
-
:param pulumi.Input[str] region: The AWS region your group will be created in.
|
|
152
|
+
:param pulumi.Input[_builtins.str] region: The AWS region your group will be created in.
|
|
144
153
|
Note: This parameter is required if you specify subnets (through subnet_ids). This parameter is optional if you specify Availability Zones (through availability_zones).
|
|
145
154
|
:param pulumi.Input[Sequence[pulumi.Input['ElastigroupResourceRequirementArgs']]] resource_requirements: Required instance attributes. Instance types will be selected based on these requirements.
|
|
146
155
|
:param pulumi.Input[Sequence[pulumi.Input['ElastigroupResourceTagSpecificationArgs']]] resource_tag_specifications: User will specify which resources should be tagged with group tags.
|
|
156
|
+
:param pulumi.Input[_builtins.bool] restrict_single_az: Elastigroup will automatically scale your instances in the most available and cost efficient availability zone. Every evaluation will be done when there are no active instances in the group.
|
|
147
157
|
:param pulumi.Input['ElastigroupRevertToSpotArgs'] revert_to_spot: Hold settings for strategy correction – replacing On-Demand for Spot instances. Supported Values: `"never"`, `"always"`, `"timeWindow"`
|
|
148
158
|
:param pulumi.Input[Sequence[pulumi.Input['ElastigroupScalingStrategyArgs']]] scaling_strategies: Set termination policy.
|
|
149
|
-
:param pulumi.Input[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/)
|
|
150
|
-
:param pulumi.Input[int] spot_percentage: The percentage of Spot instances that would spin up from the `desired_capacity` number.
|
|
151
|
-
:param pulumi.Input[Sequence[pulumi.Input[str]]] subnet_ids: List of Strings of subnet identifiers.
|
|
159
|
+
: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/)
|
|
160
|
+
:param pulumi.Input[_builtins.int] spot_percentage: The percentage of Spot instances that would spin up from the `desired_capacity` number.
|
|
161
|
+
:param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] subnet_ids: List of Strings of subnet identifiers.
|
|
152
162
|
Note: When this parameter is set, `availability_zones` should be left unused.
|
|
153
163
|
:param pulumi.Input[Sequence[pulumi.Input['ElastigroupTagArgs']]] tags: A key/value mapping of tags to assign to the resource.
|
|
154
|
-
:param pulumi.Input[str] user_data: The user data to provide when launching the instance.
|
|
155
|
-
:param pulumi.Input[bool] utilize_reserved_instances: In a case of any available reserved instances, Elastigroup will utilize them first before purchasing Spot instances.
|
|
156
|
-
:param pulumi.Input[int] wait_for_capacity: Minimum number of instances in a 'HEALTHY' status that is required before continuing. This is ignored when updating with blue/green deployment. Cannot exceed `desired_capacity`.
|
|
157
|
-
:param pulumi.Input[int] wait_for_capacity_timeout: Time (seconds) to wait for instances to report a 'HEALTHY' status. Useful for plans with multiple dependencies that take some time to initialize. Leave undefined or set to `0` to indicate no wait. This is ignored when updating with blue/green deployment.
|
|
164
|
+
:param pulumi.Input[_builtins.str] user_data: The user data to provide when launching the instance.
|
|
165
|
+
:param pulumi.Input[_builtins.bool] utilize_reserved_instances: In a case of any available reserved instances, Elastigroup will utilize them first before purchasing Spot instances.
|
|
166
|
+
:param pulumi.Input[_builtins.int] wait_for_capacity: Minimum number of instances in a 'HEALTHY' status that is required before continuing. This is ignored when updating with blue/green deployment. Cannot exceed `desired_capacity`.
|
|
167
|
+
:param pulumi.Input[_builtins.int] wait_for_capacity_timeout: Time (seconds) to wait for instances to report a 'HEALTHY' status. Useful for plans with multiple dependencies that take some time to initialize. Leave undefined or set to `0` to indicate no wait. This is ignored when updating with blue/green deployment.
|
|
158
168
|
"""
|
|
159
169
|
pulumi.set(__self__, "fallback_to_ondemand", fallback_to_ondemand)
|
|
160
170
|
pulumi.set(__self__, "orientation", orientation)
|
|
161
171
|
pulumi.set(__self__, "product", product)
|
|
162
172
|
pulumi.set(__self__, "security_groups", security_groups)
|
|
173
|
+
if auto_healing is not None:
|
|
174
|
+
pulumi.set(__self__, "auto_healing", auto_healing)
|
|
163
175
|
if availability_zones is not None:
|
|
164
176
|
pulumi.set(__self__, "availability_zones", availability_zones)
|
|
165
177
|
if block_devices_mode is not None:
|
|
@@ -240,6 +252,8 @@ class ElastigroupArgs:
|
|
|
240
252
|
pulumi.set(__self__, "lifetime_period", lifetime_period)
|
|
241
253
|
if logging is not None:
|
|
242
254
|
pulumi.set(__self__, "logging", logging)
|
|
255
|
+
if max_replacements_percentage is not None:
|
|
256
|
+
pulumi.set(__self__, "max_replacements_percentage", max_replacements_percentage)
|
|
243
257
|
if max_size is not None:
|
|
244
258
|
pulumi.set(__self__, "max_size", max_size)
|
|
245
259
|
if metadata_options is not None:
|
|
@@ -276,6 +290,8 @@ class ElastigroupArgs:
|
|
|
276
290
|
pulumi.set(__self__, "resource_requirements", resource_requirements)
|
|
277
291
|
if resource_tag_specifications is not None:
|
|
278
292
|
pulumi.set(__self__, "resource_tag_specifications", resource_tag_specifications)
|
|
293
|
+
if restrict_single_az is not None:
|
|
294
|
+
pulumi.set(__self__, "restrict_single_az", restrict_single_az)
|
|
279
295
|
if revert_to_spot is not None:
|
|
280
296
|
pulumi.set(__self__, "revert_to_spot", revert_to_spot)
|
|
281
297
|
if scaling_down_policies is not None:
|
|
@@ -298,6 +314,9 @@ class ElastigroupArgs:
|
|
|
298
314
|
pulumi.set(__self__, "stateful_deallocation", stateful_deallocation)
|
|
299
315
|
if stateful_instance_actions is not None:
|
|
300
316
|
pulumi.set(__self__, "stateful_instance_actions", stateful_instance_actions)
|
|
317
|
+
if subnet_ids is not None:
|
|
318
|
+
warnings.warn("""This field will soon be deprecated and handled by availability_zones""", DeprecationWarning)
|
|
319
|
+
pulumi.log.warn("""subnet_ids is deprecated: This field will soon be deprecated and handled by availability_zones""")
|
|
301
320
|
if subnet_ids is not None:
|
|
302
321
|
pulumi.set(__self__, "subnet_ids", subnet_ids)
|
|
303
322
|
if tags is not None:
|
|
@@ -317,58 +336,70 @@ class ElastigroupArgs:
|
|
|
317
336
|
if wait_for_capacity_timeout is not None:
|
|
318
337
|
pulumi.set(__self__, "wait_for_capacity_timeout", wait_for_capacity_timeout)
|
|
319
338
|
|
|
320
|
-
@property
|
|
339
|
+
@_builtins.property
|
|
321
340
|
@pulumi.getter(name="fallbackToOndemand")
|
|
322
|
-
def fallback_to_ondemand(self) -> pulumi.Input[bool]:
|
|
341
|
+
def fallback_to_ondemand(self) -> pulumi.Input[_builtins.bool]:
|
|
323
342
|
"""
|
|
324
343
|
In a case of no Spot instances available, Elastigroup will launch on-demand instances instead.
|
|
325
344
|
"""
|
|
326
345
|
return pulumi.get(self, "fallback_to_ondemand")
|
|
327
346
|
|
|
328
347
|
@fallback_to_ondemand.setter
|
|
329
|
-
def fallback_to_ondemand(self, value: pulumi.Input[bool]):
|
|
348
|
+
def fallback_to_ondemand(self, value: pulumi.Input[_builtins.bool]):
|
|
330
349
|
pulumi.set(self, "fallback_to_ondemand", value)
|
|
331
350
|
|
|
332
|
-
@property
|
|
351
|
+
@_builtins.property
|
|
333
352
|
@pulumi.getter
|
|
334
|
-
def orientation(self) -> pulumi.Input[str]:
|
|
353
|
+
def orientation(self) -> pulumi.Input[_builtins.str]:
|
|
335
354
|
"""
|
|
336
355
|
Select a prediction strategy. Valid values: `balanced`, `costOriented`, `equalAzDistribution`, `availabilityOriented`. You can read more in our documentation.
|
|
337
356
|
"""
|
|
338
357
|
return pulumi.get(self, "orientation")
|
|
339
358
|
|
|
340
359
|
@orientation.setter
|
|
341
|
-
def orientation(self, value: pulumi.Input[str]):
|
|
360
|
+
def orientation(self, value: pulumi.Input[_builtins.str]):
|
|
342
361
|
pulumi.set(self, "orientation", value)
|
|
343
362
|
|
|
344
|
-
@property
|
|
363
|
+
@_builtins.property
|
|
345
364
|
@pulumi.getter
|
|
346
|
-
def product(self) -> pulumi.Input[str]:
|
|
365
|
+
def product(self) -> pulumi.Input[_builtins.str]:
|
|
347
366
|
"""
|
|
348
367
|
Operation system type. Valid values: `"Linux/UNIX"`, `"SUSE Linux"`, `"Windows"`.
|
|
349
|
-
For EC2 Classic instances:
|
|
368
|
+
For EC2 Classic instances: `"SUSE Linux (Amazon VPC)"`, `"Windows (Amazon VPC)"`.
|
|
350
369
|
"""
|
|
351
370
|
return pulumi.get(self, "product")
|
|
352
371
|
|
|
353
372
|
@product.setter
|
|
354
|
-
def product(self, value: pulumi.Input[str]):
|
|
373
|
+
def product(self, value: pulumi.Input[_builtins.str]):
|
|
355
374
|
pulumi.set(self, "product", value)
|
|
356
375
|
|
|
357
|
-
@property
|
|
376
|
+
@_builtins.property
|
|
358
377
|
@pulumi.getter(name="securityGroups")
|
|
359
|
-
def security_groups(self) -> pulumi.Input[Sequence[pulumi.Input[str]]]:
|
|
378
|
+
def security_groups(self) -> pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]:
|
|
360
379
|
"""
|
|
361
380
|
A list of associated security group IDS.
|
|
362
381
|
"""
|
|
363
382
|
return pulumi.get(self, "security_groups")
|
|
364
383
|
|
|
365
384
|
@security_groups.setter
|
|
366
|
-
def security_groups(self, value: pulumi.Input[Sequence[pulumi.Input[str]]]):
|
|
385
|
+
def security_groups(self, value: pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]):
|
|
367
386
|
pulumi.set(self, "security_groups", value)
|
|
368
387
|
|
|
369
|
-
@property
|
|
388
|
+
@_builtins.property
|
|
389
|
+
@pulumi.getter(name="autoHealing")
|
|
390
|
+
def auto_healing(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
391
|
+
"""
|
|
392
|
+
Auto-healing replacement won't be triggered if this parameter value is "false". In a case of a stateful group - no recycling will start if this parameter value is "false".
|
|
393
|
+
"""
|
|
394
|
+
return pulumi.get(self, "auto_healing")
|
|
395
|
+
|
|
396
|
+
@auto_healing.setter
|
|
397
|
+
def auto_healing(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
398
|
+
pulumi.set(self, "auto_healing", value)
|
|
399
|
+
|
|
400
|
+
@_builtins.property
|
|
370
401
|
@pulumi.getter(name="availabilityZones")
|
|
371
|
-
def availability_zones(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
|
|
402
|
+
def availability_zones(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
|
|
372
403
|
"""
|
|
373
404
|
List of Strings of availability zones. When this parameter is set, `subnet_ids` should be left unused.
|
|
374
405
|
Note: `availability_zones` naming syntax follows the convention `availability-zone:subnet:placement-group-name`. For example, to set an AZ in `us-east-1` with subnet `subnet-123456` and placement group `ClusterI03`, you would set:
|
|
@@ -377,52 +408,52 @@ class ElastigroupArgs:
|
|
|
377
408
|
return pulumi.get(self, "availability_zones")
|
|
378
409
|
|
|
379
410
|
@availability_zones.setter
|
|
380
|
-
def availability_zones(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
|
|
411
|
+
def availability_zones(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]):
|
|
381
412
|
pulumi.set(self, "availability_zones", value)
|
|
382
413
|
|
|
383
|
-
@property
|
|
414
|
+
@_builtins.property
|
|
384
415
|
@pulumi.getter(name="blockDevicesMode")
|
|
385
|
-
def block_devices_mode(self) -> Optional[pulumi.Input[str]]:
|
|
416
|
+
def block_devices_mode(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
386
417
|
return pulumi.get(self, "block_devices_mode")
|
|
387
418
|
|
|
388
419
|
@block_devices_mode.setter
|
|
389
|
-
def block_devices_mode(self, value: Optional[pulumi.Input[str]]):
|
|
420
|
+
def block_devices_mode(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
390
421
|
pulumi.set(self, "block_devices_mode", value)
|
|
391
422
|
|
|
392
|
-
@property
|
|
423
|
+
@_builtins.property
|
|
393
424
|
@pulumi.getter(name="capacityUnit")
|
|
394
|
-
def capacity_unit(self) -> Optional[pulumi.Input[str]]:
|
|
425
|
+
def capacity_unit(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
395
426
|
"""
|
|
396
427
|
The capacity unit to launch instances by. If not specified, when choosing the weight unit, each instance will weight as the number of its vCPUs. Valid values: `instance`, `weight`.
|
|
397
428
|
"""
|
|
398
429
|
return pulumi.get(self, "capacity_unit")
|
|
399
430
|
|
|
400
431
|
@capacity_unit.setter
|
|
401
|
-
def capacity_unit(self, value: Optional[pulumi.Input[str]]):
|
|
432
|
+
def capacity_unit(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
402
433
|
pulumi.set(self, "capacity_unit", value)
|
|
403
434
|
|
|
404
|
-
@property
|
|
435
|
+
@_builtins.property
|
|
405
436
|
@pulumi.getter(name="considerOdPricing")
|
|
406
|
-
def consider_od_pricing(self) -> Optional[pulumi.Input[bool]]:
|
|
437
|
+
def consider_od_pricing(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
407
438
|
return pulumi.get(self, "consider_od_pricing")
|
|
408
439
|
|
|
409
440
|
@consider_od_pricing.setter
|
|
410
|
-
def consider_od_pricing(self, value: Optional[pulumi.Input[bool]]):
|
|
441
|
+
def consider_od_pricing(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
411
442
|
pulumi.set(self, "consider_od_pricing", value)
|
|
412
443
|
|
|
413
|
-
@property
|
|
444
|
+
@_builtins.property
|
|
414
445
|
@pulumi.getter(name="cpuCredits")
|
|
415
|
-
def cpu_credits(self) -> Optional[pulumi.Input[str]]:
|
|
446
|
+
def cpu_credits(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
416
447
|
"""
|
|
417
448
|
Controls how T3 instances are launched. Valid values: `standard`, `unlimited`.
|
|
418
449
|
"""
|
|
419
450
|
return pulumi.get(self, "cpu_credits")
|
|
420
451
|
|
|
421
452
|
@cpu_credits.setter
|
|
422
|
-
def cpu_credits(self, value: Optional[pulumi.Input[str]]):
|
|
453
|
+
def cpu_credits(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
423
454
|
pulumi.set(self, "cpu_credits", value)
|
|
424
455
|
|
|
425
|
-
@property
|
|
456
|
+
@_builtins.property
|
|
426
457
|
@pulumi.getter(name="cpuOptions")
|
|
427
458
|
def cpu_options(self) -> Optional[pulumi.Input['ElastigroupCpuOptionsArgs']]:
|
|
428
459
|
"""
|
|
@@ -434,43 +465,43 @@ class ElastigroupArgs:
|
|
|
434
465
|
def cpu_options(self, value: Optional[pulumi.Input['ElastigroupCpuOptionsArgs']]):
|
|
435
466
|
pulumi.set(self, "cpu_options", value)
|
|
436
467
|
|
|
437
|
-
@property
|
|
468
|
+
@_builtins.property
|
|
438
469
|
@pulumi.getter
|
|
439
|
-
def description(self) -> Optional[pulumi.Input[str]]:
|
|
470
|
+
def description(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
440
471
|
"""
|
|
441
472
|
The group description.
|
|
442
473
|
"""
|
|
443
474
|
return pulumi.get(self, "description")
|
|
444
475
|
|
|
445
476
|
@description.setter
|
|
446
|
-
def description(self, value: Optional[pulumi.Input[str]]):
|
|
477
|
+
def description(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
447
478
|
pulumi.set(self, "description", value)
|
|
448
479
|
|
|
449
|
-
@property
|
|
480
|
+
@_builtins.property
|
|
450
481
|
@pulumi.getter(name="desiredCapacity")
|
|
451
|
-
def desired_capacity(self) -> Optional[pulumi.Input[int]]:
|
|
482
|
+
def desired_capacity(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
452
483
|
"""
|
|
453
484
|
The desired number of instances the group should have at any time.
|
|
454
485
|
"""
|
|
455
486
|
return pulumi.get(self, "desired_capacity")
|
|
456
487
|
|
|
457
488
|
@desired_capacity.setter
|
|
458
|
-
def desired_capacity(self, value: Optional[pulumi.Input[int]]):
|
|
489
|
+
def desired_capacity(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
459
490
|
pulumi.set(self, "desired_capacity", value)
|
|
460
491
|
|
|
461
|
-
@property
|
|
492
|
+
@_builtins.property
|
|
462
493
|
@pulumi.getter(name="drainingTimeout")
|
|
463
|
-
def draining_timeout(self) -> Optional[pulumi.Input[int]]:
|
|
494
|
+
def draining_timeout(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
464
495
|
"""
|
|
465
496
|
The time in seconds, the instance is allowed to run while detached from the ELB. This is to allow the instance time to be drained from incoming TCP connections before terminating it, during a scale down operation.
|
|
466
497
|
"""
|
|
467
498
|
return pulumi.get(self, "draining_timeout")
|
|
468
499
|
|
|
469
500
|
@draining_timeout.setter
|
|
470
|
-
def draining_timeout(self, value: Optional[pulumi.Input[int]]):
|
|
501
|
+
def draining_timeout(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
471
502
|
pulumi.set(self, "draining_timeout", value)
|
|
472
503
|
|
|
473
|
-
@property
|
|
504
|
+
@_builtins.property
|
|
474
505
|
@pulumi.getter(name="ebsBlockDevices")
|
|
475
506
|
def ebs_block_devices(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupEbsBlockDeviceArgs']]]]:
|
|
476
507
|
return pulumi.get(self, "ebs_block_devices")
|
|
@@ -479,52 +510,52 @@ class ElastigroupArgs:
|
|
|
479
510
|
def ebs_block_devices(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupEbsBlockDeviceArgs']]]]):
|
|
480
511
|
pulumi.set(self, "ebs_block_devices", value)
|
|
481
512
|
|
|
482
|
-
@property
|
|
513
|
+
@_builtins.property
|
|
483
514
|
@pulumi.getter(name="ebsOptimized")
|
|
484
|
-
def ebs_optimized(self) -> Optional[pulumi.Input[bool]]:
|
|
515
|
+
def ebs_optimized(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
485
516
|
"""
|
|
486
517
|
Enable high bandwidth connectivity between instances and AWS’s Elastic Block Store (EBS). For instance types that are EBS-optimized by default this parameter will be ignored.
|
|
487
518
|
"""
|
|
488
519
|
return pulumi.get(self, "ebs_optimized")
|
|
489
520
|
|
|
490
521
|
@ebs_optimized.setter
|
|
491
|
-
def ebs_optimized(self, value: Optional[pulumi.Input[bool]]):
|
|
522
|
+
def ebs_optimized(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
492
523
|
pulumi.set(self, "ebs_optimized", value)
|
|
493
524
|
|
|
494
|
-
@property
|
|
525
|
+
@_builtins.property
|
|
495
526
|
@pulumi.getter(name="elasticIps")
|
|
496
|
-
def elastic_ips(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
|
|
527
|
+
def elastic_ips(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
|
|
497
528
|
"""
|
|
498
529
|
A list of [AWS Elastic IP](http://docs.aws.amazon.com/AWSEC2/latest/UserGuide/elastic-ip-addresses-eip.html) allocation IDs to associate to the group instances.
|
|
499
530
|
"""
|
|
500
531
|
return pulumi.get(self, "elastic_ips")
|
|
501
532
|
|
|
502
533
|
@elastic_ips.setter
|
|
503
|
-
def elastic_ips(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
|
|
534
|
+
def elastic_ips(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]):
|
|
504
535
|
pulumi.set(self, "elastic_ips", value)
|
|
505
536
|
|
|
506
|
-
@property
|
|
537
|
+
@_builtins.property
|
|
507
538
|
@pulumi.getter(name="elasticLoadBalancers")
|
|
508
|
-
def elastic_load_balancers(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
|
|
539
|
+
def elastic_load_balancers(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
|
|
509
540
|
return pulumi.get(self, "elastic_load_balancers")
|
|
510
541
|
|
|
511
542
|
@elastic_load_balancers.setter
|
|
512
|
-
def elastic_load_balancers(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
|
|
543
|
+
def elastic_load_balancers(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]):
|
|
513
544
|
pulumi.set(self, "elastic_load_balancers", value)
|
|
514
545
|
|
|
515
|
-
@property
|
|
546
|
+
@_builtins.property
|
|
516
547
|
@pulumi.getter(name="enableMonitoring")
|
|
517
|
-
def enable_monitoring(self) -> Optional[pulumi.Input[bool]]:
|
|
548
|
+
def enable_monitoring(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
518
549
|
"""
|
|
519
550
|
Indicates whether monitoring is enabled for the instance.
|
|
520
551
|
"""
|
|
521
552
|
return pulumi.get(self, "enable_monitoring")
|
|
522
553
|
|
|
523
554
|
@enable_monitoring.setter
|
|
524
|
-
def enable_monitoring(self, value: Optional[pulumi.Input[bool]]):
|
|
555
|
+
def enable_monitoring(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
525
556
|
pulumi.set(self, "enable_monitoring", value)
|
|
526
557
|
|
|
527
|
-
@property
|
|
558
|
+
@_builtins.property
|
|
528
559
|
@pulumi.getter(name="ephemeralBlockDevices")
|
|
529
560
|
def ephemeral_block_devices(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupEphemeralBlockDeviceArgs']]]]:
|
|
530
561
|
return pulumi.get(self, "ephemeral_block_devices")
|
|
@@ -533,67 +564,67 @@ class ElastigroupArgs:
|
|
|
533
564
|
def ephemeral_block_devices(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupEphemeralBlockDeviceArgs']]]]):
|
|
534
565
|
pulumi.set(self, "ephemeral_block_devices", value)
|
|
535
566
|
|
|
536
|
-
@property
|
|
567
|
+
@_builtins.property
|
|
537
568
|
@pulumi.getter(name="healthCheckGracePeriod")
|
|
538
|
-
def health_check_grace_period(self) -> Optional[pulumi.Input[int]]:
|
|
569
|
+
def health_check_grace_period(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
539
570
|
"""
|
|
540
571
|
The amount of time, in seconds, after the instance has launched to starts and check its health.
|
|
541
572
|
"""
|
|
542
573
|
return pulumi.get(self, "health_check_grace_period")
|
|
543
574
|
|
|
544
575
|
@health_check_grace_period.setter
|
|
545
|
-
def health_check_grace_period(self, value: Optional[pulumi.Input[int]]):
|
|
576
|
+
def health_check_grace_period(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
546
577
|
pulumi.set(self, "health_check_grace_period", value)
|
|
547
578
|
|
|
548
|
-
@property
|
|
579
|
+
@_builtins.property
|
|
549
580
|
@pulumi.getter(name="healthCheckType")
|
|
550
|
-
def health_check_type(self) -> Optional[pulumi.Input[str]]:
|
|
581
|
+
def health_check_type(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
551
582
|
"""
|
|
552
583
|
The service that will perform health checks for the instance. Valid values: `"ELB"`, `"HCS"`, `"TARGET_GROUP"`, `"EC2"`, `"K8S_NODE"`, `"NOMAD_NODE"`, `"ECS_CLUSTER_INSTANCE"`.
|
|
553
584
|
"""
|
|
554
585
|
return pulumi.get(self, "health_check_type")
|
|
555
586
|
|
|
556
587
|
@health_check_type.setter
|
|
557
|
-
def health_check_type(self, value: Optional[pulumi.Input[str]]):
|
|
588
|
+
def health_check_type(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
558
589
|
pulumi.set(self, "health_check_type", value)
|
|
559
590
|
|
|
560
|
-
@property
|
|
591
|
+
@_builtins.property
|
|
561
592
|
@pulumi.getter(name="healthCheckUnhealthyDurationBeforeReplacement")
|
|
562
|
-
def health_check_unhealthy_duration_before_replacement(self) -> Optional[pulumi.Input[int]]:
|
|
593
|
+
def health_check_unhealthy_duration_before_replacement(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
563
594
|
"""
|
|
564
595
|
The amount of time, in seconds, that we will wait before replacing an instance that is running and became unhealthy (this is only applicable for instances that were once healthy).
|
|
565
596
|
"""
|
|
566
597
|
return pulumi.get(self, "health_check_unhealthy_duration_before_replacement")
|
|
567
598
|
|
|
568
599
|
@health_check_unhealthy_duration_before_replacement.setter
|
|
569
|
-
def health_check_unhealthy_duration_before_replacement(self, value: Optional[pulumi.Input[int]]):
|
|
600
|
+
def health_check_unhealthy_duration_before_replacement(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
570
601
|
pulumi.set(self, "health_check_unhealthy_duration_before_replacement", value)
|
|
571
602
|
|
|
572
|
-
@property
|
|
603
|
+
@_builtins.property
|
|
573
604
|
@pulumi.getter(name="iamInstanceProfile")
|
|
574
|
-
def iam_instance_profile(self) -> Optional[pulumi.Input[str]]:
|
|
605
|
+
def iam_instance_profile(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
575
606
|
"""
|
|
576
607
|
The ARN or name of an IAM instance profile to associate with launched instances.
|
|
577
608
|
"""
|
|
578
609
|
return pulumi.get(self, "iam_instance_profile")
|
|
579
610
|
|
|
580
611
|
@iam_instance_profile.setter
|
|
581
|
-
def iam_instance_profile(self, value: Optional[pulumi.Input[str]]):
|
|
612
|
+
def iam_instance_profile(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
582
613
|
pulumi.set(self, "iam_instance_profile", value)
|
|
583
614
|
|
|
584
|
-
@property
|
|
615
|
+
@_builtins.property
|
|
585
616
|
@pulumi.getter(name="imageId")
|
|
586
|
-
def image_id(self) -> Optional[pulumi.Input[str]]:
|
|
617
|
+
def image_id(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
587
618
|
"""
|
|
588
619
|
The ID of the AMI used to launch the instance.
|
|
589
620
|
"""
|
|
590
621
|
return pulumi.get(self, "image_id")
|
|
591
622
|
|
|
592
623
|
@image_id.setter
|
|
593
|
-
def image_id(self, value: Optional[pulumi.Input[str]]):
|
|
624
|
+
def image_id(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
594
625
|
pulumi.set(self, "image_id", value)
|
|
595
626
|
|
|
596
|
-
@property
|
|
627
|
+
@_builtins.property
|
|
597
628
|
@pulumi.getter
|
|
598
629
|
def images(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupImageArgs']]]]:
|
|
599
630
|
"""
|
|
@@ -606,52 +637,52 @@ class ElastigroupArgs:
|
|
|
606
637
|
def images(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupImageArgs']]]]):
|
|
607
638
|
pulumi.set(self, "images", value)
|
|
608
639
|
|
|
609
|
-
@property
|
|
640
|
+
@_builtins.property
|
|
610
641
|
@pulumi.getter(name="immediateOdRecoverThreshold")
|
|
611
|
-
def immediate_od_recover_threshold(self) -> Optional[pulumi.Input[int]]:
|
|
642
|
+
def immediate_od_recover_threshold(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
612
643
|
return pulumi.get(self, "immediate_od_recover_threshold")
|
|
613
644
|
|
|
614
645
|
@immediate_od_recover_threshold.setter
|
|
615
|
-
def immediate_od_recover_threshold(self, value: Optional[pulumi.Input[int]]):
|
|
646
|
+
def immediate_od_recover_threshold(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
616
647
|
pulumi.set(self, "immediate_od_recover_threshold", value)
|
|
617
648
|
|
|
618
|
-
@property
|
|
649
|
+
@_builtins.property
|
|
619
650
|
@pulumi.getter(name="instanceTypesOndemand")
|
|
620
|
-
def instance_types_ondemand(self) -> Optional[pulumi.Input[str]]:
|
|
651
|
+
def instance_types_ondemand(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
621
652
|
"""
|
|
622
653
|
The type of instance determines your instance's CPU capacity, memory and storage (e.g., m1.small, c1.xlarge).
|
|
623
654
|
"""
|
|
624
655
|
return pulumi.get(self, "instance_types_ondemand")
|
|
625
656
|
|
|
626
657
|
@instance_types_ondemand.setter
|
|
627
|
-
def instance_types_ondemand(self, value: Optional[pulumi.Input[str]]):
|
|
658
|
+
def instance_types_ondemand(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
628
659
|
pulumi.set(self, "instance_types_ondemand", value)
|
|
629
660
|
|
|
630
|
-
@property
|
|
661
|
+
@_builtins.property
|
|
631
662
|
@pulumi.getter(name="instanceTypesPreferredSpots")
|
|
632
|
-
def instance_types_preferred_spots(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
|
|
663
|
+
def instance_types_preferred_spots(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
|
|
633
664
|
"""
|
|
634
665
|
Prioritize a subset of spot instance types. Must be a subset of the selected spot instance types.
|
|
635
666
|
"""
|
|
636
667
|
return pulumi.get(self, "instance_types_preferred_spots")
|
|
637
668
|
|
|
638
669
|
@instance_types_preferred_spots.setter
|
|
639
|
-
def instance_types_preferred_spots(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
|
|
670
|
+
def instance_types_preferred_spots(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]):
|
|
640
671
|
pulumi.set(self, "instance_types_preferred_spots", value)
|
|
641
672
|
|
|
642
|
-
@property
|
|
673
|
+
@_builtins.property
|
|
643
674
|
@pulumi.getter(name="instanceTypesSpots")
|
|
644
|
-
def instance_types_spots(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
|
|
675
|
+
def instance_types_spots(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
|
|
645
676
|
"""
|
|
646
677
|
One or more instance types. Note: Cannot be defined if 'resourceRequirements' is defined.
|
|
647
678
|
"""
|
|
648
679
|
return pulumi.get(self, "instance_types_spots")
|
|
649
680
|
|
|
650
681
|
@instance_types_spots.setter
|
|
651
|
-
def instance_types_spots(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
|
|
682
|
+
def instance_types_spots(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]):
|
|
652
683
|
pulumi.set(self, "instance_types_spots", value)
|
|
653
684
|
|
|
654
|
-
@property
|
|
685
|
+
@_builtins.property
|
|
655
686
|
@pulumi.getter(name="instanceTypesWeights")
|
|
656
687
|
def instance_types_weights(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupInstanceTypesWeightArgs']]]]:
|
|
657
688
|
"""
|
|
@@ -663,7 +694,7 @@ class ElastigroupArgs:
|
|
|
663
694
|
def instance_types_weights(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupInstanceTypesWeightArgs']]]]):
|
|
664
695
|
pulumi.set(self, "instance_types_weights", value)
|
|
665
696
|
|
|
666
|
-
@property
|
|
697
|
+
@_builtins.property
|
|
667
698
|
@pulumi.getter(name="integrationBeanstalk")
|
|
668
699
|
def integration_beanstalk(self) -> Optional[pulumi.Input['ElastigroupIntegrationBeanstalkArgs']]:
|
|
669
700
|
return pulumi.get(self, "integration_beanstalk")
|
|
@@ -672,7 +703,7 @@ class ElastigroupArgs:
|
|
|
672
703
|
def integration_beanstalk(self, value: Optional[pulumi.Input['ElastigroupIntegrationBeanstalkArgs']]):
|
|
673
704
|
pulumi.set(self, "integration_beanstalk", value)
|
|
674
705
|
|
|
675
|
-
@property
|
|
706
|
+
@_builtins.property
|
|
676
707
|
@pulumi.getter(name="integrationCodedeploy")
|
|
677
708
|
def integration_codedeploy(self) -> Optional[pulumi.Input['ElastigroupIntegrationCodedeployArgs']]:
|
|
678
709
|
return pulumi.get(self, "integration_codedeploy")
|
|
@@ -681,7 +712,7 @@ class ElastigroupArgs:
|
|
|
681
712
|
def integration_codedeploy(self, value: Optional[pulumi.Input['ElastigroupIntegrationCodedeployArgs']]):
|
|
682
713
|
pulumi.set(self, "integration_codedeploy", value)
|
|
683
714
|
|
|
684
|
-
@property
|
|
715
|
+
@_builtins.property
|
|
685
716
|
@pulumi.getter(name="integrationDockerSwarm")
|
|
686
717
|
def integration_docker_swarm(self) -> Optional[pulumi.Input['ElastigroupIntegrationDockerSwarmArgs']]:
|
|
687
718
|
return pulumi.get(self, "integration_docker_swarm")
|
|
@@ -690,7 +721,7 @@ class ElastigroupArgs:
|
|
|
690
721
|
def integration_docker_swarm(self, value: Optional[pulumi.Input['ElastigroupIntegrationDockerSwarmArgs']]):
|
|
691
722
|
pulumi.set(self, "integration_docker_swarm", value)
|
|
692
723
|
|
|
693
|
-
@property
|
|
724
|
+
@_builtins.property
|
|
694
725
|
@pulumi.getter(name="integrationEcs")
|
|
695
726
|
def integration_ecs(self) -> Optional[pulumi.Input['ElastigroupIntegrationEcsArgs']]:
|
|
696
727
|
return pulumi.get(self, "integration_ecs")
|
|
@@ -699,7 +730,7 @@ class ElastigroupArgs:
|
|
|
699
730
|
def integration_ecs(self, value: Optional[pulumi.Input['ElastigroupIntegrationEcsArgs']]):
|
|
700
731
|
pulumi.set(self, "integration_ecs", value)
|
|
701
732
|
|
|
702
|
-
@property
|
|
733
|
+
@_builtins.property
|
|
703
734
|
@pulumi.getter(name="integrationGitlab")
|
|
704
735
|
def integration_gitlab(self) -> Optional[pulumi.Input['ElastigroupIntegrationGitlabArgs']]:
|
|
705
736
|
return pulumi.get(self, "integration_gitlab")
|
|
@@ -708,7 +739,7 @@ class ElastigroupArgs:
|
|
|
708
739
|
def integration_gitlab(self, value: Optional[pulumi.Input['ElastigroupIntegrationGitlabArgs']]):
|
|
709
740
|
pulumi.set(self, "integration_gitlab", value)
|
|
710
741
|
|
|
711
|
-
@property
|
|
742
|
+
@_builtins.property
|
|
712
743
|
@pulumi.getter(name="integrationKubernetes")
|
|
713
744
|
def integration_kubernetes(self) -> Optional[pulumi.Input['ElastigroupIntegrationKubernetesArgs']]:
|
|
714
745
|
return pulumi.get(self, "integration_kubernetes")
|
|
@@ -717,7 +748,7 @@ class ElastigroupArgs:
|
|
|
717
748
|
def integration_kubernetes(self, value: Optional[pulumi.Input['ElastigroupIntegrationKubernetesArgs']]):
|
|
718
749
|
pulumi.set(self, "integration_kubernetes", value)
|
|
719
750
|
|
|
720
|
-
@property
|
|
751
|
+
@_builtins.property
|
|
721
752
|
@pulumi.getter(name="integrationMesosphere")
|
|
722
753
|
def integration_mesosphere(self) -> Optional[pulumi.Input['ElastigroupIntegrationMesosphereArgs']]:
|
|
723
754
|
return pulumi.get(self, "integration_mesosphere")
|
|
@@ -726,7 +757,7 @@ class ElastigroupArgs:
|
|
|
726
757
|
def integration_mesosphere(self, value: Optional[pulumi.Input['ElastigroupIntegrationMesosphereArgs']]):
|
|
727
758
|
pulumi.set(self, "integration_mesosphere", value)
|
|
728
759
|
|
|
729
|
-
@property
|
|
760
|
+
@_builtins.property
|
|
730
761
|
@pulumi.getter(name="integrationNomad")
|
|
731
762
|
def integration_nomad(self) -> Optional[pulumi.Input['ElastigroupIntegrationNomadArgs']]:
|
|
732
763
|
return pulumi.get(self, "integration_nomad")
|
|
@@ -735,7 +766,7 @@ class ElastigroupArgs:
|
|
|
735
766
|
def integration_nomad(self, value: Optional[pulumi.Input['ElastigroupIntegrationNomadArgs']]):
|
|
736
767
|
pulumi.set(self, "integration_nomad", value)
|
|
737
768
|
|
|
738
|
-
@property
|
|
769
|
+
@_builtins.property
|
|
739
770
|
@pulumi.getter(name="integrationRancher")
|
|
740
771
|
def integration_rancher(self) -> Optional[pulumi.Input['ElastigroupIntegrationRancherArgs']]:
|
|
741
772
|
return pulumi.get(self, "integration_rancher")
|
|
@@ -744,7 +775,7 @@ class ElastigroupArgs:
|
|
|
744
775
|
def integration_rancher(self, value: Optional[pulumi.Input['ElastigroupIntegrationRancherArgs']]):
|
|
745
776
|
pulumi.set(self, "integration_rancher", value)
|
|
746
777
|
|
|
747
|
-
@property
|
|
778
|
+
@_builtins.property
|
|
748
779
|
@pulumi.getter(name="integrationRoute53")
|
|
749
780
|
def integration_route53(self) -> Optional[pulumi.Input['ElastigroupIntegrationRoute53Args']]:
|
|
750
781
|
return pulumi.get(self, "integration_route53")
|
|
@@ -753,7 +784,7 @@ class ElastigroupArgs:
|
|
|
753
784
|
def integration_route53(self, value: Optional[pulumi.Input['ElastigroupIntegrationRoute53Args']]):
|
|
754
785
|
pulumi.set(self, "integration_route53", value)
|
|
755
786
|
|
|
756
|
-
@property
|
|
787
|
+
@_builtins.property
|
|
757
788
|
@pulumi.getter
|
|
758
789
|
def itfs(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupItfArgs']]]]:
|
|
759
790
|
return pulumi.get(self, "itfs")
|
|
@@ -762,28 +793,28 @@ class ElastigroupArgs:
|
|
|
762
793
|
def itfs(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupItfArgs']]]]):
|
|
763
794
|
pulumi.set(self, "itfs", value)
|
|
764
795
|
|
|
765
|
-
@property
|
|
796
|
+
@_builtins.property
|
|
766
797
|
@pulumi.getter(name="keyName")
|
|
767
|
-
def key_name(self) -> Optional[pulumi.Input[str]]:
|
|
798
|
+
def key_name(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
768
799
|
"""
|
|
769
800
|
The key name that should be used for the instance.
|
|
770
801
|
"""
|
|
771
802
|
return pulumi.get(self, "key_name")
|
|
772
803
|
|
|
773
804
|
@key_name.setter
|
|
774
|
-
def key_name(self, value: Optional[pulumi.Input[str]]):
|
|
805
|
+
def key_name(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
775
806
|
pulumi.set(self, "key_name", value)
|
|
776
807
|
|
|
777
|
-
@property
|
|
808
|
+
@_builtins.property
|
|
778
809
|
@pulumi.getter(name="lifetimePeriod")
|
|
779
|
-
def lifetime_period(self) -> Optional[pulumi.Input[str]]:
|
|
810
|
+
def lifetime_period(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
780
811
|
return pulumi.get(self, "lifetime_period")
|
|
781
812
|
|
|
782
813
|
@lifetime_period.setter
|
|
783
|
-
def lifetime_period(self, value: Optional[pulumi.Input[str]]):
|
|
814
|
+
def lifetime_period(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
784
815
|
pulumi.set(self, "lifetime_period", value)
|
|
785
816
|
|
|
786
|
-
@property
|
|
817
|
+
@_builtins.property
|
|
787
818
|
@pulumi.getter
|
|
788
819
|
def logging(self) -> Optional[pulumi.Input['ElastigroupLoggingArgs']]:
|
|
789
820
|
"""
|
|
@@ -795,19 +826,28 @@ class ElastigroupArgs:
|
|
|
795
826
|
def logging(self, value: Optional[pulumi.Input['ElastigroupLoggingArgs']]):
|
|
796
827
|
pulumi.set(self, "logging", value)
|
|
797
828
|
|
|
798
|
-
@property
|
|
829
|
+
@_builtins.property
|
|
830
|
+
@pulumi.getter(name="maxReplacementsPercentage")
|
|
831
|
+
def max_replacements_percentage(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
832
|
+
return pulumi.get(self, "max_replacements_percentage")
|
|
833
|
+
|
|
834
|
+
@max_replacements_percentage.setter
|
|
835
|
+
def max_replacements_percentage(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
836
|
+
pulumi.set(self, "max_replacements_percentage", value)
|
|
837
|
+
|
|
838
|
+
@_builtins.property
|
|
799
839
|
@pulumi.getter(name="maxSize")
|
|
800
|
-
def max_size(self) -> Optional[pulumi.Input[int]]:
|
|
840
|
+
def max_size(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
801
841
|
"""
|
|
802
842
|
The maximum number of instances the group should have at any time.
|
|
803
843
|
"""
|
|
804
844
|
return pulumi.get(self, "max_size")
|
|
805
845
|
|
|
806
846
|
@max_size.setter
|
|
807
|
-
def max_size(self, value: Optional[pulumi.Input[int]]):
|
|
847
|
+
def max_size(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
808
848
|
pulumi.set(self, "max_size", value)
|
|
809
849
|
|
|
810
|
-
@property
|
|
850
|
+
@_builtins.property
|
|
811
851
|
@pulumi.getter(name="metadataOptions")
|
|
812
852
|
def metadata_options(self) -> Optional[pulumi.Input['ElastigroupMetadataOptionsArgs']]:
|
|
813
853
|
"""
|
|
@@ -819,31 +859,31 @@ class ElastigroupArgs:
|
|
|
819
859
|
def metadata_options(self, value: Optional[pulumi.Input['ElastigroupMetadataOptionsArgs']]):
|
|
820
860
|
pulumi.set(self, "metadata_options", value)
|
|
821
861
|
|
|
822
|
-
@property
|
|
862
|
+
@_builtins.property
|
|
823
863
|
@pulumi.getter(name="minSize")
|
|
824
|
-
def min_size(self) -> Optional[pulumi.Input[int]]:
|
|
864
|
+
def min_size(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
825
865
|
"""
|
|
826
866
|
The minimum number of instances the group should have at any time.
|
|
827
867
|
"""
|
|
828
868
|
return pulumi.get(self, "min_size")
|
|
829
869
|
|
|
830
870
|
@min_size.setter
|
|
831
|
-
def min_size(self, value: Optional[pulumi.Input[int]]):
|
|
871
|
+
def min_size(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
832
872
|
pulumi.set(self, "min_size", value)
|
|
833
873
|
|
|
834
|
-
@property
|
|
874
|
+
@_builtins.property
|
|
835
875
|
@pulumi.getter(name="minimumInstanceLifetime")
|
|
836
|
-
def minimum_instance_lifetime(self) -> Optional[pulumi.Input[int]]:
|
|
876
|
+
def minimum_instance_lifetime(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
837
877
|
"""
|
|
838
878
|
Defines the preferred minimum instance lifetime in hours. Markets which comply with this preference will be prioritized. Optional values: 1, 3, 6, 12, 24.
|
|
839
879
|
"""
|
|
840
880
|
return pulumi.get(self, "minimum_instance_lifetime")
|
|
841
881
|
|
|
842
882
|
@minimum_instance_lifetime.setter
|
|
843
|
-
def minimum_instance_lifetime(self, value: Optional[pulumi.Input[int]]):
|
|
883
|
+
def minimum_instance_lifetime(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
844
884
|
pulumi.set(self, "minimum_instance_lifetime", value)
|
|
845
885
|
|
|
846
|
-
@property
|
|
886
|
+
@_builtins.property
|
|
847
887
|
@pulumi.getter(name="multipleMetrics")
|
|
848
888
|
def multiple_metrics(self) -> Optional[pulumi.Input['ElastigroupMultipleMetricsArgs']]:
|
|
849
889
|
return pulumi.get(self, "multiple_metrics")
|
|
@@ -852,19 +892,19 @@ class ElastigroupArgs:
|
|
|
852
892
|
def multiple_metrics(self, value: Optional[pulumi.Input['ElastigroupMultipleMetricsArgs']]):
|
|
853
893
|
pulumi.set(self, "multiple_metrics", value)
|
|
854
894
|
|
|
855
|
-
@property
|
|
895
|
+
@_builtins.property
|
|
856
896
|
@pulumi.getter
|
|
857
|
-
def name(self) -> Optional[pulumi.Input[str]]:
|
|
897
|
+
def name(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
858
898
|
"""
|
|
859
899
|
The group name.
|
|
860
900
|
"""
|
|
861
901
|
return pulumi.get(self, "name")
|
|
862
902
|
|
|
863
903
|
@name.setter
|
|
864
|
-
def name(self, value: Optional[pulumi.Input[str]]):
|
|
904
|
+
def name(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
865
905
|
pulumi.set(self, "name", value)
|
|
866
906
|
|
|
867
|
-
@property
|
|
907
|
+
@_builtins.property
|
|
868
908
|
@pulumi.getter(name="networkInterfaces")
|
|
869
909
|
def network_interfaces(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupNetworkInterfaceArgs']]]]:
|
|
870
910
|
return pulumi.get(self, "network_interfaces")
|
|
@@ -873,72 +913,72 @@ class ElastigroupArgs:
|
|
|
873
913
|
def network_interfaces(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupNetworkInterfaceArgs']]]]):
|
|
874
914
|
pulumi.set(self, "network_interfaces", value)
|
|
875
915
|
|
|
876
|
-
@property
|
|
916
|
+
@_builtins.property
|
|
877
917
|
@pulumi.getter(name="onDemandTypes")
|
|
878
|
-
def on_demand_types(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
|
|
918
|
+
def on_demand_types(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
|
|
879
919
|
"""
|
|
880
920
|
Available ondemand instance types. Note: Either ondemand or onDemandTypes must be defined, but not both.
|
|
881
921
|
"""
|
|
882
922
|
return pulumi.get(self, "on_demand_types")
|
|
883
923
|
|
|
884
924
|
@on_demand_types.setter
|
|
885
|
-
def on_demand_types(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
|
|
925
|
+
def on_demand_types(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]):
|
|
886
926
|
pulumi.set(self, "on_demand_types", value)
|
|
887
927
|
|
|
888
|
-
@property
|
|
928
|
+
@_builtins.property
|
|
889
929
|
@pulumi.getter(name="ondemandCount")
|
|
890
|
-
def ondemand_count(self) -> Optional[pulumi.Input[int]]:
|
|
930
|
+
def ondemand_count(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
891
931
|
"""
|
|
892
932
|
Number of on demand instances to launch in the group. All other instances will be spot instances. When this parameter is set the `spot_percentage` parameter is being ignored.
|
|
893
933
|
"""
|
|
894
934
|
return pulumi.get(self, "ondemand_count")
|
|
895
935
|
|
|
896
936
|
@ondemand_count.setter
|
|
897
|
-
def ondemand_count(self, value: Optional[pulumi.Input[int]]):
|
|
937
|
+
def ondemand_count(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
898
938
|
pulumi.set(self, "ondemand_count", value)
|
|
899
939
|
|
|
900
|
-
@property
|
|
940
|
+
@_builtins.property
|
|
901
941
|
@pulumi.getter(name="persistBlockDevices")
|
|
902
|
-
def persist_block_devices(self) -> Optional[pulumi.Input[bool]]:
|
|
942
|
+
def persist_block_devices(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
903
943
|
return pulumi.get(self, "persist_block_devices")
|
|
904
944
|
|
|
905
945
|
@persist_block_devices.setter
|
|
906
|
-
def persist_block_devices(self, value: Optional[pulumi.Input[bool]]):
|
|
946
|
+
def persist_block_devices(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
907
947
|
pulumi.set(self, "persist_block_devices", value)
|
|
908
948
|
|
|
909
|
-
@property
|
|
949
|
+
@_builtins.property
|
|
910
950
|
@pulumi.getter(name="persistPrivateIp")
|
|
911
|
-
def persist_private_ip(self) -> Optional[pulumi.Input[bool]]:
|
|
951
|
+
def persist_private_ip(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
912
952
|
return pulumi.get(self, "persist_private_ip")
|
|
913
953
|
|
|
914
954
|
@persist_private_ip.setter
|
|
915
|
-
def persist_private_ip(self, value: Optional[pulumi.Input[bool]]):
|
|
955
|
+
def persist_private_ip(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
916
956
|
pulumi.set(self, "persist_private_ip", value)
|
|
917
957
|
|
|
918
|
-
@property
|
|
958
|
+
@_builtins.property
|
|
919
959
|
@pulumi.getter(name="persistRootDevice")
|
|
920
|
-
def persist_root_device(self) -> Optional[pulumi.Input[bool]]:
|
|
960
|
+
def persist_root_device(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
921
961
|
return pulumi.get(self, "persist_root_device")
|
|
922
962
|
|
|
923
963
|
@persist_root_device.setter
|
|
924
|
-
def persist_root_device(self, value: Optional[pulumi.Input[bool]]):
|
|
964
|
+
def persist_root_device(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
925
965
|
pulumi.set(self, "persist_root_device", value)
|
|
926
966
|
|
|
927
|
-
@property
|
|
967
|
+
@_builtins.property
|
|
928
968
|
@pulumi.getter(name="placementTenancy")
|
|
929
|
-
def placement_tenancy(self) -> Optional[pulumi.Input[str]]:
|
|
969
|
+
def placement_tenancy(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
930
970
|
"""
|
|
931
971
|
Enable dedicated tenancy. Note: There is a flat hourly fee for each region in which dedicated tenancy is used. Valid values: "default", "dedicated" .
|
|
932
972
|
"""
|
|
933
973
|
return pulumi.get(self, "placement_tenancy")
|
|
934
974
|
|
|
935
975
|
@placement_tenancy.setter
|
|
936
|
-
def placement_tenancy(self, value: Optional[pulumi.Input[str]]):
|
|
976
|
+
def placement_tenancy(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
937
977
|
pulumi.set(self, "placement_tenancy", value)
|
|
938
978
|
|
|
939
|
-
@property
|
|
979
|
+
@_builtins.property
|
|
940
980
|
@pulumi.getter(name="preferredAvailabilityZones")
|
|
941
|
-
def preferred_availability_zones(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
|
|
981
|
+
def preferred_availability_zones(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
|
|
942
982
|
"""
|
|
943
983
|
The AZs to prioritize when launching Spot instances. If no markets are available in the Preferred AZs, Spot instances are launched in the non-preferred AZs.
|
|
944
984
|
Note: Must be a sublist of `availability_zones` and `orientation` value must not be `"equalAzDistribution"`.
|
|
@@ -946,21 +986,21 @@ class ElastigroupArgs:
|
|
|
946
986
|
return pulumi.get(self, "preferred_availability_zones")
|
|
947
987
|
|
|
948
988
|
@preferred_availability_zones.setter
|
|
949
|
-
def preferred_availability_zones(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
|
|
989
|
+
def preferred_availability_zones(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]):
|
|
950
990
|
pulumi.set(self, "preferred_availability_zones", value)
|
|
951
991
|
|
|
952
|
-
@property
|
|
992
|
+
@_builtins.property
|
|
953
993
|
@pulumi.getter(name="privateIps")
|
|
954
|
-
def private_ips(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
|
|
994
|
+
def private_ips(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
|
|
955
995
|
return pulumi.get(self, "private_ips")
|
|
956
996
|
|
|
957
997
|
@private_ips.setter
|
|
958
|
-
def private_ips(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
|
|
998
|
+
def private_ips(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]):
|
|
959
999
|
pulumi.set(self, "private_ips", value)
|
|
960
1000
|
|
|
961
|
-
@property
|
|
1001
|
+
@_builtins.property
|
|
962
1002
|
@pulumi.getter
|
|
963
|
-
def region(self) -> Optional[pulumi.Input[str]]:
|
|
1003
|
+
def region(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
964
1004
|
"""
|
|
965
1005
|
The AWS region your group will be created in.
|
|
966
1006
|
Note: This parameter is required if you specify subnets (through subnet_ids). This parameter is optional if you specify Availability Zones (through availability_zones).
|
|
@@ -968,10 +1008,10 @@ class ElastigroupArgs:
|
|
|
968
1008
|
return pulumi.get(self, "region")
|
|
969
1009
|
|
|
970
1010
|
@region.setter
|
|
971
|
-
def region(self, value: Optional[pulumi.Input[str]]):
|
|
1011
|
+
def region(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
972
1012
|
pulumi.set(self, "region", value)
|
|
973
1013
|
|
|
974
|
-
@property
|
|
1014
|
+
@_builtins.property
|
|
975
1015
|
@pulumi.getter(name="resourceRequirements")
|
|
976
1016
|
def resource_requirements(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupResourceRequirementArgs']]]]:
|
|
977
1017
|
"""
|
|
@@ -983,7 +1023,7 @@ class ElastigroupArgs:
|
|
|
983
1023
|
def resource_requirements(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupResourceRequirementArgs']]]]):
|
|
984
1024
|
pulumi.set(self, "resource_requirements", value)
|
|
985
1025
|
|
|
986
|
-
@property
|
|
1026
|
+
@_builtins.property
|
|
987
1027
|
@pulumi.getter(name="resourceTagSpecifications")
|
|
988
1028
|
def resource_tag_specifications(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupResourceTagSpecificationArgs']]]]:
|
|
989
1029
|
"""
|
|
@@ -995,7 +1035,19 @@ class ElastigroupArgs:
|
|
|
995
1035
|
def resource_tag_specifications(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupResourceTagSpecificationArgs']]]]):
|
|
996
1036
|
pulumi.set(self, "resource_tag_specifications", value)
|
|
997
1037
|
|
|
998
|
-
@property
|
|
1038
|
+
@_builtins.property
|
|
1039
|
+
@pulumi.getter(name="restrictSingleAz")
|
|
1040
|
+
def restrict_single_az(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
1041
|
+
"""
|
|
1042
|
+
Elastigroup will automatically scale your instances in the most available and cost efficient availability zone. Every evaluation will be done when there are no active instances in the group.
|
|
1043
|
+
"""
|
|
1044
|
+
return pulumi.get(self, "restrict_single_az")
|
|
1045
|
+
|
|
1046
|
+
@restrict_single_az.setter
|
|
1047
|
+
def restrict_single_az(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
1048
|
+
pulumi.set(self, "restrict_single_az", value)
|
|
1049
|
+
|
|
1050
|
+
@_builtins.property
|
|
999
1051
|
@pulumi.getter(name="revertToSpot")
|
|
1000
1052
|
def revert_to_spot(self) -> Optional[pulumi.Input['ElastigroupRevertToSpotArgs']]:
|
|
1001
1053
|
"""
|
|
@@ -1007,7 +1059,7 @@ class ElastigroupArgs:
|
|
|
1007
1059
|
def revert_to_spot(self, value: Optional[pulumi.Input['ElastigroupRevertToSpotArgs']]):
|
|
1008
1060
|
pulumi.set(self, "revert_to_spot", value)
|
|
1009
1061
|
|
|
1010
|
-
@property
|
|
1062
|
+
@_builtins.property
|
|
1011
1063
|
@pulumi.getter(name="scalingDownPolicies")
|
|
1012
1064
|
def scaling_down_policies(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupScalingDownPolicyArgs']]]]:
|
|
1013
1065
|
return pulumi.get(self, "scaling_down_policies")
|
|
@@ -1016,7 +1068,7 @@ class ElastigroupArgs:
|
|
|
1016
1068
|
def scaling_down_policies(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupScalingDownPolicyArgs']]]]):
|
|
1017
1069
|
pulumi.set(self, "scaling_down_policies", value)
|
|
1018
1070
|
|
|
1019
|
-
@property
|
|
1071
|
+
@_builtins.property
|
|
1020
1072
|
@pulumi.getter(name="scalingStrategies")
|
|
1021
1073
|
def scaling_strategies(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupScalingStrategyArgs']]]]:
|
|
1022
1074
|
"""
|
|
@@ -1028,7 +1080,7 @@ class ElastigroupArgs:
|
|
|
1028
1080
|
def scaling_strategies(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupScalingStrategyArgs']]]]):
|
|
1029
1081
|
pulumi.set(self, "scaling_strategies", value)
|
|
1030
1082
|
|
|
1031
|
-
@property
|
|
1083
|
+
@_builtins.property
|
|
1032
1084
|
@pulumi.getter(name="scalingTargetPolicies")
|
|
1033
1085
|
def scaling_target_policies(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupScalingTargetPolicyArgs']]]]:
|
|
1034
1086
|
return pulumi.get(self, "scaling_target_policies")
|
|
@@ -1037,7 +1089,7 @@ class ElastigroupArgs:
|
|
|
1037
1089
|
def scaling_target_policies(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupScalingTargetPolicyArgs']]]]):
|
|
1038
1090
|
pulumi.set(self, "scaling_target_policies", value)
|
|
1039
1091
|
|
|
1040
|
-
@property
|
|
1092
|
+
@_builtins.property
|
|
1041
1093
|
@pulumi.getter(name="scalingUpPolicies")
|
|
1042
1094
|
def scaling_up_policies(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupScalingUpPolicyArgs']]]]:
|
|
1043
1095
|
return pulumi.get(self, "scaling_up_policies")
|
|
@@ -1046,7 +1098,7 @@ class ElastigroupArgs:
|
|
|
1046
1098
|
def scaling_up_policies(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupScalingUpPolicyArgs']]]]):
|
|
1047
1099
|
pulumi.set(self, "scaling_up_policies", value)
|
|
1048
1100
|
|
|
1049
|
-
@property
|
|
1101
|
+
@_builtins.property
|
|
1050
1102
|
@pulumi.getter(name="scheduledTasks")
|
|
1051
1103
|
def scheduled_tasks(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupScheduledTaskArgs']]]]:
|
|
1052
1104
|
return pulumi.get(self, "scheduled_tasks")
|
|
@@ -1055,19 +1107,19 @@ class ElastigroupArgs:
|
|
|
1055
1107
|
def scheduled_tasks(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupScheduledTaskArgs']]]]):
|
|
1056
1108
|
pulumi.set(self, "scheduled_tasks", value)
|
|
1057
1109
|
|
|
1058
|
-
@property
|
|
1110
|
+
@_builtins.property
|
|
1059
1111
|
@pulumi.getter(name="shutdownScript")
|
|
1060
|
-
def shutdown_script(self) -> Optional[pulumi.Input[str]]:
|
|
1112
|
+
def shutdown_script(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
1061
1113
|
"""
|
|
1062
1114
|
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/)
|
|
1063
1115
|
"""
|
|
1064
1116
|
return pulumi.get(self, "shutdown_script")
|
|
1065
1117
|
|
|
1066
1118
|
@shutdown_script.setter
|
|
1067
|
-
def shutdown_script(self, value: Optional[pulumi.Input[str]]):
|
|
1119
|
+
def shutdown_script(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
1068
1120
|
pulumi.set(self, "shutdown_script", value)
|
|
1069
1121
|
|
|
1070
|
-
@property
|
|
1122
|
+
@_builtins.property
|
|
1071
1123
|
@pulumi.getter
|
|
1072
1124
|
def signals(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupSignalArgs']]]]:
|
|
1073
1125
|
return pulumi.get(self, "signals")
|
|
@@ -1076,19 +1128,19 @@ class ElastigroupArgs:
|
|
|
1076
1128
|
def signals(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupSignalArgs']]]]):
|
|
1077
1129
|
pulumi.set(self, "signals", value)
|
|
1078
1130
|
|
|
1079
|
-
@property
|
|
1131
|
+
@_builtins.property
|
|
1080
1132
|
@pulumi.getter(name="spotPercentage")
|
|
1081
|
-
def spot_percentage(self) -> Optional[pulumi.Input[int]]:
|
|
1133
|
+
def spot_percentage(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
1082
1134
|
"""
|
|
1083
1135
|
The percentage of Spot instances that would spin up from the `desired_capacity` number.
|
|
1084
1136
|
"""
|
|
1085
1137
|
return pulumi.get(self, "spot_percentage")
|
|
1086
1138
|
|
|
1087
1139
|
@spot_percentage.setter
|
|
1088
|
-
def spot_percentage(self, value: Optional[pulumi.Input[int]]):
|
|
1140
|
+
def spot_percentage(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
1089
1141
|
pulumi.set(self, "spot_percentage", value)
|
|
1090
1142
|
|
|
1091
|
-
@property
|
|
1143
|
+
@_builtins.property
|
|
1092
1144
|
@pulumi.getter(name="statefulDeallocation")
|
|
1093
1145
|
def stateful_deallocation(self) -> Optional[pulumi.Input['ElastigroupStatefulDeallocationArgs']]:
|
|
1094
1146
|
return pulumi.get(self, "stateful_deallocation")
|
|
@@ -1097,7 +1149,7 @@ class ElastigroupArgs:
|
|
|
1097
1149
|
def stateful_deallocation(self, value: Optional[pulumi.Input['ElastigroupStatefulDeallocationArgs']]):
|
|
1098
1150
|
pulumi.set(self, "stateful_deallocation", value)
|
|
1099
1151
|
|
|
1100
|
-
@property
|
|
1152
|
+
@_builtins.property
|
|
1101
1153
|
@pulumi.getter(name="statefulInstanceActions")
|
|
1102
1154
|
def stateful_instance_actions(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupStatefulInstanceActionArgs']]]]:
|
|
1103
1155
|
return pulumi.get(self, "stateful_instance_actions")
|
|
@@ -1106,9 +1158,10 @@ class ElastigroupArgs:
|
|
|
1106
1158
|
def stateful_instance_actions(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupStatefulInstanceActionArgs']]]]):
|
|
1107
1159
|
pulumi.set(self, "stateful_instance_actions", value)
|
|
1108
1160
|
|
|
1109
|
-
@property
|
|
1161
|
+
@_builtins.property
|
|
1110
1162
|
@pulumi.getter(name="subnetIds")
|
|
1111
|
-
|
|
1163
|
+
@_utilities.deprecated("""This field will soon be deprecated and handled by availability_zones""")
|
|
1164
|
+
def subnet_ids(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
|
|
1112
1165
|
"""
|
|
1113
1166
|
List of Strings of subnet identifiers.
|
|
1114
1167
|
Note: When this parameter is set, `availability_zones` should be left unused.
|
|
@@ -1116,10 +1169,10 @@ class ElastigroupArgs:
|
|
|
1116
1169
|
return pulumi.get(self, "subnet_ids")
|
|
1117
1170
|
|
|
1118
1171
|
@subnet_ids.setter
|
|
1119
|
-
def subnet_ids(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
|
|
1172
|
+
def subnet_ids(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]):
|
|
1120
1173
|
pulumi.set(self, "subnet_ids", value)
|
|
1121
1174
|
|
|
1122
|
-
@property
|
|
1175
|
+
@_builtins.property
|
|
1123
1176
|
@pulumi.getter
|
|
1124
1177
|
def tags(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupTagArgs']]]]:
|
|
1125
1178
|
"""
|
|
@@ -1131,16 +1184,16 @@ class ElastigroupArgs:
|
|
|
1131
1184
|
def tags(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupTagArgs']]]]):
|
|
1132
1185
|
pulumi.set(self, "tags", value)
|
|
1133
1186
|
|
|
1134
|
-
@property
|
|
1187
|
+
@_builtins.property
|
|
1135
1188
|
@pulumi.getter(name="targetGroupArns")
|
|
1136
|
-
def target_group_arns(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
|
|
1189
|
+
def target_group_arns(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
|
|
1137
1190
|
return pulumi.get(self, "target_group_arns")
|
|
1138
1191
|
|
|
1139
1192
|
@target_group_arns.setter
|
|
1140
|
-
def target_group_arns(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
|
|
1193
|
+
def target_group_arns(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]):
|
|
1141
1194
|
pulumi.set(self, "target_group_arns", value)
|
|
1142
1195
|
|
|
1143
|
-
@property
|
|
1196
|
+
@_builtins.property
|
|
1144
1197
|
@pulumi.getter(name="updatePolicy")
|
|
1145
1198
|
def update_policy(self) -> Optional[pulumi.Input['ElastigroupUpdatePolicyArgs']]:
|
|
1146
1199
|
return pulumi.get(self, "update_policy")
|
|
@@ -1149,93 +1202,94 @@ class ElastigroupArgs:
|
|
|
1149
1202
|
def update_policy(self, value: Optional[pulumi.Input['ElastigroupUpdatePolicyArgs']]):
|
|
1150
1203
|
pulumi.set(self, "update_policy", value)
|
|
1151
1204
|
|
|
1152
|
-
@property
|
|
1205
|
+
@_builtins.property
|
|
1153
1206
|
@pulumi.getter(name="userData")
|
|
1154
|
-
def user_data(self) -> Optional[pulumi.Input[str]]:
|
|
1207
|
+
def user_data(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
1155
1208
|
"""
|
|
1156
1209
|
The user data to provide when launching the instance.
|
|
1157
1210
|
"""
|
|
1158
1211
|
return pulumi.get(self, "user_data")
|
|
1159
1212
|
|
|
1160
1213
|
@user_data.setter
|
|
1161
|
-
def user_data(self, value: Optional[pulumi.Input[str]]):
|
|
1214
|
+
def user_data(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
1162
1215
|
pulumi.set(self, "user_data", value)
|
|
1163
1216
|
|
|
1164
|
-
@property
|
|
1217
|
+
@_builtins.property
|
|
1165
1218
|
@pulumi.getter(name="utilizeCommitments")
|
|
1166
|
-
def utilize_commitments(self) -> Optional[pulumi.Input[bool]]:
|
|
1219
|
+
def utilize_commitments(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
1167
1220
|
return pulumi.get(self, "utilize_commitments")
|
|
1168
1221
|
|
|
1169
1222
|
@utilize_commitments.setter
|
|
1170
|
-
def utilize_commitments(self, value: Optional[pulumi.Input[bool]]):
|
|
1223
|
+
def utilize_commitments(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
1171
1224
|
pulumi.set(self, "utilize_commitments", value)
|
|
1172
1225
|
|
|
1173
|
-
@property
|
|
1226
|
+
@_builtins.property
|
|
1174
1227
|
@pulumi.getter(name="utilizeReservedInstances")
|
|
1175
|
-
def utilize_reserved_instances(self) -> Optional[pulumi.Input[bool]]:
|
|
1228
|
+
def utilize_reserved_instances(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
1176
1229
|
"""
|
|
1177
1230
|
In a case of any available reserved instances, Elastigroup will utilize them first before purchasing Spot instances.
|
|
1178
1231
|
"""
|
|
1179
1232
|
return pulumi.get(self, "utilize_reserved_instances")
|
|
1180
1233
|
|
|
1181
1234
|
@utilize_reserved_instances.setter
|
|
1182
|
-
def utilize_reserved_instances(self, value: Optional[pulumi.Input[bool]]):
|
|
1235
|
+
def utilize_reserved_instances(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
1183
1236
|
pulumi.set(self, "utilize_reserved_instances", value)
|
|
1184
1237
|
|
|
1185
|
-
@property
|
|
1238
|
+
@_builtins.property
|
|
1186
1239
|
@pulumi.getter(name="waitForCapacity")
|
|
1187
|
-
def wait_for_capacity(self) -> Optional[pulumi.Input[int]]:
|
|
1240
|
+
def wait_for_capacity(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
1188
1241
|
"""
|
|
1189
1242
|
Minimum number of instances in a 'HEALTHY' status that is required before continuing. This is ignored when updating with blue/green deployment. Cannot exceed `desired_capacity`.
|
|
1190
1243
|
"""
|
|
1191
1244
|
return pulumi.get(self, "wait_for_capacity")
|
|
1192
1245
|
|
|
1193
1246
|
@wait_for_capacity.setter
|
|
1194
|
-
def wait_for_capacity(self, value: Optional[pulumi.Input[int]]):
|
|
1247
|
+
def wait_for_capacity(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
1195
1248
|
pulumi.set(self, "wait_for_capacity", value)
|
|
1196
1249
|
|
|
1197
|
-
@property
|
|
1250
|
+
@_builtins.property
|
|
1198
1251
|
@pulumi.getter(name="waitForCapacityTimeout")
|
|
1199
|
-
def wait_for_capacity_timeout(self) -> Optional[pulumi.Input[int]]:
|
|
1252
|
+
def wait_for_capacity_timeout(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
1200
1253
|
"""
|
|
1201
1254
|
Time (seconds) to wait for instances to report a 'HEALTHY' status. Useful for plans with multiple dependencies that take some time to initialize. Leave undefined or set to `0` to indicate no wait. This is ignored when updating with blue/green deployment.
|
|
1202
1255
|
"""
|
|
1203
1256
|
return pulumi.get(self, "wait_for_capacity_timeout")
|
|
1204
1257
|
|
|
1205
1258
|
@wait_for_capacity_timeout.setter
|
|
1206
|
-
def wait_for_capacity_timeout(self, value: Optional[pulumi.Input[int]]):
|
|
1259
|
+
def wait_for_capacity_timeout(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
1207
1260
|
pulumi.set(self, "wait_for_capacity_timeout", value)
|
|
1208
1261
|
|
|
1209
1262
|
|
|
1210
1263
|
@pulumi.input_type
|
|
1211
1264
|
class _ElastigroupState:
|
|
1212
1265
|
def __init__(__self__, *,
|
|
1213
|
-
|
|
1214
|
-
|
|
1215
|
-
|
|
1216
|
-
|
|
1217
|
-
|
|
1266
|
+
auto_healing: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
1267
|
+
availability_zones: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
1268
|
+
block_devices_mode: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1269
|
+
capacity_unit: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1270
|
+
consider_od_pricing: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
1271
|
+
cpu_credits: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1218
1272
|
cpu_options: Optional[pulumi.Input['ElastigroupCpuOptionsArgs']] = None,
|
|
1219
|
-
description: Optional[pulumi.Input[str]] = None,
|
|
1220
|
-
desired_capacity: Optional[pulumi.Input[int]] = None,
|
|
1221
|
-
draining_timeout: Optional[pulumi.Input[int]] = None,
|
|
1273
|
+
description: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1274
|
+
desired_capacity: Optional[pulumi.Input[_builtins.int]] = None,
|
|
1275
|
+
draining_timeout: Optional[pulumi.Input[_builtins.int]] = None,
|
|
1222
1276
|
ebs_block_devices: Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupEbsBlockDeviceArgs']]]] = None,
|
|
1223
|
-
ebs_optimized: Optional[pulumi.Input[bool]] = None,
|
|
1224
|
-
elastic_ips: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
|
|
1225
|
-
elastic_load_balancers: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
|
|
1226
|
-
enable_monitoring: Optional[pulumi.Input[bool]] = None,
|
|
1277
|
+
ebs_optimized: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
1278
|
+
elastic_ips: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
1279
|
+
elastic_load_balancers: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
1280
|
+
enable_monitoring: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
1227
1281
|
ephemeral_block_devices: Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupEphemeralBlockDeviceArgs']]]] = None,
|
|
1228
|
-
fallback_to_ondemand: Optional[pulumi.Input[bool]] = None,
|
|
1229
|
-
health_check_grace_period: Optional[pulumi.Input[int]] = None,
|
|
1230
|
-
health_check_type: Optional[pulumi.Input[str]] = None,
|
|
1231
|
-
health_check_unhealthy_duration_before_replacement: Optional[pulumi.Input[int]] = None,
|
|
1232
|
-
iam_instance_profile: Optional[pulumi.Input[str]] = None,
|
|
1233
|
-
image_id: Optional[pulumi.Input[str]] = None,
|
|
1282
|
+
fallback_to_ondemand: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
1283
|
+
health_check_grace_period: Optional[pulumi.Input[_builtins.int]] = None,
|
|
1284
|
+
health_check_type: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1285
|
+
health_check_unhealthy_duration_before_replacement: Optional[pulumi.Input[_builtins.int]] = None,
|
|
1286
|
+
iam_instance_profile: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1287
|
+
image_id: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1234
1288
|
images: Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupImageArgs']]]] = None,
|
|
1235
|
-
immediate_od_recover_threshold: Optional[pulumi.Input[int]] = None,
|
|
1236
|
-
instance_types_ondemand: Optional[pulumi.Input[str]] = None,
|
|
1237
|
-
instance_types_preferred_spots: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
|
|
1238
|
-
instance_types_spots: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
|
|
1289
|
+
immediate_od_recover_threshold: Optional[pulumi.Input[_builtins.int]] = None,
|
|
1290
|
+
instance_types_ondemand: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1291
|
+
instance_types_preferred_spots: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
1292
|
+
instance_types_spots: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
1239
1293
|
instance_types_weights: Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupInstanceTypesWeightArgs']]]] = None,
|
|
1240
1294
|
integration_beanstalk: Optional[pulumi.Input['ElastigroupIntegrationBeanstalkArgs']] = None,
|
|
1241
1295
|
integration_codedeploy: Optional[pulumi.Input['ElastigroupIntegrationCodedeployArgs']] = None,
|
|
@@ -1248,108 +1302,114 @@ class _ElastigroupState:
|
|
|
1248
1302
|
integration_rancher: Optional[pulumi.Input['ElastigroupIntegrationRancherArgs']] = None,
|
|
1249
1303
|
integration_route53: Optional[pulumi.Input['ElastigroupIntegrationRoute53Args']] = None,
|
|
1250
1304
|
itfs: Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupItfArgs']]]] = None,
|
|
1251
|
-
key_name: Optional[pulumi.Input[str]] = None,
|
|
1252
|
-
lifetime_period: Optional[pulumi.Input[str]] = None,
|
|
1305
|
+
key_name: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1306
|
+
lifetime_period: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1253
1307
|
logging: Optional[pulumi.Input['ElastigroupLoggingArgs']] = None,
|
|
1254
|
-
|
|
1308
|
+
max_replacements_percentage: Optional[pulumi.Input[_builtins.int]] = None,
|
|
1309
|
+
max_size: Optional[pulumi.Input[_builtins.int]] = None,
|
|
1255
1310
|
metadata_options: Optional[pulumi.Input['ElastigroupMetadataOptionsArgs']] = None,
|
|
1256
|
-
min_size: Optional[pulumi.Input[int]] = None,
|
|
1257
|
-
minimum_instance_lifetime: Optional[pulumi.Input[int]] = None,
|
|
1311
|
+
min_size: Optional[pulumi.Input[_builtins.int]] = None,
|
|
1312
|
+
minimum_instance_lifetime: Optional[pulumi.Input[_builtins.int]] = None,
|
|
1258
1313
|
multiple_metrics: Optional[pulumi.Input['ElastigroupMultipleMetricsArgs']] = None,
|
|
1259
|
-
name: Optional[pulumi.Input[str]] = None,
|
|
1314
|
+
name: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1260
1315
|
network_interfaces: Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupNetworkInterfaceArgs']]]] = None,
|
|
1261
|
-
on_demand_types: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
|
|
1262
|
-
ondemand_count: Optional[pulumi.Input[int]] = None,
|
|
1263
|
-
orientation: Optional[pulumi.Input[str]] = None,
|
|
1264
|
-
persist_block_devices: Optional[pulumi.Input[bool]] = None,
|
|
1265
|
-
persist_private_ip: Optional[pulumi.Input[bool]] = None,
|
|
1266
|
-
persist_root_device: Optional[pulumi.Input[bool]] = None,
|
|
1267
|
-
placement_tenancy: Optional[pulumi.Input[str]] = None,
|
|
1268
|
-
preferred_availability_zones: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
|
|
1269
|
-
private_ips: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
|
|
1270
|
-
product: Optional[pulumi.Input[str]] = None,
|
|
1271
|
-
region: Optional[pulumi.Input[str]] = None,
|
|
1316
|
+
on_demand_types: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
1317
|
+
ondemand_count: Optional[pulumi.Input[_builtins.int]] = None,
|
|
1318
|
+
orientation: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1319
|
+
persist_block_devices: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
1320
|
+
persist_private_ip: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
1321
|
+
persist_root_device: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
1322
|
+
placement_tenancy: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1323
|
+
preferred_availability_zones: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
1324
|
+
private_ips: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
1325
|
+
product: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1326
|
+
region: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1272
1327
|
resource_requirements: Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupResourceRequirementArgs']]]] = None,
|
|
1273
1328
|
resource_tag_specifications: Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupResourceTagSpecificationArgs']]]] = None,
|
|
1329
|
+
restrict_single_az: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
1274
1330
|
revert_to_spot: Optional[pulumi.Input['ElastigroupRevertToSpotArgs']] = None,
|
|
1275
1331
|
scaling_down_policies: Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupScalingDownPolicyArgs']]]] = None,
|
|
1276
1332
|
scaling_strategies: Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupScalingStrategyArgs']]]] = None,
|
|
1277
1333
|
scaling_target_policies: Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupScalingTargetPolicyArgs']]]] = None,
|
|
1278
1334
|
scaling_up_policies: Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupScalingUpPolicyArgs']]]] = None,
|
|
1279
1335
|
scheduled_tasks: Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupScheduledTaskArgs']]]] = None,
|
|
1280
|
-
security_groups: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
|
|
1281
|
-
shutdown_script: Optional[pulumi.Input[str]] = None,
|
|
1336
|
+
security_groups: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
1337
|
+
shutdown_script: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1282
1338
|
signals: Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupSignalArgs']]]] = None,
|
|
1283
|
-
spot_percentage: Optional[pulumi.Input[int]] = None,
|
|
1339
|
+
spot_percentage: Optional[pulumi.Input[_builtins.int]] = None,
|
|
1284
1340
|
stateful_deallocation: Optional[pulumi.Input['ElastigroupStatefulDeallocationArgs']] = None,
|
|
1285
1341
|
stateful_instance_actions: Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupStatefulInstanceActionArgs']]]] = None,
|
|
1286
|
-
subnet_ids: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
|
|
1342
|
+
subnet_ids: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
1287
1343
|
tags: Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupTagArgs']]]] = None,
|
|
1288
|
-
target_group_arns: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
|
|
1344
|
+
target_group_arns: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
1289
1345
|
update_policy: Optional[pulumi.Input['ElastigroupUpdatePolicyArgs']] = None,
|
|
1290
|
-
user_data: Optional[pulumi.Input[str]] = None,
|
|
1291
|
-
utilize_commitments: Optional[pulumi.Input[bool]] = None,
|
|
1292
|
-
utilize_reserved_instances: Optional[pulumi.Input[bool]] = None,
|
|
1293
|
-
wait_for_capacity: Optional[pulumi.Input[int]] = None,
|
|
1294
|
-
wait_for_capacity_timeout: Optional[pulumi.Input[int]] = None):
|
|
1346
|
+
user_data: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1347
|
+
utilize_commitments: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
1348
|
+
utilize_reserved_instances: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
1349
|
+
wait_for_capacity: Optional[pulumi.Input[_builtins.int]] = None,
|
|
1350
|
+
wait_for_capacity_timeout: Optional[pulumi.Input[_builtins.int]] = None):
|
|
1295
1351
|
"""
|
|
1296
1352
|
Input properties used for looking up and filtering Elastigroup resources.
|
|
1297
|
-
:param pulumi.Input[
|
|
1353
|
+
:param pulumi.Input[_builtins.bool] auto_healing: Auto-healing replacement won't be triggered if this parameter value is "false". In a case of a stateful group - no recycling will start if this parameter value is "false".
|
|
1354
|
+
:param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] availability_zones: List of Strings of availability zones. When this parameter is set, `subnet_ids` should be left unused.
|
|
1298
1355
|
Note: `availability_zones` naming syntax follows the convention `availability-zone:subnet:placement-group-name`. For example, to set an AZ in `us-east-1` with subnet `subnet-123456` and placement group `ClusterI03`, you would set:
|
|
1299
1356
|
`availability_zones = ["us-east-1a:subnet-123456:ClusterI03"]`
|
|
1300
|
-
:param pulumi.Input[str] capacity_unit: The capacity unit to launch instances by. If not specified, when choosing the weight unit, each instance will weight as the number of its vCPUs. Valid values: `instance`, `weight`.
|
|
1301
|
-
:param pulumi.Input[str] cpu_credits: Controls how T3 instances are launched. Valid values: `standard`, `unlimited`.
|
|
1357
|
+
:param pulumi.Input[_builtins.str] capacity_unit: The capacity unit to launch instances by. If not specified, when choosing the weight unit, each instance will weight as the number of its vCPUs. Valid values: `instance`, `weight`.
|
|
1358
|
+
:param pulumi.Input[_builtins.str] cpu_credits: Controls how T3 instances are launched. Valid values: `standard`, `unlimited`.
|
|
1302
1359
|
:param pulumi.Input['ElastigroupCpuOptionsArgs'] cpu_options: The CPU options for the instances that are launched within the group:
|
|
1303
|
-
:param pulumi.Input[str] description: The group description.
|
|
1304
|
-
:param pulumi.Input[int] desired_capacity: The desired number of instances the group should have at any time.
|
|
1305
|
-
:param pulumi.Input[int] draining_timeout: The time in seconds, the instance is allowed to run while detached from the ELB. This is to allow the instance time to be drained from incoming TCP connections before terminating it, during a scale down operation.
|
|
1306
|
-
:param pulumi.Input[bool] ebs_optimized: Enable high bandwidth connectivity between instances and AWS’s Elastic Block Store (EBS). For instance types that are EBS-optimized by default this parameter will be ignored.
|
|
1307
|
-
:param pulumi.Input[Sequence[pulumi.Input[str]]] elastic_ips: A list of [AWS Elastic IP](http://docs.aws.amazon.com/AWSEC2/latest/UserGuide/elastic-ip-addresses-eip.html) allocation IDs to associate to the group instances.
|
|
1308
|
-
:param pulumi.Input[bool] enable_monitoring: Indicates whether monitoring is enabled for the instance.
|
|
1309
|
-
:param pulumi.Input[bool] fallback_to_ondemand: In a case of no Spot instances available, Elastigroup will launch on-demand instances instead.
|
|
1310
|
-
:param pulumi.Input[int] health_check_grace_period: The amount of time, in seconds, after the instance has launched to starts and check its health.
|
|
1311
|
-
:param pulumi.Input[str] health_check_type: The service that will perform health checks for the instance. Valid values: `"ELB"`, `"HCS"`, `"TARGET_GROUP"`, `"EC2"`, `"K8S_NODE"`, `"NOMAD_NODE"`, `"ECS_CLUSTER_INSTANCE"`.
|
|
1312
|
-
:param pulumi.Input[int] health_check_unhealthy_duration_before_replacement: The amount of time, in seconds, that we will wait before replacing an instance that is running and became unhealthy (this is only applicable for instances that were once healthy).
|
|
1313
|
-
:param pulumi.Input[str] iam_instance_profile: The ARN or name of an IAM instance profile to associate with launched instances.
|
|
1314
|
-
:param pulumi.Input[str] image_id: The ID of the AMI used to launch the instance.
|
|
1360
|
+
:param pulumi.Input[_builtins.str] description: The group description.
|
|
1361
|
+
:param pulumi.Input[_builtins.int] desired_capacity: The desired number of instances the group should have at any time.
|
|
1362
|
+
:param pulumi.Input[_builtins.int] draining_timeout: The time in seconds, the instance is allowed to run while detached from the ELB. This is to allow the instance time to be drained from incoming TCP connections before terminating it, during a scale down operation.
|
|
1363
|
+
:param pulumi.Input[_builtins.bool] ebs_optimized: Enable high bandwidth connectivity between instances and AWS’s Elastic Block Store (EBS). For instance types that are EBS-optimized by default this parameter will be ignored.
|
|
1364
|
+
:param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] elastic_ips: A list of [AWS Elastic IP](http://docs.aws.amazon.com/AWSEC2/latest/UserGuide/elastic-ip-addresses-eip.html) allocation IDs to associate to the group instances.
|
|
1365
|
+
:param pulumi.Input[_builtins.bool] enable_monitoring: Indicates whether monitoring is enabled for the instance.
|
|
1366
|
+
:param pulumi.Input[_builtins.bool] fallback_to_ondemand: In a case of no Spot instances available, Elastigroup will launch on-demand instances instead.
|
|
1367
|
+
:param pulumi.Input[_builtins.int] health_check_grace_period: The amount of time, in seconds, after the instance has launched to starts and check its health.
|
|
1368
|
+
:param pulumi.Input[_builtins.str] health_check_type: The service that will perform health checks for the instance. Valid values: `"ELB"`, `"HCS"`, `"TARGET_GROUP"`, `"EC2"`, `"K8S_NODE"`, `"NOMAD_NODE"`, `"ECS_CLUSTER_INSTANCE"`.
|
|
1369
|
+
:param pulumi.Input[_builtins.int] health_check_unhealthy_duration_before_replacement: The amount of time, in seconds, that we will wait before replacing an instance that is running and became unhealthy (this is only applicable for instances that were once healthy).
|
|
1370
|
+
:param pulumi.Input[_builtins.str] iam_instance_profile: The ARN or name of an IAM instance profile to associate with launched instances.
|
|
1371
|
+
:param pulumi.Input[_builtins.str] image_id: The ID of the AMI used to launch the instance.
|
|
1315
1372
|
:param pulumi.Input[Sequence[pulumi.Input['ElastigroupImageArgs']]] images: An array of image objects.
|
|
1316
1373
|
Note: Elastigroup can be configured with either imageId or images, but not both.
|
|
1317
|
-
:param pulumi.Input[str] instance_types_ondemand: The type of instance determines your instance's CPU capacity, memory and storage (e.g., m1.small, c1.xlarge).
|
|
1318
|
-
:param pulumi.Input[Sequence[pulumi.Input[str]]] instance_types_preferred_spots: Prioritize a subset of spot instance types. Must be a subset of the selected spot instance types.
|
|
1319
|
-
:param pulumi.Input[Sequence[pulumi.Input[str]]] instance_types_spots: One or more instance types. Note: Cannot be defined if 'resourceRequirements' is defined.
|
|
1374
|
+
:param pulumi.Input[_builtins.str] instance_types_ondemand: The type of instance determines your instance's CPU capacity, memory and storage (e.g., m1.small, c1.xlarge).
|
|
1375
|
+
:param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] instance_types_preferred_spots: Prioritize a subset of spot instance types. Must be a subset of the selected spot instance types.
|
|
1376
|
+
:param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] instance_types_spots: One or more instance types. Note: Cannot be defined if 'resourceRequirements' is defined.
|
|
1320
1377
|
:param pulumi.Input[Sequence[pulumi.Input['ElastigroupInstanceTypesWeightArgs']]] instance_types_weights: List of weights per instance type for weighted groups. Each object in the list should have the following attributes:
|
|
1321
|
-
:param pulumi.Input[str] key_name: The key name that should be used for the instance.
|
|
1378
|
+
:param pulumi.Input[_builtins.str] key_name: The key name that should be used for the instance.
|
|
1322
1379
|
:param pulumi.Input['ElastigroupLoggingArgs'] logging: Logging configuration.
|
|
1323
|
-
:param pulumi.Input[int] max_size: The maximum number of instances the group should have at any time.
|
|
1380
|
+
:param pulumi.Input[_builtins.int] max_size: The maximum number of instances the group should have at any time.
|
|
1324
1381
|
:param pulumi.Input['ElastigroupMetadataOptionsArgs'] metadata_options: Data that used to configure or manage the running instances:
|
|
1325
|
-
:param pulumi.Input[int] min_size: The minimum number of instances the group should have at any time.
|
|
1326
|
-
:param pulumi.Input[int] minimum_instance_lifetime: Defines the preferred minimum instance lifetime in hours. Markets which comply with this preference will be prioritized. Optional values: 1, 3, 6, 12, 24.
|
|
1327
|
-
:param pulumi.Input[str] name: The group name.
|
|
1328
|
-
:param pulumi.Input[Sequence[pulumi.Input[str]]] on_demand_types: Available ondemand instance types. Note: Either ondemand or onDemandTypes must be defined, but not both.
|
|
1329
|
-
:param pulumi.Input[int] ondemand_count: Number of on demand instances to launch in the group. All other instances will be spot instances. When this parameter is set the `spot_percentage` parameter is being ignored.
|
|
1330
|
-
:param pulumi.Input[str] orientation: Select a prediction strategy. Valid values: `balanced`, `costOriented`, `equalAzDistribution`, `availabilityOriented`. You can read more in our documentation.
|
|
1331
|
-
:param pulumi.Input[str] placement_tenancy: Enable dedicated tenancy. Note: There is a flat hourly fee for each region in which dedicated tenancy is used. Valid values: "default", "dedicated" .
|
|
1332
|
-
:param pulumi.Input[Sequence[pulumi.Input[str]]] preferred_availability_zones: The AZs to prioritize when launching Spot instances. If no markets are available in the Preferred AZs, Spot instances are launched in the non-preferred AZs.
|
|
1382
|
+
:param pulumi.Input[_builtins.int] min_size: The minimum number of instances the group should have at any time.
|
|
1383
|
+
:param pulumi.Input[_builtins.int] minimum_instance_lifetime: Defines the preferred minimum instance lifetime in hours. Markets which comply with this preference will be prioritized. Optional values: 1, 3, 6, 12, 24.
|
|
1384
|
+
:param pulumi.Input[_builtins.str] name: The group name.
|
|
1385
|
+
:param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] on_demand_types: Available ondemand instance types. Note: Either ondemand or onDemandTypes must be defined, but not both.
|
|
1386
|
+
:param pulumi.Input[_builtins.int] ondemand_count: Number of on demand instances to launch in the group. All other instances will be spot instances. When this parameter is set the `spot_percentage` parameter is being ignored.
|
|
1387
|
+
:param pulumi.Input[_builtins.str] orientation: Select a prediction strategy. Valid values: `balanced`, `costOriented`, `equalAzDistribution`, `availabilityOriented`. You can read more in our documentation.
|
|
1388
|
+
:param pulumi.Input[_builtins.str] placement_tenancy: Enable dedicated tenancy. Note: There is a flat hourly fee for each region in which dedicated tenancy is used. Valid values: "default", "dedicated" .
|
|
1389
|
+
:param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] preferred_availability_zones: The AZs to prioritize when launching Spot instances. If no markets are available in the Preferred AZs, Spot instances are launched in the non-preferred AZs.
|
|
1333
1390
|
Note: Must be a sublist of `availability_zones` and `orientation` value must not be `"equalAzDistribution"`.
|
|
1334
|
-
:param pulumi.Input[str] product: Operation system type. Valid values: `"Linux/UNIX"`, `"SUSE Linux"`, `"Windows"`.
|
|
1335
|
-
For EC2 Classic instances:
|
|
1336
|
-
:param pulumi.Input[str] region: The AWS region your group will be created in.
|
|
1391
|
+
:param pulumi.Input[_builtins.str] product: Operation system type. Valid values: `"Linux/UNIX"`, `"SUSE Linux"`, `"Windows"`.
|
|
1392
|
+
For EC2 Classic instances: `"SUSE Linux (Amazon VPC)"`, `"Windows (Amazon VPC)"`.
|
|
1393
|
+
:param pulumi.Input[_builtins.str] region: The AWS region your group will be created in.
|
|
1337
1394
|
Note: This parameter is required if you specify subnets (through subnet_ids). This parameter is optional if you specify Availability Zones (through availability_zones).
|
|
1338
1395
|
:param pulumi.Input[Sequence[pulumi.Input['ElastigroupResourceRequirementArgs']]] resource_requirements: Required instance attributes. Instance types will be selected based on these requirements.
|
|
1339
1396
|
:param pulumi.Input[Sequence[pulumi.Input['ElastigroupResourceTagSpecificationArgs']]] resource_tag_specifications: User will specify which resources should be tagged with group tags.
|
|
1397
|
+
:param pulumi.Input[_builtins.bool] restrict_single_az: Elastigroup will automatically scale your instances in the most available and cost efficient availability zone. Every evaluation will be done when there are no active instances in the group.
|
|
1340
1398
|
:param pulumi.Input['ElastigroupRevertToSpotArgs'] revert_to_spot: Hold settings for strategy correction – replacing On-Demand for Spot instances. Supported Values: `"never"`, `"always"`, `"timeWindow"`
|
|
1341
1399
|
:param pulumi.Input[Sequence[pulumi.Input['ElastigroupScalingStrategyArgs']]] scaling_strategies: Set termination policy.
|
|
1342
|
-
:param pulumi.Input[Sequence[pulumi.Input[str]]] security_groups: A list of associated security group IDS.
|
|
1343
|
-
:param pulumi.Input[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/)
|
|
1344
|
-
:param pulumi.Input[int] spot_percentage: The percentage of Spot instances that would spin up from the `desired_capacity` number.
|
|
1345
|
-
:param pulumi.Input[Sequence[pulumi.Input[str]]] subnet_ids: List of Strings of subnet identifiers.
|
|
1400
|
+
:param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] security_groups: A list of associated security group IDS.
|
|
1401
|
+
: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/)
|
|
1402
|
+
:param pulumi.Input[_builtins.int] spot_percentage: The percentage of Spot instances that would spin up from the `desired_capacity` number.
|
|
1403
|
+
:param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] subnet_ids: List of Strings of subnet identifiers.
|
|
1346
1404
|
Note: When this parameter is set, `availability_zones` should be left unused.
|
|
1347
1405
|
:param pulumi.Input[Sequence[pulumi.Input['ElastigroupTagArgs']]] tags: A key/value mapping of tags to assign to the resource.
|
|
1348
|
-
:param pulumi.Input[str] user_data: The user data to provide when launching the instance.
|
|
1349
|
-
:param pulumi.Input[bool] utilize_reserved_instances: In a case of any available reserved instances, Elastigroup will utilize them first before purchasing Spot instances.
|
|
1350
|
-
:param pulumi.Input[int] wait_for_capacity: Minimum number of instances in a 'HEALTHY' status that is required before continuing. This is ignored when updating with blue/green deployment. Cannot exceed `desired_capacity`.
|
|
1351
|
-
:param pulumi.Input[int] wait_for_capacity_timeout: Time (seconds) to wait for instances to report a 'HEALTHY' status. Useful for plans with multiple dependencies that take some time to initialize. Leave undefined or set to `0` to indicate no wait. This is ignored when updating with blue/green deployment.
|
|
1406
|
+
:param pulumi.Input[_builtins.str] user_data: The user data to provide when launching the instance.
|
|
1407
|
+
:param pulumi.Input[_builtins.bool] utilize_reserved_instances: In a case of any available reserved instances, Elastigroup will utilize them first before purchasing Spot instances.
|
|
1408
|
+
:param pulumi.Input[_builtins.int] wait_for_capacity: Minimum number of instances in a 'HEALTHY' status that is required before continuing. This is ignored when updating with blue/green deployment. Cannot exceed `desired_capacity`.
|
|
1409
|
+
:param pulumi.Input[_builtins.int] wait_for_capacity_timeout: Time (seconds) to wait for instances to report a 'HEALTHY' status. Useful for plans with multiple dependencies that take some time to initialize. Leave undefined or set to `0` to indicate no wait. This is ignored when updating with blue/green deployment.
|
|
1352
1410
|
"""
|
|
1411
|
+
if auto_healing is not None:
|
|
1412
|
+
pulumi.set(__self__, "auto_healing", auto_healing)
|
|
1353
1413
|
if availability_zones is not None:
|
|
1354
1414
|
pulumi.set(__self__, "availability_zones", availability_zones)
|
|
1355
1415
|
if block_devices_mode is not None:
|
|
@@ -1432,6 +1492,8 @@ class _ElastigroupState:
|
|
|
1432
1492
|
pulumi.set(__self__, "lifetime_period", lifetime_period)
|
|
1433
1493
|
if logging is not None:
|
|
1434
1494
|
pulumi.set(__self__, "logging", logging)
|
|
1495
|
+
if max_replacements_percentage is not None:
|
|
1496
|
+
pulumi.set(__self__, "max_replacements_percentage", max_replacements_percentage)
|
|
1435
1497
|
if max_size is not None:
|
|
1436
1498
|
pulumi.set(__self__, "max_size", max_size)
|
|
1437
1499
|
if metadata_options is not None:
|
|
@@ -1472,6 +1534,8 @@ class _ElastigroupState:
|
|
|
1472
1534
|
pulumi.set(__self__, "resource_requirements", resource_requirements)
|
|
1473
1535
|
if resource_tag_specifications is not None:
|
|
1474
1536
|
pulumi.set(__self__, "resource_tag_specifications", resource_tag_specifications)
|
|
1537
|
+
if restrict_single_az is not None:
|
|
1538
|
+
pulumi.set(__self__, "restrict_single_az", restrict_single_az)
|
|
1475
1539
|
if revert_to_spot is not None:
|
|
1476
1540
|
pulumi.set(__self__, "revert_to_spot", revert_to_spot)
|
|
1477
1541
|
if scaling_down_policies is not None:
|
|
@@ -1496,6 +1560,9 @@ class _ElastigroupState:
|
|
|
1496
1560
|
pulumi.set(__self__, "stateful_deallocation", stateful_deallocation)
|
|
1497
1561
|
if stateful_instance_actions is not None:
|
|
1498
1562
|
pulumi.set(__self__, "stateful_instance_actions", stateful_instance_actions)
|
|
1563
|
+
if subnet_ids is not None:
|
|
1564
|
+
warnings.warn("""This field will soon be deprecated and handled by availability_zones""", DeprecationWarning)
|
|
1565
|
+
pulumi.log.warn("""subnet_ids is deprecated: This field will soon be deprecated and handled by availability_zones""")
|
|
1499
1566
|
if subnet_ids is not None:
|
|
1500
1567
|
pulumi.set(__self__, "subnet_ids", subnet_ids)
|
|
1501
1568
|
if tags is not None:
|
|
@@ -1515,9 +1582,21 @@ class _ElastigroupState:
|
|
|
1515
1582
|
if wait_for_capacity_timeout is not None:
|
|
1516
1583
|
pulumi.set(__self__, "wait_for_capacity_timeout", wait_for_capacity_timeout)
|
|
1517
1584
|
|
|
1518
|
-
@property
|
|
1585
|
+
@_builtins.property
|
|
1586
|
+
@pulumi.getter(name="autoHealing")
|
|
1587
|
+
def auto_healing(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
1588
|
+
"""
|
|
1589
|
+
Auto-healing replacement won't be triggered if this parameter value is "false". In a case of a stateful group - no recycling will start if this parameter value is "false".
|
|
1590
|
+
"""
|
|
1591
|
+
return pulumi.get(self, "auto_healing")
|
|
1592
|
+
|
|
1593
|
+
@auto_healing.setter
|
|
1594
|
+
def auto_healing(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
1595
|
+
pulumi.set(self, "auto_healing", value)
|
|
1596
|
+
|
|
1597
|
+
@_builtins.property
|
|
1519
1598
|
@pulumi.getter(name="availabilityZones")
|
|
1520
|
-
def availability_zones(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
|
|
1599
|
+
def availability_zones(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
|
|
1521
1600
|
"""
|
|
1522
1601
|
List of Strings of availability zones. When this parameter is set, `subnet_ids` should be left unused.
|
|
1523
1602
|
Note: `availability_zones` naming syntax follows the convention `availability-zone:subnet:placement-group-name`. For example, to set an AZ in `us-east-1` with subnet `subnet-123456` and placement group `ClusterI03`, you would set:
|
|
@@ -1526,52 +1605,52 @@ class _ElastigroupState:
|
|
|
1526
1605
|
return pulumi.get(self, "availability_zones")
|
|
1527
1606
|
|
|
1528
1607
|
@availability_zones.setter
|
|
1529
|
-
def availability_zones(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
|
|
1608
|
+
def availability_zones(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]):
|
|
1530
1609
|
pulumi.set(self, "availability_zones", value)
|
|
1531
1610
|
|
|
1532
|
-
@property
|
|
1611
|
+
@_builtins.property
|
|
1533
1612
|
@pulumi.getter(name="blockDevicesMode")
|
|
1534
|
-
def block_devices_mode(self) -> Optional[pulumi.Input[str]]:
|
|
1613
|
+
def block_devices_mode(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
1535
1614
|
return pulumi.get(self, "block_devices_mode")
|
|
1536
1615
|
|
|
1537
1616
|
@block_devices_mode.setter
|
|
1538
|
-
def block_devices_mode(self, value: Optional[pulumi.Input[str]]):
|
|
1617
|
+
def block_devices_mode(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
1539
1618
|
pulumi.set(self, "block_devices_mode", value)
|
|
1540
1619
|
|
|
1541
|
-
@property
|
|
1620
|
+
@_builtins.property
|
|
1542
1621
|
@pulumi.getter(name="capacityUnit")
|
|
1543
|
-
def capacity_unit(self) -> Optional[pulumi.Input[str]]:
|
|
1622
|
+
def capacity_unit(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
1544
1623
|
"""
|
|
1545
1624
|
The capacity unit to launch instances by. If not specified, when choosing the weight unit, each instance will weight as the number of its vCPUs. Valid values: `instance`, `weight`.
|
|
1546
1625
|
"""
|
|
1547
1626
|
return pulumi.get(self, "capacity_unit")
|
|
1548
1627
|
|
|
1549
1628
|
@capacity_unit.setter
|
|
1550
|
-
def capacity_unit(self, value: Optional[pulumi.Input[str]]):
|
|
1629
|
+
def capacity_unit(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
1551
1630
|
pulumi.set(self, "capacity_unit", value)
|
|
1552
1631
|
|
|
1553
|
-
@property
|
|
1632
|
+
@_builtins.property
|
|
1554
1633
|
@pulumi.getter(name="considerOdPricing")
|
|
1555
|
-
def consider_od_pricing(self) -> Optional[pulumi.Input[bool]]:
|
|
1634
|
+
def consider_od_pricing(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
1556
1635
|
return pulumi.get(self, "consider_od_pricing")
|
|
1557
1636
|
|
|
1558
1637
|
@consider_od_pricing.setter
|
|
1559
|
-
def consider_od_pricing(self, value: Optional[pulumi.Input[bool]]):
|
|
1638
|
+
def consider_od_pricing(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
1560
1639
|
pulumi.set(self, "consider_od_pricing", value)
|
|
1561
1640
|
|
|
1562
|
-
@property
|
|
1641
|
+
@_builtins.property
|
|
1563
1642
|
@pulumi.getter(name="cpuCredits")
|
|
1564
|
-
def cpu_credits(self) -> Optional[pulumi.Input[str]]:
|
|
1643
|
+
def cpu_credits(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
1565
1644
|
"""
|
|
1566
1645
|
Controls how T3 instances are launched. Valid values: `standard`, `unlimited`.
|
|
1567
1646
|
"""
|
|
1568
1647
|
return pulumi.get(self, "cpu_credits")
|
|
1569
1648
|
|
|
1570
1649
|
@cpu_credits.setter
|
|
1571
|
-
def cpu_credits(self, value: Optional[pulumi.Input[str]]):
|
|
1650
|
+
def cpu_credits(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
1572
1651
|
pulumi.set(self, "cpu_credits", value)
|
|
1573
1652
|
|
|
1574
|
-
@property
|
|
1653
|
+
@_builtins.property
|
|
1575
1654
|
@pulumi.getter(name="cpuOptions")
|
|
1576
1655
|
def cpu_options(self) -> Optional[pulumi.Input['ElastigroupCpuOptionsArgs']]:
|
|
1577
1656
|
"""
|
|
@@ -1583,43 +1662,43 @@ class _ElastigroupState:
|
|
|
1583
1662
|
def cpu_options(self, value: Optional[pulumi.Input['ElastigroupCpuOptionsArgs']]):
|
|
1584
1663
|
pulumi.set(self, "cpu_options", value)
|
|
1585
1664
|
|
|
1586
|
-
@property
|
|
1665
|
+
@_builtins.property
|
|
1587
1666
|
@pulumi.getter
|
|
1588
|
-
def description(self) -> Optional[pulumi.Input[str]]:
|
|
1667
|
+
def description(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
1589
1668
|
"""
|
|
1590
1669
|
The group description.
|
|
1591
1670
|
"""
|
|
1592
1671
|
return pulumi.get(self, "description")
|
|
1593
1672
|
|
|
1594
1673
|
@description.setter
|
|
1595
|
-
def description(self, value: Optional[pulumi.Input[str]]):
|
|
1674
|
+
def description(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
1596
1675
|
pulumi.set(self, "description", value)
|
|
1597
1676
|
|
|
1598
|
-
@property
|
|
1677
|
+
@_builtins.property
|
|
1599
1678
|
@pulumi.getter(name="desiredCapacity")
|
|
1600
|
-
def desired_capacity(self) -> Optional[pulumi.Input[int]]:
|
|
1679
|
+
def desired_capacity(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
1601
1680
|
"""
|
|
1602
1681
|
The desired number of instances the group should have at any time.
|
|
1603
1682
|
"""
|
|
1604
1683
|
return pulumi.get(self, "desired_capacity")
|
|
1605
1684
|
|
|
1606
1685
|
@desired_capacity.setter
|
|
1607
|
-
def desired_capacity(self, value: Optional[pulumi.Input[int]]):
|
|
1686
|
+
def desired_capacity(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
1608
1687
|
pulumi.set(self, "desired_capacity", value)
|
|
1609
1688
|
|
|
1610
|
-
@property
|
|
1689
|
+
@_builtins.property
|
|
1611
1690
|
@pulumi.getter(name="drainingTimeout")
|
|
1612
|
-
def draining_timeout(self) -> Optional[pulumi.Input[int]]:
|
|
1691
|
+
def draining_timeout(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
1613
1692
|
"""
|
|
1614
1693
|
The time in seconds, the instance is allowed to run while detached from the ELB. This is to allow the instance time to be drained from incoming TCP connections before terminating it, during a scale down operation.
|
|
1615
1694
|
"""
|
|
1616
1695
|
return pulumi.get(self, "draining_timeout")
|
|
1617
1696
|
|
|
1618
1697
|
@draining_timeout.setter
|
|
1619
|
-
def draining_timeout(self, value: Optional[pulumi.Input[int]]):
|
|
1698
|
+
def draining_timeout(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
1620
1699
|
pulumi.set(self, "draining_timeout", value)
|
|
1621
1700
|
|
|
1622
|
-
@property
|
|
1701
|
+
@_builtins.property
|
|
1623
1702
|
@pulumi.getter(name="ebsBlockDevices")
|
|
1624
1703
|
def ebs_block_devices(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupEbsBlockDeviceArgs']]]]:
|
|
1625
1704
|
return pulumi.get(self, "ebs_block_devices")
|
|
@@ -1628,52 +1707,52 @@ class _ElastigroupState:
|
|
|
1628
1707
|
def ebs_block_devices(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupEbsBlockDeviceArgs']]]]):
|
|
1629
1708
|
pulumi.set(self, "ebs_block_devices", value)
|
|
1630
1709
|
|
|
1631
|
-
@property
|
|
1710
|
+
@_builtins.property
|
|
1632
1711
|
@pulumi.getter(name="ebsOptimized")
|
|
1633
|
-
def ebs_optimized(self) -> Optional[pulumi.Input[bool]]:
|
|
1712
|
+
def ebs_optimized(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
1634
1713
|
"""
|
|
1635
1714
|
Enable high bandwidth connectivity between instances and AWS’s Elastic Block Store (EBS). For instance types that are EBS-optimized by default this parameter will be ignored.
|
|
1636
1715
|
"""
|
|
1637
1716
|
return pulumi.get(self, "ebs_optimized")
|
|
1638
1717
|
|
|
1639
1718
|
@ebs_optimized.setter
|
|
1640
|
-
def ebs_optimized(self, value: Optional[pulumi.Input[bool]]):
|
|
1719
|
+
def ebs_optimized(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
1641
1720
|
pulumi.set(self, "ebs_optimized", value)
|
|
1642
1721
|
|
|
1643
|
-
@property
|
|
1722
|
+
@_builtins.property
|
|
1644
1723
|
@pulumi.getter(name="elasticIps")
|
|
1645
|
-
def elastic_ips(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
|
|
1724
|
+
def elastic_ips(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
|
|
1646
1725
|
"""
|
|
1647
1726
|
A list of [AWS Elastic IP](http://docs.aws.amazon.com/AWSEC2/latest/UserGuide/elastic-ip-addresses-eip.html) allocation IDs to associate to the group instances.
|
|
1648
1727
|
"""
|
|
1649
1728
|
return pulumi.get(self, "elastic_ips")
|
|
1650
1729
|
|
|
1651
1730
|
@elastic_ips.setter
|
|
1652
|
-
def elastic_ips(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
|
|
1731
|
+
def elastic_ips(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]):
|
|
1653
1732
|
pulumi.set(self, "elastic_ips", value)
|
|
1654
1733
|
|
|
1655
|
-
@property
|
|
1734
|
+
@_builtins.property
|
|
1656
1735
|
@pulumi.getter(name="elasticLoadBalancers")
|
|
1657
|
-
def elastic_load_balancers(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
|
|
1736
|
+
def elastic_load_balancers(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
|
|
1658
1737
|
return pulumi.get(self, "elastic_load_balancers")
|
|
1659
1738
|
|
|
1660
1739
|
@elastic_load_balancers.setter
|
|
1661
|
-
def elastic_load_balancers(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
|
|
1740
|
+
def elastic_load_balancers(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]):
|
|
1662
1741
|
pulumi.set(self, "elastic_load_balancers", value)
|
|
1663
1742
|
|
|
1664
|
-
@property
|
|
1743
|
+
@_builtins.property
|
|
1665
1744
|
@pulumi.getter(name="enableMonitoring")
|
|
1666
|
-
def enable_monitoring(self) -> Optional[pulumi.Input[bool]]:
|
|
1745
|
+
def enable_monitoring(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
1667
1746
|
"""
|
|
1668
1747
|
Indicates whether monitoring is enabled for the instance.
|
|
1669
1748
|
"""
|
|
1670
1749
|
return pulumi.get(self, "enable_monitoring")
|
|
1671
1750
|
|
|
1672
1751
|
@enable_monitoring.setter
|
|
1673
|
-
def enable_monitoring(self, value: Optional[pulumi.Input[bool]]):
|
|
1752
|
+
def enable_monitoring(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
1674
1753
|
pulumi.set(self, "enable_monitoring", value)
|
|
1675
1754
|
|
|
1676
|
-
@property
|
|
1755
|
+
@_builtins.property
|
|
1677
1756
|
@pulumi.getter(name="ephemeralBlockDevices")
|
|
1678
1757
|
def ephemeral_block_devices(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupEphemeralBlockDeviceArgs']]]]:
|
|
1679
1758
|
return pulumi.get(self, "ephemeral_block_devices")
|
|
@@ -1682,79 +1761,79 @@ class _ElastigroupState:
|
|
|
1682
1761
|
def ephemeral_block_devices(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupEphemeralBlockDeviceArgs']]]]):
|
|
1683
1762
|
pulumi.set(self, "ephemeral_block_devices", value)
|
|
1684
1763
|
|
|
1685
|
-
@property
|
|
1764
|
+
@_builtins.property
|
|
1686
1765
|
@pulumi.getter(name="fallbackToOndemand")
|
|
1687
|
-
def fallback_to_ondemand(self) -> Optional[pulumi.Input[bool]]:
|
|
1766
|
+
def fallback_to_ondemand(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
1688
1767
|
"""
|
|
1689
1768
|
In a case of no Spot instances available, Elastigroup will launch on-demand instances instead.
|
|
1690
1769
|
"""
|
|
1691
1770
|
return pulumi.get(self, "fallback_to_ondemand")
|
|
1692
1771
|
|
|
1693
1772
|
@fallback_to_ondemand.setter
|
|
1694
|
-
def fallback_to_ondemand(self, value: Optional[pulumi.Input[bool]]):
|
|
1773
|
+
def fallback_to_ondemand(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
1695
1774
|
pulumi.set(self, "fallback_to_ondemand", value)
|
|
1696
1775
|
|
|
1697
|
-
@property
|
|
1776
|
+
@_builtins.property
|
|
1698
1777
|
@pulumi.getter(name="healthCheckGracePeriod")
|
|
1699
|
-
def health_check_grace_period(self) -> Optional[pulumi.Input[int]]:
|
|
1778
|
+
def health_check_grace_period(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
1700
1779
|
"""
|
|
1701
1780
|
The amount of time, in seconds, after the instance has launched to starts and check its health.
|
|
1702
1781
|
"""
|
|
1703
1782
|
return pulumi.get(self, "health_check_grace_period")
|
|
1704
1783
|
|
|
1705
1784
|
@health_check_grace_period.setter
|
|
1706
|
-
def health_check_grace_period(self, value: Optional[pulumi.Input[int]]):
|
|
1785
|
+
def health_check_grace_period(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
1707
1786
|
pulumi.set(self, "health_check_grace_period", value)
|
|
1708
1787
|
|
|
1709
|
-
@property
|
|
1788
|
+
@_builtins.property
|
|
1710
1789
|
@pulumi.getter(name="healthCheckType")
|
|
1711
|
-
def health_check_type(self) -> Optional[pulumi.Input[str]]:
|
|
1790
|
+
def health_check_type(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
1712
1791
|
"""
|
|
1713
1792
|
The service that will perform health checks for the instance. Valid values: `"ELB"`, `"HCS"`, `"TARGET_GROUP"`, `"EC2"`, `"K8S_NODE"`, `"NOMAD_NODE"`, `"ECS_CLUSTER_INSTANCE"`.
|
|
1714
1793
|
"""
|
|
1715
1794
|
return pulumi.get(self, "health_check_type")
|
|
1716
1795
|
|
|
1717
1796
|
@health_check_type.setter
|
|
1718
|
-
def health_check_type(self, value: Optional[pulumi.Input[str]]):
|
|
1797
|
+
def health_check_type(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
1719
1798
|
pulumi.set(self, "health_check_type", value)
|
|
1720
1799
|
|
|
1721
|
-
@property
|
|
1800
|
+
@_builtins.property
|
|
1722
1801
|
@pulumi.getter(name="healthCheckUnhealthyDurationBeforeReplacement")
|
|
1723
|
-
def health_check_unhealthy_duration_before_replacement(self) -> Optional[pulumi.Input[int]]:
|
|
1802
|
+
def health_check_unhealthy_duration_before_replacement(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
1724
1803
|
"""
|
|
1725
1804
|
The amount of time, in seconds, that we will wait before replacing an instance that is running and became unhealthy (this is only applicable for instances that were once healthy).
|
|
1726
1805
|
"""
|
|
1727
1806
|
return pulumi.get(self, "health_check_unhealthy_duration_before_replacement")
|
|
1728
1807
|
|
|
1729
1808
|
@health_check_unhealthy_duration_before_replacement.setter
|
|
1730
|
-
def health_check_unhealthy_duration_before_replacement(self, value: Optional[pulumi.Input[int]]):
|
|
1809
|
+
def health_check_unhealthy_duration_before_replacement(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
1731
1810
|
pulumi.set(self, "health_check_unhealthy_duration_before_replacement", value)
|
|
1732
1811
|
|
|
1733
|
-
@property
|
|
1812
|
+
@_builtins.property
|
|
1734
1813
|
@pulumi.getter(name="iamInstanceProfile")
|
|
1735
|
-
def iam_instance_profile(self) -> Optional[pulumi.Input[str]]:
|
|
1814
|
+
def iam_instance_profile(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
1736
1815
|
"""
|
|
1737
1816
|
The ARN or name of an IAM instance profile to associate with launched instances.
|
|
1738
1817
|
"""
|
|
1739
1818
|
return pulumi.get(self, "iam_instance_profile")
|
|
1740
1819
|
|
|
1741
1820
|
@iam_instance_profile.setter
|
|
1742
|
-
def iam_instance_profile(self, value: Optional[pulumi.Input[str]]):
|
|
1821
|
+
def iam_instance_profile(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
1743
1822
|
pulumi.set(self, "iam_instance_profile", value)
|
|
1744
1823
|
|
|
1745
|
-
@property
|
|
1824
|
+
@_builtins.property
|
|
1746
1825
|
@pulumi.getter(name="imageId")
|
|
1747
|
-
def image_id(self) -> Optional[pulumi.Input[str]]:
|
|
1826
|
+
def image_id(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
1748
1827
|
"""
|
|
1749
1828
|
The ID of the AMI used to launch the instance.
|
|
1750
1829
|
"""
|
|
1751
1830
|
return pulumi.get(self, "image_id")
|
|
1752
1831
|
|
|
1753
1832
|
@image_id.setter
|
|
1754
|
-
def image_id(self, value: Optional[pulumi.Input[str]]):
|
|
1833
|
+
def image_id(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
1755
1834
|
pulumi.set(self, "image_id", value)
|
|
1756
1835
|
|
|
1757
|
-
@property
|
|
1836
|
+
@_builtins.property
|
|
1758
1837
|
@pulumi.getter
|
|
1759
1838
|
def images(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupImageArgs']]]]:
|
|
1760
1839
|
"""
|
|
@@ -1767,52 +1846,52 @@ class _ElastigroupState:
|
|
|
1767
1846
|
def images(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupImageArgs']]]]):
|
|
1768
1847
|
pulumi.set(self, "images", value)
|
|
1769
1848
|
|
|
1770
|
-
@property
|
|
1849
|
+
@_builtins.property
|
|
1771
1850
|
@pulumi.getter(name="immediateOdRecoverThreshold")
|
|
1772
|
-
def immediate_od_recover_threshold(self) -> Optional[pulumi.Input[int]]:
|
|
1851
|
+
def immediate_od_recover_threshold(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
1773
1852
|
return pulumi.get(self, "immediate_od_recover_threshold")
|
|
1774
1853
|
|
|
1775
1854
|
@immediate_od_recover_threshold.setter
|
|
1776
|
-
def immediate_od_recover_threshold(self, value: Optional[pulumi.Input[int]]):
|
|
1855
|
+
def immediate_od_recover_threshold(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
1777
1856
|
pulumi.set(self, "immediate_od_recover_threshold", value)
|
|
1778
1857
|
|
|
1779
|
-
@property
|
|
1858
|
+
@_builtins.property
|
|
1780
1859
|
@pulumi.getter(name="instanceTypesOndemand")
|
|
1781
|
-
def instance_types_ondemand(self) -> Optional[pulumi.Input[str]]:
|
|
1860
|
+
def instance_types_ondemand(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
1782
1861
|
"""
|
|
1783
1862
|
The type of instance determines your instance's CPU capacity, memory and storage (e.g., m1.small, c1.xlarge).
|
|
1784
1863
|
"""
|
|
1785
1864
|
return pulumi.get(self, "instance_types_ondemand")
|
|
1786
1865
|
|
|
1787
1866
|
@instance_types_ondemand.setter
|
|
1788
|
-
def instance_types_ondemand(self, value: Optional[pulumi.Input[str]]):
|
|
1867
|
+
def instance_types_ondemand(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
1789
1868
|
pulumi.set(self, "instance_types_ondemand", value)
|
|
1790
1869
|
|
|
1791
|
-
@property
|
|
1870
|
+
@_builtins.property
|
|
1792
1871
|
@pulumi.getter(name="instanceTypesPreferredSpots")
|
|
1793
|
-
def instance_types_preferred_spots(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
|
|
1872
|
+
def instance_types_preferred_spots(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
|
|
1794
1873
|
"""
|
|
1795
1874
|
Prioritize a subset of spot instance types. Must be a subset of the selected spot instance types.
|
|
1796
1875
|
"""
|
|
1797
1876
|
return pulumi.get(self, "instance_types_preferred_spots")
|
|
1798
1877
|
|
|
1799
1878
|
@instance_types_preferred_spots.setter
|
|
1800
|
-
def instance_types_preferred_spots(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
|
|
1879
|
+
def instance_types_preferred_spots(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]):
|
|
1801
1880
|
pulumi.set(self, "instance_types_preferred_spots", value)
|
|
1802
1881
|
|
|
1803
|
-
@property
|
|
1882
|
+
@_builtins.property
|
|
1804
1883
|
@pulumi.getter(name="instanceTypesSpots")
|
|
1805
|
-
def instance_types_spots(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
|
|
1884
|
+
def instance_types_spots(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
|
|
1806
1885
|
"""
|
|
1807
1886
|
One or more instance types. Note: Cannot be defined if 'resourceRequirements' is defined.
|
|
1808
1887
|
"""
|
|
1809
1888
|
return pulumi.get(self, "instance_types_spots")
|
|
1810
1889
|
|
|
1811
1890
|
@instance_types_spots.setter
|
|
1812
|
-
def instance_types_spots(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
|
|
1891
|
+
def instance_types_spots(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]):
|
|
1813
1892
|
pulumi.set(self, "instance_types_spots", value)
|
|
1814
1893
|
|
|
1815
|
-
@property
|
|
1894
|
+
@_builtins.property
|
|
1816
1895
|
@pulumi.getter(name="instanceTypesWeights")
|
|
1817
1896
|
def instance_types_weights(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupInstanceTypesWeightArgs']]]]:
|
|
1818
1897
|
"""
|
|
@@ -1824,7 +1903,7 @@ class _ElastigroupState:
|
|
|
1824
1903
|
def instance_types_weights(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupInstanceTypesWeightArgs']]]]):
|
|
1825
1904
|
pulumi.set(self, "instance_types_weights", value)
|
|
1826
1905
|
|
|
1827
|
-
@property
|
|
1906
|
+
@_builtins.property
|
|
1828
1907
|
@pulumi.getter(name="integrationBeanstalk")
|
|
1829
1908
|
def integration_beanstalk(self) -> Optional[pulumi.Input['ElastigroupIntegrationBeanstalkArgs']]:
|
|
1830
1909
|
return pulumi.get(self, "integration_beanstalk")
|
|
@@ -1833,7 +1912,7 @@ class _ElastigroupState:
|
|
|
1833
1912
|
def integration_beanstalk(self, value: Optional[pulumi.Input['ElastigroupIntegrationBeanstalkArgs']]):
|
|
1834
1913
|
pulumi.set(self, "integration_beanstalk", value)
|
|
1835
1914
|
|
|
1836
|
-
@property
|
|
1915
|
+
@_builtins.property
|
|
1837
1916
|
@pulumi.getter(name="integrationCodedeploy")
|
|
1838
1917
|
def integration_codedeploy(self) -> Optional[pulumi.Input['ElastigroupIntegrationCodedeployArgs']]:
|
|
1839
1918
|
return pulumi.get(self, "integration_codedeploy")
|
|
@@ -1842,7 +1921,7 @@ class _ElastigroupState:
|
|
|
1842
1921
|
def integration_codedeploy(self, value: Optional[pulumi.Input['ElastigroupIntegrationCodedeployArgs']]):
|
|
1843
1922
|
pulumi.set(self, "integration_codedeploy", value)
|
|
1844
1923
|
|
|
1845
|
-
@property
|
|
1924
|
+
@_builtins.property
|
|
1846
1925
|
@pulumi.getter(name="integrationDockerSwarm")
|
|
1847
1926
|
def integration_docker_swarm(self) -> Optional[pulumi.Input['ElastigroupIntegrationDockerSwarmArgs']]:
|
|
1848
1927
|
return pulumi.get(self, "integration_docker_swarm")
|
|
@@ -1851,7 +1930,7 @@ class _ElastigroupState:
|
|
|
1851
1930
|
def integration_docker_swarm(self, value: Optional[pulumi.Input['ElastigroupIntegrationDockerSwarmArgs']]):
|
|
1852
1931
|
pulumi.set(self, "integration_docker_swarm", value)
|
|
1853
1932
|
|
|
1854
|
-
@property
|
|
1933
|
+
@_builtins.property
|
|
1855
1934
|
@pulumi.getter(name="integrationEcs")
|
|
1856
1935
|
def integration_ecs(self) -> Optional[pulumi.Input['ElastigroupIntegrationEcsArgs']]:
|
|
1857
1936
|
return pulumi.get(self, "integration_ecs")
|
|
@@ -1860,7 +1939,7 @@ class _ElastigroupState:
|
|
|
1860
1939
|
def integration_ecs(self, value: Optional[pulumi.Input['ElastigroupIntegrationEcsArgs']]):
|
|
1861
1940
|
pulumi.set(self, "integration_ecs", value)
|
|
1862
1941
|
|
|
1863
|
-
@property
|
|
1942
|
+
@_builtins.property
|
|
1864
1943
|
@pulumi.getter(name="integrationGitlab")
|
|
1865
1944
|
def integration_gitlab(self) -> Optional[pulumi.Input['ElastigroupIntegrationGitlabArgs']]:
|
|
1866
1945
|
return pulumi.get(self, "integration_gitlab")
|
|
@@ -1869,7 +1948,7 @@ class _ElastigroupState:
|
|
|
1869
1948
|
def integration_gitlab(self, value: Optional[pulumi.Input['ElastigroupIntegrationGitlabArgs']]):
|
|
1870
1949
|
pulumi.set(self, "integration_gitlab", value)
|
|
1871
1950
|
|
|
1872
|
-
@property
|
|
1951
|
+
@_builtins.property
|
|
1873
1952
|
@pulumi.getter(name="integrationKubernetes")
|
|
1874
1953
|
def integration_kubernetes(self) -> Optional[pulumi.Input['ElastigroupIntegrationKubernetesArgs']]:
|
|
1875
1954
|
return pulumi.get(self, "integration_kubernetes")
|
|
@@ -1878,7 +1957,7 @@ class _ElastigroupState:
|
|
|
1878
1957
|
def integration_kubernetes(self, value: Optional[pulumi.Input['ElastigroupIntegrationKubernetesArgs']]):
|
|
1879
1958
|
pulumi.set(self, "integration_kubernetes", value)
|
|
1880
1959
|
|
|
1881
|
-
@property
|
|
1960
|
+
@_builtins.property
|
|
1882
1961
|
@pulumi.getter(name="integrationMesosphere")
|
|
1883
1962
|
def integration_mesosphere(self) -> Optional[pulumi.Input['ElastigroupIntegrationMesosphereArgs']]:
|
|
1884
1963
|
return pulumi.get(self, "integration_mesosphere")
|
|
@@ -1887,7 +1966,7 @@ class _ElastigroupState:
|
|
|
1887
1966
|
def integration_mesosphere(self, value: Optional[pulumi.Input['ElastigroupIntegrationMesosphereArgs']]):
|
|
1888
1967
|
pulumi.set(self, "integration_mesosphere", value)
|
|
1889
1968
|
|
|
1890
|
-
@property
|
|
1969
|
+
@_builtins.property
|
|
1891
1970
|
@pulumi.getter(name="integrationNomad")
|
|
1892
1971
|
def integration_nomad(self) -> Optional[pulumi.Input['ElastigroupIntegrationNomadArgs']]:
|
|
1893
1972
|
return pulumi.get(self, "integration_nomad")
|
|
@@ -1896,7 +1975,7 @@ class _ElastigroupState:
|
|
|
1896
1975
|
def integration_nomad(self, value: Optional[pulumi.Input['ElastigroupIntegrationNomadArgs']]):
|
|
1897
1976
|
pulumi.set(self, "integration_nomad", value)
|
|
1898
1977
|
|
|
1899
|
-
@property
|
|
1978
|
+
@_builtins.property
|
|
1900
1979
|
@pulumi.getter(name="integrationRancher")
|
|
1901
1980
|
def integration_rancher(self) -> Optional[pulumi.Input['ElastigroupIntegrationRancherArgs']]:
|
|
1902
1981
|
return pulumi.get(self, "integration_rancher")
|
|
@@ -1905,7 +1984,7 @@ class _ElastigroupState:
|
|
|
1905
1984
|
def integration_rancher(self, value: Optional[pulumi.Input['ElastigroupIntegrationRancherArgs']]):
|
|
1906
1985
|
pulumi.set(self, "integration_rancher", value)
|
|
1907
1986
|
|
|
1908
|
-
@property
|
|
1987
|
+
@_builtins.property
|
|
1909
1988
|
@pulumi.getter(name="integrationRoute53")
|
|
1910
1989
|
def integration_route53(self) -> Optional[pulumi.Input['ElastigroupIntegrationRoute53Args']]:
|
|
1911
1990
|
return pulumi.get(self, "integration_route53")
|
|
@@ -1914,7 +1993,7 @@ class _ElastigroupState:
|
|
|
1914
1993
|
def integration_route53(self, value: Optional[pulumi.Input['ElastigroupIntegrationRoute53Args']]):
|
|
1915
1994
|
pulumi.set(self, "integration_route53", value)
|
|
1916
1995
|
|
|
1917
|
-
@property
|
|
1996
|
+
@_builtins.property
|
|
1918
1997
|
@pulumi.getter
|
|
1919
1998
|
def itfs(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupItfArgs']]]]:
|
|
1920
1999
|
return pulumi.get(self, "itfs")
|
|
@@ -1923,28 +2002,28 @@ class _ElastigroupState:
|
|
|
1923
2002
|
def itfs(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupItfArgs']]]]):
|
|
1924
2003
|
pulumi.set(self, "itfs", value)
|
|
1925
2004
|
|
|
1926
|
-
@property
|
|
2005
|
+
@_builtins.property
|
|
1927
2006
|
@pulumi.getter(name="keyName")
|
|
1928
|
-
def key_name(self) -> Optional[pulumi.Input[str]]:
|
|
2007
|
+
def key_name(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
1929
2008
|
"""
|
|
1930
2009
|
The key name that should be used for the instance.
|
|
1931
2010
|
"""
|
|
1932
2011
|
return pulumi.get(self, "key_name")
|
|
1933
2012
|
|
|
1934
2013
|
@key_name.setter
|
|
1935
|
-
def key_name(self, value: Optional[pulumi.Input[str]]):
|
|
2014
|
+
def key_name(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
1936
2015
|
pulumi.set(self, "key_name", value)
|
|
1937
2016
|
|
|
1938
|
-
@property
|
|
2017
|
+
@_builtins.property
|
|
1939
2018
|
@pulumi.getter(name="lifetimePeriod")
|
|
1940
|
-
def lifetime_period(self) -> Optional[pulumi.Input[str]]:
|
|
2019
|
+
def lifetime_period(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
1941
2020
|
return pulumi.get(self, "lifetime_period")
|
|
1942
2021
|
|
|
1943
2022
|
@lifetime_period.setter
|
|
1944
|
-
def lifetime_period(self, value: Optional[pulumi.Input[str]]):
|
|
2023
|
+
def lifetime_period(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
1945
2024
|
pulumi.set(self, "lifetime_period", value)
|
|
1946
2025
|
|
|
1947
|
-
@property
|
|
2026
|
+
@_builtins.property
|
|
1948
2027
|
@pulumi.getter
|
|
1949
2028
|
def logging(self) -> Optional[pulumi.Input['ElastigroupLoggingArgs']]:
|
|
1950
2029
|
"""
|
|
@@ -1956,19 +2035,28 @@ class _ElastigroupState:
|
|
|
1956
2035
|
def logging(self, value: Optional[pulumi.Input['ElastigroupLoggingArgs']]):
|
|
1957
2036
|
pulumi.set(self, "logging", value)
|
|
1958
2037
|
|
|
1959
|
-
@property
|
|
2038
|
+
@_builtins.property
|
|
2039
|
+
@pulumi.getter(name="maxReplacementsPercentage")
|
|
2040
|
+
def max_replacements_percentage(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
2041
|
+
return pulumi.get(self, "max_replacements_percentage")
|
|
2042
|
+
|
|
2043
|
+
@max_replacements_percentage.setter
|
|
2044
|
+
def max_replacements_percentage(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
2045
|
+
pulumi.set(self, "max_replacements_percentage", value)
|
|
2046
|
+
|
|
2047
|
+
@_builtins.property
|
|
1960
2048
|
@pulumi.getter(name="maxSize")
|
|
1961
|
-
def max_size(self) -> Optional[pulumi.Input[int]]:
|
|
2049
|
+
def max_size(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
1962
2050
|
"""
|
|
1963
2051
|
The maximum number of instances the group should have at any time.
|
|
1964
2052
|
"""
|
|
1965
2053
|
return pulumi.get(self, "max_size")
|
|
1966
2054
|
|
|
1967
2055
|
@max_size.setter
|
|
1968
|
-
def max_size(self, value: Optional[pulumi.Input[int]]):
|
|
2056
|
+
def max_size(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
1969
2057
|
pulumi.set(self, "max_size", value)
|
|
1970
2058
|
|
|
1971
|
-
@property
|
|
2059
|
+
@_builtins.property
|
|
1972
2060
|
@pulumi.getter(name="metadataOptions")
|
|
1973
2061
|
def metadata_options(self) -> Optional[pulumi.Input['ElastigroupMetadataOptionsArgs']]:
|
|
1974
2062
|
"""
|
|
@@ -1980,31 +2068,31 @@ class _ElastigroupState:
|
|
|
1980
2068
|
def metadata_options(self, value: Optional[pulumi.Input['ElastigroupMetadataOptionsArgs']]):
|
|
1981
2069
|
pulumi.set(self, "metadata_options", value)
|
|
1982
2070
|
|
|
1983
|
-
@property
|
|
2071
|
+
@_builtins.property
|
|
1984
2072
|
@pulumi.getter(name="minSize")
|
|
1985
|
-
def min_size(self) -> Optional[pulumi.Input[int]]:
|
|
2073
|
+
def min_size(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
1986
2074
|
"""
|
|
1987
2075
|
The minimum number of instances the group should have at any time.
|
|
1988
2076
|
"""
|
|
1989
2077
|
return pulumi.get(self, "min_size")
|
|
1990
2078
|
|
|
1991
2079
|
@min_size.setter
|
|
1992
|
-
def min_size(self, value: Optional[pulumi.Input[int]]):
|
|
2080
|
+
def min_size(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
1993
2081
|
pulumi.set(self, "min_size", value)
|
|
1994
2082
|
|
|
1995
|
-
@property
|
|
2083
|
+
@_builtins.property
|
|
1996
2084
|
@pulumi.getter(name="minimumInstanceLifetime")
|
|
1997
|
-
def minimum_instance_lifetime(self) -> Optional[pulumi.Input[int]]:
|
|
2085
|
+
def minimum_instance_lifetime(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
1998
2086
|
"""
|
|
1999
2087
|
Defines the preferred minimum instance lifetime in hours. Markets which comply with this preference will be prioritized. Optional values: 1, 3, 6, 12, 24.
|
|
2000
2088
|
"""
|
|
2001
2089
|
return pulumi.get(self, "minimum_instance_lifetime")
|
|
2002
2090
|
|
|
2003
2091
|
@minimum_instance_lifetime.setter
|
|
2004
|
-
def minimum_instance_lifetime(self, value: Optional[pulumi.Input[int]]):
|
|
2092
|
+
def minimum_instance_lifetime(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
2005
2093
|
pulumi.set(self, "minimum_instance_lifetime", value)
|
|
2006
2094
|
|
|
2007
|
-
@property
|
|
2095
|
+
@_builtins.property
|
|
2008
2096
|
@pulumi.getter(name="multipleMetrics")
|
|
2009
2097
|
def multiple_metrics(self) -> Optional[pulumi.Input['ElastigroupMultipleMetricsArgs']]:
|
|
2010
2098
|
return pulumi.get(self, "multiple_metrics")
|
|
@@ -2013,19 +2101,19 @@ class _ElastigroupState:
|
|
|
2013
2101
|
def multiple_metrics(self, value: Optional[pulumi.Input['ElastigroupMultipleMetricsArgs']]):
|
|
2014
2102
|
pulumi.set(self, "multiple_metrics", value)
|
|
2015
2103
|
|
|
2016
|
-
@property
|
|
2104
|
+
@_builtins.property
|
|
2017
2105
|
@pulumi.getter
|
|
2018
|
-
def name(self) -> Optional[pulumi.Input[str]]:
|
|
2106
|
+
def name(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
2019
2107
|
"""
|
|
2020
2108
|
The group name.
|
|
2021
2109
|
"""
|
|
2022
2110
|
return pulumi.get(self, "name")
|
|
2023
2111
|
|
|
2024
2112
|
@name.setter
|
|
2025
|
-
def name(self, value: Optional[pulumi.Input[str]]):
|
|
2113
|
+
def name(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
2026
2114
|
pulumi.set(self, "name", value)
|
|
2027
2115
|
|
|
2028
|
-
@property
|
|
2116
|
+
@_builtins.property
|
|
2029
2117
|
@pulumi.getter(name="networkInterfaces")
|
|
2030
2118
|
def network_interfaces(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupNetworkInterfaceArgs']]]]:
|
|
2031
2119
|
return pulumi.get(self, "network_interfaces")
|
|
@@ -2034,84 +2122,84 @@ class _ElastigroupState:
|
|
|
2034
2122
|
def network_interfaces(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupNetworkInterfaceArgs']]]]):
|
|
2035
2123
|
pulumi.set(self, "network_interfaces", value)
|
|
2036
2124
|
|
|
2037
|
-
@property
|
|
2125
|
+
@_builtins.property
|
|
2038
2126
|
@pulumi.getter(name="onDemandTypes")
|
|
2039
|
-
def on_demand_types(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
|
|
2127
|
+
def on_demand_types(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
|
|
2040
2128
|
"""
|
|
2041
2129
|
Available ondemand instance types. Note: Either ondemand or onDemandTypes must be defined, but not both.
|
|
2042
2130
|
"""
|
|
2043
2131
|
return pulumi.get(self, "on_demand_types")
|
|
2044
2132
|
|
|
2045
2133
|
@on_demand_types.setter
|
|
2046
|
-
def on_demand_types(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
|
|
2134
|
+
def on_demand_types(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]):
|
|
2047
2135
|
pulumi.set(self, "on_demand_types", value)
|
|
2048
2136
|
|
|
2049
|
-
@property
|
|
2137
|
+
@_builtins.property
|
|
2050
2138
|
@pulumi.getter(name="ondemandCount")
|
|
2051
|
-
def ondemand_count(self) -> Optional[pulumi.Input[int]]:
|
|
2139
|
+
def ondemand_count(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
2052
2140
|
"""
|
|
2053
2141
|
Number of on demand instances to launch in the group. All other instances will be spot instances. When this parameter is set the `spot_percentage` parameter is being ignored.
|
|
2054
2142
|
"""
|
|
2055
2143
|
return pulumi.get(self, "ondemand_count")
|
|
2056
2144
|
|
|
2057
2145
|
@ondemand_count.setter
|
|
2058
|
-
def ondemand_count(self, value: Optional[pulumi.Input[int]]):
|
|
2146
|
+
def ondemand_count(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
2059
2147
|
pulumi.set(self, "ondemand_count", value)
|
|
2060
2148
|
|
|
2061
|
-
@property
|
|
2149
|
+
@_builtins.property
|
|
2062
2150
|
@pulumi.getter
|
|
2063
|
-
def orientation(self) -> Optional[pulumi.Input[str]]:
|
|
2151
|
+
def orientation(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
2064
2152
|
"""
|
|
2065
2153
|
Select a prediction strategy. Valid values: `balanced`, `costOriented`, `equalAzDistribution`, `availabilityOriented`. You can read more in our documentation.
|
|
2066
2154
|
"""
|
|
2067
2155
|
return pulumi.get(self, "orientation")
|
|
2068
2156
|
|
|
2069
2157
|
@orientation.setter
|
|
2070
|
-
def orientation(self, value: Optional[pulumi.Input[str]]):
|
|
2158
|
+
def orientation(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
2071
2159
|
pulumi.set(self, "orientation", value)
|
|
2072
2160
|
|
|
2073
|
-
@property
|
|
2161
|
+
@_builtins.property
|
|
2074
2162
|
@pulumi.getter(name="persistBlockDevices")
|
|
2075
|
-
def persist_block_devices(self) -> Optional[pulumi.Input[bool]]:
|
|
2163
|
+
def persist_block_devices(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
2076
2164
|
return pulumi.get(self, "persist_block_devices")
|
|
2077
2165
|
|
|
2078
2166
|
@persist_block_devices.setter
|
|
2079
|
-
def persist_block_devices(self, value: Optional[pulumi.Input[bool]]):
|
|
2167
|
+
def persist_block_devices(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
2080
2168
|
pulumi.set(self, "persist_block_devices", value)
|
|
2081
2169
|
|
|
2082
|
-
@property
|
|
2170
|
+
@_builtins.property
|
|
2083
2171
|
@pulumi.getter(name="persistPrivateIp")
|
|
2084
|
-
def persist_private_ip(self) -> Optional[pulumi.Input[bool]]:
|
|
2172
|
+
def persist_private_ip(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
2085
2173
|
return pulumi.get(self, "persist_private_ip")
|
|
2086
2174
|
|
|
2087
2175
|
@persist_private_ip.setter
|
|
2088
|
-
def persist_private_ip(self, value: Optional[pulumi.Input[bool]]):
|
|
2176
|
+
def persist_private_ip(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
2089
2177
|
pulumi.set(self, "persist_private_ip", value)
|
|
2090
2178
|
|
|
2091
|
-
@property
|
|
2179
|
+
@_builtins.property
|
|
2092
2180
|
@pulumi.getter(name="persistRootDevice")
|
|
2093
|
-
def persist_root_device(self) -> Optional[pulumi.Input[bool]]:
|
|
2181
|
+
def persist_root_device(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
2094
2182
|
return pulumi.get(self, "persist_root_device")
|
|
2095
2183
|
|
|
2096
2184
|
@persist_root_device.setter
|
|
2097
|
-
def persist_root_device(self, value: Optional[pulumi.Input[bool]]):
|
|
2185
|
+
def persist_root_device(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
2098
2186
|
pulumi.set(self, "persist_root_device", value)
|
|
2099
2187
|
|
|
2100
|
-
@property
|
|
2188
|
+
@_builtins.property
|
|
2101
2189
|
@pulumi.getter(name="placementTenancy")
|
|
2102
|
-
def placement_tenancy(self) -> Optional[pulumi.Input[str]]:
|
|
2190
|
+
def placement_tenancy(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
2103
2191
|
"""
|
|
2104
2192
|
Enable dedicated tenancy. Note: There is a flat hourly fee for each region in which dedicated tenancy is used. Valid values: "default", "dedicated" .
|
|
2105
2193
|
"""
|
|
2106
2194
|
return pulumi.get(self, "placement_tenancy")
|
|
2107
2195
|
|
|
2108
2196
|
@placement_tenancy.setter
|
|
2109
|
-
def placement_tenancy(self, value: Optional[pulumi.Input[str]]):
|
|
2197
|
+
def placement_tenancy(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
2110
2198
|
pulumi.set(self, "placement_tenancy", value)
|
|
2111
2199
|
|
|
2112
|
-
@property
|
|
2200
|
+
@_builtins.property
|
|
2113
2201
|
@pulumi.getter(name="preferredAvailabilityZones")
|
|
2114
|
-
def preferred_availability_zones(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
|
|
2202
|
+
def preferred_availability_zones(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
|
|
2115
2203
|
"""
|
|
2116
2204
|
The AZs to prioritize when launching Spot instances. If no markets are available in the Preferred AZs, Spot instances are launched in the non-preferred AZs.
|
|
2117
2205
|
Note: Must be a sublist of `availability_zones` and `orientation` value must not be `"equalAzDistribution"`.
|
|
@@ -2119,34 +2207,34 @@ class _ElastigroupState:
|
|
|
2119
2207
|
return pulumi.get(self, "preferred_availability_zones")
|
|
2120
2208
|
|
|
2121
2209
|
@preferred_availability_zones.setter
|
|
2122
|
-
def preferred_availability_zones(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
|
|
2210
|
+
def preferred_availability_zones(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]):
|
|
2123
2211
|
pulumi.set(self, "preferred_availability_zones", value)
|
|
2124
2212
|
|
|
2125
|
-
@property
|
|
2213
|
+
@_builtins.property
|
|
2126
2214
|
@pulumi.getter(name="privateIps")
|
|
2127
|
-
def private_ips(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
|
|
2215
|
+
def private_ips(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
|
|
2128
2216
|
return pulumi.get(self, "private_ips")
|
|
2129
2217
|
|
|
2130
2218
|
@private_ips.setter
|
|
2131
|
-
def private_ips(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
|
|
2219
|
+
def private_ips(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]):
|
|
2132
2220
|
pulumi.set(self, "private_ips", value)
|
|
2133
2221
|
|
|
2134
|
-
@property
|
|
2222
|
+
@_builtins.property
|
|
2135
2223
|
@pulumi.getter
|
|
2136
|
-
def product(self) -> Optional[pulumi.Input[str]]:
|
|
2224
|
+
def product(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
2137
2225
|
"""
|
|
2138
2226
|
Operation system type. Valid values: `"Linux/UNIX"`, `"SUSE Linux"`, `"Windows"`.
|
|
2139
|
-
For EC2 Classic instances:
|
|
2227
|
+
For EC2 Classic instances: `"SUSE Linux (Amazon VPC)"`, `"Windows (Amazon VPC)"`.
|
|
2140
2228
|
"""
|
|
2141
2229
|
return pulumi.get(self, "product")
|
|
2142
2230
|
|
|
2143
2231
|
@product.setter
|
|
2144
|
-
def product(self, value: Optional[pulumi.Input[str]]):
|
|
2232
|
+
def product(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
2145
2233
|
pulumi.set(self, "product", value)
|
|
2146
2234
|
|
|
2147
|
-
@property
|
|
2235
|
+
@_builtins.property
|
|
2148
2236
|
@pulumi.getter
|
|
2149
|
-
def region(self) -> Optional[pulumi.Input[str]]:
|
|
2237
|
+
def region(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
2150
2238
|
"""
|
|
2151
2239
|
The AWS region your group will be created in.
|
|
2152
2240
|
Note: This parameter is required if you specify subnets (through subnet_ids). This parameter is optional if you specify Availability Zones (through availability_zones).
|
|
@@ -2154,10 +2242,10 @@ class _ElastigroupState:
|
|
|
2154
2242
|
return pulumi.get(self, "region")
|
|
2155
2243
|
|
|
2156
2244
|
@region.setter
|
|
2157
|
-
def region(self, value: Optional[pulumi.Input[str]]):
|
|
2245
|
+
def region(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
2158
2246
|
pulumi.set(self, "region", value)
|
|
2159
2247
|
|
|
2160
|
-
@property
|
|
2248
|
+
@_builtins.property
|
|
2161
2249
|
@pulumi.getter(name="resourceRequirements")
|
|
2162
2250
|
def resource_requirements(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupResourceRequirementArgs']]]]:
|
|
2163
2251
|
"""
|
|
@@ -2169,7 +2257,7 @@ class _ElastigroupState:
|
|
|
2169
2257
|
def resource_requirements(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupResourceRequirementArgs']]]]):
|
|
2170
2258
|
pulumi.set(self, "resource_requirements", value)
|
|
2171
2259
|
|
|
2172
|
-
@property
|
|
2260
|
+
@_builtins.property
|
|
2173
2261
|
@pulumi.getter(name="resourceTagSpecifications")
|
|
2174
2262
|
def resource_tag_specifications(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupResourceTagSpecificationArgs']]]]:
|
|
2175
2263
|
"""
|
|
@@ -2181,7 +2269,19 @@ class _ElastigroupState:
|
|
|
2181
2269
|
def resource_tag_specifications(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupResourceTagSpecificationArgs']]]]):
|
|
2182
2270
|
pulumi.set(self, "resource_tag_specifications", value)
|
|
2183
2271
|
|
|
2184
|
-
@property
|
|
2272
|
+
@_builtins.property
|
|
2273
|
+
@pulumi.getter(name="restrictSingleAz")
|
|
2274
|
+
def restrict_single_az(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
2275
|
+
"""
|
|
2276
|
+
Elastigroup will automatically scale your instances in the most available and cost efficient availability zone. Every evaluation will be done when there are no active instances in the group.
|
|
2277
|
+
"""
|
|
2278
|
+
return pulumi.get(self, "restrict_single_az")
|
|
2279
|
+
|
|
2280
|
+
@restrict_single_az.setter
|
|
2281
|
+
def restrict_single_az(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
2282
|
+
pulumi.set(self, "restrict_single_az", value)
|
|
2283
|
+
|
|
2284
|
+
@_builtins.property
|
|
2185
2285
|
@pulumi.getter(name="revertToSpot")
|
|
2186
2286
|
def revert_to_spot(self) -> Optional[pulumi.Input['ElastigroupRevertToSpotArgs']]:
|
|
2187
2287
|
"""
|
|
@@ -2193,7 +2293,7 @@ class _ElastigroupState:
|
|
|
2193
2293
|
def revert_to_spot(self, value: Optional[pulumi.Input['ElastigroupRevertToSpotArgs']]):
|
|
2194
2294
|
pulumi.set(self, "revert_to_spot", value)
|
|
2195
2295
|
|
|
2196
|
-
@property
|
|
2296
|
+
@_builtins.property
|
|
2197
2297
|
@pulumi.getter(name="scalingDownPolicies")
|
|
2198
2298
|
def scaling_down_policies(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupScalingDownPolicyArgs']]]]:
|
|
2199
2299
|
return pulumi.get(self, "scaling_down_policies")
|
|
@@ -2202,7 +2302,7 @@ class _ElastigroupState:
|
|
|
2202
2302
|
def scaling_down_policies(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupScalingDownPolicyArgs']]]]):
|
|
2203
2303
|
pulumi.set(self, "scaling_down_policies", value)
|
|
2204
2304
|
|
|
2205
|
-
@property
|
|
2305
|
+
@_builtins.property
|
|
2206
2306
|
@pulumi.getter(name="scalingStrategies")
|
|
2207
2307
|
def scaling_strategies(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupScalingStrategyArgs']]]]:
|
|
2208
2308
|
"""
|
|
@@ -2214,7 +2314,7 @@ class _ElastigroupState:
|
|
|
2214
2314
|
def scaling_strategies(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupScalingStrategyArgs']]]]):
|
|
2215
2315
|
pulumi.set(self, "scaling_strategies", value)
|
|
2216
2316
|
|
|
2217
|
-
@property
|
|
2317
|
+
@_builtins.property
|
|
2218
2318
|
@pulumi.getter(name="scalingTargetPolicies")
|
|
2219
2319
|
def scaling_target_policies(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupScalingTargetPolicyArgs']]]]:
|
|
2220
2320
|
return pulumi.get(self, "scaling_target_policies")
|
|
@@ -2223,7 +2323,7 @@ class _ElastigroupState:
|
|
|
2223
2323
|
def scaling_target_policies(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupScalingTargetPolicyArgs']]]]):
|
|
2224
2324
|
pulumi.set(self, "scaling_target_policies", value)
|
|
2225
2325
|
|
|
2226
|
-
@property
|
|
2326
|
+
@_builtins.property
|
|
2227
2327
|
@pulumi.getter(name="scalingUpPolicies")
|
|
2228
2328
|
def scaling_up_policies(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupScalingUpPolicyArgs']]]]:
|
|
2229
2329
|
return pulumi.get(self, "scaling_up_policies")
|
|
@@ -2232,7 +2332,7 @@ class _ElastigroupState:
|
|
|
2232
2332
|
def scaling_up_policies(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupScalingUpPolicyArgs']]]]):
|
|
2233
2333
|
pulumi.set(self, "scaling_up_policies", value)
|
|
2234
2334
|
|
|
2235
|
-
@property
|
|
2335
|
+
@_builtins.property
|
|
2236
2336
|
@pulumi.getter(name="scheduledTasks")
|
|
2237
2337
|
def scheduled_tasks(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupScheduledTaskArgs']]]]:
|
|
2238
2338
|
return pulumi.get(self, "scheduled_tasks")
|
|
@@ -2241,31 +2341,31 @@ class _ElastigroupState:
|
|
|
2241
2341
|
def scheduled_tasks(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupScheduledTaskArgs']]]]):
|
|
2242
2342
|
pulumi.set(self, "scheduled_tasks", value)
|
|
2243
2343
|
|
|
2244
|
-
@property
|
|
2344
|
+
@_builtins.property
|
|
2245
2345
|
@pulumi.getter(name="securityGroups")
|
|
2246
|
-
def security_groups(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
|
|
2346
|
+
def security_groups(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
|
|
2247
2347
|
"""
|
|
2248
2348
|
A list of associated security group IDS.
|
|
2249
2349
|
"""
|
|
2250
2350
|
return pulumi.get(self, "security_groups")
|
|
2251
2351
|
|
|
2252
2352
|
@security_groups.setter
|
|
2253
|
-
def security_groups(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
|
|
2353
|
+
def security_groups(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]):
|
|
2254
2354
|
pulumi.set(self, "security_groups", value)
|
|
2255
2355
|
|
|
2256
|
-
@property
|
|
2356
|
+
@_builtins.property
|
|
2257
2357
|
@pulumi.getter(name="shutdownScript")
|
|
2258
|
-
def shutdown_script(self) -> Optional[pulumi.Input[str]]:
|
|
2358
|
+
def shutdown_script(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
2259
2359
|
"""
|
|
2260
2360
|
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/)
|
|
2261
2361
|
"""
|
|
2262
2362
|
return pulumi.get(self, "shutdown_script")
|
|
2263
2363
|
|
|
2264
2364
|
@shutdown_script.setter
|
|
2265
|
-
def shutdown_script(self, value: Optional[pulumi.Input[str]]):
|
|
2365
|
+
def shutdown_script(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
2266
2366
|
pulumi.set(self, "shutdown_script", value)
|
|
2267
2367
|
|
|
2268
|
-
@property
|
|
2368
|
+
@_builtins.property
|
|
2269
2369
|
@pulumi.getter
|
|
2270
2370
|
def signals(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupSignalArgs']]]]:
|
|
2271
2371
|
return pulumi.get(self, "signals")
|
|
@@ -2274,19 +2374,19 @@ class _ElastigroupState:
|
|
|
2274
2374
|
def signals(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupSignalArgs']]]]):
|
|
2275
2375
|
pulumi.set(self, "signals", value)
|
|
2276
2376
|
|
|
2277
|
-
@property
|
|
2377
|
+
@_builtins.property
|
|
2278
2378
|
@pulumi.getter(name="spotPercentage")
|
|
2279
|
-
def spot_percentage(self) -> Optional[pulumi.Input[int]]:
|
|
2379
|
+
def spot_percentage(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
2280
2380
|
"""
|
|
2281
2381
|
The percentage of Spot instances that would spin up from the `desired_capacity` number.
|
|
2282
2382
|
"""
|
|
2283
2383
|
return pulumi.get(self, "spot_percentage")
|
|
2284
2384
|
|
|
2285
2385
|
@spot_percentage.setter
|
|
2286
|
-
def spot_percentage(self, value: Optional[pulumi.Input[int]]):
|
|
2386
|
+
def spot_percentage(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
2287
2387
|
pulumi.set(self, "spot_percentage", value)
|
|
2288
2388
|
|
|
2289
|
-
@property
|
|
2389
|
+
@_builtins.property
|
|
2290
2390
|
@pulumi.getter(name="statefulDeallocation")
|
|
2291
2391
|
def stateful_deallocation(self) -> Optional[pulumi.Input['ElastigroupStatefulDeallocationArgs']]:
|
|
2292
2392
|
return pulumi.get(self, "stateful_deallocation")
|
|
@@ -2295,7 +2395,7 @@ class _ElastigroupState:
|
|
|
2295
2395
|
def stateful_deallocation(self, value: Optional[pulumi.Input['ElastigroupStatefulDeallocationArgs']]):
|
|
2296
2396
|
pulumi.set(self, "stateful_deallocation", value)
|
|
2297
2397
|
|
|
2298
|
-
@property
|
|
2398
|
+
@_builtins.property
|
|
2299
2399
|
@pulumi.getter(name="statefulInstanceActions")
|
|
2300
2400
|
def stateful_instance_actions(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupStatefulInstanceActionArgs']]]]:
|
|
2301
2401
|
return pulumi.get(self, "stateful_instance_actions")
|
|
@@ -2304,9 +2404,10 @@ class _ElastigroupState:
|
|
|
2304
2404
|
def stateful_instance_actions(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupStatefulInstanceActionArgs']]]]):
|
|
2305
2405
|
pulumi.set(self, "stateful_instance_actions", value)
|
|
2306
2406
|
|
|
2307
|
-
@property
|
|
2407
|
+
@_builtins.property
|
|
2308
2408
|
@pulumi.getter(name="subnetIds")
|
|
2309
|
-
|
|
2409
|
+
@_utilities.deprecated("""This field will soon be deprecated and handled by availability_zones""")
|
|
2410
|
+
def subnet_ids(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
|
|
2310
2411
|
"""
|
|
2311
2412
|
List of Strings of subnet identifiers.
|
|
2312
2413
|
Note: When this parameter is set, `availability_zones` should be left unused.
|
|
@@ -2314,10 +2415,10 @@ class _ElastigroupState:
|
|
|
2314
2415
|
return pulumi.get(self, "subnet_ids")
|
|
2315
2416
|
|
|
2316
2417
|
@subnet_ids.setter
|
|
2317
|
-
def subnet_ids(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
|
|
2418
|
+
def subnet_ids(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]):
|
|
2318
2419
|
pulumi.set(self, "subnet_ids", value)
|
|
2319
2420
|
|
|
2320
|
-
@property
|
|
2421
|
+
@_builtins.property
|
|
2321
2422
|
@pulumi.getter
|
|
2322
2423
|
def tags(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupTagArgs']]]]:
|
|
2323
2424
|
"""
|
|
@@ -2329,16 +2430,16 @@ class _ElastigroupState:
|
|
|
2329
2430
|
def tags(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupTagArgs']]]]):
|
|
2330
2431
|
pulumi.set(self, "tags", value)
|
|
2331
2432
|
|
|
2332
|
-
@property
|
|
2433
|
+
@_builtins.property
|
|
2333
2434
|
@pulumi.getter(name="targetGroupArns")
|
|
2334
|
-
def target_group_arns(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
|
|
2435
|
+
def target_group_arns(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
|
|
2335
2436
|
return pulumi.get(self, "target_group_arns")
|
|
2336
2437
|
|
|
2337
2438
|
@target_group_arns.setter
|
|
2338
|
-
def target_group_arns(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
|
|
2439
|
+
def target_group_arns(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]):
|
|
2339
2440
|
pulumi.set(self, "target_group_arns", value)
|
|
2340
2441
|
|
|
2341
|
-
@property
|
|
2442
|
+
@_builtins.property
|
|
2342
2443
|
@pulumi.getter(name="updatePolicy")
|
|
2343
2444
|
def update_policy(self) -> Optional[pulumi.Input['ElastigroupUpdatePolicyArgs']]:
|
|
2344
2445
|
return pulumi.get(self, "update_policy")
|
|
@@ -2347,151 +2448,155 @@ class _ElastigroupState:
|
|
|
2347
2448
|
def update_policy(self, value: Optional[pulumi.Input['ElastigroupUpdatePolicyArgs']]):
|
|
2348
2449
|
pulumi.set(self, "update_policy", value)
|
|
2349
2450
|
|
|
2350
|
-
@property
|
|
2451
|
+
@_builtins.property
|
|
2351
2452
|
@pulumi.getter(name="userData")
|
|
2352
|
-
def user_data(self) -> Optional[pulumi.Input[str]]:
|
|
2453
|
+
def user_data(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
2353
2454
|
"""
|
|
2354
2455
|
The user data to provide when launching the instance.
|
|
2355
2456
|
"""
|
|
2356
2457
|
return pulumi.get(self, "user_data")
|
|
2357
2458
|
|
|
2358
2459
|
@user_data.setter
|
|
2359
|
-
def user_data(self, value: Optional[pulumi.Input[str]]):
|
|
2460
|
+
def user_data(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
2360
2461
|
pulumi.set(self, "user_data", value)
|
|
2361
2462
|
|
|
2362
|
-
@property
|
|
2463
|
+
@_builtins.property
|
|
2363
2464
|
@pulumi.getter(name="utilizeCommitments")
|
|
2364
|
-
def utilize_commitments(self) -> Optional[pulumi.Input[bool]]:
|
|
2465
|
+
def utilize_commitments(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
2365
2466
|
return pulumi.get(self, "utilize_commitments")
|
|
2366
2467
|
|
|
2367
2468
|
@utilize_commitments.setter
|
|
2368
|
-
def utilize_commitments(self, value: Optional[pulumi.Input[bool]]):
|
|
2469
|
+
def utilize_commitments(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
2369
2470
|
pulumi.set(self, "utilize_commitments", value)
|
|
2370
2471
|
|
|
2371
|
-
@property
|
|
2472
|
+
@_builtins.property
|
|
2372
2473
|
@pulumi.getter(name="utilizeReservedInstances")
|
|
2373
|
-
def utilize_reserved_instances(self) -> Optional[pulumi.Input[bool]]:
|
|
2474
|
+
def utilize_reserved_instances(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
2374
2475
|
"""
|
|
2375
2476
|
In a case of any available reserved instances, Elastigroup will utilize them first before purchasing Spot instances.
|
|
2376
2477
|
"""
|
|
2377
2478
|
return pulumi.get(self, "utilize_reserved_instances")
|
|
2378
2479
|
|
|
2379
2480
|
@utilize_reserved_instances.setter
|
|
2380
|
-
def utilize_reserved_instances(self, value: Optional[pulumi.Input[bool]]):
|
|
2481
|
+
def utilize_reserved_instances(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
2381
2482
|
pulumi.set(self, "utilize_reserved_instances", value)
|
|
2382
2483
|
|
|
2383
|
-
@property
|
|
2484
|
+
@_builtins.property
|
|
2384
2485
|
@pulumi.getter(name="waitForCapacity")
|
|
2385
|
-
def wait_for_capacity(self) -> Optional[pulumi.Input[int]]:
|
|
2486
|
+
def wait_for_capacity(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
2386
2487
|
"""
|
|
2387
2488
|
Minimum number of instances in a 'HEALTHY' status that is required before continuing. This is ignored when updating with blue/green deployment. Cannot exceed `desired_capacity`.
|
|
2388
2489
|
"""
|
|
2389
2490
|
return pulumi.get(self, "wait_for_capacity")
|
|
2390
2491
|
|
|
2391
2492
|
@wait_for_capacity.setter
|
|
2392
|
-
def wait_for_capacity(self, value: Optional[pulumi.Input[int]]):
|
|
2493
|
+
def wait_for_capacity(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
2393
2494
|
pulumi.set(self, "wait_for_capacity", value)
|
|
2394
2495
|
|
|
2395
|
-
@property
|
|
2496
|
+
@_builtins.property
|
|
2396
2497
|
@pulumi.getter(name="waitForCapacityTimeout")
|
|
2397
|
-
def wait_for_capacity_timeout(self) -> Optional[pulumi.Input[int]]:
|
|
2498
|
+
def wait_for_capacity_timeout(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
2398
2499
|
"""
|
|
2399
2500
|
Time (seconds) to wait for instances to report a 'HEALTHY' status. Useful for plans with multiple dependencies that take some time to initialize. Leave undefined or set to `0` to indicate no wait. This is ignored when updating with blue/green deployment.
|
|
2400
2501
|
"""
|
|
2401
2502
|
return pulumi.get(self, "wait_for_capacity_timeout")
|
|
2402
2503
|
|
|
2403
2504
|
@wait_for_capacity_timeout.setter
|
|
2404
|
-
def wait_for_capacity_timeout(self, value: Optional[pulumi.Input[int]]):
|
|
2505
|
+
def wait_for_capacity_timeout(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
2405
2506
|
pulumi.set(self, "wait_for_capacity_timeout", value)
|
|
2406
2507
|
|
|
2407
2508
|
|
|
2509
|
+
@pulumi.type_token("spotinst:aws/elastigroup:Elastigroup")
|
|
2408
2510
|
class Elastigroup(pulumi.CustomResource):
|
|
2409
2511
|
@overload
|
|
2410
2512
|
def __init__(__self__,
|
|
2411
2513
|
resource_name: str,
|
|
2412
2514
|
opts: Optional[pulumi.ResourceOptions] = None,
|
|
2413
|
-
|
|
2414
|
-
|
|
2415
|
-
|
|
2416
|
-
|
|
2417
|
-
|
|
2418
|
-
|
|
2419
|
-
|
|
2420
|
-
|
|
2421
|
-
|
|
2422
|
-
|
|
2423
|
-
|
|
2424
|
-
|
|
2425
|
-
|
|
2426
|
-
|
|
2427
|
-
|
|
2428
|
-
|
|
2429
|
-
|
|
2430
|
-
|
|
2431
|
-
|
|
2432
|
-
|
|
2433
|
-
|
|
2434
|
-
|
|
2435
|
-
|
|
2436
|
-
|
|
2437
|
-
|
|
2438
|
-
|
|
2439
|
-
|
|
2440
|
-
|
|
2441
|
-
|
|
2442
|
-
|
|
2443
|
-
|
|
2444
|
-
|
|
2445
|
-
|
|
2446
|
-
|
|
2447
|
-
|
|
2448
|
-
|
|
2449
|
-
|
|
2450
|
-
|
|
2451
|
-
|
|
2452
|
-
|
|
2453
|
-
|
|
2454
|
-
|
|
2455
|
-
|
|
2456
|
-
|
|
2457
|
-
|
|
2458
|
-
|
|
2459
|
-
|
|
2460
|
-
|
|
2461
|
-
|
|
2462
|
-
|
|
2463
|
-
|
|
2464
|
-
|
|
2465
|
-
|
|
2466
|
-
|
|
2467
|
-
|
|
2468
|
-
|
|
2469
|
-
|
|
2470
|
-
|
|
2471
|
-
|
|
2472
|
-
|
|
2473
|
-
|
|
2474
|
-
|
|
2475
|
-
|
|
2476
|
-
|
|
2477
|
-
|
|
2478
|
-
|
|
2479
|
-
|
|
2480
|
-
|
|
2481
|
-
|
|
2482
|
-
|
|
2483
|
-
|
|
2484
|
-
|
|
2485
|
-
|
|
2486
|
-
|
|
2487
|
-
|
|
2488
|
-
|
|
2489
|
-
|
|
2490
|
-
|
|
2491
|
-
|
|
2492
|
-
|
|
2493
|
-
|
|
2494
|
-
|
|
2515
|
+
auto_healing: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
2516
|
+
availability_zones: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
2517
|
+
block_devices_mode: Optional[pulumi.Input[_builtins.str]] = None,
|
|
2518
|
+
capacity_unit: Optional[pulumi.Input[_builtins.str]] = None,
|
|
2519
|
+
consider_od_pricing: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
2520
|
+
cpu_credits: Optional[pulumi.Input[_builtins.str]] = None,
|
|
2521
|
+
cpu_options: Optional[pulumi.Input[Union['ElastigroupCpuOptionsArgs', 'ElastigroupCpuOptionsArgsDict']]] = None,
|
|
2522
|
+
description: Optional[pulumi.Input[_builtins.str]] = None,
|
|
2523
|
+
desired_capacity: Optional[pulumi.Input[_builtins.int]] = None,
|
|
2524
|
+
draining_timeout: Optional[pulumi.Input[_builtins.int]] = None,
|
|
2525
|
+
ebs_block_devices: Optional[pulumi.Input[Sequence[pulumi.Input[Union['ElastigroupEbsBlockDeviceArgs', 'ElastigroupEbsBlockDeviceArgsDict']]]]] = None,
|
|
2526
|
+
ebs_optimized: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
2527
|
+
elastic_ips: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
2528
|
+
elastic_load_balancers: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
2529
|
+
enable_monitoring: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
2530
|
+
ephemeral_block_devices: Optional[pulumi.Input[Sequence[pulumi.Input[Union['ElastigroupEphemeralBlockDeviceArgs', 'ElastigroupEphemeralBlockDeviceArgsDict']]]]] = None,
|
|
2531
|
+
fallback_to_ondemand: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
2532
|
+
health_check_grace_period: Optional[pulumi.Input[_builtins.int]] = None,
|
|
2533
|
+
health_check_type: Optional[pulumi.Input[_builtins.str]] = None,
|
|
2534
|
+
health_check_unhealthy_duration_before_replacement: Optional[pulumi.Input[_builtins.int]] = None,
|
|
2535
|
+
iam_instance_profile: Optional[pulumi.Input[_builtins.str]] = None,
|
|
2536
|
+
image_id: Optional[pulumi.Input[_builtins.str]] = None,
|
|
2537
|
+
images: Optional[pulumi.Input[Sequence[pulumi.Input[Union['ElastigroupImageArgs', 'ElastigroupImageArgsDict']]]]] = None,
|
|
2538
|
+
immediate_od_recover_threshold: Optional[pulumi.Input[_builtins.int]] = None,
|
|
2539
|
+
instance_types_ondemand: Optional[pulumi.Input[_builtins.str]] = None,
|
|
2540
|
+
instance_types_preferred_spots: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
2541
|
+
instance_types_spots: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
2542
|
+
instance_types_weights: Optional[pulumi.Input[Sequence[pulumi.Input[Union['ElastigroupInstanceTypesWeightArgs', 'ElastigroupInstanceTypesWeightArgsDict']]]]] = None,
|
|
2543
|
+
integration_beanstalk: Optional[pulumi.Input[Union['ElastigroupIntegrationBeanstalkArgs', 'ElastigroupIntegrationBeanstalkArgsDict']]] = None,
|
|
2544
|
+
integration_codedeploy: Optional[pulumi.Input[Union['ElastigroupIntegrationCodedeployArgs', 'ElastigroupIntegrationCodedeployArgsDict']]] = None,
|
|
2545
|
+
integration_docker_swarm: Optional[pulumi.Input[Union['ElastigroupIntegrationDockerSwarmArgs', 'ElastigroupIntegrationDockerSwarmArgsDict']]] = None,
|
|
2546
|
+
integration_ecs: Optional[pulumi.Input[Union['ElastigroupIntegrationEcsArgs', 'ElastigroupIntegrationEcsArgsDict']]] = None,
|
|
2547
|
+
integration_gitlab: Optional[pulumi.Input[Union['ElastigroupIntegrationGitlabArgs', 'ElastigroupIntegrationGitlabArgsDict']]] = None,
|
|
2548
|
+
integration_kubernetes: Optional[pulumi.Input[Union['ElastigroupIntegrationKubernetesArgs', 'ElastigroupIntegrationKubernetesArgsDict']]] = None,
|
|
2549
|
+
integration_mesosphere: Optional[pulumi.Input[Union['ElastigroupIntegrationMesosphereArgs', 'ElastigroupIntegrationMesosphereArgsDict']]] = None,
|
|
2550
|
+
integration_nomad: Optional[pulumi.Input[Union['ElastigroupIntegrationNomadArgs', 'ElastigroupIntegrationNomadArgsDict']]] = None,
|
|
2551
|
+
integration_rancher: Optional[pulumi.Input[Union['ElastigroupIntegrationRancherArgs', 'ElastigroupIntegrationRancherArgsDict']]] = None,
|
|
2552
|
+
integration_route53: Optional[pulumi.Input[Union['ElastigroupIntegrationRoute53Args', 'ElastigroupIntegrationRoute53ArgsDict']]] = None,
|
|
2553
|
+
itfs: Optional[pulumi.Input[Sequence[pulumi.Input[Union['ElastigroupItfArgs', 'ElastigroupItfArgsDict']]]]] = None,
|
|
2554
|
+
key_name: Optional[pulumi.Input[_builtins.str]] = None,
|
|
2555
|
+
lifetime_period: Optional[pulumi.Input[_builtins.str]] = None,
|
|
2556
|
+
logging: Optional[pulumi.Input[Union['ElastigroupLoggingArgs', 'ElastigroupLoggingArgsDict']]] = None,
|
|
2557
|
+
max_replacements_percentage: Optional[pulumi.Input[_builtins.int]] = None,
|
|
2558
|
+
max_size: Optional[pulumi.Input[_builtins.int]] = None,
|
|
2559
|
+
metadata_options: Optional[pulumi.Input[Union['ElastigroupMetadataOptionsArgs', 'ElastigroupMetadataOptionsArgsDict']]] = None,
|
|
2560
|
+
min_size: Optional[pulumi.Input[_builtins.int]] = None,
|
|
2561
|
+
minimum_instance_lifetime: Optional[pulumi.Input[_builtins.int]] = None,
|
|
2562
|
+
multiple_metrics: Optional[pulumi.Input[Union['ElastigroupMultipleMetricsArgs', 'ElastigroupMultipleMetricsArgsDict']]] = None,
|
|
2563
|
+
name: Optional[pulumi.Input[_builtins.str]] = None,
|
|
2564
|
+
network_interfaces: Optional[pulumi.Input[Sequence[pulumi.Input[Union['ElastigroupNetworkInterfaceArgs', 'ElastigroupNetworkInterfaceArgsDict']]]]] = None,
|
|
2565
|
+
on_demand_types: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
2566
|
+
ondemand_count: Optional[pulumi.Input[_builtins.int]] = None,
|
|
2567
|
+
orientation: Optional[pulumi.Input[_builtins.str]] = None,
|
|
2568
|
+
persist_block_devices: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
2569
|
+
persist_private_ip: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
2570
|
+
persist_root_device: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
2571
|
+
placement_tenancy: Optional[pulumi.Input[_builtins.str]] = None,
|
|
2572
|
+
preferred_availability_zones: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
2573
|
+
private_ips: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
2574
|
+
product: Optional[pulumi.Input[_builtins.str]] = None,
|
|
2575
|
+
region: Optional[pulumi.Input[_builtins.str]] = None,
|
|
2576
|
+
resource_requirements: Optional[pulumi.Input[Sequence[pulumi.Input[Union['ElastigroupResourceRequirementArgs', 'ElastigroupResourceRequirementArgsDict']]]]] = None,
|
|
2577
|
+
resource_tag_specifications: Optional[pulumi.Input[Sequence[pulumi.Input[Union['ElastigroupResourceTagSpecificationArgs', 'ElastigroupResourceTagSpecificationArgsDict']]]]] = None,
|
|
2578
|
+
restrict_single_az: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
2579
|
+
revert_to_spot: Optional[pulumi.Input[Union['ElastigroupRevertToSpotArgs', 'ElastigroupRevertToSpotArgsDict']]] = None,
|
|
2580
|
+
scaling_down_policies: Optional[pulumi.Input[Sequence[pulumi.Input[Union['ElastigroupScalingDownPolicyArgs', 'ElastigroupScalingDownPolicyArgsDict']]]]] = None,
|
|
2581
|
+
scaling_strategies: Optional[pulumi.Input[Sequence[pulumi.Input[Union['ElastigroupScalingStrategyArgs', 'ElastigroupScalingStrategyArgsDict']]]]] = None,
|
|
2582
|
+
scaling_target_policies: Optional[pulumi.Input[Sequence[pulumi.Input[Union['ElastigroupScalingTargetPolicyArgs', 'ElastigroupScalingTargetPolicyArgsDict']]]]] = None,
|
|
2583
|
+
scaling_up_policies: Optional[pulumi.Input[Sequence[pulumi.Input[Union['ElastigroupScalingUpPolicyArgs', 'ElastigroupScalingUpPolicyArgsDict']]]]] = None,
|
|
2584
|
+
scheduled_tasks: Optional[pulumi.Input[Sequence[pulumi.Input[Union['ElastigroupScheduledTaskArgs', 'ElastigroupScheduledTaskArgsDict']]]]] = None,
|
|
2585
|
+
security_groups: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
2586
|
+
shutdown_script: Optional[pulumi.Input[_builtins.str]] = None,
|
|
2587
|
+
signals: Optional[pulumi.Input[Sequence[pulumi.Input[Union['ElastigroupSignalArgs', 'ElastigroupSignalArgsDict']]]]] = None,
|
|
2588
|
+
spot_percentage: Optional[pulumi.Input[_builtins.int]] = None,
|
|
2589
|
+
stateful_deallocation: Optional[pulumi.Input[Union['ElastigroupStatefulDeallocationArgs', 'ElastigroupStatefulDeallocationArgsDict']]] = None,
|
|
2590
|
+
stateful_instance_actions: Optional[pulumi.Input[Sequence[pulumi.Input[Union['ElastigroupStatefulInstanceActionArgs', 'ElastigroupStatefulInstanceActionArgsDict']]]]] = None,
|
|
2591
|
+
subnet_ids: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
2592
|
+
tags: Optional[pulumi.Input[Sequence[pulumi.Input[Union['ElastigroupTagArgs', 'ElastigroupTagArgsDict']]]]] = None,
|
|
2593
|
+
target_group_arns: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
2594
|
+
update_policy: Optional[pulumi.Input[Union['ElastigroupUpdatePolicyArgs', 'ElastigroupUpdatePolicyArgsDict']]] = None,
|
|
2595
|
+
user_data: Optional[pulumi.Input[_builtins.str]] = None,
|
|
2596
|
+
utilize_commitments: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
2597
|
+
utilize_reserved_instances: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
2598
|
+
wait_for_capacity: Optional[pulumi.Input[_builtins.int]] = None,
|
|
2599
|
+
wait_for_capacity_timeout: Optional[pulumi.Input[_builtins.int]] = None,
|
|
2495
2600
|
__props__=None):
|
|
2496
2601
|
"""
|
|
2497
2602
|
Provides a Spotinst AWS group resource.
|
|
@@ -2524,14 +2629,14 @@ class Elastigroup(pulumi.CustomResource):
|
|
|
2524
2629
|
enable_monitoring=False,
|
|
2525
2630
|
ebs_optimized=False,
|
|
2526
2631
|
placement_tenancy="default",
|
|
2527
|
-
metadata_options=
|
|
2528
|
-
http_tokens
|
|
2529
|
-
http_put_response_hop_limit
|
|
2530
|
-
instance_metadata_tags
|
|
2531
|
-
|
|
2532
|
-
cpu_options=
|
|
2533
|
-
threads_per_core
|
|
2534
|
-
|
|
2632
|
+
metadata_options={
|
|
2633
|
+
"http_tokens": "optional",
|
|
2634
|
+
"http_put_response_hop_limit": 10,
|
|
2635
|
+
"instance_metadata_tags": "enabled",
|
|
2636
|
+
},
|
|
2637
|
+
cpu_options={
|
|
2638
|
+
"threads_per_core": 1,
|
|
2639
|
+
},
|
|
2535
2640
|
instance_types_ondemand="m3.2xlarge",
|
|
2536
2641
|
instance_types_spots=[
|
|
2537
2642
|
"m3.xlarge",
|
|
@@ -2540,152 +2645,155 @@ class Elastigroup(pulumi.CustomResource):
|
|
|
2540
2645
|
instance_types_preferred_spots=["m3.xlarge"],
|
|
2541
2646
|
on_demand_types=["c3.large"],
|
|
2542
2647
|
instance_types_weights=[
|
|
2543
|
-
|
|
2544
|
-
instance_type
|
|
2545
|
-
weight
|
|
2546
|
-
|
|
2547
|
-
|
|
2548
|
-
instance_type
|
|
2549
|
-
weight
|
|
2550
|
-
|
|
2648
|
+
{
|
|
2649
|
+
"instance_type": "m3.xlarge",
|
|
2650
|
+
"weight": 10,
|
|
2651
|
+
},
|
|
2652
|
+
{
|
|
2653
|
+
"instance_type": "m3.2xlarge",
|
|
2654
|
+
"weight": 16,
|
|
2655
|
+
},
|
|
2551
2656
|
],
|
|
2552
|
-
resource_requirements=[
|
|
2553
|
-
excluded_instance_families
|
|
2657
|
+
resource_requirements=[{
|
|
2658
|
+
"excluded_instance_families": [
|
|
2554
2659
|
"a",
|
|
2555
2660
|
"m",
|
|
2556
2661
|
],
|
|
2557
|
-
excluded_instance_types
|
|
2558
|
-
excluded_instance_generations
|
|
2662
|
+
"excluded_instance_types": ["m3.large"],
|
|
2663
|
+
"excluded_instance_generations": [
|
|
2559
2664
|
"1",
|
|
2560
2665
|
"2",
|
|
2561
2666
|
],
|
|
2562
|
-
required_gpu_minimum
|
|
2563
|
-
required_gpu_maximum
|
|
2564
|
-
required_memory_minimum
|
|
2565
|
-
required_memory_maximum
|
|
2566
|
-
required_vcpu_minimum
|
|
2567
|
-
required_vcpu_maximum
|
|
2568
|
-
|
|
2667
|
+
"required_gpu_minimum": 1,
|
|
2668
|
+
"required_gpu_maximum": 16,
|
|
2669
|
+
"required_memory_minimum": 1,
|
|
2670
|
+
"required_memory_maximum": 512,
|
|
2671
|
+
"required_vcpu_minimum": 1,
|
|
2672
|
+
"required_vcpu_maximum": 64,
|
|
2673
|
+
}],
|
|
2569
2674
|
orientation="balanced",
|
|
2570
2675
|
fallback_to_ondemand=False,
|
|
2571
2676
|
cpu_credits="unlimited",
|
|
2572
2677
|
minimum_instance_lifetime=12,
|
|
2678
|
+
max_replacements_percentage=10,
|
|
2573
2679
|
wait_for_capacity=5,
|
|
2574
2680
|
wait_for_capacity_timeout=300,
|
|
2575
|
-
scaling_strategies=[
|
|
2576
|
-
terminate_at_end_of_billing_hour
|
|
2577
|
-
termination_policy
|
|
2578
|
-
|
|
2579
|
-
scaling_up_policies=[
|
|
2580
|
-
policy_name
|
|
2581
|
-
metric_name
|
|
2582
|
-
statistic
|
|
2583
|
-
unit
|
|
2584
|
-
adjustment
|
|
2585
|
-
namespace
|
|
2586
|
-
threshold
|
|
2587
|
-
period
|
|
2588
|
-
evaluation_periods
|
|
2589
|
-
cooldown
|
|
2590
|
-
|
|
2591
|
-
scaling_down_policies=[
|
|
2592
|
-
policy_name
|
|
2593
|
-
metric_name
|
|
2594
|
-
statistic
|
|
2595
|
-
unit
|
|
2596
|
-
adjustment
|
|
2597
|
-
namespace
|
|
2598
|
-
threshold
|
|
2599
|
-
period
|
|
2600
|
-
evaluation_periods
|
|
2601
|
-
cooldown
|
|
2602
|
-
|
|
2681
|
+
scaling_strategies=[{
|
|
2682
|
+
"terminate_at_end_of_billing_hour": True,
|
|
2683
|
+
"termination_policy": "default",
|
|
2684
|
+
}],
|
|
2685
|
+
scaling_up_policies=[{
|
|
2686
|
+
"policy_name": "Default Scaling Up Policy",
|
|
2687
|
+
"metric_name": "DefaultQueuesDepth",
|
|
2688
|
+
"statistic": "average",
|
|
2689
|
+
"unit": "none",
|
|
2690
|
+
"adjustment": "1",
|
|
2691
|
+
"namespace": "custom",
|
|
2692
|
+
"threshold": 100,
|
|
2693
|
+
"period": 60,
|
|
2694
|
+
"evaluation_periods": 5,
|
|
2695
|
+
"cooldown": 300,
|
|
2696
|
+
}],
|
|
2697
|
+
scaling_down_policies=[{
|
|
2698
|
+
"policy_name": "Default Scaling Down Policy",
|
|
2699
|
+
"metric_name": "DefaultQueuesDepth",
|
|
2700
|
+
"statistic": "average",
|
|
2701
|
+
"unit": "none",
|
|
2702
|
+
"adjustment": "1",
|
|
2703
|
+
"namespace": "custom",
|
|
2704
|
+
"threshold": 10,
|
|
2705
|
+
"period": 60,
|
|
2706
|
+
"evaluation_periods": 10,
|
|
2707
|
+
"cooldown": 300,
|
|
2708
|
+
}],
|
|
2603
2709
|
tags=[
|
|
2604
|
-
|
|
2605
|
-
key
|
|
2606
|
-
value
|
|
2607
|
-
|
|
2608
|
-
|
|
2609
|
-
key
|
|
2610
|
-
value
|
|
2611
|
-
|
|
2612
|
-
|
|
2613
|
-
key
|
|
2614
|
-
value
|
|
2615
|
-
|
|
2710
|
+
{
|
|
2711
|
+
"key": "Env",
|
|
2712
|
+
"value": "production",
|
|
2713
|
+
},
|
|
2714
|
+
{
|
|
2715
|
+
"key": "Name",
|
|
2716
|
+
"value": "default-production",
|
|
2717
|
+
},
|
|
2718
|
+
{
|
|
2719
|
+
"key": "Project",
|
|
2720
|
+
"value": "app_v2",
|
|
2721
|
+
},
|
|
2616
2722
|
],
|
|
2617
|
-
resource_tag_specifications=[
|
|
2618
|
-
should_tag_enis
|
|
2619
|
-
should_tag_volumes
|
|
2620
|
-
should_tag_snapshots
|
|
2621
|
-
should_tag_amis
|
|
2622
|
-
|
|
2623
|
-
logging=
|
|
2624
|
-
export
|
|
2625
|
-
s3s
|
|
2626
|
-
id
|
|
2627
|
-
|
|
2628
|
-
|
|
2629
|
-
)
|
|
2723
|
+
resource_tag_specifications=[{
|
|
2724
|
+
"should_tag_enis": True,
|
|
2725
|
+
"should_tag_volumes": True,
|
|
2726
|
+
"should_tag_snapshots": True,
|
|
2727
|
+
"should_tag_amis": True,
|
|
2728
|
+
}],
|
|
2729
|
+
logging={
|
|
2730
|
+
"export": {
|
|
2731
|
+
"s3s": [{
|
|
2732
|
+
"id": "di-123456",
|
|
2733
|
+
}],
|
|
2734
|
+
},
|
|
2735
|
+
})
|
|
2630
2736
|
```
|
|
2631
2737
|
|
|
2632
2738
|
:param str resource_name: The name of the resource.
|
|
2633
2739
|
:param pulumi.ResourceOptions opts: Options for the resource.
|
|
2634
|
-
:param pulumi.Input[
|
|
2740
|
+
:param pulumi.Input[_builtins.bool] auto_healing: Auto-healing replacement won't be triggered if this parameter value is "false". In a case of a stateful group - no recycling will start if this parameter value is "false".
|
|
2741
|
+
:param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] availability_zones: List of Strings of availability zones. When this parameter is set, `subnet_ids` should be left unused.
|
|
2635
2742
|
Note: `availability_zones` naming syntax follows the convention `availability-zone:subnet:placement-group-name`. For example, to set an AZ in `us-east-1` with subnet `subnet-123456` and placement group `ClusterI03`, you would set:
|
|
2636
2743
|
`availability_zones = ["us-east-1a:subnet-123456:ClusterI03"]`
|
|
2637
|
-
:param pulumi.Input[str] capacity_unit: The capacity unit to launch instances by. If not specified, when choosing the weight unit, each instance will weight as the number of its vCPUs. Valid values: `instance`, `weight`.
|
|
2638
|
-
:param pulumi.Input[str] cpu_credits: Controls how T3 instances are launched. Valid values: `standard`, `unlimited`.
|
|
2639
|
-
:param pulumi.Input[
|
|
2640
|
-
:param pulumi.Input[str] description: The group description.
|
|
2641
|
-
:param pulumi.Input[int] desired_capacity: The desired number of instances the group should have at any time.
|
|
2642
|
-
:param pulumi.Input[int] draining_timeout: The time in seconds, the instance is allowed to run while detached from the ELB. This is to allow the instance time to be drained from incoming TCP connections before terminating it, during a scale down operation.
|
|
2643
|
-
:param pulumi.Input[bool] ebs_optimized: Enable high bandwidth connectivity between instances and AWS’s Elastic Block Store (EBS). For instance types that are EBS-optimized by default this parameter will be ignored.
|
|
2644
|
-
:param pulumi.Input[Sequence[pulumi.Input[str]]] elastic_ips: A list of [AWS Elastic IP](http://docs.aws.amazon.com/AWSEC2/latest/UserGuide/elastic-ip-addresses-eip.html) allocation IDs to associate to the group instances.
|
|
2645
|
-
:param pulumi.Input[bool] enable_monitoring: Indicates whether monitoring is enabled for the instance.
|
|
2646
|
-
:param pulumi.Input[bool] fallback_to_ondemand: In a case of no Spot instances available, Elastigroup will launch on-demand instances instead.
|
|
2647
|
-
:param pulumi.Input[int] health_check_grace_period: The amount of time, in seconds, after the instance has launched to starts and check its health.
|
|
2648
|
-
:param pulumi.Input[str] health_check_type: The service that will perform health checks for the instance. Valid values: `"ELB"`, `"HCS"`, `"TARGET_GROUP"`, `"EC2"`, `"K8S_NODE"`, `"NOMAD_NODE"`, `"ECS_CLUSTER_INSTANCE"`.
|
|
2649
|
-
:param pulumi.Input[int] health_check_unhealthy_duration_before_replacement: The amount of time, in seconds, that we will wait before replacing an instance that is running and became unhealthy (this is only applicable for instances that were once healthy).
|
|
2650
|
-
:param pulumi.Input[str] iam_instance_profile: The ARN or name of an IAM instance profile to associate with launched instances.
|
|
2651
|
-
:param pulumi.Input[str] image_id: The ID of the AMI used to launch the instance.
|
|
2652
|
-
:param pulumi.Input[Sequence[pulumi.Input[
|
|
2744
|
+
:param pulumi.Input[_builtins.str] capacity_unit: The capacity unit to launch instances by. If not specified, when choosing the weight unit, each instance will weight as the number of its vCPUs. Valid values: `instance`, `weight`.
|
|
2745
|
+
:param pulumi.Input[_builtins.str] cpu_credits: Controls how T3 instances are launched. Valid values: `standard`, `unlimited`.
|
|
2746
|
+
:param pulumi.Input[Union['ElastigroupCpuOptionsArgs', 'ElastigroupCpuOptionsArgsDict']] cpu_options: The CPU options for the instances that are launched within the group:
|
|
2747
|
+
:param pulumi.Input[_builtins.str] description: The group description.
|
|
2748
|
+
:param pulumi.Input[_builtins.int] desired_capacity: The desired number of instances the group should have at any time.
|
|
2749
|
+
:param pulumi.Input[_builtins.int] draining_timeout: The time in seconds, the instance is allowed to run while detached from the ELB. This is to allow the instance time to be drained from incoming TCP connections before terminating it, during a scale down operation.
|
|
2750
|
+
:param pulumi.Input[_builtins.bool] ebs_optimized: Enable high bandwidth connectivity between instances and AWS’s Elastic Block Store (EBS). For instance types that are EBS-optimized by default this parameter will be ignored.
|
|
2751
|
+
:param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] elastic_ips: A list of [AWS Elastic IP](http://docs.aws.amazon.com/AWSEC2/latest/UserGuide/elastic-ip-addresses-eip.html) allocation IDs to associate to the group instances.
|
|
2752
|
+
:param pulumi.Input[_builtins.bool] enable_monitoring: Indicates whether monitoring is enabled for the instance.
|
|
2753
|
+
:param pulumi.Input[_builtins.bool] fallback_to_ondemand: In a case of no Spot instances available, Elastigroup will launch on-demand instances instead.
|
|
2754
|
+
:param pulumi.Input[_builtins.int] health_check_grace_period: The amount of time, in seconds, after the instance has launched to starts and check its health.
|
|
2755
|
+
:param pulumi.Input[_builtins.str] health_check_type: The service that will perform health checks for the instance. Valid values: `"ELB"`, `"HCS"`, `"TARGET_GROUP"`, `"EC2"`, `"K8S_NODE"`, `"NOMAD_NODE"`, `"ECS_CLUSTER_INSTANCE"`.
|
|
2756
|
+
:param pulumi.Input[_builtins.int] health_check_unhealthy_duration_before_replacement: The amount of time, in seconds, that we will wait before replacing an instance that is running and became unhealthy (this is only applicable for instances that were once healthy).
|
|
2757
|
+
:param pulumi.Input[_builtins.str] iam_instance_profile: The ARN or name of an IAM instance profile to associate with launched instances.
|
|
2758
|
+
:param pulumi.Input[_builtins.str] image_id: The ID of the AMI used to launch the instance.
|
|
2759
|
+
:param pulumi.Input[Sequence[pulumi.Input[Union['ElastigroupImageArgs', 'ElastigroupImageArgsDict']]]] images: An array of image objects.
|
|
2653
2760
|
Note: Elastigroup can be configured with either imageId or images, but not both.
|
|
2654
|
-
:param pulumi.Input[str] instance_types_ondemand: The type of instance determines your instance's CPU capacity, memory and storage (e.g., m1.small, c1.xlarge).
|
|
2655
|
-
:param pulumi.Input[Sequence[pulumi.Input[str]]] instance_types_preferred_spots: Prioritize a subset of spot instance types. Must be a subset of the selected spot instance types.
|
|
2656
|
-
:param pulumi.Input[Sequence[pulumi.Input[str]]] instance_types_spots: One or more instance types. Note: Cannot be defined if 'resourceRequirements' is defined.
|
|
2657
|
-
:param pulumi.Input[Sequence[pulumi.Input[
|
|
2658
|
-
:param pulumi.Input[str] key_name: The key name that should be used for the instance.
|
|
2659
|
-
:param pulumi.Input[
|
|
2660
|
-
:param pulumi.Input[int] max_size: The maximum number of instances the group should have at any time.
|
|
2661
|
-
:param pulumi.Input[
|
|
2662
|
-
:param pulumi.Input[int] min_size: The minimum number of instances the group should have at any time.
|
|
2663
|
-
:param pulumi.Input[int] minimum_instance_lifetime: Defines the preferred minimum instance lifetime in hours. Markets which comply with this preference will be prioritized. Optional values: 1, 3, 6, 12, 24.
|
|
2664
|
-
:param pulumi.Input[str] name: The group name.
|
|
2665
|
-
:param pulumi.Input[Sequence[pulumi.Input[str]]] on_demand_types: Available ondemand instance types. Note: Either ondemand or onDemandTypes must be defined, but not both.
|
|
2666
|
-
:param pulumi.Input[int] ondemand_count: Number of on demand instances to launch in the group. All other instances will be spot instances. When this parameter is set the `spot_percentage` parameter is being ignored.
|
|
2667
|
-
:param pulumi.Input[str] orientation: Select a prediction strategy. Valid values: `balanced`, `costOriented`, `equalAzDistribution`, `availabilityOriented`. You can read more in our documentation.
|
|
2668
|
-
:param pulumi.Input[str] placement_tenancy: Enable dedicated tenancy. Note: There is a flat hourly fee for each region in which dedicated tenancy is used. Valid values: "default", "dedicated" .
|
|
2669
|
-
:param pulumi.Input[Sequence[pulumi.Input[str]]] preferred_availability_zones: The AZs to prioritize when launching Spot instances. If no markets are available in the Preferred AZs, Spot instances are launched in the non-preferred AZs.
|
|
2761
|
+
:param pulumi.Input[_builtins.str] instance_types_ondemand: The type of instance determines your instance's CPU capacity, memory and storage (e.g., m1.small, c1.xlarge).
|
|
2762
|
+
:param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] instance_types_preferred_spots: Prioritize a subset of spot instance types. Must be a subset of the selected spot instance types.
|
|
2763
|
+
:param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] instance_types_spots: One or more instance types. Note: Cannot be defined if 'resourceRequirements' is defined.
|
|
2764
|
+
:param pulumi.Input[Sequence[pulumi.Input[Union['ElastigroupInstanceTypesWeightArgs', 'ElastigroupInstanceTypesWeightArgsDict']]]] instance_types_weights: List of weights per instance type for weighted groups. Each object in the list should have the following attributes:
|
|
2765
|
+
:param pulumi.Input[_builtins.str] key_name: The key name that should be used for the instance.
|
|
2766
|
+
:param pulumi.Input[Union['ElastigroupLoggingArgs', 'ElastigroupLoggingArgsDict']] logging: Logging configuration.
|
|
2767
|
+
:param pulumi.Input[_builtins.int] max_size: The maximum number of instances the group should have at any time.
|
|
2768
|
+
:param pulumi.Input[Union['ElastigroupMetadataOptionsArgs', 'ElastigroupMetadataOptionsArgsDict']] metadata_options: Data that used to configure or manage the running instances:
|
|
2769
|
+
:param pulumi.Input[_builtins.int] min_size: The minimum number of instances the group should have at any time.
|
|
2770
|
+
:param pulumi.Input[_builtins.int] minimum_instance_lifetime: Defines the preferred minimum instance lifetime in hours. Markets which comply with this preference will be prioritized. Optional values: 1, 3, 6, 12, 24.
|
|
2771
|
+
:param pulumi.Input[_builtins.str] name: The group name.
|
|
2772
|
+
:param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] on_demand_types: Available ondemand instance types. Note: Either ondemand or onDemandTypes must be defined, but not both.
|
|
2773
|
+
:param pulumi.Input[_builtins.int] ondemand_count: Number of on demand instances to launch in the group. All other instances will be spot instances. When this parameter is set the `spot_percentage` parameter is being ignored.
|
|
2774
|
+
:param pulumi.Input[_builtins.str] orientation: Select a prediction strategy. Valid values: `balanced`, `costOriented`, `equalAzDistribution`, `availabilityOriented`. You can read more in our documentation.
|
|
2775
|
+
:param pulumi.Input[_builtins.str] placement_tenancy: Enable dedicated tenancy. Note: There is a flat hourly fee for each region in which dedicated tenancy is used. Valid values: "default", "dedicated" .
|
|
2776
|
+
:param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] preferred_availability_zones: The AZs to prioritize when launching Spot instances. If no markets are available in the Preferred AZs, Spot instances are launched in the non-preferred AZs.
|
|
2670
2777
|
Note: Must be a sublist of `availability_zones` and `orientation` value must not be `"equalAzDistribution"`.
|
|
2671
|
-
:param pulumi.Input[str] product: Operation system type. Valid values: `"Linux/UNIX"`, `"SUSE Linux"`, `"Windows"`.
|
|
2672
|
-
For EC2 Classic instances:
|
|
2673
|
-
:param pulumi.Input[str] region: The AWS region your group will be created in.
|
|
2778
|
+
:param pulumi.Input[_builtins.str] product: Operation system type. Valid values: `"Linux/UNIX"`, `"SUSE Linux"`, `"Windows"`.
|
|
2779
|
+
For EC2 Classic instances: `"SUSE Linux (Amazon VPC)"`, `"Windows (Amazon VPC)"`.
|
|
2780
|
+
:param pulumi.Input[_builtins.str] region: The AWS region your group will be created in.
|
|
2674
2781
|
Note: This parameter is required if you specify subnets (through subnet_ids). This parameter is optional if you specify Availability Zones (through availability_zones).
|
|
2675
|
-
:param pulumi.Input[Sequence[pulumi.Input[
|
|
2676
|
-
:param pulumi.Input[Sequence[pulumi.Input[
|
|
2677
|
-
:param pulumi.Input[
|
|
2678
|
-
:param pulumi.Input[
|
|
2679
|
-
:param pulumi.Input[Sequence[pulumi.Input[
|
|
2680
|
-
:param pulumi.Input[str]
|
|
2681
|
-
:param pulumi.Input[
|
|
2682
|
-
:param pulumi.Input[
|
|
2782
|
+
:param pulumi.Input[Sequence[pulumi.Input[Union['ElastigroupResourceRequirementArgs', 'ElastigroupResourceRequirementArgsDict']]]] resource_requirements: Required instance attributes. Instance types will be selected based on these requirements.
|
|
2783
|
+
:param pulumi.Input[Sequence[pulumi.Input[Union['ElastigroupResourceTagSpecificationArgs', 'ElastigroupResourceTagSpecificationArgsDict']]]] resource_tag_specifications: User will specify which resources should be tagged with group tags.
|
|
2784
|
+
:param pulumi.Input[_builtins.bool] restrict_single_az: Elastigroup will automatically scale your instances in the most available and cost efficient availability zone. Every evaluation will be done when there are no active instances in the group.
|
|
2785
|
+
:param pulumi.Input[Union['ElastigroupRevertToSpotArgs', 'ElastigroupRevertToSpotArgsDict']] revert_to_spot: Hold settings for strategy correction – replacing On-Demand for Spot instances. Supported Values: `"never"`, `"always"`, `"timeWindow"`
|
|
2786
|
+
:param pulumi.Input[Sequence[pulumi.Input[Union['ElastigroupScalingStrategyArgs', 'ElastigroupScalingStrategyArgsDict']]]] scaling_strategies: Set termination policy.
|
|
2787
|
+
:param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] security_groups: A list of associated security group IDS.
|
|
2788
|
+
: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/)
|
|
2789
|
+
:param pulumi.Input[_builtins.int] spot_percentage: The percentage of Spot instances that would spin up from the `desired_capacity` number.
|
|
2790
|
+
:param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] subnet_ids: List of Strings of subnet identifiers.
|
|
2683
2791
|
Note: When this parameter is set, `availability_zones` should be left unused.
|
|
2684
|
-
:param pulumi.Input[Sequence[pulumi.Input[
|
|
2685
|
-
:param pulumi.Input[str] user_data: The user data to provide when launching the instance.
|
|
2686
|
-
:param pulumi.Input[bool] utilize_reserved_instances: In a case of any available reserved instances, Elastigroup will utilize them first before purchasing Spot instances.
|
|
2687
|
-
:param pulumi.Input[int] wait_for_capacity: Minimum number of instances in a 'HEALTHY' status that is required before continuing. This is ignored when updating with blue/green deployment. Cannot exceed `desired_capacity`.
|
|
2688
|
-
:param pulumi.Input[int] wait_for_capacity_timeout: Time (seconds) to wait for instances to report a 'HEALTHY' status. Useful for plans with multiple dependencies that take some time to initialize. Leave undefined or set to `0` to indicate no wait. This is ignored when updating with blue/green deployment.
|
|
2792
|
+
:param pulumi.Input[Sequence[pulumi.Input[Union['ElastigroupTagArgs', 'ElastigroupTagArgsDict']]]] tags: A key/value mapping of tags to assign to the resource.
|
|
2793
|
+
:param pulumi.Input[_builtins.str] user_data: The user data to provide when launching the instance.
|
|
2794
|
+
:param pulumi.Input[_builtins.bool] utilize_reserved_instances: In a case of any available reserved instances, Elastigroup will utilize them first before purchasing Spot instances.
|
|
2795
|
+
:param pulumi.Input[_builtins.int] wait_for_capacity: Minimum number of instances in a 'HEALTHY' status that is required before continuing. This is ignored when updating with blue/green deployment. Cannot exceed `desired_capacity`.
|
|
2796
|
+
:param pulumi.Input[_builtins.int] wait_for_capacity_timeout: Time (seconds) to wait for instances to report a 'HEALTHY' status. Useful for plans with multiple dependencies that take some time to initialize. Leave undefined or set to `0` to indicate no wait. This is ignored when updating with blue/green deployment.
|
|
2689
2797
|
"""
|
|
2690
2798
|
...
|
|
2691
2799
|
@overload
|
|
@@ -2724,14 +2832,14 @@ class Elastigroup(pulumi.CustomResource):
|
|
|
2724
2832
|
enable_monitoring=False,
|
|
2725
2833
|
ebs_optimized=False,
|
|
2726
2834
|
placement_tenancy="default",
|
|
2727
|
-
metadata_options=
|
|
2728
|
-
http_tokens
|
|
2729
|
-
http_put_response_hop_limit
|
|
2730
|
-
instance_metadata_tags
|
|
2731
|
-
|
|
2732
|
-
cpu_options=
|
|
2733
|
-
threads_per_core
|
|
2734
|
-
|
|
2835
|
+
metadata_options={
|
|
2836
|
+
"http_tokens": "optional",
|
|
2837
|
+
"http_put_response_hop_limit": 10,
|
|
2838
|
+
"instance_metadata_tags": "enabled",
|
|
2839
|
+
},
|
|
2840
|
+
cpu_options={
|
|
2841
|
+
"threads_per_core": 1,
|
|
2842
|
+
},
|
|
2735
2843
|
instance_types_ondemand="m3.2xlarge",
|
|
2736
2844
|
instance_types_spots=[
|
|
2737
2845
|
"m3.xlarge",
|
|
@@ -2740,93 +2848,94 @@ class Elastigroup(pulumi.CustomResource):
|
|
|
2740
2848
|
instance_types_preferred_spots=["m3.xlarge"],
|
|
2741
2849
|
on_demand_types=["c3.large"],
|
|
2742
2850
|
instance_types_weights=[
|
|
2743
|
-
|
|
2744
|
-
instance_type
|
|
2745
|
-
weight
|
|
2746
|
-
|
|
2747
|
-
|
|
2748
|
-
instance_type
|
|
2749
|
-
weight
|
|
2750
|
-
|
|
2851
|
+
{
|
|
2852
|
+
"instance_type": "m3.xlarge",
|
|
2853
|
+
"weight": 10,
|
|
2854
|
+
},
|
|
2855
|
+
{
|
|
2856
|
+
"instance_type": "m3.2xlarge",
|
|
2857
|
+
"weight": 16,
|
|
2858
|
+
},
|
|
2751
2859
|
],
|
|
2752
|
-
resource_requirements=[
|
|
2753
|
-
excluded_instance_families
|
|
2860
|
+
resource_requirements=[{
|
|
2861
|
+
"excluded_instance_families": [
|
|
2754
2862
|
"a",
|
|
2755
2863
|
"m",
|
|
2756
2864
|
],
|
|
2757
|
-
excluded_instance_types
|
|
2758
|
-
excluded_instance_generations
|
|
2865
|
+
"excluded_instance_types": ["m3.large"],
|
|
2866
|
+
"excluded_instance_generations": [
|
|
2759
2867
|
"1",
|
|
2760
2868
|
"2",
|
|
2761
2869
|
],
|
|
2762
|
-
required_gpu_minimum
|
|
2763
|
-
required_gpu_maximum
|
|
2764
|
-
required_memory_minimum
|
|
2765
|
-
required_memory_maximum
|
|
2766
|
-
required_vcpu_minimum
|
|
2767
|
-
required_vcpu_maximum
|
|
2768
|
-
|
|
2870
|
+
"required_gpu_minimum": 1,
|
|
2871
|
+
"required_gpu_maximum": 16,
|
|
2872
|
+
"required_memory_minimum": 1,
|
|
2873
|
+
"required_memory_maximum": 512,
|
|
2874
|
+
"required_vcpu_minimum": 1,
|
|
2875
|
+
"required_vcpu_maximum": 64,
|
|
2876
|
+
}],
|
|
2769
2877
|
orientation="balanced",
|
|
2770
2878
|
fallback_to_ondemand=False,
|
|
2771
2879
|
cpu_credits="unlimited",
|
|
2772
2880
|
minimum_instance_lifetime=12,
|
|
2881
|
+
max_replacements_percentage=10,
|
|
2773
2882
|
wait_for_capacity=5,
|
|
2774
2883
|
wait_for_capacity_timeout=300,
|
|
2775
|
-
scaling_strategies=[
|
|
2776
|
-
terminate_at_end_of_billing_hour
|
|
2777
|
-
termination_policy
|
|
2778
|
-
|
|
2779
|
-
scaling_up_policies=[
|
|
2780
|
-
policy_name
|
|
2781
|
-
metric_name
|
|
2782
|
-
statistic
|
|
2783
|
-
unit
|
|
2784
|
-
adjustment
|
|
2785
|
-
namespace
|
|
2786
|
-
threshold
|
|
2787
|
-
period
|
|
2788
|
-
evaluation_periods
|
|
2789
|
-
cooldown
|
|
2790
|
-
|
|
2791
|
-
scaling_down_policies=[
|
|
2792
|
-
policy_name
|
|
2793
|
-
metric_name
|
|
2794
|
-
statistic
|
|
2795
|
-
unit
|
|
2796
|
-
adjustment
|
|
2797
|
-
namespace
|
|
2798
|
-
threshold
|
|
2799
|
-
period
|
|
2800
|
-
evaluation_periods
|
|
2801
|
-
cooldown
|
|
2802
|
-
|
|
2884
|
+
scaling_strategies=[{
|
|
2885
|
+
"terminate_at_end_of_billing_hour": True,
|
|
2886
|
+
"termination_policy": "default",
|
|
2887
|
+
}],
|
|
2888
|
+
scaling_up_policies=[{
|
|
2889
|
+
"policy_name": "Default Scaling Up Policy",
|
|
2890
|
+
"metric_name": "DefaultQueuesDepth",
|
|
2891
|
+
"statistic": "average",
|
|
2892
|
+
"unit": "none",
|
|
2893
|
+
"adjustment": "1",
|
|
2894
|
+
"namespace": "custom",
|
|
2895
|
+
"threshold": 100,
|
|
2896
|
+
"period": 60,
|
|
2897
|
+
"evaluation_periods": 5,
|
|
2898
|
+
"cooldown": 300,
|
|
2899
|
+
}],
|
|
2900
|
+
scaling_down_policies=[{
|
|
2901
|
+
"policy_name": "Default Scaling Down Policy",
|
|
2902
|
+
"metric_name": "DefaultQueuesDepth",
|
|
2903
|
+
"statistic": "average",
|
|
2904
|
+
"unit": "none",
|
|
2905
|
+
"adjustment": "1",
|
|
2906
|
+
"namespace": "custom",
|
|
2907
|
+
"threshold": 10,
|
|
2908
|
+
"period": 60,
|
|
2909
|
+
"evaluation_periods": 10,
|
|
2910
|
+
"cooldown": 300,
|
|
2911
|
+
}],
|
|
2803
2912
|
tags=[
|
|
2804
|
-
|
|
2805
|
-
key
|
|
2806
|
-
value
|
|
2807
|
-
|
|
2808
|
-
|
|
2809
|
-
key
|
|
2810
|
-
value
|
|
2811
|
-
|
|
2812
|
-
|
|
2813
|
-
key
|
|
2814
|
-
value
|
|
2815
|
-
|
|
2913
|
+
{
|
|
2914
|
+
"key": "Env",
|
|
2915
|
+
"value": "production",
|
|
2916
|
+
},
|
|
2917
|
+
{
|
|
2918
|
+
"key": "Name",
|
|
2919
|
+
"value": "default-production",
|
|
2920
|
+
},
|
|
2921
|
+
{
|
|
2922
|
+
"key": "Project",
|
|
2923
|
+
"value": "app_v2",
|
|
2924
|
+
},
|
|
2816
2925
|
],
|
|
2817
|
-
resource_tag_specifications=[
|
|
2818
|
-
should_tag_enis
|
|
2819
|
-
should_tag_volumes
|
|
2820
|
-
should_tag_snapshots
|
|
2821
|
-
should_tag_amis
|
|
2822
|
-
|
|
2823
|
-
logging=
|
|
2824
|
-
export
|
|
2825
|
-
s3s
|
|
2826
|
-
id
|
|
2827
|
-
|
|
2828
|
-
|
|
2829
|
-
)
|
|
2926
|
+
resource_tag_specifications=[{
|
|
2927
|
+
"should_tag_enis": True,
|
|
2928
|
+
"should_tag_volumes": True,
|
|
2929
|
+
"should_tag_snapshots": True,
|
|
2930
|
+
"should_tag_amis": True,
|
|
2931
|
+
}],
|
|
2932
|
+
logging={
|
|
2933
|
+
"export": {
|
|
2934
|
+
"s3s": [{
|
|
2935
|
+
"id": "di-123456",
|
|
2936
|
+
}],
|
|
2937
|
+
},
|
|
2938
|
+
})
|
|
2830
2939
|
```
|
|
2831
2940
|
|
|
2832
2941
|
:param str resource_name: The name of the resource.
|
|
@@ -2844,88 +2953,91 @@ class Elastigroup(pulumi.CustomResource):
|
|
|
2844
2953
|
def _internal_init(__self__,
|
|
2845
2954
|
resource_name: str,
|
|
2846
2955
|
opts: Optional[pulumi.ResourceOptions] = None,
|
|
2847
|
-
|
|
2848
|
-
|
|
2849
|
-
|
|
2850
|
-
|
|
2851
|
-
|
|
2852
|
-
|
|
2853
|
-
|
|
2854
|
-
|
|
2855
|
-
|
|
2856
|
-
|
|
2857
|
-
|
|
2858
|
-
|
|
2859
|
-
|
|
2860
|
-
|
|
2861
|
-
|
|
2862
|
-
|
|
2863
|
-
|
|
2864
|
-
|
|
2865
|
-
|
|
2866
|
-
|
|
2867
|
-
|
|
2868
|
-
|
|
2869
|
-
|
|
2870
|
-
|
|
2871
|
-
|
|
2872
|
-
|
|
2873
|
-
|
|
2874
|
-
|
|
2875
|
-
|
|
2876
|
-
|
|
2877
|
-
|
|
2878
|
-
|
|
2879
|
-
|
|
2880
|
-
|
|
2881
|
-
|
|
2882
|
-
|
|
2883
|
-
|
|
2884
|
-
|
|
2885
|
-
|
|
2886
|
-
|
|
2887
|
-
|
|
2888
|
-
|
|
2889
|
-
|
|
2890
|
-
|
|
2891
|
-
|
|
2892
|
-
|
|
2893
|
-
|
|
2894
|
-
|
|
2895
|
-
|
|
2896
|
-
|
|
2897
|
-
|
|
2898
|
-
|
|
2899
|
-
|
|
2900
|
-
|
|
2901
|
-
|
|
2902
|
-
|
|
2903
|
-
|
|
2904
|
-
|
|
2905
|
-
|
|
2906
|
-
|
|
2907
|
-
|
|
2908
|
-
|
|
2909
|
-
|
|
2910
|
-
|
|
2911
|
-
|
|
2912
|
-
|
|
2913
|
-
|
|
2914
|
-
|
|
2915
|
-
|
|
2916
|
-
|
|
2917
|
-
|
|
2918
|
-
|
|
2919
|
-
|
|
2920
|
-
|
|
2921
|
-
|
|
2922
|
-
|
|
2923
|
-
|
|
2924
|
-
|
|
2925
|
-
|
|
2926
|
-
|
|
2927
|
-
|
|
2928
|
-
|
|
2956
|
+
auto_healing: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
2957
|
+
availability_zones: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
2958
|
+
block_devices_mode: Optional[pulumi.Input[_builtins.str]] = None,
|
|
2959
|
+
capacity_unit: Optional[pulumi.Input[_builtins.str]] = None,
|
|
2960
|
+
consider_od_pricing: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
2961
|
+
cpu_credits: Optional[pulumi.Input[_builtins.str]] = None,
|
|
2962
|
+
cpu_options: Optional[pulumi.Input[Union['ElastigroupCpuOptionsArgs', 'ElastigroupCpuOptionsArgsDict']]] = None,
|
|
2963
|
+
description: Optional[pulumi.Input[_builtins.str]] = None,
|
|
2964
|
+
desired_capacity: Optional[pulumi.Input[_builtins.int]] = None,
|
|
2965
|
+
draining_timeout: Optional[pulumi.Input[_builtins.int]] = None,
|
|
2966
|
+
ebs_block_devices: Optional[pulumi.Input[Sequence[pulumi.Input[Union['ElastigroupEbsBlockDeviceArgs', 'ElastigroupEbsBlockDeviceArgsDict']]]]] = None,
|
|
2967
|
+
ebs_optimized: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
2968
|
+
elastic_ips: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
2969
|
+
elastic_load_balancers: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
2970
|
+
enable_monitoring: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
2971
|
+
ephemeral_block_devices: Optional[pulumi.Input[Sequence[pulumi.Input[Union['ElastigroupEphemeralBlockDeviceArgs', 'ElastigroupEphemeralBlockDeviceArgsDict']]]]] = None,
|
|
2972
|
+
fallback_to_ondemand: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
2973
|
+
health_check_grace_period: Optional[pulumi.Input[_builtins.int]] = None,
|
|
2974
|
+
health_check_type: Optional[pulumi.Input[_builtins.str]] = None,
|
|
2975
|
+
health_check_unhealthy_duration_before_replacement: Optional[pulumi.Input[_builtins.int]] = None,
|
|
2976
|
+
iam_instance_profile: Optional[pulumi.Input[_builtins.str]] = None,
|
|
2977
|
+
image_id: Optional[pulumi.Input[_builtins.str]] = None,
|
|
2978
|
+
images: Optional[pulumi.Input[Sequence[pulumi.Input[Union['ElastigroupImageArgs', 'ElastigroupImageArgsDict']]]]] = None,
|
|
2979
|
+
immediate_od_recover_threshold: Optional[pulumi.Input[_builtins.int]] = None,
|
|
2980
|
+
instance_types_ondemand: Optional[pulumi.Input[_builtins.str]] = None,
|
|
2981
|
+
instance_types_preferred_spots: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
2982
|
+
instance_types_spots: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
2983
|
+
instance_types_weights: Optional[pulumi.Input[Sequence[pulumi.Input[Union['ElastigroupInstanceTypesWeightArgs', 'ElastigroupInstanceTypesWeightArgsDict']]]]] = None,
|
|
2984
|
+
integration_beanstalk: Optional[pulumi.Input[Union['ElastigroupIntegrationBeanstalkArgs', 'ElastigroupIntegrationBeanstalkArgsDict']]] = None,
|
|
2985
|
+
integration_codedeploy: Optional[pulumi.Input[Union['ElastigroupIntegrationCodedeployArgs', 'ElastigroupIntegrationCodedeployArgsDict']]] = None,
|
|
2986
|
+
integration_docker_swarm: Optional[pulumi.Input[Union['ElastigroupIntegrationDockerSwarmArgs', 'ElastigroupIntegrationDockerSwarmArgsDict']]] = None,
|
|
2987
|
+
integration_ecs: Optional[pulumi.Input[Union['ElastigroupIntegrationEcsArgs', 'ElastigroupIntegrationEcsArgsDict']]] = None,
|
|
2988
|
+
integration_gitlab: Optional[pulumi.Input[Union['ElastigroupIntegrationGitlabArgs', 'ElastigroupIntegrationGitlabArgsDict']]] = None,
|
|
2989
|
+
integration_kubernetes: Optional[pulumi.Input[Union['ElastigroupIntegrationKubernetesArgs', 'ElastigroupIntegrationKubernetesArgsDict']]] = None,
|
|
2990
|
+
integration_mesosphere: Optional[pulumi.Input[Union['ElastigroupIntegrationMesosphereArgs', 'ElastigroupIntegrationMesosphereArgsDict']]] = None,
|
|
2991
|
+
integration_nomad: Optional[pulumi.Input[Union['ElastigroupIntegrationNomadArgs', 'ElastigroupIntegrationNomadArgsDict']]] = None,
|
|
2992
|
+
integration_rancher: Optional[pulumi.Input[Union['ElastigroupIntegrationRancherArgs', 'ElastigroupIntegrationRancherArgsDict']]] = None,
|
|
2993
|
+
integration_route53: Optional[pulumi.Input[Union['ElastigroupIntegrationRoute53Args', 'ElastigroupIntegrationRoute53ArgsDict']]] = None,
|
|
2994
|
+
itfs: Optional[pulumi.Input[Sequence[pulumi.Input[Union['ElastigroupItfArgs', 'ElastigroupItfArgsDict']]]]] = None,
|
|
2995
|
+
key_name: Optional[pulumi.Input[_builtins.str]] = None,
|
|
2996
|
+
lifetime_period: Optional[pulumi.Input[_builtins.str]] = None,
|
|
2997
|
+
logging: Optional[pulumi.Input[Union['ElastigroupLoggingArgs', 'ElastigroupLoggingArgsDict']]] = None,
|
|
2998
|
+
max_replacements_percentage: Optional[pulumi.Input[_builtins.int]] = None,
|
|
2999
|
+
max_size: Optional[pulumi.Input[_builtins.int]] = None,
|
|
3000
|
+
metadata_options: Optional[pulumi.Input[Union['ElastigroupMetadataOptionsArgs', 'ElastigroupMetadataOptionsArgsDict']]] = None,
|
|
3001
|
+
min_size: Optional[pulumi.Input[_builtins.int]] = None,
|
|
3002
|
+
minimum_instance_lifetime: Optional[pulumi.Input[_builtins.int]] = None,
|
|
3003
|
+
multiple_metrics: Optional[pulumi.Input[Union['ElastigroupMultipleMetricsArgs', 'ElastigroupMultipleMetricsArgsDict']]] = None,
|
|
3004
|
+
name: Optional[pulumi.Input[_builtins.str]] = None,
|
|
3005
|
+
network_interfaces: Optional[pulumi.Input[Sequence[pulumi.Input[Union['ElastigroupNetworkInterfaceArgs', 'ElastigroupNetworkInterfaceArgsDict']]]]] = None,
|
|
3006
|
+
on_demand_types: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
3007
|
+
ondemand_count: Optional[pulumi.Input[_builtins.int]] = None,
|
|
3008
|
+
orientation: Optional[pulumi.Input[_builtins.str]] = None,
|
|
3009
|
+
persist_block_devices: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
3010
|
+
persist_private_ip: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
3011
|
+
persist_root_device: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
3012
|
+
placement_tenancy: Optional[pulumi.Input[_builtins.str]] = None,
|
|
3013
|
+
preferred_availability_zones: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
3014
|
+
private_ips: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
3015
|
+
product: Optional[pulumi.Input[_builtins.str]] = None,
|
|
3016
|
+
region: Optional[pulumi.Input[_builtins.str]] = None,
|
|
3017
|
+
resource_requirements: Optional[pulumi.Input[Sequence[pulumi.Input[Union['ElastigroupResourceRequirementArgs', 'ElastigroupResourceRequirementArgsDict']]]]] = None,
|
|
3018
|
+
resource_tag_specifications: Optional[pulumi.Input[Sequence[pulumi.Input[Union['ElastigroupResourceTagSpecificationArgs', 'ElastigroupResourceTagSpecificationArgsDict']]]]] = None,
|
|
3019
|
+
restrict_single_az: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
3020
|
+
revert_to_spot: Optional[pulumi.Input[Union['ElastigroupRevertToSpotArgs', 'ElastigroupRevertToSpotArgsDict']]] = None,
|
|
3021
|
+
scaling_down_policies: Optional[pulumi.Input[Sequence[pulumi.Input[Union['ElastigroupScalingDownPolicyArgs', 'ElastigroupScalingDownPolicyArgsDict']]]]] = None,
|
|
3022
|
+
scaling_strategies: Optional[pulumi.Input[Sequence[pulumi.Input[Union['ElastigroupScalingStrategyArgs', 'ElastigroupScalingStrategyArgsDict']]]]] = None,
|
|
3023
|
+
scaling_target_policies: Optional[pulumi.Input[Sequence[pulumi.Input[Union['ElastigroupScalingTargetPolicyArgs', 'ElastigroupScalingTargetPolicyArgsDict']]]]] = None,
|
|
3024
|
+
scaling_up_policies: Optional[pulumi.Input[Sequence[pulumi.Input[Union['ElastigroupScalingUpPolicyArgs', 'ElastigroupScalingUpPolicyArgsDict']]]]] = None,
|
|
3025
|
+
scheduled_tasks: Optional[pulumi.Input[Sequence[pulumi.Input[Union['ElastigroupScheduledTaskArgs', 'ElastigroupScheduledTaskArgsDict']]]]] = None,
|
|
3026
|
+
security_groups: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
3027
|
+
shutdown_script: Optional[pulumi.Input[_builtins.str]] = None,
|
|
3028
|
+
signals: Optional[pulumi.Input[Sequence[pulumi.Input[Union['ElastigroupSignalArgs', 'ElastigroupSignalArgsDict']]]]] = None,
|
|
3029
|
+
spot_percentage: Optional[pulumi.Input[_builtins.int]] = None,
|
|
3030
|
+
stateful_deallocation: Optional[pulumi.Input[Union['ElastigroupStatefulDeallocationArgs', 'ElastigroupStatefulDeallocationArgsDict']]] = None,
|
|
3031
|
+
stateful_instance_actions: Optional[pulumi.Input[Sequence[pulumi.Input[Union['ElastigroupStatefulInstanceActionArgs', 'ElastigroupStatefulInstanceActionArgsDict']]]]] = None,
|
|
3032
|
+
subnet_ids: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
3033
|
+
tags: Optional[pulumi.Input[Sequence[pulumi.Input[Union['ElastigroupTagArgs', 'ElastigroupTagArgsDict']]]]] = None,
|
|
3034
|
+
target_group_arns: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
3035
|
+
update_policy: Optional[pulumi.Input[Union['ElastigroupUpdatePolicyArgs', 'ElastigroupUpdatePolicyArgsDict']]] = None,
|
|
3036
|
+
user_data: Optional[pulumi.Input[_builtins.str]] = None,
|
|
3037
|
+
utilize_commitments: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
3038
|
+
utilize_reserved_instances: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
3039
|
+
wait_for_capacity: Optional[pulumi.Input[_builtins.int]] = None,
|
|
3040
|
+
wait_for_capacity_timeout: Optional[pulumi.Input[_builtins.int]] = None,
|
|
2929
3041
|
__props__=None):
|
|
2930
3042
|
opts = pulumi.ResourceOptions.merge(_utilities.get_resource_opts_defaults(), opts)
|
|
2931
3043
|
if not isinstance(opts, pulumi.ResourceOptions):
|
|
@@ -2935,6 +3047,7 @@ class Elastigroup(pulumi.CustomResource):
|
|
|
2935
3047
|
raise TypeError('__props__ is only valid when passed in combination with a valid opts.id to get an existing resource')
|
|
2936
3048
|
__props__ = ElastigroupArgs.__new__(ElastigroupArgs)
|
|
2937
3049
|
|
|
3050
|
+
__props__.__dict__["auto_healing"] = auto_healing
|
|
2938
3051
|
__props__.__dict__["availability_zones"] = availability_zones
|
|
2939
3052
|
__props__.__dict__["block_devices_mode"] = block_devices_mode
|
|
2940
3053
|
__props__.__dict__["capacity_unit"] = capacity_unit
|
|
@@ -2978,6 +3091,7 @@ class Elastigroup(pulumi.CustomResource):
|
|
|
2978
3091
|
__props__.__dict__["key_name"] = key_name
|
|
2979
3092
|
__props__.__dict__["lifetime_period"] = lifetime_period
|
|
2980
3093
|
__props__.__dict__["logging"] = logging
|
|
3094
|
+
__props__.__dict__["max_replacements_percentage"] = max_replacements_percentage
|
|
2981
3095
|
__props__.__dict__["max_size"] = max_size
|
|
2982
3096
|
__props__.__dict__["metadata_options"] = metadata_options
|
|
2983
3097
|
__props__.__dict__["min_size"] = min_size
|
|
@@ -3002,6 +3116,7 @@ class Elastigroup(pulumi.CustomResource):
|
|
|
3002
3116
|
__props__.__dict__["region"] = region
|
|
3003
3117
|
__props__.__dict__["resource_requirements"] = resource_requirements
|
|
3004
3118
|
__props__.__dict__["resource_tag_specifications"] = resource_tag_specifications
|
|
3119
|
+
__props__.__dict__["restrict_single_az"] = restrict_single_az
|
|
3005
3120
|
__props__.__dict__["revert_to_spot"] = revert_to_spot
|
|
3006
3121
|
__props__.__dict__["scaling_down_policies"] = scaling_down_policies
|
|
3007
3122
|
__props__.__dict__["scaling_strategies"] = scaling_strategies
|
|
@@ -3035,88 +3150,91 @@ class Elastigroup(pulumi.CustomResource):
|
|
|
3035
3150
|
def get(resource_name: str,
|
|
3036
3151
|
id: pulumi.Input[str],
|
|
3037
3152
|
opts: Optional[pulumi.ResourceOptions] = None,
|
|
3038
|
-
|
|
3039
|
-
|
|
3040
|
-
|
|
3041
|
-
|
|
3042
|
-
|
|
3043
|
-
|
|
3044
|
-
|
|
3045
|
-
|
|
3046
|
-
|
|
3047
|
-
|
|
3048
|
-
|
|
3049
|
-
|
|
3050
|
-
|
|
3051
|
-
|
|
3052
|
-
|
|
3053
|
-
|
|
3054
|
-
|
|
3055
|
-
|
|
3056
|
-
|
|
3057
|
-
|
|
3058
|
-
|
|
3059
|
-
|
|
3060
|
-
|
|
3061
|
-
|
|
3062
|
-
|
|
3063
|
-
|
|
3064
|
-
|
|
3065
|
-
|
|
3066
|
-
|
|
3067
|
-
|
|
3068
|
-
|
|
3069
|
-
|
|
3070
|
-
|
|
3071
|
-
|
|
3072
|
-
|
|
3073
|
-
|
|
3074
|
-
|
|
3075
|
-
|
|
3076
|
-
|
|
3077
|
-
|
|
3078
|
-
|
|
3079
|
-
|
|
3080
|
-
|
|
3081
|
-
|
|
3082
|
-
|
|
3083
|
-
|
|
3084
|
-
|
|
3085
|
-
|
|
3086
|
-
|
|
3087
|
-
|
|
3088
|
-
|
|
3089
|
-
|
|
3090
|
-
|
|
3091
|
-
|
|
3092
|
-
|
|
3093
|
-
|
|
3094
|
-
|
|
3095
|
-
|
|
3096
|
-
|
|
3097
|
-
|
|
3098
|
-
|
|
3099
|
-
|
|
3100
|
-
|
|
3101
|
-
|
|
3102
|
-
|
|
3103
|
-
|
|
3104
|
-
|
|
3105
|
-
|
|
3106
|
-
|
|
3107
|
-
|
|
3108
|
-
|
|
3109
|
-
|
|
3110
|
-
|
|
3111
|
-
|
|
3112
|
-
|
|
3113
|
-
|
|
3114
|
-
|
|
3115
|
-
|
|
3116
|
-
|
|
3117
|
-
|
|
3118
|
-
|
|
3119
|
-
|
|
3153
|
+
auto_healing: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
3154
|
+
availability_zones: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
3155
|
+
block_devices_mode: Optional[pulumi.Input[_builtins.str]] = None,
|
|
3156
|
+
capacity_unit: Optional[pulumi.Input[_builtins.str]] = None,
|
|
3157
|
+
consider_od_pricing: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
3158
|
+
cpu_credits: Optional[pulumi.Input[_builtins.str]] = None,
|
|
3159
|
+
cpu_options: Optional[pulumi.Input[Union['ElastigroupCpuOptionsArgs', 'ElastigroupCpuOptionsArgsDict']]] = None,
|
|
3160
|
+
description: Optional[pulumi.Input[_builtins.str]] = None,
|
|
3161
|
+
desired_capacity: Optional[pulumi.Input[_builtins.int]] = None,
|
|
3162
|
+
draining_timeout: Optional[pulumi.Input[_builtins.int]] = None,
|
|
3163
|
+
ebs_block_devices: Optional[pulumi.Input[Sequence[pulumi.Input[Union['ElastigroupEbsBlockDeviceArgs', 'ElastigroupEbsBlockDeviceArgsDict']]]]] = None,
|
|
3164
|
+
ebs_optimized: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
3165
|
+
elastic_ips: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
3166
|
+
elastic_load_balancers: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
3167
|
+
enable_monitoring: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
3168
|
+
ephemeral_block_devices: Optional[pulumi.Input[Sequence[pulumi.Input[Union['ElastigroupEphemeralBlockDeviceArgs', 'ElastigroupEphemeralBlockDeviceArgsDict']]]]] = None,
|
|
3169
|
+
fallback_to_ondemand: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
3170
|
+
health_check_grace_period: Optional[pulumi.Input[_builtins.int]] = None,
|
|
3171
|
+
health_check_type: Optional[pulumi.Input[_builtins.str]] = None,
|
|
3172
|
+
health_check_unhealthy_duration_before_replacement: Optional[pulumi.Input[_builtins.int]] = None,
|
|
3173
|
+
iam_instance_profile: Optional[pulumi.Input[_builtins.str]] = None,
|
|
3174
|
+
image_id: Optional[pulumi.Input[_builtins.str]] = None,
|
|
3175
|
+
images: Optional[pulumi.Input[Sequence[pulumi.Input[Union['ElastigroupImageArgs', 'ElastigroupImageArgsDict']]]]] = None,
|
|
3176
|
+
immediate_od_recover_threshold: Optional[pulumi.Input[_builtins.int]] = None,
|
|
3177
|
+
instance_types_ondemand: Optional[pulumi.Input[_builtins.str]] = None,
|
|
3178
|
+
instance_types_preferred_spots: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
3179
|
+
instance_types_spots: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
3180
|
+
instance_types_weights: Optional[pulumi.Input[Sequence[pulumi.Input[Union['ElastigroupInstanceTypesWeightArgs', 'ElastigroupInstanceTypesWeightArgsDict']]]]] = None,
|
|
3181
|
+
integration_beanstalk: Optional[pulumi.Input[Union['ElastigroupIntegrationBeanstalkArgs', 'ElastigroupIntegrationBeanstalkArgsDict']]] = None,
|
|
3182
|
+
integration_codedeploy: Optional[pulumi.Input[Union['ElastigroupIntegrationCodedeployArgs', 'ElastigroupIntegrationCodedeployArgsDict']]] = None,
|
|
3183
|
+
integration_docker_swarm: Optional[pulumi.Input[Union['ElastigroupIntegrationDockerSwarmArgs', 'ElastigroupIntegrationDockerSwarmArgsDict']]] = None,
|
|
3184
|
+
integration_ecs: Optional[pulumi.Input[Union['ElastigroupIntegrationEcsArgs', 'ElastigroupIntegrationEcsArgsDict']]] = None,
|
|
3185
|
+
integration_gitlab: Optional[pulumi.Input[Union['ElastigroupIntegrationGitlabArgs', 'ElastigroupIntegrationGitlabArgsDict']]] = None,
|
|
3186
|
+
integration_kubernetes: Optional[pulumi.Input[Union['ElastigroupIntegrationKubernetesArgs', 'ElastigroupIntegrationKubernetesArgsDict']]] = None,
|
|
3187
|
+
integration_mesosphere: Optional[pulumi.Input[Union['ElastigroupIntegrationMesosphereArgs', 'ElastigroupIntegrationMesosphereArgsDict']]] = None,
|
|
3188
|
+
integration_nomad: Optional[pulumi.Input[Union['ElastigroupIntegrationNomadArgs', 'ElastigroupIntegrationNomadArgsDict']]] = None,
|
|
3189
|
+
integration_rancher: Optional[pulumi.Input[Union['ElastigroupIntegrationRancherArgs', 'ElastigroupIntegrationRancherArgsDict']]] = None,
|
|
3190
|
+
integration_route53: Optional[pulumi.Input[Union['ElastigroupIntegrationRoute53Args', 'ElastigroupIntegrationRoute53ArgsDict']]] = None,
|
|
3191
|
+
itfs: Optional[pulumi.Input[Sequence[pulumi.Input[Union['ElastigroupItfArgs', 'ElastigroupItfArgsDict']]]]] = None,
|
|
3192
|
+
key_name: Optional[pulumi.Input[_builtins.str]] = None,
|
|
3193
|
+
lifetime_period: Optional[pulumi.Input[_builtins.str]] = None,
|
|
3194
|
+
logging: Optional[pulumi.Input[Union['ElastigroupLoggingArgs', 'ElastigroupLoggingArgsDict']]] = None,
|
|
3195
|
+
max_replacements_percentage: Optional[pulumi.Input[_builtins.int]] = None,
|
|
3196
|
+
max_size: Optional[pulumi.Input[_builtins.int]] = None,
|
|
3197
|
+
metadata_options: Optional[pulumi.Input[Union['ElastigroupMetadataOptionsArgs', 'ElastigroupMetadataOptionsArgsDict']]] = None,
|
|
3198
|
+
min_size: Optional[pulumi.Input[_builtins.int]] = None,
|
|
3199
|
+
minimum_instance_lifetime: Optional[pulumi.Input[_builtins.int]] = None,
|
|
3200
|
+
multiple_metrics: Optional[pulumi.Input[Union['ElastigroupMultipleMetricsArgs', 'ElastigroupMultipleMetricsArgsDict']]] = None,
|
|
3201
|
+
name: Optional[pulumi.Input[_builtins.str]] = None,
|
|
3202
|
+
network_interfaces: Optional[pulumi.Input[Sequence[pulumi.Input[Union['ElastigroupNetworkInterfaceArgs', 'ElastigroupNetworkInterfaceArgsDict']]]]] = None,
|
|
3203
|
+
on_demand_types: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
3204
|
+
ondemand_count: Optional[pulumi.Input[_builtins.int]] = None,
|
|
3205
|
+
orientation: Optional[pulumi.Input[_builtins.str]] = None,
|
|
3206
|
+
persist_block_devices: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
3207
|
+
persist_private_ip: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
3208
|
+
persist_root_device: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
3209
|
+
placement_tenancy: Optional[pulumi.Input[_builtins.str]] = None,
|
|
3210
|
+
preferred_availability_zones: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
3211
|
+
private_ips: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
3212
|
+
product: Optional[pulumi.Input[_builtins.str]] = None,
|
|
3213
|
+
region: Optional[pulumi.Input[_builtins.str]] = None,
|
|
3214
|
+
resource_requirements: Optional[pulumi.Input[Sequence[pulumi.Input[Union['ElastigroupResourceRequirementArgs', 'ElastigroupResourceRequirementArgsDict']]]]] = None,
|
|
3215
|
+
resource_tag_specifications: Optional[pulumi.Input[Sequence[pulumi.Input[Union['ElastigroupResourceTagSpecificationArgs', 'ElastigroupResourceTagSpecificationArgsDict']]]]] = None,
|
|
3216
|
+
restrict_single_az: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
3217
|
+
revert_to_spot: Optional[pulumi.Input[Union['ElastigroupRevertToSpotArgs', 'ElastigroupRevertToSpotArgsDict']]] = None,
|
|
3218
|
+
scaling_down_policies: Optional[pulumi.Input[Sequence[pulumi.Input[Union['ElastigroupScalingDownPolicyArgs', 'ElastigroupScalingDownPolicyArgsDict']]]]] = None,
|
|
3219
|
+
scaling_strategies: Optional[pulumi.Input[Sequence[pulumi.Input[Union['ElastigroupScalingStrategyArgs', 'ElastigroupScalingStrategyArgsDict']]]]] = None,
|
|
3220
|
+
scaling_target_policies: Optional[pulumi.Input[Sequence[pulumi.Input[Union['ElastigroupScalingTargetPolicyArgs', 'ElastigroupScalingTargetPolicyArgsDict']]]]] = None,
|
|
3221
|
+
scaling_up_policies: Optional[pulumi.Input[Sequence[pulumi.Input[Union['ElastigroupScalingUpPolicyArgs', 'ElastigroupScalingUpPolicyArgsDict']]]]] = None,
|
|
3222
|
+
scheduled_tasks: Optional[pulumi.Input[Sequence[pulumi.Input[Union['ElastigroupScheduledTaskArgs', 'ElastigroupScheduledTaskArgsDict']]]]] = None,
|
|
3223
|
+
security_groups: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
3224
|
+
shutdown_script: Optional[pulumi.Input[_builtins.str]] = None,
|
|
3225
|
+
signals: Optional[pulumi.Input[Sequence[pulumi.Input[Union['ElastigroupSignalArgs', 'ElastigroupSignalArgsDict']]]]] = None,
|
|
3226
|
+
spot_percentage: Optional[pulumi.Input[_builtins.int]] = None,
|
|
3227
|
+
stateful_deallocation: Optional[pulumi.Input[Union['ElastigroupStatefulDeallocationArgs', 'ElastigroupStatefulDeallocationArgsDict']]] = None,
|
|
3228
|
+
stateful_instance_actions: Optional[pulumi.Input[Sequence[pulumi.Input[Union['ElastigroupStatefulInstanceActionArgs', 'ElastigroupStatefulInstanceActionArgsDict']]]]] = None,
|
|
3229
|
+
subnet_ids: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
3230
|
+
tags: Optional[pulumi.Input[Sequence[pulumi.Input[Union['ElastigroupTagArgs', 'ElastigroupTagArgsDict']]]]] = None,
|
|
3231
|
+
target_group_arns: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
3232
|
+
update_policy: Optional[pulumi.Input[Union['ElastigroupUpdatePolicyArgs', 'ElastigroupUpdatePolicyArgsDict']]] = None,
|
|
3233
|
+
user_data: Optional[pulumi.Input[_builtins.str]] = None,
|
|
3234
|
+
utilize_commitments: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
3235
|
+
utilize_reserved_instances: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
3236
|
+
wait_for_capacity: Optional[pulumi.Input[_builtins.int]] = None,
|
|
3237
|
+
wait_for_capacity_timeout: Optional[pulumi.Input[_builtins.int]] = None) -> 'Elastigroup':
|
|
3120
3238
|
"""
|
|
3121
3239
|
Get an existing Elastigroup resource's state with the given name, id, and optional extra
|
|
3122
3240
|
properties used to qualify the lookup.
|
|
@@ -3124,66 +3242,69 @@ class Elastigroup(pulumi.CustomResource):
|
|
|
3124
3242
|
:param str resource_name: The unique name of the resulting resource.
|
|
3125
3243
|
:param pulumi.Input[str] id: The unique provider ID of the resource to lookup.
|
|
3126
3244
|
:param pulumi.ResourceOptions opts: Options for the resource.
|
|
3127
|
-
:param pulumi.Input[
|
|
3245
|
+
:param pulumi.Input[_builtins.bool] auto_healing: Auto-healing replacement won't be triggered if this parameter value is "false". In a case of a stateful group - no recycling will start if this parameter value is "false".
|
|
3246
|
+
:param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] availability_zones: List of Strings of availability zones. When this parameter is set, `subnet_ids` should be left unused.
|
|
3128
3247
|
Note: `availability_zones` naming syntax follows the convention `availability-zone:subnet:placement-group-name`. For example, to set an AZ in `us-east-1` with subnet `subnet-123456` and placement group `ClusterI03`, you would set:
|
|
3129
3248
|
`availability_zones = ["us-east-1a:subnet-123456:ClusterI03"]`
|
|
3130
|
-
:param pulumi.Input[str] capacity_unit: The capacity unit to launch instances by. If not specified, when choosing the weight unit, each instance will weight as the number of its vCPUs. Valid values: `instance`, `weight`.
|
|
3131
|
-
:param pulumi.Input[str] cpu_credits: Controls how T3 instances are launched. Valid values: `standard`, `unlimited`.
|
|
3132
|
-
:param pulumi.Input[
|
|
3133
|
-
:param pulumi.Input[str] description: The group description.
|
|
3134
|
-
:param pulumi.Input[int] desired_capacity: The desired number of instances the group should have at any time.
|
|
3135
|
-
:param pulumi.Input[int] draining_timeout: The time in seconds, the instance is allowed to run while detached from the ELB. This is to allow the instance time to be drained from incoming TCP connections before terminating it, during a scale down operation.
|
|
3136
|
-
:param pulumi.Input[bool] ebs_optimized: Enable high bandwidth connectivity between instances and AWS’s Elastic Block Store (EBS). For instance types that are EBS-optimized by default this parameter will be ignored.
|
|
3137
|
-
:param pulumi.Input[Sequence[pulumi.Input[str]]] elastic_ips: A list of [AWS Elastic IP](http://docs.aws.amazon.com/AWSEC2/latest/UserGuide/elastic-ip-addresses-eip.html) allocation IDs to associate to the group instances.
|
|
3138
|
-
:param pulumi.Input[bool] enable_monitoring: Indicates whether monitoring is enabled for the instance.
|
|
3139
|
-
:param pulumi.Input[bool] fallback_to_ondemand: In a case of no Spot instances available, Elastigroup will launch on-demand instances instead.
|
|
3140
|
-
:param pulumi.Input[int] health_check_grace_period: The amount of time, in seconds, after the instance has launched to starts and check its health.
|
|
3141
|
-
:param pulumi.Input[str] health_check_type: The service that will perform health checks for the instance. Valid values: `"ELB"`, `"HCS"`, `"TARGET_GROUP"`, `"EC2"`, `"K8S_NODE"`, `"NOMAD_NODE"`, `"ECS_CLUSTER_INSTANCE"`.
|
|
3142
|
-
:param pulumi.Input[int] health_check_unhealthy_duration_before_replacement: The amount of time, in seconds, that we will wait before replacing an instance that is running and became unhealthy (this is only applicable for instances that were once healthy).
|
|
3143
|
-
:param pulumi.Input[str] iam_instance_profile: The ARN or name of an IAM instance profile to associate with launched instances.
|
|
3144
|
-
:param pulumi.Input[str] image_id: The ID of the AMI used to launch the instance.
|
|
3145
|
-
:param pulumi.Input[Sequence[pulumi.Input[
|
|
3249
|
+
:param pulumi.Input[_builtins.str] capacity_unit: The capacity unit to launch instances by. If not specified, when choosing the weight unit, each instance will weight as the number of its vCPUs. Valid values: `instance`, `weight`.
|
|
3250
|
+
:param pulumi.Input[_builtins.str] cpu_credits: Controls how T3 instances are launched. Valid values: `standard`, `unlimited`.
|
|
3251
|
+
:param pulumi.Input[Union['ElastigroupCpuOptionsArgs', 'ElastigroupCpuOptionsArgsDict']] cpu_options: The CPU options for the instances that are launched within the group:
|
|
3252
|
+
:param pulumi.Input[_builtins.str] description: The group description.
|
|
3253
|
+
:param pulumi.Input[_builtins.int] desired_capacity: The desired number of instances the group should have at any time.
|
|
3254
|
+
:param pulumi.Input[_builtins.int] draining_timeout: The time in seconds, the instance is allowed to run while detached from the ELB. This is to allow the instance time to be drained from incoming TCP connections before terminating it, during a scale down operation.
|
|
3255
|
+
:param pulumi.Input[_builtins.bool] ebs_optimized: Enable high bandwidth connectivity between instances and AWS’s Elastic Block Store (EBS). For instance types that are EBS-optimized by default this parameter will be ignored.
|
|
3256
|
+
:param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] elastic_ips: A list of [AWS Elastic IP](http://docs.aws.amazon.com/AWSEC2/latest/UserGuide/elastic-ip-addresses-eip.html) allocation IDs to associate to the group instances.
|
|
3257
|
+
:param pulumi.Input[_builtins.bool] enable_monitoring: Indicates whether monitoring is enabled for the instance.
|
|
3258
|
+
:param pulumi.Input[_builtins.bool] fallback_to_ondemand: In a case of no Spot instances available, Elastigroup will launch on-demand instances instead.
|
|
3259
|
+
:param pulumi.Input[_builtins.int] health_check_grace_period: The amount of time, in seconds, after the instance has launched to starts and check its health.
|
|
3260
|
+
:param pulumi.Input[_builtins.str] health_check_type: The service that will perform health checks for the instance. Valid values: `"ELB"`, `"HCS"`, `"TARGET_GROUP"`, `"EC2"`, `"K8S_NODE"`, `"NOMAD_NODE"`, `"ECS_CLUSTER_INSTANCE"`.
|
|
3261
|
+
:param pulumi.Input[_builtins.int] health_check_unhealthy_duration_before_replacement: The amount of time, in seconds, that we will wait before replacing an instance that is running and became unhealthy (this is only applicable for instances that were once healthy).
|
|
3262
|
+
:param pulumi.Input[_builtins.str] iam_instance_profile: The ARN or name of an IAM instance profile to associate with launched instances.
|
|
3263
|
+
:param pulumi.Input[_builtins.str] image_id: The ID of the AMI used to launch the instance.
|
|
3264
|
+
:param pulumi.Input[Sequence[pulumi.Input[Union['ElastigroupImageArgs', 'ElastigroupImageArgsDict']]]] images: An array of image objects.
|
|
3146
3265
|
Note: Elastigroup can be configured with either imageId or images, but not both.
|
|
3147
|
-
:param pulumi.Input[str] instance_types_ondemand: The type of instance determines your instance's CPU capacity, memory and storage (e.g., m1.small, c1.xlarge).
|
|
3148
|
-
:param pulumi.Input[Sequence[pulumi.Input[str]]] instance_types_preferred_spots: Prioritize a subset of spot instance types. Must be a subset of the selected spot instance types.
|
|
3149
|
-
:param pulumi.Input[Sequence[pulumi.Input[str]]] instance_types_spots: One or more instance types. Note: Cannot be defined if 'resourceRequirements' is defined.
|
|
3150
|
-
:param pulumi.Input[Sequence[pulumi.Input[
|
|
3151
|
-
:param pulumi.Input[str] key_name: The key name that should be used for the instance.
|
|
3152
|
-
:param pulumi.Input[
|
|
3153
|
-
:param pulumi.Input[int] max_size: The maximum number of instances the group should have at any time.
|
|
3154
|
-
:param pulumi.Input[
|
|
3155
|
-
:param pulumi.Input[int] min_size: The minimum number of instances the group should have at any time.
|
|
3156
|
-
:param pulumi.Input[int] minimum_instance_lifetime: Defines the preferred minimum instance lifetime in hours. Markets which comply with this preference will be prioritized. Optional values: 1, 3, 6, 12, 24.
|
|
3157
|
-
:param pulumi.Input[str] name: The group name.
|
|
3158
|
-
:param pulumi.Input[Sequence[pulumi.Input[str]]] on_demand_types: Available ondemand instance types. Note: Either ondemand or onDemandTypes must be defined, but not both.
|
|
3159
|
-
:param pulumi.Input[int] ondemand_count: Number of on demand instances to launch in the group. All other instances will be spot instances. When this parameter is set the `spot_percentage` parameter is being ignored.
|
|
3160
|
-
:param pulumi.Input[str] orientation: Select a prediction strategy. Valid values: `balanced`, `costOriented`, `equalAzDistribution`, `availabilityOriented`. You can read more in our documentation.
|
|
3161
|
-
:param pulumi.Input[str] placement_tenancy: Enable dedicated tenancy. Note: There is a flat hourly fee for each region in which dedicated tenancy is used. Valid values: "default", "dedicated" .
|
|
3162
|
-
:param pulumi.Input[Sequence[pulumi.Input[str]]] preferred_availability_zones: The AZs to prioritize when launching Spot instances. If no markets are available in the Preferred AZs, Spot instances are launched in the non-preferred AZs.
|
|
3266
|
+
:param pulumi.Input[_builtins.str] instance_types_ondemand: The type of instance determines your instance's CPU capacity, memory and storage (e.g., m1.small, c1.xlarge).
|
|
3267
|
+
:param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] instance_types_preferred_spots: Prioritize a subset of spot instance types. Must be a subset of the selected spot instance types.
|
|
3268
|
+
:param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] instance_types_spots: One or more instance types. Note: Cannot be defined if 'resourceRequirements' is defined.
|
|
3269
|
+
:param pulumi.Input[Sequence[pulumi.Input[Union['ElastigroupInstanceTypesWeightArgs', 'ElastigroupInstanceTypesWeightArgsDict']]]] instance_types_weights: List of weights per instance type for weighted groups. Each object in the list should have the following attributes:
|
|
3270
|
+
:param pulumi.Input[_builtins.str] key_name: The key name that should be used for the instance.
|
|
3271
|
+
:param pulumi.Input[Union['ElastigroupLoggingArgs', 'ElastigroupLoggingArgsDict']] logging: Logging configuration.
|
|
3272
|
+
:param pulumi.Input[_builtins.int] max_size: The maximum number of instances the group should have at any time.
|
|
3273
|
+
:param pulumi.Input[Union['ElastigroupMetadataOptionsArgs', 'ElastigroupMetadataOptionsArgsDict']] metadata_options: Data that used to configure or manage the running instances:
|
|
3274
|
+
:param pulumi.Input[_builtins.int] min_size: The minimum number of instances the group should have at any time.
|
|
3275
|
+
:param pulumi.Input[_builtins.int] minimum_instance_lifetime: Defines the preferred minimum instance lifetime in hours. Markets which comply with this preference will be prioritized. Optional values: 1, 3, 6, 12, 24.
|
|
3276
|
+
:param pulumi.Input[_builtins.str] name: The group name.
|
|
3277
|
+
:param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] on_demand_types: Available ondemand instance types. Note: Either ondemand or onDemandTypes must be defined, but not both.
|
|
3278
|
+
:param pulumi.Input[_builtins.int] ondemand_count: Number of on demand instances to launch in the group. All other instances will be spot instances. When this parameter is set the `spot_percentage` parameter is being ignored.
|
|
3279
|
+
:param pulumi.Input[_builtins.str] orientation: Select a prediction strategy. Valid values: `balanced`, `costOriented`, `equalAzDistribution`, `availabilityOriented`. You can read more in our documentation.
|
|
3280
|
+
:param pulumi.Input[_builtins.str] placement_tenancy: Enable dedicated tenancy. Note: There is a flat hourly fee for each region in which dedicated tenancy is used. Valid values: "default", "dedicated" .
|
|
3281
|
+
:param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] preferred_availability_zones: The AZs to prioritize when launching Spot instances. If no markets are available in the Preferred AZs, Spot instances are launched in the non-preferred AZs.
|
|
3163
3282
|
Note: Must be a sublist of `availability_zones` and `orientation` value must not be `"equalAzDistribution"`.
|
|
3164
|
-
:param pulumi.Input[str] product: Operation system type. Valid values: `"Linux/UNIX"`, `"SUSE Linux"`, `"Windows"`.
|
|
3165
|
-
For EC2 Classic instances:
|
|
3166
|
-
:param pulumi.Input[str] region: The AWS region your group will be created in.
|
|
3283
|
+
:param pulumi.Input[_builtins.str] product: Operation system type. Valid values: `"Linux/UNIX"`, `"SUSE Linux"`, `"Windows"`.
|
|
3284
|
+
For EC2 Classic instances: `"SUSE Linux (Amazon VPC)"`, `"Windows (Amazon VPC)"`.
|
|
3285
|
+
:param pulumi.Input[_builtins.str] region: The AWS region your group will be created in.
|
|
3167
3286
|
Note: This parameter is required if you specify subnets (through subnet_ids). This parameter is optional if you specify Availability Zones (through availability_zones).
|
|
3168
|
-
:param pulumi.Input[Sequence[pulumi.Input[
|
|
3169
|
-
:param pulumi.Input[Sequence[pulumi.Input[
|
|
3170
|
-
:param pulumi.Input[
|
|
3171
|
-
:param pulumi.Input[
|
|
3172
|
-
:param pulumi.Input[Sequence[pulumi.Input[
|
|
3173
|
-
:param pulumi.Input[str]
|
|
3174
|
-
:param pulumi.Input[
|
|
3175
|
-
:param pulumi.Input[
|
|
3287
|
+
:param pulumi.Input[Sequence[pulumi.Input[Union['ElastigroupResourceRequirementArgs', 'ElastigroupResourceRequirementArgsDict']]]] resource_requirements: Required instance attributes. Instance types will be selected based on these requirements.
|
|
3288
|
+
:param pulumi.Input[Sequence[pulumi.Input[Union['ElastigroupResourceTagSpecificationArgs', 'ElastigroupResourceTagSpecificationArgsDict']]]] resource_tag_specifications: User will specify which resources should be tagged with group tags.
|
|
3289
|
+
:param pulumi.Input[_builtins.bool] restrict_single_az: Elastigroup will automatically scale your instances in the most available and cost efficient availability zone. Every evaluation will be done when there are no active instances in the group.
|
|
3290
|
+
:param pulumi.Input[Union['ElastigroupRevertToSpotArgs', 'ElastigroupRevertToSpotArgsDict']] revert_to_spot: Hold settings for strategy correction – replacing On-Demand for Spot instances. Supported Values: `"never"`, `"always"`, `"timeWindow"`
|
|
3291
|
+
:param pulumi.Input[Sequence[pulumi.Input[Union['ElastigroupScalingStrategyArgs', 'ElastigroupScalingStrategyArgsDict']]]] scaling_strategies: Set termination policy.
|
|
3292
|
+
:param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] security_groups: A list of associated security group IDS.
|
|
3293
|
+
: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/)
|
|
3294
|
+
:param pulumi.Input[_builtins.int] spot_percentage: The percentage of Spot instances that would spin up from the `desired_capacity` number.
|
|
3295
|
+
:param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] subnet_ids: List of Strings of subnet identifiers.
|
|
3176
3296
|
Note: When this parameter is set, `availability_zones` should be left unused.
|
|
3177
|
-
:param pulumi.Input[Sequence[pulumi.Input[
|
|
3178
|
-
:param pulumi.Input[str] user_data: The user data to provide when launching the instance.
|
|
3179
|
-
:param pulumi.Input[bool] utilize_reserved_instances: In a case of any available reserved instances, Elastigroup will utilize them first before purchasing Spot instances.
|
|
3180
|
-
:param pulumi.Input[int] wait_for_capacity: Minimum number of instances in a 'HEALTHY' status that is required before continuing. This is ignored when updating with blue/green deployment. Cannot exceed `desired_capacity`.
|
|
3181
|
-
:param pulumi.Input[int] wait_for_capacity_timeout: Time (seconds) to wait for instances to report a 'HEALTHY' status. Useful for plans with multiple dependencies that take some time to initialize. Leave undefined or set to `0` to indicate no wait. This is ignored when updating with blue/green deployment.
|
|
3297
|
+
:param pulumi.Input[Sequence[pulumi.Input[Union['ElastigroupTagArgs', 'ElastigroupTagArgsDict']]]] tags: A key/value mapping of tags to assign to the resource.
|
|
3298
|
+
:param pulumi.Input[_builtins.str] user_data: The user data to provide when launching the instance.
|
|
3299
|
+
:param pulumi.Input[_builtins.bool] utilize_reserved_instances: In a case of any available reserved instances, Elastigroup will utilize them first before purchasing Spot instances.
|
|
3300
|
+
:param pulumi.Input[_builtins.int] wait_for_capacity: Minimum number of instances in a 'HEALTHY' status that is required before continuing. This is ignored when updating with blue/green deployment. Cannot exceed `desired_capacity`.
|
|
3301
|
+
:param pulumi.Input[_builtins.int] wait_for_capacity_timeout: Time (seconds) to wait for instances to report a 'HEALTHY' status. Useful for plans with multiple dependencies that take some time to initialize. Leave undefined or set to `0` to indicate no wait. This is ignored when updating with blue/green deployment.
|
|
3182
3302
|
"""
|
|
3183
3303
|
opts = pulumi.ResourceOptions.merge(opts, pulumi.ResourceOptions(id=id))
|
|
3184
3304
|
|
|
3185
3305
|
__props__ = _ElastigroupState.__new__(_ElastigroupState)
|
|
3186
3306
|
|
|
3307
|
+
__props__.__dict__["auto_healing"] = auto_healing
|
|
3187
3308
|
__props__.__dict__["availability_zones"] = availability_zones
|
|
3188
3309
|
__props__.__dict__["block_devices_mode"] = block_devices_mode
|
|
3189
3310
|
__props__.__dict__["capacity_unit"] = capacity_unit
|
|
@@ -3225,6 +3346,7 @@ class Elastigroup(pulumi.CustomResource):
|
|
|
3225
3346
|
__props__.__dict__["key_name"] = key_name
|
|
3226
3347
|
__props__.__dict__["lifetime_period"] = lifetime_period
|
|
3227
3348
|
__props__.__dict__["logging"] = logging
|
|
3349
|
+
__props__.__dict__["max_replacements_percentage"] = max_replacements_percentage
|
|
3228
3350
|
__props__.__dict__["max_size"] = max_size
|
|
3229
3351
|
__props__.__dict__["metadata_options"] = metadata_options
|
|
3230
3352
|
__props__.__dict__["min_size"] = min_size
|
|
@@ -3245,6 +3367,7 @@ class Elastigroup(pulumi.CustomResource):
|
|
|
3245
3367
|
__props__.__dict__["region"] = region
|
|
3246
3368
|
__props__.__dict__["resource_requirements"] = resource_requirements
|
|
3247
3369
|
__props__.__dict__["resource_tag_specifications"] = resource_tag_specifications
|
|
3370
|
+
__props__.__dict__["restrict_single_az"] = restrict_single_az
|
|
3248
3371
|
__props__.__dict__["revert_to_spot"] = revert_to_spot
|
|
3249
3372
|
__props__.__dict__["scaling_down_policies"] = scaling_down_policies
|
|
3250
3373
|
__props__.__dict__["scaling_strategies"] = scaling_strategies
|
|
@@ -3268,9 +3391,17 @@ class Elastigroup(pulumi.CustomResource):
|
|
|
3268
3391
|
__props__.__dict__["wait_for_capacity_timeout"] = wait_for_capacity_timeout
|
|
3269
3392
|
return Elastigroup(resource_name, opts=opts, __props__=__props__)
|
|
3270
3393
|
|
|
3271
|
-
@property
|
|
3394
|
+
@_builtins.property
|
|
3395
|
+
@pulumi.getter(name="autoHealing")
|
|
3396
|
+
def auto_healing(self) -> pulumi.Output[Optional[_builtins.bool]]:
|
|
3397
|
+
"""
|
|
3398
|
+
Auto-healing replacement won't be triggered if this parameter value is "false". In a case of a stateful group - no recycling will start if this parameter value is "false".
|
|
3399
|
+
"""
|
|
3400
|
+
return pulumi.get(self, "auto_healing")
|
|
3401
|
+
|
|
3402
|
+
@_builtins.property
|
|
3272
3403
|
@pulumi.getter(name="availabilityZones")
|
|
3273
|
-
def availability_zones(self) -> pulumi.Output[Optional[Sequence[str]]]:
|
|
3404
|
+
def availability_zones(self) -> pulumi.Output[Optional[Sequence[_builtins.str]]]:
|
|
3274
3405
|
"""
|
|
3275
3406
|
List of Strings of availability zones. When this parameter is set, `subnet_ids` should be left unused.
|
|
3276
3407
|
Note: `availability_zones` naming syntax follows the convention `availability-zone:subnet:placement-group-name`. For example, to set an AZ in `us-east-1` with subnet `subnet-123456` and placement group `ClusterI03`, you would set:
|
|
@@ -3278,33 +3409,33 @@ class Elastigroup(pulumi.CustomResource):
|
|
|
3278
3409
|
"""
|
|
3279
3410
|
return pulumi.get(self, "availability_zones")
|
|
3280
3411
|
|
|
3281
|
-
@property
|
|
3412
|
+
@_builtins.property
|
|
3282
3413
|
@pulumi.getter(name="blockDevicesMode")
|
|
3283
|
-
def block_devices_mode(self) -> pulumi.Output[Optional[str]]:
|
|
3414
|
+
def block_devices_mode(self) -> pulumi.Output[Optional[_builtins.str]]:
|
|
3284
3415
|
return pulumi.get(self, "block_devices_mode")
|
|
3285
3416
|
|
|
3286
|
-
@property
|
|
3417
|
+
@_builtins.property
|
|
3287
3418
|
@pulumi.getter(name="capacityUnit")
|
|
3288
|
-
def capacity_unit(self) -> pulumi.Output[str]:
|
|
3419
|
+
def capacity_unit(self) -> pulumi.Output[_builtins.str]:
|
|
3289
3420
|
"""
|
|
3290
3421
|
The capacity unit to launch instances by. If not specified, when choosing the weight unit, each instance will weight as the number of its vCPUs. Valid values: `instance`, `weight`.
|
|
3291
3422
|
"""
|
|
3292
3423
|
return pulumi.get(self, "capacity_unit")
|
|
3293
3424
|
|
|
3294
|
-
@property
|
|
3425
|
+
@_builtins.property
|
|
3295
3426
|
@pulumi.getter(name="considerOdPricing")
|
|
3296
|
-
def consider_od_pricing(self) -> pulumi.Output[Optional[bool]]:
|
|
3427
|
+
def consider_od_pricing(self) -> pulumi.Output[Optional[_builtins.bool]]:
|
|
3297
3428
|
return pulumi.get(self, "consider_od_pricing")
|
|
3298
3429
|
|
|
3299
|
-
@property
|
|
3430
|
+
@_builtins.property
|
|
3300
3431
|
@pulumi.getter(name="cpuCredits")
|
|
3301
|
-
def cpu_credits(self) -> pulumi.Output[Optional[str]]:
|
|
3432
|
+
def cpu_credits(self) -> pulumi.Output[Optional[_builtins.str]]:
|
|
3302
3433
|
"""
|
|
3303
3434
|
Controls how T3 instances are launched. Valid values: `standard`, `unlimited`.
|
|
3304
3435
|
"""
|
|
3305
3436
|
return pulumi.get(self, "cpu_credits")
|
|
3306
3437
|
|
|
3307
|
-
@property
|
|
3438
|
+
@_builtins.property
|
|
3308
3439
|
@pulumi.getter(name="cpuOptions")
|
|
3309
3440
|
def cpu_options(self) -> pulumi.Output[Optional['outputs.ElastigroupCpuOptions']]:
|
|
3310
3441
|
"""
|
|
@@ -3312,118 +3443,118 @@ class Elastigroup(pulumi.CustomResource):
|
|
|
3312
3443
|
"""
|
|
3313
3444
|
return pulumi.get(self, "cpu_options")
|
|
3314
3445
|
|
|
3315
|
-
@property
|
|
3446
|
+
@_builtins.property
|
|
3316
3447
|
@pulumi.getter
|
|
3317
|
-
def description(self) -> pulumi.Output[Optional[str]]:
|
|
3448
|
+
def description(self) -> pulumi.Output[Optional[_builtins.str]]:
|
|
3318
3449
|
"""
|
|
3319
3450
|
The group description.
|
|
3320
3451
|
"""
|
|
3321
3452
|
return pulumi.get(self, "description")
|
|
3322
3453
|
|
|
3323
|
-
@property
|
|
3454
|
+
@_builtins.property
|
|
3324
3455
|
@pulumi.getter(name="desiredCapacity")
|
|
3325
|
-
def desired_capacity(self) -> pulumi.Output[Optional[int]]:
|
|
3456
|
+
def desired_capacity(self) -> pulumi.Output[Optional[_builtins.int]]:
|
|
3326
3457
|
"""
|
|
3327
3458
|
The desired number of instances the group should have at any time.
|
|
3328
3459
|
"""
|
|
3329
3460
|
return pulumi.get(self, "desired_capacity")
|
|
3330
3461
|
|
|
3331
|
-
@property
|
|
3462
|
+
@_builtins.property
|
|
3332
3463
|
@pulumi.getter(name="drainingTimeout")
|
|
3333
|
-
def draining_timeout(self) -> pulumi.Output[int]:
|
|
3464
|
+
def draining_timeout(self) -> pulumi.Output[_builtins.int]:
|
|
3334
3465
|
"""
|
|
3335
3466
|
The time in seconds, the instance is allowed to run while detached from the ELB. This is to allow the instance time to be drained from incoming TCP connections before terminating it, during a scale down operation.
|
|
3336
3467
|
"""
|
|
3337
3468
|
return pulumi.get(self, "draining_timeout")
|
|
3338
3469
|
|
|
3339
|
-
@property
|
|
3470
|
+
@_builtins.property
|
|
3340
3471
|
@pulumi.getter(name="ebsBlockDevices")
|
|
3341
3472
|
def ebs_block_devices(self) -> pulumi.Output[Optional[Sequence['outputs.ElastigroupEbsBlockDevice']]]:
|
|
3342
3473
|
return pulumi.get(self, "ebs_block_devices")
|
|
3343
3474
|
|
|
3344
|
-
@property
|
|
3475
|
+
@_builtins.property
|
|
3345
3476
|
@pulumi.getter(name="ebsOptimized")
|
|
3346
|
-
def ebs_optimized(self) -> pulumi.Output[bool]:
|
|
3477
|
+
def ebs_optimized(self) -> pulumi.Output[_builtins.bool]:
|
|
3347
3478
|
"""
|
|
3348
3479
|
Enable high bandwidth connectivity between instances and AWS’s Elastic Block Store (EBS). For instance types that are EBS-optimized by default this parameter will be ignored.
|
|
3349
3480
|
"""
|
|
3350
3481
|
return pulumi.get(self, "ebs_optimized")
|
|
3351
3482
|
|
|
3352
|
-
@property
|
|
3483
|
+
@_builtins.property
|
|
3353
3484
|
@pulumi.getter(name="elasticIps")
|
|
3354
|
-
def elastic_ips(self) -> pulumi.Output[Optional[Sequence[str]]]:
|
|
3485
|
+
def elastic_ips(self) -> pulumi.Output[Optional[Sequence[_builtins.str]]]:
|
|
3355
3486
|
"""
|
|
3356
3487
|
A list of [AWS Elastic IP](http://docs.aws.amazon.com/AWSEC2/latest/UserGuide/elastic-ip-addresses-eip.html) allocation IDs to associate to the group instances.
|
|
3357
3488
|
"""
|
|
3358
3489
|
return pulumi.get(self, "elastic_ips")
|
|
3359
3490
|
|
|
3360
|
-
@property
|
|
3491
|
+
@_builtins.property
|
|
3361
3492
|
@pulumi.getter(name="elasticLoadBalancers")
|
|
3362
|
-
def elastic_load_balancers(self) -> pulumi.Output[Optional[Sequence[str]]]:
|
|
3493
|
+
def elastic_load_balancers(self) -> pulumi.Output[Optional[Sequence[_builtins.str]]]:
|
|
3363
3494
|
return pulumi.get(self, "elastic_load_balancers")
|
|
3364
3495
|
|
|
3365
|
-
@property
|
|
3496
|
+
@_builtins.property
|
|
3366
3497
|
@pulumi.getter(name="enableMonitoring")
|
|
3367
|
-
def enable_monitoring(self) -> pulumi.Output[Optional[bool]]:
|
|
3498
|
+
def enable_monitoring(self) -> pulumi.Output[Optional[_builtins.bool]]:
|
|
3368
3499
|
"""
|
|
3369
3500
|
Indicates whether monitoring is enabled for the instance.
|
|
3370
3501
|
"""
|
|
3371
3502
|
return pulumi.get(self, "enable_monitoring")
|
|
3372
3503
|
|
|
3373
|
-
@property
|
|
3504
|
+
@_builtins.property
|
|
3374
3505
|
@pulumi.getter(name="ephemeralBlockDevices")
|
|
3375
3506
|
def ephemeral_block_devices(self) -> pulumi.Output[Optional[Sequence['outputs.ElastigroupEphemeralBlockDevice']]]:
|
|
3376
3507
|
return pulumi.get(self, "ephemeral_block_devices")
|
|
3377
3508
|
|
|
3378
|
-
@property
|
|
3509
|
+
@_builtins.property
|
|
3379
3510
|
@pulumi.getter(name="fallbackToOndemand")
|
|
3380
|
-
def fallback_to_ondemand(self) -> pulumi.Output[bool]:
|
|
3511
|
+
def fallback_to_ondemand(self) -> pulumi.Output[_builtins.bool]:
|
|
3381
3512
|
"""
|
|
3382
3513
|
In a case of no Spot instances available, Elastigroup will launch on-demand instances instead.
|
|
3383
3514
|
"""
|
|
3384
3515
|
return pulumi.get(self, "fallback_to_ondemand")
|
|
3385
3516
|
|
|
3386
|
-
@property
|
|
3517
|
+
@_builtins.property
|
|
3387
3518
|
@pulumi.getter(name="healthCheckGracePeriod")
|
|
3388
|
-
def health_check_grace_period(self) -> pulumi.Output[Optional[int]]:
|
|
3519
|
+
def health_check_grace_period(self) -> pulumi.Output[Optional[_builtins.int]]:
|
|
3389
3520
|
"""
|
|
3390
3521
|
The amount of time, in seconds, after the instance has launched to starts and check its health.
|
|
3391
3522
|
"""
|
|
3392
3523
|
return pulumi.get(self, "health_check_grace_period")
|
|
3393
3524
|
|
|
3394
|
-
@property
|
|
3525
|
+
@_builtins.property
|
|
3395
3526
|
@pulumi.getter(name="healthCheckType")
|
|
3396
|
-
def health_check_type(self) -> pulumi.Output[Optional[str]]:
|
|
3527
|
+
def health_check_type(self) -> pulumi.Output[Optional[_builtins.str]]:
|
|
3397
3528
|
"""
|
|
3398
3529
|
The service that will perform health checks for the instance. Valid values: `"ELB"`, `"HCS"`, `"TARGET_GROUP"`, `"EC2"`, `"K8S_NODE"`, `"NOMAD_NODE"`, `"ECS_CLUSTER_INSTANCE"`.
|
|
3399
3530
|
"""
|
|
3400
3531
|
return pulumi.get(self, "health_check_type")
|
|
3401
3532
|
|
|
3402
|
-
@property
|
|
3533
|
+
@_builtins.property
|
|
3403
3534
|
@pulumi.getter(name="healthCheckUnhealthyDurationBeforeReplacement")
|
|
3404
|
-
def health_check_unhealthy_duration_before_replacement(self) -> pulumi.Output[Optional[int]]:
|
|
3535
|
+
def health_check_unhealthy_duration_before_replacement(self) -> pulumi.Output[Optional[_builtins.int]]:
|
|
3405
3536
|
"""
|
|
3406
3537
|
The amount of time, in seconds, that we will wait before replacing an instance that is running and became unhealthy (this is only applicable for instances that were once healthy).
|
|
3407
3538
|
"""
|
|
3408
3539
|
return pulumi.get(self, "health_check_unhealthy_duration_before_replacement")
|
|
3409
3540
|
|
|
3410
|
-
@property
|
|
3541
|
+
@_builtins.property
|
|
3411
3542
|
@pulumi.getter(name="iamInstanceProfile")
|
|
3412
|
-
def iam_instance_profile(self) -> pulumi.Output[Optional[str]]:
|
|
3543
|
+
def iam_instance_profile(self) -> pulumi.Output[Optional[_builtins.str]]:
|
|
3413
3544
|
"""
|
|
3414
3545
|
The ARN or name of an IAM instance profile to associate with launched instances.
|
|
3415
3546
|
"""
|
|
3416
3547
|
return pulumi.get(self, "iam_instance_profile")
|
|
3417
3548
|
|
|
3418
|
-
@property
|
|
3549
|
+
@_builtins.property
|
|
3419
3550
|
@pulumi.getter(name="imageId")
|
|
3420
|
-
def image_id(self) -> pulumi.Output[Optional[str]]:
|
|
3551
|
+
def image_id(self) -> pulumi.Output[Optional[_builtins.str]]:
|
|
3421
3552
|
"""
|
|
3422
3553
|
The ID of the AMI used to launch the instance.
|
|
3423
3554
|
"""
|
|
3424
3555
|
return pulumi.get(self, "image_id")
|
|
3425
3556
|
|
|
3426
|
-
@property
|
|
3557
|
+
@_builtins.property
|
|
3427
3558
|
@pulumi.getter
|
|
3428
3559
|
def images(self) -> pulumi.Output[Optional[Sequence['outputs.ElastigroupImage']]]:
|
|
3429
3560
|
"""
|
|
@@ -3432,36 +3563,36 @@ class Elastigroup(pulumi.CustomResource):
|
|
|
3432
3563
|
"""
|
|
3433
3564
|
return pulumi.get(self, "images")
|
|
3434
3565
|
|
|
3435
|
-
@property
|
|
3566
|
+
@_builtins.property
|
|
3436
3567
|
@pulumi.getter(name="immediateOdRecoverThreshold")
|
|
3437
|
-
def immediate_od_recover_threshold(self) -> pulumi.Output[Optional[int]]:
|
|
3568
|
+
def immediate_od_recover_threshold(self) -> pulumi.Output[Optional[_builtins.int]]:
|
|
3438
3569
|
return pulumi.get(self, "immediate_od_recover_threshold")
|
|
3439
3570
|
|
|
3440
|
-
@property
|
|
3571
|
+
@_builtins.property
|
|
3441
3572
|
@pulumi.getter(name="instanceTypesOndemand")
|
|
3442
|
-
def instance_types_ondemand(self) -> pulumi.Output[Optional[str]]:
|
|
3573
|
+
def instance_types_ondemand(self) -> pulumi.Output[Optional[_builtins.str]]:
|
|
3443
3574
|
"""
|
|
3444
3575
|
The type of instance determines your instance's CPU capacity, memory and storage (e.g., m1.small, c1.xlarge).
|
|
3445
3576
|
"""
|
|
3446
3577
|
return pulumi.get(self, "instance_types_ondemand")
|
|
3447
3578
|
|
|
3448
|
-
@property
|
|
3579
|
+
@_builtins.property
|
|
3449
3580
|
@pulumi.getter(name="instanceTypesPreferredSpots")
|
|
3450
|
-
def instance_types_preferred_spots(self) -> pulumi.Output[Optional[Sequence[str]]]:
|
|
3581
|
+
def instance_types_preferred_spots(self) -> pulumi.Output[Optional[Sequence[_builtins.str]]]:
|
|
3451
3582
|
"""
|
|
3452
3583
|
Prioritize a subset of spot instance types. Must be a subset of the selected spot instance types.
|
|
3453
3584
|
"""
|
|
3454
3585
|
return pulumi.get(self, "instance_types_preferred_spots")
|
|
3455
3586
|
|
|
3456
|
-
@property
|
|
3587
|
+
@_builtins.property
|
|
3457
3588
|
@pulumi.getter(name="instanceTypesSpots")
|
|
3458
|
-
def instance_types_spots(self) -> pulumi.Output[Optional[Sequence[str]]]:
|
|
3589
|
+
def instance_types_spots(self) -> pulumi.Output[Optional[Sequence[_builtins.str]]]:
|
|
3459
3590
|
"""
|
|
3460
3591
|
One or more instance types. Note: Cannot be defined if 'resourceRequirements' is defined.
|
|
3461
3592
|
"""
|
|
3462
3593
|
return pulumi.get(self, "instance_types_spots")
|
|
3463
3594
|
|
|
3464
|
-
@property
|
|
3595
|
+
@_builtins.property
|
|
3465
3596
|
@pulumi.getter(name="instanceTypesWeights")
|
|
3466
3597
|
def instance_types_weights(self) -> pulumi.Output[Optional[Sequence['outputs.ElastigroupInstanceTypesWeight']]]:
|
|
3467
3598
|
"""
|
|
@@ -3469,75 +3600,75 @@ class Elastigroup(pulumi.CustomResource):
|
|
|
3469
3600
|
"""
|
|
3470
3601
|
return pulumi.get(self, "instance_types_weights")
|
|
3471
3602
|
|
|
3472
|
-
@property
|
|
3603
|
+
@_builtins.property
|
|
3473
3604
|
@pulumi.getter(name="integrationBeanstalk")
|
|
3474
3605
|
def integration_beanstalk(self) -> pulumi.Output[Optional['outputs.ElastigroupIntegrationBeanstalk']]:
|
|
3475
3606
|
return pulumi.get(self, "integration_beanstalk")
|
|
3476
3607
|
|
|
3477
|
-
@property
|
|
3608
|
+
@_builtins.property
|
|
3478
3609
|
@pulumi.getter(name="integrationCodedeploy")
|
|
3479
3610
|
def integration_codedeploy(self) -> pulumi.Output[Optional['outputs.ElastigroupIntegrationCodedeploy']]:
|
|
3480
3611
|
return pulumi.get(self, "integration_codedeploy")
|
|
3481
3612
|
|
|
3482
|
-
@property
|
|
3613
|
+
@_builtins.property
|
|
3483
3614
|
@pulumi.getter(name="integrationDockerSwarm")
|
|
3484
3615
|
def integration_docker_swarm(self) -> pulumi.Output[Optional['outputs.ElastigroupIntegrationDockerSwarm']]:
|
|
3485
3616
|
return pulumi.get(self, "integration_docker_swarm")
|
|
3486
3617
|
|
|
3487
|
-
@property
|
|
3618
|
+
@_builtins.property
|
|
3488
3619
|
@pulumi.getter(name="integrationEcs")
|
|
3489
3620
|
def integration_ecs(self) -> pulumi.Output[Optional['outputs.ElastigroupIntegrationEcs']]:
|
|
3490
3621
|
return pulumi.get(self, "integration_ecs")
|
|
3491
3622
|
|
|
3492
|
-
@property
|
|
3623
|
+
@_builtins.property
|
|
3493
3624
|
@pulumi.getter(name="integrationGitlab")
|
|
3494
3625
|
def integration_gitlab(self) -> pulumi.Output[Optional['outputs.ElastigroupIntegrationGitlab']]:
|
|
3495
3626
|
return pulumi.get(self, "integration_gitlab")
|
|
3496
3627
|
|
|
3497
|
-
@property
|
|
3628
|
+
@_builtins.property
|
|
3498
3629
|
@pulumi.getter(name="integrationKubernetes")
|
|
3499
3630
|
def integration_kubernetes(self) -> pulumi.Output[Optional['outputs.ElastigroupIntegrationKubernetes']]:
|
|
3500
3631
|
return pulumi.get(self, "integration_kubernetes")
|
|
3501
3632
|
|
|
3502
|
-
@property
|
|
3633
|
+
@_builtins.property
|
|
3503
3634
|
@pulumi.getter(name="integrationMesosphere")
|
|
3504
3635
|
def integration_mesosphere(self) -> pulumi.Output[Optional['outputs.ElastigroupIntegrationMesosphere']]:
|
|
3505
3636
|
return pulumi.get(self, "integration_mesosphere")
|
|
3506
3637
|
|
|
3507
|
-
@property
|
|
3638
|
+
@_builtins.property
|
|
3508
3639
|
@pulumi.getter(name="integrationNomad")
|
|
3509
3640
|
def integration_nomad(self) -> pulumi.Output[Optional['outputs.ElastigroupIntegrationNomad']]:
|
|
3510
3641
|
return pulumi.get(self, "integration_nomad")
|
|
3511
3642
|
|
|
3512
|
-
@property
|
|
3643
|
+
@_builtins.property
|
|
3513
3644
|
@pulumi.getter(name="integrationRancher")
|
|
3514
3645
|
def integration_rancher(self) -> pulumi.Output[Optional['outputs.ElastigroupIntegrationRancher']]:
|
|
3515
3646
|
return pulumi.get(self, "integration_rancher")
|
|
3516
3647
|
|
|
3517
|
-
@property
|
|
3648
|
+
@_builtins.property
|
|
3518
3649
|
@pulumi.getter(name="integrationRoute53")
|
|
3519
3650
|
def integration_route53(self) -> pulumi.Output[Optional['outputs.ElastigroupIntegrationRoute53']]:
|
|
3520
3651
|
return pulumi.get(self, "integration_route53")
|
|
3521
3652
|
|
|
3522
|
-
@property
|
|
3653
|
+
@_builtins.property
|
|
3523
3654
|
@pulumi.getter
|
|
3524
3655
|
def itfs(self) -> pulumi.Output[Optional[Sequence['outputs.ElastigroupItf']]]:
|
|
3525
3656
|
return pulumi.get(self, "itfs")
|
|
3526
3657
|
|
|
3527
|
-
@property
|
|
3658
|
+
@_builtins.property
|
|
3528
3659
|
@pulumi.getter(name="keyName")
|
|
3529
|
-
def key_name(self) -> pulumi.Output[Optional[str]]:
|
|
3660
|
+
def key_name(self) -> pulumi.Output[Optional[_builtins.str]]:
|
|
3530
3661
|
"""
|
|
3531
3662
|
The key name that should be used for the instance.
|
|
3532
3663
|
"""
|
|
3533
3664
|
return pulumi.get(self, "key_name")
|
|
3534
3665
|
|
|
3535
|
-
@property
|
|
3666
|
+
@_builtins.property
|
|
3536
3667
|
@pulumi.getter(name="lifetimePeriod")
|
|
3537
|
-
def lifetime_period(self) -> pulumi.Output[Optional[str]]:
|
|
3668
|
+
def lifetime_period(self) -> pulumi.Output[Optional[_builtins.str]]:
|
|
3538
3669
|
return pulumi.get(self, "lifetime_period")
|
|
3539
3670
|
|
|
3540
|
-
@property
|
|
3671
|
+
@_builtins.property
|
|
3541
3672
|
@pulumi.getter
|
|
3542
3673
|
def logging(self) -> pulumi.Output[Optional['outputs.ElastigroupLogging']]:
|
|
3543
3674
|
"""
|
|
@@ -3545,15 +3676,20 @@ class Elastigroup(pulumi.CustomResource):
|
|
|
3545
3676
|
"""
|
|
3546
3677
|
return pulumi.get(self, "logging")
|
|
3547
3678
|
|
|
3548
|
-
@property
|
|
3679
|
+
@_builtins.property
|
|
3680
|
+
@pulumi.getter(name="maxReplacementsPercentage")
|
|
3681
|
+
def max_replacements_percentage(self) -> pulumi.Output[Optional[_builtins.int]]:
|
|
3682
|
+
return pulumi.get(self, "max_replacements_percentage")
|
|
3683
|
+
|
|
3684
|
+
@_builtins.property
|
|
3549
3685
|
@pulumi.getter(name="maxSize")
|
|
3550
|
-
def max_size(self) -> pulumi.Output[int]:
|
|
3686
|
+
def max_size(self) -> pulumi.Output[_builtins.int]:
|
|
3551
3687
|
"""
|
|
3552
3688
|
The maximum number of instances the group should have at any time.
|
|
3553
3689
|
"""
|
|
3554
3690
|
return pulumi.get(self, "max_size")
|
|
3555
3691
|
|
|
3556
|
-
@property
|
|
3692
|
+
@_builtins.property
|
|
3557
3693
|
@pulumi.getter(name="metadataOptions")
|
|
3558
3694
|
def metadata_options(self) -> pulumi.Output[Optional['outputs.ElastigroupMetadataOptions']]:
|
|
3559
3695
|
"""
|
|
@@ -3561,120 +3697,120 @@ class Elastigroup(pulumi.CustomResource):
|
|
|
3561
3697
|
"""
|
|
3562
3698
|
return pulumi.get(self, "metadata_options")
|
|
3563
3699
|
|
|
3564
|
-
@property
|
|
3700
|
+
@_builtins.property
|
|
3565
3701
|
@pulumi.getter(name="minSize")
|
|
3566
|
-
def min_size(self) -> pulumi.Output[int]:
|
|
3702
|
+
def min_size(self) -> pulumi.Output[_builtins.int]:
|
|
3567
3703
|
"""
|
|
3568
3704
|
The minimum number of instances the group should have at any time.
|
|
3569
3705
|
"""
|
|
3570
3706
|
return pulumi.get(self, "min_size")
|
|
3571
3707
|
|
|
3572
|
-
@property
|
|
3708
|
+
@_builtins.property
|
|
3573
3709
|
@pulumi.getter(name="minimumInstanceLifetime")
|
|
3574
|
-
def minimum_instance_lifetime(self) -> pulumi.Output[Optional[int]]:
|
|
3710
|
+
def minimum_instance_lifetime(self) -> pulumi.Output[Optional[_builtins.int]]:
|
|
3575
3711
|
"""
|
|
3576
3712
|
Defines the preferred minimum instance lifetime in hours. Markets which comply with this preference will be prioritized. Optional values: 1, 3, 6, 12, 24.
|
|
3577
3713
|
"""
|
|
3578
3714
|
return pulumi.get(self, "minimum_instance_lifetime")
|
|
3579
3715
|
|
|
3580
|
-
@property
|
|
3716
|
+
@_builtins.property
|
|
3581
3717
|
@pulumi.getter(name="multipleMetrics")
|
|
3582
3718
|
def multiple_metrics(self) -> pulumi.Output[Optional['outputs.ElastigroupMultipleMetrics']]:
|
|
3583
3719
|
return pulumi.get(self, "multiple_metrics")
|
|
3584
3720
|
|
|
3585
|
-
@property
|
|
3721
|
+
@_builtins.property
|
|
3586
3722
|
@pulumi.getter
|
|
3587
|
-
def name(self) -> pulumi.Output[str]:
|
|
3723
|
+
def name(self) -> pulumi.Output[_builtins.str]:
|
|
3588
3724
|
"""
|
|
3589
3725
|
The group name.
|
|
3590
3726
|
"""
|
|
3591
3727
|
return pulumi.get(self, "name")
|
|
3592
3728
|
|
|
3593
|
-
@property
|
|
3729
|
+
@_builtins.property
|
|
3594
3730
|
@pulumi.getter(name="networkInterfaces")
|
|
3595
3731
|
def network_interfaces(self) -> pulumi.Output[Optional[Sequence['outputs.ElastigroupNetworkInterface']]]:
|
|
3596
3732
|
return pulumi.get(self, "network_interfaces")
|
|
3597
3733
|
|
|
3598
|
-
@property
|
|
3734
|
+
@_builtins.property
|
|
3599
3735
|
@pulumi.getter(name="onDemandTypes")
|
|
3600
|
-
def on_demand_types(self) -> pulumi.Output[Optional[Sequence[str]]]:
|
|
3736
|
+
def on_demand_types(self) -> pulumi.Output[Optional[Sequence[_builtins.str]]]:
|
|
3601
3737
|
"""
|
|
3602
3738
|
Available ondemand instance types. Note: Either ondemand or onDemandTypes must be defined, but not both.
|
|
3603
3739
|
"""
|
|
3604
3740
|
return pulumi.get(self, "on_demand_types")
|
|
3605
3741
|
|
|
3606
|
-
@property
|
|
3742
|
+
@_builtins.property
|
|
3607
3743
|
@pulumi.getter(name="ondemandCount")
|
|
3608
|
-
def ondemand_count(self) -> pulumi.Output[Optional[int]]:
|
|
3744
|
+
def ondemand_count(self) -> pulumi.Output[Optional[_builtins.int]]:
|
|
3609
3745
|
"""
|
|
3610
3746
|
Number of on demand instances to launch in the group. All other instances will be spot instances. When this parameter is set the `spot_percentage` parameter is being ignored.
|
|
3611
3747
|
"""
|
|
3612
3748
|
return pulumi.get(self, "ondemand_count")
|
|
3613
3749
|
|
|
3614
|
-
@property
|
|
3750
|
+
@_builtins.property
|
|
3615
3751
|
@pulumi.getter
|
|
3616
|
-
def orientation(self) -> pulumi.Output[str]:
|
|
3752
|
+
def orientation(self) -> pulumi.Output[_builtins.str]:
|
|
3617
3753
|
"""
|
|
3618
3754
|
Select a prediction strategy. Valid values: `balanced`, `costOriented`, `equalAzDistribution`, `availabilityOriented`. You can read more in our documentation.
|
|
3619
3755
|
"""
|
|
3620
3756
|
return pulumi.get(self, "orientation")
|
|
3621
3757
|
|
|
3622
|
-
@property
|
|
3758
|
+
@_builtins.property
|
|
3623
3759
|
@pulumi.getter(name="persistBlockDevices")
|
|
3624
|
-
def persist_block_devices(self) -> pulumi.Output[Optional[bool]]:
|
|
3760
|
+
def persist_block_devices(self) -> pulumi.Output[Optional[_builtins.bool]]:
|
|
3625
3761
|
return pulumi.get(self, "persist_block_devices")
|
|
3626
3762
|
|
|
3627
|
-
@property
|
|
3763
|
+
@_builtins.property
|
|
3628
3764
|
@pulumi.getter(name="persistPrivateIp")
|
|
3629
|
-
def persist_private_ip(self) -> pulumi.Output[Optional[bool]]:
|
|
3765
|
+
def persist_private_ip(self) -> pulumi.Output[Optional[_builtins.bool]]:
|
|
3630
3766
|
return pulumi.get(self, "persist_private_ip")
|
|
3631
3767
|
|
|
3632
|
-
@property
|
|
3768
|
+
@_builtins.property
|
|
3633
3769
|
@pulumi.getter(name="persistRootDevice")
|
|
3634
|
-
def persist_root_device(self) -> pulumi.Output[Optional[bool]]:
|
|
3770
|
+
def persist_root_device(self) -> pulumi.Output[Optional[_builtins.bool]]:
|
|
3635
3771
|
return pulumi.get(self, "persist_root_device")
|
|
3636
3772
|
|
|
3637
|
-
@property
|
|
3773
|
+
@_builtins.property
|
|
3638
3774
|
@pulumi.getter(name="placementTenancy")
|
|
3639
|
-
def placement_tenancy(self) -> pulumi.Output[Optional[str]]:
|
|
3775
|
+
def placement_tenancy(self) -> pulumi.Output[Optional[_builtins.str]]:
|
|
3640
3776
|
"""
|
|
3641
3777
|
Enable dedicated tenancy. Note: There is a flat hourly fee for each region in which dedicated tenancy is used. Valid values: "default", "dedicated" .
|
|
3642
3778
|
"""
|
|
3643
3779
|
return pulumi.get(self, "placement_tenancy")
|
|
3644
3780
|
|
|
3645
|
-
@property
|
|
3781
|
+
@_builtins.property
|
|
3646
3782
|
@pulumi.getter(name="preferredAvailabilityZones")
|
|
3647
|
-
def preferred_availability_zones(self) -> pulumi.Output[Optional[Sequence[str]]]:
|
|
3783
|
+
def preferred_availability_zones(self) -> pulumi.Output[Optional[Sequence[_builtins.str]]]:
|
|
3648
3784
|
"""
|
|
3649
3785
|
The AZs to prioritize when launching Spot instances. If no markets are available in the Preferred AZs, Spot instances are launched in the non-preferred AZs.
|
|
3650
3786
|
Note: Must be a sublist of `availability_zones` and `orientation` value must not be `"equalAzDistribution"`.
|
|
3651
3787
|
"""
|
|
3652
3788
|
return pulumi.get(self, "preferred_availability_zones")
|
|
3653
3789
|
|
|
3654
|
-
@property
|
|
3790
|
+
@_builtins.property
|
|
3655
3791
|
@pulumi.getter(name="privateIps")
|
|
3656
|
-
def private_ips(self) -> pulumi.Output[Optional[Sequence[str]]]:
|
|
3792
|
+
def private_ips(self) -> pulumi.Output[Optional[Sequence[_builtins.str]]]:
|
|
3657
3793
|
return pulumi.get(self, "private_ips")
|
|
3658
3794
|
|
|
3659
|
-
@property
|
|
3795
|
+
@_builtins.property
|
|
3660
3796
|
@pulumi.getter
|
|
3661
|
-
def product(self) -> pulumi.Output[str]:
|
|
3797
|
+
def product(self) -> pulumi.Output[_builtins.str]:
|
|
3662
3798
|
"""
|
|
3663
3799
|
Operation system type. Valid values: `"Linux/UNIX"`, `"SUSE Linux"`, `"Windows"`.
|
|
3664
|
-
For EC2 Classic instances:
|
|
3800
|
+
For EC2 Classic instances: `"SUSE Linux (Amazon VPC)"`, `"Windows (Amazon VPC)"`.
|
|
3665
3801
|
"""
|
|
3666
3802
|
return pulumi.get(self, "product")
|
|
3667
3803
|
|
|
3668
|
-
@property
|
|
3804
|
+
@_builtins.property
|
|
3669
3805
|
@pulumi.getter
|
|
3670
|
-
def region(self) -> pulumi.Output[Optional[str]]:
|
|
3806
|
+
def region(self) -> pulumi.Output[Optional[_builtins.str]]:
|
|
3671
3807
|
"""
|
|
3672
3808
|
The AWS region your group will be created in.
|
|
3673
3809
|
Note: This parameter is required if you specify subnets (through subnet_ids). This parameter is optional if you specify Availability Zones (through availability_zones).
|
|
3674
3810
|
"""
|
|
3675
3811
|
return pulumi.get(self, "region")
|
|
3676
3812
|
|
|
3677
|
-
@property
|
|
3813
|
+
@_builtins.property
|
|
3678
3814
|
@pulumi.getter(name="resourceRequirements")
|
|
3679
3815
|
def resource_requirements(self) -> pulumi.Output[Optional[Sequence['outputs.ElastigroupResourceRequirement']]]:
|
|
3680
3816
|
"""
|
|
@@ -3682,7 +3818,7 @@ class Elastigroup(pulumi.CustomResource):
|
|
|
3682
3818
|
"""
|
|
3683
3819
|
return pulumi.get(self, "resource_requirements")
|
|
3684
3820
|
|
|
3685
|
-
@property
|
|
3821
|
+
@_builtins.property
|
|
3686
3822
|
@pulumi.getter(name="resourceTagSpecifications")
|
|
3687
3823
|
def resource_tag_specifications(self) -> pulumi.Output[Optional[Sequence['outputs.ElastigroupResourceTagSpecification']]]:
|
|
3688
3824
|
"""
|
|
@@ -3690,7 +3826,15 @@ class Elastigroup(pulumi.CustomResource):
|
|
|
3690
3826
|
"""
|
|
3691
3827
|
return pulumi.get(self, "resource_tag_specifications")
|
|
3692
3828
|
|
|
3693
|
-
@property
|
|
3829
|
+
@_builtins.property
|
|
3830
|
+
@pulumi.getter(name="restrictSingleAz")
|
|
3831
|
+
def restrict_single_az(self) -> pulumi.Output[Optional[_builtins.bool]]:
|
|
3832
|
+
"""
|
|
3833
|
+
Elastigroup will automatically scale your instances in the most available and cost efficient availability zone. Every evaluation will be done when there are no active instances in the group.
|
|
3834
|
+
"""
|
|
3835
|
+
return pulumi.get(self, "restrict_single_az")
|
|
3836
|
+
|
|
3837
|
+
@_builtins.property
|
|
3694
3838
|
@pulumi.getter(name="revertToSpot")
|
|
3695
3839
|
def revert_to_spot(self) -> pulumi.Output[Optional['outputs.ElastigroupRevertToSpot']]:
|
|
3696
3840
|
"""
|
|
@@ -3698,12 +3842,12 @@ class Elastigroup(pulumi.CustomResource):
|
|
|
3698
3842
|
"""
|
|
3699
3843
|
return pulumi.get(self, "revert_to_spot")
|
|
3700
3844
|
|
|
3701
|
-
@property
|
|
3845
|
+
@_builtins.property
|
|
3702
3846
|
@pulumi.getter(name="scalingDownPolicies")
|
|
3703
3847
|
def scaling_down_policies(self) -> pulumi.Output[Optional[Sequence['outputs.ElastigroupScalingDownPolicy']]]:
|
|
3704
3848
|
return pulumi.get(self, "scaling_down_policies")
|
|
3705
3849
|
|
|
3706
|
-
@property
|
|
3850
|
+
@_builtins.property
|
|
3707
3851
|
@pulumi.getter(name="scalingStrategies")
|
|
3708
3852
|
def scaling_strategies(self) -> pulumi.Output[Optional[Sequence['outputs.ElastigroupScalingStrategy']]]:
|
|
3709
3853
|
"""
|
|
@@ -3711,70 +3855,71 @@ class Elastigroup(pulumi.CustomResource):
|
|
|
3711
3855
|
"""
|
|
3712
3856
|
return pulumi.get(self, "scaling_strategies")
|
|
3713
3857
|
|
|
3714
|
-
@property
|
|
3858
|
+
@_builtins.property
|
|
3715
3859
|
@pulumi.getter(name="scalingTargetPolicies")
|
|
3716
3860
|
def scaling_target_policies(self) -> pulumi.Output[Optional[Sequence['outputs.ElastigroupScalingTargetPolicy']]]:
|
|
3717
3861
|
return pulumi.get(self, "scaling_target_policies")
|
|
3718
3862
|
|
|
3719
|
-
@property
|
|
3863
|
+
@_builtins.property
|
|
3720
3864
|
@pulumi.getter(name="scalingUpPolicies")
|
|
3721
3865
|
def scaling_up_policies(self) -> pulumi.Output[Optional[Sequence['outputs.ElastigroupScalingUpPolicy']]]:
|
|
3722
3866
|
return pulumi.get(self, "scaling_up_policies")
|
|
3723
3867
|
|
|
3724
|
-
@property
|
|
3868
|
+
@_builtins.property
|
|
3725
3869
|
@pulumi.getter(name="scheduledTasks")
|
|
3726
3870
|
def scheduled_tasks(self) -> pulumi.Output[Optional[Sequence['outputs.ElastigroupScheduledTask']]]:
|
|
3727
3871
|
return pulumi.get(self, "scheduled_tasks")
|
|
3728
3872
|
|
|
3729
|
-
@property
|
|
3873
|
+
@_builtins.property
|
|
3730
3874
|
@pulumi.getter(name="securityGroups")
|
|
3731
|
-
def security_groups(self) -> pulumi.Output[Sequence[str]]:
|
|
3875
|
+
def security_groups(self) -> pulumi.Output[Sequence[_builtins.str]]:
|
|
3732
3876
|
"""
|
|
3733
3877
|
A list of associated security group IDS.
|
|
3734
3878
|
"""
|
|
3735
3879
|
return pulumi.get(self, "security_groups")
|
|
3736
3880
|
|
|
3737
|
-
@property
|
|
3881
|
+
@_builtins.property
|
|
3738
3882
|
@pulumi.getter(name="shutdownScript")
|
|
3739
|
-
def shutdown_script(self) -> pulumi.Output[Optional[str]]:
|
|
3883
|
+
def shutdown_script(self) -> pulumi.Output[Optional[_builtins.str]]:
|
|
3740
3884
|
"""
|
|
3741
3885
|
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/)
|
|
3742
3886
|
"""
|
|
3743
3887
|
return pulumi.get(self, "shutdown_script")
|
|
3744
3888
|
|
|
3745
|
-
@property
|
|
3889
|
+
@_builtins.property
|
|
3746
3890
|
@pulumi.getter
|
|
3747
3891
|
def signals(self) -> pulumi.Output[Optional[Sequence['outputs.ElastigroupSignal']]]:
|
|
3748
3892
|
return pulumi.get(self, "signals")
|
|
3749
3893
|
|
|
3750
|
-
@property
|
|
3894
|
+
@_builtins.property
|
|
3751
3895
|
@pulumi.getter(name="spotPercentage")
|
|
3752
|
-
def spot_percentage(self) -> pulumi.Output[Optional[int]]:
|
|
3896
|
+
def spot_percentage(self) -> pulumi.Output[Optional[_builtins.int]]:
|
|
3753
3897
|
"""
|
|
3754
3898
|
The percentage of Spot instances that would spin up from the `desired_capacity` number.
|
|
3755
3899
|
"""
|
|
3756
3900
|
return pulumi.get(self, "spot_percentage")
|
|
3757
3901
|
|
|
3758
|
-
@property
|
|
3902
|
+
@_builtins.property
|
|
3759
3903
|
@pulumi.getter(name="statefulDeallocation")
|
|
3760
3904
|
def stateful_deallocation(self) -> pulumi.Output[Optional['outputs.ElastigroupStatefulDeallocation']]:
|
|
3761
3905
|
return pulumi.get(self, "stateful_deallocation")
|
|
3762
3906
|
|
|
3763
|
-
@property
|
|
3907
|
+
@_builtins.property
|
|
3764
3908
|
@pulumi.getter(name="statefulInstanceActions")
|
|
3765
3909
|
def stateful_instance_actions(self) -> pulumi.Output[Optional[Sequence['outputs.ElastigroupStatefulInstanceAction']]]:
|
|
3766
3910
|
return pulumi.get(self, "stateful_instance_actions")
|
|
3767
3911
|
|
|
3768
|
-
@property
|
|
3912
|
+
@_builtins.property
|
|
3769
3913
|
@pulumi.getter(name="subnetIds")
|
|
3770
|
-
|
|
3914
|
+
@_utilities.deprecated("""This field will soon be deprecated and handled by availability_zones""")
|
|
3915
|
+
def subnet_ids(self) -> pulumi.Output[Optional[Sequence[_builtins.str]]]:
|
|
3771
3916
|
"""
|
|
3772
3917
|
List of Strings of subnet identifiers.
|
|
3773
3918
|
Note: When this parameter is set, `availability_zones` should be left unused.
|
|
3774
3919
|
"""
|
|
3775
3920
|
return pulumi.get(self, "subnet_ids")
|
|
3776
3921
|
|
|
3777
|
-
@property
|
|
3922
|
+
@_builtins.property
|
|
3778
3923
|
@pulumi.getter
|
|
3779
3924
|
def tags(self) -> pulumi.Output[Optional[Sequence['outputs.ElastigroupTag']]]:
|
|
3780
3925
|
"""
|
|
@@ -3782,48 +3927,48 @@ class Elastigroup(pulumi.CustomResource):
|
|
|
3782
3927
|
"""
|
|
3783
3928
|
return pulumi.get(self, "tags")
|
|
3784
3929
|
|
|
3785
|
-
@property
|
|
3930
|
+
@_builtins.property
|
|
3786
3931
|
@pulumi.getter(name="targetGroupArns")
|
|
3787
|
-
def target_group_arns(self) -> pulumi.Output[Optional[Sequence[str]]]:
|
|
3932
|
+
def target_group_arns(self) -> pulumi.Output[Optional[Sequence[_builtins.str]]]:
|
|
3788
3933
|
return pulumi.get(self, "target_group_arns")
|
|
3789
3934
|
|
|
3790
|
-
@property
|
|
3935
|
+
@_builtins.property
|
|
3791
3936
|
@pulumi.getter(name="updatePolicy")
|
|
3792
3937
|
def update_policy(self) -> pulumi.Output[Optional['outputs.ElastigroupUpdatePolicy']]:
|
|
3793
3938
|
return pulumi.get(self, "update_policy")
|
|
3794
3939
|
|
|
3795
|
-
@property
|
|
3940
|
+
@_builtins.property
|
|
3796
3941
|
@pulumi.getter(name="userData")
|
|
3797
|
-
def user_data(self) -> pulumi.Output[Optional[str]]:
|
|
3942
|
+
def user_data(self) -> pulumi.Output[Optional[_builtins.str]]:
|
|
3798
3943
|
"""
|
|
3799
3944
|
The user data to provide when launching the instance.
|
|
3800
3945
|
"""
|
|
3801
3946
|
return pulumi.get(self, "user_data")
|
|
3802
3947
|
|
|
3803
|
-
@property
|
|
3948
|
+
@_builtins.property
|
|
3804
3949
|
@pulumi.getter(name="utilizeCommitments")
|
|
3805
|
-
def utilize_commitments(self) -> pulumi.Output[Optional[bool]]:
|
|
3950
|
+
def utilize_commitments(self) -> pulumi.Output[Optional[_builtins.bool]]:
|
|
3806
3951
|
return pulumi.get(self, "utilize_commitments")
|
|
3807
3952
|
|
|
3808
|
-
@property
|
|
3953
|
+
@_builtins.property
|
|
3809
3954
|
@pulumi.getter(name="utilizeReservedInstances")
|
|
3810
|
-
def utilize_reserved_instances(self) -> pulumi.Output[Optional[bool]]:
|
|
3955
|
+
def utilize_reserved_instances(self) -> pulumi.Output[Optional[_builtins.bool]]:
|
|
3811
3956
|
"""
|
|
3812
3957
|
In a case of any available reserved instances, Elastigroup will utilize them first before purchasing Spot instances.
|
|
3813
3958
|
"""
|
|
3814
3959
|
return pulumi.get(self, "utilize_reserved_instances")
|
|
3815
3960
|
|
|
3816
|
-
@property
|
|
3961
|
+
@_builtins.property
|
|
3817
3962
|
@pulumi.getter(name="waitForCapacity")
|
|
3818
|
-
def wait_for_capacity(self) -> pulumi.Output[Optional[int]]:
|
|
3963
|
+
def wait_for_capacity(self) -> pulumi.Output[Optional[_builtins.int]]:
|
|
3819
3964
|
"""
|
|
3820
3965
|
Minimum number of instances in a 'HEALTHY' status that is required before continuing. This is ignored when updating with blue/green deployment. Cannot exceed `desired_capacity`.
|
|
3821
3966
|
"""
|
|
3822
3967
|
return pulumi.get(self, "wait_for_capacity")
|
|
3823
3968
|
|
|
3824
|
-
@property
|
|
3969
|
+
@_builtins.property
|
|
3825
3970
|
@pulumi.getter(name="waitForCapacityTimeout")
|
|
3826
|
-
def wait_for_capacity_timeout(self) -> pulumi.Output[Optional[int]]:
|
|
3971
|
+
def wait_for_capacity_timeout(self) -> pulumi.Output[Optional[_builtins.int]]:
|
|
3827
3972
|
"""
|
|
3828
3973
|
Time (seconds) to wait for instances to report a 'HEALTHY' status. Useful for plans with multiple dependencies that take some time to initialize. Leave undefined or set to `0` to indicate no wait. This is ignored when updating with blue/green deployment.
|
|
3829
3974
|
"""
|