Skip to content
v2.277.0

ScalingOptions Class ​

Configuration options for scaling a capacity provider, including scaling mode and policies.

Example ​

ts
import * as ec2 from 'aws-cdk-lib/aws-ec2';

const vpc = new ec2.Vpc(this, 'MyVpc');
const securityGroup = new ec2.SecurityGroup(this, 'SecurityGroup', { vpc });

const capacityProvider = new lambda.CapacityProvider(this, 'MyCapacityProvider', {
  subnets: vpc.privateSubnets,
  securityGroups: [securityGroup],
  scalingOptions: lambda.ScalingOptions.manual([
    lambda.TargetTrackingScalingPolicy.cpuUtilization(70),
  ]),
});
python
import aws_cdk.aws_ec2 as ec2


vpc = ec2.Vpc(self, "MyVpc")
security_group = ec2.SecurityGroup(self, "SecurityGroup", vpc=vpc)

capacity_provider = lambda_.CapacityProvider(self, "MyCapacityProvider",
    subnets=vpc.private_subnets,
    security_groups=[security_group],
    scaling_options=lambda_.ScalingOptions.manual([
        lambda_.TargetTrackingScalingPolicy.cpu_utilization(70)
    ])
)
java
import software.amazon.awscdk.services.ec2.*;


Vpc vpc = new Vpc(this, "MyVpc");
SecurityGroup securityGroup = SecurityGroup.Builder.create(this, "SecurityGroup").vpc(vpc).build();

CapacityProvider capacityProvider = CapacityProvider.Builder.create(this, "MyCapacityProvider")
        .subnets(vpc.getPrivateSubnets())
        .securityGroups(List.of(securityGroup))
        .scalingOptions(ScalingOptions.manual(List.of(TargetTrackingScalingPolicy.cpuUtilization(70))))
        .build();
csharp
// Install: dotnet add package Amazon.CDK.Lib
using Amazon.CDK.AWS.EC2;


var vpc = new Vpc(this, "MyVpc");
var securityGroup = new SecurityGroup(this, "SecurityGroup", new SecurityGroupProps { Vpc = vpc });

var capacityProvider = new CapacityProvider(this, "MyCapacityProvider", new CapacityProviderProps {
    Subnets = vpc.PrivateSubnets,
    SecurityGroups = new [] { securityGroup },
    ScalingOptions = ScalingOptions.Manual(new [] { TargetTrackingScalingPolicy.CpuUtilization(70) })
});
go
// Install: go get github.com/aws/aws-cdk-go/awscdk/v2
import "github.com/aws/aws-cdk-go/awscdk"


vpc := ec2.NewVpc(this, jsii.String("MyVpc"))
securityGroup := ec2.NewSecurityGroup(this, jsii.String("SecurityGroup"), &SecurityGroupProps{
	Vpc: Vpc,
})

capacityProvider := lambda.NewCapacityProvider(this, jsii.String("MyCapacityProvider"), &CapacityProviderProps{
	Subnets: vpc.PrivateSubnets,
	SecurityGroups: []ISecurityGroup{
		securityGroup,
	},
	ScalingOptions: lambda.ScalingOptions_Manual([]TargetTrackingScalingPolicy{
		lambda.TargetTrackingScalingPolicy_CpuUtilization(jsii.Number(70)),
	}),
})

Properties ​

scalingModestringscaling_modestrscalingModeStringScalingModestringScalingMode*string #
The scaling mode for the capacity provider.
scalingPoliciesmay be undefinedTargetTrackingScalingPolicy[]scaling_policiesmay be undefinedtyping.List[TargetTrackingScalingPolicy]scalingPoliciesmay be undefinedList<TargetTrackingScalingPolicy>ScalingPoliciesmay be undefinedTargetTrackingScalingPolicy[]ScalingPoliciesmay be undefined*[]TargetTrackingScalingPolicy #
The target tracking scaling policies used when scaling mode is 'Manual'.

Methods ​

auto(): ScalingOptions // chainable@staticmethod def auto() -> ScalingOptionspublic static ScalingOptions auto()public static ScalingOptions Auto()func Auto() ScalingOptions static #
Creates scaling options where the capacity provider manages scaling automatically.
manual(scalingPolicies: TargetTrackingScalingPolicy[]): ScalingOptions // chainable@staticmethod def manual(scaling_policies: typing.List[TargetTrackingScalingPolicy]) -> ScalingOptionspublic static ScalingOptions manual(List<TargetTrackingScalingPolicy> scalingPolicies)public static ScalingOptions Manual(TargetTrackingScalingPolicy[] scalingPolicies)func Manual(ScalingPolicies *[]TargetTrackingScalingPolicy) ScalingOptions static #
Creates manual scaling options with custom target tracking scaling policies.

At least one policy is required.

1 parameter

Parameters

  • scalingPoliciesscaling_policiesscalingPoliciesscalingPoliciesScalingPolicies — The target tracking scaling policies to use for manual scaling.