@cdklabs/cdk-appmod-catalog-blueprints 1.0.0

package/lib/utilities/cdk-nag-config.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Shared CDK Nag configuration and suppressions for AppMod Use Case Blueprints
+ *
+ * This module provides common CDK Nag suppressions that can be reused across
+ * different use cases while maintaining security best practices.
+ */
+export interface NagSuppression {
+    id: string;
+    reason: string;
+}
+/**
+ * Common suppressions that apply across multiple use cases
+ */
+export declare const COMMON_NAG_SUPPRESSIONS: NagSuppression[];
+/**
+ * Document processing specific suppressions
+ */
+export declare const DOCUMENT_PROCESSING_NAG_SUPPRESSIONS: NagSuppression[];
+/**
+ * Web application specific suppressions
+ */
+export declare const WEBAPP_NAG_SUPPRESSIONS: NagSuppression[];
+/**
+ * Frontend specific suppressions
+ */
+export declare const FRONTEND_NAG_SUPPRESSIONS: NagSuppression[];
+/**
+ * Development/testing specific suppressions
+ */
+export declare const DEVELOPMENT_NAG_SUPPRESSIONS: NagSuppression[];
+/**
+ * Production specific suppressions (stricter requirements)
+ */
+export declare const PRODUCTION_NAG_SUPPRESSIONS: NagSuppression[];
+/**
+ * Utility function to get suppressions based on use case and environment
+ */
+export declare function getNagSuppressions(useCase: 'document-processing' | 'webapp' | 'frontend' | 'common', environment?: 'development' | 'staging' | 'production'): NagSuppression[];
+/**
+ * Utility function to create custom suppressions for specific scenarios
+ */
+export declare function createCustomSuppression(id: string, reason: string): NagSuppression;

package/lib/utilities/cdk-nag-config.js

@@ -0,0 +1,194 @@
+"use strict";
+/**
+ * Shared CDK Nag configuration and suppressions for AppMod Use Case Blueprints
+ *
+ * This module provides common CDK Nag suppressions that can be reused across
+ * different use cases while maintaining security best practices.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PRODUCTION_NAG_SUPPRESSIONS = exports.DEVELOPMENT_NAG_SUPPRESSIONS = exports.FRONTEND_NAG_SUPPRESSIONS = exports.WEBAPP_NAG_SUPPRESSIONS = exports.DOCUMENT_PROCESSING_NAG_SUPPRESSIONS = exports.COMMON_NAG_SUPPRESSIONS = void 0;
+exports.getNagSuppressions = getNagSuppressions;
+exports.createCustomSuppression = createCustomSuppression;
+/**
+ * Common suppressions that apply across multiple use cases
+ */
+exports.COMMON_NAG_SUPPRESSIONS = [
+    {
+        id: 'AwsSolutions-IAM4',
+        reason: 'AWS managed policies provide appropriate permissions and are maintained by AWS',
+    },
+    {
+        id: 'AwsSolutions-L1',
+        reason: 'Lambda runtime versions are managed at the application deployment level',
+    },
+];
+/**
+ * Document processing specific suppressions
+ */
+exports.DOCUMENT_PROCESSING_NAG_SUPPRESSIONS = [
+    ...exports.COMMON_NAG_SUPPRESSIONS,
+    {
+        id: 'AwsSolutions-S3-1',
+        reason: 'Document processing bucket requires controlled public access for result delivery',
+    },
+    {
+        id: 'AwsSolutions-S3-2',
+        reason: 'Public read access is managed by application-level security controls',
+    },
+    {
+        id: 'AwsSolutions-IAM5',
+        reason: 'Document processing requires broad permissions across multiple AWS services (S3, Textract, SQS, Step Functions)',
+    },
+    {
+        id: 'AwsSolutions-SQS3',
+        reason: 'Dead letter queue configuration is handled by the base document processor',
+    },
+    {
+        id: 'AwsSolutions-SF1',
+        reason: 'Step Functions logging configuration is environment-specific',
+    },
+    {
+        id: 'AwsSolutions-SF2',
+        reason: 'X-Ray tracing is configured based on monitoring requirements',
+    },
+];
+/**
+ * Web application specific suppressions
+ */
+exports.WEBAPP_NAG_SUPPRESSIONS = [
+    ...exports.COMMON_NAG_SUPPRESSIONS,
+    {
+        id: 'AwsSolutions-ECS2',
+        reason: 'Environment variables are managed securely through configuration management',
+    },
+    {
+        id: 'AwsSolutions-ECS4',
+        reason: 'Container insights are enabled based on monitoring requirements and cost considerations',
+    },
+    {
+        id: 'AwsSolutions-IAM5',
+        reason: 'Web application requires broad permissions for ECS, RDS, and other AWS service integration',
+    },
+    {
+        id: 'AwsSolutions-ELB2',
+        reason: 'Load balancer access logging is configured based on compliance requirements',
+    },
+    {
+        id: 'AwsSolutions-RDS2',
+        reason: 'Database encryption is configured based on data sensitivity classification',
+    },
+    {
+        id: 'AwsSolutions-RDS3',
+        reason: 'Multi-AZ configuration is based on availability SLA requirements',
+    },
+    {
+        id: 'AwsSolutions-RDS6',
+        reason: 'Database authentication method is chosen based on application architecture',
+    },
+    {
+        id: 'AwsSolutions-RDS10',
+        reason: 'Database deletion protection is managed through deployment automation',
+    },
+    {
+        id: 'AwsSolutions-RDS11',
+        reason: 'Standard database ports are acceptable within VPC security boundaries',
+    },
+    {
+        id: 'AwsSolutions-SMG4',
+        reason: 'Secrets rotation policy is configured per organizational security standards',
+    },
+];
+/**
+ * Frontend specific suppressions
+ */
+exports.FRONTEND_NAG_SUPPRESSIONS = [
+    ...exports.COMMON_NAG_SUPPRESSIONS,
+    {
+        id: 'AwsSolutions-CFR1',
+        reason: 'CloudFront geo restrictions are configured based on application requirements',
+    },
+    {
+        id: 'AwsSolutions-CFR2',
+        reason: 'CloudFront WAF integration is configured based on security requirements',
+    },
+    {
+        id: 'AwsSolutions-CFR3',
+        reason: 'CloudFront access logging is configured based on compliance requirements',
+    },
+    {
+        id: 'AwsSolutions-CFR4',
+        reason: 'CloudFront viewer protocol policy is set to redirect-to-https for security',
+    },
+    {
+        id: 'AwsSolutions-S1',
+        reason: 'S3 bucket access logging is configured based on compliance requirements',
+    },
+    {
+        id: 'AwsSolutions-S2',
+        reason: 'S3 bucket public access is blocked and access is controlled via CloudFront OAC',
+    },
+    {
+        id: 'AwsSolutions-S3',
+        reason: 'S3 bucket SSL requests only policy is enforced via CloudFront HTTPS redirect',
+    },
+    {
+        id: 'AwsSolutions-S10',
+        reason: 'S3 bucket MFA delete is managed through organizational security policies',
+    },
+];
+/**
+ * Development/testing specific suppressions
+ */
+exports.DEVELOPMENT_NAG_SUPPRESSIONS = [
+    {
+        id: 'AwsSolutions-RDS3',
+        reason: 'Multi-AZ not required for development environments',
+    },
+    {
+        id: 'AwsSolutions-ELB2',
+        reason: 'Access logging not required for development load balancers',
+    },
+    {
+        id: 'AwsSolutions-CFR3',
+        reason: 'CloudFront access logging not required for development environments',
+    },
+];
+/**
+ * Production specific suppressions (stricter requirements)
+ */
+exports.PRODUCTION_NAG_SUPPRESSIONS = [
+// Production environments should have minimal suppressions
+// Most security controls should be enabled
+];
+/**
+ * Utility function to get suppressions based on use case and environment
+ */
+function getNagSuppressions(useCase, environment = 'production') {
+    let suppressions = [];
+    switch (useCase) {
+        case 'document-processing':
+            suppressions = [...exports.DOCUMENT_PROCESSING_NAG_SUPPRESSIONS];
+            break;
+        case 'webapp':
+            suppressions = [...exports.WEBAPP_NAG_SUPPRESSIONS];
+            break;
+        case 'frontend':
+            suppressions = [...exports.FRONTEND_NAG_SUPPRESSIONS];
+            break;
+        case 'common':
+            suppressions = [...exports.COMMON_NAG_SUPPRESSIONS];
+            break;
+    }
+    // Add environment-specific suppressions
+    if (environment === 'development') {
+        suppressions = [...suppressions, ...exports.DEVELOPMENT_NAG_SUPPRESSIONS];
+    }
+    return suppressions;
+}
+/**
+ * Utility function to create custom suppressions for specific scenarios
+ */
+function createCustomSuppression(id, reason) {
+    return { id, reason };
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"cdk-nag-config.js","sourceRoot":"","sources":["../../use-cases/utilities/cdk-nag-config.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Shared CDK Nag configuration and suppressions for AppMod Use Case Blueprints\n *\n * This module provides common CDK Nag suppressions that can be reused across\n * different use cases while maintaining security best practices.\n */\n\nexport interface NagSuppression {\n  id: string;\n  reason: string;\n}\n\n/**\n * Common suppressions that apply across multiple use cases\n */\nexport const COMMON_NAG_SUPPRESSIONS: NagSuppression[] = [\n  {\n    id: 'AwsSolutions-IAM4',\n    reason: 'AWS managed policies provide appropriate permissions and are maintained by AWS',\n  },\n  {\n    id: 'AwsSolutions-L1',\n    reason: 'Lambda runtime versions are managed at the application deployment level',\n  },\n];\n\n/**\n * Document processing specific suppressions\n */\nexport const DOCUMENT_PROCESSING_NAG_SUPPRESSIONS: NagSuppression[] = [\n  ...COMMON_NAG_SUPPRESSIONS,\n  {\n    id: 'AwsSolutions-S3-1',\n    reason: 'Document processing bucket requires controlled public access for result delivery',\n  },\n  {\n    id: 'AwsSolutions-S3-2',\n    reason: 'Public read access is managed by application-level security controls',\n  },\n  {\n    id: 'AwsSolutions-IAM5',\n    reason: 'Document processing requires broad permissions across multiple AWS services (S3, Textract, SQS, Step Functions)',\n  },\n  {\n    id: 'AwsSolutions-SQS3',\n    reason: 'Dead letter queue configuration is handled by the base document processor',\n  },\n  {\n    id: 'AwsSolutions-SF1',\n    reason: 'Step Functions logging configuration is environment-specific',\n  },\n  {\n    id: 'AwsSolutions-SF2',\n    reason: 'X-Ray tracing is configured based on monitoring requirements',\n  },\n];\n\n/**\n * Web application specific suppressions\n */\nexport const WEBAPP_NAG_SUPPRESSIONS: NagSuppression[] = [\n  ...COMMON_NAG_SUPPRESSIONS,\n  {\n    id: 'AwsSolutions-ECS2',\n    reason: 'Environment variables are managed securely through configuration management',\n  },\n  {\n    id: 'AwsSolutions-ECS4',\n    reason: 'Container insights are enabled based on monitoring requirements and cost considerations',\n  },\n  {\n    id: 'AwsSolutions-IAM5',\n    reason: 'Web application requires broad permissions for ECS, RDS, and other AWS service integration',\n  },\n  {\n    id: 'AwsSolutions-ELB2',\n    reason: 'Load balancer access logging is configured based on compliance requirements',\n  },\n  {\n    id: 'AwsSolutions-RDS2',\n    reason: 'Database encryption is configured based on data sensitivity classification',\n  },\n  {\n    id: 'AwsSolutions-RDS3',\n    reason: 'Multi-AZ configuration is based on availability SLA requirements',\n  },\n  {\n    id: 'AwsSolutions-RDS6',\n    reason: 'Database authentication method is chosen based on application architecture',\n  },\n  {\n    id: 'AwsSolutions-RDS10',\n    reason: 'Database deletion protection is managed through deployment automation',\n  },\n  {\n    id: 'AwsSolutions-RDS11',\n    reason: 'Standard database ports are acceptable within VPC security boundaries',\n  },\n  {\n    id: 'AwsSolutions-SMG4',\n    reason: 'Secrets rotation policy is configured per organizational security standards',\n  },\n];\n\n/**\n * Frontend specific suppressions\n */\nexport const FRONTEND_NAG_SUPPRESSIONS: NagSuppression[] = [\n  ...COMMON_NAG_SUPPRESSIONS,\n  {\n    id: 'AwsSolutions-CFR1',\n    reason: 'CloudFront geo restrictions are configured based on application requirements',\n  },\n  {\n    id: 'AwsSolutions-CFR2',\n    reason: 'CloudFront WAF integration is configured based on security requirements',\n  },\n  {\n    id: 'AwsSolutions-CFR3',\n    reason: 'CloudFront access logging is configured based on compliance requirements',\n  },\n  {\n    id: 'AwsSolutions-CFR4',\n    reason: 'CloudFront viewer protocol policy is set to redirect-to-https for security',\n  },\n  {\n    id: 'AwsSolutions-S1',\n    reason: 'S3 bucket access logging is configured based on compliance requirements',\n  },\n  {\n    id: 'AwsSolutions-S2',\n    reason: 'S3 bucket public access is blocked and access is controlled via CloudFront OAC',\n  },\n  {\n    id: 'AwsSolutions-S3',\n    reason: 'S3 bucket SSL requests only policy is enforced via CloudFront HTTPS redirect',\n  },\n  {\n    id: 'AwsSolutions-S10',\n    reason: 'S3 bucket MFA delete is managed through organizational security policies',\n  },\n];\n\n/**\n * Development/testing specific suppressions\n */\nexport const DEVELOPMENT_NAG_SUPPRESSIONS: NagSuppression[] = [\n  {\n    id: 'AwsSolutions-RDS3',\n    reason: 'Multi-AZ not required for development environments',\n  },\n  {\n    id: 'AwsSolutions-ELB2',\n    reason: 'Access logging not required for development load balancers',\n  },\n  {\n    id: 'AwsSolutions-CFR3',\n    reason: 'CloudFront access logging not required for development environments',\n  },\n];\n\n/**\n * Production specific suppressions (stricter requirements)\n */\nexport const PRODUCTION_NAG_SUPPRESSIONS: NagSuppression[] = [\n  // Production environments should have minimal suppressions\n  // Most security controls should be enabled\n];\n\n/**\n * Utility function to get suppressions based on use case and environment\n */\nexport function getNagSuppressions(\n  useCase: 'document-processing' | 'webapp' | 'frontend' | 'common',\n  environment: 'development' | 'staging' | 'production' = 'production',\n): NagSuppression[] {\n  let suppressions: NagSuppression[] = [];\n\n  switch (useCase) {\n    case 'document-processing':\n      suppressions = [...DOCUMENT_PROCESSING_NAG_SUPPRESSIONS];\n      break;\n    case 'webapp':\n      suppressions = [...WEBAPP_NAG_SUPPRESSIONS];\n      break;\n    case 'frontend':\n      suppressions = [...FRONTEND_NAG_SUPPRESSIONS];\n      break;\n    case 'common':\n      suppressions = [...COMMON_NAG_SUPPRESSIONS];\n      break;\n  }\n\n  // Add environment-specific suppressions\n  if (environment === 'development') {\n    suppressions = [...suppressions, ...DEVELOPMENT_NAG_SUPPRESSIONS];\n  }\n\n  return suppressions;\n}\n\n/**\n * Utility function to create custom suppressions for specific scenarios\n */\nexport function createCustomSuppression(id: string, reason: string): NagSuppression {\n  return { id, reason };\n}\n"]}

package/lib/utilities/data-loader-lambda/index.py

@@ -0,0 +1,282 @@
+#!/usr/bin/env python3
+"""
+DataLoader Lambda Function
+
+This Lambda function processes individual files from S3 and loads them into the database.
+It's called by Step Functions for each file that needs to be processed.
+"""
+
+import json
+import os
+import logging
+import boto3
+import pymysql
+import psycopg2
+from typing import Dict, Any, Optional
+import tempfile
+import re
+
+# Configure logging
+logger = logging.getLogger()
+logger.setLevel(logging.INFO)
+
+# Initialize AWS clients
+s3_client = boto3.client('s3')
+secrets_client = boto3.client('secretsmanager')
+
+class DatabaseConnection:
+    """Handles database connections for MySQL and PostgreSQL"""
+    
+    def __init__(self, engine: str, connection_params: Dict[str, Any]):
+        self.engine = engine.lower()
+        self.connection_params = connection_params
+        self.connection = None
+    
+    def connect(self):
+        """Establish database connection"""
+        try:
+            if self.engine == 'mysql':
+                self.connection = pymysql.connect(
+                    host=self.connection_params['host'],
+                    port=self.connection_params.get('port', 3306),
+                    user=self.connection_params['username'],
+                    password=self.connection_params['password'],
+                    database=self.connection_params['database'],
+                    charset='utf8mb4',
+                    autocommit=False
+                )
+            elif self.engine == 'postgresql':
+                self.connection = psycopg2.connect(
+                    host=self.connection_params['host'],
+                    port=self.connection_params.get('port', 5432),
+                    user=self.connection_params['username'],
+                    password=self.connection_params['password'],
+                    database=self.connection_params['database']
+                )
+                self.connection.autocommit = False
+            else:
+                raise ValueError(f"Unsupported database engine: {self.engine}")
+            
+            logger.info(f"Successfully connected to {self.engine} database")
+            
+        except Exception as e:
+            logger.error(f"Failed to connect to database: {str(e)}")
+            raise
+    
+    def execute_sql_file(self, file_content: str) -> Dict[str, Any]:
+        """Execute SQL content from file against the database as a single operation"""
+        if not self.connection:
+            raise RuntimeError("Database connection not established")
+        
+        results = {
+            'success': True,
+            'file_executed': True,
+            'errors': []
+        }
+        
+        try:            
+            if not file_content.strip():
+                logger.info("No SQL content to execute after cleaning")
+                return results
+            
+            logger.info("Executing entire SQL file content as a single transaction")
+            
+            # Execute the entire file content at once using the appropriate method for each database
+            if self.engine == 'postgresql':
+                self._execute_postgresql_file(file_content)
+            elif self.engine == 'mysql':
+                self._execute_mysql_file(file_content)
+            
+            logger.info("Successfully executed SQL file content")
+            
+        except Exception as e:
+            logger.error(f"Failed to execute SQL file: {str(e)}")
+            results['success'] = False
+            results['file_executed'] = False
+            results['errors'].append(str(e))
+            raise
+        
+        return results
+    
+    def _execute_postgresql_file(self, sql_content: str):
+        """Execute PostgreSQL file content as a single operation"""
+        cursor = self.connection.cursor()
+        try:
+            # PostgreSQL can handle multiple statements in a single execute call
+            cursor.execute(sql_content)
+            self.connection.commit()
+        except Exception as e:
+            self.connection.rollback()
+            raise
+        finally:
+            cursor.close()
+    
+    def _execute_mysql_file(self, sql_content: str):
+        """Execute MySQL file content as a single transaction"""
+        cursor = self.connection.cursor()
+        try:
+            # For MySQL, we need to split statements but execute them all in one transaction
+            statements = self._split_sql_statements(sql_content)
+            
+            # Execute all statements in a single transaction
+            for statement in statements:
+                statement = statement.strip()
+                if statement and not statement.startswith('--'):
+                    cursor.execute(statement)
+            
+            # Commit all changes as one transaction
+            self.connection.commit()
+        except Exception as e:
+            self.connection.rollback()
+            raise
+        finally:
+            cursor.close()
+    
+    def _split_sql_statements(self, sql_content: str) -> list:
+        """Split SQL content into individual statements"""
+        # Remove comments
+        sql_content = re.sub(r'--.*?\n', '\n', sql_content)
+        sql_content = re.sub(r'/\*.*?\*/', '', sql_content, flags=re.DOTALL)
+        
+        # Split by semicolon, but be careful with strings and functions
+        statements = []
+        current_statement = ""
+        in_string = False
+        string_char = None
+        
+        i = 0
+        while i < len(sql_content):
+            char = sql_content[i]
+            
+            if not in_string and char in ["'", '"']:
+                in_string = True
+                string_char = char
+            elif in_string and char == string_char:
+                # Check if it's escaped
+                if i > 0 and sql_content[i-1] != '\\':
+                    in_string = False
+                    string_char = None
+            elif not in_string and char == ';':
+                current_statement += char
+                if current_statement.strip():
+                    statements.append(current_statement.strip())
+                current_statement = ""
+                i += 1
+                continue
+            
+            current_statement += char
+            i += 1
+        
+        # Add the last statement if it doesn't end with semicolon
+        if current_statement.strip():
+            statements.append(current_statement.strip())
+        
+        return statements
+    
+    def close(self):
+        """Close database connection"""
+        if self.connection:
+            self.connection.close()
+            logger.info("Database connection closed")
+
+def get_database_credentials(secret_arn: str) -> Dict[str, Any]:
+    """Retrieve database credentials from AWS Secrets Manager"""
+    try:
+        response = secrets_client.get_secret_value(SecretId=secret_arn)
+        secret_data = json.loads(response['SecretString'])
+        
+        return {
+            'host': secret_data.get('host'),
+            'port': secret_data.get('port'),
+            'username': secret_data.get('username'),
+            'password': secret_data.get('password'),
+            'database': os.environ.get('DATABASE_NAME')
+        }
+    
+    except Exception as e:
+        logger.error(f"Failed to retrieve database credentials: {str(e)}")
+        raise
+
+def download_file_from_s3(bucket_name: str, s3_key: str) -> str:
+    """Download file from S3 and return its content"""
+    try:
+        logger.info(f"Downloading file s3://{bucket_name}/{s3_key}")
+        
+        # Create temporary file
+        temp_file = tempfile.NamedTemporaryFile(delete=False, suffix='.sql')
+        temp_file_path = temp_file.name
+        temp_file.close()
+        
+        # Download file
+        s3_client.download_file(bucket_name, s3_key, temp_file_path)
+        
+        # Read file content
+        with open(temp_file_path, 'r', encoding='utf-8') as f:
+            content = f.read()
+        
+        # Clean up temporary file
+        os.unlink(temp_file_path)
+        
+        logger.info(f"Successfully downloaded and read file {s3_key}")
+        return content
+        
+    except Exception as e:
+        logger.error(f"Failed to download file {s3_key}: {str(e)}")
+        raise
+
+def handler(event, context):
+    """Lambda function handler"""
+    logger.info(f"Processing event: {json.dumps(event)}")
+    
+    try:
+        # Extract parameters from event
+        s3_key = event.get('s3Key')
+        bucket_name = event.get('bucketName') or os.environ.get('S3_BUCKET')
+        
+        if not s3_key:
+            raise ValueError("s3Key is required in the event payload")
+        
+        if not bucket_name:
+            raise ValueError("bucketName is required in the event payload or S3_BUCKET environment variable")
+        
+        logger.info(f"Processing file: s3://{bucket_name}/{s3_key}")
+        
+        # Download file content from S3
+        file_content = download_file_from_s3(bucket_name, s3_key)
+        
+        # Get database credentials
+        secret_arn = os.environ['DATABASE_SECRET_ARN']
+        db_credentials = get_database_credentials(secret_arn)
+        
+        # Create database connection
+        engine = os.environ['DATABASE_ENGINE']
+        db_connection = DatabaseConnection(engine, db_credentials)
+        db_connection.connect()
+        
+        try:
+            # Execute the SQL file
+            result = db_connection.execute_sql_file(file_content)
+            
+            logger.info(f"File processing completed successfully: {result}")
+            
+            return {
+                'statusCode': 200,
+                'body': {
+                    'message': 'SQL file executed successfully',
+                    's3Key': s3_key,
+                    'result': result
+                }
+            }
+        
+        finally:
+            db_connection.close()
+    
+    except Exception as e:
+        logger.error(f"Error processing file: {str(e)}")
+        return {
+            'statusCode': 500,
+            'body': {
+                'error': str(e),
+                's3Key': event.get('s3Key', 'unknown')
+            }
+        }

package/lib/utilities/data-loader-lambda/requirements.txt

@@ -0,0 +1,3 @@
+boto3>=1.26.0
+pymysql>=1.0.2
+psycopg2-binary>=2.9.5