How Do I Dynamically Scale AWS DynamoDB With AppAutoScaling?

Introduction

This guide provides a comprehensive overview of how to dynamically scale AWS DynamoDB tables using AWS Application Auto Scaling with Pulumi. The objective is to create a DynamoDB table and configure it to automatically adjust its read and write capacities in response to varying workloads. By following this guide, you will ensure that your DynamoDB tables maintain optimal performance and cost-efficiency.

Step-by-Step Process

Define the DynamoDB Table:
- Create a DynamoDB table with the necessary attributes and key schema. This involves specifying the hash key and setting initial read and write capacities.
Configure the IAM Role:
- Set up an IAM role for Application Auto Scaling with the appropriate assume role policy. Attach the necessary policies to grant it full access to DynamoDB operations.
Set Up Scalable Targets:
- Define scalable targets for both read and write capacities. Specify the minimum and maximum capacity limits and associate them with the DynamoDB table.
Implement Scaling Policies:
- Develop scaling policies for read and write operations using target tracking scaling. These policies will adjust capacities based on CloudWatch metrics to maintain a target utilization percentage.
Export Table Details:
- Export the DynamoDB table name and ARN for reference and potential use in other configurations or applications.

Key Points

DynamoDB Table Configuration: Begin by defining the table structure with attributes, key schema, and initial capacity settings.
IAM Role for Auto Scaling: Ensure the role has the necessary permissions by attaching the AmazonDynamoDBFullAccess policy.
Scalable Targets: Set up targets to specify how the table’s read and write capacities should scale.
Scaling Policies: Use target tracking to automatically adjust capacity based on workload, ensuring efficient resource usage.
Export Information: Make the table’s name and ARN available for easy access and integration.

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

// Define the DynamoDB table
const dynamoTable = new aws.dynamodb.Table("myTable", {
    attributes: [
        { name: "Id", type: "S" },
    ],
    hashKey: "Id",
    readCapacity: 5,
    writeCapacity: 5,
    streamEnabled: true,
    streamViewType: "NEW_AND_OLD_IMAGES",
});

// Define the role for Application Auto Scaling
const role = new aws.iam.Role("autoScalingRole", {
    assumeRolePolicy: aws.iam.assumeRolePolicyForPrincipal({
        Service: "application-autoscaling.amazonaws.com",
    }),
});

// Attach the necessary policies to the role
const policyAttachment = new aws.iam.RolePolicyAttachment("autoScalingPolicy", {
    role: role.name,
    policyArn: "arn:aws:iam::aws:policy/service-role/AmazonDynamoDBFullAccess",
});

// Create a scalable target for the DynamoDB table's read capacity
const readScalableTarget = new aws.appautoscaling.Target("readScalableTarget", {
    maxCapacity: 20,
    minCapacity: 5,
    resourceId: pulumi.interpolate`table/${dynamoTable.name}`,
    scalableDimension: "dynamodb:table:ReadCapacityUnits",
    serviceNamespace: "dynamodb",
    roleArn: role.arn,
});

// Create a scalable target for the DynamoDB table's write capacity
const writeScalableTarget = new aws.appautoscaling.Target("writeScalableTarget", {
    maxCapacity: 20,
    minCapacity: 5,
    resourceId: pulumi.interpolate`table/${dynamoTable.name}`,
    scalableDimension: "dynamodb:table:WriteCapacityUnits",
    serviceNamespace: "dynamodb",
    roleArn: role.arn,
});

// Define a scaling policy for read capacity
const readScalingPolicy = new aws.appautoscaling.Policy("readScalingPolicy", {
    policyType: "TargetTrackingScaling",
    resourceId: readScalableTarget.resourceId,
    scalableDimension: readScalableTarget.scalableDimension,
    serviceNamespace: readScalableTarget.serviceNamespace,
    targetTrackingScalingPolicyConfiguration: {
        targetValue: 70.0,
        predefinedMetricSpecification: {
            predefinedMetricType: "DynamoDBReadCapacityUtilization",
        },
        scaleInCooldown: 60,
        scaleOutCooldown: 60,
    },
});

// Define a scaling policy for write capacity
const writeScalingPolicy = new aws.appautoscaling.Policy("writeScalingPolicy", {
    policyType: "TargetTrackingScaling",
    resourceId: writeScalableTarget.resourceId,
    scalableDimension: writeScalableTarget.scalableDimension,
    serviceNamespace: writeScalableTarget.serviceNamespace,
    targetTrackingScalingPolicyConfiguration: {
        targetValue: 70.0,
        predefinedMetricSpecification: {
            predefinedMetricType: "DynamoDBWriteCapacityUtilization",
        },
        scaleInCooldown: 60,
        scaleOutCooldown: 60,
    },
});

// Export the DynamoDB table name and ARN
export const tableName = dynamoTable.name;
export const tableArn = dynamoTable.arn;

Summary

In this guide, we successfully set up a DynamoDB table with dynamic scaling capabilities using AWS Application Auto Scaling. By defining scalable targets and implementing scaling policies, we ensured that the table’s read and write capacities adjust automatically based on demand. This approach optimizes both the performance and cost-effectiveness of your DynamoDB resources.

Deploy this code

Want to deploy this code? Sign up for a free Pulumi account to deploy in a few clicks.

New to Pulumi?

Want to deploy this code? Sign up with Pulumi to deploy in a few clicks.