spotinst.aws.Elastigroup

import * as pulumi from "@pulumi/pulumi";
import * as spotinst from "@pulumi/spotinst";

// Create an Elastigroup
const default_elastigroup = new spotinst.aws.Elastigroup("default-elastigroup", {
    name: "default-elastigroup",
    description: "created by Pulumi",
    product: "Linux/UNIX",
    maxSize: 0,
    minSize: 0,
    desiredCapacity: 0,
    capacityUnit: "weight",
    region: "us-west-2",
    subnetIds: [
        "sb-123456",
        "sb-456789",
    ],
    imageId: "ami-a27d8fda",
    iamInstanceProfile: "iam-profile",
    keyName: "my-key.ssh",
    securityGroups: ["sg-123456"],
    userData: "echo hello world",
    enableMonitoring: false,
    ebsOptimized: false,
    placementTenancy: "default",
    metadataOptions: {
        httpTokens: "optional",
        httpPutResponseHopLimit: 10,
        instanceMetadataTags: "enabled",
    },
    cpuOptions: {
        threadsPerCore: 1,
    },
    instanceTypesOndemand: "m3.2xlarge",
    instanceTypesSpots: [
        "m3.xlarge",
        "m3.2xlarge",
    ],
    instanceTypesPreferredSpots: ["m3.xlarge"],
    onDemandTypes: ["c3.large"],
    instanceTypesWeights: [
        {
            instanceType: "m3.xlarge",
            weight: 10,
        },
        {
            instanceType: "m3.2xlarge",
            weight: 16,
        },
    ],
    resourceRequirements: [{
        excludedInstanceFamilies: [
            "a",
            "m",
        ],
        excludedInstanceTypes: ["m3.large"],
        excludedInstanceGenerations: [
            "1",
            "2",
        ],
        requiredGpuMinimum: 1,
        requiredGpuMaximum: 16,
        requiredMemoryMinimum: 1,
        requiredMemoryMaximum: 512,
        requiredVcpuMinimum: 1,
        requiredVcpuMaximum: 64,
    }],
    orientation: "balanced",
    fallbackToOndemand: false,
    cpuCredits: "unlimited",
    minimumInstanceLifetime: 12,
    waitForCapacity: 5,
    waitForCapacityTimeout: 300,
    scalingStrategies: [{
        terminateAtEndOfBillingHour: true,
        terminationPolicy: "default",
    }],
    scalingUpPolicies: [{
        policyName: "Default Scaling Up Policy",
        metricName: "DefaultQueuesDepth",
        statistic: "average",
        unit: "none",
        adjustment: "1",
        namespace: "custom",
        threshold: 100,
        period: 60,
        evaluationPeriods: 5,
        cooldown: 300,
    }],
    scalingDownPolicies: [{
        policyName: "Default Scaling Down Policy",
        metricName: "DefaultQueuesDepth",
        statistic: "average",
        unit: "none",
        adjustment: "1",
        namespace: "custom",
        threshold: 10,
        period: 60,
        evaluationPeriods: 10,
        cooldown: 300,
    }],
    tags: [
        {
            key: "Env",
            value: "production",
        },
        {
            key: "Name",
            value: "default-production",
        },
        {
            key: "Project",
            value: "app_v2",
        },
    ],
    resourceTagSpecifications: [{
        shouldTagEnis: true,
        shouldTagVolumes: true,
        shouldTagSnapshots: true,
        shouldTagAmis: true,
    }],
    logging: {
        "export": {
            s3s: [{
                id: "di-123456",
            }],
        },
    },
});

import pulumi
import pulumi_spotinst as spotinst

# Create an Elastigroup
default_elastigroup = spotinst.aws.Elastigroup("default-elastigroup",
    name="default-elastigroup",
    description="created by Pulumi",
    product="Linux/UNIX",
    max_size=0,
    min_size=0,
    desired_capacity=0,
    capacity_unit="weight",
    region="us-west-2",
    subnet_ids=[
        "sb-123456",
        "sb-456789",
    ],
    image_id="ami-a27d8fda",
    iam_instance_profile="iam-profile",
    key_name="my-key.ssh",
    security_groups=["sg-123456"],
    user_data="echo hello world",
    enable_monitoring=False,
    ebs_optimized=False,
    placement_tenancy="default",
    metadata_options={
        "http_tokens": "optional",
        "http_put_response_hop_limit": 10,
        "instance_metadata_tags": "enabled",
    },
    cpu_options={
        "threads_per_core": 1,
    },
    instance_types_ondemand="m3.2xlarge",
    instance_types_spots=[
        "m3.xlarge",
        "m3.2xlarge",
    ],
    instance_types_preferred_spots=["m3.xlarge"],
    on_demand_types=["c3.large"],
    instance_types_weights=[
        {
            "instance_type": "m3.xlarge",
            "weight": 10,
        },
        {
            "instance_type": "m3.2xlarge",
            "weight": 16,
        },
    ],
    resource_requirements=[{
        "excluded_instance_families": [
            "a",
            "m",
        ],
        "excluded_instance_types": ["m3.large"],
        "excluded_instance_generations": [
            "1",
            "2",
        ],
        "required_gpu_minimum": 1,
        "required_gpu_maximum": 16,
        "required_memory_minimum": 1,
        "required_memory_maximum": 512,
        "required_vcpu_minimum": 1,
        "required_vcpu_maximum": 64,
    }],
    orientation="balanced",
    fallback_to_ondemand=False,
    cpu_credits="unlimited",
    minimum_instance_lifetime=12,
    wait_for_capacity=5,
    wait_for_capacity_timeout=300,
    scaling_strategies=[{
        "terminate_at_end_of_billing_hour": True,
        "termination_policy": "default",
    }],
    scaling_up_policies=[{
        "policy_name": "Default Scaling Up Policy",
        "metric_name": "DefaultQueuesDepth",
        "statistic": "average",
        "unit": "none",
        "adjustment": "1",
        "namespace": "custom",
        "threshold": 100,
        "period": 60,
        "evaluation_periods": 5,
        "cooldown": 300,
    }],
    scaling_down_policies=[{
        "policy_name": "Default Scaling Down Policy",
        "metric_name": "DefaultQueuesDepth",
        "statistic": "average",
        "unit": "none",
        "adjustment": "1",
        "namespace": "custom",
        "threshold": 10,
        "period": 60,
        "evaluation_periods": 10,
        "cooldown": 300,
    }],
    tags=[
        {
            "key": "Env",
            "value": "production",
        },
        {
            "key": "Name",
            "value": "default-production",
        },
        {
            "key": "Project",
            "value": "app_v2",
        },
    ],
    resource_tag_specifications=[{
        "should_tag_enis": True,
        "should_tag_volumes": True,
        "should_tag_snapshots": True,
        "should_tag_amis": True,
    }],
    logging={
        "export": {
            "s3s": [{
                "id": "di-123456",
            }],
        },
    })

package main

import (
	"github.com/pulumi/pulumi-spotinst/sdk/v3/go/spotinst/aws"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		// Create an Elastigroup
		_, err := aws.NewElastigroup(ctx, "default-elastigroup", &aws.ElastigroupArgs{
			Name:            pulumi.String("default-elastigroup"),
			Description:     pulumi.String("created by Pulumi"),
			Product:         pulumi.String("Linux/UNIX"),
			MaxSize:         pulumi.Int(0),
			MinSize:         pulumi.Int(0),
			DesiredCapacity: pulumi.Int(0),
			CapacityUnit:    pulumi.String("weight"),
			Region:          pulumi.String("us-west-2"),
			SubnetIds: pulumi.StringArray{
				pulumi.String("sb-123456"),
				pulumi.String("sb-456789"),
			},
			ImageId:            pulumi.String("ami-a27d8fda"),
			IamInstanceProfile: pulumi.String("iam-profile"),
			KeyName:            pulumi.String("my-key.ssh"),
			SecurityGroups: pulumi.StringArray{
				pulumi.String("sg-123456"),
			},
			UserData:         pulumi.String("echo hello world"),
			EnableMonitoring: pulumi.Bool(false),
			EbsOptimized:     pulumi.Bool(false),
			PlacementTenancy: pulumi.String("default"),
			MetadataOptions: &aws.ElastigroupMetadataOptionsArgs{
				HttpTokens:              pulumi.String("optional"),
				HttpPutResponseHopLimit: pulumi.Int(10),
				InstanceMetadataTags:    pulumi.String("enabled"),
			},
			CpuOptions: &aws.ElastigroupCpuOptionsArgs{
				ThreadsPerCore: pulumi.Int(1),
			},
			InstanceTypesOndemand: pulumi.String("m3.2xlarge"),
			InstanceTypesSpots: pulumi.StringArray{
				pulumi.String("m3.xlarge"),
				pulumi.String("m3.2xlarge"),
			},
			InstanceTypesPreferredSpots: pulumi.StringArray{
				pulumi.String("m3.xlarge"),
			},
			OnDemandTypes: pulumi.StringArray{
				pulumi.String("c3.large"),
			},
			InstanceTypesWeights: aws.ElastigroupInstanceTypesWeightArray{
				&aws.ElastigroupInstanceTypesWeightArgs{
					InstanceType: pulumi.String("m3.xlarge"),
					Weight:       pulumi.Int(10),
				},
				&aws.ElastigroupInstanceTypesWeightArgs{
					InstanceType: pulumi.String("m3.2xlarge"),
					Weight:       pulumi.Int(16),
				},
			},
			ResourceRequirements: aws.ElastigroupResourceRequirementArray{
				&aws.ElastigroupResourceRequirementArgs{
					ExcludedInstanceFamilies: pulumi.StringArray{
						pulumi.String("a"),
						pulumi.String("m"),
					},
					ExcludedInstanceTypes: pulumi.StringArray{
						pulumi.String("m3.large"),
					},
					ExcludedInstanceGenerations: pulumi.StringArray{
						pulumi.String("1"),
						pulumi.String("2"),
					},
					RequiredGpuMinimum:    pulumi.Int(1),
					RequiredGpuMaximum:    pulumi.Int(16),
					RequiredMemoryMinimum: pulumi.Int(1),
					RequiredMemoryMaximum: pulumi.Int(512),
					RequiredVcpuMinimum:   pulumi.Int(1),
					RequiredVcpuMaximum:   pulumi.Int(64),
				},
			},
			Orientation:             pulumi.String("balanced"),
			FallbackToOndemand:      pulumi.Bool(false),
			CpuCredits:              pulumi.String("unlimited"),
			MinimumInstanceLifetime: pulumi.Int(12),
			WaitForCapacity:         pulumi.Int(5),
			WaitForCapacityTimeout:  pulumi.Int(300),
			ScalingStrategies: aws.ElastigroupScalingStrategyArray{
				&aws.ElastigroupScalingStrategyArgs{
					TerminateAtEndOfBillingHour: pulumi.Bool(true),
					TerminationPolicy:           pulumi.String("default"),
				},
			},
			ScalingUpPolicies: aws.ElastigroupScalingUpPolicyArray{
				&aws.ElastigroupScalingUpPolicyArgs{
					PolicyName:        pulumi.String("Default Scaling Up Policy"),
					MetricName:        pulumi.String("DefaultQueuesDepth"),
					Statistic:         pulumi.String("average"),
					Unit:              pulumi.String("none"),
					Adjustment:        pulumi.String("1"),
					Namespace:         pulumi.String("custom"),
					Threshold:         pulumi.Float64(100),
					Period:            pulumi.Int(60),
					EvaluationPeriods: pulumi.Int(5),
					Cooldown:          pulumi.Int(300),
				},
			},
			ScalingDownPolicies: aws.ElastigroupScalingDownPolicyArray{
				&aws.ElastigroupScalingDownPolicyArgs{
					PolicyName:        pulumi.String("Default Scaling Down Policy"),
					MetricName:        pulumi.String("DefaultQueuesDepth"),
					Statistic:         pulumi.String("average"),
					Unit:              pulumi.String("none"),
					Adjustment:        pulumi.String("1"),
					Namespace:         pulumi.String("custom"),
					Threshold:         pulumi.Float64(10),
					Period:            pulumi.Int(60),
					EvaluationPeriods: pulumi.Int(10),
					Cooldown:          pulumi.Int(300),
				},
			},
			Tags: aws.ElastigroupTagArray{
				&aws.ElastigroupTagArgs{
					Key:   pulumi.String("Env"),
					Value: pulumi.String("production"),
				},
				&aws.ElastigroupTagArgs{
					Key:   pulumi.String("Name"),
					Value: pulumi.String("default-production"),
				},
				&aws.ElastigroupTagArgs{
					Key:   pulumi.String("Project"),
					Value: pulumi.String("app_v2"),
				},
			},
			ResourceTagSpecifications: aws.ElastigroupResourceTagSpecificationArray{
				&aws.ElastigroupResourceTagSpecificationArgs{
					ShouldTagEnis:      pulumi.Bool(true),
					ShouldTagVolumes:   pulumi.Bool(true),
					ShouldTagSnapshots: pulumi.Bool(true),
					ShouldTagAmis:      pulumi.Bool(true),
				},
			},
			Logging: &aws.ElastigroupLoggingArgs{
				Export: &aws.ElastigroupLoggingExportArgs{
					S3s: aws.ElastigroupLoggingExportS3Array{
						&aws.ElastigroupLoggingExportS3Args{
							Id: pulumi.String("di-123456"),
						},
					},
				},
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using SpotInst = Pulumi.SpotInst;

return await Deployment.RunAsync(() => 
{
    // Create an Elastigroup
    var default_elastigroup = new SpotInst.Aws.Elastigroup("default-elastigroup", new()
    {
        Name = "default-elastigroup",
        Description = "created by Pulumi",
        Product = "Linux/UNIX",
        MaxSize = 0,
        MinSize = 0,
        DesiredCapacity = 0,
        CapacityUnit = "weight",
        Region = "us-west-2",
        SubnetIds = new[]
        {
            "sb-123456",
            "sb-456789",
        },
        ImageId = "ami-a27d8fda",
        IamInstanceProfile = "iam-profile",
        KeyName = "my-key.ssh",
        SecurityGroups = new[]
        {
            "sg-123456",
        },
        UserData = "echo hello world",
        EnableMonitoring = false,
        EbsOptimized = false,
        PlacementTenancy = "default",
        MetadataOptions = new SpotInst.Aws.Inputs.ElastigroupMetadataOptionsArgs
        {
            HttpTokens = "optional",
            HttpPutResponseHopLimit = 10,
            InstanceMetadataTags = "enabled",
        },
        CpuOptions = new SpotInst.Aws.Inputs.ElastigroupCpuOptionsArgs
        {
            ThreadsPerCore = 1,
        },
        InstanceTypesOndemand = "m3.2xlarge",
        InstanceTypesSpots = new[]
        {
            "m3.xlarge",
            "m3.2xlarge",
        },
        InstanceTypesPreferredSpots = new[]
        {
            "m3.xlarge",
        },
        OnDemandTypes = new[]
        {
            "c3.large",
        },
        InstanceTypesWeights = new[]
        {
            new SpotInst.Aws.Inputs.ElastigroupInstanceTypesWeightArgs
            {
                InstanceType = "m3.xlarge",
                Weight = 10,
            },
            new SpotInst.Aws.Inputs.ElastigroupInstanceTypesWeightArgs
            {
                InstanceType = "m3.2xlarge",
                Weight = 16,
            },
        },
        ResourceRequirements = new[]
        {
            new SpotInst.Aws.Inputs.ElastigroupResourceRequirementArgs
            {
                ExcludedInstanceFamilies = new[]
                {
                    "a",
                    "m",
                },
                ExcludedInstanceTypes = new[]
                {
                    "m3.large",
                },
                ExcludedInstanceGenerations = new[]
                {
                    "1",
                    "2",
                },
                RequiredGpuMinimum = 1,
                RequiredGpuMaximum = 16,
                RequiredMemoryMinimum = 1,
                RequiredMemoryMaximum = 512,
                RequiredVcpuMinimum = 1,
                RequiredVcpuMaximum = 64,
            },
        },
        Orientation = "balanced",
        FallbackToOndemand = false,
        CpuCredits = "unlimited",
        MinimumInstanceLifetime = 12,
        WaitForCapacity = 5,
        WaitForCapacityTimeout = 300,
        ScalingStrategies = new[]
        {
            new SpotInst.Aws.Inputs.ElastigroupScalingStrategyArgs
            {
                TerminateAtEndOfBillingHour = true,
                TerminationPolicy = "default",
            },
        },
        ScalingUpPolicies = new[]
        {
            new SpotInst.Aws.Inputs.ElastigroupScalingUpPolicyArgs
            {
                PolicyName = "Default Scaling Up Policy",
                MetricName = "DefaultQueuesDepth",
                Statistic = "average",
                Unit = "none",
                Adjustment = "1",
                Namespace = "custom",
                Threshold = 100,
                Period = 60,
                EvaluationPeriods = 5,
                Cooldown = 300,
            },
        },
        ScalingDownPolicies = new[]
        {
            new SpotInst.Aws.Inputs.ElastigroupScalingDownPolicyArgs
            {
                PolicyName = "Default Scaling Down Policy",
                MetricName = "DefaultQueuesDepth",
                Statistic = "average",
                Unit = "none",
                Adjustment = "1",
                Namespace = "custom",
                Threshold = 10,
                Period = 60,
                EvaluationPeriods = 10,
                Cooldown = 300,
            },
        },
        Tags = new[]
        {
            new SpotInst.Aws.Inputs.ElastigroupTagArgs
            {
                Key = "Env",
                Value = "production",
            },
            new SpotInst.Aws.Inputs.ElastigroupTagArgs
            {
                Key = "Name",
                Value = "default-production",
            },
            new SpotInst.Aws.Inputs.ElastigroupTagArgs
            {
                Key = "Project",
                Value = "app_v2",
            },
        },
        ResourceTagSpecifications = new[]
        {
            new SpotInst.Aws.Inputs.ElastigroupResourceTagSpecificationArgs
            {
                ShouldTagEnis = true,
                ShouldTagVolumes = true,
                ShouldTagSnapshots = true,
                ShouldTagAmis = true,
            },
        },
        Logging = new SpotInst.Aws.Inputs.ElastigroupLoggingArgs
        {
            Export = new SpotInst.Aws.Inputs.ElastigroupLoggingExportArgs
            {
                S3s = new[]
                {
                    new SpotInst.Aws.Inputs.ElastigroupLoggingExportS3Args
                    {
                        Id = "di-123456",
                    },
                },
            },
        },
    });

});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.spotinst.aws.Elastigroup;
import com.pulumi.spotinst.aws.ElastigroupArgs;
import com.pulumi.spotinst.aws.inputs.ElastigroupMetadataOptionsArgs;
import com.pulumi.spotinst.aws.inputs.ElastigroupCpuOptionsArgs;
import com.pulumi.spotinst.aws.inputs.ElastigroupInstanceTypesWeightArgs;
import com.pulumi.spotinst.aws.inputs.ElastigroupResourceRequirementArgs;
import com.pulumi.spotinst.aws.inputs.ElastigroupScalingStrategyArgs;
import com.pulumi.spotinst.aws.inputs.ElastigroupScalingUpPolicyArgs;
import com.pulumi.spotinst.aws.inputs.ElastigroupScalingDownPolicyArgs;
import com.pulumi.spotinst.aws.inputs.ElastigroupTagArgs;
import com.pulumi.spotinst.aws.inputs.ElastigroupResourceTagSpecificationArgs;
import com.pulumi.spotinst.aws.inputs.ElastigroupLoggingArgs;
import com.pulumi.spotinst.aws.inputs.ElastigroupLoggingExportArgs;
import java.util.List;
import java.util.ArrayList;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;

public class App {
    public static void main(String[] args) {
        Pulumi.run(App::stack);
    }

    public static void stack(Context ctx) {
        // Create an Elastigroup
        var default_elastigroup = new Elastigroup("default-elastigroup", ElastigroupArgs.builder()
            .name("default-elastigroup")
            .description("created by Pulumi")
            .product("Linux/UNIX")
            .maxSize(0)
            .minSize(0)
            .desiredCapacity(0)
            .capacityUnit("weight")
            .region("us-west-2")
            .subnetIds(            
                "sb-123456",
                "sb-456789")
            .imageId("ami-a27d8fda")
            .iamInstanceProfile("iam-profile")
            .keyName("my-key.ssh")
            .securityGroups("sg-123456")
            .userData("echo hello world")
            .enableMonitoring(false)
            .ebsOptimized(false)
            .placementTenancy("default")
            .metadataOptions(ElastigroupMetadataOptionsArgs.builder()
                .httpTokens("optional")
                .httpPutResponseHopLimit(10)
                .instanceMetadataTags("enabled")
                .build())
            .cpuOptions(ElastigroupCpuOptionsArgs.builder()
                .threadsPerCore(1)
                .build())
            .instanceTypesOndemand("m3.2xlarge")
            .instanceTypesSpots(            
                "m3.xlarge",
                "m3.2xlarge")
            .instanceTypesPreferredSpots("m3.xlarge")
            .onDemandTypes("c3.large")
            .instanceTypesWeights(            
                ElastigroupInstanceTypesWeightArgs.builder()
                    .instanceType("m3.xlarge")
                    .weight(10)
                    .build(),
                ElastigroupInstanceTypesWeightArgs.builder()
                    .instanceType("m3.2xlarge")
                    .weight(16)
                    .build())
            .resourceRequirements(ElastigroupResourceRequirementArgs.builder()
                .excludedInstanceFamilies(                
                    "a",
                    "m")
                .excludedInstanceTypes("m3.large")
                .excludedInstanceGenerations(                
                    "1",
                    "2")
                .requiredGpuMinimum(1)
                .requiredGpuMaximum(16)
                .requiredMemoryMinimum(1)
                .requiredMemoryMaximum(512)
                .requiredVcpuMinimum(1)
                .requiredVcpuMaximum(64)
                .build())
            .orientation("balanced")
            .fallbackToOndemand(false)
            .cpuCredits("unlimited")
            .minimumInstanceLifetime(12)
            .waitForCapacity(5)
            .waitForCapacityTimeout(300)
            .scalingStrategies(ElastigroupScalingStrategyArgs.builder()
                .terminateAtEndOfBillingHour(true)
                .terminationPolicy("default")
                .build())
            .scalingUpPolicies(ElastigroupScalingUpPolicyArgs.builder()
                .policyName("Default Scaling Up Policy")
                .metricName("DefaultQueuesDepth")
                .statistic("average")
                .unit("none")
                .adjustment(1)
                .namespace("custom")
                .threshold(100)
                .period(60)
                .evaluationPeriods(5)
                .cooldown(300)
                .build())
            .scalingDownPolicies(ElastigroupScalingDownPolicyArgs.builder()
                .policyName("Default Scaling Down Policy")
                .metricName("DefaultQueuesDepth")
                .statistic("average")
                .unit("none")
                .adjustment(1)
                .namespace("custom")
                .threshold(10)
                .period(60)
                .evaluationPeriods(10)
                .cooldown(300)
                .build())
            .tags(            
                ElastigroupTagArgs.builder()
                    .key("Env")
                    .value("production")
                    .build(),
                ElastigroupTagArgs.builder()
                    .key("Name")
                    .value("default-production")
                    .build(),
                ElastigroupTagArgs.builder()
                    .key("Project")
                    .value("app_v2")
                    .build())
            .resourceTagSpecifications(ElastigroupResourceTagSpecificationArgs.builder()
                .shouldTagEnis(true)
                .shouldTagVolumes(true)
                .shouldTagSnapshots(true)
                .shouldTagAmis(true)
                .build())
            .logging(ElastigroupLoggingArgs.builder()
                .export(ElastigroupLoggingExportArgs.builder()
                    .s3s(ElastigroupLoggingExportS3Args.builder()
                        .id("di-123456")
                        .build())
                    .build())
                .build())
            .build());

    }
}

resources:
  # Create an Elastigroup
  default-elastigroup:
    type: spotinst:aws:Elastigroup
    properties:
      name: default-elastigroup
      description: created by Pulumi
      product: Linux/UNIX
      maxSize: 0
      minSize: 0
      desiredCapacity: 0
      capacityUnit: weight
      region: us-west-2
      subnetIds:
        - sb-123456
        - sb-456789
      imageId: ami-a27d8fda
      iamInstanceProfile: iam-profile
      keyName: my-key.ssh
      securityGroups:
        - sg-123456
      userData: echo hello world
      enableMonitoring: false
      ebsOptimized: false
      placementTenancy: default
      metadataOptions:
        httpTokens: optional
        httpPutResponseHopLimit: 10
        instanceMetadataTags: enabled
      cpuOptions:
        threadsPerCore: 1
      instanceTypesOndemand: m3.2xlarge
      instanceTypesSpots:
        - m3.xlarge
        - m3.2xlarge
      instanceTypesPreferredSpots:
        - m3.xlarge
      onDemandTypes:
        - c3.large
      instanceTypesWeights:
        - instanceType: m3.xlarge
          weight: 10
        - instanceType: m3.2xlarge
          weight: 16
      resourceRequirements:
        - excludedInstanceFamilies:
            - a
            - m
          excludedInstanceTypes:
            - m3.large
          excludedInstanceGenerations:
            - '1'
            - '2'
          requiredGpuMinimum: 1
          requiredGpuMaximum: 16
          requiredMemoryMinimum: 1
          requiredMemoryMaximum: 512
          requiredVcpuMinimum: 1
          requiredVcpuMaximum: 64
      orientation: balanced
      fallbackToOndemand: false
      cpuCredits: unlimited
      minimumInstanceLifetime: 12
      waitForCapacity: 5
      waitForCapacityTimeout: 300
      scalingStrategies:
        - terminateAtEndOfBillingHour: true
          terminationPolicy: default
      scalingUpPolicies:
        - policyName: Default Scaling Up Policy
          metricName: DefaultQueuesDepth
          statistic: average
          unit: none
          adjustment: 1
          namespace: custom
          threshold: 100
          period: 60
          evaluationPeriods: 5
          cooldown: 300
      scalingDownPolicies:
        - policyName: Default Scaling Down Policy
          metricName: DefaultQueuesDepth
          statistic: average
          unit: none
          adjustment: 1
          namespace: custom
          threshold: 10
          period: 60
          evaluationPeriods: 10
          cooldown: 300
      tags:
        - key: Env
          value: production
        - key: Name
          value: default-production
        - key: Project
          value: app_v2
      resourceTagSpecifications:
        - shouldTagEnis: true
          shouldTagVolumes: true
          shouldTagSnapshots: true
          shouldTagAmis: true
      logging:
        export:
          s3s:
            - id: di-123456

var elastigroupResource = new SpotInst.Aws.Elastigroup("elastigroupResource", new()
{
    FallbackToOndemand = false,
    Orientation = "string",
    Product = "string",
    SecurityGroups = new[]
    {
        "string",
    },
    AutoHealing = false,
    AvailabilityZones = new[]
    {
        "string",
    },
    BlockDevicesMode = "string",
    CapacityUnit = "string",
    ConsiderOdPricing = false,
    CpuCredits = "string",
    CpuOptions = new SpotInst.Aws.Inputs.ElastigroupCpuOptionsArgs
    {
        ThreadsPerCore = 0,
    },
    Description = "string",
    DesiredCapacity = 0,
    DrainingTimeout = 0,
    EbsBlockDevices = new[]
    {
        new SpotInst.Aws.Inputs.ElastigroupEbsBlockDeviceArgs
        {
            DeviceName = "string",
            DeleteOnTermination = false,
            DynamicIops = new SpotInst.Aws.Inputs.ElastigroupEbsBlockDeviceDynamicIopsArgs
            {
                BaseSize = 0,
                Resource = "string",
                SizePerResourceUnit = 0,
            },
            DynamicVolumeSize = new SpotInst.Aws.Inputs.ElastigroupEbsBlockDeviceDynamicVolumeSizeArgs
            {
                BaseSize = 0,
                Resource = "string",
                SizePerResourceUnit = 0,
            },
            Encrypted = false,
            Iops = 0,
            KmsKeyId = "string",
            SnapshotId = "string",
            Throughput = 0,
            VolumeSize = 0,
            VolumeType = "string",
        },
    },
    EbsOptimized = false,
    ElasticIps = new[]
    {
        "string",
    },
    ElasticLoadBalancers = new[]
    {
        "string",
    },
    EnableMonitoring = false,
    EphemeralBlockDevices = new[]
    {
        new SpotInst.Aws.Inputs.ElastigroupEphemeralBlockDeviceArgs
        {
            DeviceName = "string",
            VirtualName = "string",
        },
    },
    HealthCheckGracePeriod = 0,
    HealthCheckType = "string",
    HealthCheckUnhealthyDurationBeforeReplacement = 0,
    IamInstanceProfile = "string",
    ImageId = "string",
    Images = new[]
    {
        new SpotInst.Aws.Inputs.ElastigroupImageArgs
        {
            Images = new[]
            {
                new SpotInst.Aws.Inputs.ElastigroupImageImageArgs
                {
                    Id = "string",
                },
            },
        },
    },
    ImmediateOdRecoverThreshold = 0,
    InstanceTypesOndemand = "string",
    InstanceTypesPreferredSpots = new[]
    {
        "string",
    },
    InstanceTypesSpots = new[]
    {
        "string",
    },
    InstanceTypesWeights = new[]
    {
        new SpotInst.Aws.Inputs.ElastigroupInstanceTypesWeightArgs
        {
            InstanceType = "string",
            Weight = 0,
        },
    },
    IntegrationBeanstalk = new SpotInst.Aws.Inputs.ElastigroupIntegrationBeanstalkArgs
    {
        DeploymentPreferences = new SpotInst.Aws.Inputs.ElastigroupIntegrationBeanstalkDeploymentPreferencesArgs
        {
            AutomaticRoll = false,
            BatchSizePercentage = 0,
            GracePeriod = 0,
            Strategy = new SpotInst.Aws.Inputs.ElastigroupIntegrationBeanstalkDeploymentPreferencesStrategyArgs
            {
                Action = "string",
                ShouldDrainInstances = false,
            },
        },
        EnvironmentId = "string",
        ManagedActions = new SpotInst.Aws.Inputs.ElastigroupIntegrationBeanstalkManagedActionsArgs
        {
            PlatformUpdate = new SpotInst.Aws.Inputs.ElastigroupIntegrationBeanstalkManagedActionsPlatformUpdateArgs
            {
                PerformAt = "string",
                TimeWindow = "string",
                UpdateLevel = "string",
            },
        },
    },
    IntegrationCodedeploy = new SpotInst.Aws.Inputs.ElastigroupIntegrationCodedeployArgs
    {
        CleanupOnFailure = false,
        DeploymentGroups = new[]
        {
            new SpotInst.Aws.Inputs.ElastigroupIntegrationCodedeployDeploymentGroupArgs
            {
                ApplicationName = "string",
                DeploymentGroupName = "string",
            },
        },
        TerminateInstanceOnFailure = false,
    },
    IntegrationDockerSwarm = new SpotInst.Aws.Inputs.ElastigroupIntegrationDockerSwarmArgs
    {
        MasterHost = "string",
        MasterPort = 0,
        AutoscaleCooldown = 0,
        AutoscaleDown = new SpotInst.Aws.Inputs.ElastigroupIntegrationDockerSwarmAutoscaleDownArgs
        {
            EvaluationPeriods = 0,
            MaxScaleDownPercentage = 0,
        },
        AutoscaleHeadroom = new SpotInst.Aws.Inputs.ElastigroupIntegrationDockerSwarmAutoscaleHeadroomArgs
        {
            CpuPerUnit = 0,
            MemoryPerUnit = 0,
            NumOfUnits = 0,
        },
        AutoscaleIsEnabled = false,
    },
    IntegrationEcs = new SpotInst.Aws.Inputs.ElastigroupIntegrationEcsArgs
    {
        ClusterName = "string",
        AutoscaleAttributes = new[]
        {
            new SpotInst.Aws.Inputs.ElastigroupIntegrationEcsAutoscaleAttributeArgs
            {
                Key = "string",
                Value = "string",
            },
        },
        AutoscaleCooldown = 0,
        AutoscaleDown = new SpotInst.Aws.Inputs.ElastigroupIntegrationEcsAutoscaleDownArgs
        {
            EvaluationPeriods = 0,
            MaxScaleDownPercentage = 0,
        },
        AutoscaleHeadroom = new SpotInst.Aws.Inputs.ElastigroupIntegrationEcsAutoscaleHeadroomArgs
        {
            CpuPerUnit = 0,
            MemoryPerUnit = 0,
            NumOfUnits = 0,
        },
        AutoscaleIsAutoConfig = false,
        AutoscaleIsEnabled = false,
        AutoscaleScaleDownNonServiceTasks = false,
        Batch = new SpotInst.Aws.Inputs.ElastigroupIntegrationEcsBatchArgs
        {
            JobQueueNames = new[]
            {
                "string",
            },
        },
    },
    IntegrationGitlab = new SpotInst.Aws.Inputs.ElastigroupIntegrationGitlabArgs
    {
        Runner = new SpotInst.Aws.Inputs.ElastigroupIntegrationGitlabRunnerArgs
        {
            IsEnabled = false,
        },
    },
    IntegrationKubernetes = new SpotInst.Aws.Inputs.ElastigroupIntegrationKubernetesArgs
    {
        ApiServer = "string",
        AutoscaleCooldown = 0,
        AutoscaleDown = new SpotInst.Aws.Inputs.ElastigroupIntegrationKubernetesAutoscaleDownArgs
        {
            EvaluationPeriods = 0,
            MaxScaleDownPercentage = 0,
        },
        AutoscaleHeadroom = new SpotInst.Aws.Inputs.ElastigroupIntegrationKubernetesAutoscaleHeadroomArgs
        {
            CpuPerUnit = 0,
            MemoryPerUnit = 0,
            NumOfUnits = 0,
        },
        AutoscaleIsAutoConfig = false,
        AutoscaleIsEnabled = false,
        AutoscaleLabels = new[]
        {
            new SpotInst.Aws.Inputs.ElastigroupIntegrationKubernetesAutoscaleLabelArgs
            {
                Key = "string",
                Value = "string",
            },
        },
        ClusterIdentifier = "string",
        IntegrationMode = "string",
        Token = "string",
    },
    IntegrationMesosphere = new SpotInst.Aws.Inputs.ElastigroupIntegrationMesosphereArgs
    {
        ApiServer = "string",
    },
    IntegrationNomad = new SpotInst.Aws.Inputs.ElastigroupIntegrationNomadArgs
    {
        MasterHost = "string",
        MasterPort = 0,
        AclToken = "string",
        AutoscaleConstraints = new[]
        {
            new SpotInst.Aws.Inputs.ElastigroupIntegrationNomadAutoscaleConstraintArgs
            {
                Key = "string",
                Value = "string",
            },
        },
        AutoscaleCooldown = 0,
        AutoscaleDown = new SpotInst.Aws.Inputs.ElastigroupIntegrationNomadAutoscaleDownArgs
        {
            EvaluationPeriods = 0,
        },
        AutoscaleHeadroom = new SpotInst.Aws.Inputs.ElastigroupIntegrationNomadAutoscaleHeadroomArgs
        {
            CpuPerUnit = 0,
            MemoryPerUnit = 0,
            NumOfUnits = 0,
        },
        AutoscaleIsEnabled = false,
    },
    IntegrationRancher = new SpotInst.Aws.Inputs.ElastigroupIntegrationRancherArgs
    {
        AccessKey = "string",
        MasterHost = "string",
        SecretKey = "string",
        Version = "string",
    },
    IntegrationRoute53 = new SpotInst.Aws.Inputs.ElastigroupIntegrationRoute53Args
    {
        Domains = new[]
        {
            new SpotInst.Aws.Inputs.ElastigroupIntegrationRoute53DomainArgs
            {
                HostedZoneId = "string",
                RecordSets = new[]
                {
                    new SpotInst.Aws.Inputs.ElastigroupIntegrationRoute53DomainRecordSetArgs
                    {
                        Name = "string",
                        UsePublicDns = false,
                        UsePublicIp = false,
                    },
                },
                RecordSetType = "string",
                SpotinstAcctId = "string",
            },
        },
    },
    Itfs = new[]
    {
        new SpotInst.Aws.Inputs.ElastigroupItfArgs
        {
            FixedTargetGroups = false,
            LoadBalancers = new[]
            {
                new SpotInst.Aws.Inputs.ElastigroupItfLoadBalancerArgs
                {
                    ListenerRules = new[]
                    {
                        new SpotInst.Aws.Inputs.ElastigroupItfLoadBalancerListenerRuleArgs
                        {
                            RuleArn = "string",
                            StaticTargetGroup = new SpotInst.Aws.Inputs.ElastigroupItfLoadBalancerListenerRuleStaticTargetGroupArgs
                            {
                                Arn = "string",
                                Percentage = 0,
                            },
                        },
                    },
                    LoadBalancerArn = "string",
                },
            },
            TargetGroupConfigs = new[]
            {
                new SpotInst.Aws.Inputs.ElastigroupItfTargetGroupConfigArgs
                {
                    Port = 0,
                    HealthCheckPath = "string",
                    VpcId = "string",
                    Protocol = "string",
                    Matchers = new[]
                    {
                        new SpotInst.Aws.Inputs.ElastigroupItfTargetGroupConfigMatcherArgs
                        {
                            GrpcCode = "string",
                            HttpCode = "string",
                        },
                    },
                    HealthyThresholdCount = 0,
                    HealthCheckIntervalSeconds = 0,
                    HealthCheckTimeoutSeconds = 0,
                    HealthCheckProtocol = "string",
                    ProtocolVersion = "string",
                    Tags = new[]
                    {
                        new SpotInst.Aws.Inputs.ElastigroupItfTargetGroupConfigTagArgs
                        {
                            TagKey = "string",
                            TagValue = "string",
                        },
                    },
                    UnhealthyThresholdCount = 0,
                    HealthCheckPort = "string",
                },
            },
            WeightStrategy = "string",
            DefaultStaticTargetGroup = new SpotInst.Aws.Inputs.ElastigroupItfDefaultStaticTargetGroupArgs
            {
                Arn = "string",
                Percentage = 0,
            },
            MigrationHealthinessThreshold = 0,
        },
    },
    KeyName = "string",
    LifetimePeriod = "string",
    Logging = new SpotInst.Aws.Inputs.ElastigroupLoggingArgs
    {
        Export = new SpotInst.Aws.Inputs.ElastigroupLoggingExportArgs
        {
            S3s = new[]
            {
                new SpotInst.Aws.Inputs.ElastigroupLoggingExportS3Args
                {
                    Id = "string",
                },
            },
        },
    },
    MaxSize = 0,
    MetadataOptions = new SpotInst.Aws.Inputs.ElastigroupMetadataOptionsArgs
    {
        HttpTokens = "string",
        HttpPutResponseHopLimit = 0,
        InstanceMetadataTags = "string",
    },
    MinSize = 0,
    MinimumInstanceLifetime = 0,
    MultipleMetrics = new SpotInst.Aws.Inputs.ElastigroupMultipleMetricsArgs
    {
        Expressions = new[]
        {
            new SpotInst.Aws.Inputs.ElastigroupMultipleMetricsExpressionArgs
            {
                Expression = "string",
                Name = "string",
            },
        },
        Metrics = new[]
        {
            new SpotInst.Aws.Inputs.ElastigroupMultipleMetricsMetricArgs
            {
                MetricName = "string",
                Name = "string",
                Namespace = "string",
                Dimensions = new[]
                {
                    new SpotInst.Aws.Inputs.ElastigroupMultipleMetricsMetricDimensionArgs
                    {
                        Name = "string",
                        Value = "string",
                    },
                },
                ExtendedStatistic = "string",
                Statistic = "string",
                Unit = "string",
            },
        },
    },
    Name = "string",
    NetworkInterfaces = new[]
    {
        new SpotInst.Aws.Inputs.ElastigroupNetworkInterfaceArgs
        {
            DeviceIndex = "string",
            AssociateIpv6Address = false,
            AssociatePublicIpAddress = false,
            DeleteOnTermination = false,
            Description = "string",
            NetworkInterfaceId = "string",
            PrivateIpAddress = "string",
            SecondaryPrivateIpAddressCount = "string",
        },
    },
    OnDemandTypes = new[]
    {
        "string",
    },
    OndemandCount = 0,
    PersistBlockDevices = false,
    PersistPrivateIp = false,
    PersistRootDevice = false,
    PlacementTenancy = "string",
    PreferredAvailabilityZones = new[]
    {
        "string",
    },
    PrivateIps = new[]
    {
        "string",
    },
    Region = "string",
    ResourceRequirements = new[]
    {
        new SpotInst.Aws.Inputs.ElastigroupResourceRequirementArgs
        {
            RequiredMemoryMaximum = 0,
            RequiredMemoryMinimum = 0,
            RequiredVcpuMaximum = 0,
            RequiredVcpuMinimum = 0,
            ExcludedInstanceFamilies = new[]
            {
                "string",
            },
            ExcludedInstanceGenerations = new[]
            {
                "string",
            },
            ExcludedInstanceTypes = new[]
            {
                "string",
            },
            RequiredGpuMaximum = 0,
            RequiredGpuMinimum = 0,
        },
    },
    ResourceTagSpecifications = new[]
    {
        new SpotInst.Aws.Inputs.ElastigroupResourceTagSpecificationArgs
        {
            ShouldTagAmis = false,
            ShouldTagEnis = false,
            ShouldTagSnapshots = false,
            ShouldTagVolumes = false,
        },
    },
    RestrictSingleAz = false,
    RevertToSpot = new SpotInst.Aws.Inputs.ElastigroupRevertToSpotArgs
    {
        PerformAt = "string",
        TimeWindows = new[]
        {
            "string",
        },
    },
    ScalingDownPolicies = new[]
    {
        new SpotInst.Aws.Inputs.ElastigroupScalingDownPolicyArgs
        {
            MetricName = "string",
            PolicyName = "string",
            Namespace = "string",
            Minimum = "string",
            Operator = "string",
            IsEnabled = false,
            MaxTargetCapacity = "string",
            Maximum = "string",
            Dimensions = new[]
            {
                new SpotInst.Aws.Inputs.ElastigroupScalingDownPolicyDimensionArgs
                {
                    Name = "string",
                    Value = "string",
                },
            },
            MinTargetCapacity = "string",
            ActionType = "string",
            Cooldown = 0,
            EvaluationPeriods = 0,
            Period = 0,
            Adjustment = "string",
            Source = "string",
            Statistic = "string",
            StepAdjustments = new[]
            {
                new SpotInst.Aws.Inputs.ElastigroupScalingDownPolicyStepAdjustmentArgs
                {
                    Action = new SpotInst.Aws.Inputs.ElastigroupScalingDownPolicyStepAdjustmentActionArgs
                    {
                        Type = "string",
                        Adjustment = "string",
                        MaxTargetCapacity = "string",
                        Maximum = "string",
                        MinTargetCapacity = "string",
                        Minimum = "string",
                        Target = "string",
                    },
                    Threshold = 0,
                },
            },
            Target = "string",
            Threshold = 0,
            Unit = "string",
        },
    },
    ScalingStrategies = new[]
    {
        new SpotInst.Aws.Inputs.ElastigroupScalingStrategyArgs
        {
            TerminateAtEndOfBillingHour = false,
            TerminationPolicy = "string",
        },
    },
    ScalingTargetPolicies = new[]
    {
        new SpotInst.Aws.Inputs.ElastigroupScalingTargetPolicyArgs
        {
            MetricName = "string",
            Target = 0,
            PolicyName = "string",
            Namespace = "string",
            Period = 0,
            MaxCapacityPerScale = "string",
            Cooldown = 0,
            EvaluationPeriods = 0,
            PredictiveMode = "string",
            Source = "string",
            Statistic = "string",
            Dimensions = new[]
            {
                new SpotInst.Aws.Inputs.ElastigroupScalingTargetPolicyDimensionArgs
                {
                    Name = "string",
                    Value = "string",
                },
            },
            Unit = "string",
        },
    },
    ScalingUpPolicies = new[]
    {
        new SpotInst.Aws.Inputs.ElastigroupScalingUpPolicyArgs
        {
            MetricName = "string",
            PolicyName = "string",
            Namespace = "string",
            Minimum = "string",
            Operator = "string",
            IsEnabled = false,
            MaxTargetCapacity = "string",
            Maximum = "string",
            Dimensions = new[]
            {
                new SpotInst.Aws.Inputs.ElastigroupScalingUpPolicyDimensionArgs
                {
                    Name = "string",
                    Value = "string",
                },
            },
            MinTargetCapacity = "string",
            ActionType = "string",
            Cooldown = 0,
            EvaluationPeriods = 0,
            Period = 0,
            Adjustment = "string",
            Source = "string",
            Statistic = "string",
            StepAdjustments = new[]
            {
                new SpotInst.Aws.Inputs.ElastigroupScalingUpPolicyStepAdjustmentArgs
                {
                    Action = new SpotInst.Aws.Inputs.ElastigroupScalingUpPolicyStepAdjustmentActionArgs
                    {
                        Type = "string",
                        Adjustment = "string",
                        MaxTargetCapacity = "string",
                        Maximum = "string",
                        MinTargetCapacity = "string",
                        Minimum = "string",
                        Target = "string",
                    },
                    Threshold = 0,
                },
            },
            Target = "string",
            Threshold = 0,
            Unit = "string",
        },
    },
    ScheduledTasks = new[]
    {
        new SpotInst.Aws.Inputs.ElastigroupScheduledTaskArgs
        {
            TaskType = "string",
            IsEnabled = false,
            MinCapacity = "string",
            CronExpression = "string",
            Frequency = "string",
            GracePeriod = "string",
            Adjustment = "string",
            MaxCapacity = "string",
            BatchSizePercentage = "string",
            ScaleMaxCapacity = "string",
            ScaleMinCapacity = "string",
            ScaleTargetCapacity = "string",
            StartTime = "string",
            TargetCapacity = "string",
            AdjustmentPercentage = "string",
        },
    },
    ShutdownScript = "string",
    Signals = new[]
    {
        new SpotInst.Aws.Inputs.ElastigroupSignalArgs
        {
            Name = "string",
            Timeout = 0,
        },
    },
    SpotPercentage = 0,
    StatefulDeallocation = new SpotInst.Aws.Inputs.ElastigroupStatefulDeallocationArgs
    {
        ShouldDeleteImages = false,
        ShouldDeleteNetworkInterfaces = false,
        ShouldDeleteSnapshots = false,
        ShouldDeleteVolumes = false,
    },
    StatefulInstanceActions = new[]
    {
        new SpotInst.Aws.Inputs.ElastigroupStatefulInstanceActionArgs
        {
            StatefulInstanceId = "string",
            Type = "string",
        },
    },
    SubnetIds = new[]
    {
        "string",
    },
    Tags = new[]
    {
        new SpotInst.Aws.Inputs.ElastigroupTagArgs
        {
            Key = "string",
            Value = "string",
        },
    },
    TargetGroupArns = new[]
    {
        "string",
    },
    UpdatePolicy = new SpotInst.Aws.Inputs.ElastigroupUpdatePolicyArgs
    {
        ShouldResumeStateful = false,
        ShouldRoll = false,
        AutoApplyTags = false,
        RollConfig = new SpotInst.Aws.Inputs.ElastigroupUpdatePolicyRollConfigArgs
        {
            BatchSizePercentage = 0,
            GracePeriod = 0,
            HealthCheckType = "string",
            Strategy = new SpotInst.Aws.Inputs.ElastigroupUpdatePolicyRollConfigStrategyArgs
            {
                Action = "string",
                BatchMinHealthyPercentage = 0,
                OnFailure = new SpotInst.Aws.Inputs.ElastigroupUpdatePolicyRollConfigStrategyOnFailureArgs
                {
                    ActionType = "string",
                    BatchNum = 0,
                    DrainingTimeout = 0,
                    ShouldDecrementTargetCapacity = false,
                    ShouldHandleAllBatches = false,
                },
                ShouldDrainInstances = false,
            },
            WaitForRollPercentage = 0,
            WaitForRollTimeout = 0,
        },
    },
    UserData = "string",
    UtilizeCommitments = false,
    UtilizeReservedInstances = false,
    WaitForCapacity = 0,
    WaitForCapacityTimeout = 0,
});