pulumi-spotinst 3.115.0a1742873189__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 +11 -1
- pulumi_spotinst/_inputs.py +2206 -1519
- pulumi_spotinst/_utilities.py +1 -1
- pulumi_spotinst/account.py +20 -19
- pulumi_spotinst/aws/__init__.py +2 -1
- pulumi_spotinst/aws/_inputs.py +3991 -3619
- pulumi_spotinst/aws/account.py +20 -19
- pulumi_spotinst/aws/beanstalk.py +254 -177
- pulumi_spotinst/aws/credentials.py +37 -36
- pulumi_spotinst/aws/elastigroup.py +938 -950
- pulumi_spotinst/aws/managed_instance.py +507 -506
- pulumi_spotinst/aws/mr_scalar.py +658 -653
- pulumi_spotinst/aws/ocean.py +624 -529
- pulumi_spotinst/aws/ocean_extended_resource_definition.py +37 -36
- pulumi_spotinst/aws/ocean_launch_spec.py +395 -300
- pulumi_spotinst/aws/outputs.py +2631 -2371
- pulumi_spotinst/aws/suspension.py +23 -22
- pulumi_spotinst/azure/__init__.py +2 -1
- pulumi_spotinst/azure/_inputs.py +607 -607
- pulumi_spotinst/azure/ocean_np.py +387 -386
- pulumi_spotinst/azure/ocean_np_virtual_node_group.py +323 -322
- pulumi_spotinst/azure/outputs.py +411 -411
- pulumi_spotinst/config/__init__.py +2 -1
- pulumi_spotinst/config/__init__.pyi +2 -2
- pulumi_spotinst/config/vars.py +6 -6
- pulumi_spotinst/credentials_azure.py +139 -89
- pulumi_spotinst/credentials_gcp.py +190 -189
- pulumi_spotinst/data_integration.py +40 -39
- pulumi_spotinst/ecs/__init__.py +2 -1
- pulumi_spotinst/ecs/_inputs.py +584 -584
- pulumi_spotinst/ecs/ocean.py +628 -415
- pulumi_spotinst/ecs/ocean_launch_spec.py +197 -196
- pulumi_spotinst/ecs/outputs.py +394 -394
- pulumi_spotinst/elastigroup_azure_v3.py +326 -325
- pulumi_spotinst/gcp/__init__.py +2 -1
- pulumi_spotinst/gcp/_inputs.py +573 -499
- pulumi_spotinst/gcp/elastigroup.py +491 -482
- pulumi_spotinst/gcp/outputs.py +395 -330
- pulumi_spotinst/gke/__init__.py +2 -1
- pulumi_spotinst/gke/_inputs.py +1120 -895
- pulumi_spotinst/gke/elastigroup.py +341 -340
- pulumi_spotinst/gke/ocean_import.py +204 -203
- pulumi_spotinst/gke/ocean_launch_spec.py +285 -213
- pulumi_spotinst/gke/ocean_launch_spec_import.py +37 -36
- pulumi_spotinst/gke/outputs.py +769 -583
- pulumi_spotinst/health_check.py +106 -65
- pulumi_spotinst/notification_center.py +344 -0
- pulumi_spotinst/ocean_right_sizing_rule.py +424 -77
- pulumi_spotinst/oceancd/__init__.py +2 -1
- pulumi_spotinst/oceancd/_inputs.py +764 -764
- pulumi_spotinst/oceancd/outputs.py +526 -526
- pulumi_spotinst/oceancd/rollout_spec.py +35 -34
- pulumi_spotinst/oceancd/strategy.py +22 -21
- pulumi_spotinst/oceancd/verification_provider.py +52 -51
- pulumi_spotinst/oceancd/verification_template.py +26 -25
- pulumi_spotinst/organization/__init__.py +2 -1
- pulumi_spotinst/organization/_inputs.py +68 -68
- pulumi_spotinst/organization/outputs.py +46 -46
- pulumi_spotinst/organization/policy.py +40 -39
- pulumi_spotinst/organization/programmatic_user.py +60 -59
- pulumi_spotinst/organization/user.py +108 -107
- pulumi_spotinst/organization/user_group.py +57 -56
- pulumi_spotinst/outputs.py +1472 -932
- pulumi_spotinst/provider.py +61 -40
- pulumi_spotinst/pulumi-plugin.json +1 -1
- pulumi_spotinst/spark/__init__.py +2 -1
- pulumi_spotinst/spark/_inputs.py +104 -104
- pulumi_spotinst/spark/ocean.py +38 -37
- pulumi_spotinst/spark/ocean_virtual_node_group.py +29 -28
- pulumi_spotinst/spark/outputs.py +72 -72
- pulumi_spotinst/stateful_node_azure.py +318 -343
- pulumi_spotinst/subscription.py +88 -87
- {pulumi_spotinst-3.115.0a1742873189.dist-info → pulumi_spotinst-3.128.0a1767140134.dist-info}/METADATA +3 -3
- pulumi_spotinst-3.128.0a1767140134.dist-info/RECORD +77 -0
- {pulumi_spotinst-3.115.0a1742873189.dist-info → pulumi_spotinst-3.128.0a1767140134.dist-info}/WHEEL +1 -1
- pulumi_spotinst-3.115.0a1742873189.dist-info/RECORD +0 -76
- {pulumi_spotinst-3.115.0a1742873189.dist-info → pulumi_spotinst-3.128.0a1767140134.dist-info}/top_level.txt +0 -0
|
@@ -1,8 +1,8 @@
|
|
|
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
7
|
import sys
|
|
8
8
|
import pulumi
|
|
@@ -21,36 +21,36 @@ __all__ = ['ElastigroupArgs', 'Elastigroup']
|
|
|
21
21
|
@pulumi.input_type
|
|
22
22
|
class ElastigroupArgs:
|
|
23
23
|
def __init__(__self__, *,
|
|
24
|
-
fallback_to_ondemand: pulumi.Input[bool],
|
|
25
|
-
orientation: pulumi.Input[str],
|
|
26
|
-
product: pulumi.Input[str],
|
|
27
|
-
security_groups: pulumi.Input[Sequence[pulumi.Input[str]]],
|
|
28
|
-
auto_healing: Optional[pulumi.Input[bool]] = None,
|
|
29
|
-
availability_zones: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
|
|
30
|
-
block_devices_mode: Optional[pulumi.Input[str]] = None,
|
|
31
|
-
capacity_unit: Optional[pulumi.Input[str]] = None,
|
|
32
|
-
consider_od_pricing: Optional[pulumi.Input[bool]] = None,
|
|
33
|
-
cpu_credits: Optional[pulumi.Input[str]] = None,
|
|
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,
|
|
34
34
|
cpu_options: Optional[pulumi.Input['ElastigroupCpuOptionsArgs']] = None,
|
|
35
|
-
description: Optional[pulumi.Input[str]] = None,
|
|
36
|
-
desired_capacity: Optional[pulumi.Input[int]] = None,
|
|
37
|
-
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,
|
|
38
38
|
ebs_block_devices: Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupEbsBlockDeviceArgs']]]] = None,
|
|
39
|
-
ebs_optimized: Optional[pulumi.Input[bool]] = None,
|
|
40
|
-
elastic_ips: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
|
|
41
|
-
elastic_load_balancers: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
|
|
42
|
-
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,
|
|
43
43
|
ephemeral_block_devices: Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupEphemeralBlockDeviceArgs']]]] = None,
|
|
44
|
-
health_check_grace_period: Optional[pulumi.Input[int]] = None,
|
|
45
|
-
health_check_type: Optional[pulumi.Input[str]] = None,
|
|
46
|
-
health_check_unhealthy_duration_before_replacement: Optional[pulumi.Input[int]] = None,
|
|
47
|
-
iam_instance_profile: Optional[pulumi.Input[str]] = None,
|
|
48
|
-
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,
|
|
49
49
|
images: Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupImageArgs']]]] = None,
|
|
50
|
-
immediate_od_recover_threshold: Optional[pulumi.Input[int]] = None,
|
|
51
|
-
instance_types_ondemand: Optional[pulumi.Input[str]] = None,
|
|
52
|
-
instance_types_preferred_spots: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
|
|
53
|
-
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,
|
|
54
54
|
instance_types_weights: Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupInstanceTypesWeightArgs']]]] = None,
|
|
55
55
|
integration_beanstalk: Optional[pulumi.Input['ElastigroupIntegrationBeanstalkArgs']] = None,
|
|
56
56
|
integration_codedeploy: Optional[pulumi.Input['ElastigroupIntegrationCodedeployArgs']] = None,
|
|
@@ -63,109 +63,108 @@ class ElastigroupArgs:
|
|
|
63
63
|
integration_rancher: Optional[pulumi.Input['ElastigroupIntegrationRancherArgs']] = None,
|
|
64
64
|
integration_route53: Optional[pulumi.Input['ElastigroupIntegrationRoute53Args']] = None,
|
|
65
65
|
itfs: Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupItfArgs']]]] = None,
|
|
66
|
-
key_name: Optional[pulumi.Input[str]] = None,
|
|
67
|
-
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,
|
|
68
68
|
logging: Optional[pulumi.Input['ElastigroupLoggingArgs']] = None,
|
|
69
|
-
max_replacements_percentage: Optional[pulumi.Input[int]] = None,
|
|
70
|
-
max_size: Optional[pulumi.Input[int]] = None,
|
|
69
|
+
max_replacements_percentage: Optional[pulumi.Input[_builtins.int]] = None,
|
|
70
|
+
max_size: Optional[pulumi.Input[_builtins.int]] = None,
|
|
71
71
|
metadata_options: Optional[pulumi.Input['ElastigroupMetadataOptionsArgs']] = None,
|
|
72
|
-
min_size: Optional[pulumi.Input[int]] = None,
|
|
73
|
-
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,
|
|
74
74
|
multiple_metrics: Optional[pulumi.Input['ElastigroupMultipleMetricsArgs']] = None,
|
|
75
|
-
name: Optional[pulumi.Input[str]] = None,
|
|
75
|
+
name: Optional[pulumi.Input[_builtins.str]] = None,
|
|
76
76
|
network_interfaces: Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupNetworkInterfaceArgs']]]] = None,
|
|
77
|
-
on_demand_types: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
|
|
78
|
-
ondemand_count: Optional[pulumi.Input[int]] = None,
|
|
79
|
-
persist_block_devices: Optional[pulumi.Input[bool]] = None,
|
|
80
|
-
persist_private_ip: Optional[pulumi.Input[bool]] = None,
|
|
81
|
-
persist_root_device: Optional[pulumi.Input[bool]] = None,
|
|
82
|
-
placement_tenancy: Optional[pulumi.Input[str]] = None,
|
|
83
|
-
preferred_availability_zones: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
|
|
84
|
-
private_ips: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
|
|
85
|
-
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,
|
|
86
86
|
resource_requirements: Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupResourceRequirementArgs']]]] = None,
|
|
87
87
|
resource_tag_specifications: Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupResourceTagSpecificationArgs']]]] = None,
|
|
88
|
-
restrict_single_az: Optional[pulumi.Input[bool]] = None,
|
|
88
|
+
restrict_single_az: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
89
89
|
revert_to_spot: Optional[pulumi.Input['ElastigroupRevertToSpotArgs']] = None,
|
|
90
90
|
scaling_down_policies: Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupScalingDownPolicyArgs']]]] = None,
|
|
91
91
|
scaling_strategies: Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupScalingStrategyArgs']]]] = None,
|
|
92
92
|
scaling_target_policies: Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupScalingTargetPolicyArgs']]]] = None,
|
|
93
93
|
scaling_up_policies: Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupScalingUpPolicyArgs']]]] = None,
|
|
94
94
|
scheduled_tasks: Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupScheduledTaskArgs']]]] = None,
|
|
95
|
-
shutdown_script: Optional[pulumi.Input[str]] = None,
|
|
95
|
+
shutdown_script: Optional[pulumi.Input[_builtins.str]] = None,
|
|
96
96
|
signals: Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupSignalArgs']]]] = None,
|
|
97
|
-
spot_percentage: Optional[pulumi.Input[int]] = None,
|
|
97
|
+
spot_percentage: Optional[pulumi.Input[_builtins.int]] = None,
|
|
98
98
|
stateful_deallocation: Optional[pulumi.Input['ElastigroupStatefulDeallocationArgs']] = None,
|
|
99
99
|
stateful_instance_actions: Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupStatefulInstanceActionArgs']]]] = None,
|
|
100
|
-
subnet_ids: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
|
|
100
|
+
subnet_ids: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
101
101
|
tags: Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupTagArgs']]]] = None,
|
|
102
|
-
target_group_arns: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
|
|
102
|
+
target_group_arns: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
103
103
|
update_policy: Optional[pulumi.Input['ElastigroupUpdatePolicyArgs']] = None,
|
|
104
|
-
user_data: Optional[pulumi.Input[str]] = None,
|
|
105
|
-
utilize_commitments: Optional[pulumi.Input[bool]] = None,
|
|
106
|
-
utilize_reserved_instances: Optional[pulumi.Input[bool]] = None,
|
|
107
|
-
wait_for_capacity: Optional[pulumi.Input[int]] = None,
|
|
108
|
-
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):
|
|
109
109
|
"""
|
|
110
110
|
The set of arguments for constructing a Elastigroup resource.
|
|
111
|
-
:param pulumi.Input[bool] fallback_to_ondemand: In a case of no Spot instances available, Elastigroup will launch on-demand instances instead.
|
|
112
|
-
:param pulumi.Input[str] orientation: Select a prediction strategy. Valid values: `balanced`, `costOriented`, `equalAzDistribution`, `availabilityOriented`. You can read more in our documentation.
|
|
113
|
-
:param pulumi.Input[str] product: Operation system type. Valid values: `"Linux/UNIX"`, `"SUSE Linux"`, `"Windows"`.
|
|
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
114
|
For EC2 Classic instances: `"SUSE Linux (Amazon VPC)"`, `"Windows (Amazon VPC)"`.
|
|
115
|
-
:param pulumi.Input[Sequence[pulumi.Input[str]]] security_groups: A list of associated security group IDS.
|
|
116
|
-
:param pulumi.Input[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[str]]] availability_zones: List of Strings of availability zones. When this parameter is set, `subnet_ids` should be left unused.
|
|
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.
|
|
118
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:
|
|
119
119
|
`availability_zones = ["us-east-1a:subnet-123456:ClusterI03"]`
|
|
120
|
-
: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`.
|
|
121
|
-
: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`.
|
|
122
122
|
:param pulumi.Input['ElastigroupCpuOptionsArgs'] cpu_options: The CPU options for the instances that are launched within the group:
|
|
123
|
-
:param pulumi.Input[str] description: The group description.
|
|
124
|
-
:param pulumi.Input[int] desired_capacity: The desired number of instances the group should have at any time.
|
|
125
|
-
: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.
|
|
126
|
-
: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.
|
|
127
|
-
: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.
|
|
128
|
-
:param pulumi.Input[bool] enable_monitoring: Indicates whether monitoring is enabled for the instance.
|
|
129
|
-
: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.
|
|
130
|
-
: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"`.
|
|
131
|
-
: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).
|
|
132
|
-
:param pulumi.Input[str] iam_instance_profile: The ARN or name of an IAM instance profile to associate with launched instances.
|
|
133
|
-
: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.
|
|
134
134
|
:param pulumi.Input[Sequence[pulumi.Input['ElastigroupImageArgs']]] images: An array of image objects.
|
|
135
135
|
Note: Elastigroup can be configured with either imageId or images, but not both.
|
|
136
|
-
: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).
|
|
137
|
-
: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.
|
|
138
|
-
: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.
|
|
139
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:
|
|
140
|
-
: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.
|
|
141
141
|
:param pulumi.Input['ElastigroupLoggingArgs'] logging: Logging configuration.
|
|
142
|
-
:param pulumi.Input[int]
|
|
143
|
-
: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.
|
|
144
143
|
:param pulumi.Input['ElastigroupMetadataOptionsArgs'] metadata_options: Data that used to configure or manage the running instances:
|
|
145
|
-
:param pulumi.Input[int] min_size: The minimum number of instances the group should have at any time.
|
|
146
|
-
: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.
|
|
147
|
-
:param pulumi.Input[str] name: The group name.
|
|
148
|
-
: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.
|
|
149
|
-
: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.
|
|
150
|
-
: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" .
|
|
151
|
-
: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.
|
|
152
151
|
Note: Must be a sublist of `availability_zones` and `orientation` value must not be `"equalAzDistribution"`.
|
|
153
|
-
: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.
|
|
154
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).
|
|
155
154
|
:param pulumi.Input[Sequence[pulumi.Input['ElastigroupResourceRequirementArgs']]] resource_requirements: Required instance attributes. Instance types will be selected based on these requirements.
|
|
156
155
|
:param pulumi.Input[Sequence[pulumi.Input['ElastigroupResourceTagSpecificationArgs']]] resource_tag_specifications: User will specify which resources should be tagged with group tags.
|
|
157
|
-
:param pulumi.Input[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.
|
|
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.
|
|
158
157
|
:param pulumi.Input['ElastigroupRevertToSpotArgs'] revert_to_spot: Hold settings for strategy correction – replacing On-Demand for Spot instances. Supported Values: `"never"`, `"always"`, `"timeWindow"`
|
|
159
158
|
:param pulumi.Input[Sequence[pulumi.Input['ElastigroupScalingStrategyArgs']]] scaling_strategies: Set termination policy.
|
|
160
|
-
: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/)
|
|
161
|
-
:param pulumi.Input[int] spot_percentage: The percentage of Spot instances that would spin up from the `desired_capacity` number.
|
|
162
|
-
: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.
|
|
163
162
|
Note: When this parameter is set, `availability_zones` should be left unused.
|
|
164
163
|
:param pulumi.Input[Sequence[pulumi.Input['ElastigroupTagArgs']]] tags: A key/value mapping of tags to assign to the resource.
|
|
165
|
-
:param pulumi.Input[str] user_data: The user data to provide when launching the instance.
|
|
166
|
-
:param pulumi.Input[bool] utilize_reserved_instances: In a case of any available reserved instances, Elastigroup will utilize them first before purchasing Spot instances.
|
|
167
|
-
: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`.
|
|
168
|
-
: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.
|
|
169
168
|
"""
|
|
170
169
|
pulumi.set(__self__, "fallback_to_ondemand", fallback_to_ondemand)
|
|
171
170
|
pulumi.set(__self__, "orientation", orientation)
|
|
@@ -337,33 +336,33 @@ class ElastigroupArgs:
|
|
|
337
336
|
if wait_for_capacity_timeout is not None:
|
|
338
337
|
pulumi.set(__self__, "wait_for_capacity_timeout", wait_for_capacity_timeout)
|
|
339
338
|
|
|
340
|
-
@property
|
|
339
|
+
@_builtins.property
|
|
341
340
|
@pulumi.getter(name="fallbackToOndemand")
|
|
342
|
-
def fallback_to_ondemand(self) -> pulumi.Input[bool]:
|
|
341
|
+
def fallback_to_ondemand(self) -> pulumi.Input[_builtins.bool]:
|
|
343
342
|
"""
|
|
344
343
|
In a case of no Spot instances available, Elastigroup will launch on-demand instances instead.
|
|
345
344
|
"""
|
|
346
345
|
return pulumi.get(self, "fallback_to_ondemand")
|
|
347
346
|
|
|
348
347
|
@fallback_to_ondemand.setter
|
|
349
|
-
def fallback_to_ondemand(self, value: pulumi.Input[bool]):
|
|
348
|
+
def fallback_to_ondemand(self, value: pulumi.Input[_builtins.bool]):
|
|
350
349
|
pulumi.set(self, "fallback_to_ondemand", value)
|
|
351
350
|
|
|
352
|
-
@property
|
|
351
|
+
@_builtins.property
|
|
353
352
|
@pulumi.getter
|
|
354
|
-
def orientation(self) -> pulumi.Input[str]:
|
|
353
|
+
def orientation(self) -> pulumi.Input[_builtins.str]:
|
|
355
354
|
"""
|
|
356
355
|
Select a prediction strategy. Valid values: `balanced`, `costOriented`, `equalAzDistribution`, `availabilityOriented`. You can read more in our documentation.
|
|
357
356
|
"""
|
|
358
357
|
return pulumi.get(self, "orientation")
|
|
359
358
|
|
|
360
359
|
@orientation.setter
|
|
361
|
-
def orientation(self, value: pulumi.Input[str]):
|
|
360
|
+
def orientation(self, value: pulumi.Input[_builtins.str]):
|
|
362
361
|
pulumi.set(self, "orientation", value)
|
|
363
362
|
|
|
364
|
-
@property
|
|
363
|
+
@_builtins.property
|
|
365
364
|
@pulumi.getter
|
|
366
|
-
def product(self) -> pulumi.Input[str]:
|
|
365
|
+
def product(self) -> pulumi.Input[_builtins.str]:
|
|
367
366
|
"""
|
|
368
367
|
Operation system type. Valid values: `"Linux/UNIX"`, `"SUSE Linux"`, `"Windows"`.
|
|
369
368
|
For EC2 Classic instances: `"SUSE Linux (Amazon VPC)"`, `"Windows (Amazon VPC)"`.
|
|
@@ -371,36 +370,36 @@ class ElastigroupArgs:
|
|
|
371
370
|
return pulumi.get(self, "product")
|
|
372
371
|
|
|
373
372
|
@product.setter
|
|
374
|
-
def product(self, value: pulumi.Input[str]):
|
|
373
|
+
def product(self, value: pulumi.Input[_builtins.str]):
|
|
375
374
|
pulumi.set(self, "product", value)
|
|
376
375
|
|
|
377
|
-
@property
|
|
376
|
+
@_builtins.property
|
|
378
377
|
@pulumi.getter(name="securityGroups")
|
|
379
|
-
def security_groups(self) -> pulumi.Input[Sequence[pulumi.Input[str]]]:
|
|
378
|
+
def security_groups(self) -> pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]:
|
|
380
379
|
"""
|
|
381
380
|
A list of associated security group IDS.
|
|
382
381
|
"""
|
|
383
382
|
return pulumi.get(self, "security_groups")
|
|
384
383
|
|
|
385
384
|
@security_groups.setter
|
|
386
|
-
def security_groups(self, value: pulumi.Input[Sequence[pulumi.Input[str]]]):
|
|
385
|
+
def security_groups(self, value: pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]):
|
|
387
386
|
pulumi.set(self, "security_groups", value)
|
|
388
387
|
|
|
389
|
-
@property
|
|
388
|
+
@_builtins.property
|
|
390
389
|
@pulumi.getter(name="autoHealing")
|
|
391
|
-
def auto_healing(self) -> Optional[pulumi.Input[bool]]:
|
|
390
|
+
def auto_healing(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
392
391
|
"""
|
|
393
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".
|
|
394
393
|
"""
|
|
395
394
|
return pulumi.get(self, "auto_healing")
|
|
396
395
|
|
|
397
396
|
@auto_healing.setter
|
|
398
|
-
def auto_healing(self, value: Optional[pulumi.Input[bool]]):
|
|
397
|
+
def auto_healing(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
399
398
|
pulumi.set(self, "auto_healing", value)
|
|
400
399
|
|
|
401
|
-
@property
|
|
400
|
+
@_builtins.property
|
|
402
401
|
@pulumi.getter(name="availabilityZones")
|
|
403
|
-
def availability_zones(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
|
|
402
|
+
def availability_zones(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
|
|
404
403
|
"""
|
|
405
404
|
List of Strings of availability zones. When this parameter is set, `subnet_ids` should be left unused.
|
|
406
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:
|
|
@@ -409,52 +408,52 @@ class ElastigroupArgs:
|
|
|
409
408
|
return pulumi.get(self, "availability_zones")
|
|
410
409
|
|
|
411
410
|
@availability_zones.setter
|
|
412
|
-
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]]]]):
|
|
413
412
|
pulumi.set(self, "availability_zones", value)
|
|
414
413
|
|
|
415
|
-
@property
|
|
414
|
+
@_builtins.property
|
|
416
415
|
@pulumi.getter(name="blockDevicesMode")
|
|
417
|
-
def block_devices_mode(self) -> Optional[pulumi.Input[str]]:
|
|
416
|
+
def block_devices_mode(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
418
417
|
return pulumi.get(self, "block_devices_mode")
|
|
419
418
|
|
|
420
419
|
@block_devices_mode.setter
|
|
421
|
-
def block_devices_mode(self, value: Optional[pulumi.Input[str]]):
|
|
420
|
+
def block_devices_mode(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
422
421
|
pulumi.set(self, "block_devices_mode", value)
|
|
423
422
|
|
|
424
|
-
@property
|
|
423
|
+
@_builtins.property
|
|
425
424
|
@pulumi.getter(name="capacityUnit")
|
|
426
|
-
def capacity_unit(self) -> Optional[pulumi.Input[str]]:
|
|
425
|
+
def capacity_unit(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
427
426
|
"""
|
|
428
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`.
|
|
429
428
|
"""
|
|
430
429
|
return pulumi.get(self, "capacity_unit")
|
|
431
430
|
|
|
432
431
|
@capacity_unit.setter
|
|
433
|
-
def capacity_unit(self, value: Optional[pulumi.Input[str]]):
|
|
432
|
+
def capacity_unit(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
434
433
|
pulumi.set(self, "capacity_unit", value)
|
|
435
434
|
|
|
436
|
-
@property
|
|
435
|
+
@_builtins.property
|
|
437
436
|
@pulumi.getter(name="considerOdPricing")
|
|
438
|
-
def consider_od_pricing(self) -> Optional[pulumi.Input[bool]]:
|
|
437
|
+
def consider_od_pricing(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
439
438
|
return pulumi.get(self, "consider_od_pricing")
|
|
440
439
|
|
|
441
440
|
@consider_od_pricing.setter
|
|
442
|
-
def consider_od_pricing(self, value: Optional[pulumi.Input[bool]]):
|
|
441
|
+
def consider_od_pricing(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
443
442
|
pulumi.set(self, "consider_od_pricing", value)
|
|
444
443
|
|
|
445
|
-
@property
|
|
444
|
+
@_builtins.property
|
|
446
445
|
@pulumi.getter(name="cpuCredits")
|
|
447
|
-
def cpu_credits(self) -> Optional[pulumi.Input[str]]:
|
|
446
|
+
def cpu_credits(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
448
447
|
"""
|
|
449
448
|
Controls how T3 instances are launched. Valid values: `standard`, `unlimited`.
|
|
450
449
|
"""
|
|
451
450
|
return pulumi.get(self, "cpu_credits")
|
|
452
451
|
|
|
453
452
|
@cpu_credits.setter
|
|
454
|
-
def cpu_credits(self, value: Optional[pulumi.Input[str]]):
|
|
453
|
+
def cpu_credits(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
455
454
|
pulumi.set(self, "cpu_credits", value)
|
|
456
455
|
|
|
457
|
-
@property
|
|
456
|
+
@_builtins.property
|
|
458
457
|
@pulumi.getter(name="cpuOptions")
|
|
459
458
|
def cpu_options(self) -> Optional[pulumi.Input['ElastigroupCpuOptionsArgs']]:
|
|
460
459
|
"""
|
|
@@ -466,43 +465,43 @@ class ElastigroupArgs:
|
|
|
466
465
|
def cpu_options(self, value: Optional[pulumi.Input['ElastigroupCpuOptionsArgs']]):
|
|
467
466
|
pulumi.set(self, "cpu_options", value)
|
|
468
467
|
|
|
469
|
-
@property
|
|
468
|
+
@_builtins.property
|
|
470
469
|
@pulumi.getter
|
|
471
|
-
def description(self) -> Optional[pulumi.Input[str]]:
|
|
470
|
+
def description(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
472
471
|
"""
|
|
473
472
|
The group description.
|
|
474
473
|
"""
|
|
475
474
|
return pulumi.get(self, "description")
|
|
476
475
|
|
|
477
476
|
@description.setter
|
|
478
|
-
def description(self, value: Optional[pulumi.Input[str]]):
|
|
477
|
+
def description(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
479
478
|
pulumi.set(self, "description", value)
|
|
480
479
|
|
|
481
|
-
@property
|
|
480
|
+
@_builtins.property
|
|
482
481
|
@pulumi.getter(name="desiredCapacity")
|
|
483
|
-
def desired_capacity(self) -> Optional[pulumi.Input[int]]:
|
|
482
|
+
def desired_capacity(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
484
483
|
"""
|
|
485
484
|
The desired number of instances the group should have at any time.
|
|
486
485
|
"""
|
|
487
486
|
return pulumi.get(self, "desired_capacity")
|
|
488
487
|
|
|
489
488
|
@desired_capacity.setter
|
|
490
|
-
def desired_capacity(self, value: Optional[pulumi.Input[int]]):
|
|
489
|
+
def desired_capacity(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
491
490
|
pulumi.set(self, "desired_capacity", value)
|
|
492
491
|
|
|
493
|
-
@property
|
|
492
|
+
@_builtins.property
|
|
494
493
|
@pulumi.getter(name="drainingTimeout")
|
|
495
|
-
def draining_timeout(self) -> Optional[pulumi.Input[int]]:
|
|
494
|
+
def draining_timeout(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
496
495
|
"""
|
|
497
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.
|
|
498
497
|
"""
|
|
499
498
|
return pulumi.get(self, "draining_timeout")
|
|
500
499
|
|
|
501
500
|
@draining_timeout.setter
|
|
502
|
-
def draining_timeout(self, value: Optional[pulumi.Input[int]]):
|
|
501
|
+
def draining_timeout(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
503
502
|
pulumi.set(self, "draining_timeout", value)
|
|
504
503
|
|
|
505
|
-
@property
|
|
504
|
+
@_builtins.property
|
|
506
505
|
@pulumi.getter(name="ebsBlockDevices")
|
|
507
506
|
def ebs_block_devices(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupEbsBlockDeviceArgs']]]]:
|
|
508
507
|
return pulumi.get(self, "ebs_block_devices")
|
|
@@ -511,52 +510,52 @@ class ElastigroupArgs:
|
|
|
511
510
|
def ebs_block_devices(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupEbsBlockDeviceArgs']]]]):
|
|
512
511
|
pulumi.set(self, "ebs_block_devices", value)
|
|
513
512
|
|
|
514
|
-
@property
|
|
513
|
+
@_builtins.property
|
|
515
514
|
@pulumi.getter(name="ebsOptimized")
|
|
516
|
-
def ebs_optimized(self) -> Optional[pulumi.Input[bool]]:
|
|
515
|
+
def ebs_optimized(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
517
516
|
"""
|
|
518
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.
|
|
519
518
|
"""
|
|
520
519
|
return pulumi.get(self, "ebs_optimized")
|
|
521
520
|
|
|
522
521
|
@ebs_optimized.setter
|
|
523
|
-
def ebs_optimized(self, value: Optional[pulumi.Input[bool]]):
|
|
522
|
+
def ebs_optimized(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
524
523
|
pulumi.set(self, "ebs_optimized", value)
|
|
525
524
|
|
|
526
|
-
@property
|
|
525
|
+
@_builtins.property
|
|
527
526
|
@pulumi.getter(name="elasticIps")
|
|
528
|
-
def elastic_ips(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
|
|
527
|
+
def elastic_ips(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
|
|
529
528
|
"""
|
|
530
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.
|
|
531
530
|
"""
|
|
532
531
|
return pulumi.get(self, "elastic_ips")
|
|
533
532
|
|
|
534
533
|
@elastic_ips.setter
|
|
535
|
-
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]]]]):
|
|
536
535
|
pulumi.set(self, "elastic_ips", value)
|
|
537
536
|
|
|
538
|
-
@property
|
|
537
|
+
@_builtins.property
|
|
539
538
|
@pulumi.getter(name="elasticLoadBalancers")
|
|
540
|
-
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]]]]:
|
|
541
540
|
return pulumi.get(self, "elastic_load_balancers")
|
|
542
541
|
|
|
543
542
|
@elastic_load_balancers.setter
|
|
544
|
-
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]]]]):
|
|
545
544
|
pulumi.set(self, "elastic_load_balancers", value)
|
|
546
545
|
|
|
547
|
-
@property
|
|
546
|
+
@_builtins.property
|
|
548
547
|
@pulumi.getter(name="enableMonitoring")
|
|
549
|
-
def enable_monitoring(self) -> Optional[pulumi.Input[bool]]:
|
|
548
|
+
def enable_monitoring(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
550
549
|
"""
|
|
551
550
|
Indicates whether monitoring is enabled for the instance.
|
|
552
551
|
"""
|
|
553
552
|
return pulumi.get(self, "enable_monitoring")
|
|
554
553
|
|
|
555
554
|
@enable_monitoring.setter
|
|
556
|
-
def enable_monitoring(self, value: Optional[pulumi.Input[bool]]):
|
|
555
|
+
def enable_monitoring(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
557
556
|
pulumi.set(self, "enable_monitoring", value)
|
|
558
557
|
|
|
559
|
-
@property
|
|
558
|
+
@_builtins.property
|
|
560
559
|
@pulumi.getter(name="ephemeralBlockDevices")
|
|
561
560
|
def ephemeral_block_devices(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupEphemeralBlockDeviceArgs']]]]:
|
|
562
561
|
return pulumi.get(self, "ephemeral_block_devices")
|
|
@@ -565,67 +564,67 @@ class ElastigroupArgs:
|
|
|
565
564
|
def ephemeral_block_devices(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupEphemeralBlockDeviceArgs']]]]):
|
|
566
565
|
pulumi.set(self, "ephemeral_block_devices", value)
|
|
567
566
|
|
|
568
|
-
@property
|
|
567
|
+
@_builtins.property
|
|
569
568
|
@pulumi.getter(name="healthCheckGracePeriod")
|
|
570
|
-
def health_check_grace_period(self) -> Optional[pulumi.Input[int]]:
|
|
569
|
+
def health_check_grace_period(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
571
570
|
"""
|
|
572
571
|
The amount of time, in seconds, after the instance has launched to starts and check its health.
|
|
573
572
|
"""
|
|
574
573
|
return pulumi.get(self, "health_check_grace_period")
|
|
575
574
|
|
|
576
575
|
@health_check_grace_period.setter
|
|
577
|
-
def health_check_grace_period(self, value: Optional[pulumi.Input[int]]):
|
|
576
|
+
def health_check_grace_period(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
578
577
|
pulumi.set(self, "health_check_grace_period", value)
|
|
579
578
|
|
|
580
|
-
@property
|
|
579
|
+
@_builtins.property
|
|
581
580
|
@pulumi.getter(name="healthCheckType")
|
|
582
|
-
def health_check_type(self) -> Optional[pulumi.Input[str]]:
|
|
581
|
+
def health_check_type(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
583
582
|
"""
|
|
584
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"`.
|
|
585
584
|
"""
|
|
586
585
|
return pulumi.get(self, "health_check_type")
|
|
587
586
|
|
|
588
587
|
@health_check_type.setter
|
|
589
|
-
def health_check_type(self, value: Optional[pulumi.Input[str]]):
|
|
588
|
+
def health_check_type(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
590
589
|
pulumi.set(self, "health_check_type", value)
|
|
591
590
|
|
|
592
|
-
@property
|
|
591
|
+
@_builtins.property
|
|
593
592
|
@pulumi.getter(name="healthCheckUnhealthyDurationBeforeReplacement")
|
|
594
|
-
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]]:
|
|
595
594
|
"""
|
|
596
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).
|
|
597
596
|
"""
|
|
598
597
|
return pulumi.get(self, "health_check_unhealthy_duration_before_replacement")
|
|
599
598
|
|
|
600
599
|
@health_check_unhealthy_duration_before_replacement.setter
|
|
601
|
-
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]]):
|
|
602
601
|
pulumi.set(self, "health_check_unhealthy_duration_before_replacement", value)
|
|
603
602
|
|
|
604
|
-
@property
|
|
603
|
+
@_builtins.property
|
|
605
604
|
@pulumi.getter(name="iamInstanceProfile")
|
|
606
|
-
def iam_instance_profile(self) -> Optional[pulumi.Input[str]]:
|
|
605
|
+
def iam_instance_profile(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
607
606
|
"""
|
|
608
607
|
The ARN or name of an IAM instance profile to associate with launched instances.
|
|
609
608
|
"""
|
|
610
609
|
return pulumi.get(self, "iam_instance_profile")
|
|
611
610
|
|
|
612
611
|
@iam_instance_profile.setter
|
|
613
|
-
def iam_instance_profile(self, value: Optional[pulumi.Input[str]]):
|
|
612
|
+
def iam_instance_profile(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
614
613
|
pulumi.set(self, "iam_instance_profile", value)
|
|
615
614
|
|
|
616
|
-
@property
|
|
615
|
+
@_builtins.property
|
|
617
616
|
@pulumi.getter(name="imageId")
|
|
618
|
-
def image_id(self) -> Optional[pulumi.Input[str]]:
|
|
617
|
+
def image_id(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
619
618
|
"""
|
|
620
619
|
The ID of the AMI used to launch the instance.
|
|
621
620
|
"""
|
|
622
621
|
return pulumi.get(self, "image_id")
|
|
623
622
|
|
|
624
623
|
@image_id.setter
|
|
625
|
-
def image_id(self, value: Optional[pulumi.Input[str]]):
|
|
624
|
+
def image_id(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
626
625
|
pulumi.set(self, "image_id", value)
|
|
627
626
|
|
|
628
|
-
@property
|
|
627
|
+
@_builtins.property
|
|
629
628
|
@pulumi.getter
|
|
630
629
|
def images(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupImageArgs']]]]:
|
|
631
630
|
"""
|
|
@@ -638,52 +637,52 @@ class ElastigroupArgs:
|
|
|
638
637
|
def images(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupImageArgs']]]]):
|
|
639
638
|
pulumi.set(self, "images", value)
|
|
640
639
|
|
|
641
|
-
@property
|
|
640
|
+
@_builtins.property
|
|
642
641
|
@pulumi.getter(name="immediateOdRecoverThreshold")
|
|
643
|
-
def immediate_od_recover_threshold(self) -> Optional[pulumi.Input[int]]:
|
|
642
|
+
def immediate_od_recover_threshold(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
644
643
|
return pulumi.get(self, "immediate_od_recover_threshold")
|
|
645
644
|
|
|
646
645
|
@immediate_od_recover_threshold.setter
|
|
647
|
-
def immediate_od_recover_threshold(self, value: Optional[pulumi.Input[int]]):
|
|
646
|
+
def immediate_od_recover_threshold(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
648
647
|
pulumi.set(self, "immediate_od_recover_threshold", value)
|
|
649
648
|
|
|
650
|
-
@property
|
|
649
|
+
@_builtins.property
|
|
651
650
|
@pulumi.getter(name="instanceTypesOndemand")
|
|
652
|
-
def instance_types_ondemand(self) -> Optional[pulumi.Input[str]]:
|
|
651
|
+
def instance_types_ondemand(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
653
652
|
"""
|
|
654
653
|
The type of instance determines your instance's CPU capacity, memory and storage (e.g., m1.small, c1.xlarge).
|
|
655
654
|
"""
|
|
656
655
|
return pulumi.get(self, "instance_types_ondemand")
|
|
657
656
|
|
|
658
657
|
@instance_types_ondemand.setter
|
|
659
|
-
def instance_types_ondemand(self, value: Optional[pulumi.Input[str]]):
|
|
658
|
+
def instance_types_ondemand(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
660
659
|
pulumi.set(self, "instance_types_ondemand", value)
|
|
661
660
|
|
|
662
|
-
@property
|
|
661
|
+
@_builtins.property
|
|
663
662
|
@pulumi.getter(name="instanceTypesPreferredSpots")
|
|
664
|
-
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]]]]:
|
|
665
664
|
"""
|
|
666
665
|
Prioritize a subset of spot instance types. Must be a subset of the selected spot instance types.
|
|
667
666
|
"""
|
|
668
667
|
return pulumi.get(self, "instance_types_preferred_spots")
|
|
669
668
|
|
|
670
669
|
@instance_types_preferred_spots.setter
|
|
671
|
-
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]]]]):
|
|
672
671
|
pulumi.set(self, "instance_types_preferred_spots", value)
|
|
673
672
|
|
|
674
|
-
@property
|
|
673
|
+
@_builtins.property
|
|
675
674
|
@pulumi.getter(name="instanceTypesSpots")
|
|
676
|
-
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]]]]:
|
|
677
676
|
"""
|
|
678
677
|
One or more instance types. Note: Cannot be defined if 'resourceRequirements' is defined.
|
|
679
678
|
"""
|
|
680
679
|
return pulumi.get(self, "instance_types_spots")
|
|
681
680
|
|
|
682
681
|
@instance_types_spots.setter
|
|
683
|
-
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]]]]):
|
|
684
683
|
pulumi.set(self, "instance_types_spots", value)
|
|
685
684
|
|
|
686
|
-
@property
|
|
685
|
+
@_builtins.property
|
|
687
686
|
@pulumi.getter(name="instanceTypesWeights")
|
|
688
687
|
def instance_types_weights(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupInstanceTypesWeightArgs']]]]:
|
|
689
688
|
"""
|
|
@@ -695,7 +694,7 @@ class ElastigroupArgs:
|
|
|
695
694
|
def instance_types_weights(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupInstanceTypesWeightArgs']]]]):
|
|
696
695
|
pulumi.set(self, "instance_types_weights", value)
|
|
697
696
|
|
|
698
|
-
@property
|
|
697
|
+
@_builtins.property
|
|
699
698
|
@pulumi.getter(name="integrationBeanstalk")
|
|
700
699
|
def integration_beanstalk(self) -> Optional[pulumi.Input['ElastigroupIntegrationBeanstalkArgs']]:
|
|
701
700
|
return pulumi.get(self, "integration_beanstalk")
|
|
@@ -704,7 +703,7 @@ class ElastigroupArgs:
|
|
|
704
703
|
def integration_beanstalk(self, value: Optional[pulumi.Input['ElastigroupIntegrationBeanstalkArgs']]):
|
|
705
704
|
pulumi.set(self, "integration_beanstalk", value)
|
|
706
705
|
|
|
707
|
-
@property
|
|
706
|
+
@_builtins.property
|
|
708
707
|
@pulumi.getter(name="integrationCodedeploy")
|
|
709
708
|
def integration_codedeploy(self) -> Optional[pulumi.Input['ElastigroupIntegrationCodedeployArgs']]:
|
|
710
709
|
return pulumi.get(self, "integration_codedeploy")
|
|
@@ -713,7 +712,7 @@ class ElastigroupArgs:
|
|
|
713
712
|
def integration_codedeploy(self, value: Optional[pulumi.Input['ElastigroupIntegrationCodedeployArgs']]):
|
|
714
713
|
pulumi.set(self, "integration_codedeploy", value)
|
|
715
714
|
|
|
716
|
-
@property
|
|
715
|
+
@_builtins.property
|
|
717
716
|
@pulumi.getter(name="integrationDockerSwarm")
|
|
718
717
|
def integration_docker_swarm(self) -> Optional[pulumi.Input['ElastigroupIntegrationDockerSwarmArgs']]:
|
|
719
718
|
return pulumi.get(self, "integration_docker_swarm")
|
|
@@ -722,7 +721,7 @@ class ElastigroupArgs:
|
|
|
722
721
|
def integration_docker_swarm(self, value: Optional[pulumi.Input['ElastigroupIntegrationDockerSwarmArgs']]):
|
|
723
722
|
pulumi.set(self, "integration_docker_swarm", value)
|
|
724
723
|
|
|
725
|
-
@property
|
|
724
|
+
@_builtins.property
|
|
726
725
|
@pulumi.getter(name="integrationEcs")
|
|
727
726
|
def integration_ecs(self) -> Optional[pulumi.Input['ElastigroupIntegrationEcsArgs']]:
|
|
728
727
|
return pulumi.get(self, "integration_ecs")
|
|
@@ -731,7 +730,7 @@ class ElastigroupArgs:
|
|
|
731
730
|
def integration_ecs(self, value: Optional[pulumi.Input['ElastigroupIntegrationEcsArgs']]):
|
|
732
731
|
pulumi.set(self, "integration_ecs", value)
|
|
733
732
|
|
|
734
|
-
@property
|
|
733
|
+
@_builtins.property
|
|
735
734
|
@pulumi.getter(name="integrationGitlab")
|
|
736
735
|
def integration_gitlab(self) -> Optional[pulumi.Input['ElastigroupIntegrationGitlabArgs']]:
|
|
737
736
|
return pulumi.get(self, "integration_gitlab")
|
|
@@ -740,7 +739,7 @@ class ElastigroupArgs:
|
|
|
740
739
|
def integration_gitlab(self, value: Optional[pulumi.Input['ElastigroupIntegrationGitlabArgs']]):
|
|
741
740
|
pulumi.set(self, "integration_gitlab", value)
|
|
742
741
|
|
|
743
|
-
@property
|
|
742
|
+
@_builtins.property
|
|
744
743
|
@pulumi.getter(name="integrationKubernetes")
|
|
745
744
|
def integration_kubernetes(self) -> Optional[pulumi.Input['ElastigroupIntegrationKubernetesArgs']]:
|
|
746
745
|
return pulumi.get(self, "integration_kubernetes")
|
|
@@ -749,7 +748,7 @@ class ElastigroupArgs:
|
|
|
749
748
|
def integration_kubernetes(self, value: Optional[pulumi.Input['ElastigroupIntegrationKubernetesArgs']]):
|
|
750
749
|
pulumi.set(self, "integration_kubernetes", value)
|
|
751
750
|
|
|
752
|
-
@property
|
|
751
|
+
@_builtins.property
|
|
753
752
|
@pulumi.getter(name="integrationMesosphere")
|
|
754
753
|
def integration_mesosphere(self) -> Optional[pulumi.Input['ElastigroupIntegrationMesosphereArgs']]:
|
|
755
754
|
return pulumi.get(self, "integration_mesosphere")
|
|
@@ -758,7 +757,7 @@ class ElastigroupArgs:
|
|
|
758
757
|
def integration_mesosphere(self, value: Optional[pulumi.Input['ElastigroupIntegrationMesosphereArgs']]):
|
|
759
758
|
pulumi.set(self, "integration_mesosphere", value)
|
|
760
759
|
|
|
761
|
-
@property
|
|
760
|
+
@_builtins.property
|
|
762
761
|
@pulumi.getter(name="integrationNomad")
|
|
763
762
|
def integration_nomad(self) -> Optional[pulumi.Input['ElastigroupIntegrationNomadArgs']]:
|
|
764
763
|
return pulumi.get(self, "integration_nomad")
|
|
@@ -767,7 +766,7 @@ class ElastigroupArgs:
|
|
|
767
766
|
def integration_nomad(self, value: Optional[pulumi.Input['ElastigroupIntegrationNomadArgs']]):
|
|
768
767
|
pulumi.set(self, "integration_nomad", value)
|
|
769
768
|
|
|
770
|
-
@property
|
|
769
|
+
@_builtins.property
|
|
771
770
|
@pulumi.getter(name="integrationRancher")
|
|
772
771
|
def integration_rancher(self) -> Optional[pulumi.Input['ElastigroupIntegrationRancherArgs']]:
|
|
773
772
|
return pulumi.get(self, "integration_rancher")
|
|
@@ -776,7 +775,7 @@ class ElastigroupArgs:
|
|
|
776
775
|
def integration_rancher(self, value: Optional[pulumi.Input['ElastigroupIntegrationRancherArgs']]):
|
|
777
776
|
pulumi.set(self, "integration_rancher", value)
|
|
778
777
|
|
|
779
|
-
@property
|
|
778
|
+
@_builtins.property
|
|
780
779
|
@pulumi.getter(name="integrationRoute53")
|
|
781
780
|
def integration_route53(self) -> Optional[pulumi.Input['ElastigroupIntegrationRoute53Args']]:
|
|
782
781
|
return pulumi.get(self, "integration_route53")
|
|
@@ -785,7 +784,7 @@ class ElastigroupArgs:
|
|
|
785
784
|
def integration_route53(self, value: Optional[pulumi.Input['ElastigroupIntegrationRoute53Args']]):
|
|
786
785
|
pulumi.set(self, "integration_route53", value)
|
|
787
786
|
|
|
788
|
-
@property
|
|
787
|
+
@_builtins.property
|
|
789
788
|
@pulumi.getter
|
|
790
789
|
def itfs(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupItfArgs']]]]:
|
|
791
790
|
return pulumi.get(self, "itfs")
|
|
@@ -794,28 +793,28 @@ class ElastigroupArgs:
|
|
|
794
793
|
def itfs(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupItfArgs']]]]):
|
|
795
794
|
pulumi.set(self, "itfs", value)
|
|
796
795
|
|
|
797
|
-
@property
|
|
796
|
+
@_builtins.property
|
|
798
797
|
@pulumi.getter(name="keyName")
|
|
799
|
-
def key_name(self) -> Optional[pulumi.Input[str]]:
|
|
798
|
+
def key_name(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
800
799
|
"""
|
|
801
800
|
The key name that should be used for the instance.
|
|
802
801
|
"""
|
|
803
802
|
return pulumi.get(self, "key_name")
|
|
804
803
|
|
|
805
804
|
@key_name.setter
|
|
806
|
-
def key_name(self, value: Optional[pulumi.Input[str]]):
|
|
805
|
+
def key_name(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
807
806
|
pulumi.set(self, "key_name", value)
|
|
808
807
|
|
|
809
|
-
@property
|
|
808
|
+
@_builtins.property
|
|
810
809
|
@pulumi.getter(name="lifetimePeriod")
|
|
811
|
-
def lifetime_period(self) -> Optional[pulumi.Input[str]]:
|
|
810
|
+
def lifetime_period(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
812
811
|
return pulumi.get(self, "lifetime_period")
|
|
813
812
|
|
|
814
813
|
@lifetime_period.setter
|
|
815
|
-
def lifetime_period(self, value: Optional[pulumi.Input[str]]):
|
|
814
|
+
def lifetime_period(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
816
815
|
pulumi.set(self, "lifetime_period", value)
|
|
817
816
|
|
|
818
|
-
@property
|
|
817
|
+
@_builtins.property
|
|
819
818
|
@pulumi.getter
|
|
820
819
|
def logging(self) -> Optional[pulumi.Input['ElastigroupLoggingArgs']]:
|
|
821
820
|
"""
|
|
@@ -827,31 +826,28 @@ class ElastigroupArgs:
|
|
|
827
826
|
def logging(self, value: Optional[pulumi.Input['ElastigroupLoggingArgs']]):
|
|
828
827
|
pulumi.set(self, "logging", value)
|
|
829
828
|
|
|
830
|
-
@property
|
|
829
|
+
@_builtins.property
|
|
831
830
|
@pulumi.getter(name="maxReplacementsPercentage")
|
|
832
|
-
def max_replacements_percentage(self) -> Optional[pulumi.Input[int]]:
|
|
833
|
-
"""
|
|
834
|
-
The percentage of active instances that can be replaced in parallel. This is used to prevent a large number of instances from being replaced at once.
|
|
835
|
-
"""
|
|
831
|
+
def max_replacements_percentage(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
836
832
|
return pulumi.get(self, "max_replacements_percentage")
|
|
837
833
|
|
|
838
834
|
@max_replacements_percentage.setter
|
|
839
|
-
def max_replacements_percentage(self, value: Optional[pulumi.Input[int]]):
|
|
835
|
+
def max_replacements_percentage(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
840
836
|
pulumi.set(self, "max_replacements_percentage", value)
|
|
841
837
|
|
|
842
|
-
@property
|
|
838
|
+
@_builtins.property
|
|
843
839
|
@pulumi.getter(name="maxSize")
|
|
844
|
-
def max_size(self) -> Optional[pulumi.Input[int]]:
|
|
840
|
+
def max_size(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
845
841
|
"""
|
|
846
842
|
The maximum number of instances the group should have at any time.
|
|
847
843
|
"""
|
|
848
844
|
return pulumi.get(self, "max_size")
|
|
849
845
|
|
|
850
846
|
@max_size.setter
|
|
851
|
-
def max_size(self, value: Optional[pulumi.Input[int]]):
|
|
847
|
+
def max_size(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
852
848
|
pulumi.set(self, "max_size", value)
|
|
853
849
|
|
|
854
|
-
@property
|
|
850
|
+
@_builtins.property
|
|
855
851
|
@pulumi.getter(name="metadataOptions")
|
|
856
852
|
def metadata_options(self) -> Optional[pulumi.Input['ElastigroupMetadataOptionsArgs']]:
|
|
857
853
|
"""
|
|
@@ -863,31 +859,31 @@ class ElastigroupArgs:
|
|
|
863
859
|
def metadata_options(self, value: Optional[pulumi.Input['ElastigroupMetadataOptionsArgs']]):
|
|
864
860
|
pulumi.set(self, "metadata_options", value)
|
|
865
861
|
|
|
866
|
-
@property
|
|
862
|
+
@_builtins.property
|
|
867
863
|
@pulumi.getter(name="minSize")
|
|
868
|
-
def min_size(self) -> Optional[pulumi.Input[int]]:
|
|
864
|
+
def min_size(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
869
865
|
"""
|
|
870
866
|
The minimum number of instances the group should have at any time.
|
|
871
867
|
"""
|
|
872
868
|
return pulumi.get(self, "min_size")
|
|
873
869
|
|
|
874
870
|
@min_size.setter
|
|
875
|
-
def min_size(self, value: Optional[pulumi.Input[int]]):
|
|
871
|
+
def min_size(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
876
872
|
pulumi.set(self, "min_size", value)
|
|
877
873
|
|
|
878
|
-
@property
|
|
874
|
+
@_builtins.property
|
|
879
875
|
@pulumi.getter(name="minimumInstanceLifetime")
|
|
880
|
-
def minimum_instance_lifetime(self) -> Optional[pulumi.Input[int]]:
|
|
876
|
+
def minimum_instance_lifetime(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
881
877
|
"""
|
|
882
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.
|
|
883
879
|
"""
|
|
884
880
|
return pulumi.get(self, "minimum_instance_lifetime")
|
|
885
881
|
|
|
886
882
|
@minimum_instance_lifetime.setter
|
|
887
|
-
def minimum_instance_lifetime(self, value: Optional[pulumi.Input[int]]):
|
|
883
|
+
def minimum_instance_lifetime(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
888
884
|
pulumi.set(self, "minimum_instance_lifetime", value)
|
|
889
885
|
|
|
890
|
-
@property
|
|
886
|
+
@_builtins.property
|
|
891
887
|
@pulumi.getter(name="multipleMetrics")
|
|
892
888
|
def multiple_metrics(self) -> Optional[pulumi.Input['ElastigroupMultipleMetricsArgs']]:
|
|
893
889
|
return pulumi.get(self, "multiple_metrics")
|
|
@@ -896,19 +892,19 @@ class ElastigroupArgs:
|
|
|
896
892
|
def multiple_metrics(self, value: Optional[pulumi.Input['ElastigroupMultipleMetricsArgs']]):
|
|
897
893
|
pulumi.set(self, "multiple_metrics", value)
|
|
898
894
|
|
|
899
|
-
@property
|
|
895
|
+
@_builtins.property
|
|
900
896
|
@pulumi.getter
|
|
901
|
-
def name(self) -> Optional[pulumi.Input[str]]:
|
|
897
|
+
def name(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
902
898
|
"""
|
|
903
899
|
The group name.
|
|
904
900
|
"""
|
|
905
901
|
return pulumi.get(self, "name")
|
|
906
902
|
|
|
907
903
|
@name.setter
|
|
908
|
-
def name(self, value: Optional[pulumi.Input[str]]):
|
|
904
|
+
def name(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
909
905
|
pulumi.set(self, "name", value)
|
|
910
906
|
|
|
911
|
-
@property
|
|
907
|
+
@_builtins.property
|
|
912
908
|
@pulumi.getter(name="networkInterfaces")
|
|
913
909
|
def network_interfaces(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupNetworkInterfaceArgs']]]]:
|
|
914
910
|
return pulumi.get(self, "network_interfaces")
|
|
@@ -917,72 +913,72 @@ class ElastigroupArgs:
|
|
|
917
913
|
def network_interfaces(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupNetworkInterfaceArgs']]]]):
|
|
918
914
|
pulumi.set(self, "network_interfaces", value)
|
|
919
915
|
|
|
920
|
-
@property
|
|
916
|
+
@_builtins.property
|
|
921
917
|
@pulumi.getter(name="onDemandTypes")
|
|
922
|
-
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]]]]:
|
|
923
919
|
"""
|
|
924
920
|
Available ondemand instance types. Note: Either ondemand or onDemandTypes must be defined, but not both.
|
|
925
921
|
"""
|
|
926
922
|
return pulumi.get(self, "on_demand_types")
|
|
927
923
|
|
|
928
924
|
@on_demand_types.setter
|
|
929
|
-
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]]]]):
|
|
930
926
|
pulumi.set(self, "on_demand_types", value)
|
|
931
927
|
|
|
932
|
-
@property
|
|
928
|
+
@_builtins.property
|
|
933
929
|
@pulumi.getter(name="ondemandCount")
|
|
934
|
-
def ondemand_count(self) -> Optional[pulumi.Input[int]]:
|
|
930
|
+
def ondemand_count(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
935
931
|
"""
|
|
936
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.
|
|
937
933
|
"""
|
|
938
934
|
return pulumi.get(self, "ondemand_count")
|
|
939
935
|
|
|
940
936
|
@ondemand_count.setter
|
|
941
|
-
def ondemand_count(self, value: Optional[pulumi.Input[int]]):
|
|
937
|
+
def ondemand_count(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
942
938
|
pulumi.set(self, "ondemand_count", value)
|
|
943
939
|
|
|
944
|
-
@property
|
|
940
|
+
@_builtins.property
|
|
945
941
|
@pulumi.getter(name="persistBlockDevices")
|
|
946
|
-
def persist_block_devices(self) -> Optional[pulumi.Input[bool]]:
|
|
942
|
+
def persist_block_devices(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
947
943
|
return pulumi.get(self, "persist_block_devices")
|
|
948
944
|
|
|
949
945
|
@persist_block_devices.setter
|
|
950
|
-
def persist_block_devices(self, value: Optional[pulumi.Input[bool]]):
|
|
946
|
+
def persist_block_devices(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
951
947
|
pulumi.set(self, "persist_block_devices", value)
|
|
952
948
|
|
|
953
|
-
@property
|
|
949
|
+
@_builtins.property
|
|
954
950
|
@pulumi.getter(name="persistPrivateIp")
|
|
955
|
-
def persist_private_ip(self) -> Optional[pulumi.Input[bool]]:
|
|
951
|
+
def persist_private_ip(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
956
952
|
return pulumi.get(self, "persist_private_ip")
|
|
957
953
|
|
|
958
954
|
@persist_private_ip.setter
|
|
959
|
-
def persist_private_ip(self, value: Optional[pulumi.Input[bool]]):
|
|
955
|
+
def persist_private_ip(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
960
956
|
pulumi.set(self, "persist_private_ip", value)
|
|
961
957
|
|
|
962
|
-
@property
|
|
958
|
+
@_builtins.property
|
|
963
959
|
@pulumi.getter(name="persistRootDevice")
|
|
964
|
-
def persist_root_device(self) -> Optional[pulumi.Input[bool]]:
|
|
960
|
+
def persist_root_device(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
965
961
|
return pulumi.get(self, "persist_root_device")
|
|
966
962
|
|
|
967
963
|
@persist_root_device.setter
|
|
968
|
-
def persist_root_device(self, value: Optional[pulumi.Input[bool]]):
|
|
964
|
+
def persist_root_device(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
969
965
|
pulumi.set(self, "persist_root_device", value)
|
|
970
966
|
|
|
971
|
-
@property
|
|
967
|
+
@_builtins.property
|
|
972
968
|
@pulumi.getter(name="placementTenancy")
|
|
973
|
-
def placement_tenancy(self) -> Optional[pulumi.Input[str]]:
|
|
969
|
+
def placement_tenancy(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
974
970
|
"""
|
|
975
971
|
Enable dedicated tenancy. Note: There is a flat hourly fee for each region in which dedicated tenancy is used. Valid values: "default", "dedicated" .
|
|
976
972
|
"""
|
|
977
973
|
return pulumi.get(self, "placement_tenancy")
|
|
978
974
|
|
|
979
975
|
@placement_tenancy.setter
|
|
980
|
-
def placement_tenancy(self, value: Optional[pulumi.Input[str]]):
|
|
976
|
+
def placement_tenancy(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
981
977
|
pulumi.set(self, "placement_tenancy", value)
|
|
982
978
|
|
|
983
|
-
@property
|
|
979
|
+
@_builtins.property
|
|
984
980
|
@pulumi.getter(name="preferredAvailabilityZones")
|
|
985
|
-
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]]]]:
|
|
986
982
|
"""
|
|
987
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.
|
|
988
984
|
Note: Must be a sublist of `availability_zones` and `orientation` value must not be `"equalAzDistribution"`.
|
|
@@ -990,21 +986,21 @@ class ElastigroupArgs:
|
|
|
990
986
|
return pulumi.get(self, "preferred_availability_zones")
|
|
991
987
|
|
|
992
988
|
@preferred_availability_zones.setter
|
|
993
|
-
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]]]]):
|
|
994
990
|
pulumi.set(self, "preferred_availability_zones", value)
|
|
995
991
|
|
|
996
|
-
@property
|
|
992
|
+
@_builtins.property
|
|
997
993
|
@pulumi.getter(name="privateIps")
|
|
998
|
-
def private_ips(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
|
|
994
|
+
def private_ips(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
|
|
999
995
|
return pulumi.get(self, "private_ips")
|
|
1000
996
|
|
|
1001
997
|
@private_ips.setter
|
|
1002
|
-
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]]]]):
|
|
1003
999
|
pulumi.set(self, "private_ips", value)
|
|
1004
1000
|
|
|
1005
|
-
@property
|
|
1001
|
+
@_builtins.property
|
|
1006
1002
|
@pulumi.getter
|
|
1007
|
-
def region(self) -> Optional[pulumi.Input[str]]:
|
|
1003
|
+
def region(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
1008
1004
|
"""
|
|
1009
1005
|
The AWS region your group will be created in.
|
|
1010
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).
|
|
@@ -1012,10 +1008,10 @@ class ElastigroupArgs:
|
|
|
1012
1008
|
return pulumi.get(self, "region")
|
|
1013
1009
|
|
|
1014
1010
|
@region.setter
|
|
1015
|
-
def region(self, value: Optional[pulumi.Input[str]]):
|
|
1011
|
+
def region(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
1016
1012
|
pulumi.set(self, "region", value)
|
|
1017
1013
|
|
|
1018
|
-
@property
|
|
1014
|
+
@_builtins.property
|
|
1019
1015
|
@pulumi.getter(name="resourceRequirements")
|
|
1020
1016
|
def resource_requirements(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupResourceRequirementArgs']]]]:
|
|
1021
1017
|
"""
|
|
@@ -1027,7 +1023,7 @@ class ElastigroupArgs:
|
|
|
1027
1023
|
def resource_requirements(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupResourceRequirementArgs']]]]):
|
|
1028
1024
|
pulumi.set(self, "resource_requirements", value)
|
|
1029
1025
|
|
|
1030
|
-
@property
|
|
1026
|
+
@_builtins.property
|
|
1031
1027
|
@pulumi.getter(name="resourceTagSpecifications")
|
|
1032
1028
|
def resource_tag_specifications(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupResourceTagSpecificationArgs']]]]:
|
|
1033
1029
|
"""
|
|
@@ -1039,19 +1035,19 @@ class ElastigroupArgs:
|
|
|
1039
1035
|
def resource_tag_specifications(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupResourceTagSpecificationArgs']]]]):
|
|
1040
1036
|
pulumi.set(self, "resource_tag_specifications", value)
|
|
1041
1037
|
|
|
1042
|
-
@property
|
|
1038
|
+
@_builtins.property
|
|
1043
1039
|
@pulumi.getter(name="restrictSingleAz")
|
|
1044
|
-
def restrict_single_az(self) -> Optional[pulumi.Input[bool]]:
|
|
1040
|
+
def restrict_single_az(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
1045
1041
|
"""
|
|
1046
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.
|
|
1047
1043
|
"""
|
|
1048
1044
|
return pulumi.get(self, "restrict_single_az")
|
|
1049
1045
|
|
|
1050
1046
|
@restrict_single_az.setter
|
|
1051
|
-
def restrict_single_az(self, value: Optional[pulumi.Input[bool]]):
|
|
1047
|
+
def restrict_single_az(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
1052
1048
|
pulumi.set(self, "restrict_single_az", value)
|
|
1053
1049
|
|
|
1054
|
-
@property
|
|
1050
|
+
@_builtins.property
|
|
1055
1051
|
@pulumi.getter(name="revertToSpot")
|
|
1056
1052
|
def revert_to_spot(self) -> Optional[pulumi.Input['ElastigroupRevertToSpotArgs']]:
|
|
1057
1053
|
"""
|
|
@@ -1063,7 +1059,7 @@ class ElastigroupArgs:
|
|
|
1063
1059
|
def revert_to_spot(self, value: Optional[pulumi.Input['ElastigroupRevertToSpotArgs']]):
|
|
1064
1060
|
pulumi.set(self, "revert_to_spot", value)
|
|
1065
1061
|
|
|
1066
|
-
@property
|
|
1062
|
+
@_builtins.property
|
|
1067
1063
|
@pulumi.getter(name="scalingDownPolicies")
|
|
1068
1064
|
def scaling_down_policies(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupScalingDownPolicyArgs']]]]:
|
|
1069
1065
|
return pulumi.get(self, "scaling_down_policies")
|
|
@@ -1072,7 +1068,7 @@ class ElastigroupArgs:
|
|
|
1072
1068
|
def scaling_down_policies(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupScalingDownPolicyArgs']]]]):
|
|
1073
1069
|
pulumi.set(self, "scaling_down_policies", value)
|
|
1074
1070
|
|
|
1075
|
-
@property
|
|
1071
|
+
@_builtins.property
|
|
1076
1072
|
@pulumi.getter(name="scalingStrategies")
|
|
1077
1073
|
def scaling_strategies(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupScalingStrategyArgs']]]]:
|
|
1078
1074
|
"""
|
|
@@ -1084,7 +1080,7 @@ class ElastigroupArgs:
|
|
|
1084
1080
|
def scaling_strategies(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupScalingStrategyArgs']]]]):
|
|
1085
1081
|
pulumi.set(self, "scaling_strategies", value)
|
|
1086
1082
|
|
|
1087
|
-
@property
|
|
1083
|
+
@_builtins.property
|
|
1088
1084
|
@pulumi.getter(name="scalingTargetPolicies")
|
|
1089
1085
|
def scaling_target_policies(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupScalingTargetPolicyArgs']]]]:
|
|
1090
1086
|
return pulumi.get(self, "scaling_target_policies")
|
|
@@ -1093,7 +1089,7 @@ class ElastigroupArgs:
|
|
|
1093
1089
|
def scaling_target_policies(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupScalingTargetPolicyArgs']]]]):
|
|
1094
1090
|
pulumi.set(self, "scaling_target_policies", value)
|
|
1095
1091
|
|
|
1096
|
-
@property
|
|
1092
|
+
@_builtins.property
|
|
1097
1093
|
@pulumi.getter(name="scalingUpPolicies")
|
|
1098
1094
|
def scaling_up_policies(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupScalingUpPolicyArgs']]]]:
|
|
1099
1095
|
return pulumi.get(self, "scaling_up_policies")
|
|
@@ -1102,7 +1098,7 @@ class ElastigroupArgs:
|
|
|
1102
1098
|
def scaling_up_policies(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupScalingUpPolicyArgs']]]]):
|
|
1103
1099
|
pulumi.set(self, "scaling_up_policies", value)
|
|
1104
1100
|
|
|
1105
|
-
@property
|
|
1101
|
+
@_builtins.property
|
|
1106
1102
|
@pulumi.getter(name="scheduledTasks")
|
|
1107
1103
|
def scheduled_tasks(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupScheduledTaskArgs']]]]:
|
|
1108
1104
|
return pulumi.get(self, "scheduled_tasks")
|
|
@@ -1111,19 +1107,19 @@ class ElastigroupArgs:
|
|
|
1111
1107
|
def scheduled_tasks(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupScheduledTaskArgs']]]]):
|
|
1112
1108
|
pulumi.set(self, "scheduled_tasks", value)
|
|
1113
1109
|
|
|
1114
|
-
@property
|
|
1110
|
+
@_builtins.property
|
|
1115
1111
|
@pulumi.getter(name="shutdownScript")
|
|
1116
|
-
def shutdown_script(self) -> Optional[pulumi.Input[str]]:
|
|
1112
|
+
def shutdown_script(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
1117
1113
|
"""
|
|
1118
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/)
|
|
1119
1115
|
"""
|
|
1120
1116
|
return pulumi.get(self, "shutdown_script")
|
|
1121
1117
|
|
|
1122
1118
|
@shutdown_script.setter
|
|
1123
|
-
def shutdown_script(self, value: Optional[pulumi.Input[str]]):
|
|
1119
|
+
def shutdown_script(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
1124
1120
|
pulumi.set(self, "shutdown_script", value)
|
|
1125
1121
|
|
|
1126
|
-
@property
|
|
1122
|
+
@_builtins.property
|
|
1127
1123
|
@pulumi.getter
|
|
1128
1124
|
def signals(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupSignalArgs']]]]:
|
|
1129
1125
|
return pulumi.get(self, "signals")
|
|
@@ -1132,19 +1128,19 @@ class ElastigroupArgs:
|
|
|
1132
1128
|
def signals(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupSignalArgs']]]]):
|
|
1133
1129
|
pulumi.set(self, "signals", value)
|
|
1134
1130
|
|
|
1135
|
-
@property
|
|
1131
|
+
@_builtins.property
|
|
1136
1132
|
@pulumi.getter(name="spotPercentage")
|
|
1137
|
-
def spot_percentage(self) -> Optional[pulumi.Input[int]]:
|
|
1133
|
+
def spot_percentage(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
1138
1134
|
"""
|
|
1139
1135
|
The percentage of Spot instances that would spin up from the `desired_capacity` number.
|
|
1140
1136
|
"""
|
|
1141
1137
|
return pulumi.get(self, "spot_percentage")
|
|
1142
1138
|
|
|
1143
1139
|
@spot_percentage.setter
|
|
1144
|
-
def spot_percentage(self, value: Optional[pulumi.Input[int]]):
|
|
1140
|
+
def spot_percentage(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
1145
1141
|
pulumi.set(self, "spot_percentage", value)
|
|
1146
1142
|
|
|
1147
|
-
@property
|
|
1143
|
+
@_builtins.property
|
|
1148
1144
|
@pulumi.getter(name="statefulDeallocation")
|
|
1149
1145
|
def stateful_deallocation(self) -> Optional[pulumi.Input['ElastigroupStatefulDeallocationArgs']]:
|
|
1150
1146
|
return pulumi.get(self, "stateful_deallocation")
|
|
@@ -1153,7 +1149,7 @@ class ElastigroupArgs:
|
|
|
1153
1149
|
def stateful_deallocation(self, value: Optional[pulumi.Input['ElastigroupStatefulDeallocationArgs']]):
|
|
1154
1150
|
pulumi.set(self, "stateful_deallocation", value)
|
|
1155
1151
|
|
|
1156
|
-
@property
|
|
1152
|
+
@_builtins.property
|
|
1157
1153
|
@pulumi.getter(name="statefulInstanceActions")
|
|
1158
1154
|
def stateful_instance_actions(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupStatefulInstanceActionArgs']]]]:
|
|
1159
1155
|
return pulumi.get(self, "stateful_instance_actions")
|
|
@@ -1162,10 +1158,10 @@ class ElastigroupArgs:
|
|
|
1162
1158
|
def stateful_instance_actions(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupStatefulInstanceActionArgs']]]]):
|
|
1163
1159
|
pulumi.set(self, "stateful_instance_actions", value)
|
|
1164
1160
|
|
|
1165
|
-
@property
|
|
1161
|
+
@_builtins.property
|
|
1166
1162
|
@pulumi.getter(name="subnetIds")
|
|
1167
1163
|
@_utilities.deprecated("""This field will soon be deprecated and handled by availability_zones""")
|
|
1168
|
-
def subnet_ids(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
|
|
1164
|
+
def subnet_ids(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
|
|
1169
1165
|
"""
|
|
1170
1166
|
List of Strings of subnet identifiers.
|
|
1171
1167
|
Note: When this parameter is set, `availability_zones` should be left unused.
|
|
@@ -1173,10 +1169,10 @@ class ElastigroupArgs:
|
|
|
1173
1169
|
return pulumi.get(self, "subnet_ids")
|
|
1174
1170
|
|
|
1175
1171
|
@subnet_ids.setter
|
|
1176
|
-
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]]]]):
|
|
1177
1173
|
pulumi.set(self, "subnet_ids", value)
|
|
1178
1174
|
|
|
1179
|
-
@property
|
|
1175
|
+
@_builtins.property
|
|
1180
1176
|
@pulumi.getter
|
|
1181
1177
|
def tags(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupTagArgs']]]]:
|
|
1182
1178
|
"""
|
|
@@ -1188,16 +1184,16 @@ class ElastigroupArgs:
|
|
|
1188
1184
|
def tags(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupTagArgs']]]]):
|
|
1189
1185
|
pulumi.set(self, "tags", value)
|
|
1190
1186
|
|
|
1191
|
-
@property
|
|
1187
|
+
@_builtins.property
|
|
1192
1188
|
@pulumi.getter(name="targetGroupArns")
|
|
1193
|
-
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]]]]:
|
|
1194
1190
|
return pulumi.get(self, "target_group_arns")
|
|
1195
1191
|
|
|
1196
1192
|
@target_group_arns.setter
|
|
1197
|
-
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]]]]):
|
|
1198
1194
|
pulumi.set(self, "target_group_arns", value)
|
|
1199
1195
|
|
|
1200
|
-
@property
|
|
1196
|
+
@_builtins.property
|
|
1201
1197
|
@pulumi.getter(name="updatePolicy")
|
|
1202
1198
|
def update_policy(self) -> Optional[pulumi.Input['ElastigroupUpdatePolicyArgs']]:
|
|
1203
1199
|
return pulumi.get(self, "update_policy")
|
|
@@ -1206,94 +1202,94 @@ class ElastigroupArgs:
|
|
|
1206
1202
|
def update_policy(self, value: Optional[pulumi.Input['ElastigroupUpdatePolicyArgs']]):
|
|
1207
1203
|
pulumi.set(self, "update_policy", value)
|
|
1208
1204
|
|
|
1209
|
-
@property
|
|
1205
|
+
@_builtins.property
|
|
1210
1206
|
@pulumi.getter(name="userData")
|
|
1211
|
-
def user_data(self) -> Optional[pulumi.Input[str]]:
|
|
1207
|
+
def user_data(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
1212
1208
|
"""
|
|
1213
1209
|
The user data to provide when launching the instance.
|
|
1214
1210
|
"""
|
|
1215
1211
|
return pulumi.get(self, "user_data")
|
|
1216
1212
|
|
|
1217
1213
|
@user_data.setter
|
|
1218
|
-
def user_data(self, value: Optional[pulumi.Input[str]]):
|
|
1214
|
+
def user_data(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
1219
1215
|
pulumi.set(self, "user_data", value)
|
|
1220
1216
|
|
|
1221
|
-
@property
|
|
1217
|
+
@_builtins.property
|
|
1222
1218
|
@pulumi.getter(name="utilizeCommitments")
|
|
1223
|
-
def utilize_commitments(self) -> Optional[pulumi.Input[bool]]:
|
|
1219
|
+
def utilize_commitments(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
1224
1220
|
return pulumi.get(self, "utilize_commitments")
|
|
1225
1221
|
|
|
1226
1222
|
@utilize_commitments.setter
|
|
1227
|
-
def utilize_commitments(self, value: Optional[pulumi.Input[bool]]):
|
|
1223
|
+
def utilize_commitments(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
1228
1224
|
pulumi.set(self, "utilize_commitments", value)
|
|
1229
1225
|
|
|
1230
|
-
@property
|
|
1226
|
+
@_builtins.property
|
|
1231
1227
|
@pulumi.getter(name="utilizeReservedInstances")
|
|
1232
|
-
def utilize_reserved_instances(self) -> Optional[pulumi.Input[bool]]:
|
|
1228
|
+
def utilize_reserved_instances(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
1233
1229
|
"""
|
|
1234
1230
|
In a case of any available reserved instances, Elastigroup will utilize them first before purchasing Spot instances.
|
|
1235
1231
|
"""
|
|
1236
1232
|
return pulumi.get(self, "utilize_reserved_instances")
|
|
1237
1233
|
|
|
1238
1234
|
@utilize_reserved_instances.setter
|
|
1239
|
-
def utilize_reserved_instances(self, value: Optional[pulumi.Input[bool]]):
|
|
1235
|
+
def utilize_reserved_instances(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
1240
1236
|
pulumi.set(self, "utilize_reserved_instances", value)
|
|
1241
1237
|
|
|
1242
|
-
@property
|
|
1238
|
+
@_builtins.property
|
|
1243
1239
|
@pulumi.getter(name="waitForCapacity")
|
|
1244
|
-
def wait_for_capacity(self) -> Optional[pulumi.Input[int]]:
|
|
1240
|
+
def wait_for_capacity(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
1245
1241
|
"""
|
|
1246
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`.
|
|
1247
1243
|
"""
|
|
1248
1244
|
return pulumi.get(self, "wait_for_capacity")
|
|
1249
1245
|
|
|
1250
1246
|
@wait_for_capacity.setter
|
|
1251
|
-
def wait_for_capacity(self, value: Optional[pulumi.Input[int]]):
|
|
1247
|
+
def wait_for_capacity(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
1252
1248
|
pulumi.set(self, "wait_for_capacity", value)
|
|
1253
1249
|
|
|
1254
|
-
@property
|
|
1250
|
+
@_builtins.property
|
|
1255
1251
|
@pulumi.getter(name="waitForCapacityTimeout")
|
|
1256
|
-
def wait_for_capacity_timeout(self) -> Optional[pulumi.Input[int]]:
|
|
1252
|
+
def wait_for_capacity_timeout(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
1257
1253
|
"""
|
|
1258
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.
|
|
1259
1255
|
"""
|
|
1260
1256
|
return pulumi.get(self, "wait_for_capacity_timeout")
|
|
1261
1257
|
|
|
1262
1258
|
@wait_for_capacity_timeout.setter
|
|
1263
|
-
def wait_for_capacity_timeout(self, value: Optional[pulumi.Input[int]]):
|
|
1259
|
+
def wait_for_capacity_timeout(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
1264
1260
|
pulumi.set(self, "wait_for_capacity_timeout", value)
|
|
1265
1261
|
|
|
1266
1262
|
|
|
1267
1263
|
@pulumi.input_type
|
|
1268
1264
|
class _ElastigroupState:
|
|
1269
1265
|
def __init__(__self__, *,
|
|
1270
|
-
auto_healing: Optional[pulumi.Input[bool]] = None,
|
|
1271
|
-
availability_zones: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
|
|
1272
|
-
block_devices_mode: Optional[pulumi.Input[str]] = None,
|
|
1273
|
-
capacity_unit: Optional[pulumi.Input[str]] = None,
|
|
1274
|
-
consider_od_pricing: Optional[pulumi.Input[bool]] = None,
|
|
1275
|
-
cpu_credits: Optional[pulumi.Input[str]] = None,
|
|
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,
|
|
1276
1272
|
cpu_options: Optional[pulumi.Input['ElastigroupCpuOptionsArgs']] = None,
|
|
1277
|
-
description: Optional[pulumi.Input[str]] = None,
|
|
1278
|
-
desired_capacity: Optional[pulumi.Input[int]] = None,
|
|
1279
|
-
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,
|
|
1280
1276
|
ebs_block_devices: Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupEbsBlockDeviceArgs']]]] = None,
|
|
1281
|
-
ebs_optimized: Optional[pulumi.Input[bool]] = None,
|
|
1282
|
-
elastic_ips: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
|
|
1283
|
-
elastic_load_balancers: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
|
|
1284
|
-
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,
|
|
1285
1281
|
ephemeral_block_devices: Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupEphemeralBlockDeviceArgs']]]] = None,
|
|
1286
|
-
fallback_to_ondemand: Optional[pulumi.Input[bool]] = None,
|
|
1287
|
-
health_check_grace_period: Optional[pulumi.Input[int]] = None,
|
|
1288
|
-
health_check_type: Optional[pulumi.Input[str]] = None,
|
|
1289
|
-
health_check_unhealthy_duration_before_replacement: Optional[pulumi.Input[int]] = None,
|
|
1290
|
-
iam_instance_profile: Optional[pulumi.Input[str]] = None,
|
|
1291
|
-
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,
|
|
1292
1288
|
images: Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupImageArgs']]]] = None,
|
|
1293
|
-
immediate_od_recover_threshold: Optional[pulumi.Input[int]] = None,
|
|
1294
|
-
instance_types_ondemand: Optional[pulumi.Input[str]] = None,
|
|
1295
|
-
instance_types_preferred_spots: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
|
|
1296
|
-
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,
|
|
1297
1293
|
instance_types_weights: Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupInstanceTypesWeightArgs']]]] = None,
|
|
1298
1294
|
integration_beanstalk: Optional[pulumi.Input['ElastigroupIntegrationBeanstalkArgs']] = None,
|
|
1299
1295
|
integration_codedeploy: Optional[pulumi.Input['ElastigroupIntegrationCodedeployArgs']] = None,
|
|
@@ -1306,112 +1302,111 @@ class _ElastigroupState:
|
|
|
1306
1302
|
integration_rancher: Optional[pulumi.Input['ElastigroupIntegrationRancherArgs']] = None,
|
|
1307
1303
|
integration_route53: Optional[pulumi.Input['ElastigroupIntegrationRoute53Args']] = None,
|
|
1308
1304
|
itfs: Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupItfArgs']]]] = None,
|
|
1309
|
-
key_name: Optional[pulumi.Input[str]] = None,
|
|
1310
|
-
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,
|
|
1311
1307
|
logging: Optional[pulumi.Input['ElastigroupLoggingArgs']] = None,
|
|
1312
|
-
max_replacements_percentage: Optional[pulumi.Input[int]] = None,
|
|
1313
|
-
max_size: Optional[pulumi.Input[int]] = None,
|
|
1308
|
+
max_replacements_percentage: Optional[pulumi.Input[_builtins.int]] = None,
|
|
1309
|
+
max_size: Optional[pulumi.Input[_builtins.int]] = None,
|
|
1314
1310
|
metadata_options: Optional[pulumi.Input['ElastigroupMetadataOptionsArgs']] = None,
|
|
1315
|
-
min_size: Optional[pulumi.Input[int]] = None,
|
|
1316
|
-
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,
|
|
1317
1313
|
multiple_metrics: Optional[pulumi.Input['ElastigroupMultipleMetricsArgs']] = None,
|
|
1318
|
-
name: Optional[pulumi.Input[str]] = None,
|
|
1314
|
+
name: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1319
1315
|
network_interfaces: Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupNetworkInterfaceArgs']]]] = None,
|
|
1320
|
-
on_demand_types: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
|
|
1321
|
-
ondemand_count: Optional[pulumi.Input[int]] = None,
|
|
1322
|
-
orientation: Optional[pulumi.Input[str]] = None,
|
|
1323
|
-
persist_block_devices: Optional[pulumi.Input[bool]] = None,
|
|
1324
|
-
persist_private_ip: Optional[pulumi.Input[bool]] = None,
|
|
1325
|
-
persist_root_device: Optional[pulumi.Input[bool]] = None,
|
|
1326
|
-
placement_tenancy: Optional[pulumi.Input[str]] = None,
|
|
1327
|
-
preferred_availability_zones: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
|
|
1328
|
-
private_ips: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
|
|
1329
|
-
product: Optional[pulumi.Input[str]] = None,
|
|
1330
|
-
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,
|
|
1331
1327
|
resource_requirements: Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupResourceRequirementArgs']]]] = None,
|
|
1332
1328
|
resource_tag_specifications: Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupResourceTagSpecificationArgs']]]] = None,
|
|
1333
|
-
restrict_single_az: Optional[pulumi.Input[bool]] = None,
|
|
1329
|
+
restrict_single_az: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
1334
1330
|
revert_to_spot: Optional[pulumi.Input['ElastigroupRevertToSpotArgs']] = None,
|
|
1335
1331
|
scaling_down_policies: Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupScalingDownPolicyArgs']]]] = None,
|
|
1336
1332
|
scaling_strategies: Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupScalingStrategyArgs']]]] = None,
|
|
1337
1333
|
scaling_target_policies: Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupScalingTargetPolicyArgs']]]] = None,
|
|
1338
1334
|
scaling_up_policies: Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupScalingUpPolicyArgs']]]] = None,
|
|
1339
1335
|
scheduled_tasks: Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupScheduledTaskArgs']]]] = None,
|
|
1340
|
-
security_groups: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
|
|
1341
|
-
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,
|
|
1342
1338
|
signals: Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupSignalArgs']]]] = None,
|
|
1343
|
-
spot_percentage: Optional[pulumi.Input[int]] = None,
|
|
1339
|
+
spot_percentage: Optional[pulumi.Input[_builtins.int]] = None,
|
|
1344
1340
|
stateful_deallocation: Optional[pulumi.Input['ElastigroupStatefulDeallocationArgs']] = None,
|
|
1345
1341
|
stateful_instance_actions: Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupStatefulInstanceActionArgs']]]] = None,
|
|
1346
|
-
subnet_ids: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
|
|
1342
|
+
subnet_ids: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
1347
1343
|
tags: Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupTagArgs']]]] = None,
|
|
1348
|
-
target_group_arns: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
|
|
1344
|
+
target_group_arns: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
1349
1345
|
update_policy: Optional[pulumi.Input['ElastigroupUpdatePolicyArgs']] = None,
|
|
1350
|
-
user_data: Optional[pulumi.Input[str]] = None,
|
|
1351
|
-
utilize_commitments: Optional[pulumi.Input[bool]] = None,
|
|
1352
|
-
utilize_reserved_instances: Optional[pulumi.Input[bool]] = None,
|
|
1353
|
-
wait_for_capacity: Optional[pulumi.Input[int]] = None,
|
|
1354
|
-
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):
|
|
1355
1351
|
"""
|
|
1356
1352
|
Input properties used for looking up and filtering Elastigroup resources.
|
|
1357
|
-
:param pulumi.Input[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".
|
|
1358
|
-
:param pulumi.Input[Sequence[pulumi.Input[str]]] availability_zones: List of Strings of availability zones. When this parameter is set, `subnet_ids` should be left unused.
|
|
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.
|
|
1359
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:
|
|
1360
1356
|
`availability_zones = ["us-east-1a:subnet-123456:ClusterI03"]`
|
|
1361
|
-
: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`.
|
|
1362
|
-
: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`.
|
|
1363
1359
|
:param pulumi.Input['ElastigroupCpuOptionsArgs'] cpu_options: The CPU options for the instances that are launched within the group:
|
|
1364
|
-
:param pulumi.Input[str] description: The group description.
|
|
1365
|
-
:param pulumi.Input[int] desired_capacity: The desired number of instances the group should have at any time.
|
|
1366
|
-
: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.
|
|
1367
|
-
: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.
|
|
1368
|
-
: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.
|
|
1369
|
-
:param pulumi.Input[bool] enable_monitoring: Indicates whether monitoring is enabled for the instance.
|
|
1370
|
-
:param pulumi.Input[bool] fallback_to_ondemand: In a case of no Spot instances available, Elastigroup will launch on-demand instances instead.
|
|
1371
|
-
: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.
|
|
1372
|
-
: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"`.
|
|
1373
|
-
: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).
|
|
1374
|
-
:param pulumi.Input[str] iam_instance_profile: The ARN or name of an IAM instance profile to associate with launched instances.
|
|
1375
|
-
: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.
|
|
1376
1372
|
:param pulumi.Input[Sequence[pulumi.Input['ElastigroupImageArgs']]] images: An array of image objects.
|
|
1377
1373
|
Note: Elastigroup can be configured with either imageId or images, but not both.
|
|
1378
|
-
: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).
|
|
1379
|
-
: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.
|
|
1380
|
-
: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.
|
|
1381
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:
|
|
1382
|
-
: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.
|
|
1383
1379
|
:param pulumi.Input['ElastigroupLoggingArgs'] logging: Logging configuration.
|
|
1384
|
-
:param pulumi.Input[int]
|
|
1385
|
-
: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.
|
|
1386
1381
|
:param pulumi.Input['ElastigroupMetadataOptionsArgs'] metadata_options: Data that used to configure or manage the running instances:
|
|
1387
|
-
:param pulumi.Input[int] min_size: The minimum number of instances the group should have at any time.
|
|
1388
|
-
: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.
|
|
1389
|
-
:param pulumi.Input[str] name: The group name.
|
|
1390
|
-
: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.
|
|
1391
|
-
: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.
|
|
1392
|
-
:param pulumi.Input[str] orientation: Select a prediction strategy. Valid values: `balanced`, `costOriented`, `equalAzDistribution`, `availabilityOriented`. You can read more in our documentation.
|
|
1393
|
-
: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" .
|
|
1394
|
-
: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.
|
|
1395
1390
|
Note: Must be a sublist of `availability_zones` and `orientation` value must not be `"equalAzDistribution"`.
|
|
1396
|
-
:param pulumi.Input[str] product: Operation system type. Valid values: `"Linux/UNIX"`, `"SUSE Linux"`, `"Windows"`.
|
|
1391
|
+
:param pulumi.Input[_builtins.str] product: Operation system type. Valid values: `"Linux/UNIX"`, `"SUSE Linux"`, `"Windows"`.
|
|
1397
1392
|
For EC2 Classic instances: `"SUSE Linux (Amazon VPC)"`, `"Windows (Amazon VPC)"`.
|
|
1398
|
-
:param pulumi.Input[str] region: The AWS region your group will be created in.
|
|
1393
|
+
:param pulumi.Input[_builtins.str] region: The AWS region your group will be created in.
|
|
1399
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).
|
|
1400
1395
|
:param pulumi.Input[Sequence[pulumi.Input['ElastigroupResourceRequirementArgs']]] resource_requirements: Required instance attributes. Instance types will be selected based on these requirements.
|
|
1401
1396
|
:param pulumi.Input[Sequence[pulumi.Input['ElastigroupResourceTagSpecificationArgs']]] resource_tag_specifications: User will specify which resources should be tagged with group tags.
|
|
1402
|
-
:param pulumi.Input[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.
|
|
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.
|
|
1403
1398
|
:param pulumi.Input['ElastigroupRevertToSpotArgs'] revert_to_spot: Hold settings for strategy correction – replacing On-Demand for Spot instances. Supported Values: `"never"`, `"always"`, `"timeWindow"`
|
|
1404
1399
|
:param pulumi.Input[Sequence[pulumi.Input['ElastigroupScalingStrategyArgs']]] scaling_strategies: Set termination policy.
|
|
1405
|
-
:param pulumi.Input[Sequence[pulumi.Input[str]]] security_groups: A list of associated security group IDS.
|
|
1406
|
-
: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/)
|
|
1407
|
-
:param pulumi.Input[int] spot_percentage: The percentage of Spot instances that would spin up from the `desired_capacity` number.
|
|
1408
|
-
: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.
|
|
1409
1404
|
Note: When this parameter is set, `availability_zones` should be left unused.
|
|
1410
1405
|
:param pulumi.Input[Sequence[pulumi.Input['ElastigroupTagArgs']]] tags: A key/value mapping of tags to assign to the resource.
|
|
1411
|
-
:param pulumi.Input[str] user_data: The user data to provide when launching the instance.
|
|
1412
|
-
:param pulumi.Input[bool] utilize_reserved_instances: In a case of any available reserved instances, Elastigroup will utilize them first before purchasing Spot instances.
|
|
1413
|
-
: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`.
|
|
1414
|
-
: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.
|
|
1415
1410
|
"""
|
|
1416
1411
|
if auto_healing is not None:
|
|
1417
1412
|
pulumi.set(__self__, "auto_healing", auto_healing)
|
|
@@ -1587,21 +1582,21 @@ class _ElastigroupState:
|
|
|
1587
1582
|
if wait_for_capacity_timeout is not None:
|
|
1588
1583
|
pulumi.set(__self__, "wait_for_capacity_timeout", wait_for_capacity_timeout)
|
|
1589
1584
|
|
|
1590
|
-
@property
|
|
1585
|
+
@_builtins.property
|
|
1591
1586
|
@pulumi.getter(name="autoHealing")
|
|
1592
|
-
def auto_healing(self) -> Optional[pulumi.Input[bool]]:
|
|
1587
|
+
def auto_healing(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
1593
1588
|
"""
|
|
1594
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".
|
|
1595
1590
|
"""
|
|
1596
1591
|
return pulumi.get(self, "auto_healing")
|
|
1597
1592
|
|
|
1598
1593
|
@auto_healing.setter
|
|
1599
|
-
def auto_healing(self, value: Optional[pulumi.Input[bool]]):
|
|
1594
|
+
def auto_healing(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
1600
1595
|
pulumi.set(self, "auto_healing", value)
|
|
1601
1596
|
|
|
1602
|
-
@property
|
|
1597
|
+
@_builtins.property
|
|
1603
1598
|
@pulumi.getter(name="availabilityZones")
|
|
1604
|
-
def availability_zones(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
|
|
1599
|
+
def availability_zones(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
|
|
1605
1600
|
"""
|
|
1606
1601
|
List of Strings of availability zones. When this parameter is set, `subnet_ids` should be left unused.
|
|
1607
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:
|
|
@@ -1610,52 +1605,52 @@ class _ElastigroupState:
|
|
|
1610
1605
|
return pulumi.get(self, "availability_zones")
|
|
1611
1606
|
|
|
1612
1607
|
@availability_zones.setter
|
|
1613
|
-
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]]]]):
|
|
1614
1609
|
pulumi.set(self, "availability_zones", value)
|
|
1615
1610
|
|
|
1616
|
-
@property
|
|
1611
|
+
@_builtins.property
|
|
1617
1612
|
@pulumi.getter(name="blockDevicesMode")
|
|
1618
|
-
def block_devices_mode(self) -> Optional[pulumi.Input[str]]:
|
|
1613
|
+
def block_devices_mode(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
1619
1614
|
return pulumi.get(self, "block_devices_mode")
|
|
1620
1615
|
|
|
1621
1616
|
@block_devices_mode.setter
|
|
1622
|
-
def block_devices_mode(self, value: Optional[pulumi.Input[str]]):
|
|
1617
|
+
def block_devices_mode(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
1623
1618
|
pulumi.set(self, "block_devices_mode", value)
|
|
1624
1619
|
|
|
1625
|
-
@property
|
|
1620
|
+
@_builtins.property
|
|
1626
1621
|
@pulumi.getter(name="capacityUnit")
|
|
1627
|
-
def capacity_unit(self) -> Optional[pulumi.Input[str]]:
|
|
1622
|
+
def capacity_unit(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
1628
1623
|
"""
|
|
1629
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`.
|
|
1630
1625
|
"""
|
|
1631
1626
|
return pulumi.get(self, "capacity_unit")
|
|
1632
1627
|
|
|
1633
1628
|
@capacity_unit.setter
|
|
1634
|
-
def capacity_unit(self, value: Optional[pulumi.Input[str]]):
|
|
1629
|
+
def capacity_unit(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
1635
1630
|
pulumi.set(self, "capacity_unit", value)
|
|
1636
1631
|
|
|
1637
|
-
@property
|
|
1632
|
+
@_builtins.property
|
|
1638
1633
|
@pulumi.getter(name="considerOdPricing")
|
|
1639
|
-
def consider_od_pricing(self) -> Optional[pulumi.Input[bool]]:
|
|
1634
|
+
def consider_od_pricing(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
1640
1635
|
return pulumi.get(self, "consider_od_pricing")
|
|
1641
1636
|
|
|
1642
1637
|
@consider_od_pricing.setter
|
|
1643
|
-
def consider_od_pricing(self, value: Optional[pulumi.Input[bool]]):
|
|
1638
|
+
def consider_od_pricing(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
1644
1639
|
pulumi.set(self, "consider_od_pricing", value)
|
|
1645
1640
|
|
|
1646
|
-
@property
|
|
1641
|
+
@_builtins.property
|
|
1647
1642
|
@pulumi.getter(name="cpuCredits")
|
|
1648
|
-
def cpu_credits(self) -> Optional[pulumi.Input[str]]:
|
|
1643
|
+
def cpu_credits(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
1649
1644
|
"""
|
|
1650
1645
|
Controls how T3 instances are launched. Valid values: `standard`, `unlimited`.
|
|
1651
1646
|
"""
|
|
1652
1647
|
return pulumi.get(self, "cpu_credits")
|
|
1653
1648
|
|
|
1654
1649
|
@cpu_credits.setter
|
|
1655
|
-
def cpu_credits(self, value: Optional[pulumi.Input[str]]):
|
|
1650
|
+
def cpu_credits(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
1656
1651
|
pulumi.set(self, "cpu_credits", value)
|
|
1657
1652
|
|
|
1658
|
-
@property
|
|
1653
|
+
@_builtins.property
|
|
1659
1654
|
@pulumi.getter(name="cpuOptions")
|
|
1660
1655
|
def cpu_options(self) -> Optional[pulumi.Input['ElastigroupCpuOptionsArgs']]:
|
|
1661
1656
|
"""
|
|
@@ -1667,43 +1662,43 @@ class _ElastigroupState:
|
|
|
1667
1662
|
def cpu_options(self, value: Optional[pulumi.Input['ElastigroupCpuOptionsArgs']]):
|
|
1668
1663
|
pulumi.set(self, "cpu_options", value)
|
|
1669
1664
|
|
|
1670
|
-
@property
|
|
1665
|
+
@_builtins.property
|
|
1671
1666
|
@pulumi.getter
|
|
1672
|
-
def description(self) -> Optional[pulumi.Input[str]]:
|
|
1667
|
+
def description(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
1673
1668
|
"""
|
|
1674
1669
|
The group description.
|
|
1675
1670
|
"""
|
|
1676
1671
|
return pulumi.get(self, "description")
|
|
1677
1672
|
|
|
1678
1673
|
@description.setter
|
|
1679
|
-
def description(self, value: Optional[pulumi.Input[str]]):
|
|
1674
|
+
def description(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
1680
1675
|
pulumi.set(self, "description", value)
|
|
1681
1676
|
|
|
1682
|
-
@property
|
|
1677
|
+
@_builtins.property
|
|
1683
1678
|
@pulumi.getter(name="desiredCapacity")
|
|
1684
|
-
def desired_capacity(self) -> Optional[pulumi.Input[int]]:
|
|
1679
|
+
def desired_capacity(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
1685
1680
|
"""
|
|
1686
1681
|
The desired number of instances the group should have at any time.
|
|
1687
1682
|
"""
|
|
1688
1683
|
return pulumi.get(self, "desired_capacity")
|
|
1689
1684
|
|
|
1690
1685
|
@desired_capacity.setter
|
|
1691
|
-
def desired_capacity(self, value: Optional[pulumi.Input[int]]):
|
|
1686
|
+
def desired_capacity(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
1692
1687
|
pulumi.set(self, "desired_capacity", value)
|
|
1693
1688
|
|
|
1694
|
-
@property
|
|
1689
|
+
@_builtins.property
|
|
1695
1690
|
@pulumi.getter(name="drainingTimeout")
|
|
1696
|
-
def draining_timeout(self) -> Optional[pulumi.Input[int]]:
|
|
1691
|
+
def draining_timeout(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
1697
1692
|
"""
|
|
1698
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.
|
|
1699
1694
|
"""
|
|
1700
1695
|
return pulumi.get(self, "draining_timeout")
|
|
1701
1696
|
|
|
1702
1697
|
@draining_timeout.setter
|
|
1703
|
-
def draining_timeout(self, value: Optional[pulumi.Input[int]]):
|
|
1698
|
+
def draining_timeout(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
1704
1699
|
pulumi.set(self, "draining_timeout", value)
|
|
1705
1700
|
|
|
1706
|
-
@property
|
|
1701
|
+
@_builtins.property
|
|
1707
1702
|
@pulumi.getter(name="ebsBlockDevices")
|
|
1708
1703
|
def ebs_block_devices(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupEbsBlockDeviceArgs']]]]:
|
|
1709
1704
|
return pulumi.get(self, "ebs_block_devices")
|
|
@@ -1712,52 +1707,52 @@ class _ElastigroupState:
|
|
|
1712
1707
|
def ebs_block_devices(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupEbsBlockDeviceArgs']]]]):
|
|
1713
1708
|
pulumi.set(self, "ebs_block_devices", value)
|
|
1714
1709
|
|
|
1715
|
-
@property
|
|
1710
|
+
@_builtins.property
|
|
1716
1711
|
@pulumi.getter(name="ebsOptimized")
|
|
1717
|
-
def ebs_optimized(self) -> Optional[pulumi.Input[bool]]:
|
|
1712
|
+
def ebs_optimized(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
1718
1713
|
"""
|
|
1719
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.
|
|
1720
1715
|
"""
|
|
1721
1716
|
return pulumi.get(self, "ebs_optimized")
|
|
1722
1717
|
|
|
1723
1718
|
@ebs_optimized.setter
|
|
1724
|
-
def ebs_optimized(self, value: Optional[pulumi.Input[bool]]):
|
|
1719
|
+
def ebs_optimized(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
1725
1720
|
pulumi.set(self, "ebs_optimized", value)
|
|
1726
1721
|
|
|
1727
|
-
@property
|
|
1722
|
+
@_builtins.property
|
|
1728
1723
|
@pulumi.getter(name="elasticIps")
|
|
1729
|
-
def elastic_ips(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
|
|
1724
|
+
def elastic_ips(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
|
|
1730
1725
|
"""
|
|
1731
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.
|
|
1732
1727
|
"""
|
|
1733
1728
|
return pulumi.get(self, "elastic_ips")
|
|
1734
1729
|
|
|
1735
1730
|
@elastic_ips.setter
|
|
1736
|
-
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]]]]):
|
|
1737
1732
|
pulumi.set(self, "elastic_ips", value)
|
|
1738
1733
|
|
|
1739
|
-
@property
|
|
1734
|
+
@_builtins.property
|
|
1740
1735
|
@pulumi.getter(name="elasticLoadBalancers")
|
|
1741
|
-
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]]]]:
|
|
1742
1737
|
return pulumi.get(self, "elastic_load_balancers")
|
|
1743
1738
|
|
|
1744
1739
|
@elastic_load_balancers.setter
|
|
1745
|
-
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]]]]):
|
|
1746
1741
|
pulumi.set(self, "elastic_load_balancers", value)
|
|
1747
1742
|
|
|
1748
|
-
@property
|
|
1743
|
+
@_builtins.property
|
|
1749
1744
|
@pulumi.getter(name="enableMonitoring")
|
|
1750
|
-
def enable_monitoring(self) -> Optional[pulumi.Input[bool]]:
|
|
1745
|
+
def enable_monitoring(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
1751
1746
|
"""
|
|
1752
1747
|
Indicates whether monitoring is enabled for the instance.
|
|
1753
1748
|
"""
|
|
1754
1749
|
return pulumi.get(self, "enable_monitoring")
|
|
1755
1750
|
|
|
1756
1751
|
@enable_monitoring.setter
|
|
1757
|
-
def enable_monitoring(self, value: Optional[pulumi.Input[bool]]):
|
|
1752
|
+
def enable_monitoring(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
1758
1753
|
pulumi.set(self, "enable_monitoring", value)
|
|
1759
1754
|
|
|
1760
|
-
@property
|
|
1755
|
+
@_builtins.property
|
|
1761
1756
|
@pulumi.getter(name="ephemeralBlockDevices")
|
|
1762
1757
|
def ephemeral_block_devices(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupEphemeralBlockDeviceArgs']]]]:
|
|
1763
1758
|
return pulumi.get(self, "ephemeral_block_devices")
|
|
@@ -1766,79 +1761,79 @@ class _ElastigroupState:
|
|
|
1766
1761
|
def ephemeral_block_devices(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupEphemeralBlockDeviceArgs']]]]):
|
|
1767
1762
|
pulumi.set(self, "ephemeral_block_devices", value)
|
|
1768
1763
|
|
|
1769
|
-
@property
|
|
1764
|
+
@_builtins.property
|
|
1770
1765
|
@pulumi.getter(name="fallbackToOndemand")
|
|
1771
|
-
def fallback_to_ondemand(self) -> Optional[pulumi.Input[bool]]:
|
|
1766
|
+
def fallback_to_ondemand(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
1772
1767
|
"""
|
|
1773
1768
|
In a case of no Spot instances available, Elastigroup will launch on-demand instances instead.
|
|
1774
1769
|
"""
|
|
1775
1770
|
return pulumi.get(self, "fallback_to_ondemand")
|
|
1776
1771
|
|
|
1777
1772
|
@fallback_to_ondemand.setter
|
|
1778
|
-
def fallback_to_ondemand(self, value: Optional[pulumi.Input[bool]]):
|
|
1773
|
+
def fallback_to_ondemand(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
1779
1774
|
pulumi.set(self, "fallback_to_ondemand", value)
|
|
1780
1775
|
|
|
1781
|
-
@property
|
|
1776
|
+
@_builtins.property
|
|
1782
1777
|
@pulumi.getter(name="healthCheckGracePeriod")
|
|
1783
|
-
def health_check_grace_period(self) -> Optional[pulumi.Input[int]]:
|
|
1778
|
+
def health_check_grace_period(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
1784
1779
|
"""
|
|
1785
1780
|
The amount of time, in seconds, after the instance has launched to starts and check its health.
|
|
1786
1781
|
"""
|
|
1787
1782
|
return pulumi.get(self, "health_check_grace_period")
|
|
1788
1783
|
|
|
1789
1784
|
@health_check_grace_period.setter
|
|
1790
|
-
def health_check_grace_period(self, value: Optional[pulumi.Input[int]]):
|
|
1785
|
+
def health_check_grace_period(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
1791
1786
|
pulumi.set(self, "health_check_grace_period", value)
|
|
1792
1787
|
|
|
1793
|
-
@property
|
|
1788
|
+
@_builtins.property
|
|
1794
1789
|
@pulumi.getter(name="healthCheckType")
|
|
1795
|
-
def health_check_type(self) -> Optional[pulumi.Input[str]]:
|
|
1790
|
+
def health_check_type(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
1796
1791
|
"""
|
|
1797
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"`.
|
|
1798
1793
|
"""
|
|
1799
1794
|
return pulumi.get(self, "health_check_type")
|
|
1800
1795
|
|
|
1801
1796
|
@health_check_type.setter
|
|
1802
|
-
def health_check_type(self, value: Optional[pulumi.Input[str]]):
|
|
1797
|
+
def health_check_type(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
1803
1798
|
pulumi.set(self, "health_check_type", value)
|
|
1804
1799
|
|
|
1805
|
-
@property
|
|
1800
|
+
@_builtins.property
|
|
1806
1801
|
@pulumi.getter(name="healthCheckUnhealthyDurationBeforeReplacement")
|
|
1807
|
-
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]]:
|
|
1808
1803
|
"""
|
|
1809
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).
|
|
1810
1805
|
"""
|
|
1811
1806
|
return pulumi.get(self, "health_check_unhealthy_duration_before_replacement")
|
|
1812
1807
|
|
|
1813
1808
|
@health_check_unhealthy_duration_before_replacement.setter
|
|
1814
|
-
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]]):
|
|
1815
1810
|
pulumi.set(self, "health_check_unhealthy_duration_before_replacement", value)
|
|
1816
1811
|
|
|
1817
|
-
@property
|
|
1812
|
+
@_builtins.property
|
|
1818
1813
|
@pulumi.getter(name="iamInstanceProfile")
|
|
1819
|
-
def iam_instance_profile(self) -> Optional[pulumi.Input[str]]:
|
|
1814
|
+
def iam_instance_profile(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
1820
1815
|
"""
|
|
1821
1816
|
The ARN or name of an IAM instance profile to associate with launched instances.
|
|
1822
1817
|
"""
|
|
1823
1818
|
return pulumi.get(self, "iam_instance_profile")
|
|
1824
1819
|
|
|
1825
1820
|
@iam_instance_profile.setter
|
|
1826
|
-
def iam_instance_profile(self, value: Optional[pulumi.Input[str]]):
|
|
1821
|
+
def iam_instance_profile(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
1827
1822
|
pulumi.set(self, "iam_instance_profile", value)
|
|
1828
1823
|
|
|
1829
|
-
@property
|
|
1824
|
+
@_builtins.property
|
|
1830
1825
|
@pulumi.getter(name="imageId")
|
|
1831
|
-
def image_id(self) -> Optional[pulumi.Input[str]]:
|
|
1826
|
+
def image_id(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
1832
1827
|
"""
|
|
1833
1828
|
The ID of the AMI used to launch the instance.
|
|
1834
1829
|
"""
|
|
1835
1830
|
return pulumi.get(self, "image_id")
|
|
1836
1831
|
|
|
1837
1832
|
@image_id.setter
|
|
1838
|
-
def image_id(self, value: Optional[pulumi.Input[str]]):
|
|
1833
|
+
def image_id(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
1839
1834
|
pulumi.set(self, "image_id", value)
|
|
1840
1835
|
|
|
1841
|
-
@property
|
|
1836
|
+
@_builtins.property
|
|
1842
1837
|
@pulumi.getter
|
|
1843
1838
|
def images(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupImageArgs']]]]:
|
|
1844
1839
|
"""
|
|
@@ -1851,52 +1846,52 @@ class _ElastigroupState:
|
|
|
1851
1846
|
def images(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupImageArgs']]]]):
|
|
1852
1847
|
pulumi.set(self, "images", value)
|
|
1853
1848
|
|
|
1854
|
-
@property
|
|
1849
|
+
@_builtins.property
|
|
1855
1850
|
@pulumi.getter(name="immediateOdRecoverThreshold")
|
|
1856
|
-
def immediate_od_recover_threshold(self) -> Optional[pulumi.Input[int]]:
|
|
1851
|
+
def immediate_od_recover_threshold(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
1857
1852
|
return pulumi.get(self, "immediate_od_recover_threshold")
|
|
1858
1853
|
|
|
1859
1854
|
@immediate_od_recover_threshold.setter
|
|
1860
|
-
def immediate_od_recover_threshold(self, value: Optional[pulumi.Input[int]]):
|
|
1855
|
+
def immediate_od_recover_threshold(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
1861
1856
|
pulumi.set(self, "immediate_od_recover_threshold", value)
|
|
1862
1857
|
|
|
1863
|
-
@property
|
|
1858
|
+
@_builtins.property
|
|
1864
1859
|
@pulumi.getter(name="instanceTypesOndemand")
|
|
1865
|
-
def instance_types_ondemand(self) -> Optional[pulumi.Input[str]]:
|
|
1860
|
+
def instance_types_ondemand(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
1866
1861
|
"""
|
|
1867
1862
|
The type of instance determines your instance's CPU capacity, memory and storage (e.g., m1.small, c1.xlarge).
|
|
1868
1863
|
"""
|
|
1869
1864
|
return pulumi.get(self, "instance_types_ondemand")
|
|
1870
1865
|
|
|
1871
1866
|
@instance_types_ondemand.setter
|
|
1872
|
-
def instance_types_ondemand(self, value: Optional[pulumi.Input[str]]):
|
|
1867
|
+
def instance_types_ondemand(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
1873
1868
|
pulumi.set(self, "instance_types_ondemand", value)
|
|
1874
1869
|
|
|
1875
|
-
@property
|
|
1870
|
+
@_builtins.property
|
|
1876
1871
|
@pulumi.getter(name="instanceTypesPreferredSpots")
|
|
1877
|
-
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]]]]:
|
|
1878
1873
|
"""
|
|
1879
1874
|
Prioritize a subset of spot instance types. Must be a subset of the selected spot instance types.
|
|
1880
1875
|
"""
|
|
1881
1876
|
return pulumi.get(self, "instance_types_preferred_spots")
|
|
1882
1877
|
|
|
1883
1878
|
@instance_types_preferred_spots.setter
|
|
1884
|
-
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]]]]):
|
|
1885
1880
|
pulumi.set(self, "instance_types_preferred_spots", value)
|
|
1886
1881
|
|
|
1887
|
-
@property
|
|
1882
|
+
@_builtins.property
|
|
1888
1883
|
@pulumi.getter(name="instanceTypesSpots")
|
|
1889
|
-
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]]]]:
|
|
1890
1885
|
"""
|
|
1891
1886
|
One or more instance types. Note: Cannot be defined if 'resourceRequirements' is defined.
|
|
1892
1887
|
"""
|
|
1893
1888
|
return pulumi.get(self, "instance_types_spots")
|
|
1894
1889
|
|
|
1895
1890
|
@instance_types_spots.setter
|
|
1896
|
-
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]]]]):
|
|
1897
1892
|
pulumi.set(self, "instance_types_spots", value)
|
|
1898
1893
|
|
|
1899
|
-
@property
|
|
1894
|
+
@_builtins.property
|
|
1900
1895
|
@pulumi.getter(name="instanceTypesWeights")
|
|
1901
1896
|
def instance_types_weights(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupInstanceTypesWeightArgs']]]]:
|
|
1902
1897
|
"""
|
|
@@ -1908,7 +1903,7 @@ class _ElastigroupState:
|
|
|
1908
1903
|
def instance_types_weights(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupInstanceTypesWeightArgs']]]]):
|
|
1909
1904
|
pulumi.set(self, "instance_types_weights", value)
|
|
1910
1905
|
|
|
1911
|
-
@property
|
|
1906
|
+
@_builtins.property
|
|
1912
1907
|
@pulumi.getter(name="integrationBeanstalk")
|
|
1913
1908
|
def integration_beanstalk(self) -> Optional[pulumi.Input['ElastigroupIntegrationBeanstalkArgs']]:
|
|
1914
1909
|
return pulumi.get(self, "integration_beanstalk")
|
|
@@ -1917,7 +1912,7 @@ class _ElastigroupState:
|
|
|
1917
1912
|
def integration_beanstalk(self, value: Optional[pulumi.Input['ElastigroupIntegrationBeanstalkArgs']]):
|
|
1918
1913
|
pulumi.set(self, "integration_beanstalk", value)
|
|
1919
1914
|
|
|
1920
|
-
@property
|
|
1915
|
+
@_builtins.property
|
|
1921
1916
|
@pulumi.getter(name="integrationCodedeploy")
|
|
1922
1917
|
def integration_codedeploy(self) -> Optional[pulumi.Input['ElastigroupIntegrationCodedeployArgs']]:
|
|
1923
1918
|
return pulumi.get(self, "integration_codedeploy")
|
|
@@ -1926,7 +1921,7 @@ class _ElastigroupState:
|
|
|
1926
1921
|
def integration_codedeploy(self, value: Optional[pulumi.Input['ElastigroupIntegrationCodedeployArgs']]):
|
|
1927
1922
|
pulumi.set(self, "integration_codedeploy", value)
|
|
1928
1923
|
|
|
1929
|
-
@property
|
|
1924
|
+
@_builtins.property
|
|
1930
1925
|
@pulumi.getter(name="integrationDockerSwarm")
|
|
1931
1926
|
def integration_docker_swarm(self) -> Optional[pulumi.Input['ElastigroupIntegrationDockerSwarmArgs']]:
|
|
1932
1927
|
return pulumi.get(self, "integration_docker_swarm")
|
|
@@ -1935,7 +1930,7 @@ class _ElastigroupState:
|
|
|
1935
1930
|
def integration_docker_swarm(self, value: Optional[pulumi.Input['ElastigroupIntegrationDockerSwarmArgs']]):
|
|
1936
1931
|
pulumi.set(self, "integration_docker_swarm", value)
|
|
1937
1932
|
|
|
1938
|
-
@property
|
|
1933
|
+
@_builtins.property
|
|
1939
1934
|
@pulumi.getter(name="integrationEcs")
|
|
1940
1935
|
def integration_ecs(self) -> Optional[pulumi.Input['ElastigroupIntegrationEcsArgs']]:
|
|
1941
1936
|
return pulumi.get(self, "integration_ecs")
|
|
@@ -1944,7 +1939,7 @@ class _ElastigroupState:
|
|
|
1944
1939
|
def integration_ecs(self, value: Optional[pulumi.Input['ElastigroupIntegrationEcsArgs']]):
|
|
1945
1940
|
pulumi.set(self, "integration_ecs", value)
|
|
1946
1941
|
|
|
1947
|
-
@property
|
|
1942
|
+
@_builtins.property
|
|
1948
1943
|
@pulumi.getter(name="integrationGitlab")
|
|
1949
1944
|
def integration_gitlab(self) -> Optional[pulumi.Input['ElastigroupIntegrationGitlabArgs']]:
|
|
1950
1945
|
return pulumi.get(self, "integration_gitlab")
|
|
@@ -1953,7 +1948,7 @@ class _ElastigroupState:
|
|
|
1953
1948
|
def integration_gitlab(self, value: Optional[pulumi.Input['ElastigroupIntegrationGitlabArgs']]):
|
|
1954
1949
|
pulumi.set(self, "integration_gitlab", value)
|
|
1955
1950
|
|
|
1956
|
-
@property
|
|
1951
|
+
@_builtins.property
|
|
1957
1952
|
@pulumi.getter(name="integrationKubernetes")
|
|
1958
1953
|
def integration_kubernetes(self) -> Optional[pulumi.Input['ElastigroupIntegrationKubernetesArgs']]:
|
|
1959
1954
|
return pulumi.get(self, "integration_kubernetes")
|
|
@@ -1962,7 +1957,7 @@ class _ElastigroupState:
|
|
|
1962
1957
|
def integration_kubernetes(self, value: Optional[pulumi.Input['ElastigroupIntegrationKubernetesArgs']]):
|
|
1963
1958
|
pulumi.set(self, "integration_kubernetes", value)
|
|
1964
1959
|
|
|
1965
|
-
@property
|
|
1960
|
+
@_builtins.property
|
|
1966
1961
|
@pulumi.getter(name="integrationMesosphere")
|
|
1967
1962
|
def integration_mesosphere(self) -> Optional[pulumi.Input['ElastigroupIntegrationMesosphereArgs']]:
|
|
1968
1963
|
return pulumi.get(self, "integration_mesosphere")
|
|
@@ -1971,7 +1966,7 @@ class _ElastigroupState:
|
|
|
1971
1966
|
def integration_mesosphere(self, value: Optional[pulumi.Input['ElastigroupIntegrationMesosphereArgs']]):
|
|
1972
1967
|
pulumi.set(self, "integration_mesosphere", value)
|
|
1973
1968
|
|
|
1974
|
-
@property
|
|
1969
|
+
@_builtins.property
|
|
1975
1970
|
@pulumi.getter(name="integrationNomad")
|
|
1976
1971
|
def integration_nomad(self) -> Optional[pulumi.Input['ElastigroupIntegrationNomadArgs']]:
|
|
1977
1972
|
return pulumi.get(self, "integration_nomad")
|
|
@@ -1980,7 +1975,7 @@ class _ElastigroupState:
|
|
|
1980
1975
|
def integration_nomad(self, value: Optional[pulumi.Input['ElastigroupIntegrationNomadArgs']]):
|
|
1981
1976
|
pulumi.set(self, "integration_nomad", value)
|
|
1982
1977
|
|
|
1983
|
-
@property
|
|
1978
|
+
@_builtins.property
|
|
1984
1979
|
@pulumi.getter(name="integrationRancher")
|
|
1985
1980
|
def integration_rancher(self) -> Optional[pulumi.Input['ElastigroupIntegrationRancherArgs']]:
|
|
1986
1981
|
return pulumi.get(self, "integration_rancher")
|
|
@@ -1989,7 +1984,7 @@ class _ElastigroupState:
|
|
|
1989
1984
|
def integration_rancher(self, value: Optional[pulumi.Input['ElastigroupIntegrationRancherArgs']]):
|
|
1990
1985
|
pulumi.set(self, "integration_rancher", value)
|
|
1991
1986
|
|
|
1992
|
-
@property
|
|
1987
|
+
@_builtins.property
|
|
1993
1988
|
@pulumi.getter(name="integrationRoute53")
|
|
1994
1989
|
def integration_route53(self) -> Optional[pulumi.Input['ElastigroupIntegrationRoute53Args']]:
|
|
1995
1990
|
return pulumi.get(self, "integration_route53")
|
|
@@ -1998,7 +1993,7 @@ class _ElastigroupState:
|
|
|
1998
1993
|
def integration_route53(self, value: Optional[pulumi.Input['ElastigroupIntegrationRoute53Args']]):
|
|
1999
1994
|
pulumi.set(self, "integration_route53", value)
|
|
2000
1995
|
|
|
2001
|
-
@property
|
|
1996
|
+
@_builtins.property
|
|
2002
1997
|
@pulumi.getter
|
|
2003
1998
|
def itfs(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupItfArgs']]]]:
|
|
2004
1999
|
return pulumi.get(self, "itfs")
|
|
@@ -2007,28 +2002,28 @@ class _ElastigroupState:
|
|
|
2007
2002
|
def itfs(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupItfArgs']]]]):
|
|
2008
2003
|
pulumi.set(self, "itfs", value)
|
|
2009
2004
|
|
|
2010
|
-
@property
|
|
2005
|
+
@_builtins.property
|
|
2011
2006
|
@pulumi.getter(name="keyName")
|
|
2012
|
-
def key_name(self) -> Optional[pulumi.Input[str]]:
|
|
2007
|
+
def key_name(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
2013
2008
|
"""
|
|
2014
2009
|
The key name that should be used for the instance.
|
|
2015
2010
|
"""
|
|
2016
2011
|
return pulumi.get(self, "key_name")
|
|
2017
2012
|
|
|
2018
2013
|
@key_name.setter
|
|
2019
|
-
def key_name(self, value: Optional[pulumi.Input[str]]):
|
|
2014
|
+
def key_name(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
2020
2015
|
pulumi.set(self, "key_name", value)
|
|
2021
2016
|
|
|
2022
|
-
@property
|
|
2017
|
+
@_builtins.property
|
|
2023
2018
|
@pulumi.getter(name="lifetimePeriod")
|
|
2024
|
-
def lifetime_period(self) -> Optional[pulumi.Input[str]]:
|
|
2019
|
+
def lifetime_period(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
2025
2020
|
return pulumi.get(self, "lifetime_period")
|
|
2026
2021
|
|
|
2027
2022
|
@lifetime_period.setter
|
|
2028
|
-
def lifetime_period(self, value: Optional[pulumi.Input[str]]):
|
|
2023
|
+
def lifetime_period(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
2029
2024
|
pulumi.set(self, "lifetime_period", value)
|
|
2030
2025
|
|
|
2031
|
-
@property
|
|
2026
|
+
@_builtins.property
|
|
2032
2027
|
@pulumi.getter
|
|
2033
2028
|
def logging(self) -> Optional[pulumi.Input['ElastigroupLoggingArgs']]:
|
|
2034
2029
|
"""
|
|
@@ -2040,31 +2035,28 @@ class _ElastigroupState:
|
|
|
2040
2035
|
def logging(self, value: Optional[pulumi.Input['ElastigroupLoggingArgs']]):
|
|
2041
2036
|
pulumi.set(self, "logging", value)
|
|
2042
2037
|
|
|
2043
|
-
@property
|
|
2038
|
+
@_builtins.property
|
|
2044
2039
|
@pulumi.getter(name="maxReplacementsPercentage")
|
|
2045
|
-
def max_replacements_percentage(self) -> Optional[pulumi.Input[int]]:
|
|
2046
|
-
"""
|
|
2047
|
-
The percentage of active instances that can be replaced in parallel. This is used to prevent a large number of instances from being replaced at once.
|
|
2048
|
-
"""
|
|
2040
|
+
def max_replacements_percentage(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
2049
2041
|
return pulumi.get(self, "max_replacements_percentage")
|
|
2050
2042
|
|
|
2051
2043
|
@max_replacements_percentage.setter
|
|
2052
|
-
def max_replacements_percentage(self, value: Optional[pulumi.Input[int]]):
|
|
2044
|
+
def max_replacements_percentage(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
2053
2045
|
pulumi.set(self, "max_replacements_percentage", value)
|
|
2054
2046
|
|
|
2055
|
-
@property
|
|
2047
|
+
@_builtins.property
|
|
2056
2048
|
@pulumi.getter(name="maxSize")
|
|
2057
|
-
def max_size(self) -> Optional[pulumi.Input[int]]:
|
|
2049
|
+
def max_size(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
2058
2050
|
"""
|
|
2059
2051
|
The maximum number of instances the group should have at any time.
|
|
2060
2052
|
"""
|
|
2061
2053
|
return pulumi.get(self, "max_size")
|
|
2062
2054
|
|
|
2063
2055
|
@max_size.setter
|
|
2064
|
-
def max_size(self, value: Optional[pulumi.Input[int]]):
|
|
2056
|
+
def max_size(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
2065
2057
|
pulumi.set(self, "max_size", value)
|
|
2066
2058
|
|
|
2067
|
-
@property
|
|
2059
|
+
@_builtins.property
|
|
2068
2060
|
@pulumi.getter(name="metadataOptions")
|
|
2069
2061
|
def metadata_options(self) -> Optional[pulumi.Input['ElastigroupMetadataOptionsArgs']]:
|
|
2070
2062
|
"""
|
|
@@ -2076,31 +2068,31 @@ class _ElastigroupState:
|
|
|
2076
2068
|
def metadata_options(self, value: Optional[pulumi.Input['ElastigroupMetadataOptionsArgs']]):
|
|
2077
2069
|
pulumi.set(self, "metadata_options", value)
|
|
2078
2070
|
|
|
2079
|
-
@property
|
|
2071
|
+
@_builtins.property
|
|
2080
2072
|
@pulumi.getter(name="minSize")
|
|
2081
|
-
def min_size(self) -> Optional[pulumi.Input[int]]:
|
|
2073
|
+
def min_size(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
2082
2074
|
"""
|
|
2083
2075
|
The minimum number of instances the group should have at any time.
|
|
2084
2076
|
"""
|
|
2085
2077
|
return pulumi.get(self, "min_size")
|
|
2086
2078
|
|
|
2087
2079
|
@min_size.setter
|
|
2088
|
-
def min_size(self, value: Optional[pulumi.Input[int]]):
|
|
2080
|
+
def min_size(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
2089
2081
|
pulumi.set(self, "min_size", value)
|
|
2090
2082
|
|
|
2091
|
-
@property
|
|
2083
|
+
@_builtins.property
|
|
2092
2084
|
@pulumi.getter(name="minimumInstanceLifetime")
|
|
2093
|
-
def minimum_instance_lifetime(self) -> Optional[pulumi.Input[int]]:
|
|
2085
|
+
def minimum_instance_lifetime(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
2094
2086
|
"""
|
|
2095
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.
|
|
2096
2088
|
"""
|
|
2097
2089
|
return pulumi.get(self, "minimum_instance_lifetime")
|
|
2098
2090
|
|
|
2099
2091
|
@minimum_instance_lifetime.setter
|
|
2100
|
-
def minimum_instance_lifetime(self, value: Optional[pulumi.Input[int]]):
|
|
2092
|
+
def minimum_instance_lifetime(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
2101
2093
|
pulumi.set(self, "minimum_instance_lifetime", value)
|
|
2102
2094
|
|
|
2103
|
-
@property
|
|
2095
|
+
@_builtins.property
|
|
2104
2096
|
@pulumi.getter(name="multipleMetrics")
|
|
2105
2097
|
def multiple_metrics(self) -> Optional[pulumi.Input['ElastigroupMultipleMetricsArgs']]:
|
|
2106
2098
|
return pulumi.get(self, "multiple_metrics")
|
|
@@ -2109,19 +2101,19 @@ class _ElastigroupState:
|
|
|
2109
2101
|
def multiple_metrics(self, value: Optional[pulumi.Input['ElastigroupMultipleMetricsArgs']]):
|
|
2110
2102
|
pulumi.set(self, "multiple_metrics", value)
|
|
2111
2103
|
|
|
2112
|
-
@property
|
|
2104
|
+
@_builtins.property
|
|
2113
2105
|
@pulumi.getter
|
|
2114
|
-
def name(self) -> Optional[pulumi.Input[str]]:
|
|
2106
|
+
def name(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
2115
2107
|
"""
|
|
2116
2108
|
The group name.
|
|
2117
2109
|
"""
|
|
2118
2110
|
return pulumi.get(self, "name")
|
|
2119
2111
|
|
|
2120
2112
|
@name.setter
|
|
2121
|
-
def name(self, value: Optional[pulumi.Input[str]]):
|
|
2113
|
+
def name(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
2122
2114
|
pulumi.set(self, "name", value)
|
|
2123
2115
|
|
|
2124
|
-
@property
|
|
2116
|
+
@_builtins.property
|
|
2125
2117
|
@pulumi.getter(name="networkInterfaces")
|
|
2126
2118
|
def network_interfaces(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupNetworkInterfaceArgs']]]]:
|
|
2127
2119
|
return pulumi.get(self, "network_interfaces")
|
|
@@ -2130,84 +2122,84 @@ class _ElastigroupState:
|
|
|
2130
2122
|
def network_interfaces(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupNetworkInterfaceArgs']]]]):
|
|
2131
2123
|
pulumi.set(self, "network_interfaces", value)
|
|
2132
2124
|
|
|
2133
|
-
@property
|
|
2125
|
+
@_builtins.property
|
|
2134
2126
|
@pulumi.getter(name="onDemandTypes")
|
|
2135
|
-
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]]]]:
|
|
2136
2128
|
"""
|
|
2137
2129
|
Available ondemand instance types. Note: Either ondemand or onDemandTypes must be defined, but not both.
|
|
2138
2130
|
"""
|
|
2139
2131
|
return pulumi.get(self, "on_demand_types")
|
|
2140
2132
|
|
|
2141
2133
|
@on_demand_types.setter
|
|
2142
|
-
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]]]]):
|
|
2143
2135
|
pulumi.set(self, "on_demand_types", value)
|
|
2144
2136
|
|
|
2145
|
-
@property
|
|
2137
|
+
@_builtins.property
|
|
2146
2138
|
@pulumi.getter(name="ondemandCount")
|
|
2147
|
-
def ondemand_count(self) -> Optional[pulumi.Input[int]]:
|
|
2139
|
+
def ondemand_count(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
2148
2140
|
"""
|
|
2149
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.
|
|
2150
2142
|
"""
|
|
2151
2143
|
return pulumi.get(self, "ondemand_count")
|
|
2152
2144
|
|
|
2153
2145
|
@ondemand_count.setter
|
|
2154
|
-
def ondemand_count(self, value: Optional[pulumi.Input[int]]):
|
|
2146
|
+
def ondemand_count(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
2155
2147
|
pulumi.set(self, "ondemand_count", value)
|
|
2156
2148
|
|
|
2157
|
-
@property
|
|
2149
|
+
@_builtins.property
|
|
2158
2150
|
@pulumi.getter
|
|
2159
|
-
def orientation(self) -> Optional[pulumi.Input[str]]:
|
|
2151
|
+
def orientation(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
2160
2152
|
"""
|
|
2161
2153
|
Select a prediction strategy. Valid values: `balanced`, `costOriented`, `equalAzDistribution`, `availabilityOriented`. You can read more in our documentation.
|
|
2162
2154
|
"""
|
|
2163
2155
|
return pulumi.get(self, "orientation")
|
|
2164
2156
|
|
|
2165
2157
|
@orientation.setter
|
|
2166
|
-
def orientation(self, value: Optional[pulumi.Input[str]]):
|
|
2158
|
+
def orientation(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
2167
2159
|
pulumi.set(self, "orientation", value)
|
|
2168
2160
|
|
|
2169
|
-
@property
|
|
2161
|
+
@_builtins.property
|
|
2170
2162
|
@pulumi.getter(name="persistBlockDevices")
|
|
2171
|
-
def persist_block_devices(self) -> Optional[pulumi.Input[bool]]:
|
|
2163
|
+
def persist_block_devices(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
2172
2164
|
return pulumi.get(self, "persist_block_devices")
|
|
2173
2165
|
|
|
2174
2166
|
@persist_block_devices.setter
|
|
2175
|
-
def persist_block_devices(self, value: Optional[pulumi.Input[bool]]):
|
|
2167
|
+
def persist_block_devices(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
2176
2168
|
pulumi.set(self, "persist_block_devices", value)
|
|
2177
2169
|
|
|
2178
|
-
@property
|
|
2170
|
+
@_builtins.property
|
|
2179
2171
|
@pulumi.getter(name="persistPrivateIp")
|
|
2180
|
-
def persist_private_ip(self) -> Optional[pulumi.Input[bool]]:
|
|
2172
|
+
def persist_private_ip(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
2181
2173
|
return pulumi.get(self, "persist_private_ip")
|
|
2182
2174
|
|
|
2183
2175
|
@persist_private_ip.setter
|
|
2184
|
-
def persist_private_ip(self, value: Optional[pulumi.Input[bool]]):
|
|
2176
|
+
def persist_private_ip(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
2185
2177
|
pulumi.set(self, "persist_private_ip", value)
|
|
2186
2178
|
|
|
2187
|
-
@property
|
|
2179
|
+
@_builtins.property
|
|
2188
2180
|
@pulumi.getter(name="persistRootDevice")
|
|
2189
|
-
def persist_root_device(self) -> Optional[pulumi.Input[bool]]:
|
|
2181
|
+
def persist_root_device(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
2190
2182
|
return pulumi.get(self, "persist_root_device")
|
|
2191
2183
|
|
|
2192
2184
|
@persist_root_device.setter
|
|
2193
|
-
def persist_root_device(self, value: Optional[pulumi.Input[bool]]):
|
|
2185
|
+
def persist_root_device(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
2194
2186
|
pulumi.set(self, "persist_root_device", value)
|
|
2195
2187
|
|
|
2196
|
-
@property
|
|
2188
|
+
@_builtins.property
|
|
2197
2189
|
@pulumi.getter(name="placementTenancy")
|
|
2198
|
-
def placement_tenancy(self) -> Optional[pulumi.Input[str]]:
|
|
2190
|
+
def placement_tenancy(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
2199
2191
|
"""
|
|
2200
2192
|
Enable dedicated tenancy. Note: There is a flat hourly fee for each region in which dedicated tenancy is used. Valid values: "default", "dedicated" .
|
|
2201
2193
|
"""
|
|
2202
2194
|
return pulumi.get(self, "placement_tenancy")
|
|
2203
2195
|
|
|
2204
2196
|
@placement_tenancy.setter
|
|
2205
|
-
def placement_tenancy(self, value: Optional[pulumi.Input[str]]):
|
|
2197
|
+
def placement_tenancy(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
2206
2198
|
pulumi.set(self, "placement_tenancy", value)
|
|
2207
2199
|
|
|
2208
|
-
@property
|
|
2200
|
+
@_builtins.property
|
|
2209
2201
|
@pulumi.getter(name="preferredAvailabilityZones")
|
|
2210
|
-
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]]]]:
|
|
2211
2203
|
"""
|
|
2212
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.
|
|
2213
2205
|
Note: Must be a sublist of `availability_zones` and `orientation` value must not be `"equalAzDistribution"`.
|
|
@@ -2215,21 +2207,21 @@ class _ElastigroupState:
|
|
|
2215
2207
|
return pulumi.get(self, "preferred_availability_zones")
|
|
2216
2208
|
|
|
2217
2209
|
@preferred_availability_zones.setter
|
|
2218
|
-
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]]]]):
|
|
2219
2211
|
pulumi.set(self, "preferred_availability_zones", value)
|
|
2220
2212
|
|
|
2221
|
-
@property
|
|
2213
|
+
@_builtins.property
|
|
2222
2214
|
@pulumi.getter(name="privateIps")
|
|
2223
|
-
def private_ips(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
|
|
2215
|
+
def private_ips(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
|
|
2224
2216
|
return pulumi.get(self, "private_ips")
|
|
2225
2217
|
|
|
2226
2218
|
@private_ips.setter
|
|
2227
|
-
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]]]]):
|
|
2228
2220
|
pulumi.set(self, "private_ips", value)
|
|
2229
2221
|
|
|
2230
|
-
@property
|
|
2222
|
+
@_builtins.property
|
|
2231
2223
|
@pulumi.getter
|
|
2232
|
-
def product(self) -> Optional[pulumi.Input[str]]:
|
|
2224
|
+
def product(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
2233
2225
|
"""
|
|
2234
2226
|
Operation system type. Valid values: `"Linux/UNIX"`, `"SUSE Linux"`, `"Windows"`.
|
|
2235
2227
|
For EC2 Classic instances: `"SUSE Linux (Amazon VPC)"`, `"Windows (Amazon VPC)"`.
|
|
@@ -2237,12 +2229,12 @@ class _ElastigroupState:
|
|
|
2237
2229
|
return pulumi.get(self, "product")
|
|
2238
2230
|
|
|
2239
2231
|
@product.setter
|
|
2240
|
-
def product(self, value: Optional[pulumi.Input[str]]):
|
|
2232
|
+
def product(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
2241
2233
|
pulumi.set(self, "product", value)
|
|
2242
2234
|
|
|
2243
|
-
@property
|
|
2235
|
+
@_builtins.property
|
|
2244
2236
|
@pulumi.getter
|
|
2245
|
-
def region(self) -> Optional[pulumi.Input[str]]:
|
|
2237
|
+
def region(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
2246
2238
|
"""
|
|
2247
2239
|
The AWS region your group will be created in.
|
|
2248
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).
|
|
@@ -2250,10 +2242,10 @@ class _ElastigroupState:
|
|
|
2250
2242
|
return pulumi.get(self, "region")
|
|
2251
2243
|
|
|
2252
2244
|
@region.setter
|
|
2253
|
-
def region(self, value: Optional[pulumi.Input[str]]):
|
|
2245
|
+
def region(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
2254
2246
|
pulumi.set(self, "region", value)
|
|
2255
2247
|
|
|
2256
|
-
@property
|
|
2248
|
+
@_builtins.property
|
|
2257
2249
|
@pulumi.getter(name="resourceRequirements")
|
|
2258
2250
|
def resource_requirements(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupResourceRequirementArgs']]]]:
|
|
2259
2251
|
"""
|
|
@@ -2265,7 +2257,7 @@ class _ElastigroupState:
|
|
|
2265
2257
|
def resource_requirements(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupResourceRequirementArgs']]]]):
|
|
2266
2258
|
pulumi.set(self, "resource_requirements", value)
|
|
2267
2259
|
|
|
2268
|
-
@property
|
|
2260
|
+
@_builtins.property
|
|
2269
2261
|
@pulumi.getter(name="resourceTagSpecifications")
|
|
2270
2262
|
def resource_tag_specifications(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupResourceTagSpecificationArgs']]]]:
|
|
2271
2263
|
"""
|
|
@@ -2277,19 +2269,19 @@ class _ElastigroupState:
|
|
|
2277
2269
|
def resource_tag_specifications(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupResourceTagSpecificationArgs']]]]):
|
|
2278
2270
|
pulumi.set(self, "resource_tag_specifications", value)
|
|
2279
2271
|
|
|
2280
|
-
@property
|
|
2272
|
+
@_builtins.property
|
|
2281
2273
|
@pulumi.getter(name="restrictSingleAz")
|
|
2282
|
-
def restrict_single_az(self) -> Optional[pulumi.Input[bool]]:
|
|
2274
|
+
def restrict_single_az(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
2283
2275
|
"""
|
|
2284
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.
|
|
2285
2277
|
"""
|
|
2286
2278
|
return pulumi.get(self, "restrict_single_az")
|
|
2287
2279
|
|
|
2288
2280
|
@restrict_single_az.setter
|
|
2289
|
-
def restrict_single_az(self, value: Optional[pulumi.Input[bool]]):
|
|
2281
|
+
def restrict_single_az(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
2290
2282
|
pulumi.set(self, "restrict_single_az", value)
|
|
2291
2283
|
|
|
2292
|
-
@property
|
|
2284
|
+
@_builtins.property
|
|
2293
2285
|
@pulumi.getter(name="revertToSpot")
|
|
2294
2286
|
def revert_to_spot(self) -> Optional[pulumi.Input['ElastigroupRevertToSpotArgs']]:
|
|
2295
2287
|
"""
|
|
@@ -2301,7 +2293,7 @@ class _ElastigroupState:
|
|
|
2301
2293
|
def revert_to_spot(self, value: Optional[pulumi.Input['ElastigroupRevertToSpotArgs']]):
|
|
2302
2294
|
pulumi.set(self, "revert_to_spot", value)
|
|
2303
2295
|
|
|
2304
|
-
@property
|
|
2296
|
+
@_builtins.property
|
|
2305
2297
|
@pulumi.getter(name="scalingDownPolicies")
|
|
2306
2298
|
def scaling_down_policies(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupScalingDownPolicyArgs']]]]:
|
|
2307
2299
|
return pulumi.get(self, "scaling_down_policies")
|
|
@@ -2310,7 +2302,7 @@ class _ElastigroupState:
|
|
|
2310
2302
|
def scaling_down_policies(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupScalingDownPolicyArgs']]]]):
|
|
2311
2303
|
pulumi.set(self, "scaling_down_policies", value)
|
|
2312
2304
|
|
|
2313
|
-
@property
|
|
2305
|
+
@_builtins.property
|
|
2314
2306
|
@pulumi.getter(name="scalingStrategies")
|
|
2315
2307
|
def scaling_strategies(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupScalingStrategyArgs']]]]:
|
|
2316
2308
|
"""
|
|
@@ -2322,7 +2314,7 @@ class _ElastigroupState:
|
|
|
2322
2314
|
def scaling_strategies(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupScalingStrategyArgs']]]]):
|
|
2323
2315
|
pulumi.set(self, "scaling_strategies", value)
|
|
2324
2316
|
|
|
2325
|
-
@property
|
|
2317
|
+
@_builtins.property
|
|
2326
2318
|
@pulumi.getter(name="scalingTargetPolicies")
|
|
2327
2319
|
def scaling_target_policies(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupScalingTargetPolicyArgs']]]]:
|
|
2328
2320
|
return pulumi.get(self, "scaling_target_policies")
|
|
@@ -2331,7 +2323,7 @@ class _ElastigroupState:
|
|
|
2331
2323
|
def scaling_target_policies(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupScalingTargetPolicyArgs']]]]):
|
|
2332
2324
|
pulumi.set(self, "scaling_target_policies", value)
|
|
2333
2325
|
|
|
2334
|
-
@property
|
|
2326
|
+
@_builtins.property
|
|
2335
2327
|
@pulumi.getter(name="scalingUpPolicies")
|
|
2336
2328
|
def scaling_up_policies(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupScalingUpPolicyArgs']]]]:
|
|
2337
2329
|
return pulumi.get(self, "scaling_up_policies")
|
|
@@ -2340,7 +2332,7 @@ class _ElastigroupState:
|
|
|
2340
2332
|
def scaling_up_policies(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupScalingUpPolicyArgs']]]]):
|
|
2341
2333
|
pulumi.set(self, "scaling_up_policies", value)
|
|
2342
2334
|
|
|
2343
|
-
@property
|
|
2335
|
+
@_builtins.property
|
|
2344
2336
|
@pulumi.getter(name="scheduledTasks")
|
|
2345
2337
|
def scheduled_tasks(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupScheduledTaskArgs']]]]:
|
|
2346
2338
|
return pulumi.get(self, "scheduled_tasks")
|
|
@@ -2349,31 +2341,31 @@ class _ElastigroupState:
|
|
|
2349
2341
|
def scheduled_tasks(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupScheduledTaskArgs']]]]):
|
|
2350
2342
|
pulumi.set(self, "scheduled_tasks", value)
|
|
2351
2343
|
|
|
2352
|
-
@property
|
|
2344
|
+
@_builtins.property
|
|
2353
2345
|
@pulumi.getter(name="securityGroups")
|
|
2354
|
-
def security_groups(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
|
|
2346
|
+
def security_groups(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
|
|
2355
2347
|
"""
|
|
2356
2348
|
A list of associated security group IDS.
|
|
2357
2349
|
"""
|
|
2358
2350
|
return pulumi.get(self, "security_groups")
|
|
2359
2351
|
|
|
2360
2352
|
@security_groups.setter
|
|
2361
|
-
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]]]]):
|
|
2362
2354
|
pulumi.set(self, "security_groups", value)
|
|
2363
2355
|
|
|
2364
|
-
@property
|
|
2356
|
+
@_builtins.property
|
|
2365
2357
|
@pulumi.getter(name="shutdownScript")
|
|
2366
|
-
def shutdown_script(self) -> Optional[pulumi.Input[str]]:
|
|
2358
|
+
def shutdown_script(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
2367
2359
|
"""
|
|
2368
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/)
|
|
2369
2361
|
"""
|
|
2370
2362
|
return pulumi.get(self, "shutdown_script")
|
|
2371
2363
|
|
|
2372
2364
|
@shutdown_script.setter
|
|
2373
|
-
def shutdown_script(self, value: Optional[pulumi.Input[str]]):
|
|
2365
|
+
def shutdown_script(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
2374
2366
|
pulumi.set(self, "shutdown_script", value)
|
|
2375
2367
|
|
|
2376
|
-
@property
|
|
2368
|
+
@_builtins.property
|
|
2377
2369
|
@pulumi.getter
|
|
2378
2370
|
def signals(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupSignalArgs']]]]:
|
|
2379
2371
|
return pulumi.get(self, "signals")
|
|
@@ -2382,19 +2374,19 @@ class _ElastigroupState:
|
|
|
2382
2374
|
def signals(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupSignalArgs']]]]):
|
|
2383
2375
|
pulumi.set(self, "signals", value)
|
|
2384
2376
|
|
|
2385
|
-
@property
|
|
2377
|
+
@_builtins.property
|
|
2386
2378
|
@pulumi.getter(name="spotPercentage")
|
|
2387
|
-
def spot_percentage(self) -> Optional[pulumi.Input[int]]:
|
|
2379
|
+
def spot_percentage(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
2388
2380
|
"""
|
|
2389
2381
|
The percentage of Spot instances that would spin up from the `desired_capacity` number.
|
|
2390
2382
|
"""
|
|
2391
2383
|
return pulumi.get(self, "spot_percentage")
|
|
2392
2384
|
|
|
2393
2385
|
@spot_percentage.setter
|
|
2394
|
-
def spot_percentage(self, value: Optional[pulumi.Input[int]]):
|
|
2386
|
+
def spot_percentage(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
2395
2387
|
pulumi.set(self, "spot_percentage", value)
|
|
2396
2388
|
|
|
2397
|
-
@property
|
|
2389
|
+
@_builtins.property
|
|
2398
2390
|
@pulumi.getter(name="statefulDeallocation")
|
|
2399
2391
|
def stateful_deallocation(self) -> Optional[pulumi.Input['ElastigroupStatefulDeallocationArgs']]:
|
|
2400
2392
|
return pulumi.get(self, "stateful_deallocation")
|
|
@@ -2403,7 +2395,7 @@ class _ElastigroupState:
|
|
|
2403
2395
|
def stateful_deallocation(self, value: Optional[pulumi.Input['ElastigroupStatefulDeallocationArgs']]):
|
|
2404
2396
|
pulumi.set(self, "stateful_deallocation", value)
|
|
2405
2397
|
|
|
2406
|
-
@property
|
|
2398
|
+
@_builtins.property
|
|
2407
2399
|
@pulumi.getter(name="statefulInstanceActions")
|
|
2408
2400
|
def stateful_instance_actions(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupStatefulInstanceActionArgs']]]]:
|
|
2409
2401
|
return pulumi.get(self, "stateful_instance_actions")
|
|
@@ -2412,10 +2404,10 @@ class _ElastigroupState:
|
|
|
2412
2404
|
def stateful_instance_actions(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupStatefulInstanceActionArgs']]]]):
|
|
2413
2405
|
pulumi.set(self, "stateful_instance_actions", value)
|
|
2414
2406
|
|
|
2415
|
-
@property
|
|
2407
|
+
@_builtins.property
|
|
2416
2408
|
@pulumi.getter(name="subnetIds")
|
|
2417
2409
|
@_utilities.deprecated("""This field will soon be deprecated and handled by availability_zones""")
|
|
2418
|
-
def subnet_ids(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
|
|
2410
|
+
def subnet_ids(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
|
|
2419
2411
|
"""
|
|
2420
2412
|
List of Strings of subnet identifiers.
|
|
2421
2413
|
Note: When this parameter is set, `availability_zones` should be left unused.
|
|
@@ -2423,10 +2415,10 @@ class _ElastigroupState:
|
|
|
2423
2415
|
return pulumi.get(self, "subnet_ids")
|
|
2424
2416
|
|
|
2425
2417
|
@subnet_ids.setter
|
|
2426
|
-
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]]]]):
|
|
2427
2419
|
pulumi.set(self, "subnet_ids", value)
|
|
2428
2420
|
|
|
2429
|
-
@property
|
|
2421
|
+
@_builtins.property
|
|
2430
2422
|
@pulumi.getter
|
|
2431
2423
|
def tags(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupTagArgs']]]]:
|
|
2432
2424
|
"""
|
|
@@ -2438,16 +2430,16 @@ class _ElastigroupState:
|
|
|
2438
2430
|
def tags(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupTagArgs']]]]):
|
|
2439
2431
|
pulumi.set(self, "tags", value)
|
|
2440
2432
|
|
|
2441
|
-
@property
|
|
2433
|
+
@_builtins.property
|
|
2442
2434
|
@pulumi.getter(name="targetGroupArns")
|
|
2443
|
-
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]]]]:
|
|
2444
2436
|
return pulumi.get(self, "target_group_arns")
|
|
2445
2437
|
|
|
2446
2438
|
@target_group_arns.setter
|
|
2447
|
-
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]]]]):
|
|
2448
2440
|
pulumi.set(self, "target_group_arns", value)
|
|
2449
2441
|
|
|
2450
|
-
@property
|
|
2442
|
+
@_builtins.property
|
|
2451
2443
|
@pulumi.getter(name="updatePolicy")
|
|
2452
2444
|
def update_policy(self) -> Optional[pulumi.Input['ElastigroupUpdatePolicyArgs']]:
|
|
2453
2445
|
return pulumi.get(self, "update_policy")
|
|
@@ -2456,96 +2448,97 @@ class _ElastigroupState:
|
|
|
2456
2448
|
def update_policy(self, value: Optional[pulumi.Input['ElastigroupUpdatePolicyArgs']]):
|
|
2457
2449
|
pulumi.set(self, "update_policy", value)
|
|
2458
2450
|
|
|
2459
|
-
@property
|
|
2451
|
+
@_builtins.property
|
|
2460
2452
|
@pulumi.getter(name="userData")
|
|
2461
|
-
def user_data(self) -> Optional[pulumi.Input[str]]:
|
|
2453
|
+
def user_data(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
2462
2454
|
"""
|
|
2463
2455
|
The user data to provide when launching the instance.
|
|
2464
2456
|
"""
|
|
2465
2457
|
return pulumi.get(self, "user_data")
|
|
2466
2458
|
|
|
2467
2459
|
@user_data.setter
|
|
2468
|
-
def user_data(self, value: Optional[pulumi.Input[str]]):
|
|
2460
|
+
def user_data(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
2469
2461
|
pulumi.set(self, "user_data", value)
|
|
2470
2462
|
|
|
2471
|
-
@property
|
|
2463
|
+
@_builtins.property
|
|
2472
2464
|
@pulumi.getter(name="utilizeCommitments")
|
|
2473
|
-
def utilize_commitments(self) -> Optional[pulumi.Input[bool]]:
|
|
2465
|
+
def utilize_commitments(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
2474
2466
|
return pulumi.get(self, "utilize_commitments")
|
|
2475
2467
|
|
|
2476
2468
|
@utilize_commitments.setter
|
|
2477
|
-
def utilize_commitments(self, value: Optional[pulumi.Input[bool]]):
|
|
2469
|
+
def utilize_commitments(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
2478
2470
|
pulumi.set(self, "utilize_commitments", value)
|
|
2479
2471
|
|
|
2480
|
-
@property
|
|
2472
|
+
@_builtins.property
|
|
2481
2473
|
@pulumi.getter(name="utilizeReservedInstances")
|
|
2482
|
-
def utilize_reserved_instances(self) -> Optional[pulumi.Input[bool]]:
|
|
2474
|
+
def utilize_reserved_instances(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
2483
2475
|
"""
|
|
2484
2476
|
In a case of any available reserved instances, Elastigroup will utilize them first before purchasing Spot instances.
|
|
2485
2477
|
"""
|
|
2486
2478
|
return pulumi.get(self, "utilize_reserved_instances")
|
|
2487
2479
|
|
|
2488
2480
|
@utilize_reserved_instances.setter
|
|
2489
|
-
def utilize_reserved_instances(self, value: Optional[pulumi.Input[bool]]):
|
|
2481
|
+
def utilize_reserved_instances(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
2490
2482
|
pulumi.set(self, "utilize_reserved_instances", value)
|
|
2491
2483
|
|
|
2492
|
-
@property
|
|
2484
|
+
@_builtins.property
|
|
2493
2485
|
@pulumi.getter(name="waitForCapacity")
|
|
2494
|
-
def wait_for_capacity(self) -> Optional[pulumi.Input[int]]:
|
|
2486
|
+
def wait_for_capacity(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
2495
2487
|
"""
|
|
2496
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`.
|
|
2497
2489
|
"""
|
|
2498
2490
|
return pulumi.get(self, "wait_for_capacity")
|
|
2499
2491
|
|
|
2500
2492
|
@wait_for_capacity.setter
|
|
2501
|
-
def wait_for_capacity(self, value: Optional[pulumi.Input[int]]):
|
|
2493
|
+
def wait_for_capacity(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
2502
2494
|
pulumi.set(self, "wait_for_capacity", value)
|
|
2503
2495
|
|
|
2504
|
-
@property
|
|
2496
|
+
@_builtins.property
|
|
2505
2497
|
@pulumi.getter(name="waitForCapacityTimeout")
|
|
2506
|
-
def wait_for_capacity_timeout(self) -> Optional[pulumi.Input[int]]:
|
|
2498
|
+
def wait_for_capacity_timeout(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
2507
2499
|
"""
|
|
2508
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.
|
|
2509
2501
|
"""
|
|
2510
2502
|
return pulumi.get(self, "wait_for_capacity_timeout")
|
|
2511
2503
|
|
|
2512
2504
|
@wait_for_capacity_timeout.setter
|
|
2513
|
-
def wait_for_capacity_timeout(self, value: Optional[pulumi.Input[int]]):
|
|
2505
|
+
def wait_for_capacity_timeout(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
2514
2506
|
pulumi.set(self, "wait_for_capacity_timeout", value)
|
|
2515
2507
|
|
|
2516
2508
|
|
|
2509
|
+
@pulumi.type_token("spotinst:aws/elastigroup:Elastigroup")
|
|
2517
2510
|
class Elastigroup(pulumi.CustomResource):
|
|
2518
2511
|
@overload
|
|
2519
2512
|
def __init__(__self__,
|
|
2520
2513
|
resource_name: str,
|
|
2521
2514
|
opts: Optional[pulumi.ResourceOptions] = None,
|
|
2522
|
-
auto_healing: Optional[pulumi.Input[bool]] = None,
|
|
2523
|
-
availability_zones: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
|
|
2524
|
-
block_devices_mode: Optional[pulumi.Input[str]] = None,
|
|
2525
|
-
capacity_unit: Optional[pulumi.Input[str]] = None,
|
|
2526
|
-
consider_od_pricing: Optional[pulumi.Input[bool]] = None,
|
|
2527
|
-
cpu_credits: Optional[pulumi.Input[str]] = None,
|
|
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,
|
|
2528
2521
|
cpu_options: Optional[pulumi.Input[Union['ElastigroupCpuOptionsArgs', 'ElastigroupCpuOptionsArgsDict']]] = None,
|
|
2529
|
-
description: Optional[pulumi.Input[str]] = None,
|
|
2530
|
-
desired_capacity: Optional[pulumi.Input[int]] = None,
|
|
2531
|
-
draining_timeout: Optional[pulumi.Input[int]] = 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,
|
|
2532
2525
|
ebs_block_devices: Optional[pulumi.Input[Sequence[pulumi.Input[Union['ElastigroupEbsBlockDeviceArgs', 'ElastigroupEbsBlockDeviceArgsDict']]]]] = None,
|
|
2533
|
-
ebs_optimized: Optional[pulumi.Input[bool]] = None,
|
|
2534
|
-
elastic_ips: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
|
|
2535
|
-
elastic_load_balancers: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
|
|
2536
|
-
enable_monitoring: Optional[pulumi.Input[bool]] = 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,
|
|
2537
2530
|
ephemeral_block_devices: Optional[pulumi.Input[Sequence[pulumi.Input[Union['ElastigroupEphemeralBlockDeviceArgs', 'ElastigroupEphemeralBlockDeviceArgsDict']]]]] = None,
|
|
2538
|
-
fallback_to_ondemand: Optional[pulumi.Input[bool]] = None,
|
|
2539
|
-
health_check_grace_period: Optional[pulumi.Input[int]] = None,
|
|
2540
|
-
health_check_type: Optional[pulumi.Input[str]] = None,
|
|
2541
|
-
health_check_unhealthy_duration_before_replacement: Optional[pulumi.Input[int]] = None,
|
|
2542
|
-
iam_instance_profile: Optional[pulumi.Input[str]] = None,
|
|
2543
|
-
image_id: Optional[pulumi.Input[str]] = 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,
|
|
2544
2537
|
images: Optional[pulumi.Input[Sequence[pulumi.Input[Union['ElastigroupImageArgs', 'ElastigroupImageArgsDict']]]]] = None,
|
|
2545
|
-
immediate_od_recover_threshold: Optional[pulumi.Input[int]] = None,
|
|
2546
|
-
instance_types_ondemand: Optional[pulumi.Input[str]] = None,
|
|
2547
|
-
instance_types_preferred_spots: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
|
|
2548
|
-
instance_types_spots: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = 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,
|
|
2549
2542
|
instance_types_weights: Optional[pulumi.Input[Sequence[pulumi.Input[Union['ElastigroupInstanceTypesWeightArgs', 'ElastigroupInstanceTypesWeightArgsDict']]]]] = None,
|
|
2550
2543
|
integration_beanstalk: Optional[pulumi.Input[Union['ElastigroupIntegrationBeanstalkArgs', 'ElastigroupIntegrationBeanstalkArgsDict']]] = None,
|
|
2551
2544
|
integration_codedeploy: Optional[pulumi.Input[Union['ElastigroupIntegrationCodedeployArgs', 'ElastigroupIntegrationCodedeployArgsDict']]] = None,
|
|
@@ -2558,52 +2551,52 @@ class Elastigroup(pulumi.CustomResource):
|
|
|
2558
2551
|
integration_rancher: Optional[pulumi.Input[Union['ElastigroupIntegrationRancherArgs', 'ElastigroupIntegrationRancherArgsDict']]] = None,
|
|
2559
2552
|
integration_route53: Optional[pulumi.Input[Union['ElastigroupIntegrationRoute53Args', 'ElastigroupIntegrationRoute53ArgsDict']]] = None,
|
|
2560
2553
|
itfs: Optional[pulumi.Input[Sequence[pulumi.Input[Union['ElastigroupItfArgs', 'ElastigroupItfArgsDict']]]]] = None,
|
|
2561
|
-
key_name: Optional[pulumi.Input[str]] = None,
|
|
2562
|
-
lifetime_period: Optional[pulumi.Input[str]] = None,
|
|
2554
|
+
key_name: Optional[pulumi.Input[_builtins.str]] = None,
|
|
2555
|
+
lifetime_period: Optional[pulumi.Input[_builtins.str]] = None,
|
|
2563
2556
|
logging: Optional[pulumi.Input[Union['ElastigroupLoggingArgs', 'ElastigroupLoggingArgsDict']]] = None,
|
|
2564
|
-
max_replacements_percentage: Optional[pulumi.Input[int]] = None,
|
|
2565
|
-
max_size: Optional[pulumi.Input[int]] = None,
|
|
2557
|
+
max_replacements_percentage: Optional[pulumi.Input[_builtins.int]] = None,
|
|
2558
|
+
max_size: Optional[pulumi.Input[_builtins.int]] = None,
|
|
2566
2559
|
metadata_options: Optional[pulumi.Input[Union['ElastigroupMetadataOptionsArgs', 'ElastigroupMetadataOptionsArgsDict']]] = None,
|
|
2567
|
-
min_size: Optional[pulumi.Input[int]] = None,
|
|
2568
|
-
minimum_instance_lifetime: Optional[pulumi.Input[int]] = None,
|
|
2560
|
+
min_size: Optional[pulumi.Input[_builtins.int]] = None,
|
|
2561
|
+
minimum_instance_lifetime: Optional[pulumi.Input[_builtins.int]] = None,
|
|
2569
2562
|
multiple_metrics: Optional[pulumi.Input[Union['ElastigroupMultipleMetricsArgs', 'ElastigroupMultipleMetricsArgsDict']]] = None,
|
|
2570
|
-
name: Optional[pulumi.Input[str]] = None,
|
|
2563
|
+
name: Optional[pulumi.Input[_builtins.str]] = None,
|
|
2571
2564
|
network_interfaces: Optional[pulumi.Input[Sequence[pulumi.Input[Union['ElastigroupNetworkInterfaceArgs', 'ElastigroupNetworkInterfaceArgsDict']]]]] = None,
|
|
2572
|
-
on_demand_types: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
|
|
2573
|
-
ondemand_count: Optional[pulumi.Input[int]] = None,
|
|
2574
|
-
orientation: Optional[pulumi.Input[str]] = None,
|
|
2575
|
-
persist_block_devices: Optional[pulumi.Input[bool]] = None,
|
|
2576
|
-
persist_private_ip: Optional[pulumi.Input[bool]] = None,
|
|
2577
|
-
persist_root_device: Optional[pulumi.Input[bool]] = None,
|
|
2578
|
-
placement_tenancy: Optional[pulumi.Input[str]] = None,
|
|
2579
|
-
preferred_availability_zones: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
|
|
2580
|
-
private_ips: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
|
|
2581
|
-
product: Optional[pulumi.Input[str]] = None,
|
|
2582
|
-
region: Optional[pulumi.Input[str]] = 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,
|
|
2583
2576
|
resource_requirements: Optional[pulumi.Input[Sequence[pulumi.Input[Union['ElastigroupResourceRequirementArgs', 'ElastigroupResourceRequirementArgsDict']]]]] = None,
|
|
2584
2577
|
resource_tag_specifications: Optional[pulumi.Input[Sequence[pulumi.Input[Union['ElastigroupResourceTagSpecificationArgs', 'ElastigroupResourceTagSpecificationArgsDict']]]]] = None,
|
|
2585
|
-
restrict_single_az: Optional[pulumi.Input[bool]] = None,
|
|
2578
|
+
restrict_single_az: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
2586
2579
|
revert_to_spot: Optional[pulumi.Input[Union['ElastigroupRevertToSpotArgs', 'ElastigroupRevertToSpotArgsDict']]] = None,
|
|
2587
2580
|
scaling_down_policies: Optional[pulumi.Input[Sequence[pulumi.Input[Union['ElastigroupScalingDownPolicyArgs', 'ElastigroupScalingDownPolicyArgsDict']]]]] = None,
|
|
2588
2581
|
scaling_strategies: Optional[pulumi.Input[Sequence[pulumi.Input[Union['ElastigroupScalingStrategyArgs', 'ElastigroupScalingStrategyArgsDict']]]]] = None,
|
|
2589
2582
|
scaling_target_policies: Optional[pulumi.Input[Sequence[pulumi.Input[Union['ElastigroupScalingTargetPolicyArgs', 'ElastigroupScalingTargetPolicyArgsDict']]]]] = None,
|
|
2590
2583
|
scaling_up_policies: Optional[pulumi.Input[Sequence[pulumi.Input[Union['ElastigroupScalingUpPolicyArgs', 'ElastigroupScalingUpPolicyArgsDict']]]]] = None,
|
|
2591
2584
|
scheduled_tasks: Optional[pulumi.Input[Sequence[pulumi.Input[Union['ElastigroupScheduledTaskArgs', 'ElastigroupScheduledTaskArgsDict']]]]] = None,
|
|
2592
|
-
security_groups: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
|
|
2593
|
-
shutdown_script: Optional[pulumi.Input[str]] = None,
|
|
2585
|
+
security_groups: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
2586
|
+
shutdown_script: Optional[pulumi.Input[_builtins.str]] = None,
|
|
2594
2587
|
signals: Optional[pulumi.Input[Sequence[pulumi.Input[Union['ElastigroupSignalArgs', 'ElastigroupSignalArgsDict']]]]] = None,
|
|
2595
|
-
spot_percentage: Optional[pulumi.Input[int]] = None,
|
|
2588
|
+
spot_percentage: Optional[pulumi.Input[_builtins.int]] = None,
|
|
2596
2589
|
stateful_deallocation: Optional[pulumi.Input[Union['ElastigroupStatefulDeallocationArgs', 'ElastigroupStatefulDeallocationArgsDict']]] = None,
|
|
2597
2590
|
stateful_instance_actions: Optional[pulumi.Input[Sequence[pulumi.Input[Union['ElastigroupStatefulInstanceActionArgs', 'ElastigroupStatefulInstanceActionArgsDict']]]]] = None,
|
|
2598
|
-
subnet_ids: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
|
|
2591
|
+
subnet_ids: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
2599
2592
|
tags: Optional[pulumi.Input[Sequence[pulumi.Input[Union['ElastigroupTagArgs', 'ElastigroupTagArgsDict']]]]] = None,
|
|
2600
|
-
target_group_arns: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
|
|
2593
|
+
target_group_arns: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
2601
2594
|
update_policy: Optional[pulumi.Input[Union['ElastigroupUpdatePolicyArgs', 'ElastigroupUpdatePolicyArgsDict']]] = None,
|
|
2602
|
-
user_data: Optional[pulumi.Input[str]] = None,
|
|
2603
|
-
utilize_commitments: Optional[pulumi.Input[bool]] = None,
|
|
2604
|
-
utilize_reserved_instances: Optional[pulumi.Input[bool]] = None,
|
|
2605
|
-
wait_for_capacity: Optional[pulumi.Input[int]] = None,
|
|
2606
|
-
wait_for_capacity_timeout: Optional[pulumi.Input[int]] = 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,
|
|
2607
2600
|
__props__=None):
|
|
2608
2601
|
"""
|
|
2609
2602
|
Provides a Spotinst AWS group resource.
|
|
@@ -2744,64 +2737,63 @@ class Elastigroup(pulumi.CustomResource):
|
|
|
2744
2737
|
|
|
2745
2738
|
:param str resource_name: The name of the resource.
|
|
2746
2739
|
:param pulumi.ResourceOptions opts: Options for the resource.
|
|
2747
|
-
:param pulumi.Input[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".
|
|
2748
|
-
:param pulumi.Input[Sequence[pulumi.Input[str]]] availability_zones: List of Strings of availability zones. When this parameter is set, `subnet_ids` should be left unused.
|
|
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.
|
|
2749
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:
|
|
2750
2743
|
`availability_zones = ["us-east-1a:subnet-123456:ClusterI03"]`
|
|
2751
|
-
: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`.
|
|
2752
|
-
:param pulumi.Input[str] cpu_credits: Controls how T3 instances are launched. Valid values: `standard`, `unlimited`.
|
|
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`.
|
|
2753
2746
|
:param pulumi.Input[Union['ElastigroupCpuOptionsArgs', 'ElastigroupCpuOptionsArgsDict']] cpu_options: The CPU options for the instances that are launched within the group:
|
|
2754
|
-
:param pulumi.Input[str] description: The group description.
|
|
2755
|
-
:param pulumi.Input[int] desired_capacity: The desired number of instances the group should have at any time.
|
|
2756
|
-
: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.
|
|
2757
|
-
: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.
|
|
2758
|
-
: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.
|
|
2759
|
-
:param pulumi.Input[bool] enable_monitoring: Indicates whether monitoring is enabled for the instance.
|
|
2760
|
-
:param pulumi.Input[bool] fallback_to_ondemand: In a case of no Spot instances available, Elastigroup will launch on-demand instances instead.
|
|
2761
|
-
: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.
|
|
2762
|
-
: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"`.
|
|
2763
|
-
: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).
|
|
2764
|
-
:param pulumi.Input[str] iam_instance_profile: The ARN or name of an IAM instance profile to associate with launched instances.
|
|
2765
|
-
:param pulumi.Input[str] image_id: The ID of the AMI used to launch the instance.
|
|
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.
|
|
2766
2759
|
:param pulumi.Input[Sequence[pulumi.Input[Union['ElastigroupImageArgs', 'ElastigroupImageArgsDict']]]] images: An array of image objects.
|
|
2767
2760
|
Note: Elastigroup can be configured with either imageId or images, but not both.
|
|
2768
|
-
: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).
|
|
2769
|
-
: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.
|
|
2770
|
-
:param pulumi.Input[Sequence[pulumi.Input[str]]] instance_types_spots: One or more instance types. Note: Cannot be defined if 'resourceRequirements' is defined.
|
|
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.
|
|
2771
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:
|
|
2772
|
-
:param pulumi.Input[str] key_name: The key name that should be used for the instance.
|
|
2765
|
+
:param pulumi.Input[_builtins.str] key_name: The key name that should be used for the instance.
|
|
2773
2766
|
:param pulumi.Input[Union['ElastigroupLoggingArgs', 'ElastigroupLoggingArgsDict']] logging: Logging configuration.
|
|
2774
|
-
:param pulumi.Input[int]
|
|
2775
|
-
:param pulumi.Input[int] max_size: The maximum number of instances the group should have at any time.
|
|
2767
|
+
:param pulumi.Input[_builtins.int] max_size: The maximum number of instances the group should have at any time.
|
|
2776
2768
|
:param pulumi.Input[Union['ElastigroupMetadataOptionsArgs', 'ElastigroupMetadataOptionsArgsDict']] metadata_options: Data that used to configure or manage the running instances:
|
|
2777
|
-
:param pulumi.Input[int] min_size: The minimum number of instances the group should have at any time.
|
|
2778
|
-
: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.
|
|
2779
|
-
:param pulumi.Input[str] name: The group name.
|
|
2780
|
-
: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.
|
|
2781
|
-
: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.
|
|
2782
|
-
:param pulumi.Input[str] orientation: Select a prediction strategy. Valid values: `balanced`, `costOriented`, `equalAzDistribution`, `availabilityOriented`. You can read more in our documentation.
|
|
2783
|
-
: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" .
|
|
2784
|
-
: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.
|
|
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.
|
|
2785
2777
|
Note: Must be a sublist of `availability_zones` and `orientation` value must not be `"equalAzDistribution"`.
|
|
2786
|
-
:param pulumi.Input[str] product: Operation system type. Valid values: `"Linux/UNIX"`, `"SUSE Linux"`, `"Windows"`.
|
|
2778
|
+
:param pulumi.Input[_builtins.str] product: Operation system type. Valid values: `"Linux/UNIX"`, `"SUSE Linux"`, `"Windows"`.
|
|
2787
2779
|
For EC2 Classic instances: `"SUSE Linux (Amazon VPC)"`, `"Windows (Amazon VPC)"`.
|
|
2788
|
-
:param pulumi.Input[str] region: The AWS region your group will be created in.
|
|
2780
|
+
:param pulumi.Input[_builtins.str] region: The AWS region your group will be created in.
|
|
2789
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).
|
|
2790
2782
|
:param pulumi.Input[Sequence[pulumi.Input[Union['ElastigroupResourceRequirementArgs', 'ElastigroupResourceRequirementArgsDict']]]] resource_requirements: Required instance attributes. Instance types will be selected based on these requirements.
|
|
2791
2783
|
:param pulumi.Input[Sequence[pulumi.Input[Union['ElastigroupResourceTagSpecificationArgs', 'ElastigroupResourceTagSpecificationArgsDict']]]] resource_tag_specifications: User will specify which resources should be tagged with group tags.
|
|
2792
|
-
:param pulumi.Input[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.
|
|
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.
|
|
2793
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"`
|
|
2794
2786
|
:param pulumi.Input[Sequence[pulumi.Input[Union['ElastigroupScalingStrategyArgs', 'ElastigroupScalingStrategyArgsDict']]]] scaling_strategies: Set termination policy.
|
|
2795
|
-
:param pulumi.Input[Sequence[pulumi.Input[str]]] security_groups: A list of associated security group IDS.
|
|
2796
|
-
: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/)
|
|
2797
|
-
:param pulumi.Input[int] spot_percentage: The percentage of Spot instances that would spin up from the `desired_capacity` number.
|
|
2798
|
-
:param pulumi.Input[Sequence[pulumi.Input[str]]] subnet_ids: List of Strings of subnet identifiers.
|
|
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.
|
|
2799
2791
|
Note: When this parameter is set, `availability_zones` should be left unused.
|
|
2800
2792
|
:param pulumi.Input[Sequence[pulumi.Input[Union['ElastigroupTagArgs', 'ElastigroupTagArgsDict']]]] tags: A key/value mapping of tags to assign to the resource.
|
|
2801
|
-
:param pulumi.Input[str] user_data: The user data to provide when launching the instance.
|
|
2802
|
-
:param pulumi.Input[bool] utilize_reserved_instances: In a case of any available reserved instances, Elastigroup will utilize them first before purchasing Spot instances.
|
|
2803
|
-
: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`.
|
|
2804
|
-
: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.
|
|
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.
|
|
2805
2797
|
"""
|
|
2806
2798
|
...
|
|
2807
2799
|
@overload
|
|
@@ -2961,33 +2953,33 @@ class Elastigroup(pulumi.CustomResource):
|
|
|
2961
2953
|
def _internal_init(__self__,
|
|
2962
2954
|
resource_name: str,
|
|
2963
2955
|
opts: Optional[pulumi.ResourceOptions] = None,
|
|
2964
|
-
auto_healing: Optional[pulumi.Input[bool]] = None,
|
|
2965
|
-
availability_zones: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
|
|
2966
|
-
block_devices_mode: Optional[pulumi.Input[str]] = None,
|
|
2967
|
-
capacity_unit: Optional[pulumi.Input[str]] = None,
|
|
2968
|
-
consider_od_pricing: Optional[pulumi.Input[bool]] = None,
|
|
2969
|
-
cpu_credits: Optional[pulumi.Input[str]] = None,
|
|
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,
|
|
2970
2962
|
cpu_options: Optional[pulumi.Input[Union['ElastigroupCpuOptionsArgs', 'ElastigroupCpuOptionsArgsDict']]] = None,
|
|
2971
|
-
description: Optional[pulumi.Input[str]] = None,
|
|
2972
|
-
desired_capacity: Optional[pulumi.Input[int]] = None,
|
|
2973
|
-
draining_timeout: Optional[pulumi.Input[int]] = 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,
|
|
2974
2966
|
ebs_block_devices: Optional[pulumi.Input[Sequence[pulumi.Input[Union['ElastigroupEbsBlockDeviceArgs', 'ElastigroupEbsBlockDeviceArgsDict']]]]] = None,
|
|
2975
|
-
ebs_optimized: Optional[pulumi.Input[bool]] = None,
|
|
2976
|
-
elastic_ips: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
|
|
2977
|
-
elastic_load_balancers: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
|
|
2978
|
-
enable_monitoring: Optional[pulumi.Input[bool]] = 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,
|
|
2979
2971
|
ephemeral_block_devices: Optional[pulumi.Input[Sequence[pulumi.Input[Union['ElastigroupEphemeralBlockDeviceArgs', 'ElastigroupEphemeralBlockDeviceArgsDict']]]]] = None,
|
|
2980
|
-
fallback_to_ondemand: Optional[pulumi.Input[bool]] = None,
|
|
2981
|
-
health_check_grace_period: Optional[pulumi.Input[int]] = None,
|
|
2982
|
-
health_check_type: Optional[pulumi.Input[str]] = None,
|
|
2983
|
-
health_check_unhealthy_duration_before_replacement: Optional[pulumi.Input[int]] = None,
|
|
2984
|
-
iam_instance_profile: Optional[pulumi.Input[str]] = None,
|
|
2985
|
-
image_id: Optional[pulumi.Input[str]] = 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,
|
|
2986
2978
|
images: Optional[pulumi.Input[Sequence[pulumi.Input[Union['ElastigroupImageArgs', 'ElastigroupImageArgsDict']]]]] = None,
|
|
2987
|
-
immediate_od_recover_threshold: Optional[pulumi.Input[int]] = None,
|
|
2988
|
-
instance_types_ondemand: Optional[pulumi.Input[str]] = None,
|
|
2989
|
-
instance_types_preferred_spots: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
|
|
2990
|
-
instance_types_spots: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = 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,
|
|
2991
2983
|
instance_types_weights: Optional[pulumi.Input[Sequence[pulumi.Input[Union['ElastigroupInstanceTypesWeightArgs', 'ElastigroupInstanceTypesWeightArgsDict']]]]] = None,
|
|
2992
2984
|
integration_beanstalk: Optional[pulumi.Input[Union['ElastigroupIntegrationBeanstalkArgs', 'ElastigroupIntegrationBeanstalkArgsDict']]] = None,
|
|
2993
2985
|
integration_codedeploy: Optional[pulumi.Input[Union['ElastigroupIntegrationCodedeployArgs', 'ElastigroupIntegrationCodedeployArgsDict']]] = None,
|
|
@@ -3000,52 +2992,52 @@ class Elastigroup(pulumi.CustomResource):
|
|
|
3000
2992
|
integration_rancher: Optional[pulumi.Input[Union['ElastigroupIntegrationRancherArgs', 'ElastigroupIntegrationRancherArgsDict']]] = None,
|
|
3001
2993
|
integration_route53: Optional[pulumi.Input[Union['ElastigroupIntegrationRoute53Args', 'ElastigroupIntegrationRoute53ArgsDict']]] = None,
|
|
3002
2994
|
itfs: Optional[pulumi.Input[Sequence[pulumi.Input[Union['ElastigroupItfArgs', 'ElastigroupItfArgsDict']]]]] = None,
|
|
3003
|
-
key_name: Optional[pulumi.Input[str]] = None,
|
|
3004
|
-
lifetime_period: Optional[pulumi.Input[str]] = None,
|
|
2995
|
+
key_name: Optional[pulumi.Input[_builtins.str]] = None,
|
|
2996
|
+
lifetime_period: Optional[pulumi.Input[_builtins.str]] = None,
|
|
3005
2997
|
logging: Optional[pulumi.Input[Union['ElastigroupLoggingArgs', 'ElastigroupLoggingArgsDict']]] = None,
|
|
3006
|
-
max_replacements_percentage: Optional[pulumi.Input[int]] = None,
|
|
3007
|
-
max_size: Optional[pulumi.Input[int]] = None,
|
|
2998
|
+
max_replacements_percentage: Optional[pulumi.Input[_builtins.int]] = None,
|
|
2999
|
+
max_size: Optional[pulumi.Input[_builtins.int]] = None,
|
|
3008
3000
|
metadata_options: Optional[pulumi.Input[Union['ElastigroupMetadataOptionsArgs', 'ElastigroupMetadataOptionsArgsDict']]] = None,
|
|
3009
|
-
min_size: Optional[pulumi.Input[int]] = None,
|
|
3010
|
-
minimum_instance_lifetime: Optional[pulumi.Input[int]] = None,
|
|
3001
|
+
min_size: Optional[pulumi.Input[_builtins.int]] = None,
|
|
3002
|
+
minimum_instance_lifetime: Optional[pulumi.Input[_builtins.int]] = None,
|
|
3011
3003
|
multiple_metrics: Optional[pulumi.Input[Union['ElastigroupMultipleMetricsArgs', 'ElastigroupMultipleMetricsArgsDict']]] = None,
|
|
3012
|
-
name: Optional[pulumi.Input[str]] = None,
|
|
3004
|
+
name: Optional[pulumi.Input[_builtins.str]] = None,
|
|
3013
3005
|
network_interfaces: Optional[pulumi.Input[Sequence[pulumi.Input[Union['ElastigroupNetworkInterfaceArgs', 'ElastigroupNetworkInterfaceArgsDict']]]]] = None,
|
|
3014
|
-
on_demand_types: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
|
|
3015
|
-
ondemand_count: Optional[pulumi.Input[int]] = None,
|
|
3016
|
-
orientation: Optional[pulumi.Input[str]] = None,
|
|
3017
|
-
persist_block_devices: Optional[pulumi.Input[bool]] = None,
|
|
3018
|
-
persist_private_ip: Optional[pulumi.Input[bool]] = None,
|
|
3019
|
-
persist_root_device: Optional[pulumi.Input[bool]] = None,
|
|
3020
|
-
placement_tenancy: Optional[pulumi.Input[str]] = None,
|
|
3021
|
-
preferred_availability_zones: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
|
|
3022
|
-
private_ips: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
|
|
3023
|
-
product: Optional[pulumi.Input[str]] = None,
|
|
3024
|
-
region: Optional[pulumi.Input[str]] = 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,
|
|
3025
3017
|
resource_requirements: Optional[pulumi.Input[Sequence[pulumi.Input[Union['ElastigroupResourceRequirementArgs', 'ElastigroupResourceRequirementArgsDict']]]]] = None,
|
|
3026
3018
|
resource_tag_specifications: Optional[pulumi.Input[Sequence[pulumi.Input[Union['ElastigroupResourceTagSpecificationArgs', 'ElastigroupResourceTagSpecificationArgsDict']]]]] = None,
|
|
3027
|
-
restrict_single_az: Optional[pulumi.Input[bool]] = None,
|
|
3019
|
+
restrict_single_az: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
3028
3020
|
revert_to_spot: Optional[pulumi.Input[Union['ElastigroupRevertToSpotArgs', 'ElastigroupRevertToSpotArgsDict']]] = None,
|
|
3029
3021
|
scaling_down_policies: Optional[pulumi.Input[Sequence[pulumi.Input[Union['ElastigroupScalingDownPolicyArgs', 'ElastigroupScalingDownPolicyArgsDict']]]]] = None,
|
|
3030
3022
|
scaling_strategies: Optional[pulumi.Input[Sequence[pulumi.Input[Union['ElastigroupScalingStrategyArgs', 'ElastigroupScalingStrategyArgsDict']]]]] = None,
|
|
3031
3023
|
scaling_target_policies: Optional[pulumi.Input[Sequence[pulumi.Input[Union['ElastigroupScalingTargetPolicyArgs', 'ElastigroupScalingTargetPolicyArgsDict']]]]] = None,
|
|
3032
3024
|
scaling_up_policies: Optional[pulumi.Input[Sequence[pulumi.Input[Union['ElastigroupScalingUpPolicyArgs', 'ElastigroupScalingUpPolicyArgsDict']]]]] = None,
|
|
3033
3025
|
scheduled_tasks: Optional[pulumi.Input[Sequence[pulumi.Input[Union['ElastigroupScheduledTaskArgs', 'ElastigroupScheduledTaskArgsDict']]]]] = None,
|
|
3034
|
-
security_groups: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
|
|
3035
|
-
shutdown_script: Optional[pulumi.Input[str]] = None,
|
|
3026
|
+
security_groups: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
3027
|
+
shutdown_script: Optional[pulumi.Input[_builtins.str]] = None,
|
|
3036
3028
|
signals: Optional[pulumi.Input[Sequence[pulumi.Input[Union['ElastigroupSignalArgs', 'ElastigroupSignalArgsDict']]]]] = None,
|
|
3037
|
-
spot_percentage: Optional[pulumi.Input[int]] = None,
|
|
3029
|
+
spot_percentage: Optional[pulumi.Input[_builtins.int]] = None,
|
|
3038
3030
|
stateful_deallocation: Optional[pulumi.Input[Union['ElastigroupStatefulDeallocationArgs', 'ElastigroupStatefulDeallocationArgsDict']]] = None,
|
|
3039
3031
|
stateful_instance_actions: Optional[pulumi.Input[Sequence[pulumi.Input[Union['ElastigroupStatefulInstanceActionArgs', 'ElastigroupStatefulInstanceActionArgsDict']]]]] = None,
|
|
3040
|
-
subnet_ids: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
|
|
3032
|
+
subnet_ids: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
3041
3033
|
tags: Optional[pulumi.Input[Sequence[pulumi.Input[Union['ElastigroupTagArgs', 'ElastigroupTagArgsDict']]]]] = None,
|
|
3042
|
-
target_group_arns: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
|
|
3034
|
+
target_group_arns: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
3043
3035
|
update_policy: Optional[pulumi.Input[Union['ElastigroupUpdatePolicyArgs', 'ElastigroupUpdatePolicyArgsDict']]] = None,
|
|
3044
|
-
user_data: Optional[pulumi.Input[str]] = None,
|
|
3045
|
-
utilize_commitments: Optional[pulumi.Input[bool]] = None,
|
|
3046
|
-
utilize_reserved_instances: Optional[pulumi.Input[bool]] = None,
|
|
3047
|
-
wait_for_capacity: Optional[pulumi.Input[int]] = None,
|
|
3048
|
-
wait_for_capacity_timeout: Optional[pulumi.Input[int]] = 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,
|
|
3049
3041
|
__props__=None):
|
|
3050
3042
|
opts = pulumi.ResourceOptions.merge(_utilities.get_resource_opts_defaults(), opts)
|
|
3051
3043
|
if not isinstance(opts, pulumi.ResourceOptions):
|
|
@@ -3158,33 +3150,33 @@ class Elastigroup(pulumi.CustomResource):
|
|
|
3158
3150
|
def get(resource_name: str,
|
|
3159
3151
|
id: pulumi.Input[str],
|
|
3160
3152
|
opts: Optional[pulumi.ResourceOptions] = None,
|
|
3161
|
-
auto_healing: Optional[pulumi.Input[bool]] = None,
|
|
3162
|
-
availability_zones: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
|
|
3163
|
-
block_devices_mode: Optional[pulumi.Input[str]] = None,
|
|
3164
|
-
capacity_unit: Optional[pulumi.Input[str]] = None,
|
|
3165
|
-
consider_od_pricing: Optional[pulumi.Input[bool]] = None,
|
|
3166
|
-
cpu_credits: Optional[pulumi.Input[str]] = None,
|
|
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,
|
|
3167
3159
|
cpu_options: Optional[pulumi.Input[Union['ElastigroupCpuOptionsArgs', 'ElastigroupCpuOptionsArgsDict']]] = None,
|
|
3168
|
-
description: Optional[pulumi.Input[str]] = None,
|
|
3169
|
-
desired_capacity: Optional[pulumi.Input[int]] = None,
|
|
3170
|
-
draining_timeout: Optional[pulumi.Input[int]] = 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,
|
|
3171
3163
|
ebs_block_devices: Optional[pulumi.Input[Sequence[pulumi.Input[Union['ElastigroupEbsBlockDeviceArgs', 'ElastigroupEbsBlockDeviceArgsDict']]]]] = None,
|
|
3172
|
-
ebs_optimized: Optional[pulumi.Input[bool]] = None,
|
|
3173
|
-
elastic_ips: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
|
|
3174
|
-
elastic_load_balancers: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
|
|
3175
|
-
enable_monitoring: Optional[pulumi.Input[bool]] = 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,
|
|
3176
3168
|
ephemeral_block_devices: Optional[pulumi.Input[Sequence[pulumi.Input[Union['ElastigroupEphemeralBlockDeviceArgs', 'ElastigroupEphemeralBlockDeviceArgsDict']]]]] = None,
|
|
3177
|
-
fallback_to_ondemand: Optional[pulumi.Input[bool]] = None,
|
|
3178
|
-
health_check_grace_period: Optional[pulumi.Input[int]] = None,
|
|
3179
|
-
health_check_type: Optional[pulumi.Input[str]] = None,
|
|
3180
|
-
health_check_unhealthy_duration_before_replacement: Optional[pulumi.Input[int]] = None,
|
|
3181
|
-
iam_instance_profile: Optional[pulumi.Input[str]] = None,
|
|
3182
|
-
image_id: Optional[pulumi.Input[str]] = 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,
|
|
3183
3175
|
images: Optional[pulumi.Input[Sequence[pulumi.Input[Union['ElastigroupImageArgs', 'ElastigroupImageArgsDict']]]]] = None,
|
|
3184
|
-
immediate_od_recover_threshold: Optional[pulumi.Input[int]] = None,
|
|
3185
|
-
instance_types_ondemand: Optional[pulumi.Input[str]] = None,
|
|
3186
|
-
instance_types_preferred_spots: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
|
|
3187
|
-
instance_types_spots: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = 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,
|
|
3188
3180
|
instance_types_weights: Optional[pulumi.Input[Sequence[pulumi.Input[Union['ElastigroupInstanceTypesWeightArgs', 'ElastigroupInstanceTypesWeightArgsDict']]]]] = None,
|
|
3189
3181
|
integration_beanstalk: Optional[pulumi.Input[Union['ElastigroupIntegrationBeanstalkArgs', 'ElastigroupIntegrationBeanstalkArgsDict']]] = None,
|
|
3190
3182
|
integration_codedeploy: Optional[pulumi.Input[Union['ElastigroupIntegrationCodedeployArgs', 'ElastigroupIntegrationCodedeployArgsDict']]] = None,
|
|
@@ -3197,52 +3189,52 @@ class Elastigroup(pulumi.CustomResource):
|
|
|
3197
3189
|
integration_rancher: Optional[pulumi.Input[Union['ElastigroupIntegrationRancherArgs', 'ElastigroupIntegrationRancherArgsDict']]] = None,
|
|
3198
3190
|
integration_route53: Optional[pulumi.Input[Union['ElastigroupIntegrationRoute53Args', 'ElastigroupIntegrationRoute53ArgsDict']]] = None,
|
|
3199
3191
|
itfs: Optional[pulumi.Input[Sequence[pulumi.Input[Union['ElastigroupItfArgs', 'ElastigroupItfArgsDict']]]]] = None,
|
|
3200
|
-
key_name: Optional[pulumi.Input[str]] = None,
|
|
3201
|
-
lifetime_period: Optional[pulumi.Input[str]] = None,
|
|
3192
|
+
key_name: Optional[pulumi.Input[_builtins.str]] = None,
|
|
3193
|
+
lifetime_period: Optional[pulumi.Input[_builtins.str]] = None,
|
|
3202
3194
|
logging: Optional[pulumi.Input[Union['ElastigroupLoggingArgs', 'ElastigroupLoggingArgsDict']]] = None,
|
|
3203
|
-
max_replacements_percentage: Optional[pulumi.Input[int]] = None,
|
|
3204
|
-
max_size: Optional[pulumi.Input[int]] = None,
|
|
3195
|
+
max_replacements_percentage: Optional[pulumi.Input[_builtins.int]] = None,
|
|
3196
|
+
max_size: Optional[pulumi.Input[_builtins.int]] = None,
|
|
3205
3197
|
metadata_options: Optional[pulumi.Input[Union['ElastigroupMetadataOptionsArgs', 'ElastigroupMetadataOptionsArgsDict']]] = None,
|
|
3206
|
-
min_size: Optional[pulumi.Input[int]] = None,
|
|
3207
|
-
minimum_instance_lifetime: Optional[pulumi.Input[int]] = None,
|
|
3198
|
+
min_size: Optional[pulumi.Input[_builtins.int]] = None,
|
|
3199
|
+
minimum_instance_lifetime: Optional[pulumi.Input[_builtins.int]] = None,
|
|
3208
3200
|
multiple_metrics: Optional[pulumi.Input[Union['ElastigroupMultipleMetricsArgs', 'ElastigroupMultipleMetricsArgsDict']]] = None,
|
|
3209
|
-
name: Optional[pulumi.Input[str]] = None,
|
|
3201
|
+
name: Optional[pulumi.Input[_builtins.str]] = None,
|
|
3210
3202
|
network_interfaces: Optional[pulumi.Input[Sequence[pulumi.Input[Union['ElastigroupNetworkInterfaceArgs', 'ElastigroupNetworkInterfaceArgsDict']]]]] = None,
|
|
3211
|
-
on_demand_types: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
|
|
3212
|
-
ondemand_count: Optional[pulumi.Input[int]] = None,
|
|
3213
|
-
orientation: Optional[pulumi.Input[str]] = None,
|
|
3214
|
-
persist_block_devices: Optional[pulumi.Input[bool]] = None,
|
|
3215
|
-
persist_private_ip: Optional[pulumi.Input[bool]] = None,
|
|
3216
|
-
persist_root_device: Optional[pulumi.Input[bool]] = None,
|
|
3217
|
-
placement_tenancy: Optional[pulumi.Input[str]] = None,
|
|
3218
|
-
preferred_availability_zones: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
|
|
3219
|
-
private_ips: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
|
|
3220
|
-
product: Optional[pulumi.Input[str]] = None,
|
|
3221
|
-
region: Optional[pulumi.Input[str]] = 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,
|
|
3222
3214
|
resource_requirements: Optional[pulumi.Input[Sequence[pulumi.Input[Union['ElastigroupResourceRequirementArgs', 'ElastigroupResourceRequirementArgsDict']]]]] = None,
|
|
3223
3215
|
resource_tag_specifications: Optional[pulumi.Input[Sequence[pulumi.Input[Union['ElastigroupResourceTagSpecificationArgs', 'ElastigroupResourceTagSpecificationArgsDict']]]]] = None,
|
|
3224
|
-
restrict_single_az: Optional[pulumi.Input[bool]] = None,
|
|
3216
|
+
restrict_single_az: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
3225
3217
|
revert_to_spot: Optional[pulumi.Input[Union['ElastigroupRevertToSpotArgs', 'ElastigroupRevertToSpotArgsDict']]] = None,
|
|
3226
3218
|
scaling_down_policies: Optional[pulumi.Input[Sequence[pulumi.Input[Union['ElastigroupScalingDownPolicyArgs', 'ElastigroupScalingDownPolicyArgsDict']]]]] = None,
|
|
3227
3219
|
scaling_strategies: Optional[pulumi.Input[Sequence[pulumi.Input[Union['ElastigroupScalingStrategyArgs', 'ElastigroupScalingStrategyArgsDict']]]]] = None,
|
|
3228
3220
|
scaling_target_policies: Optional[pulumi.Input[Sequence[pulumi.Input[Union['ElastigroupScalingTargetPolicyArgs', 'ElastigroupScalingTargetPolicyArgsDict']]]]] = None,
|
|
3229
3221
|
scaling_up_policies: Optional[pulumi.Input[Sequence[pulumi.Input[Union['ElastigroupScalingUpPolicyArgs', 'ElastigroupScalingUpPolicyArgsDict']]]]] = None,
|
|
3230
3222
|
scheduled_tasks: Optional[pulumi.Input[Sequence[pulumi.Input[Union['ElastigroupScheduledTaskArgs', 'ElastigroupScheduledTaskArgsDict']]]]] = None,
|
|
3231
|
-
security_groups: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
|
|
3232
|
-
shutdown_script: Optional[pulumi.Input[str]] = None,
|
|
3223
|
+
security_groups: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
3224
|
+
shutdown_script: Optional[pulumi.Input[_builtins.str]] = None,
|
|
3233
3225
|
signals: Optional[pulumi.Input[Sequence[pulumi.Input[Union['ElastigroupSignalArgs', 'ElastigroupSignalArgsDict']]]]] = None,
|
|
3234
|
-
spot_percentage: Optional[pulumi.Input[int]] = None,
|
|
3226
|
+
spot_percentage: Optional[pulumi.Input[_builtins.int]] = None,
|
|
3235
3227
|
stateful_deallocation: Optional[pulumi.Input[Union['ElastigroupStatefulDeallocationArgs', 'ElastigroupStatefulDeallocationArgsDict']]] = None,
|
|
3236
3228
|
stateful_instance_actions: Optional[pulumi.Input[Sequence[pulumi.Input[Union['ElastigroupStatefulInstanceActionArgs', 'ElastigroupStatefulInstanceActionArgsDict']]]]] = None,
|
|
3237
|
-
subnet_ids: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
|
|
3229
|
+
subnet_ids: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
3238
3230
|
tags: Optional[pulumi.Input[Sequence[pulumi.Input[Union['ElastigroupTagArgs', 'ElastigroupTagArgsDict']]]]] = None,
|
|
3239
|
-
target_group_arns: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
|
|
3231
|
+
target_group_arns: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
3240
3232
|
update_policy: Optional[pulumi.Input[Union['ElastigroupUpdatePolicyArgs', 'ElastigroupUpdatePolicyArgsDict']]] = None,
|
|
3241
|
-
user_data: Optional[pulumi.Input[str]] = None,
|
|
3242
|
-
utilize_commitments: Optional[pulumi.Input[bool]] = None,
|
|
3243
|
-
utilize_reserved_instances: Optional[pulumi.Input[bool]] = None,
|
|
3244
|
-
wait_for_capacity: Optional[pulumi.Input[int]] = None,
|
|
3245
|
-
wait_for_capacity_timeout: Optional[pulumi.Input[int]] = None) -> 'Elastigroup':
|
|
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':
|
|
3246
3238
|
"""
|
|
3247
3239
|
Get an existing Elastigroup resource's state with the given name, id, and optional extra
|
|
3248
3240
|
properties used to qualify the lookup.
|
|
@@ -3250,64 +3242,63 @@ class Elastigroup(pulumi.CustomResource):
|
|
|
3250
3242
|
:param str resource_name: The unique name of the resulting resource.
|
|
3251
3243
|
:param pulumi.Input[str] id: The unique provider ID of the resource to lookup.
|
|
3252
3244
|
:param pulumi.ResourceOptions opts: Options for the resource.
|
|
3253
|
-
:param pulumi.Input[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".
|
|
3254
|
-
:param pulumi.Input[Sequence[pulumi.Input[str]]] availability_zones: List of Strings of availability zones. When this parameter is set, `subnet_ids` should be left unused.
|
|
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.
|
|
3255
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:
|
|
3256
3248
|
`availability_zones = ["us-east-1a:subnet-123456:ClusterI03"]`
|
|
3257
|
-
: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`.
|
|
3258
|
-
:param pulumi.Input[str] cpu_credits: Controls how T3 instances are launched. Valid values: `standard`, `unlimited`.
|
|
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`.
|
|
3259
3251
|
:param pulumi.Input[Union['ElastigroupCpuOptionsArgs', 'ElastigroupCpuOptionsArgsDict']] cpu_options: The CPU options for the instances that are launched within the group:
|
|
3260
|
-
:param pulumi.Input[str] description: The group description.
|
|
3261
|
-
:param pulumi.Input[int] desired_capacity: The desired number of instances the group should have at any time.
|
|
3262
|
-
: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.
|
|
3263
|
-
: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.
|
|
3264
|
-
: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.
|
|
3265
|
-
:param pulumi.Input[bool] enable_monitoring: Indicates whether monitoring is enabled for the instance.
|
|
3266
|
-
:param pulumi.Input[bool] fallback_to_ondemand: In a case of no Spot instances available, Elastigroup will launch on-demand instances instead.
|
|
3267
|
-
: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.
|
|
3268
|
-
: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"`.
|
|
3269
|
-
: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).
|
|
3270
|
-
:param pulumi.Input[str] iam_instance_profile: The ARN or name of an IAM instance profile to associate with launched instances.
|
|
3271
|
-
:param pulumi.Input[str] image_id: The ID of the AMI used to launch the instance.
|
|
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.
|
|
3272
3264
|
:param pulumi.Input[Sequence[pulumi.Input[Union['ElastigroupImageArgs', 'ElastigroupImageArgsDict']]]] images: An array of image objects.
|
|
3273
3265
|
Note: Elastigroup can be configured with either imageId or images, but not both.
|
|
3274
|
-
: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).
|
|
3275
|
-
: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.
|
|
3276
|
-
:param pulumi.Input[Sequence[pulumi.Input[str]]] instance_types_spots: One or more instance types. Note: Cannot be defined if 'resourceRequirements' is defined.
|
|
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.
|
|
3277
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:
|
|
3278
|
-
:param pulumi.Input[str] key_name: The key name that should be used for the instance.
|
|
3270
|
+
:param pulumi.Input[_builtins.str] key_name: The key name that should be used for the instance.
|
|
3279
3271
|
:param pulumi.Input[Union['ElastigroupLoggingArgs', 'ElastigroupLoggingArgsDict']] logging: Logging configuration.
|
|
3280
|
-
:param pulumi.Input[int]
|
|
3281
|
-
:param pulumi.Input[int] max_size: The maximum number of instances the group should have at any time.
|
|
3272
|
+
:param pulumi.Input[_builtins.int] max_size: The maximum number of instances the group should have at any time.
|
|
3282
3273
|
:param pulumi.Input[Union['ElastigroupMetadataOptionsArgs', 'ElastigroupMetadataOptionsArgsDict']] metadata_options: Data that used to configure or manage the running instances:
|
|
3283
|
-
:param pulumi.Input[int] min_size: The minimum number of instances the group should have at any time.
|
|
3284
|
-
: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.
|
|
3285
|
-
:param pulumi.Input[str] name: The group name.
|
|
3286
|
-
: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.
|
|
3287
|
-
: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.
|
|
3288
|
-
:param pulumi.Input[str] orientation: Select a prediction strategy. Valid values: `balanced`, `costOriented`, `equalAzDistribution`, `availabilityOriented`. You can read more in our documentation.
|
|
3289
|
-
: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" .
|
|
3290
|
-
: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.
|
|
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.
|
|
3291
3282
|
Note: Must be a sublist of `availability_zones` and `orientation` value must not be `"equalAzDistribution"`.
|
|
3292
|
-
:param pulumi.Input[str] product: Operation system type. Valid values: `"Linux/UNIX"`, `"SUSE Linux"`, `"Windows"`.
|
|
3283
|
+
:param pulumi.Input[_builtins.str] product: Operation system type. Valid values: `"Linux/UNIX"`, `"SUSE Linux"`, `"Windows"`.
|
|
3293
3284
|
For EC2 Classic instances: `"SUSE Linux (Amazon VPC)"`, `"Windows (Amazon VPC)"`.
|
|
3294
|
-
:param pulumi.Input[str] region: The AWS region your group will be created in.
|
|
3285
|
+
:param pulumi.Input[_builtins.str] region: The AWS region your group will be created in.
|
|
3295
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).
|
|
3296
3287
|
:param pulumi.Input[Sequence[pulumi.Input[Union['ElastigroupResourceRequirementArgs', 'ElastigroupResourceRequirementArgsDict']]]] resource_requirements: Required instance attributes. Instance types will be selected based on these requirements.
|
|
3297
3288
|
:param pulumi.Input[Sequence[pulumi.Input[Union['ElastigroupResourceTagSpecificationArgs', 'ElastigroupResourceTagSpecificationArgsDict']]]] resource_tag_specifications: User will specify which resources should be tagged with group tags.
|
|
3298
|
-
:param pulumi.Input[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.
|
|
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.
|
|
3299
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"`
|
|
3300
3291
|
:param pulumi.Input[Sequence[pulumi.Input[Union['ElastigroupScalingStrategyArgs', 'ElastigroupScalingStrategyArgsDict']]]] scaling_strategies: Set termination policy.
|
|
3301
|
-
:param pulumi.Input[Sequence[pulumi.Input[str]]] security_groups: A list of associated security group IDS.
|
|
3302
|
-
: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/)
|
|
3303
|
-
:param pulumi.Input[int] spot_percentage: The percentage of Spot instances that would spin up from the `desired_capacity` number.
|
|
3304
|
-
:param pulumi.Input[Sequence[pulumi.Input[str]]] subnet_ids: List of Strings of subnet identifiers.
|
|
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.
|
|
3305
3296
|
Note: When this parameter is set, `availability_zones` should be left unused.
|
|
3306
3297
|
:param pulumi.Input[Sequence[pulumi.Input[Union['ElastigroupTagArgs', 'ElastigroupTagArgsDict']]]] tags: A key/value mapping of tags to assign to the resource.
|
|
3307
|
-
:param pulumi.Input[str] user_data: The user data to provide when launching the instance.
|
|
3308
|
-
:param pulumi.Input[bool] utilize_reserved_instances: In a case of any available reserved instances, Elastigroup will utilize them first before purchasing Spot instances.
|
|
3309
|
-
: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`.
|
|
3310
|
-
: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.
|
|
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.
|
|
3311
3302
|
"""
|
|
3312
3303
|
opts = pulumi.ResourceOptions.merge(opts, pulumi.ResourceOptions(id=id))
|
|
3313
3304
|
|
|
@@ -3400,17 +3391,17 @@ class Elastigroup(pulumi.CustomResource):
|
|
|
3400
3391
|
__props__.__dict__["wait_for_capacity_timeout"] = wait_for_capacity_timeout
|
|
3401
3392
|
return Elastigroup(resource_name, opts=opts, __props__=__props__)
|
|
3402
3393
|
|
|
3403
|
-
@property
|
|
3394
|
+
@_builtins.property
|
|
3404
3395
|
@pulumi.getter(name="autoHealing")
|
|
3405
|
-
def auto_healing(self) -> pulumi.Output[Optional[bool]]:
|
|
3396
|
+
def auto_healing(self) -> pulumi.Output[Optional[_builtins.bool]]:
|
|
3406
3397
|
"""
|
|
3407
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".
|
|
3408
3399
|
"""
|
|
3409
3400
|
return pulumi.get(self, "auto_healing")
|
|
3410
3401
|
|
|
3411
|
-
@property
|
|
3402
|
+
@_builtins.property
|
|
3412
3403
|
@pulumi.getter(name="availabilityZones")
|
|
3413
|
-
def availability_zones(self) -> pulumi.Output[Optional[Sequence[str]]]:
|
|
3404
|
+
def availability_zones(self) -> pulumi.Output[Optional[Sequence[_builtins.str]]]:
|
|
3414
3405
|
"""
|
|
3415
3406
|
List of Strings of availability zones. When this parameter is set, `subnet_ids` should be left unused.
|
|
3416
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:
|
|
@@ -3418,33 +3409,33 @@ class Elastigroup(pulumi.CustomResource):
|
|
|
3418
3409
|
"""
|
|
3419
3410
|
return pulumi.get(self, "availability_zones")
|
|
3420
3411
|
|
|
3421
|
-
@property
|
|
3412
|
+
@_builtins.property
|
|
3422
3413
|
@pulumi.getter(name="blockDevicesMode")
|
|
3423
|
-
def block_devices_mode(self) -> pulumi.Output[Optional[str]]:
|
|
3414
|
+
def block_devices_mode(self) -> pulumi.Output[Optional[_builtins.str]]:
|
|
3424
3415
|
return pulumi.get(self, "block_devices_mode")
|
|
3425
3416
|
|
|
3426
|
-
@property
|
|
3417
|
+
@_builtins.property
|
|
3427
3418
|
@pulumi.getter(name="capacityUnit")
|
|
3428
|
-
def capacity_unit(self) -> pulumi.Output[str]:
|
|
3419
|
+
def capacity_unit(self) -> pulumi.Output[_builtins.str]:
|
|
3429
3420
|
"""
|
|
3430
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`.
|
|
3431
3422
|
"""
|
|
3432
3423
|
return pulumi.get(self, "capacity_unit")
|
|
3433
3424
|
|
|
3434
|
-
@property
|
|
3425
|
+
@_builtins.property
|
|
3435
3426
|
@pulumi.getter(name="considerOdPricing")
|
|
3436
|
-
def consider_od_pricing(self) -> pulumi.Output[Optional[bool]]:
|
|
3427
|
+
def consider_od_pricing(self) -> pulumi.Output[Optional[_builtins.bool]]:
|
|
3437
3428
|
return pulumi.get(self, "consider_od_pricing")
|
|
3438
3429
|
|
|
3439
|
-
@property
|
|
3430
|
+
@_builtins.property
|
|
3440
3431
|
@pulumi.getter(name="cpuCredits")
|
|
3441
|
-
def cpu_credits(self) -> pulumi.Output[Optional[str]]:
|
|
3432
|
+
def cpu_credits(self) -> pulumi.Output[Optional[_builtins.str]]:
|
|
3442
3433
|
"""
|
|
3443
3434
|
Controls how T3 instances are launched. Valid values: `standard`, `unlimited`.
|
|
3444
3435
|
"""
|
|
3445
3436
|
return pulumi.get(self, "cpu_credits")
|
|
3446
3437
|
|
|
3447
|
-
@property
|
|
3438
|
+
@_builtins.property
|
|
3448
3439
|
@pulumi.getter(name="cpuOptions")
|
|
3449
3440
|
def cpu_options(self) -> pulumi.Output[Optional['outputs.ElastigroupCpuOptions']]:
|
|
3450
3441
|
"""
|
|
@@ -3452,118 +3443,118 @@ class Elastigroup(pulumi.CustomResource):
|
|
|
3452
3443
|
"""
|
|
3453
3444
|
return pulumi.get(self, "cpu_options")
|
|
3454
3445
|
|
|
3455
|
-
@property
|
|
3446
|
+
@_builtins.property
|
|
3456
3447
|
@pulumi.getter
|
|
3457
|
-
def description(self) -> pulumi.Output[Optional[str]]:
|
|
3448
|
+
def description(self) -> pulumi.Output[Optional[_builtins.str]]:
|
|
3458
3449
|
"""
|
|
3459
3450
|
The group description.
|
|
3460
3451
|
"""
|
|
3461
3452
|
return pulumi.get(self, "description")
|
|
3462
3453
|
|
|
3463
|
-
@property
|
|
3454
|
+
@_builtins.property
|
|
3464
3455
|
@pulumi.getter(name="desiredCapacity")
|
|
3465
|
-
def desired_capacity(self) -> pulumi.Output[Optional[int]]:
|
|
3456
|
+
def desired_capacity(self) -> pulumi.Output[Optional[_builtins.int]]:
|
|
3466
3457
|
"""
|
|
3467
3458
|
The desired number of instances the group should have at any time.
|
|
3468
3459
|
"""
|
|
3469
3460
|
return pulumi.get(self, "desired_capacity")
|
|
3470
3461
|
|
|
3471
|
-
@property
|
|
3462
|
+
@_builtins.property
|
|
3472
3463
|
@pulumi.getter(name="drainingTimeout")
|
|
3473
|
-
def draining_timeout(self) -> pulumi.Output[int]:
|
|
3464
|
+
def draining_timeout(self) -> pulumi.Output[_builtins.int]:
|
|
3474
3465
|
"""
|
|
3475
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.
|
|
3476
3467
|
"""
|
|
3477
3468
|
return pulumi.get(self, "draining_timeout")
|
|
3478
3469
|
|
|
3479
|
-
@property
|
|
3470
|
+
@_builtins.property
|
|
3480
3471
|
@pulumi.getter(name="ebsBlockDevices")
|
|
3481
3472
|
def ebs_block_devices(self) -> pulumi.Output[Optional[Sequence['outputs.ElastigroupEbsBlockDevice']]]:
|
|
3482
3473
|
return pulumi.get(self, "ebs_block_devices")
|
|
3483
3474
|
|
|
3484
|
-
@property
|
|
3475
|
+
@_builtins.property
|
|
3485
3476
|
@pulumi.getter(name="ebsOptimized")
|
|
3486
|
-
def ebs_optimized(self) -> pulumi.Output[bool]:
|
|
3477
|
+
def ebs_optimized(self) -> pulumi.Output[_builtins.bool]:
|
|
3487
3478
|
"""
|
|
3488
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.
|
|
3489
3480
|
"""
|
|
3490
3481
|
return pulumi.get(self, "ebs_optimized")
|
|
3491
3482
|
|
|
3492
|
-
@property
|
|
3483
|
+
@_builtins.property
|
|
3493
3484
|
@pulumi.getter(name="elasticIps")
|
|
3494
|
-
def elastic_ips(self) -> pulumi.Output[Optional[Sequence[str]]]:
|
|
3485
|
+
def elastic_ips(self) -> pulumi.Output[Optional[Sequence[_builtins.str]]]:
|
|
3495
3486
|
"""
|
|
3496
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.
|
|
3497
3488
|
"""
|
|
3498
3489
|
return pulumi.get(self, "elastic_ips")
|
|
3499
3490
|
|
|
3500
|
-
@property
|
|
3491
|
+
@_builtins.property
|
|
3501
3492
|
@pulumi.getter(name="elasticLoadBalancers")
|
|
3502
|
-
def elastic_load_balancers(self) -> pulumi.Output[Optional[Sequence[str]]]:
|
|
3493
|
+
def elastic_load_balancers(self) -> pulumi.Output[Optional[Sequence[_builtins.str]]]:
|
|
3503
3494
|
return pulumi.get(self, "elastic_load_balancers")
|
|
3504
3495
|
|
|
3505
|
-
@property
|
|
3496
|
+
@_builtins.property
|
|
3506
3497
|
@pulumi.getter(name="enableMonitoring")
|
|
3507
|
-
def enable_monitoring(self) -> pulumi.Output[Optional[bool]]:
|
|
3498
|
+
def enable_monitoring(self) -> pulumi.Output[Optional[_builtins.bool]]:
|
|
3508
3499
|
"""
|
|
3509
3500
|
Indicates whether monitoring is enabled for the instance.
|
|
3510
3501
|
"""
|
|
3511
3502
|
return pulumi.get(self, "enable_monitoring")
|
|
3512
3503
|
|
|
3513
|
-
@property
|
|
3504
|
+
@_builtins.property
|
|
3514
3505
|
@pulumi.getter(name="ephemeralBlockDevices")
|
|
3515
3506
|
def ephemeral_block_devices(self) -> pulumi.Output[Optional[Sequence['outputs.ElastigroupEphemeralBlockDevice']]]:
|
|
3516
3507
|
return pulumi.get(self, "ephemeral_block_devices")
|
|
3517
3508
|
|
|
3518
|
-
@property
|
|
3509
|
+
@_builtins.property
|
|
3519
3510
|
@pulumi.getter(name="fallbackToOndemand")
|
|
3520
|
-
def fallback_to_ondemand(self) -> pulumi.Output[bool]:
|
|
3511
|
+
def fallback_to_ondemand(self) -> pulumi.Output[_builtins.bool]:
|
|
3521
3512
|
"""
|
|
3522
3513
|
In a case of no Spot instances available, Elastigroup will launch on-demand instances instead.
|
|
3523
3514
|
"""
|
|
3524
3515
|
return pulumi.get(self, "fallback_to_ondemand")
|
|
3525
3516
|
|
|
3526
|
-
@property
|
|
3517
|
+
@_builtins.property
|
|
3527
3518
|
@pulumi.getter(name="healthCheckGracePeriod")
|
|
3528
|
-
def health_check_grace_period(self) -> pulumi.Output[Optional[int]]:
|
|
3519
|
+
def health_check_grace_period(self) -> pulumi.Output[Optional[_builtins.int]]:
|
|
3529
3520
|
"""
|
|
3530
3521
|
The amount of time, in seconds, after the instance has launched to starts and check its health.
|
|
3531
3522
|
"""
|
|
3532
3523
|
return pulumi.get(self, "health_check_grace_period")
|
|
3533
3524
|
|
|
3534
|
-
@property
|
|
3525
|
+
@_builtins.property
|
|
3535
3526
|
@pulumi.getter(name="healthCheckType")
|
|
3536
|
-
def health_check_type(self) -> pulumi.Output[Optional[str]]:
|
|
3527
|
+
def health_check_type(self) -> pulumi.Output[Optional[_builtins.str]]:
|
|
3537
3528
|
"""
|
|
3538
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"`.
|
|
3539
3530
|
"""
|
|
3540
3531
|
return pulumi.get(self, "health_check_type")
|
|
3541
3532
|
|
|
3542
|
-
@property
|
|
3533
|
+
@_builtins.property
|
|
3543
3534
|
@pulumi.getter(name="healthCheckUnhealthyDurationBeforeReplacement")
|
|
3544
|
-
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]]:
|
|
3545
3536
|
"""
|
|
3546
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).
|
|
3547
3538
|
"""
|
|
3548
3539
|
return pulumi.get(self, "health_check_unhealthy_duration_before_replacement")
|
|
3549
3540
|
|
|
3550
|
-
@property
|
|
3541
|
+
@_builtins.property
|
|
3551
3542
|
@pulumi.getter(name="iamInstanceProfile")
|
|
3552
|
-
def iam_instance_profile(self) -> pulumi.Output[Optional[str]]:
|
|
3543
|
+
def iam_instance_profile(self) -> pulumi.Output[Optional[_builtins.str]]:
|
|
3553
3544
|
"""
|
|
3554
3545
|
The ARN or name of an IAM instance profile to associate with launched instances.
|
|
3555
3546
|
"""
|
|
3556
3547
|
return pulumi.get(self, "iam_instance_profile")
|
|
3557
3548
|
|
|
3558
|
-
@property
|
|
3549
|
+
@_builtins.property
|
|
3559
3550
|
@pulumi.getter(name="imageId")
|
|
3560
|
-
def image_id(self) -> pulumi.Output[Optional[str]]:
|
|
3551
|
+
def image_id(self) -> pulumi.Output[Optional[_builtins.str]]:
|
|
3561
3552
|
"""
|
|
3562
3553
|
The ID of the AMI used to launch the instance.
|
|
3563
3554
|
"""
|
|
3564
3555
|
return pulumi.get(self, "image_id")
|
|
3565
3556
|
|
|
3566
|
-
@property
|
|
3557
|
+
@_builtins.property
|
|
3567
3558
|
@pulumi.getter
|
|
3568
3559
|
def images(self) -> pulumi.Output[Optional[Sequence['outputs.ElastigroupImage']]]:
|
|
3569
3560
|
"""
|
|
@@ -3572,36 +3563,36 @@ class Elastigroup(pulumi.CustomResource):
|
|
|
3572
3563
|
"""
|
|
3573
3564
|
return pulumi.get(self, "images")
|
|
3574
3565
|
|
|
3575
|
-
@property
|
|
3566
|
+
@_builtins.property
|
|
3576
3567
|
@pulumi.getter(name="immediateOdRecoverThreshold")
|
|
3577
|
-
def immediate_od_recover_threshold(self) -> pulumi.Output[Optional[int]]:
|
|
3568
|
+
def immediate_od_recover_threshold(self) -> pulumi.Output[Optional[_builtins.int]]:
|
|
3578
3569
|
return pulumi.get(self, "immediate_od_recover_threshold")
|
|
3579
3570
|
|
|
3580
|
-
@property
|
|
3571
|
+
@_builtins.property
|
|
3581
3572
|
@pulumi.getter(name="instanceTypesOndemand")
|
|
3582
|
-
def instance_types_ondemand(self) -> pulumi.Output[Optional[str]]:
|
|
3573
|
+
def instance_types_ondemand(self) -> pulumi.Output[Optional[_builtins.str]]:
|
|
3583
3574
|
"""
|
|
3584
3575
|
The type of instance determines your instance's CPU capacity, memory and storage (e.g., m1.small, c1.xlarge).
|
|
3585
3576
|
"""
|
|
3586
3577
|
return pulumi.get(self, "instance_types_ondemand")
|
|
3587
3578
|
|
|
3588
|
-
@property
|
|
3579
|
+
@_builtins.property
|
|
3589
3580
|
@pulumi.getter(name="instanceTypesPreferredSpots")
|
|
3590
|
-
def instance_types_preferred_spots(self) -> pulumi.Output[Optional[Sequence[str]]]:
|
|
3581
|
+
def instance_types_preferred_spots(self) -> pulumi.Output[Optional[Sequence[_builtins.str]]]:
|
|
3591
3582
|
"""
|
|
3592
3583
|
Prioritize a subset of spot instance types. Must be a subset of the selected spot instance types.
|
|
3593
3584
|
"""
|
|
3594
3585
|
return pulumi.get(self, "instance_types_preferred_spots")
|
|
3595
3586
|
|
|
3596
|
-
@property
|
|
3587
|
+
@_builtins.property
|
|
3597
3588
|
@pulumi.getter(name="instanceTypesSpots")
|
|
3598
|
-
def instance_types_spots(self) -> pulumi.Output[Optional[Sequence[str]]]:
|
|
3589
|
+
def instance_types_spots(self) -> pulumi.Output[Optional[Sequence[_builtins.str]]]:
|
|
3599
3590
|
"""
|
|
3600
3591
|
One or more instance types. Note: Cannot be defined if 'resourceRequirements' is defined.
|
|
3601
3592
|
"""
|
|
3602
3593
|
return pulumi.get(self, "instance_types_spots")
|
|
3603
3594
|
|
|
3604
|
-
@property
|
|
3595
|
+
@_builtins.property
|
|
3605
3596
|
@pulumi.getter(name="instanceTypesWeights")
|
|
3606
3597
|
def instance_types_weights(self) -> pulumi.Output[Optional[Sequence['outputs.ElastigroupInstanceTypesWeight']]]:
|
|
3607
3598
|
"""
|
|
@@ -3609,75 +3600,75 @@ class Elastigroup(pulumi.CustomResource):
|
|
|
3609
3600
|
"""
|
|
3610
3601
|
return pulumi.get(self, "instance_types_weights")
|
|
3611
3602
|
|
|
3612
|
-
@property
|
|
3603
|
+
@_builtins.property
|
|
3613
3604
|
@pulumi.getter(name="integrationBeanstalk")
|
|
3614
3605
|
def integration_beanstalk(self) -> pulumi.Output[Optional['outputs.ElastigroupIntegrationBeanstalk']]:
|
|
3615
3606
|
return pulumi.get(self, "integration_beanstalk")
|
|
3616
3607
|
|
|
3617
|
-
@property
|
|
3608
|
+
@_builtins.property
|
|
3618
3609
|
@pulumi.getter(name="integrationCodedeploy")
|
|
3619
3610
|
def integration_codedeploy(self) -> pulumi.Output[Optional['outputs.ElastigroupIntegrationCodedeploy']]:
|
|
3620
3611
|
return pulumi.get(self, "integration_codedeploy")
|
|
3621
3612
|
|
|
3622
|
-
@property
|
|
3613
|
+
@_builtins.property
|
|
3623
3614
|
@pulumi.getter(name="integrationDockerSwarm")
|
|
3624
3615
|
def integration_docker_swarm(self) -> pulumi.Output[Optional['outputs.ElastigroupIntegrationDockerSwarm']]:
|
|
3625
3616
|
return pulumi.get(self, "integration_docker_swarm")
|
|
3626
3617
|
|
|
3627
|
-
@property
|
|
3618
|
+
@_builtins.property
|
|
3628
3619
|
@pulumi.getter(name="integrationEcs")
|
|
3629
3620
|
def integration_ecs(self) -> pulumi.Output[Optional['outputs.ElastigroupIntegrationEcs']]:
|
|
3630
3621
|
return pulumi.get(self, "integration_ecs")
|
|
3631
3622
|
|
|
3632
|
-
@property
|
|
3623
|
+
@_builtins.property
|
|
3633
3624
|
@pulumi.getter(name="integrationGitlab")
|
|
3634
3625
|
def integration_gitlab(self) -> pulumi.Output[Optional['outputs.ElastigroupIntegrationGitlab']]:
|
|
3635
3626
|
return pulumi.get(self, "integration_gitlab")
|
|
3636
3627
|
|
|
3637
|
-
@property
|
|
3628
|
+
@_builtins.property
|
|
3638
3629
|
@pulumi.getter(name="integrationKubernetes")
|
|
3639
3630
|
def integration_kubernetes(self) -> pulumi.Output[Optional['outputs.ElastigroupIntegrationKubernetes']]:
|
|
3640
3631
|
return pulumi.get(self, "integration_kubernetes")
|
|
3641
3632
|
|
|
3642
|
-
@property
|
|
3633
|
+
@_builtins.property
|
|
3643
3634
|
@pulumi.getter(name="integrationMesosphere")
|
|
3644
3635
|
def integration_mesosphere(self) -> pulumi.Output[Optional['outputs.ElastigroupIntegrationMesosphere']]:
|
|
3645
3636
|
return pulumi.get(self, "integration_mesosphere")
|
|
3646
3637
|
|
|
3647
|
-
@property
|
|
3638
|
+
@_builtins.property
|
|
3648
3639
|
@pulumi.getter(name="integrationNomad")
|
|
3649
3640
|
def integration_nomad(self) -> pulumi.Output[Optional['outputs.ElastigroupIntegrationNomad']]:
|
|
3650
3641
|
return pulumi.get(self, "integration_nomad")
|
|
3651
3642
|
|
|
3652
|
-
@property
|
|
3643
|
+
@_builtins.property
|
|
3653
3644
|
@pulumi.getter(name="integrationRancher")
|
|
3654
3645
|
def integration_rancher(self) -> pulumi.Output[Optional['outputs.ElastigroupIntegrationRancher']]:
|
|
3655
3646
|
return pulumi.get(self, "integration_rancher")
|
|
3656
3647
|
|
|
3657
|
-
@property
|
|
3648
|
+
@_builtins.property
|
|
3658
3649
|
@pulumi.getter(name="integrationRoute53")
|
|
3659
3650
|
def integration_route53(self) -> pulumi.Output[Optional['outputs.ElastigroupIntegrationRoute53']]:
|
|
3660
3651
|
return pulumi.get(self, "integration_route53")
|
|
3661
3652
|
|
|
3662
|
-
@property
|
|
3653
|
+
@_builtins.property
|
|
3663
3654
|
@pulumi.getter
|
|
3664
3655
|
def itfs(self) -> pulumi.Output[Optional[Sequence['outputs.ElastigroupItf']]]:
|
|
3665
3656
|
return pulumi.get(self, "itfs")
|
|
3666
3657
|
|
|
3667
|
-
@property
|
|
3658
|
+
@_builtins.property
|
|
3668
3659
|
@pulumi.getter(name="keyName")
|
|
3669
|
-
def key_name(self) -> pulumi.Output[Optional[str]]:
|
|
3660
|
+
def key_name(self) -> pulumi.Output[Optional[_builtins.str]]:
|
|
3670
3661
|
"""
|
|
3671
3662
|
The key name that should be used for the instance.
|
|
3672
3663
|
"""
|
|
3673
3664
|
return pulumi.get(self, "key_name")
|
|
3674
3665
|
|
|
3675
|
-
@property
|
|
3666
|
+
@_builtins.property
|
|
3676
3667
|
@pulumi.getter(name="lifetimePeriod")
|
|
3677
|
-
def lifetime_period(self) -> pulumi.Output[Optional[str]]:
|
|
3668
|
+
def lifetime_period(self) -> pulumi.Output[Optional[_builtins.str]]:
|
|
3678
3669
|
return pulumi.get(self, "lifetime_period")
|
|
3679
3670
|
|
|
3680
|
-
@property
|
|
3671
|
+
@_builtins.property
|
|
3681
3672
|
@pulumi.getter
|
|
3682
3673
|
def logging(self) -> pulumi.Output[Optional['outputs.ElastigroupLogging']]:
|
|
3683
3674
|
"""
|
|
@@ -3685,23 +3676,20 @@ class Elastigroup(pulumi.CustomResource):
|
|
|
3685
3676
|
"""
|
|
3686
3677
|
return pulumi.get(self, "logging")
|
|
3687
3678
|
|
|
3688
|
-
@property
|
|
3679
|
+
@_builtins.property
|
|
3689
3680
|
@pulumi.getter(name="maxReplacementsPercentage")
|
|
3690
|
-
def max_replacements_percentage(self) -> pulumi.Output[Optional[int]]:
|
|
3691
|
-
"""
|
|
3692
|
-
The percentage of active instances that can be replaced in parallel. This is used to prevent a large number of instances from being replaced at once.
|
|
3693
|
-
"""
|
|
3681
|
+
def max_replacements_percentage(self) -> pulumi.Output[Optional[_builtins.int]]:
|
|
3694
3682
|
return pulumi.get(self, "max_replacements_percentage")
|
|
3695
3683
|
|
|
3696
|
-
@property
|
|
3684
|
+
@_builtins.property
|
|
3697
3685
|
@pulumi.getter(name="maxSize")
|
|
3698
|
-
def max_size(self) -> pulumi.Output[int]:
|
|
3686
|
+
def max_size(self) -> pulumi.Output[_builtins.int]:
|
|
3699
3687
|
"""
|
|
3700
3688
|
The maximum number of instances the group should have at any time.
|
|
3701
3689
|
"""
|
|
3702
3690
|
return pulumi.get(self, "max_size")
|
|
3703
3691
|
|
|
3704
|
-
@property
|
|
3692
|
+
@_builtins.property
|
|
3705
3693
|
@pulumi.getter(name="metadataOptions")
|
|
3706
3694
|
def metadata_options(self) -> pulumi.Output[Optional['outputs.ElastigroupMetadataOptions']]:
|
|
3707
3695
|
"""
|
|
@@ -3709,120 +3697,120 @@ class Elastigroup(pulumi.CustomResource):
|
|
|
3709
3697
|
"""
|
|
3710
3698
|
return pulumi.get(self, "metadata_options")
|
|
3711
3699
|
|
|
3712
|
-
@property
|
|
3700
|
+
@_builtins.property
|
|
3713
3701
|
@pulumi.getter(name="minSize")
|
|
3714
|
-
def min_size(self) -> pulumi.Output[int]:
|
|
3702
|
+
def min_size(self) -> pulumi.Output[_builtins.int]:
|
|
3715
3703
|
"""
|
|
3716
3704
|
The minimum number of instances the group should have at any time.
|
|
3717
3705
|
"""
|
|
3718
3706
|
return pulumi.get(self, "min_size")
|
|
3719
3707
|
|
|
3720
|
-
@property
|
|
3708
|
+
@_builtins.property
|
|
3721
3709
|
@pulumi.getter(name="minimumInstanceLifetime")
|
|
3722
|
-
def minimum_instance_lifetime(self) -> pulumi.Output[Optional[int]]:
|
|
3710
|
+
def minimum_instance_lifetime(self) -> pulumi.Output[Optional[_builtins.int]]:
|
|
3723
3711
|
"""
|
|
3724
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.
|
|
3725
3713
|
"""
|
|
3726
3714
|
return pulumi.get(self, "minimum_instance_lifetime")
|
|
3727
3715
|
|
|
3728
|
-
@property
|
|
3716
|
+
@_builtins.property
|
|
3729
3717
|
@pulumi.getter(name="multipleMetrics")
|
|
3730
3718
|
def multiple_metrics(self) -> pulumi.Output[Optional['outputs.ElastigroupMultipleMetrics']]:
|
|
3731
3719
|
return pulumi.get(self, "multiple_metrics")
|
|
3732
3720
|
|
|
3733
|
-
@property
|
|
3721
|
+
@_builtins.property
|
|
3734
3722
|
@pulumi.getter
|
|
3735
|
-
def name(self) -> pulumi.Output[str]:
|
|
3723
|
+
def name(self) -> pulumi.Output[_builtins.str]:
|
|
3736
3724
|
"""
|
|
3737
3725
|
The group name.
|
|
3738
3726
|
"""
|
|
3739
3727
|
return pulumi.get(self, "name")
|
|
3740
3728
|
|
|
3741
|
-
@property
|
|
3729
|
+
@_builtins.property
|
|
3742
3730
|
@pulumi.getter(name="networkInterfaces")
|
|
3743
3731
|
def network_interfaces(self) -> pulumi.Output[Optional[Sequence['outputs.ElastigroupNetworkInterface']]]:
|
|
3744
3732
|
return pulumi.get(self, "network_interfaces")
|
|
3745
3733
|
|
|
3746
|
-
@property
|
|
3734
|
+
@_builtins.property
|
|
3747
3735
|
@pulumi.getter(name="onDemandTypes")
|
|
3748
|
-
def on_demand_types(self) -> pulumi.Output[Optional[Sequence[str]]]:
|
|
3736
|
+
def on_demand_types(self) -> pulumi.Output[Optional[Sequence[_builtins.str]]]:
|
|
3749
3737
|
"""
|
|
3750
3738
|
Available ondemand instance types. Note: Either ondemand or onDemandTypes must be defined, but not both.
|
|
3751
3739
|
"""
|
|
3752
3740
|
return pulumi.get(self, "on_demand_types")
|
|
3753
3741
|
|
|
3754
|
-
@property
|
|
3742
|
+
@_builtins.property
|
|
3755
3743
|
@pulumi.getter(name="ondemandCount")
|
|
3756
|
-
def ondemand_count(self) -> pulumi.Output[Optional[int]]:
|
|
3744
|
+
def ondemand_count(self) -> pulumi.Output[Optional[_builtins.int]]:
|
|
3757
3745
|
"""
|
|
3758
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.
|
|
3759
3747
|
"""
|
|
3760
3748
|
return pulumi.get(self, "ondemand_count")
|
|
3761
3749
|
|
|
3762
|
-
@property
|
|
3750
|
+
@_builtins.property
|
|
3763
3751
|
@pulumi.getter
|
|
3764
|
-
def orientation(self) -> pulumi.Output[str]:
|
|
3752
|
+
def orientation(self) -> pulumi.Output[_builtins.str]:
|
|
3765
3753
|
"""
|
|
3766
3754
|
Select a prediction strategy. Valid values: `balanced`, `costOriented`, `equalAzDistribution`, `availabilityOriented`. You can read more in our documentation.
|
|
3767
3755
|
"""
|
|
3768
3756
|
return pulumi.get(self, "orientation")
|
|
3769
3757
|
|
|
3770
|
-
@property
|
|
3758
|
+
@_builtins.property
|
|
3771
3759
|
@pulumi.getter(name="persistBlockDevices")
|
|
3772
|
-
def persist_block_devices(self) -> pulumi.Output[Optional[bool]]:
|
|
3760
|
+
def persist_block_devices(self) -> pulumi.Output[Optional[_builtins.bool]]:
|
|
3773
3761
|
return pulumi.get(self, "persist_block_devices")
|
|
3774
3762
|
|
|
3775
|
-
@property
|
|
3763
|
+
@_builtins.property
|
|
3776
3764
|
@pulumi.getter(name="persistPrivateIp")
|
|
3777
|
-
def persist_private_ip(self) -> pulumi.Output[Optional[bool]]:
|
|
3765
|
+
def persist_private_ip(self) -> pulumi.Output[Optional[_builtins.bool]]:
|
|
3778
3766
|
return pulumi.get(self, "persist_private_ip")
|
|
3779
3767
|
|
|
3780
|
-
@property
|
|
3768
|
+
@_builtins.property
|
|
3781
3769
|
@pulumi.getter(name="persistRootDevice")
|
|
3782
|
-
def persist_root_device(self) -> pulumi.Output[Optional[bool]]:
|
|
3770
|
+
def persist_root_device(self) -> pulumi.Output[Optional[_builtins.bool]]:
|
|
3783
3771
|
return pulumi.get(self, "persist_root_device")
|
|
3784
3772
|
|
|
3785
|
-
@property
|
|
3773
|
+
@_builtins.property
|
|
3786
3774
|
@pulumi.getter(name="placementTenancy")
|
|
3787
|
-
def placement_tenancy(self) -> pulumi.Output[Optional[str]]:
|
|
3775
|
+
def placement_tenancy(self) -> pulumi.Output[Optional[_builtins.str]]:
|
|
3788
3776
|
"""
|
|
3789
3777
|
Enable dedicated tenancy. Note: There is a flat hourly fee for each region in which dedicated tenancy is used. Valid values: "default", "dedicated" .
|
|
3790
3778
|
"""
|
|
3791
3779
|
return pulumi.get(self, "placement_tenancy")
|
|
3792
3780
|
|
|
3793
|
-
@property
|
|
3781
|
+
@_builtins.property
|
|
3794
3782
|
@pulumi.getter(name="preferredAvailabilityZones")
|
|
3795
|
-
def preferred_availability_zones(self) -> pulumi.Output[Optional[Sequence[str]]]:
|
|
3783
|
+
def preferred_availability_zones(self) -> pulumi.Output[Optional[Sequence[_builtins.str]]]:
|
|
3796
3784
|
"""
|
|
3797
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.
|
|
3798
3786
|
Note: Must be a sublist of `availability_zones` and `orientation` value must not be `"equalAzDistribution"`.
|
|
3799
3787
|
"""
|
|
3800
3788
|
return pulumi.get(self, "preferred_availability_zones")
|
|
3801
3789
|
|
|
3802
|
-
@property
|
|
3790
|
+
@_builtins.property
|
|
3803
3791
|
@pulumi.getter(name="privateIps")
|
|
3804
|
-
def private_ips(self) -> pulumi.Output[Optional[Sequence[str]]]:
|
|
3792
|
+
def private_ips(self) -> pulumi.Output[Optional[Sequence[_builtins.str]]]:
|
|
3805
3793
|
return pulumi.get(self, "private_ips")
|
|
3806
3794
|
|
|
3807
|
-
@property
|
|
3795
|
+
@_builtins.property
|
|
3808
3796
|
@pulumi.getter
|
|
3809
|
-
def product(self) -> pulumi.Output[str]:
|
|
3797
|
+
def product(self) -> pulumi.Output[_builtins.str]:
|
|
3810
3798
|
"""
|
|
3811
3799
|
Operation system type. Valid values: `"Linux/UNIX"`, `"SUSE Linux"`, `"Windows"`.
|
|
3812
3800
|
For EC2 Classic instances: `"SUSE Linux (Amazon VPC)"`, `"Windows (Amazon VPC)"`.
|
|
3813
3801
|
"""
|
|
3814
3802
|
return pulumi.get(self, "product")
|
|
3815
3803
|
|
|
3816
|
-
@property
|
|
3804
|
+
@_builtins.property
|
|
3817
3805
|
@pulumi.getter
|
|
3818
|
-
def region(self) -> pulumi.Output[Optional[str]]:
|
|
3806
|
+
def region(self) -> pulumi.Output[Optional[_builtins.str]]:
|
|
3819
3807
|
"""
|
|
3820
3808
|
The AWS region your group will be created in.
|
|
3821
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).
|
|
3822
3810
|
"""
|
|
3823
3811
|
return pulumi.get(self, "region")
|
|
3824
3812
|
|
|
3825
|
-
@property
|
|
3813
|
+
@_builtins.property
|
|
3826
3814
|
@pulumi.getter(name="resourceRequirements")
|
|
3827
3815
|
def resource_requirements(self) -> pulumi.Output[Optional[Sequence['outputs.ElastigroupResourceRequirement']]]:
|
|
3828
3816
|
"""
|
|
@@ -3830,7 +3818,7 @@ class Elastigroup(pulumi.CustomResource):
|
|
|
3830
3818
|
"""
|
|
3831
3819
|
return pulumi.get(self, "resource_requirements")
|
|
3832
3820
|
|
|
3833
|
-
@property
|
|
3821
|
+
@_builtins.property
|
|
3834
3822
|
@pulumi.getter(name="resourceTagSpecifications")
|
|
3835
3823
|
def resource_tag_specifications(self) -> pulumi.Output[Optional[Sequence['outputs.ElastigroupResourceTagSpecification']]]:
|
|
3836
3824
|
"""
|
|
@@ -3838,15 +3826,15 @@ class Elastigroup(pulumi.CustomResource):
|
|
|
3838
3826
|
"""
|
|
3839
3827
|
return pulumi.get(self, "resource_tag_specifications")
|
|
3840
3828
|
|
|
3841
|
-
@property
|
|
3829
|
+
@_builtins.property
|
|
3842
3830
|
@pulumi.getter(name="restrictSingleAz")
|
|
3843
|
-
def restrict_single_az(self) -> pulumi.Output[Optional[bool]]:
|
|
3831
|
+
def restrict_single_az(self) -> pulumi.Output[Optional[_builtins.bool]]:
|
|
3844
3832
|
"""
|
|
3845
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.
|
|
3846
3834
|
"""
|
|
3847
3835
|
return pulumi.get(self, "restrict_single_az")
|
|
3848
3836
|
|
|
3849
|
-
@property
|
|
3837
|
+
@_builtins.property
|
|
3850
3838
|
@pulumi.getter(name="revertToSpot")
|
|
3851
3839
|
def revert_to_spot(self) -> pulumi.Output[Optional['outputs.ElastigroupRevertToSpot']]:
|
|
3852
3840
|
"""
|
|
@@ -3854,12 +3842,12 @@ class Elastigroup(pulumi.CustomResource):
|
|
|
3854
3842
|
"""
|
|
3855
3843
|
return pulumi.get(self, "revert_to_spot")
|
|
3856
3844
|
|
|
3857
|
-
@property
|
|
3845
|
+
@_builtins.property
|
|
3858
3846
|
@pulumi.getter(name="scalingDownPolicies")
|
|
3859
3847
|
def scaling_down_policies(self) -> pulumi.Output[Optional[Sequence['outputs.ElastigroupScalingDownPolicy']]]:
|
|
3860
3848
|
return pulumi.get(self, "scaling_down_policies")
|
|
3861
3849
|
|
|
3862
|
-
@property
|
|
3850
|
+
@_builtins.property
|
|
3863
3851
|
@pulumi.getter(name="scalingStrategies")
|
|
3864
3852
|
def scaling_strategies(self) -> pulumi.Output[Optional[Sequence['outputs.ElastigroupScalingStrategy']]]:
|
|
3865
3853
|
"""
|
|
@@ -3867,71 +3855,71 @@ class Elastigroup(pulumi.CustomResource):
|
|
|
3867
3855
|
"""
|
|
3868
3856
|
return pulumi.get(self, "scaling_strategies")
|
|
3869
3857
|
|
|
3870
|
-
@property
|
|
3858
|
+
@_builtins.property
|
|
3871
3859
|
@pulumi.getter(name="scalingTargetPolicies")
|
|
3872
3860
|
def scaling_target_policies(self) -> pulumi.Output[Optional[Sequence['outputs.ElastigroupScalingTargetPolicy']]]:
|
|
3873
3861
|
return pulumi.get(self, "scaling_target_policies")
|
|
3874
3862
|
|
|
3875
|
-
@property
|
|
3863
|
+
@_builtins.property
|
|
3876
3864
|
@pulumi.getter(name="scalingUpPolicies")
|
|
3877
3865
|
def scaling_up_policies(self) -> pulumi.Output[Optional[Sequence['outputs.ElastigroupScalingUpPolicy']]]:
|
|
3878
3866
|
return pulumi.get(self, "scaling_up_policies")
|
|
3879
3867
|
|
|
3880
|
-
@property
|
|
3868
|
+
@_builtins.property
|
|
3881
3869
|
@pulumi.getter(name="scheduledTasks")
|
|
3882
3870
|
def scheduled_tasks(self) -> pulumi.Output[Optional[Sequence['outputs.ElastigroupScheduledTask']]]:
|
|
3883
3871
|
return pulumi.get(self, "scheduled_tasks")
|
|
3884
3872
|
|
|
3885
|
-
@property
|
|
3873
|
+
@_builtins.property
|
|
3886
3874
|
@pulumi.getter(name="securityGroups")
|
|
3887
|
-
def security_groups(self) -> pulumi.Output[Sequence[str]]:
|
|
3875
|
+
def security_groups(self) -> pulumi.Output[Sequence[_builtins.str]]:
|
|
3888
3876
|
"""
|
|
3889
3877
|
A list of associated security group IDS.
|
|
3890
3878
|
"""
|
|
3891
3879
|
return pulumi.get(self, "security_groups")
|
|
3892
3880
|
|
|
3893
|
-
@property
|
|
3881
|
+
@_builtins.property
|
|
3894
3882
|
@pulumi.getter(name="shutdownScript")
|
|
3895
|
-
def shutdown_script(self) -> pulumi.Output[Optional[str]]:
|
|
3883
|
+
def shutdown_script(self) -> pulumi.Output[Optional[_builtins.str]]:
|
|
3896
3884
|
"""
|
|
3897
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/)
|
|
3898
3886
|
"""
|
|
3899
3887
|
return pulumi.get(self, "shutdown_script")
|
|
3900
3888
|
|
|
3901
|
-
@property
|
|
3889
|
+
@_builtins.property
|
|
3902
3890
|
@pulumi.getter
|
|
3903
3891
|
def signals(self) -> pulumi.Output[Optional[Sequence['outputs.ElastigroupSignal']]]:
|
|
3904
3892
|
return pulumi.get(self, "signals")
|
|
3905
3893
|
|
|
3906
|
-
@property
|
|
3894
|
+
@_builtins.property
|
|
3907
3895
|
@pulumi.getter(name="spotPercentage")
|
|
3908
|
-
def spot_percentage(self) -> pulumi.Output[Optional[int]]:
|
|
3896
|
+
def spot_percentage(self) -> pulumi.Output[Optional[_builtins.int]]:
|
|
3909
3897
|
"""
|
|
3910
3898
|
The percentage of Spot instances that would spin up from the `desired_capacity` number.
|
|
3911
3899
|
"""
|
|
3912
3900
|
return pulumi.get(self, "spot_percentage")
|
|
3913
3901
|
|
|
3914
|
-
@property
|
|
3902
|
+
@_builtins.property
|
|
3915
3903
|
@pulumi.getter(name="statefulDeallocation")
|
|
3916
3904
|
def stateful_deallocation(self) -> pulumi.Output[Optional['outputs.ElastigroupStatefulDeallocation']]:
|
|
3917
3905
|
return pulumi.get(self, "stateful_deallocation")
|
|
3918
3906
|
|
|
3919
|
-
@property
|
|
3907
|
+
@_builtins.property
|
|
3920
3908
|
@pulumi.getter(name="statefulInstanceActions")
|
|
3921
3909
|
def stateful_instance_actions(self) -> pulumi.Output[Optional[Sequence['outputs.ElastigroupStatefulInstanceAction']]]:
|
|
3922
3910
|
return pulumi.get(self, "stateful_instance_actions")
|
|
3923
3911
|
|
|
3924
|
-
@property
|
|
3912
|
+
@_builtins.property
|
|
3925
3913
|
@pulumi.getter(name="subnetIds")
|
|
3926
3914
|
@_utilities.deprecated("""This field will soon be deprecated and handled by availability_zones""")
|
|
3927
|
-
def subnet_ids(self) -> pulumi.Output[Optional[Sequence[str]]]:
|
|
3915
|
+
def subnet_ids(self) -> pulumi.Output[Optional[Sequence[_builtins.str]]]:
|
|
3928
3916
|
"""
|
|
3929
3917
|
List of Strings of subnet identifiers.
|
|
3930
3918
|
Note: When this parameter is set, `availability_zones` should be left unused.
|
|
3931
3919
|
"""
|
|
3932
3920
|
return pulumi.get(self, "subnet_ids")
|
|
3933
3921
|
|
|
3934
|
-
@property
|
|
3922
|
+
@_builtins.property
|
|
3935
3923
|
@pulumi.getter
|
|
3936
3924
|
def tags(self) -> pulumi.Output[Optional[Sequence['outputs.ElastigroupTag']]]:
|
|
3937
3925
|
"""
|
|
@@ -3939,48 +3927,48 @@ class Elastigroup(pulumi.CustomResource):
|
|
|
3939
3927
|
"""
|
|
3940
3928
|
return pulumi.get(self, "tags")
|
|
3941
3929
|
|
|
3942
|
-
@property
|
|
3930
|
+
@_builtins.property
|
|
3943
3931
|
@pulumi.getter(name="targetGroupArns")
|
|
3944
|
-
def target_group_arns(self) -> pulumi.Output[Optional[Sequence[str]]]:
|
|
3932
|
+
def target_group_arns(self) -> pulumi.Output[Optional[Sequence[_builtins.str]]]:
|
|
3945
3933
|
return pulumi.get(self, "target_group_arns")
|
|
3946
3934
|
|
|
3947
|
-
@property
|
|
3935
|
+
@_builtins.property
|
|
3948
3936
|
@pulumi.getter(name="updatePolicy")
|
|
3949
3937
|
def update_policy(self) -> pulumi.Output[Optional['outputs.ElastigroupUpdatePolicy']]:
|
|
3950
3938
|
return pulumi.get(self, "update_policy")
|
|
3951
3939
|
|
|
3952
|
-
@property
|
|
3940
|
+
@_builtins.property
|
|
3953
3941
|
@pulumi.getter(name="userData")
|
|
3954
|
-
def user_data(self) -> pulumi.Output[Optional[str]]:
|
|
3942
|
+
def user_data(self) -> pulumi.Output[Optional[_builtins.str]]:
|
|
3955
3943
|
"""
|
|
3956
3944
|
The user data to provide when launching the instance.
|
|
3957
3945
|
"""
|
|
3958
3946
|
return pulumi.get(self, "user_data")
|
|
3959
3947
|
|
|
3960
|
-
@property
|
|
3948
|
+
@_builtins.property
|
|
3961
3949
|
@pulumi.getter(name="utilizeCommitments")
|
|
3962
|
-
def utilize_commitments(self) -> pulumi.Output[Optional[bool]]:
|
|
3950
|
+
def utilize_commitments(self) -> pulumi.Output[Optional[_builtins.bool]]:
|
|
3963
3951
|
return pulumi.get(self, "utilize_commitments")
|
|
3964
3952
|
|
|
3965
|
-
@property
|
|
3953
|
+
@_builtins.property
|
|
3966
3954
|
@pulumi.getter(name="utilizeReservedInstances")
|
|
3967
|
-
def utilize_reserved_instances(self) -> pulumi.Output[Optional[bool]]:
|
|
3955
|
+
def utilize_reserved_instances(self) -> pulumi.Output[Optional[_builtins.bool]]:
|
|
3968
3956
|
"""
|
|
3969
3957
|
In a case of any available reserved instances, Elastigroup will utilize them first before purchasing Spot instances.
|
|
3970
3958
|
"""
|
|
3971
3959
|
return pulumi.get(self, "utilize_reserved_instances")
|
|
3972
3960
|
|
|
3973
|
-
@property
|
|
3961
|
+
@_builtins.property
|
|
3974
3962
|
@pulumi.getter(name="waitForCapacity")
|
|
3975
|
-
def wait_for_capacity(self) -> pulumi.Output[Optional[int]]:
|
|
3963
|
+
def wait_for_capacity(self) -> pulumi.Output[Optional[_builtins.int]]:
|
|
3976
3964
|
"""
|
|
3977
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`.
|
|
3978
3966
|
"""
|
|
3979
3967
|
return pulumi.get(self, "wait_for_capacity")
|
|
3980
3968
|
|
|
3981
|
-
@property
|
|
3969
|
+
@_builtins.property
|
|
3982
3970
|
@pulumi.getter(name="waitForCapacityTimeout")
|
|
3983
|
-
def wait_for_capacity_timeout(self) -> pulumi.Output[Optional[int]]:
|
|
3971
|
+
def wait_for_capacity_timeout(self) -> pulumi.Output[Optional[_builtins.int]]:
|
|
3984
3972
|
"""
|
|
3985
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.
|
|
3986
3974
|
"""
|