Decoding Construct and Stack: The Quickest Way to Understand When to Use What

AWS Cloud Development Kit (CDK) simplifies defining cloud infrastructure by allowing you to use familiar programming languages instead of JSON or YAML. Two core concepts in CDK Constructs and Stacks are essential for organizing and deploying your infrastructure effectively. Constructs act as building blocks for defining resources, while Stacks group these resources for deployment.

Understanding these concepts is key to building scalable, reusable, and maintainable infrastructure. In this blog, we’ll explore what Constructs and Stacks are, their importance, and how to use them effectively in your CDK projects.

Key Concepts of AWS CDK Architecture

AWS CDK provides a high-level framework for defining cloud infrastructure, and understanding its core components helps you navigate and design effective solutions. Here’s how the main components fit together:

Constructs: The fundamental building blocks of CDK. Constructs define AWS resources and can be reused or combined into Stacks.
Stacks: Logical groupings of resources that are deployed together. Each Stack corresponds to an AWS Cloud Formation stack.
Apps: The fundamental building blocks of CDK. Constructs define AWS resources and can be reused or combined into Stacks.

By breaking infrastructure into these components, CDK makes it easier to manage resources, scale projects, and deploy environments effectively.

Understanding Constructs in AWS CDK

AWS CDK, Constructs are the basic building blocks you use to define your cloud infrastructure. Rather than manually creating resources through the AWS Management Console, you can write code to describe your infrastructure. Constructs in CDK simplify this process by turning AWS resources into reusable components.

Think of Constructs like pre-built templates or blueprints for AWS resources. You can use these Constructs to build everything from a simple S3 bucket to complex cloud architectures.

There are three types of Constructs, each offering a different level of abstraction:

1. L1 Constructs (Low-Level Constructs)

L1 Constructs are the most detailed and provide direct access to AWS Cloud Formation resources. These are like the raw building blocks of AWS infrastructure, giving you complete control over the configuration. However, they also require more effort to use because you need to manually specify all the settings for each resource.

Example: If you want to create an S3 bucket using an L1 Construct, you would use the CfnBucket construct. It maps directly to the Cloud Formation AWS::S3::Bucket resource.

				
					import * as cdk from 'aws-cdk-lib';
import * as s3 from 'aws-cdk-lib/aws-s3';

class L1ConstructExample extends cdk.Stack {
  constructor(scope: cdk.App, id: string) {
    super(scope, id);

    new s3.CfnBucket(this, 'MyL1Bucket', {
      bucketName: 'my-l1-bucket',
    });
  }
}

While this gives you fine control, you need to manually specify every configuration detail. It’s ideal when you need to customize the resource in ways not covered by higher-level Constructs.

2. L2 Constructs (Higher-Level Constructs)

L2 Constructs offer a simpler and more flexible way to create resources. These Constructs provide sensible defaults and handle many configuration details for you. They abstract away some of the complexity and allow you to focus on the most important settings.

Example: If you want to create an S3 bucket with versioning enabled, you can use the Bucket L2 Construct, which simplifies the process. You don’t need to specify everything manually like in L1 Constructs.

				
					import * as cdk from 'aws-cdk-lib';
import * as s3 from 'aws-cdk-lib/aws-s3';

class L2ConstructExample extends cdk.Stack {
  constructor(scope: cdk.App, id: string) {
    super(scope, id);

    new s3.Bucket(this, 'MyL2Bucket', {
      versioned: true,
      removalPolicy: cdk.RemovalPolicy.DESTROY, // Allows bucket to be deleted when the stack is deleted
    });
  }
}

The L2 Construct automatically handles a lot of behind-the-scenes configuration, like setting up defaults for lifecycle policies or permissions, making it easier to work with common use cases.

3. L3 Constructs (Pattern)

L3 Constructs are the highest level of abstraction and represent complete architectural patterns. These Constructs often combine multiple L2 resources to provide an out-of-the-box solution that follows AWS best practices. They are perfect for quickly deploying common infrastructure patterns without having to manually configure each resource.

Example: Let’s say you need to deploy an application with a load-balanced Fargate service. Instead of manually configuring ECS clusters, load balancers, and scaling policies, you can use an L3 Construct that handles it all for you.

				
					import * as cdk from 'aws-cdk-lib';
import * as ecs from 'aws-cdk-lib/aws-ecs';
import * as patterns from 'aws-cdk-lib/aws-ecs-patterns';

class L3ConstructExample extends cdk.Stack {
  constructor(scope: cdk.App, id: string) {
    super(scope, id);

    new patterns.ApplicationLoadBalancedFargateService(this, 'MyFargateService', {
      taskImageOptions: {
        image: ecs.ContainerImage.fromRegistry('amazon/amazon-ecs-sample'),
      },
    });
  }
}

This L3 Construct not only creates the Fargate service but also configures the load balancer and other necessary components automatically, making it incredibly easy to deploy complex systems.

In summary, L1 Constructs give you complete control, L2 Constructs simplify common tasks, and L3 Constructs provide ready-made solutions for entire applications. Each type is suited to different use cases, depending on how much customization and control you need.

Understanding Stacks in AWS CDK

In AWS CDK, a Stack is a logical unit that groups your cloud resources together. Stacks act as containers for the resources you define, such as S3 buckets, Lambda functions, or Dynamo DB tables. They are directly mapped to AWS Cloud Formation stacks, meaning each Stack in your CDK application corresponds to a Cloud Formation template that AWS uses to provision the resources.

How Stacks Work in AWS CDK:

When you deploy a Stack, AWS CDK generates a CloudFormation template for it and submits it to AWS CloudFormation, which then creates or updates the resources defined in the Stack. This approach has several advantages:

Logical Grouping: You can organize your infrastructure by grouping related resources in separate Stacks (e.g., one Stack for frontend resources and another for backend services).
Easier Management: Since Stacks are deployed independently, you can update or redeploy a specific part of your infrastructure without affecting the rest.
Scalability: Stacks help you scale across environments (like dev, staging, and prod) by reusing the same code with different configurations.

Here’s an example of a Stack in AWS CDK that creates an S3 bucket and a DynamoDB table:

				
					import * as cdk from 'aws-cdk-lib';
import * as s3 from 'aws-cdk-lib/aws-s3';
import * as dynamodb from 'aws-cdk-lib/aws-dynamodb';

export class MyAppStack extends cdk.Stack {
  constructor(scope: cdk.App, id: string) {
    super(scope, id);

    // Create an S3 Bucket
    new s3.Bucket(this, 'MyBucket', {
      versioned: true,
    });

    // Create a DynamoDB Table
    new dynamodb.Table(this, 'MyTable', {
      partitionKey: { name: 'id', type: dynamodb.AttributeType.STRING },
    });
  }
}

Understanding the “this” Keyword

In this example, the this keyword refers to the current instance of the MyAppStack class. It is used as the scope for the resources being created, like the S3 bucket and DynamoDB table. When you pass this as the first argument to resource constructors (like s3.Bucket or dynamodb.Table), you are telling AWS CDK that:

These resources belong to the current stack (MyAppStack).
They should be logically grouped and deployed as part of this stack.

In AWS CDK, the scope helps organize resources within the CDK app. Without it, CDK wouldn’t know which stack or parent the resource belongs to, leading to deployment errors.

When to Use Stacks

Separate resources by functionality or environment (e.g., backend and frontend stacks).
Control deployment order. For example, deploy a database Stack first, followed by the application Stack that uses it.
Scale your infrastructure to multiple environments (like dev, staging, and production).

Stacks bring structure and efficiency to your cloud infrastructure, making it easier to manage, deploy, and scale resources.

Understanding Apps in AWS CDK

In AWS CDK, an App serves as the root of your cloud infrastructure project. Think of an App as the entry point or the “main container” that holds all your Stacks. When you deploy your infrastructure using CDK, you first define an App and then add one or more Stacks to it.

An App is like the “blueprint folder” for your entire cloud architecture. It ties everything together, ensuring that your Stacks and their resources are properly organized and deployed.

How Do Apps Work?

An App is represented by the App class in AWS CDK. You define your infrastructure by creating an instance of the App class and then adding one or more Stacks to it. When you run the cdk deploy command, the App compiles all the Stacks into CloudFormation templates and sends them to AWS for deployment.

Here’s a basic structure of how an App works in CDK:

The App contains one or more Stacks.
Each Stack contains resources (e.g., S3 buckets, Lambda functions, DynamoDB tables).
The App ensures all the Stacks are deployed in the correct order.

Here’s an example of a simple CDK App with two Stacks:

				
					import * as cdk from 'aws-cdk-lib';
import { MyAppStack } from './my-app-stack';
import { AnotherStack } from './another-stack';

// Create a new CDK App
const app = new cdk.App();

// Add Stacks to the App
new MyAppStack(app, 'MyAppStack'); // First stack
new AnotherStack(app, 'AnotherStack'); // Second stack

How Constructs, Stacks, and Apps Work Together

In AWS CDK, Constructs, Stacks, and Apps are the building blocks of your infrastructure as code. They work in a layered hierarchy to help you design, organize, and deploy cloud resources effectively. Let’s break down their roles and how they fit together:

Apps:
- The root of your CDK application.
- An App contains one or more Stacks.
- It serves as the entry point for defining your infrastructure and ties everything together.
- Think of it as the “project folder” where all your Stacks and Constructs reside.
Stacks:
- Logical units within an App that group related resources.
- Each Stack represents an independent CloudFormation stack.
- Resources inside a Stack are provisioned together.
- Stacks provide a way to separate concerns (e.g., one Stack for the backend, another for the frontend).
Constructs:
- The foundational building blocks.
- Constructs represent AWS resources like S3 buckets, Lambda functions, and VPCs.
- You define Constructs within Stacks, and they ultimately translate into CloudFormation resources.
- Constructs can be basic (L1), higher-level (L2), or complex abstractions (L3).

Here’s a complete example to show how these three work together:

				
					import * as cdk from 'aws-cdk-lib';
import * as s3 from 'aws-cdk-lib/aws-s3';
import * as dynamodb from 'aws-cdk-lib/aws-dynamodb';

// Define a Stack
class MyStack extends cdk.Stack {
  constructor(scope: cdk.App, id: string) {
    super(scope, id);

    // Add an S3 Bucket (Construct)
    new s3.Bucket(this, 'MyBucket', {
      versioned: true,
    });

    // Add a DynamoDB Table (Construct)
    new dynamodb.Table(this, 'MyTable', {
      partitionKey: { name: 'id', type: dynamodb.AttributeType.STRING },
    });
  }
}

// Define the App
const app = new cdk.App();

// Add Stacks to the App
new MyStack(app, 'MyFirstStack');
new MyStack(app, 'MySecondStack');

How It Works:

App: The entry point is the cdk.App instance (app), which acts as the container for all the Stacks.
Stacks: Two instances of MyStack are created (MyFirstStack and MySecondStack). Each Stack is deployed as an independent unit.
Constructs: The MyStack class defines two Constructs (an S3 bucket and a DynamoDB table) within each Stack. These Constructs translate into AWS resources during deployment.

Conclusion

AWS CDK provides a powerful way to define and manage cloud infrastructure using code. By understanding the roles of Apps, Stacks, and Constructs, you can organize your resources effectively, reuse components, and scale your architecture with ease. This hierarchy simplifies infrastructure management, making it accessible for both beginners and experienced developers. Start exploring CDK to unlock its full potential for building modular and maintainable cloud solutions.