This AWS CDK skill enables developers to architect and deploy robust cloud infrastructure using Infrastructure as Code (IaC) principles. By leveraging TypeScript or Python, it simplifies the creation of scalable serverless applications, containerized services, and automated CI/CD pipelines while adhering to AWS best practices for security, reliability, and cost optimization.

When should I use aws-cdk?

aws-cdk is useful in the following scenarios: • Architecting Serverless APIs: Rapidly deploy scalable backends using API Gateway, AWS Lambda, and DynamoDB patterns. • Static Website Hosting: Automating the setup of high-performance websites with S3, CloudFront, and Route53 integration. • Container Orchestration: Defining complex containerized environments using ECS Fargate, Load Balancers, and RDS databases. • Automated CI/CD Pipelines: Building robust deployment workflows using CodePipeline and CodeBuild for infrastructure and application code. • Security & Compliance Enforcement: Implementing IAM least privilege, VPC configurations, and resource tagging across multi-environment setups (Dev/Staging/Prod).

name	aws-cdk
description	AWS Cloud Development Kit infrastructure as code patterns and best practices for serverless, containers, and cloud-native applications

AWS CDK Skill

Infrastructure as Code (IaC) using AWS Cloud Development Kit with TypeScript/Python for building scalable cloud applications.

When to Use This Skill

Activate this skill when the user:

Requests AWS infrastructure setup
Needs serverless application architecture
Wants to define cloud resources as code
Mentions "AWS CDK", "infrastructure as code", "CloudFormation", "serverless"
Requires best practices for AWS resource management
Asks about container orchestration (ECS, EKS)
Needs API Gateway, Lambda, DynamoDB patterns

Core Capabilities

1. Common CDK Patterns

Serverless API: API Gateway + Lambda + DynamoDB
Static Website: S3 + CloudFront + Route53
Container Service: ECS Fargate + ALB + RDS
Event-Driven: EventBridge + Lambda + SQS/SNS
Data Pipeline: S3 + Lambda + Glue + Athena
CI/CD Pipeline: CodePipeline + CodeBuild + CodeDeploy

2. CDK Constructs

L1 (CloudFormation): Direct CFN resources
L2 (Curated): AWS construct library
L3 (Patterns): High-level patterns
Custom Constructs: Reusable components

3. Best Practices

Multi-environment deployment (dev, staging, prod)
Tagging and cost allocation
Security best practices (IAM, VPC, encryption)
Monitoring and logging (CloudWatch)
Resource cleanup and lifecycle management

Example Patterns

Serverless API Stack

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

export class ServerlessApiStack extends cdk.Stack {
  constructor(scope: cdk.App, id: string, props?: cdk.StackProps) {
    super(scope, id, props);

    // DynamoDB Table
    const table = new dynamodb.Table(this, 'ItemsTable', {
      partitionKey: { name: 'id', type: dynamodb.AttributeType.STRING },
      billingMode: dynamodb.BillingMode.PAY_PER_REQUEST,
      removalPolicy: cdk.RemovalPolicy.DESTROY,
    });

    // Lambda Function
    const handler = new lambda.Function(this, 'ItemsHandler', {
      runtime: lambda.Runtime.NODEJS_18_X,
      code: lambda.Code.fromAsset('lambda'),
      handler: 'index.handler',
      environment: {
        TABLE_NAME: table.tableName,
      },
    });

    table.grantReadWriteData(handler);

    // API Gateway
    const api = new apigateway.RestApi(this, 'ItemsApi', {
      restApiName: 'Items Service',
      description: 'This service manages items.',
    });

    const items = api.root.addResource('items');
    items.addMethod('GET', new apigateway.LambdaIntegration(handler));
    items.addMethod('POST', new apigateway.LambdaIntegration(handler));

    const item = items.addResource('{id}');
    item.addMethod('GET', new apigateway.LambdaIntegration(handler));
    item.addMethod('PUT', new apigateway.LambdaIntegration(handler));
    item.addMethod('DELETE', new apigateway.LambdaIntegration(handler));
  }
}

Static Website with CloudFront

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

export class StaticWebsiteStack extends cdk.Stack {
  constructor(scope: cdk.App, id: string, props?: cdk.StackProps) {
    super(scope, id, props);

    // S3 Bucket
    const siteBucket = new s3.Bucket(this, 'SiteBucket', {
      websiteIndexDocument: 'index.html',
      websiteErrorDocument: 'error.html',
      publicReadAccess: true,
      removalPolicy: cdk.RemovalPolicy.DESTROY,
      autoDeleteObjects: true,
    });

    // CloudFront Distribution
    const distribution = new cloudfront.CloudFrontWebDistribution(this, 'SiteDistribution', {
      originConfigs: [{
        s3OriginSource: {
          s3BucketSource: siteBucket,
        },
        behaviors: [{ isDefaultBehavior: true }],
      }],
    });

    // Deploy site contents
    new s3deploy.BucketDeployment(this, 'DeployWebsite', {
      sources: [s3deploy.Source.asset('./website')],
      destinationBucket: siteBucket,
      distribution,
      distributionPaths: ['/*'],
    });

    new cdk.CfnOutput(this, 'DistributionDomainName', {
      value: distribution.distributionDomainName,
    });
  }
}

Best Practices

Do's

✅ Use typed constructs (TypeScript recommended)
✅ Separate stacks by lifecycle and team ownership
✅ Tag all resources for cost tracking
✅ Use environment variables for configuration
✅ Implement proper IAM least privilege
✅ Enable CloudWatch logs and metrics
✅ Use CDK context for environment-specific values
✅ Version lock your CDK dependencies

Don'ts

❌ Don't hardcode sensitive values (use Secrets Manager)
❌ Don't create circular dependencies between stacks
❌ Don't forget to set removal policies
❌ Don't ignore CDK security warnings
❌ Don't deploy to production without testing

Resources

AWS CDK Docs: https://docs.aws.amazon.com/cdk/
CDK Patterns: https://cdkpatterns.com/
AWS Construct Library: https://docs.aws.amazon.com/cdk/api/v2/

aws-cdk

When & Why to Use This Skill

Use Cases