Group class

Provides an Auto Scaling Group resource.

> Note: You must specify either launchConfiguration, launchTemplate, or mixedInstancesPolicy.

> NOTE on Auto Scaling Groups, Attachments and Traffic Source Attachments: Pulumi provides standalone Attachment (for attaching Classic Load Balancers and Application Load Balancer, Gateway Load Balancer, or Network Load Balancer target groups) and Traffic Source Attachment (for attaching Load Balancers and VPC Lattice target groups) resources and an Auto Scaling Group resource with loadBalancers, targetGroupArns and trafficSource attributes. Do not use the same traffic source in more than one of these resources. Doing so will cause a conflict of attachments. A lifecycle configuration block can be used to suppress differences if necessary.

A newly-created ASG is initially empty and begins to scale to minSize (or desiredCapacity, if specified) by launching instances using the provided Launch Configuration. These instances take time to launch and boot.

On ASG Update, changes to these values also take time to result in the target number of instances providing service.

This provider provides two mechanisms to help consistently manage ASG scale up time across dependent resources.

Waiting for ASG Capacity

The first is default behavior. This provider waits after ASG creation for minSize (or desiredCapacity, if specified) healthy instances to show up in the ASG before continuing.

If minSize or desiredCapacity are changed in a subsequent update, this provider will also wait for the correct number of healthy instances before continuing.

This provider considers an instance "healthy" when the ASG reports HealthStatus: "Healthy" and LifecycleState: "InService". See the AWS AutoScaling Docs for more information on an ASG's lifecycle.

This provider will wait for healthy instances for up to waitForCapacityTimeout. If ASG creation is taking more than a few minutes, it's worth investigating for scaling activity errors, which can be caused by problems with the selected Launch Configuration.

Setting waitForCapacityTimeout to "0" disables ASG Capacity waiting.

Waiting for ELB Capacity

The second mechanism is optional, and affects ASGs with attached ELBs specified via the loadBalancers attribute or with ALBs specified with targetGroupArns.

The minElbCapacity parameter causes the provider to wait for at least the requested number of instances to show up "InService" in all attached ELBs during ASG creation. It has no effect on ASG updates.

If waitForElbCapacity is set, the provider will wait for exactly that number of Instances to be "InService" in all attached ELBs on both creation and updates.

These parameters can be used to ensure that service is being provided before the provider moves on. If new instances don't pass the ELB's health checks for any reason, the apply will time out, and the ASG will be marked as tainted (i.e., marked to be destroyed in a follow up run).

As with ASG Capacity, the provider will wait for up to waitForCapacityTimeout for the proper number of instances to be healthy.

Troubleshooting Capacity Waiting Timeouts

If ASG creation takes more than a few minutes, this could indicate one of a number of configuration problems. See the AWS Docs on Load Balancer Troubleshooting for more information.

Example Usage

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

const test = new aws.ec2.PlacementGroup("test", {
    name: "test",
    strategy: aws.ec2.PlacementStrategy.Cluster,
});
const bar = new aws.autoscaling.Group("bar", {
    instanceMaintenancePolicy: {
        minHealthyPercentage: 90,
        maxHealthyPercentage: 120,
    },
    initialLifecycleHooks: [{
        name: "foobar",
        defaultResult: "CONTINUE",
        heartbeatTimeout: 2000,
        lifecycleTransition: "autoscaling:EC2_INSTANCE_LAUNCHING",
        notificationMetadata: JSON.stringify({
            foo: "bar",
        }),
        notificationTargetArn: "arn:aws:sqs:us-east-1:444455556666:queue1*",
        roleArn: "arn:aws:iam::123456789012:role/S3Access",
    }],
    tags: [
        {
            key: "foo",
            value: "bar",
            propagateAtLaunch: true,
        },
        {
            key: "lorem",
            value: "ipsum",
            propagateAtLaunch: false,
        },
    ],
    name: "foobar3-test",
    maxSize: 5,
    minSize: 2,
    healthCheckGracePeriod: 300,
    healthCheckType: "ELB",
    desiredCapacity: 4,
    forceDelete: true,
    placementGroup: test.id,
    launchConfiguration: foobar.name,
    vpcZoneIdentifiers: [
        example1.id,
        example2.id,
    ],
}, {
    customTimeouts: {
        "delete": "15m",
    },
});
import pulumi
import json
import pulumi_aws as aws

test = aws.ec2.PlacementGroup("test",
    name="test",
    strategy=aws.ec2.PlacementStrategy.CLUSTER)
bar = aws.autoscaling.Group("bar",
    instance_maintenance_policy={
        "min_healthy_percentage": 90,
        "max_healthy_percentage": 120,
    },
    initial_lifecycle_hooks=[{
        "name": "foobar",
        "default_result": "CONTINUE",
        "heartbeat_timeout": 2000,
        "lifecycle_transition": "autoscaling:EC2_INSTANCE_LAUNCHING",
        "notification_metadata": json.dumps({
            "foo": "bar",
        }),
        "notification_target_arn": "arn:aws:sqs:us-east-1:444455556666:queue1*",
        "role_arn": "arn:aws:iam::123456789012:role/S3Access",
    }],
    tags=[
        {
            "key": "foo",
            "value": "bar",
            "propagate_at_launch": True,
        },
        {
            "key": "lorem",
            "value": "ipsum",
            "propagate_at_launch": False,
        },
    ],
    name="foobar3-test",
    max_size=5,
    min_size=2,
    health_check_grace_period=300,
    health_check_type="ELB",
    desired_capacity=4,
    force_delete=True,
    placement_group=test.id,
    launch_configuration=foobar["name"],
    vpc_zone_identifiers=[
        example1["id"],
        example2["id"],
    ],
    opts = pulumi.ResourceOptions(custom_timeouts=pulumi.CustomTimeouts(delete="15m")))
using System.Collections.Generic;
using System.Linq;
using System.Text.Json;
using Pulumi;
using Aws = Pulumi.Aws;

return await Deployment.RunAsync(() =>
{
    var test = new Aws.Ec2.PlacementGroup("test", new()
    {
        Name = "test",
        Strategy = Aws.Ec2.PlacementStrategy.Cluster,
    });

    var bar = new Aws.AutoScaling.Group("bar", new()
    {
        InstanceMaintenancePolicy = new Aws.AutoScaling.Inputs.GroupInstanceMaintenancePolicyArgs
        {
            MinHealthyPercentage = 90,
            MaxHealthyPercentage = 120,
        },
        InitialLifecycleHooks = new[]
        {
            new Aws.AutoScaling.Inputs.GroupInitialLifecycleHookArgs
            {
                Name = "foobar",
                DefaultResult = "CONTINUE",
                HeartbeatTimeout = 2000,
                LifecycleTransition = "autoscaling:EC2_INSTANCE_LAUNCHING",
                NotificationMetadata = JsonSerializer.Serialize(new Dictionary<string, object?>
                {
                    ["foo"] = "bar",
                }),
                NotificationTargetArn = "arn:aws:sqs:us-east-1:444455556666:queue1*",
                RoleArn = "arn:aws:iam::123456789012:role/S3Access",
            },
        },
        Tags = new[]
        {
            new Aws.AutoScaling.Inputs.GroupTagArgs
            {
                Key = "foo",
                Value = "bar",
                PropagateAtLaunch = true,
            },
            new Aws.AutoScaling.Inputs.GroupTagArgs
            {
                Key = "lorem",
                Value = "ipsum",
                PropagateAtLaunch = false,
            },
        },
        Name = "foobar3-test",
        MaxSize = 5,
        MinSize = 2,
        HealthCheckGracePeriod = 300,
        HealthCheckType = "ELB",
        DesiredCapacity = 4,
        ForceDelete = true,
        PlacementGroup = test.Id,
        LaunchConfiguration = foobar.Name,
        VpcZoneIdentifiers = new[]
        {
            example1.Id,
            example2.Id,
        },
    });

});
package main

import (
	"encoding/json"

	"github.com/pulumi/pulumi-aws/sdk/v7/go/aws/autoscaling"
	"github.com/pulumi/pulumi-aws/sdk/v7/go/aws/ec2"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		test, err := ec2.NewPlacementGroup(ctx, "test", &ec2.PlacementGroupArgs{
			Name:     pulumi.String("test"),
			Strategy: pulumi.String(ec2.PlacementStrategyCluster),
		})
		if err != nil {
			return err
		}
		tmpJSON0, err := json.Marshal(map[string]string{
			"foo": "bar",
		})
		if err != nil {
			return err
		}
		json0 := string(tmpJSON0)
		_, err = autoscaling.NewGroup(ctx, "bar", &autoscaling.GroupArgs{
			InstanceMaintenancePolicy: &autoscaling.GroupInstanceMaintenancePolicyArgs{
				MinHealthyPercentage: pulumi.Int(90),
				MaxHealthyPercentage: pulumi.Int(120),
			},
			InitialLifecycleHooks: autoscaling.GroupInitialLifecycleHookArray{
				&autoscaling.GroupInitialLifecycleHookArgs{
					Name:                  pulumi.String("foobar"),
					DefaultResult:         pulumi.String("CONTINUE"),
					HeartbeatTimeout:      pulumi.Int(2000),
					LifecycleTransition:   pulumi.String("autoscaling:EC2_INSTANCE_LAUNCHING"),
					NotificationMetadata:  pulumi.String(json0),
					NotificationTargetArn: pulumi.String("arn:aws:sqs:us-east-1:444455556666:queue1*"),
					RoleArn:               pulumi.String("arn:aws:iam::123456789012:role/S3Access"),
				},
			},
			Tags: autoscaling.GroupTagArray{
				&autoscaling.GroupTagArgs{
					Key:               pulumi.String("foo"),
					Value:             pulumi.String("bar"),
					PropagateAtLaunch: pulumi.Bool(true),
				},
				&autoscaling.GroupTagArgs{
					Key:               pulumi.String("lorem"),
					Value:             pulumi.String("ipsum"),
					PropagateAtLaunch: pulumi.Bool(false),
				},
			},
			Name:                   pulumi.String("foobar3-test"),
			MaxSize:                pulumi.Int(5),
			MinSize:                pulumi.Int(2),
			HealthCheckGracePeriod: pulumi.Int(300),
			HealthCheckType:        pulumi.String("ELB"),
			DesiredCapacity:        pulumi.Int(4),
			ForceDelete:            pulumi.Bool(true),
			PlacementGroup:         test.ID().ToIDOutput().ToStringOutput(),
			LaunchConfiguration:    pulumi.Any(foobar.Name),
			VpcZoneIdentifiers: pulumi.StringArray{
				example1.Id,
				example2.Id,
			},
		}, pulumi.Timeouts(&pulumi.CustomTimeouts{Delete: "15m"}))
		if err != nil {
			return err
		}
		return nil
	})
}
pulumi {
  required_providers {
    aws = {
      source = "pulumi/aws"
    }
  }
}

resource "aws_ec2_placementgroup" "test" {
  name     = "test"
  strategy = "cluster"
}
resource "aws_autoscaling_group" "bar" {
  timeouts {
    delete = "15m"
  }
  instance_maintenance_policy = {
    min_healthy_percentage = 90
    max_healthy_percentage = 120
  }
  initial_lifecycle_hooks {
    name                 = "foobar"
    default_result       = "CONTINUE"
    heartbeat_timeout    = 2000
    lifecycle_transition = "autoscaling:EC2_INSTANCE_LAUNCHING"
    notification_metadata = jsonencode({
      "foo" = "bar"
    })
    notification_target_arn = "arn:aws:sqs:us-east-1:444455556666:queue1*"
    role_arn                = "arn:aws:iam::123456789012:role/S3Access"
  }
  tags {
    key                 = "foo"
    value               = "bar"
    propagate_at_launch = true
  }
  tags {
    key                 = "lorem"
    value               = "ipsum"
    propagate_at_launch = false
  }
  name                      = "foobar3-test"
  max_size                  = 5
  min_size                  = 2
  health_check_grace_period = 300
  health_check_type         = "ELB"
  desired_capacity          = 4
  force_delete              = true
  placement_group           = aws_ec2_placementgroup.test.id
  launch_configuration      = foobar.name
  vpc_zone_identifiers      = [example1.id, example2.id]
}
package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.aws.ec2.PlacementGroup;
import com.pulumi.aws.ec2.PlacementGroupArgs;
import com.pulumi.aws.autoscaling.Group;
import com.pulumi.aws.autoscaling.GroupArgs;
import com.pulumi.aws.autoscaling.inputs.GroupInstanceMaintenancePolicyArgs;
import com.pulumi.aws.autoscaling.inputs.GroupInitialLifecycleHookArgs;
import com.pulumi.aws.autoscaling.inputs.GroupTagArgs;
import static com.pulumi.codegen.internal.Serialization.*;
import com.pulumi.resources.CustomResourceOptions;
import com.pulumi.resources.CustomTimeouts;
import java.util.ArrayList;
import java.util.Arrays;
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) {
        var test = new PlacementGroup("test", PlacementGroupArgs.builder()
            .name("test")
            .strategy("cluster")
            .build());

        var bar = new Group("bar", GroupArgs.builder()
            .instanceMaintenancePolicy(GroupInstanceMaintenancePolicyArgs.builder()
                .minHealthyPercentage(90)
                .maxHealthyPercentage(120)
                .build())
            .initialLifecycleHooks(GroupInitialLifecycleHookArgs.builder()
                .name("foobar")
                .defaultResult("CONTINUE")
                .heartbeatTimeout(2000)
                .lifecycleTransition("autoscaling:EC2_INSTANCE_LAUNCHING")
                .notificationMetadata(serializeJson(
                    jsonObject(
                        jsonProperty("foo", "bar")
                    )))
                .notificationTargetArn("arn:aws:sqs:us-east-1:444455556666:queue1*")
                .roleArn("arn:aws:iam::123456789012:role/S3Access")
                .build())
            .tags(
                GroupTagArgs.builder()
                    .key("foo")
                    .value("bar")
                    .propagateAtLaunch(true)
                    .build(),
                GroupTagArgs.builder()
                    .key("lorem")
                    .value("ipsum")
                    .propagateAtLaunch(false)
                    .build())
            .name("foobar3-test")
            .maxSize(5)
            .minSize(2)
            .healthCheckGracePeriod(300)
            .healthCheckType("ELB")
            .desiredCapacity(4)
            .forceDelete(true)
            .placementGroup(test.id())
            .launchConfiguration(foobar.name())
            .vpcZoneIdentifiers(
                example1.id(),
                example2.id())
            .build(), CustomResourceOptions.builder()
                .customTimeouts(CustomTimeouts.builder()
                    .delete(CustomTimeouts.parseTimeoutString("15m"))
                .build())
                .build());

    }
}
resources:
  test:
    type: aws:ec2:PlacementGroup
    properties:
      name: test
      strategy: cluster
  bar:
    type: aws:autoscaling:Group
    properties:
      instanceMaintenancePolicy:
        minHealthyPercentage: 90
        maxHealthyPercentage: 120
      initialLifecycleHooks:
        - name: foobar
          defaultResult: CONTINUE
          heartbeatTimeout: 2000
          lifecycleTransition: autoscaling:EC2_INSTANCE_LAUNCHING
          notificationMetadata:
            fn::toJSON:
              foo: bar
          notificationTargetArn: arn:aws:sqs:us-east-1:444455556666:queue1*
          roleArn: arn:aws:iam::123456789012:role/S3Access
      tags:
        - key: foo
          value: bar
          propagateAtLaunch: true
        - key: lorem
          value: ipsum
          propagateAtLaunch: false
      name: foobar3-test
      maxSize: 5
      minSize: 2
      healthCheckGracePeriod: 300
      healthCheckType: ELB
      desiredCapacity: 4
      forceDelete: true
      placementGroup: ${test.id}
      launchConfiguration: ${foobar.name}
      vpcZoneIdentifiers:
        - ${example1.id}
        - ${example2.id}
    options:
      customTimeouts:
        delete: 15m

With Latest Version Of Launch Template

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

const foobar = new aws.ec2.LaunchTemplate("foobar", {
    namePrefix: "foobar",
    imageId: "ami-1a2b3c",
    instanceType: "t2.micro",
});
const bar = new aws.autoscaling.Group("bar", {
    launchTemplate: {
        id: foobar.id,
        version: "$Latest",
    },
    availabilityZones: ["us-east-1a"],
    desiredCapacity: 1,
    maxSize: 1,
    minSize: 1,
});
import pulumi
import pulumi_aws as aws

foobar = aws.ec2.LaunchTemplate("foobar",
    name_prefix="foobar",
    image_id="ami-1a2b3c",
    instance_type="t2.micro")
bar = aws.autoscaling.Group("bar",
    launch_template={
        "id": foobar.id,
        "version": "$Latest",
    },
    availability_zones=["us-east-1a"],
    desired_capacity=1,
    max_size=1,
    min_size=1)
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Aws = Pulumi.Aws;

return await Deployment.RunAsync(() =>
{
    var foobar = new Aws.Ec2.LaunchTemplate("foobar", new()
    {
        NamePrefix = "foobar",
        ImageId = "ami-1a2b3c",
        InstanceType = "t2.micro",
    });

    var bar = new Aws.AutoScaling.Group("bar", new()
    {
        LaunchTemplate = new Aws.AutoScaling.Inputs.GroupLaunchTemplateArgs
        {
            Id = foobar.Id,
            Version = "$Latest",
        },
        AvailabilityZones = new[]
        {
            "us-east-1a",
        },
        DesiredCapacity = 1,
        MaxSize = 1,
        MinSize = 1,
    });

});
package main

import (
	"github.com/pulumi/pulumi-aws/sdk/v7/go/aws/autoscaling"
	"github.com/pulumi/pulumi-aws/sdk/v7/go/aws/ec2"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		foobar, err := ec2.NewLaunchTemplate(ctx, "foobar", &ec2.LaunchTemplateArgs{
			NamePrefix:   pulumi.String("foobar"),
			ImageId:      pulumi.String("ami-1a2b3c"),
			InstanceType: pulumi.String("t2.micro"),
		})
		if err != nil {
			return err
		}
		_, err = autoscaling.NewGroup(ctx, "bar", &autoscaling.GroupArgs{
			LaunchTemplate: &autoscaling.GroupLaunchTemplateArgs{
				Id:      foobar.ID().ToIDOutput().ToStringOutput(),
				Version: pulumi.String("$Latest"),
			},
			AvailabilityZones: pulumi.StringArray{
				pulumi.String("us-east-1a"),
			},
			DesiredCapacity: pulumi.Int(1),
			MaxSize:         pulumi.Int(1),
			MinSize:         pulumi.Int(1),
		})
		if err != nil {
			return err
		}
		return nil
	})
}
pulumi {
  required_providers {
    aws = {
      source = "pulumi/aws"
    }
  }
}

resource "aws_ec2_launchtemplate" "foobar" {
  name_prefix   = "foobar"
  image_id      = "ami-1a2b3c"
  instance_type = "t2.micro"
}
resource "aws_autoscaling_group" "bar" {
  launch_template = {
    id      = aws_ec2_launchtemplate.foobar.id
    version = "$Latest"
  }
  availability_zones = ["us-east-1a"]
  desired_capacity   = 1
  max_size           = 1
  min_size           = 1
}
package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.aws.ec2.LaunchTemplate;
import com.pulumi.aws.ec2.LaunchTemplateArgs;
import com.pulumi.aws.autoscaling.Group;
import com.pulumi.aws.autoscaling.GroupArgs;
import com.pulumi.aws.autoscaling.inputs.GroupLaunchTemplateArgs;
import java.util.ArrayList;
import java.util.Arrays;
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) {
        var foobar = new LaunchTemplate("foobar", LaunchTemplateArgs.builder()
            .namePrefix("foobar")
            .imageId("ami-1a2b3c")
            .instanceType("t2.micro")
            .build());

        var bar = new Group("bar", GroupArgs.builder()
            .launchTemplate(GroupLaunchTemplateArgs.builder()
                .id(foobar.id())
                .version("$Latest")
                .build())
            .availabilityZones("us-east-1a")
            .desiredCapacity(1)
            .maxSize(1)
            .minSize(1)
            .build());

    }
}
resources:
  foobar:
    type: aws:ec2:LaunchTemplate
    properties:
      namePrefix: foobar
      imageId: ami-1a2b3c
      instanceType: t2.micro
  bar:
    type: aws:autoscaling:Group
    properties:
      launchTemplate:
        id: ${foobar.id}
        version: $Latest
      availabilityZones:
        - us-east-1a
      desiredCapacity: 1
      maxSize: 1
      minSize: 1

Mixed Instances Policy

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

const example = new aws.ec2.LaunchTemplate("example", {
    namePrefix: "example",
    imageId: exampleAwsAmi.id,
    instanceType: "c5.large",
});
const exampleGroup = new aws.autoscaling.Group("example", {
    mixedInstancesPolicy: {
        launchTemplate: {
            launchTemplateSpecification: {
                launchTemplateId: example.id,
            },
            overrides: [
                {
                    instanceType: "c4.large",
                    weightedCapacity: "3",
                },
                {
                    instanceType: "c3.large",
                    weightedCapacity: "2",
                },
            ],
        },
    },
    availabilityZones: ["us-east-1a"],
    desiredCapacity: 1,
    maxSize: 1,
    minSize: 1,
});
import pulumi
import pulumi_aws as aws

example = aws.ec2.LaunchTemplate("example",
    name_prefix="example",
    image_id=example_aws_ami["id"],
    instance_type="c5.large")
example_group = aws.autoscaling.Group("example",
    mixed_instances_policy={
        "launch_template": {
            "launch_template_specification": {
                "launch_template_id": example.id,
            },
            "overrides": [
                {
                    "instance_type": "c4.large",
                    "weighted_capacity": "3",
                },
                {
                    "instance_type": "c3.large",
                    "weighted_capacity": "2",
                },
            ],
        },
    },
    availability_zones=["us-east-1a"],
    desired_capacity=1,
    max_size=1,
    min_size=1)
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Aws = Pulumi.Aws;

return await Deployment.RunAsync(() =>
{
    var example = new Aws.Ec2.LaunchTemplate("example", new()
    {
        NamePrefix = "example",
        ImageId = exampleAwsAmi.Id,
        InstanceType = "c5.large",
    });

    var exampleGroup = new Aws.AutoScaling.Group("example", new()
    {
        MixedInstancesPolicy = new Aws.AutoScaling.Inputs.GroupMixedInstancesPolicyArgs
        {
            LaunchTemplate = new Aws.AutoScaling.Inputs.GroupMixedInstancesPolicyLaunchTemplateArgs
            {
                LaunchTemplateSpecification = new Aws.AutoScaling.Inputs.GroupMixedInstancesPolicyLaunchTemplateLaunchTemplateSpecificationArgs
                {
                    LaunchTemplateId = example.Id,
                },
                Overrides = new[]
                {
                    new Aws.AutoScaling.Inputs.GroupMixedInstancesPolicyLaunchTemplateOverrideArgs
                    {
                        InstanceType = "c4.large",
                        WeightedCapacity = "3",
                    },
                    new Aws.AutoScaling.Inputs.GroupMixedInstancesPolicyLaunchTemplateOverrideArgs
                    {
                        InstanceType = "c3.large",
                        WeightedCapacity = "2",
                    },
                },
            },
        },
        AvailabilityZones = new[]
        {
            "us-east-1a",
        },
        DesiredCapacity = 1,
        MaxSize = 1,
        MinSize = 1,
    });

});
package main

import (
	"github.com/pulumi/pulumi-aws/sdk/v7/go/aws/autoscaling"
	"github.com/pulumi/pulumi-aws/sdk/v7/go/aws/ec2"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		example, err := ec2.NewLaunchTemplate(ctx, "example", &ec2.LaunchTemplateArgs{
			NamePrefix:   pulumi.String("example"),
			ImageId:      pulumi.Any(exampleAwsAmi.Id),
			InstanceType: pulumi.String("c5.large"),
		})
		if err != nil {
			return err
		}
		_, err = autoscaling.NewGroup(ctx, "example", &autoscaling.GroupArgs{
			MixedInstancesPolicy: &autoscaling.GroupMixedInstancesPolicyArgs{
				LaunchTemplate: &autoscaling.GroupMixedInstancesPolicyLaunchTemplateArgs{
					LaunchTemplateSpecification: &autoscaling.GroupMixedInstancesPolicyLaunchTemplateLaunchTemplateSpecificationArgs{
						LaunchTemplateId: example.ID().ToIDOutput().ToStringOutput(),
					},
					Overrides: autoscaling.GroupMixedInstancesPolicyLaunchTemplateOverrideArray{
						&autoscaling.GroupMixedInstancesPolicyLaunchTemplateOverrideArgs{
							InstanceType:     pulumi.String("c4.large"),
							WeightedCapacity: pulumi.String("3"),
						},
						&autoscaling.GroupMixedInstancesPolicyLaunchTemplateOverrideArgs{
							InstanceType:     pulumi.String("c3.large"),
							WeightedCapacity: pulumi.String("2"),
						},
					},
				},
			},
			AvailabilityZones: pulumi.StringArray{
				pulumi.String("us-east-1a"),
			},
			DesiredCapacity: pulumi.Int(1),
			MaxSize:         pulumi.Int(1),
			MinSize:         pulumi.Int(1),
		})
		if err != nil {
			return err
		}
		return nil
	})
}
pulumi {
  required_providers {
    aws = {
      source = "pulumi/aws"
    }
  }
}

resource "aws_ec2_launchtemplate" "example" {
  name_prefix   = "example"
  image_id      = exampleAwsAmi.id
  instance_type = "c5.large"
}
resource "aws_autoscaling_group" "example" {
  mixed_instances_policy = {
    launch_template = {
      launch_template_specification = {
        launch_template_id = aws_ec2_launchtemplate.example.id
      }
      overrides = [{
        "instanceType"     = "c4.large"
        "weightedCapacity" = "3"
        }, {
        "instanceType"     = "c3.large"
        "weightedCapacity" = "2"
      }]
    }
  }
  availability_zones = ["us-east-1a"]
  desired_capacity   = 1
  max_size           = 1
  min_size           = 1
}
package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.aws.ec2.LaunchTemplate;
import com.pulumi.aws.ec2.LaunchTemplateArgs;
import com.pulumi.aws.autoscaling.Group;
import com.pulumi.aws.autoscaling.GroupArgs;
import com.pulumi.aws.autoscaling.inputs.GroupMixedInstancesPolicyArgs;
import com.pulumi.aws.autoscaling.inputs.GroupMixedInstancesPolicyLaunchTemplateArgs;
import com.pulumi.aws.autoscaling.inputs.GroupMixedInstancesPolicyLaunchTemplateLaunchTemplateSpecificationArgs;
import com.pulumi.aws.autoscaling.inputs.GroupMixedInstancesPolicyLaunchTemplateOverrideArgs;
import java.util.ArrayList;
import java.util.Arrays;
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) {
        var example = new LaunchTemplate("example", LaunchTemplateArgs.builder()
            .namePrefix("example")
            .imageId(exampleAwsAmi.id())
            .instanceType("c5.large")
            .build());

        var exampleGroup = new Group("exampleGroup", GroupArgs.builder()
            .mixedInstancesPolicy(GroupMixedInstancesPolicyArgs.builder()
                .launchTemplate(GroupMixedInstancesPolicyLaunchTemplateArgs.builder()
                    .launchTemplateSpecification(GroupMixedInstancesPolicyLaunchTemplateLaunchTemplateSpecificationArgs.builder()
                        .launchTemplateId(example.id())
                        .build())
                    .overrides(
                        GroupMixedInstancesPolicyLaunchTemplateOverrideArgs.builder()
                            .instanceType("c4.large")
                            .weightedCapacity("3")
                            .build(),
                        GroupMixedInstancesPolicyLaunchTemplateOverrideArgs.builder()
                            .instanceType("c3.large")
                            .weightedCapacity("2")
                            .build())
                    .build())
                .build())
            .availabilityZones("us-east-1a")
            .desiredCapacity(1)
            .maxSize(1)
            .minSize(1)
            .build());

    }
}
resources:
  example:
    type: aws:ec2:LaunchTemplate
    properties:
      namePrefix: example
      imageId: ${exampleAwsAmi.id}
      instanceType: c5.large
  exampleGroup:
    type: aws:autoscaling:Group
    name: example
    properties:
      mixedInstancesPolicy:
        launchTemplate:
          launchTemplateSpecification:
            launchTemplateId: ${example.id}
          overrides:
            - instanceType: c4.large
              weightedCapacity: '3'
            - instanceType: c3.large
              weightedCapacity: '2'
      availabilityZones:
        - us-east-1a
      desiredCapacity: 1
      maxSize: 1
      minSize: 1

Mixed Instances Policy with Spot Instances and Capacity Rebalance

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

const example = new aws.ec2.LaunchTemplate("example", {
    namePrefix: "example",
    imageId: exampleAwsAmi.id,
    instanceType: "c5.large",
});
const exampleGroup = new aws.autoscaling.Group("example", {
    mixedInstancesPolicy: {
        instancesDistribution: {
            onDemandBaseCapacity: 0,
            onDemandPercentageAboveBaseCapacity: 25,
            spotAllocationStrategy: "capacity-optimized",
        },
        launchTemplate: {
            launchTemplateSpecification: {
                launchTemplateId: example.id,
            },
            overrides: [
                {
                    instanceType: "c4.large",
                    weightedCapacity: "3",
                },
                {
                    instanceType: "c3.large",
                    weightedCapacity: "2",
                },
            ],
        },
    },
    capacityRebalance: true,
    desiredCapacity: 12,
    maxSize: 15,
    minSize: 12,
    vpcZoneIdentifiers: [
        example1.id,
        example2.id,
    ],
});
import pulumi
import pulumi_aws as aws

example = aws.ec2.LaunchTemplate("example",
    name_prefix="example",
    image_id=example_aws_ami["id"],
    instance_type="c5.large")
example_group = aws.autoscaling.Group("example",
    mixed_instances_policy={
        "instances_distribution": {
            "on_demand_base_capacity": 0,
            "on_demand_percentage_above_base_capacity": 25,
            "spot_allocation_strategy": "capacity-optimized",
        },
        "launch_template": {
            "launch_template_specification": {
                "launch_template_id": example.id,
            },
            "overrides": [
                {
                    "instance_type": "c4.large",
                    "weighted_capacity": "3",
                },
                {
                    "instance_type": "c3.large",
                    "weighted_capacity": "2",
                },
            ],
        },
    },
    capacity_rebalance=True,
    desired_capacity=12,
    max_size=15,
    min_size=12,
    vpc_zone_identifiers=[
        example1["id"],
        example2["id"],
    ])
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Aws = Pulumi.Aws;

return await Deployment.RunAsync(() =>
{
    var example = new Aws.Ec2.LaunchTemplate("example", new()
    {
        NamePrefix = "example",
        ImageId = exampleAwsAmi.Id,
        InstanceType = "c5.large",
    });

    var exampleGroup = new Aws.AutoScaling.Group("example", new()
    {
        MixedInstancesPolicy = new Aws.AutoScaling.Inputs.GroupMixedInstancesPolicyArgs
        {
            InstancesDistribution = new Aws.AutoScaling.Inputs.GroupMixedInstancesPolicyInstancesDistributionArgs
            {
                OnDemandBaseCapacity = 0,
                OnDemandPercentageAboveBaseCapacity = 25,
                SpotAllocationStrategy = "capacity-optimized",
            },
            LaunchTemplate = new Aws.AutoScaling.Inputs.GroupMixedInstancesPolicyLaunchTemplateArgs
            {
                LaunchTemplateSpecification = new Aws.AutoScaling.Inputs.GroupMixedInstancesPolicyLaunchTemplateLaunchTemplateSpecificationArgs
                {
                    LaunchTemplateId = example.Id,
                },
                Overrides = new[]
                {
                    new Aws.AutoScaling.Inputs.GroupMixedInstancesPolicyLaunchTemplateOverrideArgs
                    {
                        InstanceType = "c4.large",
                        WeightedCapacity = "3",
                    },
                    new Aws.AutoScaling.Inputs.GroupMixedInstancesPolicyLaunchTemplateOverrideArgs
                    {
                        InstanceType = "c3.large",
                        WeightedCapacity = "2",
                    },
                },
            },
        },
        CapacityRebalance = true,
        DesiredCapacity = 12,
        MaxSize = 15,
        MinSize = 12,
        VpcZoneIdentifiers = new[]
        {
            example1.Id,
            example2.Id,
        },
    });

});
package main

import (
	"github.com/pulumi/pulumi-aws/sdk/v7/go/aws/autoscaling"
	"github.com/pulumi/pulumi-aws/sdk/v7/go/aws/ec2"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		example, err := ec2.NewLaunchTemplate(ctx, "example", &ec2.LaunchTemplateArgs{
			NamePrefix:   pulumi.String("example"),
			ImageId:      pulumi.Any(exampleAwsAmi.Id),
			InstanceType: pulumi.String("c5.large"),
		})
		if err != nil {
			return err
		}
		_, err = autoscaling.NewGroup(ctx, "example", &autoscaling.GroupArgs{
			MixedInstancesPolicy: &autoscaling.GroupMixedInstancesPolicyArgs{
				InstancesDistribution: &autoscaling.GroupMixedInstancesPolicyInstancesDistributionArgs{
					OnDemandBaseCapacity:                pulumi.Int(0),
					OnDemandPercentageAboveBaseCapacity: pulumi.Int(25),
					SpotAllocationStrategy:              pulumi.String("capacity-optimized"),
				},
				LaunchTemplate: &autoscaling.GroupMixedInstancesPolicyLaunchTemplateArgs{
					LaunchTemplateSpecification: &autoscaling.GroupMixedInstancesPolicyLaunchTemplateLaunchTemplateSpecificationArgs{
						LaunchTemplateId: example.ID().ToIDOutput().ToStringOutput(),
					},
					Overrides: autoscaling.GroupMixedInstancesPolicyLaunchTemplateOverrideArray{
						&autoscaling.GroupMixedInstancesPolicyLaunchTemplateOverrideArgs{
							InstanceType:     pulumi.String("c4.large"),
							WeightedCapacity: pulumi.String("3"),
						},
						&autoscaling.GroupMixedInstancesPolicyLaunchTemplateOverrideArgs{
							InstanceType:     pulumi.String("c3.large"),
							WeightedCapacity: pulumi.String("2"),
						},
					},
				},
			},
			CapacityRebalance: pulumi.Bool(true),
			DesiredCapacity:   pulumi.Int(12),
			MaxSize:           pulumi.Int(15),
			MinSize:           pulumi.Int(12),
			VpcZoneIdentifiers: pulumi.StringArray{
				example1.Id,
				example2.Id,
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}
pulumi {
  required_providers {
    aws = {
      source = "pulumi/aws"
    }
  }
}

resource "aws_ec2_launchtemplate" "example" {
  name_prefix   = "example"
  image_id      = exampleAwsAmi.id
  instance_type = "c5.large"
}
resource "aws_autoscaling_group" "example" {
  mixed_instances_policy = {
    instances_distribution = {
      on_demand_base_capacity                  = 0
      on_demand_percentage_above_base_capacity = 25
      spot_allocation_strategy                 = "capacity-optimized"
    }
    launch_template = {
      launch_template_specification = {
        launch_template_id = aws_ec2_launchtemplate.example.id
      }
      overrides = [{
        "instanceType"     = "c4.large"
        "weightedCapacity" = "3"
        }, {
        "instanceType"     = "c3.large"
        "weightedCapacity" = "2"
      }]
    }
  }
  capacity_rebalance   = true
  desired_capacity     = 12
  max_size             = 15
  min_size             = 12
  vpc_zone_identifiers = [example1.id, example2.id]
}
package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.aws.ec2.LaunchTemplate;
import com.pulumi.aws.ec2.LaunchTemplateArgs;
import com.pulumi.aws.autoscaling.Group;
import com.pulumi.aws.autoscaling.GroupArgs;
import com.pulumi.aws.autoscaling.inputs.GroupMixedInstancesPolicyArgs;
import com.pulumi.aws.autoscaling.inputs.GroupMixedInstancesPolicyInstancesDistributionArgs;
import com.pulumi.aws.autoscaling.inputs.GroupMixedInstancesPolicyLaunchTemplateArgs;
import com.pulumi.aws.autoscaling.inputs.GroupMixedInstancesPolicyLaunchTemplateLaunchTemplateSpecificationArgs;
import com.pulumi.aws.autoscaling.inputs.GroupMixedInstancesPolicyLaunchTemplateOverrideArgs;
import java.util.ArrayList;
import java.util.Arrays;
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) {
        var example = new LaunchTemplate("example", LaunchTemplateArgs.builder()
            .namePrefix("example")
            .imageId(exampleAwsAmi.id())
            .instanceType("c5.large")
            .build());

        var exampleGroup = new Group("exampleGroup", GroupArgs.builder()
            .mixedInstancesPolicy(GroupMixedInstancesPolicyArgs.builder()
                .instancesDistribution(GroupMixedInstancesPolicyInstancesDistributionArgs.builder()
                    .onDemandBaseCapacity(0)
                    .onDemandPercentageAboveBaseCapacity(25)
                    .spotAllocationStrategy("capacity-optimized")
                    .build())
                .launchTemplate(GroupMixedInstancesPolicyLaunchTemplateArgs.builder()
                    .launchTemplateSpecification(GroupMixedInstancesPolicyLaunchTemplateLaunchTemplateSpecificationArgs.builder()
                        .launchTemplateId(example.id())
                        .build())
                    .overrides(
                        GroupMixedInstancesPolicyLaunchTemplateOverrideArgs.builder()
                            .instanceType("c4.large")
                            .weightedCapacity("3")
                            .build(),
                        GroupMixedInstancesPolicyLaunchTemplateOverrideArgs.builder()
                            .instanceType("c3.large")
                            .weightedCapacity("2")
                            .build())
                    .build())
                .build())
            .capacityRebalance(true)
            .desiredCapacity(12)
            .maxSize(15)
            .minSize(12)
            .vpcZoneIdentifiers(
                example1.id(),
                example2.id())
            .build());

    }
}
resources:
  example:
    type: aws:ec2:LaunchTemplate
    properties:
      namePrefix: example
      imageId: ${exampleAwsAmi.id}
      instanceType: c5.large
  exampleGroup:
    type: aws:autoscaling:Group
    name: example
    properties:
      mixedInstancesPolicy:
        instancesDistribution:
          onDemandBaseCapacity: 0
          onDemandPercentageAboveBaseCapacity: 25
          spotAllocationStrategy: capacity-optimized
        launchTemplate:
          launchTemplateSpecification:
            launchTemplateId: ${example.id}
          overrides:
            - instanceType: c4.large
              weightedCapacity: '3'
            - instanceType: c3.large
              weightedCapacity: '2'
      capacityRebalance: true
      desiredCapacity: 12
      maxSize: 15
      minSize: 12
      vpcZoneIdentifiers:
        - ${example1.id}
        - ${example2.id}

Mixed Instances Policy with Instance level LaunchTemplateSpecification Overrides

When using a diverse instance set, some instance types might require a launch template with configuration values unique to that instance type such as a different AMI (Graviton2), architecture specific user data script, different EBS configuration, or different networking configuration.

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

const example = new aws.ec2.LaunchTemplate("example", {
    namePrefix: "example",
    imageId: exampleAwsAmi.id,
    instanceType: "c5.large",
});
const example2 = new aws.ec2.LaunchTemplate("example2", {
    namePrefix: "example2",
    imageId: example2AwsAmi.id,
});
const exampleGroup = new aws.autoscaling.Group("example", {
    mixedInstancesPolicy: {
        launchTemplate: {
            launchTemplateSpecification: {
                launchTemplateId: example.id,
            },
            overrides: [
                {
                    instanceType: "c4.large",
                    weightedCapacity: "3",
                },
                {
                    launchTemplateSpecification: {
                        launchTemplateId: example2.id,
                    },
                    instanceType: "c6g.large",
                    weightedCapacity: "2",
                },
            ],
        },
    },
    availabilityZones: ["us-east-1a"],
    desiredCapacity: 1,
    maxSize: 1,
    minSize: 1,
});
import pulumi
import pulumi_aws as aws

example = aws.ec2.LaunchTemplate("example",
    name_prefix="example",
    image_id=example_aws_ami["id"],
    instance_type="c5.large")
example2 = aws.ec2.LaunchTemplate("example2",
    name_prefix="example2",
    image_id=example2_aws_ami["id"])
example_group = aws.autoscaling.Group("example",
    mixed_instances_policy={
        "launch_template": {
            "launch_template_specification": {
                "launch_template_id": example.id,
            },
            "overrides": [
                {
                    "instance_type": "c4.large",
                    "weighted_capacity": "3",
                },
                {
                    "launch_template_specification": {
                        "launch_template_id": example2.id,
                    },
                    "instance_type": "c6g.large",
                    "weighted_capacity": "2",
                },
            ],
        },
    },
    availability_zones=["us-east-1a"],
    desired_capacity=1,
    max_size=1,
    min_size=1)
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Aws = Pulumi.Aws;

return await Deployment.RunAsync(() =>
{
    var example = new Aws.Ec2.LaunchTemplate("example", new()
    {
        NamePrefix = "example",
        ImageId = exampleAwsAmi.Id,
        InstanceType = "c5.large",
    });

    var example2 = new Aws.Ec2.LaunchTemplate("example2", new()
    {
        NamePrefix = "example2",
        ImageId = example2AwsAmi.Id,
    });

    var exampleGroup = new Aws.AutoScaling.Group("example", new()
    {
        MixedInstancesPolicy = new Aws.AutoScaling.Inputs.GroupMixedInstancesPolicyArgs
        {
            LaunchTemplate = new Aws.AutoScaling.Inputs.GroupMixedInstancesPolicyLaunchTemplateArgs
            {
                LaunchTemplateSpecification = new Aws.AutoScaling.Inputs.GroupMixedInstancesPolicyLaunchTemplateLaunchTemplateSpecificationArgs
                {
                    LaunchTemplateId = example.Id,
                },
                Overrides = new[]
                {
                    new Aws.AutoScaling.Inputs.GroupMixedInstancesPolicyLaunchTemplateOverrideArgs
                    {
                        InstanceType = "c4.large",
                        WeightedCapacity = "3",
                    },
                    new Aws.AutoScaling.Inputs.GroupMixedInstancesPolicyLaunchTemplateOverrideArgs
                    {
                        LaunchTemplateSpecification = new Aws.AutoScaling.Inputs.GroupMixedInstancesPolicyLaunchTemplateOverrideLaunchTemplateSpecificationArgs
                        {
                            LaunchTemplateId = example2.Id,
                        },
                        InstanceType = "c6g.large",
                        WeightedCapacity = "2",
                    },
                },
            },
        },
        AvailabilityZones = new[]
        {
            "us-east-1a",
        },
        DesiredCapacity = 1,
        MaxSize = 1,
        MinSize = 1,
    });

});
package main

import (
	"github.com/pulumi/pulumi-aws/sdk/v7/go/aws/autoscaling"
	"github.com/pulumi/pulumi-aws/sdk/v7/go/aws/ec2"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		example, err := ec2.NewLaunchTemplate(ctx, "example", &ec2.LaunchTemplateArgs{
			NamePrefix:   pulumi.String("example"),
			ImageId:      pulumi.Any(exampleAwsAmi.Id),
			InstanceType: pulumi.String("c5.large"),
		})
		if err != nil {
			return err
		}
		example2, err := ec2.NewLaunchTemplate(ctx, "example2", &ec2.LaunchTemplateArgs{
			NamePrefix: pulumi.String("example2"),
			ImageId:    pulumi.Any(example2AwsAmi.Id),
		})
		if err != nil {
			return err
		}
		_, err = autoscaling.NewGroup(ctx, "example", &autoscaling.GroupArgs{
			MixedInstancesPolicy: &autoscaling.GroupMixedInstancesPolicyArgs{
				LaunchTemplate: &autoscaling.GroupMixedInstancesPolicyLaunchTemplateArgs{
					LaunchTemplateSpecification: &autoscaling.GroupMixedInstancesPolicyLaunchTemplateLaunchTemplateSpecificationArgs{
						LaunchTemplateId: example.ID().ToIDOutput().ToStringOutput(),
					},
					Overrides: autoscaling.GroupMixedInstancesPolicyLaunchTemplateOverrideArray{
						&autoscaling.GroupMixedInstancesPolicyLaunchTemplateOverrideArgs{
							InstanceType:     pulumi.String("c4.large"),
							WeightedCapacity: pulumi.String("3"),
						},
						&autoscaling.GroupMixedInstancesPolicyLaunchTemplateOverrideArgs{
							LaunchTemplateSpecification: &autoscaling.GroupMixedInstancesPolicyLaunchTemplateOverrideLaunchTemplateSpecificationArgs{
								LaunchTemplateId: example2.ID().ToIDOutput().ToStringOutput(),
							},
							InstanceType:     pulumi.String("c6g.large"),
							WeightedCapacity: pulumi.String("2"),
						},
					},
				},
			},
			AvailabilityZones: pulumi.StringArray{
				pulumi.String("us-east-1a"),
			},
			DesiredCapacity: pulumi.Int(1),
			MaxSize:         pulumi.Int(1),
			MinSize:         pulumi.Int(1),
		})
		if err != nil {
			return err
		}
		return nil
	})
}
pulumi {
  required_providers {
    aws = {
      source = "pulumi/aws"
    }
  }
}

resource "aws_ec2_launchtemplate" "example" {
  name_prefix   = "example"
  image_id      = exampleAwsAmi.id
  instance_type = "c5.large"
}
resource "aws_ec2_launchtemplate" "example2" {
  name_prefix = "example2"
  image_id    = example2AwsAmi.id
}
resource "aws_autoscaling_group" "example" {
  mixed_instances_policy = {
    launch_template = {
      launch_template_specification = {
        launch_template_id = aws_ec2_launchtemplate.example.id
      }
      overrides = [{
        "instanceType"     = "c4.large"
        "weightedCapacity" = "3"
        }, {
        "launchTemplateSpecification" = {
          "launchTemplateId" = aws_ec2_launchtemplate.example2.id
        }
        "instanceType"     = "c6g.large"
        "weightedCapacity" = "2"
      }]
    }
  }
  availability_zones = ["us-east-1a"]
  desired_capacity   = 1
  max_size           = 1
  min_size           = 1
}
package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.aws.ec2.LaunchTemplate;
import com.pulumi.aws.ec2.LaunchTemplateArgs;
import com.pulumi.aws.autoscaling.Group;
import com.pulumi.aws.autoscaling.GroupArgs;
import com.pulumi.aws.autoscaling.inputs.GroupMixedInstancesPolicyArgs;
import com.pulumi.aws.autoscaling.inputs.GroupMixedInstancesPolicyLaunchTemplateArgs;
import com.pulumi.aws.autoscaling.inputs.GroupMixedInstancesPolicyLaunchTemplateLaunchTemplateSpecificationArgs;
import com.pulumi.aws.autoscaling.inputs.GroupMixedInstancesPolicyLaunchTemplateOverrideArgs;
import com.pulumi.aws.autoscaling.inputs.GroupMixedInstancesPolicyLaunchTemplateOverrideLaunchTemplateSpecificationArgs;
import java.util.ArrayList;
import java.util.Arrays;
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) {
        var example = new LaunchTemplate("example", LaunchTemplateArgs.builder()
            .namePrefix("example")
            .imageId(exampleAwsAmi.id())
            .instanceType("c5.large")
            .build());

        var example2 = new LaunchTemplate("example2", LaunchTemplateArgs.builder()
            .namePrefix("example2")
            .imageId(example2AwsAmi.id())
            .build());

        var exampleGroup = new Group("exampleGroup", GroupArgs.builder()
            .mixedInstancesPolicy(GroupMixedInstancesPolicyArgs.builder()
                .launchTemplate(GroupMixedInstancesPolicyLaunchTemplateArgs.builder()
                    .launchTemplateSpecification(GroupMixedInstancesPolicyLaunchTemplateLaunchTemplateSpecificationArgs.builder()
                        .launchTemplateId(example.id())
                        .build())
                    .overrides(
                        GroupMixedInstancesPolicyLaunchTemplateOverrideArgs.builder()
                            .instanceType("c4.large")
                            .weightedCapacity("3")
                            .build(),
                        GroupMixedInstancesPolicyLaunchTemplateOverrideArgs.builder()
                            .launchTemplateSpecification(GroupMixedInstancesPolicyLaunchTemplateOverrideLaunchTemplateSpecificationArgs.builder()
                                .launchTemplateId(example2.id())
                                .build())
                            .instanceType("c6g.large")
                            .weightedCapacity("2")
                            .build())
                    .build())
                .build())
            .availabilityZones("us-east-1a")
            .desiredCapacity(1)
            .maxSize(1)
            .minSize(1)
            .build());

    }
}
resources:
  example:
    type: aws:ec2:LaunchTemplate
    properties:
      namePrefix: example
      imageId: ${exampleAwsAmi.id}
      instanceType: c5.large
  example2:
    type: aws:ec2:LaunchTemplate
    properties:
      namePrefix: example2
      imageId: ${example2AwsAmi.id}
  exampleGroup:
    type: aws:autoscaling:Group
    name: example
    properties:
      mixedInstancesPolicy:
        launchTemplate:
          launchTemplateSpecification:
            launchTemplateId: ${example.id}
          overrides:
            - instanceType: c4.large
              weightedCapacity: '3'
            - launchTemplateSpecification:
                launchTemplateId: ${example2.id}
              instanceType: c6g.large
              weightedCapacity: '2'
      availabilityZones:
        - us-east-1a
      desiredCapacity: 1
      maxSize: 1
      minSize: 1

Mixed Instances Policy with Attribute-based Instance Type Selection

As an alternative to manually choosing instance types when creating a mixed instances group, you can specify a set of instance attributes that describe your compute requirements.

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

const example = new aws.ec2.LaunchTemplate("example", {
    namePrefix: "example",
    imageId: exampleAwsAmi.id,
    instanceType: "c5.large",
});
const exampleGroup = new aws.autoscaling.Group("example", {
    mixedInstancesPolicy: {
        launchTemplate: {
            launchTemplateSpecification: {
                launchTemplateId: example.id,
            },
            overrides: [{
                instanceRequirements: {
                    memoryMib: {
                        min: 1000,
                    },
                    vcpuCount: {
                        min: 4,
                    },
                },
            }],
        },
    },
    availabilityZones: ["us-east-1a"],
    desiredCapacity: 1,
    maxSize: 1,
    minSize: 1,
});
import pulumi
import pulumi_aws as aws

example = aws.ec2.LaunchTemplate("example",
    name_prefix="example",
    image_id=example_aws_ami["id"],
    instance_type="c5.large")
example_group = aws.autoscaling.Group("example",
    mixed_instances_policy={
        "launch_template": {
            "launch_template_specification": {
                "launch_template_id": example.id,
            },
            "overrides": [{
                "instance_requirements": {
                    "memory_mib": {
                        "min": 1000,
                    },
                    "vcpu_count": {
                        "min": 4,
                    },
                },
            }],
        },
    },
    availability_zones=["us-east-1a"],
    desired_capacity=1,
    max_size=1,
    min_size=1)
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Aws = Pulumi.Aws;

return await Deployment.RunAsync(() =>
{
    var example = new Aws.Ec2.LaunchTemplate("example", new()
    {
        NamePrefix = "example",
        ImageId = exampleAwsAmi.Id,
        InstanceType = "c5.large",
    });

    var exampleGroup = new Aws.AutoScaling.Group("example", new()
    {
        MixedInstancesPolicy = new Aws.AutoScaling.Inputs.GroupMixedInstancesPolicyArgs
        {
            LaunchTemplate = new Aws.AutoScaling.Inputs.GroupMixedInstancesPolicyLaunchTemplateArgs
            {
                LaunchTemplateSpecification = new Aws.AutoScaling.Inputs.GroupMixedInstancesPolicyLaunchTemplateLaunchTemplateSpecificationArgs
                {
                    LaunchTemplateId = example.Id,
                },
                Overrides = new[]
                {
                    new Aws.AutoScaling.Inputs.GroupMixedInstancesPolicyLaunchTemplateOverrideArgs
                    {
                        InstanceRequirements = new Aws.AutoScaling.Inputs.GroupMixedInstancesPolicyLaunchTemplateOverrideInstanceRequirementsArgs
                        {
                            MemoryMib = new Aws.AutoScaling.Inputs.GroupMixedInstancesPolicyLaunchTemplateOverrideInstanceRequirementsMemoryMibArgs
                            {
                                Min = 1000,
                            },
                            VcpuCount = new Aws.AutoScaling.Inputs.GroupMixedInstancesPolicyLaunchTemplateOverrideInstanceRequirementsVcpuCountArgs
                            {
                                Min = 4,
                            },
                        },
                    },
                },
            },
        },
        AvailabilityZones = new[]
        {
            "us-east-1a",
        },
        DesiredCapacity = 1,
        MaxSize = 1,
        MinSize = 1,
    });

});
package main

import (
	"github.com/pulumi/pulumi-aws/sdk/v7/go/aws/autoscaling"
	"github.com/pulumi/pulumi-aws/sdk/v7/go/aws/ec2"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		example, err := ec2.NewLaunchTemplate(ctx, "example", &ec2.LaunchTemplateArgs{
			NamePrefix:   pulumi.String("example"),
			ImageId:      pulumi.Any(exampleAwsAmi.Id),
			InstanceType: pulumi.String("c5.large"),
		})
		if err != nil {
			return err
		}
		_, err = autoscaling.NewGroup(ctx, "example", &autoscaling.GroupArgs{
			MixedInstancesPolicy: &autoscaling.GroupMixedInstancesPolicyArgs{
				LaunchTemplate: &autoscaling.GroupMixedInstancesPolicyLaunchTemplateArgs{
					LaunchTemplateSpecification: &autoscaling.GroupMixedInstancesPolicyLaunchTemplateLaunchTemplateSpecificationArgs{
						LaunchTemplateId: example.ID().ToIDOutput().ToStringOutput(),
					},
					Overrides: autoscaling.GroupMixedInstancesPolicyLaunchTemplateOverrideArray{
						&autoscaling.GroupMixedInstancesPolicyLaunchTemplateOverrideArgs{
							InstanceRequirements: &autoscaling.GroupMixedInstancesPolicyLaunchTemplateOverrideInstanceRequirementsArgs{
								MemoryMib: &autoscaling.GroupMixedInstancesPolicyLaunchTemplateOverrideInstanceRequirementsMemoryMibArgs{
									Min: pulumi.Int(1000),
								},
								VcpuCount: &autoscaling.GroupMixedInstancesPolicyLaunchTemplateOverrideInstanceRequirementsVcpuCountArgs{
									Min: pulumi.Int(4),
								},
							},
						},
					},
				},
			},
			AvailabilityZones: pulumi.StringArray{
				pulumi.String("us-east-1a"),
			},
			DesiredCapacity: pulumi.Int(1),
			MaxSize:         pulumi.Int(1),
			MinSize:         pulumi.Int(1),
		})
		if err != nil {
			return err
		}
		return nil
	})
}
pulumi {
  required_providers {
    aws = {
      source = "pulumi/aws"
    }
  }
}

resource "aws_ec2_launchtemplate" "example" {
  name_prefix   = "example"
  image_id      = exampleAwsAmi.id
  instance_type = "c5.large"
}
resource "aws_autoscaling_group" "example" {
  mixed_instances_policy = {
    launch_template = {
      launch_template_specification = {
        launch_template_id = aws_ec2_launchtemplate.example.id
      }
      overrides = [{
        "instanceRequirements" = {
          "memoryMib" = {
            "min" = 1000
          }
          "vcpuCount" = {
            "min" = 4
          }
        }
      }]
    }
  }
  availability_zones = ["us-east-1a"]
  desired_capacity   = 1
  max_size           = 1
  min_size           = 1
}
package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.aws.ec2.LaunchTemplate;
import com.pulumi.aws.ec2.LaunchTemplateArgs;
import com.pulumi.aws.autoscaling.Group;
import com.pulumi.aws.autoscaling.GroupArgs;
import com.pulumi.aws.autoscaling.inputs.GroupMixedInstancesPolicyArgs;
import com.pulumi.aws.autoscaling.inputs.GroupMixedInstancesPolicyLaunchTemplateArgs;
import com.pulumi.aws.autoscaling.inputs.GroupMixedInstancesPolicyLaunchTemplateLaunchTemplateSpecificationArgs;
import com.pulumi.aws.autoscaling.inputs.GroupMixedInstancesPolicyLaunchTemplateOverrideArgs;
import com.pulumi.aws.autoscaling.inputs.GroupMixedInstancesPolicyLaunchTemplateOverrideInstanceRequirementsArgs;
import com.pulumi.aws.autoscaling.inputs.GroupMixedInstancesPolicyLaunchTemplateOverrideInstanceRequirementsMemoryMibArgs;
import com.pulumi.aws.autoscaling.inputs.GroupMixedInstancesPolicyLaunchTemplateOverrideInstanceRequirementsVcpuCountArgs;
import java.util.ArrayList;
import java.util.Arrays;
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) {
        var example = new LaunchTemplate("example", LaunchTemplateArgs.builder()
            .namePrefix("example")
            .imageId(exampleAwsAmi.id())
            .instanceType("c5.large")
            .build());

        var exampleGroup = new Group("exampleGroup", GroupArgs.builder()
            .mixedInstancesPolicy(GroupMixedInstancesPolicyArgs.builder()
                .launchTemplate(GroupMixedInstancesPolicyLaunchTemplateArgs.builder()
                    .launchTemplateSpecification(GroupMixedInstancesPolicyLaunchTemplateLaunchTemplateSpecificationArgs.builder()
                        .launchTemplateId(example.id())
                        .build())
                    .overrides(GroupMixedInstancesPolicyLaunchTemplateOverrideArgs.builder()
                        .instanceRequirements(GroupMixedInstancesPolicyLaunchTemplateOverrideInstanceRequirementsArgs.builder()
                            .memoryMib(GroupMixedInstancesPolicyLaunchTemplateOverrideInstanceRequirementsMemoryMibArgs.builder()
                                .min(1000)
                                .build())
                            .vcpuCount(GroupMixedInstancesPolicyLaunchTemplateOverrideInstanceRequirementsVcpuCountArgs.builder()
                                .min(4)
                                .build())
                            .build())
                        .build())
                    .build())
                .build())
            .availabilityZones("us-east-1a")
            .desiredCapacity(1)
            .maxSize(1)
            .minSize(1)
            .build());

    }
}
resources:
  example:
    type: aws:ec2:LaunchTemplate
    properties:
      namePrefix: example
      imageId: ${exampleAwsAmi.id}
      instanceType: c5.large
  exampleGroup:
    type: aws:autoscaling:Group
    name: example
    properties:
      mixedInstancesPolicy:
        launchTemplate:
          launchTemplateSpecification:
            launchTemplateId: ${example.id}
          overrides:
            - instanceRequirements:
                memoryMib:
                  min: 1000
                vcpuCount:
                  min: 4
      availabilityZones:
        - us-east-1a
      desiredCapacity: 1
      maxSize: 1
      minSize: 1

Dynamic tagging

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

const config = new pulumi.Config();
const extraTags = config.getObject<any>("extraTags") || [
    {
        key: "Foo",
        propagateAtLaunch: true,
        value: "Bar",
    },
    {
        key: "Baz",
        propagateAtLaunch: true,
        value: "Bam",
    },
];
const test = new aws.autoscaling.Group("test", {
    tags: [
        {
            key: "explicit1",
            value: "value1",
            propagateAtLaunch: true,
        },
        {
            key: "explicit2",
            value: "value2",
            propagateAtLaunch: true,
        },
    ],
    name: "foobar3-test",
    maxSize: 5,
    minSize: 2,
    launchConfiguration: foobar.name,
    vpcZoneIdentifiers: [
        example1.id,
        example2.id,
    ],
});
import pulumi
import pulumi_aws as aws

config = pulumi.Config()
extra_tags = config.get_object("extraTags")
if extra_tags is None:
    extra_tags = [
        {
            "key": "Foo",
            "propagateAtLaunch": True,
            "value": "Bar",
        },
        {
            "key": "Baz",
            "propagateAtLaunch": True,
            "value": "Bam",
        },
    ]
test = aws.autoscaling.Group("test",
    tags=[
        {
            "key": "explicit1",
            "value": "value1",
            "propagate_at_launch": True,
        },
        {
            "key": "explicit2",
            "value": "value2",
            "propagate_at_launch": True,
        },
    ],
    name="foobar3-test",
    max_size=5,
    min_size=2,
    launch_configuration=foobar["name"],
    vpc_zone_identifiers=[
        example1["id"],
        example2["id"],
    ])
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Aws = Pulumi.Aws;

return await Deployment.RunAsync(() =>
{
    var config = new Config();
    var extraTags = config.GetObject<dynamic>("extraTags") ?? new[]
    {

        {
            { "key", "Foo" },
            { "propagateAtLaunch", true },
            { "value", "Bar" },
        },

        {
            { "key", "Baz" },
            { "propagateAtLaunch", true },
            { "value", "Bam" },
        },
    };
    var test = new Aws.AutoScaling.Group("test", new()
    {
        Tags = new[]
        {
            new Aws.AutoScaling.Inputs.GroupTagArgs
            {
                Key = "explicit1",
                Value = "value1",
                PropagateAtLaunch = true,
            },
            new Aws.AutoScaling.Inputs.GroupTagArgs
            {
                Key = "explicit2",
                Value = "value2",
                PropagateAtLaunch = true,
            },
        },
        Name = "foobar3-test",
        MaxSize = 5,
        MinSize = 2,
        LaunchConfiguration = foobar.Name,
        VpcZoneIdentifiers = new[]
        {
            example1.Id,
            example2.Id,
        },
    });

});
package main

import (
	"github.com/pulumi/pulumi-aws/sdk/v7/go/aws/autoscaling"
	"github.com/pulumi/pulumi-aws/sdk/v7/go/aws/ec2"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi/config"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		cfg := config.New(ctx, "")
		extraTags := []map[string]interface{}{
			map[string]interface{}{
				"key":               "Foo",
				"propagateAtLaunch": true,
				"value":             "Bar",
			},
			map[string]interface{}{
				"key":               "Baz",
				"propagateAtLaunch": true,
				"value":             "Bam",
			},
		}
		if param := cfg.GetObject("extraTags"); param != nil {
			extraTags = param
		}
		_, err := autoscaling.NewGroup(ctx, "test", &autoscaling.GroupArgs{
			Tags: autoscaling.GroupTagArray{
				&autoscaling.GroupTagArgs{
					Key:               pulumi.String("explicit1"),
					Value:             pulumi.String("value1"),
					PropagateAtLaunch: pulumi.Bool(true),
				},
				&autoscaling.GroupTagArgs{
					Key:               pulumi.String("explicit2"),
					Value:             pulumi.String("value2"),
					PropagateAtLaunch: pulumi.Bool(true),
				},
			},
			Name:                pulumi.String("foobar3-test"),
			MaxSize:             pulumi.Int(5),
			MinSize:             pulumi.Int(2),
			LaunchConfiguration: pulumi.Any(foobar.Name),
			VpcZoneIdentifiers: pulumi.StringArray{
				example1.Id,
				example2.Id,
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}
pulumi {
  required_providers {
    aws = {
      source = "pulumi/aws"
    }
  }
}

resource "aws_autoscaling_group" "test" {
  tags {
    key                 = "explicit1"
    value               = "value1"
    propagate_at_launch = true
  }
  tags {
    key                 = "explicit2"
    value               = "value2"
    propagate_at_launch = true
  }
  name                 = "foobar3-test"
  max_size             = 5
  min_size             = 2
  launch_configuration = foobar.name
  vpc_zone_identifiers = [example1.id, example2.id]
}
variable "extraTags" {
  default = [{
    "key"               = "Foo"
    "propagateAtLaunch" = true
    "value"             = "Bar"
    }, {
    "key"               = "Baz"
    "propagateAtLaunch" = true
    "value"             = "Bam"
  }]
}
package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.aws.autoscaling.Group;
import com.pulumi.aws.autoscaling.GroupArgs;
import com.pulumi.aws.autoscaling.inputs.GroupTagArgs;
import java.util.ArrayList;
import java.util.Arrays;
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) {
        final var config = ctx.config();
        final var extraTags = config.get("extraTags").orElse(Arrays.asList(
            Map.ofEntries(
                Map.entry("key", "Foo"),
                Map.entry("propagateAtLaunch", true),
                Map.entry("value", "Bar")
            ),
            Map.ofEntries(
                Map.entry("key", "Baz"),
                Map.entry("propagateAtLaunch", true),
                Map.entry("value", "Bam")
            )));
        var test = new Group("test", GroupArgs.builder()
            .tags(
                GroupTagArgs.builder()
                    .key("explicit1")
                    .value("value1")
                    .propagateAtLaunch(true)
                    .build(),
                GroupTagArgs.builder()
                    .key("explicit2")
                    .value("value2")
                    .propagateAtLaunch(true)
                    .build())
            .name("foobar3-test")
            .maxSize(5)
            .minSize(2)
            .launchConfiguration(foobar.name())
            .vpcZoneIdentifiers(
                example1.id(),
                example2.id())
            .build());

    }
}
configuration:
  extraTags:
    type: object
    default:
      - key: Foo
        propagateAtLaunch: true
        value: Bar
      - key: Baz
        propagateAtLaunch: true
        value: Bam
resources:
  test:
    type: aws:autoscaling:Group
    properties:
      tags:
        - key: explicit1
          value: value1
          propagateAtLaunch: true
        - key: explicit2
          value: value2
          propagateAtLaunch: true
      name: foobar3-test
      maxSize: 5
      minSize: 2
      launchConfiguration: ${foobar.name}
      vpcZoneIdentifiers:
        - ${example1.id}
        - ${example2.id}

Automatically refresh all instances after the group is updated

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

const example = aws.ec2.getAmi({
    filters: [{
        name: "name",
        values: ["amzn-ami-hvm-*-x86_64-gp2"],
    }],
    mostRecent: true,
    owners: ["amazon"],
});
const exampleLaunchTemplate = new aws.ec2.LaunchTemplate("example", {
    imageId: example.then(example => example.id),
    instanceType: "t3.nano",
});
const exampleGroup = new aws.autoscaling.Group("example", {
    launchTemplate: {
        id: exampleLaunchTemplate.id,
        version: exampleLaunchTemplate.latestVersion.apply(x =>String(x)),
    },
    instanceRefresh: {
        preferences: {
            minHealthyPercentage: 50,
        },
        strategy: "Rolling",
        triggers: ["tag"],
    },
    tags: [{
        key: "Key",
        value: "Value",
        propagateAtLaunch: true,
    }],
    availabilityZones: ["us-east-1a"],
    desiredCapacity: 1,
    maxSize: 2,
    minSize: 1,
});
import pulumi
import pulumi_aws as aws

example = aws.ec2.get_ami(filters=[{
        "name": "name",
        "values": ["amzn-ami-hvm-*-x86_64-gp2"],
    }],
    most_recent=True,
    owners=["amazon"])
example_launch_template = aws.ec2.LaunchTemplate("example",
    image_id=example.id,
    instance_type="t3.nano")
example_group = aws.autoscaling.Group("example",
    launch_template={
        "id": example_launch_template.id,
        "version": example_launch_template.latest_version.apply(lambda x: str(x)),
    },
    instance_refresh={
        "preferences": {
            "min_healthy_percentage": 50,
        },
        "strategy": "Rolling",
        "triggers": ["tag"],
    },
    tags=[{
        "key": "Key",
        "value": "Value",
        "propagate_at_launch": True,
    }],
    availability_zones=["us-east-1a"],
    desired_capacity=1,
    max_size=2,
    min_size=1)
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Aws = Pulumi.Aws;

return await Deployment.RunAsync(() =>
{
    var example = Aws.Ec2.GetAmi.Invoke(new()
    {
        Filters = new[]
        {
            new Aws.Ec2.Inputs.GetAmiFilterInputArgs
            {
                Name = "name",
                Values = new[]
                {
                    "amzn-ami-hvm-*-x86_64-gp2",
                },
            },
        },
        MostRecent = true,
        Owners = new[]
        {
            "amazon",
        },
    });

    var exampleLaunchTemplate = new Aws.Ec2.LaunchTemplate("example", new()
    {
        ImageId = example.Apply(getAmiResult => getAmiResult.Id),
        InstanceType = "t3.nano",
    });

    var exampleGroup = new Aws.AutoScaling.Group("example", new()
    {
        LaunchTemplate = new Aws.AutoScaling.Inputs.GroupLaunchTemplateArgs
        {
            Id = exampleLaunchTemplate.Id,
            Version = exampleLaunchTemplate.LatestVersion,
        },
        InstanceRefresh = new Aws.AutoScaling.Inputs.GroupInstanceRefreshArgs
        {
            Preferences = new Aws.AutoScaling.Inputs.GroupInstanceRefreshPreferencesArgs
            {
                MinHealthyPercentage = 50,
            },
            Strategy = "Rolling",
            Triggers = new[]
            {
                "tag",
            },
        },
        Tags = new[]
        {
            new Aws.AutoScaling.Inputs.GroupTagArgs
            {
                Key = "Key",
                Value = "Value",
                PropagateAtLaunch = true,
            },
        },
        AvailabilityZones = new[]
        {
            "us-east-1a",
        },
        DesiredCapacity = 1,
        MaxSize = 2,
        MinSize = 1,
    });

});
package main

import (
	"github.com/pulumi/pulumi-aws/sdk/v7/go/aws/autoscaling"
	"github.com/pulumi/pulumi-aws/sdk/v7/go/aws/ec2"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		example, err := ec2.LookupAmi(ctx, &ec2.LookupAmiArgs{
			Filters: []ec2.GetAmiFilter{
				{
					Name: "name",
					Values: []string{
						"amzn-ami-hvm-*-x86_64-gp2",
					},
				},
			},
			MostRecent: pulumi.BoolRef(true),
			Owners: []string{
				"amazon",
			},
		}, nil)
		if err != nil {
			return err
		}
		exampleLaunchTemplate, err := ec2.NewLaunchTemplate(ctx, "example", &ec2.LaunchTemplateArgs{
			ImageId:      pulumi.String(example.Id),
			InstanceType: pulumi.String("t3.nano"),
		})
		if err != nil {
			return err
		}
		_, err = autoscaling.NewGroup(ctx, "example", &autoscaling.GroupArgs{
			LaunchTemplate: &autoscaling.GroupLaunchTemplateArgs{
				Id:      exampleLaunchTemplate.ID().ToIDOutput().ToStringOutput(),
				Version: exampleLaunchTemplate.LatestVersion,
			},
			InstanceRefresh: &autoscaling.GroupInstanceRefreshArgs{
				Preferences: &autoscaling.GroupInstanceRefreshPreferencesArgs{
					MinHealthyPercentage: pulumi.Int(50),
				},
				Strategy: pulumi.String("Rolling"),
				Triggers: pulumi.StringArray{
					pulumi.String("tag"),
				},
			},
			Tags: autoscaling.GroupTagArray{
				&autoscaling.GroupTagArgs{
					Key:               pulumi.String("Key"),
					Value:             pulumi.String("Value"),
					PropagateAtLaunch: pulumi.Bool(true),
				},
			},
			AvailabilityZones: pulumi.StringArray{
				pulumi.String("us-east-1a"),
			},
			DesiredCapacity: pulumi.Int(1),
			MaxSize:         pulumi.Int(2),
			MinSize:         pulumi.Int(1),
		})
		if err != nil {
			return err
		}
		return nil
	})
}
pulumi {
  required_providers {
    aws = {
      source = "pulumi/aws"
    }
  }
}

data "aws_ec2_getami" "example" {
  filters {
    name   = "name"
    values = ["amzn-ami-hvm-*-x86_64-gp2"]
  }
  most_recent = true
  owners      = ["amazon"]
}

resource "aws_autoscaling_group" "example" {
  launch_template = {
    id      = aws_ec2_launchtemplate.example.id
    version = aws_ec2_launchtemplate.example.latest_version
  }
  instance_refresh = {
    preferences = {
      min_healthy_percentage = 50
    }
    strategy = "Rolling"
    triggers = ["tag"]
  }
  tags {
    key                 = "Key"
    value               = "Value"
    propagate_at_launch = true
  }
  availability_zones = ["us-east-1a"]
  desired_capacity   = 1
  max_size           = 2
  min_size           = 1
}
resource "aws_ec2_launchtemplate" "example" {
  image_id      = data.aws_ec2_getami.example.id
  instance_type = "t3.nano"
}
package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.aws.ec2.Ec2Functions;
import com.pulumi.aws.ec2.inputs.GetAmiArgs;
import com.pulumi.aws.ec2.inputs.GetAmiFilterArgs;
import com.pulumi.aws.ec2.LaunchTemplate;
import com.pulumi.aws.ec2.LaunchTemplateArgs;
import com.pulumi.aws.autoscaling.Group;
import com.pulumi.aws.autoscaling.GroupArgs;
import com.pulumi.aws.autoscaling.inputs.GroupLaunchTemplateArgs;
import com.pulumi.aws.autoscaling.inputs.GroupInstanceRefreshArgs;
import com.pulumi.aws.autoscaling.inputs.GroupInstanceRefreshPreferencesArgs;
import com.pulumi.aws.autoscaling.inputs.GroupTagArgs;
import java.util.ArrayList;
import java.util.Arrays;
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) {
        final var example = Ec2Functions.getAmi(GetAmiArgs.builder()
            .filters(GetAmiFilterArgs.builder()
                .name("name")
                .values("amzn-ami-hvm-*-x86_64-gp2")
                .build())
            .mostRecent(true)
            .owners("amazon")
            .build());

        var exampleLaunchTemplate = new LaunchTemplate("exampleLaunchTemplate", LaunchTemplateArgs.builder()
            .imageId(example.id())
            .instanceType("t3.nano")
            .build());

        var exampleGroup = new Group("exampleGroup", GroupArgs.builder()
            .launchTemplate(GroupLaunchTemplateArgs.builder()
                .id(exampleLaunchTemplate.id())
                .version(exampleLaunchTemplate.latestVersion())
                .build())
            .instanceRefresh(GroupInstanceRefreshArgs.builder()
                .preferences(GroupInstanceRefreshPreferencesArgs.builder()
                    .minHealthyPercentage(50)
                    .build())
                .strategy("Rolling")
                .triggers("tag")
                .build())
            .tags(GroupTagArgs.builder()
                .key("Key")
                .value("Value")
                .propagateAtLaunch(true)
                .build())
            .availabilityZones("us-east-1a")
            .desiredCapacity(1)
            .maxSize(2)
            .minSize(1)
            .build());

    }
}
resources:
  exampleGroup:
    type: aws:autoscaling:Group
    name: example
    properties:
      launchTemplate:
        id: ${exampleLaunchTemplate.id}
        version: ${exampleLaunchTemplate.latestVersion}
      instanceRefresh:
        preferences:
          minHealthyPercentage: 50
        strategy: Rolling
        triggers:
          - tag
      tags:
        - key: Key
          value: Value
          propagateAtLaunch: true
      availabilityZones:
        - us-east-1a
      desiredCapacity: 1
      maxSize: 2
      minSize: 1
  exampleLaunchTemplate:
    type: aws:ec2:LaunchTemplate
    name: example
    properties:
      imageId: ${example.id}
      instanceType: t3.nano
variables:
  example:
    fn::invoke:
      function: aws:ec2:getAmi
      arguments:
        filters:
          - name: name
            values:
              - amzn-ami-hvm-*-x86_64-gp2
        mostRecent: true
        owners:
          - amazon

Auto Scaling group with Warm Pool

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

const example = new aws.ec2.LaunchTemplate("example", {
    namePrefix: "example",
    imageId: exampleAwsAmi.id,
    instanceType: "c5.large",
});
const exampleGroup = new aws.autoscaling.Group("example", {
    warmPool: {
        instanceReusePolicy: {
            reuseOnScaleIn: true,
        },
        poolState: "Hibernated",
        minSize: 1,
        maxGroupPreparedCapacity: 10,
    },
    availabilityZones: ["us-east-1a"],
    desiredCapacity: 1,
    maxSize: 5,
    minSize: 1,
});
import pulumi
import pulumi_aws as aws

example = aws.ec2.LaunchTemplate("example",
    name_prefix="example",
    image_id=example_aws_ami["id"],
    instance_type="c5.large")
example_group = aws.autoscaling.Group("example",
    warm_pool={
        "instance_reuse_policy": {
            "reuse_on_scale_in": True,
        },
        "pool_state": "Hibernated",
        "min_size": 1,
        "max_group_prepared_capacity": 10,
    },
    availability_zones=["us-east-1a"],
    desired_capacity=1,
    max_size=5,
    min_size=1)
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Aws = Pulumi.Aws;

return await Deployment.RunAsync(() =>
{
    var example = new Aws.Ec2.LaunchTemplate("example", new()
    {
        NamePrefix = "example",
        ImageId = exampleAwsAmi.Id,
        InstanceType = "c5.large",
    });

    var exampleGroup = new Aws.AutoScaling.Group("example", new()
    {
        WarmPool = new Aws.AutoScaling.Inputs.GroupWarmPoolArgs
        {
            InstanceReusePolicy = new Aws.AutoScaling.Inputs.GroupWarmPoolInstanceReusePolicyArgs
            {
                ReuseOnScaleIn = true,
            },
            PoolState = "Hibernated",
            MinSize = 1,
            MaxGroupPreparedCapacity = 10,
        },
        AvailabilityZones = new[]
        {
            "us-east-1a",
        },
        DesiredCapacity = 1,
        MaxSize = 5,
        MinSize = 1,
    });

});
package main

import (
	"github.com/pulumi/pulumi-aws/sdk/v7/go/aws/autoscaling"
	"github.com/pulumi/pulumi-aws/sdk/v7/go/aws/ec2"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := ec2.NewLaunchTemplate(ctx, "example", &ec2.LaunchTemplateArgs{
			NamePrefix:   pulumi.String("example"),
			ImageId:      pulumi.Any(exampleAwsAmi.Id),
			InstanceType: pulumi.String("c5.large"),
		})
		if err != nil {
			return err
		}
		_, err = autoscaling.NewGroup(ctx, "example", &autoscaling.GroupArgs{
			WarmPool: &autoscaling.GroupWarmPoolArgs{
				InstanceReusePolicy: &autoscaling.GroupWarmPoolInstanceReusePolicyArgs{
					ReuseOnScaleIn: pulumi.Bool(true),
				},
				PoolState:                pulumi.String("Hibernated"),
				MinSize:                  pulumi.Int(1),
				MaxGroupPreparedCapacity: pulumi.Int(10),
			},
			AvailabilityZones: pulumi.StringArray{
				pulumi.String("us-east-1a"),
			},
			DesiredCapacity: pulumi.Int(1),
			MaxSize:         pulumi.Int(5),
			MinSize:         pulumi.Int(1),
		})
		if err != nil {
			return err
		}
		return nil
	})
}
pulumi {
  required_providers {
    aws = {
      source = "pulumi/aws"
    }
  }
}

resource "aws_ec2_launchtemplate" "example" {
  name_prefix   = "example"
  image_id      = exampleAwsAmi.id
  instance_type = "c5.large"
}
resource "aws_autoscaling_group" "example" {
  warm_pool = {
    instance_reuse_policy = {
      reuse_on_scale_in = true
    }
    pool_state                  = "Hibernated"
    min_size                    = 1
    max_group_prepared_capacity = 10
  }
  availability_zones = ["us-east-1a"]
  desired_capacity   = 1
  max_size           = 5
  min_size           = 1
}
package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.aws.ec2.LaunchTemplate;
import com.pulumi.aws.ec2.LaunchTemplateArgs;
import com.pulumi.aws.autoscaling.Group;
import com.pulumi.aws.autoscaling.GroupArgs;
import com.pulumi.aws.autoscaling.inputs.GroupWarmPoolArgs;
import com.pulumi.aws.autoscaling.inputs.GroupWarmPoolInstanceReusePolicyArgs;
import java.util.ArrayList;
import java.util.Arrays;
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) {
        var example = new LaunchTemplate("example", LaunchTemplateArgs.builder()
            .namePrefix("example")
            .imageId(exampleAwsAmi.id())
            .instanceType("c5.large")
            .build());

        var exampleGroup = new Group("exampleGroup", GroupArgs.builder()
            .warmPool(GroupWarmPoolArgs.builder()
                .instanceReusePolicy(GroupWarmPoolInstanceReusePolicyArgs.builder()
                    .reuseOnScaleIn(true)
                    .build())
                .poolState("Hibernated")
                .minSize(1)
                .maxGroupPreparedCapacity(10)
                .build())
            .availabilityZones("us-east-1a")
            .desiredCapacity(1)
            .maxSize(5)
            .minSize(1)
            .build());

    }
}
resources:
  example:
    type: aws:ec2:LaunchTemplate
    properties:
      namePrefix: example
      imageId: ${exampleAwsAmi.id}
      instanceType: c5.large
  exampleGroup:
    type: aws:autoscaling:Group
    name: example
    properties:
      warmPool:
        instanceReusePolicy:
          reuseOnScaleIn: true
        poolState: Hibernated
        minSize: 1
        maxGroupPreparedCapacity: 10
      availabilityZones:
        - us-east-1a
      desiredCapacity: 1
      maxSize: 5
      minSize: 1

Auto Scaling group with Traffic Sources

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

const test = new aws.autoscaling.Group("test", {
    trafficSources: testAwsVpclatticeTargetGroup.map(__item => __item).map(entry => ({
        identifier: entry.arn,
        type: "vpc-lattice",
    })),
    vpcZoneIdentifiers: testAwsSubnet.id,
    maxSize: 1,
    minSize: 1,
    forceDelete: true,
});
import pulumi
import pulumi_aws as aws

test = aws.autoscaling.Group("test",
    traffic_sources=[{
        "identifier": entry["arn"],
        "type": "vpc-lattice",
    } for entry in [__item for __item in test_aws_vpclattice_target_group]],
    vpc_zone_identifiers=test_aws_subnet["id"],
    max_size=1,
    min_size=1,
    force_delete=True)
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Aws = Pulumi.Aws;

return await Deployment.RunAsync(() =>
{
    var test = new Aws.AutoScaling.Group("test", new()
    {
        TrafficSources = testAwsVpclatticeTargetGroup.Select(__item => __item).ToList().Select(entry =>
        {
            return new Aws.AutoScaling.Inputs.GroupTrafficSourceArgs
            {
                Identifier = entry.Arn,
                Type = "vpc-lattice",
            };
        }).ToList(),
        VpcZoneIdentifiers = testAwsSubnet.Id,
        MaxSize = 1,
        MinSize = 1,
        ForceDelete = true,
    });

});
package main

import (
	"github.com/pulumi/pulumi-aws/sdk/v7/go/aws/autoscaling"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
pulumi.Run(func(ctx *pulumi.Context) error {
var forResult0 []map[string]interface{}
for _, entry := range %!v(PANIC=Format method: fatal: A failure has occurred: unlowered splat expression @ example.pp:1,34-65) {
forResult0 = append(forResult0, map[string]interface{}{
"identifier": entry.(map[string]interface{})["arn"],
"type": "vpc-lattice",
})
}
_, err := autoscaling.NewGroup(ctx, "test", &autoscaling.GroupArgs{
TrafficSources: toPulumiMapArray(forResult0),
VpcZoneIdentifiers: pulumi.Any(testAwsSubnet.Id),
MaxSize: pulumi.Int(1),
MinSize: pulumi.Int(1),
ForceDelete: pulumi.Bool(true),
})
if err != nil {
return err
}
return nil
})
}
func toPulumiMapArray(arr []Map) pulumi.MapArray {
var pulumiArr pulumi.MapArray
for _, v := range arr {
pulumiArr = append(pulumiArr, pulumi.Map(v))
}
return pulumiArr
}
pulumi {
  required_providers {
    aws = {
      source = "pulumi/aws"
    }
  }
}

resource "aws_autoscaling_group" "test" {
  dynamic "traffic_sources" {
    for_each = testAwsVpclatticeTargetGroup[*]
    content {
      identifier = traffic_sources.value.arn
      type       = "vpc-lattice"
    }
  }
  vpc_zone_identifiers = testAwsSubnet.id
  max_size             = 1
  min_size             = 1
  force_delete         = true
}

Import

Identity Schema

Required

  • name (String) Name of the Auto Scaling Group.

Optional

  • accountId (String) AWS Account where this resource is managed.
  • region (String) Region where this resource is managed.

Using pulumi import, import Auto Scaling Groups using the name. For example:

$ pulumi import aws:autoscaling/group:Group example example

Constructors

Group(String name, {GroupArgs? args, CustomResourceOptions? options})
Creates a new Group. name The Pulumi resource name. args Arguments used to configure this Group. The set of arguments for Group. options Resource options controlling this resource's behavior.
Group.reference(String urn)
Creates a typed reference to an existing Group resource.

Properties

arn ↔ Output<String>
ARN for this Auto Scaling Group
latefinal
availabilityZoneDistribution ↔ Output<GroupAvailabilityZoneDistribution>
The instance capacity distribution across Availability Zones. See availabilityZoneDistribution Block below for more details.
latefinal
availabilityZones ↔ Output<List<String>>
A list of Availability Zones where instances in the Auto Scaling group can be created. Used for launching into the default VPC subnet in each Availability Zone when not using the vpcZoneIdentifier attribute, or for attaching a network interface when an existing network interface ID is specified in a launch template. Conflicts with vpcZoneIdentifier.
latefinal
capacityRebalance ↔ Output<bool?>
Whether capacity rebalance is enabled. Otherwise, capacity rebalance is disabled.
latefinal
capacityReservationSpecification ↔ Output<GroupCapacityReservationSpecification>
The capacity reservation specification for the Auto Scaling group allows you to prioritize launching into On-Demand Capacity Reservations. See capacityReservationSpecification Block below for more details.
latefinal
childResources → Set<Resource>
finalinherited
completionSources ↔ Map<String, IOutputCompletionSource>
latefinalinherited
context ↔ Output<String?>
Reserved.
latefinal
defaultCooldown ↔ Output<int>
Amount of time, in seconds, after a scaling activity completes before another scaling activity can start.
latefinal
defaultInstanceWarmup ↔ Output<int?>
Amount of time, in seconds, until a newly launched instance can contribute to the Amazon CloudWatch metrics. This delay lets an instance finish initializing before Amazon EC2 Auto Scaling aggregates instance metrics, resulting in more reliable usage data. Set this value equal to the amount of time that it takes for resource consumption to become stable after an instance reaches the InService state. (See Set the default instance warmup for an Auto Scaling group)
latefinal
desiredCapacity ↔ Output<int>
Number of Amazon EC2 instances that should be running in the group. (See also Waiting for Capacity below.)
latefinal
desiredCapacityType ↔ Output<String?>
The unit of measurement for the value specified for desiredCapacity. Supported for attribute-based instance type selection only. Valid values: "units", "vcpu", "memory-mib".
latefinal
enabledMetrics ↔ Output<List<Metric>?>
List of metrics to collect. The allowed values are defined by the underlying AWS API.
latefinal
forceDelete ↔ Output<bool?>
Allows deleting the Auto Scaling Group without waiting for all instances in the pool to terminate. You can force an Auto Scaling Group to delete even if it's in the process of scaling a resource. Normally, this provider drains all the instances before deleting the group. This bypasses that behavior and potentially leaves resources dangling.
latefinal
forceDeleteWarmPool ↔ Output<bool?>
Allows deleting the Auto Scaling Group without waiting for all instances in the warm pool to terminate.
latefinal
hashCode → int
The hash code for this object.
no setterinherited
healthCheckGracePeriod ↔ Output<int?>
Time (in seconds) after instance comes into service before checking health.
latefinal
healthCheckType ↔ Output<String>
"EC2" or "ELB". Controls how health checking is done.
latefinal
id ↔ Output<String>
getter/setter pairinherited
ignoreFailedScalingActivities ↔ Output<bool?>
Whether to ignore failed Auto Scaling scaling activities while waiting for capacity. The default is false -- failed scaling activities cause errors to be returned.
latefinal
initialLifecycleHooks ↔ Output<List<GroupInitialLifecycleHook>?>
One or more Lifecycle Hooks to attach to the Auto Scaling Group before instances are launched. The syntax is exactly the same as the separate aws.autoscaling.LifecycleHook resource, without the autoscalingGroupName attribute. Please note that this will only work when creating a new Auto Scaling Group. For all other use-cases, please use aws.autoscaling.LifecycleHook resource.
latefinal
instanceLifecyclePolicy ↔ Output<GroupInstanceLifecyclePolicy>
If this block is configured, adds an instance lifecycle policy to the specified Auto Scaling Group. Defined below.
latefinal
instanceMaintenancePolicy ↔ Output<GroupInstanceMaintenancePolicy?>
If this block is configured, add a instance maintenance policy to the specified Auto Scaling group. Defined below.
latefinal
instanceRefresh ↔ Output<GroupInstanceRefresh?>
If this block is configured, start an Instance Refresh when this Auto Scaling Group is updated. Defined below.
latefinal
isCustom → bool
Returns whether this resource is provider-managed.
no setterinherited
isProtected → bool
Returns whether this resource is protected from deletion.
no setterinherited
isRemote → bool
Whether this resource is registered as remote.
no setterinherited
isResourceReference → bool
Whether this instance represents a resource value returned over RPC.
finalinherited
launchConfiguration ↔ Output<String?>
Name of the launch configuration to use.
latefinal
launchTemplate ↔ Output<GroupLaunchTemplate>
Nested argument with Launch template specification to use to launch instances. See launchTemplate Block below for more details.
latefinal
loadBalancers ↔ Output<List<String>>
List of elastic load balancer names to add to the autoscaling group names. Only valid for classic load balancers. For ALBs, use targetGroupArns instead. To remove all load balancer attachments an empty list should be specified.
latefinal
maxInstanceLifetime ↔ Output<int?>
Maximum amount of time, in seconds, that an instance can be in service, values must be either equal to 0 or between 86400 and 31536000 seconds.
latefinal
maxSize ↔ Output<int>
Maximum size of the Auto Scaling Group.
latefinal
metricsGranularity ↔ Output<String?>
Granularity to associate with the metrics to collect. The only valid value is 1Minute. Default is 1Minute.
latefinal
minElbCapacity ↔ Output<int?>
Setting this causes Pulumi to wait for this number of instances from this Auto Scaling Group to show up healthy in the ELB only on creation. Updates will not wait on ELB instance number changes. (See also Waiting for Capacity below.)
latefinal
minSize ↔ Output<int>
Minimum size of the Auto Scaling Group. (See also Waiting for Capacity below.)
latefinal
mixedInstancesPolicy ↔ Output<GroupMixedInstancesPolicy>
Configuration block containing settings to define launch targets for Auto Scaling groups. See mixedInstancesPolicy Block below for more details.
latefinal
name ↔ Output<String>
Name of the Auto Scaling Group. By default generated by Pulumi. Conflicts with namePrefix.
latefinal
namePrefix ↔ Output<String>
Creates a unique name beginning with the specified prefix. Conflicts with name.
latefinal
placementGroup ↔ Output<String?>
Name of the placement group into which you'll launch your instances, if any.
latefinal
predictedCapacity ↔ Output<int>
Predicted capacity of the group.
latefinal
protectFromScaleIn ↔ Output<bool?>
Whether newly launched instances are automatically protected from termination by Amazon EC2 Auto Scaling when scaling in. For more information about preventing instances from terminating on scale in, see Using instance scale-in protection in the Amazon EC2 Auto Scaling User Guide.
latefinal
region ↔ Output<String>
Region where this resource will be managed. Defaults to the Region set in the provider configuration.
latefinal
resourceTransforms → List<ResourceTransform>
Inherited/explicit async transforms.
no setterinherited
runtimeType → Type
A representation of the runtime type of the object.
no setterinherited
serviceLinkedRoleArn ↔ Output<String>
ARN of the service-linked role that the ASG will use to call other AWS services
latefinal
suspendedProcesses ↔ Output<List<String>?>
List of processes to suspend for the Auto Scaling Group. The allowed values are Launch, Terminate, HealthCheck, ReplaceUnhealthy, AZRebalance, AlarmNotification, ScheduledActions, AddToLoadBalancer, InstanceRefresh. Note that if you suspend either the Launch or Terminate process types, it can prevent your Auto Scaling Group from functioning properly.
latefinal
tags ↔ Output<List<GroupTag>?>
Configuration block(s) containing resource tags. See tag Block below for more details.
latefinal
targetGroupArns ↔ Output<List<String>>
Set of aws.lb.TargetGroup ARNs, for use with Application or Network Load Balancing. To remove all target group attachments an empty list should be specified.
latefinal
terminationPolicies ↔ Output<List<String>?>
List of policies to decide how the instances in the Auto Scaling Group should be terminated. The allowed values are OldestInstance, NewestInstance, OldestLaunchConfiguration, ClosestToNextInstanceHour, OldestLaunchTemplate, AllocationStrategy, Default. Additionally, the ARN of a Lambda function can be specified for custom termination policies.
latefinal
trafficSources ↔ Output<List<GroupTrafficSource>>
Attaches one or more traffic sources to the specified Auto Scaling group.
latefinal
transformations → List<ResourceTransformation>
Inherited/explicit legacy transformations.
no setterinherited
urn ↔ Output<String>
latefinalinherited
vpcZoneIdentifiers ↔ Output<List<String>>
List of subnet IDs to launch resources in. Subnets automatically determine which availability zones the group will reside. Conflicts with availabilityZones.
latefinal
waitForCapacityTimeout ↔ Output<String?>
Maximum duration that the provider should wait for ASG instances to be healthy before timing out. (See also Waiting for Capacity below.) Setting this to "0" causes the provider to skip all Capacity Waiting behavior.
latefinal
waitForElbCapacity ↔ Output<int?>
Setting this will cause Pulumi to wait for exactly this number of healthy instances from this Auto Scaling Group in all attached load balancers on both create and update operations. (Takes precedence over minElbCapacity behavior.) (See also Waiting for Capacity below.)
latefinal
warmPool ↔ Output<GroupWarmPool?>
If this block is configured, add a Warm Pool to the specified Auto Scaling group. Defined below
latefinal
warmPoolSize ↔ Output<int>
Current size of the warm pool.
latefinal

Methods

failId(Object error) → void
Completes this resource ID with an error when registration fails.
inherited
failOutputs(Object error) → void
Completes all output properties with error.
inherited
failUrn(Object error) → void
Completes this resource URN with an error when registration fails.
inherited
getProvider(String moduleMember) → ProviderResource?
Returns provider for moduleMember's package, if configured.
inherited
getResourceName() → String
Returns this resource's logical name.
inherited
getResourceType() → String
Returns this resource's Pulumi type token.
inherited
noSuchMethod(Invocation invocation) → dynamic
Invoked when a nonexistent method or property is accessed.
inherited
registerOutput<T>(String propertyName, {Object? decoder(Object?)?, bool isSecret = false}) → Output<T>
Registers a dynamic output property for this resource.
inherited
resolveId(String? value, {required bool isKnown}) → void
Resolves the provider-assigned ID for this resource.
inherited
resolveOutputs(Struct outputs) → void
Resolves all output properties from a monitor response payload.
inherited
resolveUrn(String value) → void
Resolves this resource's URN once assigned by the engine.
inherited
serializeProperties(Map<String, dynamic> properties) → Future<Struct>
Serializes resource properties for RPC transmission.
inherited
toString() → String
A string representation of this object.
inherited

Operators

operator ==(Object other) → bool
The equality operator.
inherited

Static Methods

get(String name, Input<String> id, {GroupState? state, CustomResourceOptions? options}) → Group
Gets an existing Group resource's state with the given name and id.