Comprehensive comparison for DevOps technology in Software Development applications

import * as cdk from 'aws-cdk-lib';
import * as apigateway from 'aws-cdk-lib/aws-apigateway';
import * as lambda from 'aws-cdk-lib/aws-lambda';
import * as dynamodb from 'aws-cdk-lib/aws-dynamodb';
import * as logs from 'aws-cdk-lib/aws-logs';
import * as iam from 'aws-cdk-lib/aws-iam';
import { Construct } from 'constructs';

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

    // DynamoDB table for user data with point-in-time recovery
    const usersTable = new dynamodb.Table(this, 'UsersTable', {
      tableName: 'users-table',
      partitionKey: { name: 'userId', type: dynamodb.AttributeType.STRING },
      billingMode: dynamodb.BillingMode.PAY_PER_REQUEST,
      pointInTimeRecovery: true,
      removalPolicy: cdk.RemovalPolicy.RETAIN,
      encryption: dynamodb.TableEncryption.AWS_MANAGED,
      stream: dynamodb.StreamViewType.NEW_AND_OLD_IMAGES
    });

    // Add GSI for email lookups
    usersTable.addGlobalSecondaryIndex({
      indexName: 'EmailIndex',
      partitionKey: { name: 'email', type: dynamodb.AttributeType.STRING },
      projectionType: dynamodb.ProjectionType.ALL
    });

    // Lambda execution role with least privilege
    const lambdaRole = new iam.Role(this, 'UserApiLambdaRole', {
      assumedBy: new iam.ServicePrincipal('lambda.amazonaws.com'),
      managedPolicies: [
        iam.ManagedPolicy.fromAwsManagedPolicyName('service-role/AWSLambdaBasicExecutionRole')
      ]
    });

    // Lambda function for user operations
    const userApiFunction = new lambda.Function(this, 'UserApiFunction', {
      runtime: lambda.Runtime.NODEJS_18_X,
      handler: 'index.handler',
      code: lambda.Code.fromInline(`
        const { DynamoDBClient, PutItemCommand, GetItemCommand, UpdateItemCommand } = require('@aws-sdk/client-dynamodb');
        const { marshall, unmarshall } = require('@aws-sdk/util-dynamodb');
        const client = new DynamoDBClient({});
        
        exports.handler = async (event) => {
          try {
            const method = event.httpMethod;
            const path = event.path;
            
            if (method === 'POST' && path === '/users') {
              const body = JSON.parse(event.body);
              if (!body.email || !body.name) {
                return { statusCode: 400, body: JSON.stringify({ error: 'Missing required fields' }) };
              }
              const userId = Date.now().toString();
              await client.send(new PutItemCommand({
                TableName: process.env.TABLE_NAME,
                Item: marshall({ userId, ...body, createdAt: new Date().toISOString() })
              }));
              return { statusCode: 201, body: JSON.stringify({ userId, message: 'User created' }) };
            }
            
            if (method === 'GET' && path.startsWith('/users/')) {
              const userId = path.split('/')[2];
              const result = await client.send(new GetItemCommand({
                TableName: process.env.TABLE_NAME,
                Key: marshall({ userId })
              }));
              if (!result.Item) {
                return { statusCode: 404, body: JSON.stringify({ error: 'User not found' }) };
              }
              return { statusCode: 200, body: JSON.stringify(unmarshall(result.Item)) };
            }
            
            return { statusCode: 400, body: JSON.stringify({ error: 'Invalid request' }) };
          } catch (error) {
            console.error('Error:', error);
            return { statusCode: 500, body: JSON.stringify({ error: 'Internal server error' }) };
          }
        };
      `),
      environment: {
        TABLE_NAME: usersTable.tableName,
        NODE_OPTIONS: '--enable-source-maps'
      },
      role: lambdaRole,
      timeout: cdk.Duration.seconds(30),
      memorySize: 512,
      logRetention: logs.RetentionDays.ONE_WEEK,
      tracing: lambda.Tracing.ACTIVE
    });

    // Grant DynamoDB permissions to Lambda
    usersTable.grantReadWriteData(userApiFunction);

    // API Gateway with CloudWatch logging
    const api = new apigateway.RestApi(this, 'UserManagementApi', {
      restApiName: 'User Management Service',
      description: 'API for user CRUD operations',
      deployOptions: {
        stageName: 'prod',
        loggingLevel: apigateway.MethodLoggingLevel.INFO,
        dataTraceEnabled: true,
        metricsEnabled: true,
        tracingEnabled: true
      },
      defaultCorsPreflightOptions: {
        allowOrigins: apigateway.Cors.ALL_ORIGINS,
        allowMethods: ['GET', 'POST', 'PUT', 'DELETE'],
        allowHeaders: ['Content-Type', 'Authorization']
      }
    });

    // Lambda integration
    const integration = new apigateway.LambdaIntegration(userApiFunction, {
      proxy: true,
      allowTestInvoke: false
    });

    // API resources and methods
    const users = api.root.addResource('users');
    users.addMethod('POST', integration);
    
    const userById = users.addResource('{userId}');
    userById.addMethod('GET', integration);

    // Outputs
    new cdk.CfnOutput(this, 'ApiUrl', {
      value: api.url,
      description: 'User Management API URL'
    });

    new cdk.CfnOutput(this, 'TableName', {
      value: usersTable.tableName,
      description: 'DynamoDB Table Name'
    });
  }
}