What is the process for horizontally scaling Amazon Aurora databases using the Aurora Limitless feature in TypeScript

Question

Pulumi · Accepted Answer

Horizontal scaling of Amazon Aurora databases involves adding more read replicas to handle increased read traffic or modifying the capacity settings of serverless Aurora instances to handle more concurrent connections and higher workloads. Aurora Serverless V2 (Aurora Limitless) simplifies this process by automatically scaling the database capacity based on workload changes without manual intervention.

To horizontally scale an Amazon Aurora database using Pulumi and TypeScript, you would typically create or update Aurora Serverless V2 instances with auto-scaling configurations. This ensures that the database can scale in and out automatically based on predefined metrics such as CPU utilization, connections, or other custom metrics.

Here's how you can define an Aurora Serverless V2 instance and apply auto-scaling rules using Pulumi and TypeScript.

First, be sure to have Pulumi installed and AWS configured for your environment.

Now, let's create a new Pulumi program:

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

// Create an Aurora DB cluster with serverless engine mode.
const cluster = new aws.rds.Cluster("my-aurora-cluster", {
    engine: "aurora",
    engineMode: "serverless",
    masterUsername: "aurora",
    masterPassword: "supersecretpassword",
    skipFinalSnapshot: true,
    backupRetentionPeriod: 7,
    preferredBackupWindow: "07:00-09:00",
    dbSubnetGroupName: "my-db-subnet-group", // Assume this subnet group is already created.
    vpcSecurityGroupIds: ["sg-xxxxxxxx"], // Replace with your VPC's security group.
    scalingConfiguration: {
        autoPause: false, // Disable auto-pause to allow continuous scaling.
        minCapacity: 2, // Set minimum capacity.
        maxCapacity: 16, // Set maximum capacity.
        // Other scaling configurations can be set here.
    }
});

// (Optional) Define scaling policies using aws.appautoscaling if you need finer control or if you are not using Serverless V2.

// Export the cluster's endpoint URL for easy access in your application.
export const auroraEndpoint = cluster.endpoint;
```

In the code above, we've defined an Amazon Aurora DB cluster with the following key parameters:
- `engine`: Specifies the database engine. Aurora supports both MySQL and PostgreSQL, but not all features are available for both engines.
- `engineMode`: We have set the engine mode to `serverless` which is required for using Aurora Serverless.
- `masterUsername` and `masterPassword`: These are your database credentials. Be sure to manage these securely and avoid hardcoding sensitive information.
- `skipFinalSnapshot`: For this example, we are skipping the final snapshot, but for production environments, you should have snapshots enabled.
- `scalingConfiguration`: Here is where we define the rules for how the serverless DB automatically scales. We set `autoPause` to `false` to avoid pausing the database when not in use, which might not be optimal during development or testing. We also set a minimum and maximum capacity. Aurora will automatically scale the capacity based on the workload between these values.

Please note that you must define security groups (`vpcSecurityGroupIds`) to control who can connect to your database cluster. The specified `dbSubnetGroupName` is the database subnet group that determines which subnets within your VPC the database instances reside in.

The cluster endpoint URL is exported so you can connect to the Aurora Serverless V2 database from other services or applications.

Security notice: Never hardcode sensitive data like database passwords directly in your source code. It’s recommended to use a secrets manager or environment variables and Pulumi's secret handling.

Please refer to the AWS documentation for any prerequisites and configurations for VPC, subnets, and other network configurations that might be needed before deploying database clusters.

Remember to check the official [Pulumi AWS RDS documentation](https://www.pulumi.com/docs/reference/pkg/aws/rds/cluster/) for more details on the properties and methods used for creating and managing AWS RDS clusters with Pulumi.

To apply this configuration, run `pulumi up` in your terminal with the Pulumi project. Pulumi will handle provisioning and deploying the necessary resources on AWS for you.