AWS CDK

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';
import { Construct } from 'constructs';
 
export class UserServiceStack extends cdk.Stack {
  constructor(scope: Construct, id: string, props?: cdk.StackProps) {
    super(scope, id, props);
 
    // DynamoDB table with production configuration
    const userTable = new dynamodb.Table(this, 'UserTable', {
      tableName: 'users',
      partitionKey: { name: 'userId', type: dynamodb.AttributeType.STRING },
      billingMode: dynamodb.BillingMode.PAY_PER_REQUEST,
      encryption: dynamodb.TableEncryption.AWS_MANAGED,
      pointInTimeRecovery: true,
      removalPolicy: cdk.RemovalPolicy.RETAIN,
    });
 
    // Lambda function with optimized configuration
    const userHandler = new lambda.Function(this, 'UserHandler', {
      runtime: lambda.Runtime.NODEJS_20_X,
      handler: 'index.handler',
      code: lambda.Code.fromAsset('lambda'),
      environment: {
        TABLE_NAME: userTable.tableName,
      },
      timeout: cdk.Duration.seconds(30),
      memorySize: 512,
      tracing: lambda.Tracing.ACTIVE,
    });
 
    // Granular permissions for DynamoDB
    userTable.grantReadWriteData(userHandler);
 
    // API Gateway with production configuration
    const api = new apigateway.RestApi(this, 'UserApi', {
      restApiName: 'User Service API',
      description: 'API for user management',
      defaultCorsPreflightOptions: {
        allowOrigins: apigateway.Cors.ALL_ORIGINS,
        allowMethods: apigateway.Cors.ALL_METHODS,
      },
      deployOptions: {
        stageName: 'prod',
        throttlingRateLimit: 1000,
        throttlingBurstLimit: 2000,
        loggingLevel: apigateway.MethodLoggingLevel.INFO,
      },
    });
 
    const users = api.root.addResource('users');
    users.addMethod('GET', new apigateway.LambdaIntegration(userHandler));
    users.addMethod('POST', new apigateway.LambdaIntegration(userHandler));
 
    const userById = users.addResource('{userId}');
    userById.addMethod('GET', new apigateway.LambdaIntegration(userHandler));
    userById.addMethod('PUT', new apigateway.LambdaIntegration(userHandler));
    userById.addMethod('DELETE', new apigateway.LambdaIntegration(userHandler));
 
    // Outputs for integration with other stacks
    new cdk.CfnOutput(this, 'ApiUrl', {
      value: api.url,
      description: 'URL of the User API',
    });
 
    new cdk.CfnOutput(this, 'TableName', {
      value: userTable.tableName,
      description: 'Name of the DynamoDB table',
    });
  }
}

import { Template, Match } from 'aws-cdk-lib/assertions';
import { UserServiceStack } from '../lib/user-service-stack';
import { App } from 'aws-cdk-lib';
 
test('DynamoDB table created with correct configuration', () => {
  const app = new App();
  const stack = new UserServiceStack(app, 'TestStack');
  const template = Template.fromStack(stack);
 
  template.hasResourceProperties('AWS::DynamoDB::Table', {
    BillingMode: 'PAY_PER_REQUEST',
    SSESpecification: {
      SSEEnabled: true,
    },
    PointInTimeRecoverySpecification: {
      PointInTimeRecoveryEnabled: true,
    },
  });
});
 
test('Lambda has correct environment variables', () => {
  const app = new App();
  const stack = new UserServiceStack(app, 'TestStack');
  const template = Template.fromStack(stack);
 
  template.hasResourceProperties('AWS::Lambda::Function', {
    Environment: {
      Variables: {
        TABLE_NAME: { Ref: Match.stringLikeRegexp('UserTable') },
      },
    },
  });
});

// Database stack
export class DatabaseStack extends cdk.Stack {
  public readonly userTable: dynamodb.Table;
 
  constructor(scope: Construct, id: string, props?: cdk.StackProps) {
    super(scope, id, props);
    
    this.userTable = new dynamodb.Table(this, 'UserTable', {
      // configuration...
    });
  }
}
 
// API stack that consumes the database
export class ApiStack extends cdk.Stack {
  constructor(scope: Construct, id: string, 
              databaseStack: DatabaseStack, 
              props?: cdk.StackProps) {
    super(scope, id, props);
 
    const handler = new lambda.Function(this, 'Handler', {
      environment: {
        TABLE_NAME: databaseStack.userTable.tableName,
      },
      // configuration...
    });
 
    databaseStack.userTable.grantReadWriteData(handler);
  }
}

export interface ApiLambdaProps {
  tableName: string;
  timeout?: cdk.Duration;
  memorySize?: number;
}
 
export class ApiLambda extends Construct {
  public readonly function: lambda.Function;
  public readonly api: apigateway.RestApi;
 
  constructor(scope: Construct, id: string, props: ApiLambdaProps) {
    super(scope, id);
 
    this.function = new lambda.Function(this, 'Function', {
      runtime: lambda.Runtime.NODEJS_20_X,
      handler: 'index.handler',
      code: lambda.Code.fromAsset('lambda'),
      environment: { TABLE_NAME: props.tableName },
      timeout: props.timeout ?? cdk.Duration.seconds(30),
      memorySize: props.memorySize ?? 512,
    });
 
    this.api = new apigateway.LambdaRestApi(this, 'Api', {
      handler: this.function,
      proxy: false,
    });
  }
}