Namespace Amazon.CDK.AWS.AutoScaling
Amazon EC2 Auto Scaling Construct Library
This module is part of the AWS Cloud Development Kit project.
Auto Scaling Group
An AutoScalingGroup represents a number of instances on which you run your code. You
pick the size of the fleet, the instance type and the OS image:
Vpc vpc;
new AutoScalingGroup(this, "ASG", new AutoScalingGroupProps {
Vpc = vpc,
InstanceType = InstanceType.Of(InstanceClass.BURSTABLE2, InstanceSize.MICRO),
// The latest Amazon Linux 2 image
MachineImage = MachineImage.LatestAmazonLinux2()
});Creating an AutoScalingGroup from a Launch Configuration has been deprecated. All new accounts created after December 31, 2023 will no longer be able to create Launch Configurations. With the @aws-cdk/aws-autoscaling:generateLaunchTemplateInsteadOfLaunchConfig feature flag set to true, AutoScalingGroup properties used to create a Launch Configuration will now be used to create a LaunchTemplate using a Launch Configuration to LaunchTemplate mapping. Specifically, the following AutoScalingGroup properties will be used to generate a LaunchTemplate:
After the Launch Configuration is replaced with a LaunchTemplate, any new instances launched by the AutoScalingGroup will use the new LaunchTemplate. Existing instances are not affected. To update an existing instance, you can allow the AutoScalingGroup to gradually replace existing instances with new instances based on the terminationPolicies for the AutoScalingGroup. Alternatively, you can terminate them yourself and force the AutoScalingGroup to launch new instances to maintain the desiredCapacity.
Support for creating an AutoScalingGroup from a LaunchTemplate was added in CDK version 2.21.0. Users on a CDK version earlier than version 2.21.0 that need to create an AutoScalingGroup with an account created after December 31, 2023 must update their CDK version to 2.21.0 or later. Users on CDK versions 2.21.0 up to, but not including 2.86.0, must use a manually created LaunchTemplate to create an AutoScalingGroup for accounts created after December 31, 2023. CDK version 2.86.0 or later will automatically generate a LaunchTemplate using the AutoScalingGroup properties mentioned above.
For additional migration information, please see: Migrating to a LaunchTemplate from a Launch Configuration
NOTE: AutoScalingGroup has a property called allowAllOutbound (allowing the instances to contact the
internet) which is set to true by default. Be sure to set this to false if you don't want
your instances to be able to start arbitrary connections. Alternatively, you can specify an existing security
group to attach to the instances that are launched, rather than have the group create a new one.
Vpc vpc;
var mySecurityGroup = new SecurityGroup(this, "SecurityGroup", new SecurityGroupProps { Vpc = vpc });
new AutoScalingGroup(this, "ASG", new AutoScalingGroupProps {
Vpc = vpc,
InstanceType = InstanceType.Of(InstanceClass.BURSTABLE2, InstanceSize.MICRO),
MachineImage = MachineImage.LatestAmazonLinux2(),
SecurityGroup = mySecurityGroup
});Alternatively, to enable more advanced features, you can create an AutoScalingGroup from a supplied LaunchTemplate:
Vpc vpc;
LaunchTemplate launchTemplate;
new AutoScalingGroup(this, "ASG", new AutoScalingGroupProps {
Vpc = vpc,
LaunchTemplate = launchTemplate
});To launch a mixture of Spot and on-demand instances, and/or with multiple instance types, you can create an AutoScalingGroup from a MixedInstancesPolicy:
Vpc vpc;
LaunchTemplate launchTemplate1;
LaunchTemplate launchTemplate2;
new AutoScalingGroup(this, "ASG", new AutoScalingGroupProps {
Vpc = vpc,
MixedInstancesPolicy = new MixedInstancesPolicy {
InstancesDistribution = new InstancesDistribution {
OnDemandPercentageAboveBaseCapacity = 50
},
LaunchTemplate = launchTemplate1,
LaunchTemplateOverrides = new [] { new LaunchTemplateOverrides { InstanceType = new InstanceType("t3.micro") }, new LaunchTemplateOverrides { InstanceType = new InstanceType("t3a.micro") }, new LaunchTemplateOverrides { InstanceType = new InstanceType("t4g.micro"), LaunchTemplate = launchTemplate2 } }
}
});You can specify instances requirements with the instanceRequirements property:
Vpc vpc;
LaunchTemplate launchTemplate1;
new AutoScalingGroup(this, "ASG", new AutoScalingGroupProps {
Vpc = vpc,
MixedInstancesPolicy = new MixedInstancesPolicy {
LaunchTemplate = launchTemplate1,
LaunchTemplateOverrides = new [] { new LaunchTemplateOverrides {
InstanceRequirements = new InstanceRequirementsProperty {
VCpuCount = new VCpuCountRequestProperty { Min = 4, Max = 8 },
MemoryMiB = new MemoryMiBRequestProperty { Min = 16384 },
CpuManufacturers = new [] { "intel" }
}
} }
}
});Machine Images (AMIs)
AMIs control the OS that gets launched when you start your EC2 instance. The EC2 library contains constructs to select the AMI you want to use.
Depending on the type of AMI, you select it a different way.
The latest version of Amazon Linux and Microsoft Windows images are selectable by instantiating one of these classes:
// Pick a Windows edition to use
var windows = new WindowsImage(WindowsVersion.WINDOWS_SERVER_2019_ENGLISH_FULL_BASE);
// Pick the right Amazon Linux edition. All arguments shown are optional
// and will default to these values when omitted.
var amznLinux = new AmazonLinuxImage(new AmazonLinuxImageProps {
Generation = AmazonLinuxGeneration.AMAZON_LINUX,
Edition = AmazonLinuxEdition.STANDARD,
Virtualization = AmazonLinuxVirt.HVM,
Storage = AmazonLinuxStorage.GENERAL_PURPOSE
});
// For other custom (Linux) images, instantiate a `GenericLinuxImage` with
// a map giving the AMI to in for each region:
var linux = new GenericLinuxImage(new Dictionary<string, string> {
{ "us-east-1", "ami-97785bed" },
{ "eu-west-1", "ami-12345678" }
});NOTE: The Amazon Linux images selected will be cached in your <code>cdk.json</code>, so that your
AutoScalingGroups don't automatically change out from under you when you're making unrelated
changes. To update to the latest version of Amazon Linux, remove the cache entry from the <code>context</code>
section of your <code>cdk.json</code>.
We will add command-line options to make this step easier in the future.
AutoScaling Instance Counts
AutoScalingGroups make it possible to raise and lower the number of instances in the group, in response to (or in advance of) changes in workload.
When you create your AutoScalingGroup, you specify a minCapacity and a
maxCapacity. AutoScaling policies that respond to metrics will never go higher
or lower than the indicated capacity (but scheduled scaling actions might, see
below).
There are three ways to scale your capacity:
The general pattern of autoscaling will look like this:
Vpc vpc;
InstanceType instanceType;
IMachineImage machineImage;
var autoScalingGroup = new AutoScalingGroup(this, "ASG", new AutoScalingGroupProps {
Vpc = vpc,
InstanceType = instanceType,
MachineImage = machineImage,
MinCapacity = 5,
MaxCapacity = 100
});Step Scaling
This type of scaling scales in and out in deterministics steps that you configure, in response to metric values. For example, your scaling strategy to scale in response to a metric that represents your average worker pool usage might look like this:
Scaling -1 (no change) +1 +3
│ │ │ │ │
├────────┼───────────────────────┼────────┼────────┤
│ │ │ │ │
Worker use 0% 10% 50% 70% 100%(Note that this is not necessarily a recommended scaling strategy, but it's a possible one. You will have to determine what thresholds are right for you).
Note that in order to set up this scaling strategy, you will have to emit a metric representing your worker utilization from your instances. After that, you would configure the scaling something like this:
AutoScalingGroup autoScalingGroup;
var workerUtilizationMetric = new Metric(new MetricProps {
Namespace = "MyService",
MetricName = "WorkerUtilization"
});
autoScalingGroup.ScaleOnMetric("ScaleToCPU", new BasicStepScalingPolicyProps {
Metric = workerUtilizationMetric,
ScalingSteps = new [] { new ScalingInterval { Upper = 10, Change = -1 }, new ScalingInterval { Lower = 50, Change = +1 }, new ScalingInterval { Lower = 70, Change = +3 } },
EvaluationPeriods = 10,
DatapointsToAlarm = 5,
// Change this to AdjustmentType.PERCENT_CHANGE_IN_CAPACITY to interpret the
// 'change' numbers before as percentages instead of capacity counts.
AdjustmentType = AdjustmentType.CHANGE_IN_CAPACITY
});The AutoScaling construct library will create the required CloudWatch alarms and AutoScaling policies for you.
Target Tracking Scaling
This type of scaling scales in and out in order to keep a metric around a value you prefer. There are four types of predefined metrics you can track, or you can choose to track a custom metric. If you do choose to track a custom metric, be aware that the metric has to represent instance utilization in some way (AutoScaling will scale out if the metric is higher than the target, and scale in if the metric is lower than the target).
If you configure multiple target tracking policies, AutoScaling will use the one that yields the highest capacity.
The following example scales to keep the CPU usage of your instances around 50% utilization:
AutoScalingGroup autoScalingGroup;
autoScalingGroup.ScaleOnCpuUtilization("KeepSpareCPU", new CpuUtilizationScalingProps {
TargetUtilizationPercent = 50
});To scale on average network traffic in and out of your instances:
AutoScalingGroup autoScalingGroup;
autoScalingGroup.ScaleOnIncomingBytes("LimitIngressPerInstance", new NetworkUtilizationScalingProps {
TargetBytesPerSecond = 10 * 1024 * 1024
});
autoScalingGroup.ScaleOnOutgoingBytes("LimitEgressPerInstance", new NetworkUtilizationScalingProps {
TargetBytesPerSecond = 10 * 1024 * 1024
});To scale on the average request count per instance (only works for AutoScalingGroups that have been attached to Application Load Balancers):
AutoScalingGroup autoScalingGroup;
autoScalingGroup.ScaleOnRequestCount("LimitRPS", new RequestCountScalingProps {
TargetRequestsPerSecond = 1000
});Scheduled Scaling
This type of scaling is used to change capacities based on time. It works by
changing minCapacity, maxCapacity and desiredCapacity of the
AutoScalingGroup, and so can be used for two purposes:
A schedule is expressed as a cron expression. The Schedule class has a cron method to help build cron expressions.
The following example scales the fleet out in the morning, going back to natural scaling (all the way down to 1 instance if necessary) at night:
AutoScalingGroup autoScalingGroup;
autoScalingGroup.ScaleOnSchedule("PrescaleInTheMorning", new BasicScheduledActionProps {
Schedule = Schedule.Cron(new CronOptions { Hour = "8", Minute = "0" }),
MinCapacity = 20
});
autoScalingGroup.ScaleOnSchedule("AllowDownscalingAtNight", new BasicScheduledActionProps {
Schedule = Schedule.Cron(new CronOptions { Hour = "20", Minute = "0" }),
MinCapacity = 1
});Instance Maintenance Policy
You can configure an instance maintenance policy for your Auto Scaling group to meet specific capacity requirements during events that cause instances to be replaced, such as an instance refresh or the health check process.
For example, suppose you have an Auto Scaling group that has a small number of instances. You want to avoid the potential disruptions from terminating and then replacing an instance when health checks indicate an impaired instance. With an instance maintenance policy, you can make sure that Amazon EC2 Auto Scaling first launches a new instance and then waits for it to be fully ready before terminating the unhealthy instance.
An instance maintenance policy also helps you minimize any potential disruptions in cases where
multiple instances are replaced at the same time. You set the minHealthyPercentage
and the maxHealthyPercentage for the policy, and your Auto Scaling group can only
increase and decrease capacity within that minimum-maximum range when replacing instances.
A larger range increases the number of instances that can be replaced at the same time.
Vpc vpc;
new AutoScalingGroup(this, "ASG", new AutoScalingGroupProps {
Vpc = vpc,
InstanceType = InstanceType.Of(InstanceClass.BURSTABLE2, InstanceSize.MICRO),
MachineImage = MachineImage.LatestAmazonLinux2(),
MaxHealthyPercentage = 200,
MinHealthyPercentage = 100
});Visit <a href="https://docs.aws.amazon.com/autoscaling/ec2/userguide/ec2-auto-scaling-instance-maintenance-policy.html">Instance maintenance policies</a> for more details.
Block Devices
This type specifies how block devices are exposed to the instance. You can specify virtual devices and EBS volumes.
GP3 Volumes
You can only specify the throughput on GP3 volumes.
Vpc vpc;
InstanceType instanceType;
IMachineImage machineImage;
var autoScalingGroup = new AutoScalingGroup(this, "ASG", new AutoScalingGroupProps {
Vpc = vpc,
InstanceType = instanceType,
MachineImage = machineImage,
BlockDevices = new [] { new BlockDevice {
DeviceName = "gp3-volume",
Volume = BlockDeviceVolume.Ebs(15, new EbsDeviceOptions {
VolumeType = EbsDeviceVolumeType.GP3,
Throughput = 125
})
} }
});Configuring Instances using CloudFormation Init
It is possible to use the CloudFormation Init mechanism to configure the
instances in the AutoScalingGroup. You can write files to it, run commands,
start services, etc. See the documentation of
AWS::CloudFormation::Init
and the documentation of CDK's aws-ec2 library for more information.
When you specify a CloudFormation Init configuration for an AutoScalingGroup:
Here's an example of using CloudFormation Init to write a file to the instance hosts on startup:
Vpc vpc;
InstanceType instanceType;
IMachineImage machineImage;
new AutoScalingGroup(this, "ASG", new AutoScalingGroupProps {
Vpc = vpc,
InstanceType = instanceType,
MachineImage = machineImage,
// ...
Init = CloudFormationInit.FromElements(InitFile.FromString("/etc/my_instance", "This got written during instance startup")),
Signals = Signals.WaitForAll(new SignalsOptions {
Timeout = Duration.Minutes(10)
})
});Signals
In normal operation, CloudFormation will send a Create or Update command to an AutoScalingGroup and proceed with the rest of the deployment without waiting for the instances in the AutoScalingGroup.
Configure signals to tell CloudFormation to wait for a specific number of
instances in the AutoScalingGroup to have been started (or failed to start)
before moving on. An instance is supposed to execute the
cfn-signal
program as part of its startup to indicate whether it was started
successfully or not.
If you use CloudFormation Init support (described in the previous section),
the appropriate call to cfn-signal is automatically added to the
AutoScalingGroup's UserData. If you don't use the signals directly, you are
responsible for adding such a call yourself.
The following type of Signals are available:
There are two options you can configure:
Update Policy
The update policy describes what should happen to running instances when the definition of the AutoScalingGroup is changed. For example, if you add a command to the UserData of an AutoScalingGroup, do the existing instances get replaced with new instances that have executed the new UserData? Or do the "old" instances just keep on running?
It is recommended to always use an update policy, otherwise the current state of your instances also depends the previous state of your instances, rather than just on your source code. This degrades the reproducibility of your deployments.
The following update policies are available:
Allowing Connections
See the documentation of the aws-cdk-lib/aws-ec2 package for more information
about allowing connections between resources backed by instances.
Max Instance Lifetime
To enable the max instance lifetime support, specify maxInstanceLifetime property
for the AutoscalingGroup resource. The value must be between 7 and 365 days(inclusive).
To clear a previously set value, leave this property undefined.
Instance Monitoring
To disable detailed instance monitoring, specify instanceMonitoring property
for the AutoscalingGroup resource as Monitoring.BASIC. Otherwise detailed monitoring
will be enabled.
Monitoring Group Metrics
Group metrics are used to monitor group level properties; they describe the group rather than any of its instances (e.g GroupMaxSize, the group maximum size). To enable group metrics monitoring, use the groupMetrics property.
All group metrics are reported in a granularity of 1 minute at no additional charge.
See EC2 docs for a list of all available group metrics.
To enable group metrics monitoring using the groupMetrics property:
Vpc vpc;
InstanceType instanceType;
IMachineImage machineImage;
// Enable monitoring of all group metrics
// Enable monitoring of all group metrics
new AutoScalingGroup(this, "ASG", new AutoScalingGroupProps {
Vpc = vpc,
InstanceType = instanceType,
MachineImage = machineImage,
// ...
GroupMetrics = new [] { GroupMetrics.All() }
});
// Enable monitoring for a subset of group metrics
// Enable monitoring for a subset of group metrics
new AutoScalingGroup(this, "ASG", new AutoScalingGroupProps {
Vpc = vpc,
InstanceType = instanceType,
MachineImage = machineImage,
// ...
GroupMetrics = new [] { new GroupMetrics(GroupMetric.MIN_SIZE, GroupMetric.MAX_SIZE) }
});Termination policies
Auto Scaling uses termination policies
to determine which instances it terminates first during scale-in events. You
can specify one or more termination policies with the terminationPolicies
property:
Custom termination policy with lambda
can be used to determine which instances to terminate based on custom logic.
The custom termination policy can be specified using TerminationPolicy.CUSTOM_LAMBDA_FUNCTION. If this is
specified, you must also supply a value of lambda arn in the terminationPolicyCustomLambdaFunctionArn property and
attach necessary permission
to invoke the lambda function.
If there are multiple termination policies specified,
custom termination policy with lambda TerminationPolicy.CUSTOM_LAMBDA_FUNCTION
must be specified first.
Vpc vpc;
InstanceType instanceType;
IMachineImage machineImage;
string arn;
new AutoScalingGroup(this, "ASG", new AutoScalingGroupProps {
Vpc = vpc,
InstanceType = instanceType,
MachineImage = machineImage,
// ...
TerminationPolicies = new [] { TerminationPolicy.CUSTOM_LAMBDA_FUNCTION, TerminationPolicy.OLDEST_INSTANCE, TerminationPolicy.DEFAULT },
//terminationPolicyCustomLambdaFunctionArn property must be specified if the TerminationPolicy.CUSTOM_LAMBDA_FUNCTION is used
TerminationPolicyCustomLambdaFunctionArn = arn
});Protecting new instances from being terminated on scale-in
By default, Auto Scaling can terminate an instance at any time after launch when scaling in an Auto Scaling Group, subject to the group's termination policy.
However, you may wish to protect newly-launched instances from being scaled in
if they are going to run critical applications that should not be prematurely
terminated. EC2 Capacity Providers for Amazon ECS requires this attribute be
set to true.
Vpc vpc;
InstanceType instanceType;
IMachineImage machineImage;
new AutoScalingGroup(this, "ASG", new AutoScalingGroupProps {
Vpc = vpc,
InstanceType = instanceType,
MachineImage = machineImage,
// ...
NewInstancesProtectedFromScaleIn = true
});Configuring Capacity Rebalancing
Indicates whether Capacity Rebalancing is enabled. Otherwise, Capacity Rebalancing is disabled. When you turn on Capacity Rebalancing, Amazon EC2 Auto Scaling attempts to launch a Spot Instance whenever Amazon EC2 notifies that a Spot Instance is at an elevated risk of interruption. After launching a new instance, it then terminates an old instance. For more information, see Use Capacity Rebalancing to handle Amazon EC2 Spot Interruptions in the in the Amazon EC2 Auto Scaling User Guide.
Vpc vpc;
InstanceType instanceType;
IMachineImage machineImage;
new AutoScalingGroup(this, "ASG", new AutoScalingGroupProps {
Vpc = vpc,
InstanceType = instanceType,
MachineImage = machineImage,
// ...
CapacityRebalance = true
});Connecting to your instances using SSM Session Manager
SSM Session Manager makes it possible to connect to your instances from the AWS Console, without preparing SSH keys.
To do so, you need to:
If these conditions are met, you can connect to the instance from the EC2 Console. Example:
Vpc vpc;
new AutoScalingGroup(this, "ASG", new AutoScalingGroupProps {
Vpc = vpc,
InstanceType = InstanceType.Of(InstanceClass.T3, InstanceSize.MICRO),
// Amazon Linux 2 comes with SSM Agent by default
MachineImage = MachineImage.LatestAmazonLinux2(),
// Turn on SSM
SsmSessionPermissions = true
});Configuring Instance Metadata Service (IMDS)
Toggling IMDSv1
You can configure EC2 Instance Metadata Service options to either allow both IMDSv1 and IMDSv2 or enforce IMDSv2 when interacting with the IMDS.
To do this for a single AutoScalingGroup, you can use set the requireImdsv2 property.
The example below demonstrates IMDSv2 being required on a single AutoScalingGroup:
Vpc vpc;
InstanceType instanceType;
IMachineImage machineImage;
new AutoScalingGroup(this, "ASG", new AutoScalingGroupProps {
Vpc = vpc,
InstanceType = instanceType,
MachineImage = machineImage,
// ...
RequireImdsv2 = true
});You can also use AutoScalingGroupRequireImdsv2Aspect to apply the operation to multiple AutoScalingGroups.
The example below demonstrates the AutoScalingGroupRequireImdsv2Aspect being used to require IMDSv2 for all AutoScalingGroups in a stack:
var aspect = new AutoScalingGroupRequireImdsv2Aspect();
Aspects.Of(this).Add(aspect);Warm Pool
Auto Scaling offers a warm pool which gives an ability to decrease latency for applications that have exceptionally long boot times. You can create a warm pool with default parameters as below:
AutoScalingGroup autoScalingGroup;
autoScalingGroup.AddWarmPool();You can also customize a warm pool by configuring parameters:
AutoScalingGroup autoScalingGroup;
autoScalingGroup.AddWarmPool(new WarmPoolOptions {
MinSize = 1,
ReuseOnScaleIn = true
});Default Instance Warming
You can use the default instance warmup feature to improve the Amazon CloudWatch metrics used for dynamic scaling. When default instance warmup is not enabled, each instance starts contributing usage data to the aggregated metrics as soon as the instance reaches the InService state. However, if you enable default instance warmup, this lets your instances finish warming up before they contribute the usage data.
To optimize the performance of scaling policies that scale continuously, such as target tracking and step scaling policies, we strongly recommend that you enable the default instance warmup, even if its value is set to 0 seconds.
To set up Default Instance Warming for an autoscaling group, simply pass it in as a prop
Vpc vpc;
InstanceType instanceType;
IMachineImage machineImage;
new AutoScalingGroup(this, "ASG", new AutoScalingGroupProps {
Vpc = vpc,
InstanceType = instanceType,
MachineImage = machineImage,
// ...
DefaultInstanceWarmup = Duration.Seconds(5)
});Configuring KeyPair for instances
You can use a keyPair to build your asg when you decide not to use a ready-made LanchTemplate.
To configure KeyPair for an autoscaling group, pass the keyPair as a prop:
Vpc vpc;
InstanceType instanceType;
IMachineImage machineImage;
var myKeyPair = new KeyPair(this, "MyKeyPair");
new AutoScalingGroup(this, "ASG", new AutoScalingGroupProps {
Vpc = vpc,
InstanceType = instanceType,
MachineImage = machineImage,
// ...
KeyPair = myKeyPair
});Capacity Distribution Strategy
If launches fail in an Availability Zone, the following strategies are available.
Vpc vpc;
InstanceType instanceType;
IMachineImage machineImage;
new AutoScalingGroup(this, "ASG", new AutoScalingGroupProps {
Vpc = vpc,
InstanceType = instanceType,
MachineImage = machineImage,
// ...
AzCapacityDistributionStrategy = CapacityDistributionStrategy.BALANCED_ONLY
});Future work
Classes
| AdjustmentTier | An adjustment. |
| AdjustmentType | How adjustment numbers are interpreted. |
| ApplyCloudFormationInitOptions | Options for applying CloudFormation init to an instance or instance group. |
| AutoScalingGroup | A Fleet represents a managed set of EC2 instances. |
| AutoScalingGroupProps | Properties of a Fleet. |
| AutoScalingGroupRequireImdsv2Aspect | Aspect that makes IMDSv2 required on instances deployed by AutoScalingGroups. |
| BaseTargetTrackingProps | Base interface for target tracking props. |
| BasicLifecycleHookProps | Basic properties for a lifecycle hook. |
| BasicScheduledActionProps | Properties for a scheduled scaling action. |
| BasicStepScalingPolicyProps | |
| BasicTargetTrackingScalingPolicyProps | Properties for a Target Tracking policy that include the metric but exclude the target. |
| BindHookTargetOptions | Options needed to bind a target to a lifecycle hook. |
| BlockDevice | Block device. |
| BlockDeviceVolume | Describes a block device mapping for an EC2 instance or Auto Scaling group. |
| CapacityDistributionStrategy | The strategies for when launches fail in an Availability Zone. |
| CfnAutoScalingGroup | The |
| CfnAutoScalingGroup.AcceleratorCountRequestProperty |
|
| CfnAutoScalingGroup.AcceleratorTotalMemoryMiBRequestProperty |
|
| CfnAutoScalingGroup.AvailabilityZoneDistributionProperty |
|
| CfnAutoScalingGroup.AvailabilityZoneImpairmentPolicyProperty | Describes an Availability Zone impairment policy. |
| CfnAutoScalingGroup.BaselineEbsBandwidthMbpsRequestProperty |
|
| CfnAutoScalingGroup.BaselinePerformanceFactorsRequestProperty | The baseline performance to consider, using an instance family as a baseline reference. |
| CfnAutoScalingGroup.CapacityReservationSpecificationProperty | Describes the Capacity Reservation preference and targeting options. |
| CfnAutoScalingGroup.CapacityReservationTargetProperty | The target for the Capacity Reservation. |
| CfnAutoScalingGroup.CpuPerformanceFactorRequestProperty | The CPU performance to consider, using an instance family as the baseline reference. |
| CfnAutoScalingGroup.InstanceMaintenancePolicyProperty |
|
| CfnAutoScalingGroup.InstanceRequirementsProperty | The attributes for the instance types for a mixed instances policy. |
| CfnAutoScalingGroup.InstancesDistributionProperty | Use this structure to specify the distribution of On-Demand Instances and Spot Instances and the allocation strategies used to fulfill On-Demand and Spot capacities for a mixed instances policy. |
| CfnAutoScalingGroup.LaunchTemplateOverridesProperty | Use this structure to let Amazon EC2 Auto Scaling do the following when the Auto Scaling group has a mixed instances policy: - Override the instance type that is specified in the launch template. |
| CfnAutoScalingGroup.LaunchTemplateProperty | Use this structure to specify the launch templates and instance types (overrides) for a mixed instances policy. |
| CfnAutoScalingGroup.LaunchTemplateSpecificationProperty | Specifies a launch template to use when provisioning EC2 instances for an Auto Scaling group. |
| CfnAutoScalingGroup.LifecycleHookSpecificationProperty |
|
| CfnAutoScalingGroup.MemoryGiBPerVCpuRequestProperty |
|
| CfnAutoScalingGroup.MemoryMiBRequestProperty |
|
| CfnAutoScalingGroup.MetricsCollectionProperty |
|
| CfnAutoScalingGroup.MixedInstancesPolicyProperty | Use this structure to launch multiple instance types and On-Demand Instances and Spot Instances within a single Auto Scaling group. |
| CfnAutoScalingGroup.NetworkBandwidthGbpsRequestProperty |
|
| CfnAutoScalingGroup.NetworkInterfaceCountRequestProperty |
|
| CfnAutoScalingGroup.NotificationConfigurationProperty | A structure that specifies an Amazon SNS notification configuration for the |
| CfnAutoScalingGroup.PerformanceFactorReferenceRequestProperty | Specify an instance family to use as the baseline reference for CPU performance. |
| CfnAutoScalingGroup.TagPropertyProperty | A structure that specifies a tag for the |
| CfnAutoScalingGroup.TotalLocalStorageGBRequestProperty |
|
| CfnAutoScalingGroup.TrafficSourceIdentifierProperty | Identifying information for a traffic source. |
| CfnAutoScalingGroup.VCpuCountRequestProperty |
|
| CfnAutoScalingGroupProps | Properties for defining a |
| CfnLaunchConfiguration | The |
| CfnLaunchConfiguration.BlockDeviceMappingProperty |
|
| CfnLaunchConfiguration.BlockDeviceProperty |
|
| CfnLaunchConfiguration.MetadataOptionsProperty |
|
| CfnLaunchConfigurationProps | Properties for defining a |
| CfnLifecycleHook | The |
| CfnLifecycleHookProps | Properties for defining a |
| CfnScalingPolicy | The |
| CfnScalingPolicy.CustomizedMetricSpecificationProperty | Contains customized metric specification information for a target tracking scaling policy for Amazon EC2 Auto Scaling. |
| CfnScalingPolicy.MetricDataQueryProperty | The metric data to return. |
| CfnScalingPolicy.MetricDimensionProperty |
|
| CfnScalingPolicy.MetricProperty | Represents a specific metric. |
| CfnScalingPolicy.MetricStatProperty |
|
| CfnScalingPolicy.PredefinedMetricSpecificationProperty | Contains predefined metric specification information for a target tracking scaling policy for Amazon EC2 Auto Scaling. |
| CfnScalingPolicy.PredictiveScalingConfigurationProperty |
|
| CfnScalingPolicy.PredictiveScalingCustomizedCapacityMetricProperty | Contains capacity metric information for the |
| CfnScalingPolicy.PredictiveScalingCustomizedLoadMetricProperty | Contains load metric information for the |
| CfnScalingPolicy.PredictiveScalingCustomizedScalingMetricProperty | Contains scaling metric information for the |
| CfnScalingPolicy.PredictiveScalingMetricSpecificationProperty | A structure that specifies a metric specification for the |
| CfnScalingPolicy.PredictiveScalingPredefinedLoadMetricProperty | Contains load metric information for the |
| CfnScalingPolicy.PredictiveScalingPredefinedMetricPairProperty | Contains metric pair information for the |
| CfnScalingPolicy.PredictiveScalingPredefinedScalingMetricProperty | Contains scaling metric information for the |
| CfnScalingPolicy.StepAdjustmentProperty |
|
| CfnScalingPolicy.TargetTrackingConfigurationProperty |
|
| CfnScalingPolicy.TargetTrackingMetricDataQueryProperty | The metric data to return. |
| CfnScalingPolicy.TargetTrackingMetricStatProperty | This structure defines the CloudWatch metric to return, along with the statistic and unit. |
| CfnScalingPolicyProps | Properties for defining a |
| CfnScheduledAction | The |
| CfnScheduledActionProps | Properties for defining a |
| CfnWarmPool | The |
| CfnWarmPool.InstanceReusePolicyProperty | A structure that specifies an instance reuse policy for the |
| CfnWarmPoolProps | Properties for defining a |
| CommonAutoScalingGroupProps | Basic properties of an AutoScalingGroup, except the exact machines to run and where they should run. |
| CpuUtilizationScalingProps | Properties for enabling scaling based on CPU utilization. |
| CronOptions | Options to configure a cron expression. |
| DefaultResult | |
| EbsDeviceOptions | Block device options for an EBS volume. |
| EbsDeviceOptionsBase | Base block device options for an EBS volume. |
| EbsDeviceProps | Properties of an EBS block device. |
| EbsDeviceSnapshotOptions | Block device options for an EBS volume created from a snapshot. |
| EbsDeviceVolumeType | Supported EBS volume types for blockDevices. |
| Ec2HealthCheckOptions | EC2 Heath check options. |
| ElbHealthCheckOptions | ELB Heath check options. |
| GroupMetric | Group metrics that an Auto Scaling group sends to Amazon CloudWatch. |
| GroupMetrics | A set of group metrics. |
| HealthCheck | Health check settings. |
| InstancesDistribution | InstancesDistribution is a subproperty of MixedInstancesPolicy that describes an instances distribution for an Auto Scaling group. |
| LaunchTemplateOverrides | LaunchTemplateOverrides is a subproperty of LaunchTemplate that describes an override for a launch template. |
| LifecycleHook | Define a life cycle hook. |
| LifecycleHookProps | Properties for a Lifecycle hook. |
| LifecycleHookTargetConfig | Result of binding a lifecycle hook to a target. |
| LifecycleTransition | What instance transition to attach the hook to. |
| MetricAggregationType | How the scaling metric is going to be aggregated. |
| MetricTargetTrackingProps | Properties for enabling tracking of an arbitrary metric. |
| MixedInstancesPolicy | MixedInstancesPolicy allows you to configure a group that diversifies across On-Demand Instances and Spot Instances of multiple instance types. |
| Monitoring | The monitoring mode for instances launched in an autoscaling group. |
| NetworkUtilizationScalingProps | Properties for enabling scaling based on network utilization. |
| NotificationConfiguration | AutoScalingGroup fleet change notifications configurations. |
| OnDemandAllocationStrategy | Indicates how to allocate instance types to fulfill On-Demand capacity. |
| PoolState | The instance state in the warm pool. |
| PredefinedMetric | One of the predefined autoscaling metrics. |
| RenderSignalsOptions | Input for Signals.renderCreationPolicy. |
| RequestCountScalingProps | Properties for enabling scaling based on request/second. |
| RollingUpdateOptions | Options for customizing the rolling update. |
| ScalingEvent | Fleet scaling events. |
| ScalingEvents | A list of ScalingEvents, you can use one of the predefined lists, such as ScalingEvents.ERRORS or create a custom group by instantiating a |
| ScalingInterval | A range of metric values in which to apply a certain scaling operation. |
| ScalingProcess | |
| Schedule | Schedule for scheduled scaling actions. |
| ScheduledAction | Define a scheduled scaling action. |
| ScheduledActionProps | Properties for a scheduled action on an AutoScalingGroup. |
| Signals | Configure whether the AutoScalingGroup waits for signals. |
| SignalsOptions | Customization options for Signal handling. |
| SpotAllocationStrategy | Indicates how to allocate instance types to fulfill Spot capacity. |
| StepScalingAction | Define a step scaling action. |
| StepScalingActionProps | Properties for a scaling policy. |
| StepScalingPolicy | Define a acaling strategy which scales depending on absolute values of some metric. |
| StepScalingPolicyProps | |
| TargetTrackingScalingPolicy | |
| TargetTrackingScalingPolicyProps | Properties for a concrete TargetTrackingPolicy. |
| TerminationPolicy | Specifies the termination criteria to apply before Amazon EC2 Auto Scaling chooses an instance for termination. |
| UpdatePolicy | How existing instances should be updated. |
| WarmPool | Define a warm pool. |
| WarmPoolOptions | Options for a warm pool. |
| WarmPoolProps | Properties for a warm pool. |
Interfaces
| CfnAutoScalingGroup.IAcceleratorCountRequestProperty |
|
| CfnAutoScalingGroup.IAcceleratorTotalMemoryMiBRequestProperty |
|
| CfnAutoScalingGroup.IAvailabilityZoneDistributionProperty |
|
| CfnAutoScalingGroup.IAvailabilityZoneImpairmentPolicyProperty | Describes an Availability Zone impairment policy. |
| CfnAutoScalingGroup.IBaselineEbsBandwidthMbpsRequestProperty |
|
| CfnAutoScalingGroup.IBaselinePerformanceFactorsRequestProperty | The baseline performance to consider, using an instance family as a baseline reference. |
| CfnAutoScalingGroup.ICapacityReservationSpecificationProperty | Describes the Capacity Reservation preference and targeting options. |
| CfnAutoScalingGroup.ICapacityReservationTargetProperty | The target for the Capacity Reservation. |
| CfnAutoScalingGroup.ICpuPerformanceFactorRequestProperty | The CPU performance to consider, using an instance family as the baseline reference. |
| CfnAutoScalingGroup.IInstanceMaintenancePolicyProperty |
|
| CfnAutoScalingGroup.IInstanceRequirementsProperty | The attributes for the instance types for a mixed instances policy. |
| CfnAutoScalingGroup.IInstancesDistributionProperty | Use this structure to specify the distribution of On-Demand Instances and Spot Instances and the allocation strategies used to fulfill On-Demand and Spot capacities for a mixed instances policy. |
| CfnAutoScalingGroup.ILaunchTemplateOverridesProperty | Use this structure to let Amazon EC2 Auto Scaling do the following when the Auto Scaling group has a mixed instances policy: - Override the instance type that is specified in the launch template. |
| CfnAutoScalingGroup.ILaunchTemplateProperty | Use this structure to specify the launch templates and instance types (overrides) for a mixed instances policy. |
| CfnAutoScalingGroup.ILaunchTemplateSpecificationProperty | Specifies a launch template to use when provisioning EC2 instances for an Auto Scaling group. |
| CfnAutoScalingGroup.ILifecycleHookSpecificationProperty |
|
| CfnAutoScalingGroup.IMemoryGiBPerVCpuRequestProperty |
|
| CfnAutoScalingGroup.IMemoryMiBRequestProperty |
|
| CfnAutoScalingGroup.IMetricsCollectionProperty |
|
| CfnAutoScalingGroup.IMixedInstancesPolicyProperty | Use this structure to launch multiple instance types and On-Demand Instances and Spot Instances within a single Auto Scaling group. |
| CfnAutoScalingGroup.INetworkBandwidthGbpsRequestProperty |
|
| CfnAutoScalingGroup.INetworkInterfaceCountRequestProperty |
|
| CfnAutoScalingGroup.INotificationConfigurationProperty | A structure that specifies an Amazon SNS notification configuration for the |
| CfnAutoScalingGroup.IPerformanceFactorReferenceRequestProperty | Specify an instance family to use as the baseline reference for CPU performance. |
| CfnAutoScalingGroup.ITagPropertyProperty | A structure that specifies a tag for the |
| CfnAutoScalingGroup.ITotalLocalStorageGBRequestProperty |
|
| CfnAutoScalingGroup.ITrafficSourceIdentifierProperty | Identifying information for a traffic source. |
| CfnAutoScalingGroup.IVCpuCountRequestProperty |
|
| CfnLaunchConfiguration.IBlockDeviceMappingProperty |
|
| CfnLaunchConfiguration.IBlockDeviceProperty |
|
| CfnLaunchConfiguration.IMetadataOptionsProperty |
|
| CfnScalingPolicy.ICustomizedMetricSpecificationProperty | Contains customized metric specification information for a target tracking scaling policy for Amazon EC2 Auto Scaling. |
| CfnScalingPolicy.IMetricDataQueryProperty | The metric data to return. |
| CfnScalingPolicy.IMetricDimensionProperty |
|
| CfnScalingPolicy.IMetricProperty | Represents a specific metric. |
| CfnScalingPolicy.IMetricStatProperty |
|
| CfnScalingPolicy.IPredefinedMetricSpecificationProperty | Contains predefined metric specification information for a target tracking scaling policy for Amazon EC2 Auto Scaling. |
| CfnScalingPolicy.IPredictiveScalingConfigurationProperty |
|
| CfnScalingPolicy.IPredictiveScalingCustomizedCapacityMetricProperty | Contains capacity metric information for the |
| CfnScalingPolicy.IPredictiveScalingCustomizedLoadMetricProperty | Contains load metric information for the |
| CfnScalingPolicy.IPredictiveScalingCustomizedScalingMetricProperty | Contains scaling metric information for the |
| CfnScalingPolicy.IPredictiveScalingMetricSpecificationProperty | A structure that specifies a metric specification for the |
| CfnScalingPolicy.IPredictiveScalingPredefinedLoadMetricProperty | Contains load metric information for the |
| CfnScalingPolicy.IPredictiveScalingPredefinedMetricPairProperty | Contains metric pair information for the |
| CfnScalingPolicy.IPredictiveScalingPredefinedScalingMetricProperty | Contains scaling metric information for the |
| CfnScalingPolicy.IStepAdjustmentProperty |
|
| CfnScalingPolicy.ITargetTrackingConfigurationProperty |
|
| CfnScalingPolicy.ITargetTrackingMetricDataQueryProperty | The metric data to return. |
| CfnScalingPolicy.ITargetTrackingMetricStatProperty | This structure defines the CloudWatch metric to return, along with the statistic and unit. |
| CfnWarmPool.IInstanceReusePolicyProperty | A structure that specifies an instance reuse policy for the |
| IAdjustmentTier | An adjustment. |
| IApplyCloudFormationInitOptions | Options for applying CloudFormation init to an instance or instance group. |
| IAutoScalingGroup | An AutoScalingGroup. |
| IAutoScalingGroupProps | Properties of a Fleet. |
| IBaseTargetTrackingProps | Base interface for target tracking props. |
| IBasicLifecycleHookProps | Basic properties for a lifecycle hook. |
| IBasicScheduledActionProps | Properties for a scheduled scaling action. |
| IBasicStepScalingPolicyProps | |
| IBasicTargetTrackingScalingPolicyProps | Properties for a Target Tracking policy that include the metric but exclude the target. |
| IBindHookTargetOptions | Options needed to bind a target to a lifecycle hook. |
| IBlockDevice | Block device. |
| ICfnAutoScalingGroupProps | Properties for defining a |
| ICfnLaunchConfigurationProps | Properties for defining a |
| ICfnLifecycleHookProps | Properties for defining a |
| ICfnScalingPolicyProps | Properties for defining a |
| ICfnScheduledActionProps | Properties for defining a |
| ICfnWarmPoolProps | Properties for defining a |
| ICommonAutoScalingGroupProps | Basic properties of an AutoScalingGroup, except the exact machines to run and where they should run. |
| ICpuUtilizationScalingProps | Properties for enabling scaling based on CPU utilization. |
| ICronOptions | Options to configure a cron expression. |
| IEbsDeviceOptions | Block device options for an EBS volume. |
| IEbsDeviceOptionsBase | Base block device options for an EBS volume. |
| IEbsDeviceProps | Properties of an EBS block device. |
| IEbsDeviceSnapshotOptions | Block device options for an EBS volume created from a snapshot. |
| IEc2HealthCheckOptions | EC2 Heath check options. |
| IElbHealthCheckOptions | ELB Heath check options. |
| IInstancesDistribution | InstancesDistribution is a subproperty of MixedInstancesPolicy that describes an instances distribution for an Auto Scaling group. |
| ILaunchTemplateOverrides | LaunchTemplateOverrides is a subproperty of LaunchTemplate that describes an override for a launch template. |
| ILifecycleHook | A basic lifecycle hook object. |
| ILifecycleHookProps | Properties for a Lifecycle hook. |
| ILifecycleHookTarget | Interface for autoscaling lifecycle hook targets. |
| ILifecycleHookTargetConfig | Result of binding a lifecycle hook to a target. |
| IMetricTargetTrackingProps | Properties for enabling tracking of an arbitrary metric. |
| IMixedInstancesPolicy | MixedInstancesPolicy allows you to configure a group that diversifies across On-Demand Instances and Spot Instances of multiple instance types. |
| INetworkUtilizationScalingProps | Properties for enabling scaling based on network utilization. |
| INotificationConfiguration | AutoScalingGroup fleet change notifications configurations. |
| IRenderSignalsOptions | Input for Signals.renderCreationPolicy. |
| IRequestCountScalingProps | Properties for enabling scaling based on request/second. |
| IRollingUpdateOptions | Options for customizing the rolling update. |
| IScalingInterval | A range of metric values in which to apply a certain scaling operation. |
| IScheduledActionProps | Properties for a scheduled action on an AutoScalingGroup. |
| ISignalsOptions | Customization options for Signal handling. |
| IStepScalingActionProps | Properties for a scaling policy. |
| IStepScalingPolicyProps | |
| ITargetTrackingScalingPolicyProps | Properties for a concrete TargetTrackingPolicy. |
| IWarmPoolOptions | Options for a warm pool. |
| IWarmPoolProps | Properties for a warm pool. |