cdk-factory 0.15.10__py3-none-any.whl → 0.18.9__py3-none-any.whl

cdk_factory/stack_library/ecs/ecs_cluster_stack.py

@@ -0,0 +1,316 @@
+"""
+ECS Cluster Stack Module (Standardized SSM Version)
+
+Provides a dedicated stack for creating and configuring ECS clusters
+with proper configurability, explicit resource management, and standardized SSM integration.
+"""
+
+import logging
+from typing import Optional, Dict, Any
+
+from aws_cdk import (
+    aws_ecs as ecs,
+    aws_ec2 as ec2,
+    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.interfaces.standardized_ssm_mixin import StandardizedSsmMixin
+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, StandardizedSsmMixin):
+    """
+    A dedicated stack for creating and managing ECS clusters with standardized SSM integration.
+
+    This stack provides explicit configuration of ECS clusters including:
+    - Cluster naming
+    - Container insights
+    - Cluster settings
+    - Standardized SSM parameter exports
+    - IAM role configurations
+    - Template variable resolution
+    - Comprehensive validation
+    """
+
+    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
+
+    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 with full stack config for SSM access
+        ecs_cluster_dict = stack_config.dictionary.get("ecs_cluster", {})
+        # Merge SSM config from root level into ECS config for VPC resolution
+        if "ssm" in stack_config.dictionary:
+            ecs_cluster_dict["ssm"] = stack_config.dictionary["ssm"]
+        
+        self.ecs_config: EcsClusterConfig = EcsClusterConfig(ecs_cluster_dict)
+        
+        cluster_name = deployment.build_resource_name(self.ecs_config.name)
+        
+        logger.info(f"Creating ECS Cluster stack: {cluster_name}")
+        
+        # Setup standardized SSM integration
+        self.setup_ssm_integration(
+            scope=self,
+            config=self.ecs_config,
+            resource_type="ecs_cluster",
+            resource_name=cluster_name,
+            deployment=deployment,
+            workload=workload
+        )
+
+        # Process SSM imports using standardized method
+        self.process_ssm_imports()
+        
+        # Create the ECS cluster
+        self._create_ecs_cluster()
+        
+        # Create IAM roles if needed
+        self._create_iam_roles()
+        
+        # Export cluster information
+        self._export_cluster_info()
+        
+        # Export SSM parameters
+        logger.info("Starting SSM parameter export for ECS cluster")
+        self._export_ssm_parameters()
+        logger.info("Completed SSM parameter export for ECS cluster")
+        
+        logger.info(f"ECS Cluster stack created: {cluster_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)
+
+        # Get VPC using standardized approach
+        self.vpc = self._get_vpc()
+        
+        # Create the ECS cluster
+        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"ECS cluster created: {self.ecs_config.name}")
+
+    def _get_vpc(self):
+        """
+        Get VPC using the centralized VPC provider mixin.
+        """
+        
+        # Use the stack_config (not ecs_config) to ensure SSM imports are available
+        return self.resolve_vpc(
+            config=self.ecs_config,
+            deployment=self.deployment,
+            workload=self.workload
+        )
+
+    def _create_iam_roles(self):
+        """Create IAM roles for the ECS cluster if configured."""
+        logger.info(f"create_instance_role setting: {self.ecs_config.create_instance_role}")
+        
+        if not self.ecs_config.create_instance_role:
+            logger.info("Skipping instance role creation (disabled in config)")
+            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"),
+            managed_policies=[
+                iam.ManagedPolicy.from_aws_managed_policy_name("service-role/AmazonEC2ContainerServiceforEC2Role"),
+                iam.ManagedPolicy.from_aws_managed_policy_name("AmazonEC2ContainerRegistryReadOnly"),
+                iam.ManagedPolicy.from_aws_managed_policy_name("AmazonSSMManagedInstanceCore"),
+            ],
+            role_name=f"{self.ecs_config.name}-ecs-instance-role",
+        )
+
+        logger.info(f"Created ECS instance role: {self.instance_role.role_name}")
+
+        # Create instance profile
+        self.instance_profile = iam.CfnInstanceProfile(
+            self,
+            "ECSInstanceProfile",
+            instance_profile_name=f"{self.ecs_config.name}-ecs-instance-profile",
+            roles=[self.instance_role.role_name],
+        )
+
+        logger.info(f"Created ECS instance profile: {self.instance_profile.instance_profile_name}")
+
+        logger.info("ECS instance role and profile created")
+
+    def _export_cluster_info(self):
+        """Export cluster information as CloudFormation outputs."""
+        if not self.ecs_cluster:
+            return
+
+        cluster_name = self.deployment.build_resource_name(self.ecs_config.name)
+
+        # Export cluster name
+        CfnOutput(
+            self,
+            f"{cluster_name}-ClusterName",
+            value=self.ecs_cluster.cluster_name,
+            description=f"ECS Cluster Name for {cluster_name}",
+            export_name=f"{self.deployment.workload_name}-{self.deployment.environment}-ecs-cluster-name",
+        )
+
+        # Export cluster ARN
+        CfnOutput(
+            self,
+            f"{cluster_name}-ClusterArn",
+            value=self.ecs_cluster.cluster_arn,
+            description=f"ECS Cluster ARN for {cluster_name}",
+            export_name=f"{self.deployment.workload_name}-{self.deployment.environment}-ecs-cluster-arn",
+        )
+
+        # Export security group if available
+        if hasattr(self.ecs_cluster, 'connections') and self.ecs_cluster.connections:
+            security_groups = self.ecs_cluster.connections.security_groups
+            if security_groups:
+                CfnOutput(
+                    self,
+                    f"{cluster_name}-SecurityGroupId",
+                    value=security_groups[0].security_group_id,
+                    description=f"ECS Cluster Security Group ID for {cluster_name}",
+                    export_name=f"{self.deployment.workload_name}-{self.deployment.environment}-ecs-cluster-sg-id",
+                )
+
+        # Export instance profile if created
+        if self.instance_profile:
+            CfnOutput(
+                self,
+                f"{cluster_name}-InstanceProfileArn",
+                value=self.instance_profile.attr_arn,
+                description=f"ECS Instance Profile ARN for {cluster_name}",
+                export_name=f"{self.deployment.workload_name}-{self.deployment.environment}-ecs-instance-profile-arn",
+            )
+
+        logger.info("ECS cluster information exported as outputs")
+
+    def _export_ssm_parameters(self) -> None:
+        """Export SSM parameters using standardized approach"""
+        logger.info("=== Starting SSM Parameter Export ===")
+        
+        if not self.ecs_cluster:
+            logger.warning("No ECS cluster to export")
+            return
+
+        logger.info(f"ECS cluster found: {self.ecs_cluster.cluster_name}")
+        logger.info(f"SSM exports configured: {self.ssm_config.get('exports', {})}")
+
+        # Prepare resource values for export
+        resource_values = {
+            "cluster_name": self.ecs_cluster.cluster_name,
+            "cluster_arn": self.ecs_cluster.cluster_arn,
+        }
+        
+        # Add instance role ARN if created
+        if self.instance_role:
+            resource_values["instance_role_arn"] = self.instance_role.role_arn
+            logger.info(f"Instance role ARN added: {self.instance_role.role_name}")
+        else:
+            logger.info("No instance role to export")
+        
+        # Add security group ID if available
+        if hasattr(self.ecs_cluster, 'connections') and self.ecs_cluster.connections:
+            security_groups = self.ecs_cluster.connections.security_groups
+            if security_groups:
+                resource_values["security_group_id"] = security_groups[0].security_group_id
+                logger.info(f"Security group ID added: {security_groups[0].security_group_id}")
+        
+        # Add instance profile ARN if created
+        if self.instance_profile:
+            resource_values["instance_profile_arn"] = self.instance_profile.attr_arn
+            logger.info(f"Instance profile ARN added: {self.instance_profile.instance_profile_name}")
+
+        # Export using standardized SSM mixin
+        logger.info(f"Resource values available for export: {list(resource_values.keys())}")
+        for key, value in resource_values.items():
+            logger.info(f"  {key}: {value}")
+            
+        try:
+            exported_params = self.export_ssm_parameters(resource_values)
+            logger.info(f"Successfully exported SSM parameters: {exported_params}")
+        except Exception as e:
+            logger.error(f"Failed to export SSM parameters: {str(e)}")
+            raise
+
+    # Backward compatibility alias
+EcsClusterStackStandardized = EcsClusterStack

cdk_factory/stack_library/ecs/ecs_service_stack.py

@@ -23,7 +23,8 @@ from cdk_factory.configurations.deployment import DeploymentConfig
 from cdk_factory.configurations.stack import StackConfig
 from cdk_factory.configurations.resources.ecs_service import EcsServiceConfig
 from cdk_factory.interfaces.istack import IStack
-from cdk_factory.interfaces.enhanced_ssm_parameter_mixin import EnhancedSsmParameterMixin
+from cdk_factory.interfaces.vpc_provider_mixin import VPCProviderMixin
+from cdk_factory.interfaces.standardized_ssm_mixin import StandardizedSsmMixin
 from cdk_factory.stack.stack_module_registry import register_stack
 from cdk_factory.workload.workload_factory import WorkloadConfig
 
@@ -33,7 +34,7 @@ logger = Logger(service="EcsServiceStack")
 @register_stack("ecs_service_library_module")
 @register_stack("ecs_service_stack")
 @register_stack("fargate_service_stack")
-class EcsServiceStack(IStack, EnhancedSsmParameterMixin):
+class EcsServiceStack(IStack, VPCProviderMixin, StandardizedSsmMixin):
     """
     Reusable stack for ECS/Fargate services with Docker container support.
     Supports blue-green deployments, maintenance mode, and auto-scaling.
@@ -47,7 +48,7 @@ class EcsServiceStack(IStack, EnhancedSsmParameterMixin):
         self.workload: Optional[WorkloadConfig] = None
         self.cluster: Optional[ecs.ICluster] = None
         self.service: Optional[ecs.FargateService] = None
-        self.task_definition: Optional[ecs.FargateTaskDefinition] = None
+        self.task_definition: Optional[ecs.FargateTaskDefinition] | Optional[ecs.EcsTaskDefinition] = None
         self._vpc: Optional[ec2.IVpc] = None
         # SSM imported values
         self.ssm_imported_values: Dict[str, Any] = {}
@@ -74,7 +75,7 @@ class EcsServiceStack(IStack, EnhancedSsmParameterMixin):
         
         # Load ECS configuration
         self.ecs_config = EcsServiceConfig(
-            stack_config.dictionary.get("ecs_service", {})
+            stack_config.dictionary.get("ecs_service") or stack_config.dictionary.get("ecs", {})
         )
         
         service_name = deployment.build_resource_name(self.ecs_config.name)
@@ -102,30 +103,13 @@ class EcsServiceStack(IStack, EnhancedSsmParameterMixin):
         self._add_outputs(service_name)
 
     def _load_vpc(self) -> None:
-        """Load VPC from configuration"""
-        # Check SSM imported values first
-        if "vpc_id" in self.ssm_imported_values:
-            vpc_id = self.ssm_imported_values["vpc_id"]
-            
-            # Build VPC attributes
-            vpc_attrs = {
-                "vpc_id": vpc_id,
-                "availability_zones": ["us-east-1a", "us-east-1b"]
-            }
-            
-            # Use from_vpc_attributes() for SSM tokens
-            self._vpc = ec2.Vpc.from_vpc_attributes(self, "VPC", **vpc_attrs)
-        else:
-            vpc_id = self.ecs_config.vpc_id or self.workload.vpc_id
-            
-            if not vpc_id:
-                raise ValueError("VPC ID is required for ECS service")
-            
-            self._vpc = ec2.Vpc.from_lookup(
-                self,
-                "VPC",
-                vpc_id=vpc_id
-            )
+        """Load VPC using the centralized VPC provider mixin."""
+        # Use the centralized VPC resolution from VPCProviderMixin
+        self._vpc = self.resolve_vpc(
+            config=self.ecs_config,
+            deployment=self.deployment,
+            workload=self.workload
+        )
 
     def _process_ssm_imports(self) -> None:
         """
@@ -450,7 +434,10 @@ class EcsServiceStack(IStack, EnhancedSsmParameterMixin):
                 health_check_grace_period=cdk.Duration.seconds(
                     self.ecs_config.health_check_grace_period
                 ) if self.ecs_config.target_group_arns else None,
-                circuit_breaker=ecs.DeploymentCircuitBreaker(rollback=True),
+                circuit_breaker=ecs.DeploymentCircuitBreaker(
+                    enable=self.ecs_config.deployment_circuit_breaker.get("enable", True),
+                    rollback=self.ecs_config.deployment_circuit_breaker.get("rollback", True)
+                ) if self.ecs_config.deployment_circuit_breaker else None,
                 placement_strategies=self._get_placement_strategies(),
                 placement_constraints=self._get_placement_constraints(),
             )
@@ -470,7 +457,10 @@ class EcsServiceStack(IStack, EnhancedSsmParameterMixin):
                 health_check_grace_period=cdk.Duration.seconds(
                     self.ecs_config.health_check_grace_period
                 ) if self.ecs_config.target_group_arns else None,
-                circuit_breaker=ecs.DeploymentCircuitBreaker(rollback=True),
+                circuit_breaker=ecs.DeploymentCircuitBreaker(
+                    enable=self.ecs_config.deployment_circuit_breaker.get("enable", True),
+                    rollback=self.ecs_config.deployment_circuit_breaker.get("rollback", True)
+                ) if self.ecs_config.deployment_circuit_breaker else None,
             )
         
         # Attach to load balancer target groups
@@ -662,15 +652,6 @@ class EcsServiceStack(IStack, EnhancedSsmParameterMixin):
                 description=f"ECS Service ARN: {service_name}",
             )
         
-        # Cluster name
-        if "cluster_name" in ssm_exports:
-            self.export_ssm_parameter(
-                scope=self,
-                id="ClusterNameParam",
-                value=self.cluster.cluster_name,
-                parameter_name=ssm_exports["cluster_name"],
-                description=f"ECS Cluster Name for {service_name}",
-            )
         
         # Task definition ARN
         if "task_definition_arn" in ssm_exports:

cdk_factory/stack_library/lambda_edge/lambda_edge_stack.py

@@ -25,7 +25,7 @@ from cdk_factory.configurations.deployment import DeploymentConfig
 from cdk_factory.configurations.stack import StackConfig
 from cdk_factory.configurations.resources.lambda_edge import LambdaEdgeConfig
 from cdk_factory.interfaces.istack import IStack
-from cdk_factory.interfaces.enhanced_ssm_parameter_mixin import EnhancedSsmParameterMixin
+from cdk_factory.interfaces.standardized_ssm_mixin import StandardizedSsmMixin
 from cdk_factory.stack.stack_module_registry import register_stack
 from cdk_factory.workload.workload_factory import WorkloadConfig
 
@@ -34,7 +34,7 @@ logger = Logger(service="LambdaEdgeStack")
 
 @register_stack("lambda_edge_library_module")
 @register_stack("lambda_edge_stack")
-class LambdaEdgeStack(IStack, EnhancedSsmParameterMixin):
+class LambdaEdgeStack(IStack, StandardizedSsmMixin):
     """
     Reusable stack for Lambda@Edge functions.