AcceleratorConfig Struct
Accelerator configuration for Lambda Managed Instance (LMI) functions.
| Source | aws-lambda/lib/accelerator-config.ts |
|---|
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 gpuCapacityProvider = new lambda.CapacityProvider(this, 'GpuCapacityProvider', {
subnets: vpc.privateSubnets,
securityGroups: [securityGroup],
architectures: [lambda.Architecture.X86_64],
instanceTypeFilter: lambda.InstanceTypeFilter.allow([
ec2.InstanceType.of(ec2.InstanceClass.G6, ec2.InstanceSize.XLARGE),
]),
scalingOptions: lambda.ScalingOptions.manual([
lambda.TargetTrackingScalingPolicy.gpuUtilization(60),
]),
});
const fn = new lambda.Function(this, 'MyFunction', {
runtime: lambda.Runtime.FROM_IMAGE,
handler: lambda.Handler.FROM_IMAGE,
code: lambda.Code.fromAssetImage(path.join(__dirname, 'lambda-handler')),
memorySize: 2048,
acceleratorConfig: {
acceleratorMemorySize: lambda.AcceleratorMemorySize.GIB_24,
},
});
gpuCapacityProvider.addFunction(fn);
python
import aws_cdk.aws_ec2 as ec2
vpc = ec2.Vpc(self, "MyVpc")
security_group = ec2.SecurityGroup(self, "SecurityGroup", vpc=vpc)
gpu_capacity_provider = lambda_.CapacityProvider(self, "GpuCapacityProvider",
subnets=vpc.private_subnets,
security_groups=[security_group],
architectures=[lambda_.Architecture.X86_64],
instance_type_filter=lambda_.InstanceTypeFilter.allow([
ec2.InstanceType.of(ec2.InstanceClass.G6, ec2.InstanceSize.XLARGE)
]),
scaling_options=lambda_.ScalingOptions.manual([
lambda_.TargetTrackingScalingPolicy.gpu_utilization(60)
])
)
fn = lambda_.Function(self, "MyFunction",
runtime=lambda_.Runtime.FROM_IMAGE,
handler=lambda_.Handler.FROM_IMAGE,
code=lambda_.Code.from_asset_image(path.join(__dirname, "lambda-handler")),
memory_size=2048,
accelerator_config=lambda.AcceleratorConfig(
accelerator_memory_size=lambda_.AcceleratorMemorySize.GIB_24
)
)
gpu_capacity_provider.add_function(fn)
java
import software.amazon.awscdk.services.ec2.*;
Vpc vpc = new Vpc(this, "MyVpc");
SecurityGroup securityGroup = SecurityGroup.Builder.create(this, "SecurityGroup").vpc(vpc).build();
CapacityProvider gpuCapacityProvider = CapacityProvider.Builder.create(this, "GpuCapacityProvider")
.subnets(vpc.getPrivateSubnets())
.securityGroups(List.of(securityGroup))
.architectures(List.of(Architecture.X86_64))
.instanceTypeFilter(InstanceTypeFilter.allow(List.of(InstanceType.of(InstanceClass.G6, InstanceSize.XLARGE))))
.scalingOptions(ScalingOptions.manual(List.of(TargetTrackingScalingPolicy.gpuUtilization(60))))
.build();
Function fn = Function.Builder.create(this, "MyFunction")
.runtime(Runtime.FROM_IMAGE)
.handler(Handler.FROM_IMAGE)
.code(Code.fromAssetImage(join(__dirname, "lambda-handler")))
.memorySize(2048)
.acceleratorConfig(AcceleratorConfig.builder()
.acceleratorMemorySize(AcceleratorMemorySize.GIB_24)
.build())
.build();
gpuCapacityProvider.addFunction(fn);
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 gpuCapacityProvider = new CapacityProvider(this, "GpuCapacityProvider", new CapacityProviderProps {
Subnets = vpc.PrivateSubnets,
SecurityGroups = new [] { securityGroup },
Architectures = new [] { Architecture.X86_64 },
InstanceTypeFilter = InstanceTypeFilter.Allow(new [] { InstanceType.Of(InstanceClass.G6, InstanceSize.XLARGE) }),
ScalingOptions = ScalingOptions.Manual(new [] { TargetTrackingScalingPolicy.GpuUtilization(60) })
});
var fn = new Function(this, "MyFunction", new FunctionProps {
Runtime = Runtime.FROM_IMAGE,
Handler = Handler.FROM_IMAGE,
Code = Code.FromAssetImage(Join(__dirname, "lambda-handler")),
MemorySize = 2048,
AcceleratorConfig = new AcceleratorConfig {
AcceleratorMemorySize = AcceleratorMemorySize.GIB_24
}
});
gpuCapacityProvider.AddFunction(fn);
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,
})
gpuCapacityProvider := lambda.NewCapacityProvider(this, jsii.String("GpuCapacityProvider"), &CapacityProviderProps{
Subnets: vpc.PrivateSubnets,
SecurityGroups: []ISecurityGroup{
securityGroup,
},
Architectures: []Architecture{
lambda.Architecture_X86_64(),
},
InstanceTypeFilter: lambda.InstanceTypeFilter_Allow([]InstanceType{
ec2.InstanceType_Of(ec2.InstanceClass_G6, ec2.InstanceSize_XLARGE),
}),
ScalingOptions: lambda.ScalingOptions_Manual([]TargetTrackingScalingPolicy{
lambda.TargetTrackingScalingPolicy_GpuUtilization(jsii.Number(60)),
}),
})
fn := lambda.NewFunction(this, jsii.String("MyFunction"), &FunctionProps{
Runtime: lambda.Runtime_FROM_IMAGE(),
Handler: lambda.Handler_FROM_IMAGE(),
Code: lambda.Code_FromAssetImage(path.join(__dirname, jsii.String("lambda-handler"))),
MemorySize: jsii.Number(2048),
AcceleratorConfig: &AcceleratorConfig{
AcceleratorMemorySize: lambda.AcceleratorMemorySize_GIB_24(),
},
})
gpuCapacityProvider.AddFunction(fn)
Properties
acceleratorMemorySizeAcceleratorMemorySizeaccelerator_memory_sizeAcceleratorMemorySizeacceleratorMemorySizeAcceleratorMemorySizeAcceleratorMemorySizeAcceleratorMemorySizeAcceleratorMemorySizeAcceleratorMemorySize required #The minimum amount of memory of each accelerator device exposed to the execution environment.
Lambda might allocate more, depending on the accelerator instance types available.