cdk-factory 0.16.16__py3-none-any.whl → 0.17.0__py3-none-any.whl

cdk_factory/stack_library/ecs/ecs_cluster_stack.py

@@ -1,232 +0,0 @@
-"""
-ECS Cluster Stack Module
-
-Provides a dedicated stack for creating and configuring ECS clusters
-with proper configurability and explicit resource management.
-"""
-
-import logging
-from typing import Optional, Dict, Any
-
-from aws_cdk import (
-    aws_ecs as ecs,
-    aws_iam as iam,
-    CfnOutput,
-)
-from constructs import Construct
-
-from cdk_factory.configurations.stack import StackConfig
-from cdk_factory.configurations.deployment import DeploymentConfig
-from cdk_factory.configurations.workload import WorkloadConfig
-from cdk_factory.interfaces.vpc_provider_mixin import VPCProviderMixin
-from cdk_factory.configurations.resources.ecs_cluster import EcsClusterConfig
-from cdk_factory.stack.stack_module_registry import register_stack
-from cdk_factory.interfaces.istack import IStack
-
-logger = logging.getLogger(__name__)
-
-
-@register_stack("ecs_cluster_stack")
-class EcsClusterStack(IStack, VPCProviderMixin):
-    """
-    A dedicated stack for creating and managing ECS clusters.
-
-    This stack provides explicit configuration of ECS clusters including:
-    - Cluster naming
-    - Container insights
-    - Cluster settings
-    - SSM parameter exports
-    - IAM role configurations
-    """
-
-    def __init__(self, scope: Construct, id: str, **kwargs) -> None:
-        """
-        Initialize the ECS Cluster stack.
-        
-        Args:
-            scope: The CDK construct scope
-            id: The construct ID
-        """
-        super().__init__(scope, id, **kwargs)
-        
-        self._initialize_vpc_cache()
-        
-        self.ecs_config: Optional[EcsClusterConfig] = None
-        self.stack_config: Optional[StackConfig] = None
-        self.deployment: Optional[DeploymentConfig] = None
-        self.workload: Optional[WorkloadConfig] = None
-        self.ecs_cluster: Optional[ecs.Cluster] = None
-        self.instance_role: Optional[iam.Role] = None
-        self.instance_profile: Optional[iam.CfnInstanceProfile] = None
-        
-        # SSM imported values
-        self.ssm_imported_values: Dict[str, Any] = {}
-
-    
-
-    def build(
-        self,
-        stack_config: StackConfig,
-        deployment: DeploymentConfig,
-        workload: WorkloadConfig,
-    ) -> None:
-        """Build the ECS Cluster stack"""
-        self._build(stack_config, deployment, workload)
-
-    def _build(
-        self,
-        stack_config: StackConfig,
-        deployment: DeploymentConfig,
-        workload: WorkloadConfig,
-    ) -> None:
-        """Internal build method for the ECS Cluster stack"""
-        self.stack_config = stack_config
-        self.deployment = deployment
-        self.workload = workload
-        
-        # Initialize VPC cache from mixin
-        self._initialize_vpc_cache()
-        
-        # Load ECS cluster configuration
-        self.ecs_config: EcsClusterConfig = EcsClusterConfig(
-            stack_config.dictionary.get("ecs_cluster", {})
-        )
-        
-        logger.info(f"Creating ECS Cluster stack: {self.stack_name}")
-        
-        # Process SSM imports first
-        self.process_ssm_imports(self.ecs_config, deployment, "ECS Cluster")
-        
-        # Create the ECS cluster
-        self._create_ecs_cluster()
-        
-        # Create IAM roles if needed
-        self._create_iam_roles()
-        
-        # Export cluster information
-        self._export_cluster_info()
-        
-        logger.info(f"ECS Cluster stack created: {self.stack_name}")
-
-    def _create_ecs_cluster(self):
-        """Create the ECS cluster with explicit configuration."""
-        logger.info(f"Creating ECS cluster: {self.ecs_config.name}")
-
-        # Build cluster settings
-        cluster_settings = []
-
-        # Add container insights if enabled
-        if self.ecs_config.container_insights:
-            cluster_settings.append({"name": "containerInsights", "value": "enabled"})
-
-        # Add custom cluster settings
-        if self.ecs_config.cluster_settings:
-            cluster_settings.extend(self.ecs_config.cluster_settings)
-
-        # Create the ECS cluster
-        self.vpc = self.resolve_vpc(
-            config=self.ecs_config,
-            deployment=self.deployment,
-            workload=self.workload
-        )
-        
-        self.ecs_cluster = ecs.Cluster(
-            self,
-            "ECSCluster",
-            cluster_name=self.ecs_config.name,
-            vpc=self.vpc,
-            container_insights=self.ecs_config.container_insights,
-            default_cloud_map_namespace=(
-                self.ecs_config.cloud_map_namespace
-                if self.ecs_config.cloud_map_namespace
-                else None
-            ),
-            execute_command_configuration=(
-                self.ecs_config.execute_command_configuration
-                if self.ecs_config.execute_command_configuration
-                else None
-            ),
-        )
-
-        logger.info(f"Created ECS cluster: {self.ecs_config.name}")
-
-    def _create_iam_roles(self):
-        """Create IAM roles for the ECS cluster if configured."""
-        if not self.ecs_config.create_instance_role:
-            return
-
-        logger.info("Creating ECS instance role")
-
-        # Create the instance role
-        self.instance_role = iam.Role(
-            self,
-            "ECSInstanceRole",
-            assumed_by=iam.ServicePrincipal("ec2.amazonaws.com"),
-            role_name=self.ecs_config.instance_role_name
-            or f"{self.ecs_config.name}-instance-role",
-        )
-
-        # Add managed policies
-        for policy in self.ecs_config.managed_policies:
-            self.instance_role.add_managed_policy(
-                iam.ManagedPolicy.from_aws_managed_policy_name(policy)
-            )
-
-        # Add inline policies if provided
-        if self.ecs_config.inline_policies:
-            for policy_name, policy_document in self.ecs_config.inline_policies.items():
-                self.instance_role.add_to_policy(
-                    iam.PolicyStatement.from_json(policy_document)
-                )
-
-        # Create instance profile
-        self.instance_profile = iam.CfnInstanceProfile(
-            self,
-            "ECSInstanceProfile",
-            roles=[self.instance_role.role_name],
-            instance_profile_name=self.ecs_config.instance_profile_name
-            or f"{self.ecs_config.name}-instance-profile",
-        )
-
-        logger.info("Created ECS instance role and profile")
-
-    def _export_cluster_info(self):
-        """Export cluster information via SSM parameters and CloudFormation outputs."""
-        logger.info("Exporting ECS cluster information")
-
-        ssm_exports = self.ecs_config.ssm_exports
-        
-        if not ssm_exports:
-            logger.info("No SSM exports configured for ECS Cluster")
-            return
-
-        logger.info(f"Processing {len(ssm_exports)} SSM exports for ECS Cluster")
-
-        if "cluster_name" in ssm_exports:
-            self.export_ssm_parameter(
-                scope=self,
-                id="ClusterNameParam",
-                value=self.ecs_config.name,
-                parameter_name=ssm_exports["cluster_name"],
-                description=f"ECS Cluster Name: {self.ecs_config.name}",
-            )
-
-        if "cluster_arn" in ssm_exports:
-            self.export_ssm_parameter(
-                scope=self,
-                id="ClusterArnParam",
-                value=self.ecs_cluster.cluster_arn,
-                parameter_name=ssm_exports["cluster_arn"],
-                description=f"ECS Cluster ARN: {self.ecs_cluster.cluster_arn}",
-            )
-
-        if "instance_role_arn" in ssm_exports:
-            self.export_ssm_parameter(
-                scope=self,
-                id="InstanceRoleArnParam",
-                value=self.instance_role.role_arn,
-                parameter_name=ssm_exports["instance_role_arn"],
-                description=f"ECS Instance Role ARN: {self.instance_role.role_arn}",
-            )
-        
-        

cdk_factory/stack_library/vpc/vpc_stack.py

@@ -1,298 +0,0 @@
-"""
-VPC Stack Pattern for CDK-Factory
-Maintainers: Eric Wilson
-MIT License.  See Project Root for the license information.
-"""
-
-from typing import Dict, Any, List, Optional
-
-import aws_cdk as cdk
-from aws_cdk import aws_ec2 as ec2
-from aws_lambda_powertools import Logger
-from constructs import Construct
-
-from cdk_factory.configurations.deployment import DeploymentConfig
-from cdk_factory.configurations.stack import StackConfig
-from cdk_factory.configurations.resources.vpc import VpcConfig
-from cdk_factory.interfaces.istack import IStack
-from cdk_factory.interfaces.enhanced_ssm_parameter_mixin import EnhancedSsmParameterMixin
-from cdk_factory.stack.stack_module_registry import register_stack
-from cdk_factory.workload.workload_factory import WorkloadConfig
-
-logger = Logger(service="VpcStack")
-
-
-@register_stack("vpc_library_module")
-@register_stack("vpc_stack")
-class VpcStack(IStack, EnhancedSsmParameterMixin):
-    """
-    Reusable stack for AWS VPC.
-    Supports creating VPCs with customizable CIDR blocks, subnets, and networking components.
-    """
-
-    def __init__(self, scope: Construct, id: str, **kwargs) -> None:
-        super().__init__(scope, id, **kwargs)
-        self.vpc_config = None
-        self.stack_config = None
-        self.deployment = None
-        self.workload = None
-        self.vpc = None
-
-    def build(
-        self,
-        stack_config: StackConfig,
-        deployment: DeploymentConfig,
-        workload: WorkloadConfig,
-    ) -> None:
-        """Build the VPC stack"""
-        self._build(stack_config, deployment, workload)
-
-    def _build(
-        self,
-        stack_config: StackConfig,
-        deployment: DeploymentConfig,
-        workload: WorkloadConfig,
-    ) -> None:
-        """Internal build method for the VPC stack"""
-        self.stack_config = stack_config
-        self.deployment = deployment
-        self.workload = workload
-
-        self.vpc_config = VpcConfig(stack_config.dictionary.get("vpc", {}), deployment)
-        vpc_name = deployment.build_resource_name(self.vpc_config.name)
-
-        # Setup enhanced SSM integration
-        self.setup_enhanced_ssm_integration(self, self.vpc_config)
-
-        # Import any required resources from SSM
-        imported_resources = self.auto_import_resources({
-            "deployment_name": deployment.name,
-            "environment": deployment.environment,
-            "workload_name": workload.name
-        })
-        
-        if imported_resources:
-            logger.info(f"Imported resources from SSM: {list(imported_resources.keys())}")
-
-        # Create the VPC
-        self.vpc = self._create_vpc(vpc_name)
-
-        # Add outputs
-        self._add_outputs(vpc_name)
-
-    def _create_vpc(self, vpc_name: str) -> ec2.Vpc:
-        """Create a VPC with the specified configuration"""
-        # Configure subnet configuration
-        subnet_configuration = self._get_subnet_configuration()
-
-        # Configure NAT gateways
-        nat_gateway_count = self.vpc_config.nat_gateways.get("count", 1)
-
-        # Get explicit availability zones to avoid dummy AZs in pipeline synthesis
-        # When CDK synthesizes in a pipeline context, it doesn't have access to real AZs
-        # So we explicitly specify them based on the deployment region
-        availability_zones = None
-        if self.deployment:
-            region = self.deployment.region or "us-east-1"
-            # Explicitly list AZs for the region to avoid dummy values
-            max_azs = self.vpc_config.max_azs or 2
-            if region == "us-east-1":
-                availability_zones = [f"us-east-1{chr(97+i)}" for i in range(max_azs)]  # us-east-1a, us-east-1b, etc.
-            elif region == "us-east-2":
-                availability_zones = [f"us-east-2{chr(97+i)}" for i in range(max_azs)]
-            elif region == "us-west-1":
-                availability_zones = [f"us-west-1{chr(97+i)}" for i in range(max_azs)]
-            elif region == "us-west-2":
-                availability_zones = [f"us-west-2{chr(97+i)}" for i in range(max_azs)]
-        
-        # Build VPC properties
-        # Note: CDK doesn't allow both 'availability_zones' and 'max_azs' - use one or the other
-        vpc_props = {
-            "vpc_name": vpc_name,
-            "cidr": self.vpc_config.cidr,
-            "nat_gateways": nat_gateway_count,
-            "subnet_configuration": subnet_configuration,
-            "enable_dns_hostnames": self.vpc_config.enable_dns_hostnames,
-            "enable_dns_support": self.vpc_config.enable_dns_support,
-            "gateway_endpoints": (
-                {
-                    "S3": ec2.GatewayVpcEndpointOptions(
-                        service=ec2.GatewayVpcEndpointAwsService.S3
-                    )
-                }
-                if self.vpc_config.enable_s3_endpoint
-                else None
-            ),
-        }
-        
-        # Use either availability_zones or max_azs, not both
-        if availability_zones:
-            vpc_props["availability_zones"] = availability_zones
-        else:
-            vpc_props["max_azs"] = self.vpc_config.max_azs
-        
-        # Create the VPC
-        vpc = ec2.Vpc(self, vpc_name, **vpc_props)
-
-        # Add interface endpoints if specified
-        if self.vpc_config.enable_interface_endpoints:
-            self._add_interface_endpoints(vpc, self.vpc_config.interface_endpoints)
-
-        # Add tags if specified
-        for key, value in self.vpc_config.tags.items():
-            cdk.Tags.of(vpc).add(key, value)
-
-        return vpc
-
-    def _get_subnet_configuration(self) -> List[ec2.SubnetConfiguration]:
-        """Configure the subnets for the VPC"""
-        subnet_configs = []
-
-        # Public subnets
-        if self.vpc_config.public_subnets:
-            subnet_configs.append(
-                ec2.SubnetConfiguration(
-                    name=self.vpc_config.public_subnet_name,
-                    subnet_type=ec2.SubnetType.PUBLIC,
-                    cidr_mask=self.vpc_config.public_subnet_mask,
-                )
-            )
-
-        # Private subnets
-        if self.vpc_config.private_subnets:
-            subnet_configs.append(
-                ec2.SubnetConfiguration(
-                    name=self.vpc_config.private_subnet_name,
-                    subnet_type=ec2.SubnetType.PRIVATE_WITH_EGRESS,
-                    cidr_mask=self.vpc_config.private_subnet_mask,
-                )
-            )
-
-        # Isolated subnets
-        if self.vpc_config.isolated_subnets:
-            subnet_configs.append(
-                ec2.SubnetConfiguration(
-                    name=self.vpc_config.isolated_subnet_name,
-                    subnet_type=ec2.SubnetType.PRIVATE_ISOLATED,
-                    cidr_mask=self.vpc_config.isolated_subnet_mask,
-                )
-            )
-
-        return subnet_configs
-
-    def _get_nat_gateway_configuration(self) -> Dict[str, Any]:
-        """Configure NAT gateways for the VPC"""
-        return self.vpc_config.nat_gateways
-
-    def _add_interface_endpoints(self, vpc: ec2.Vpc, endpoints: List[str]) -> None:
-        """Add interface endpoints to the VPC"""
-        # Common interface endpoints
-        endpoint_services = {
-            "ecr.api": ec2.InterfaceVpcEndpointAwsService.ECR,
-            "ecr.dkr": ec2.InterfaceVpcEndpointAwsService.ECR_DOCKER,
-            "logs": ec2.InterfaceVpcEndpointAwsService.CLOUDWATCH_LOGS,
-            "ssm": ec2.InterfaceVpcEndpointAwsService.SSM,
-            "secretsmanager": ec2.InterfaceVpcEndpointAwsService.SECRETS_MANAGER,
-            "lambda": ec2.InterfaceVpcEndpointAwsService.LAMBDA_,
-            "sts": ec2.InterfaceVpcEndpointAwsService.STS,
-        }
-
-        # Add specified endpoints
-        for endpoint in endpoints:
-            if endpoint in endpoint_services:
-                vpc.add_interface_endpoint(
-                    f"{endpoint}-endpoint", service=endpoint_services[endpoint]
-                )
-            else:
-                logger.warning(f"Unsupported interface endpoint: {endpoint}")
-
-    def _add_outputs(self, vpc_name: str) -> None:
-        """Add CloudFormation outputs for the VPC"""
-        if self.vpc:
-            cdk.CfnOutput(
-                self,
-                f"{vpc_name}-id",
-                value=self.vpc.vpc_id,
-                export_name=f"{self.deployment.build_resource_name(vpc_name)}-id",
-            )
-
-            cdk.CfnOutput(
-                self,
-                f"{vpc_name}-public-subnets",
-                value=",".join(
-                    [subnet.subnet_id for subnet in self.vpc.public_subnets]
-                ),
-                export_name=f"{self.deployment.build_resource_name(vpc_name)}-public-subnets",
-            )
-
-            if self.vpc.private_subnets:
-                cdk.CfnOutput(
-                    self,
-                    f"{vpc_name}-private-subnets",
-                    value=",".join(
-                        [subnet.subnet_id for subnet in self.vpc.private_subnets]
-                    ),
-                    export_name=f"{self.deployment.build_resource_name(vpc_name)}-private-subnets",
-                )
-
-            if hasattr(self.vpc, "isolated_subnets") and self.vpc.isolated_subnets:
-                cdk.CfnOutput(
-                    self,
-                    f"{vpc_name}-isolated-subnets",
-                    value=",".join(
-                        [subnet.subnet_id for subnet in self.vpc.isolated_subnets]
-                    ),
-                    export_name=f"{self.deployment.build_resource_name(vpc_name)}-isolated-subnets",
-                )
-
-            # Export SSM parameters if configured
-            self._export_ssm_parameters(vpc_name)
-
-    def _export_ssm_parameters(self, vpc_name: str) -> None:
-        """Export VPC resources to SSM Parameter Store using enhanced auto-export"""
-        if not self.vpc:
-            return
-
-        # Create a dictionary of VPC resources to export
-        vpc_resources = {
-            "vpc_id": self.vpc.vpc_id,
-            "vpc_cidr": self.vpc.vpc_cidr_block,
-        }
-
-        # Add subnet IDs as comma-separated lists
-        if self.vpc.public_subnets:
-            vpc_resources["public_subnet_ids"] = ",".join(
-                [subnet.subnet_id for subnet in self.vpc.public_subnets]
-            )
-
-        if self.vpc.private_subnets:
-            vpc_resources["private_subnet_ids"] = ",".join(
-                [subnet.subnet_id for subnet in self.vpc.private_subnets]
-            )
-
-        if hasattr(self.vpc, "isolated_subnets") and self.vpc.isolated_subnets:
-            vpc_resources["isolated_subnet_ids"] = ",".join(
-                [subnet.subnet_id for subnet in self.vpc.isolated_subnets]
-            )
-
-        # Use enhanced auto-export with context
-        context = {
-            "deployment_name": self.deployment.name,
-            "environment": self.deployment.environment,
-            "workload_name": self.workload.name
-        }
-        
-        exported_params = self.auto_export_resources(vpc_resources, context)
-        
-        if exported_params:
-            logger.info(f"Auto-exported VPC resources to SSM: {list(exported_params.keys())}")
-        else:
-            # Fall back to legacy method for backward compatibility
-            self.export_resource_to_ssm(
-                scope=self,
-                resource_values=vpc_resources,
-                config=self.vpc_config,
-                resource_name=vpc_name,
-                resource_type="vpc",
-                context=context
-            )