Skip to content
v2.278.0

Capacity Class ​

Represents the amount of read and write operations supported by a DynamoDB table.

Example ​

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

const app = new cdk.App();
const stack = new cdk.Stack(app, 'Stack', { env: { region: 'us-west-2' } });

const globalTable = new dynamodb.TableV2(stack, 'GlobalTable', {
  partitionKey: { name: 'pk', type: dynamodb.AttributeType.STRING },
  billing: dynamodb.Billing.provisioned({
    readCapacity: dynamodb.Capacity.fixed(10),
    writeCapacity: dynamodb.Capacity.autoscaled({ maxCapacity: 15 }),
  }),
  replicas: [
    {
      region: 'us-east-1',
    },
    {
      region: 'us-east-2',
      readCapacity: dynamodb.Capacity.autoscaled({ maxCapacity: 20, targetUtilizationPercent: 50 }),
    },
  ],
});
python
import aws_cdk as cdk


app = cdk.App()
stack = cdk.Stack(app, "Stack", env=cdk.Environment(region="us-west-2"))

global_table = dynamodb.TableV2(stack, "GlobalTable",
    partition_key=dynamodb.Attribute(name="pk", type=dynamodb.AttributeType.STRING),
    billing=dynamodb.Billing.provisioned(
        read_capacity=dynamodb.Capacity.fixed(10),
        write_capacity=dynamodb.Capacity.autoscaled(max_capacity=15)
    ),
    replicas=[dynamodb.ReplicaTableProps(
        region="us-east-1"
    ), dynamodb.ReplicaTableProps(
        region="us-east-2",
        read_capacity=dynamodb.Capacity.autoscaled(max_capacity=20, target_utilization_percent=50)
    )
    ]
)
java
import software.amazon.awscdk.*;


App app = new App();
Stack stack = Stack.Builder.create(app, "Stack").env(Environment.builder().region("us-west-2").build()).build();

TableV2 globalTable = TableV2.Builder.create(stack, "GlobalTable")
        .partitionKey(Attribute.builder().name("pk").type(AttributeType.STRING).build())
        .billing(Billing.provisioned(ThroughputProps.builder()
                .readCapacity(Capacity.fixed(10))
                .writeCapacity(Capacity.autoscaled(AutoscaledCapacityOptions.builder().maxCapacity(15).build()))
                .build()))
        .replicas(List.of(ReplicaTableProps.builder()
                .region("us-east-1")
                .build(), ReplicaTableProps.builder()
                .region("us-east-2")
                .readCapacity(Capacity.autoscaled(AutoscaledCapacityOptions.builder().maxCapacity(20).targetUtilizationPercent(50).build()))
                .build()))
        .build();
csharp
// Install: dotnet add package Amazon.CDK.Lib
using Amazon.CDK;


var app = new App();
var stack = new Stack(app, "Stack", new StackProps { Env = new Environment { Region = "us-west-2" } });

var globalTable = new TableV2(stack, "GlobalTable", new TablePropsV2 {
    PartitionKey = new Attribute { Name = "pk", Type = AttributeType.STRING },
    Billing = Billing.Provisioned(new ThroughputProps {
        ReadCapacity = Capacity.Fixed(10),
        WriteCapacity = Capacity.Autoscaled(new AutoscaledCapacityOptions { MaxCapacity = 15 })
    }),
    Replicas = new [] { new ReplicaTableProps {
        Region = "us-east-1"
    }, new ReplicaTableProps {
        Region = "us-east-2",
        ReadCapacity = Capacity.Autoscaled(new AutoscaledCapacityOptions { MaxCapacity = 20, TargetUtilizationPercent = 50 })
    } }
});
go
// Install: go get github.com/aws/aws-cdk-go/awscdk/v2
import "github.com/aws/aws-cdk-go/awscdk"


app := cdk.NewApp()
stack := cdk.NewStack(app, jsii.String("Stack"), &StackProps{
	Env: &Environment{
		Region: jsii.String("us-west-2"),
	},
})

globalTable := dynamodb.NewTableV2(stack, jsii.String("GlobalTable"), &TablePropsV2{
	PartitionKey: &Attribute{
		Name: jsii.String("pk"),
		Type: dynamodb.AttributeType_STRING,
	},
	Billing: dynamodb.Billing_Provisioned(&ThroughputProps{
		ReadCapacity: dynamodb.Capacity_Fixed(jsii.Number(10)),
		WriteCapacity: dynamodb.Capacity_Autoscaled(&AutoscaledCapacityOptions{
			MaxCapacity: jsii.Number(15),
		}),
	}),
	Replicas: []ReplicaTableProps{
		&ReplicaTableProps{
			Region: jsii.String("us-east-1"),
		},
		&ReplicaTableProps{
			Region: jsii.String("us-east-2"),
			ReadCapacity: dynamodb.Capacity_*Autoscaled(&AutoscaledCapacityOptions{
				MaxCapacity: jsii.Number(20),
				TargetUtilizationPercent: jsii.Number(50),
			}),
		},
	},
})

Properties ​

Methods ​

autoscaled(options: AutoscaledCapacityOptions): Capacity // chainable@staticmethod def autoscaled(options: AutoscaledCapacityOptions) -> Capacitypublic static Capacity autoscaled(AutoscaledCapacityOptions options)public static Capacity Autoscaled(AutoscaledCapacityOptions options)func Autoscaled(Options AutoscaledCapacityOptions) Capacity static #
Dynamically adjusts provisioned throughput capacity on your behalf in response to actual traffic patterns.
1 parameter

Parameters

  • optionsoptionsoptionsoptionsOptions — options used to configure autoscaled capacity mode.
fixed(iops: number): Capacity // chainable@staticmethod def fixed(iops: int | float) -> Capacitypublic static Capacity fixed(Number iops)public static Capacity Fixed(double iops)func Fixed(Iops *float64) Capacity static #
Provisioned throughput capacity is configured with fixed capacity units.

Note: You cannot configure write capacity using fixed capacity mode.

1 parameter

Parameters

  • iopsiopsiopsiopsIops — the number of I/O operations per second.