cdk-factory 0.16.10__tar.gz → 0.16.12__tar.gz

{cdk_factory-0.16.10 → cdk_factory-0.16.12}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cdk_factory
-Version: 0.16.10
+Version: 0.16.12
 Summary: CDK Factory. A QuickStarter and best practices setup for CDK projects
 Author-email: Eric Wilson <eric.wilson@geekcafe.com>
 License: MIT License

{cdk_factory-0.16.10 → cdk_factory-0.16.12}/pyproject.toml

@@ -33,7 +33,7 @@ markers = [
 [project]
 
 name = "cdk_factory"
-version = "0.16.10"
+version = "0.16.12"
 authors = [
   { name="Eric Wilson", email="eric.wilson@geekcafe.com" }
 ]

cdk_factory-0.16.12/src/cdk_factory/configurations/resources/ecs_cluster.py

@@ -0,0 +1,87 @@
+"""
+ECS Cluster Configuration
+
+Defines the configuration schema for ECS cluster stacks.
+"""
+
+from typing import Optional, Dict, Any, List
+
+
+class EcsClusterConfig:
+    """
+    Configuration for an ECS cluster.
+    
+    This class defines all the configurable parameters for an ECS cluster,
+    providing explicit control over cluster creation and settings.
+    """
+    
+    def __init__(self, config: Dict[str, Any]) -> None:
+        self._config = config or {}
+    
+    @property
+    def name(self) -> str:
+        """Name of the ECS cluster. Supports template variables like {{WORKLOAD_NAME}}-{{ENVIRONMENT}}-cluster"""
+        return self._config.get("name", "cluster")
+    
+    @property
+    def container_insights(self) -> bool:
+        """Enable container insights for the cluster"""
+        return self._config.get("container_insights", True)
+    
+    @property
+    def cluster_settings(self) -> Optional[List[Dict[str, str]]]:
+        """Additional cluster settings as name-value pairs"""
+        return self._config.get("cluster_settings")
+    
+    @property
+    def cloud_map_namespace(self) -> Optional[Dict[str, Any]]:
+        """Cloud Map namespace configuration for service discovery"""
+        return self._config.get("cloud_map_namespace")
+    
+    @property
+    def execute_command_configuration(self) -> Optional[Dict[str, Any]]:
+        """Execute command configuration for ECS"""
+        return self._config.get("execute_command_configuration")
+    
+    @property
+    def vpc_id(self) -> Optional[str]:
+        """VPC ID where the cluster should be created"""
+        return self._config.get("vpc_id")
+    
+    @property
+    def ssm_vpc_id(self) -> Optional[str]:
+        """SSM parameter path to import VPC ID"""
+        return self._config.get("ssm_vpc_id")
+    
+    @property
+    def create_instance_role(self) -> bool:
+        """Whether to create an ECS instance role"""
+        return self._config.get("create_instance_role", True)
+    
+    @property
+    def instance_role_name(self) -> Optional[str]:
+        """Custom name for the ECS instance role"""
+        return self._config.get("instance_role_name")
+    
+    @property
+    def instance_profile_name(self) -> Optional[str]:
+        """Custom name for the ECS instance profile"""
+        return self._config.get("instance_profile_name")
+    
+    @property
+    def managed_policies(self) -> List[str]:
+        """List of AWS managed policies to attach to the instance role"""
+        return self._config.get("managed_policies", [
+            "service-role/AmazonEC2ContainerServiceforEC2Role",
+            "AmazonSSMManagedInstanceCore"
+        ])
+    
+    @property
+    def inline_policies(self) -> Optional[Dict[str, Dict[str, Any]]]:
+        """Inline IAM policies to attach to the instance role"""
+        return self._config.get("inline_policies")
+    
+    @property
+    def export_ssm_parameters(self) -> bool:
+        """Whether to export cluster information to SSM parameters"""
+        return self._config.get("export_ssm_parameters", True)

{cdk_factory-0.16.10 → cdk_factory-0.16.12}/src/cdk_factory/stack_library/auto_scaling/auto_scaling_stack.py

@@ -248,10 +248,12 @@ class AutoScalingStack(IStack, VPCProviderMixin):
         # Add base commands
         user_data.add_commands("set -euxo pipefail")
 
-        # Add custom commands from config
+        # Add custom commands from config (with variable substitution)
         for command in self.asg_config.user_data_commands:
-            user_data.add_commands(command)
-            self.user_data_commands.append(command)
+            # Perform variable substitution on the command
+            substituted_command = self._substitute_variables(command)
+            user_data.add_commands(substituted_command)
+            self.user_data_commands.append(substituted_command)
 
         # Add user data scripts from files (with variable substitution)
         if self.asg_config.user_data_scripts:
@@ -324,6 +326,49 @@ class AutoScalingStack(IStack, VPCProviderMixin):
             
             logger.info(f"Added user data script from {script_type}: {script_config.get('path', 'inline')}")
 
+    def _substitute_variables(self, command: str) -> str:
+        """
+        Perform variable substitution on a user data command.
+        Uses workload and deployment configuration for substitution.
+        """
+        if not command:
+            return command
+            
+        # Start with the original command
+        substituted_command = command
+        
+        # Define available variables for substitution
+        variables = {}
+        
+        # Add workload variables
+        if self.workload:
+            variables.update({
+                "WORKLOAD_NAME": getattr(self.workload, 'name', ''),
+                "ENVIRONMENT": getattr(self.workload, 'environment', ''),
+                "WORKLOAD": getattr(self.workload, 'name', ''),
+            })
+        
+        # Add deployment variables
+        if self.deployment:
+            variables.update({
+                "DEPLOYMENT_NAME": getattr(self.deployment, 'name', ''),
+                "REGION": getattr(self.deployment, 'region', ''),
+                "ACCOUNT": getattr(self.deployment, 'account', ''),
+            })
+        
+        # Add stack-level variables
+        variables.update({
+            "STACK_NAME": self.stack_name,
+        })
+        
+        # Perform substitution
+        for var_name, var_value in variables.items():
+            if var_value is not None:
+                placeholder = f"{{{{{var_name}}}}}"  # {{VAR_NAME}}
+                substituted_command = substituted_command.replace(placeholder, str(var_value))
+        
+        return substituted_command
+
     def _add_container_user_data(
         self, user_data: ec2.UserData, container_config: Dict[str, Any]
     ) -> None:
@@ -587,56 +632,34 @@ class AutoScalingStack(IStack, VPCProviderMixin):
             # Scheduled action implementation would go here
             pass
 
-    def _create_ecs_cluster_if_needed(self, asg_name: str) -> None:
-        """Create ECS cluster if ECS configuration is detected"""
-        # Check if this is an ECS configuration by looking for ECS-related patterns
-        is_ecs_config = (
-            # Check if ECS managed policy is attached
-            any("AmazonEC2ContainerServiceforEC2Role" in policy for policy in self.asg_config.managed_policies) or
-            # Check for explicit ECS configuration
-            self.stack_config.dictionary.get("auto_scaling", {}).get("enable_ecs_cluster", False)
-        )
-        
-        if not is_ecs_config:
-            logger.debug("No ECS configuration detected, skipping cluster creation")
+    def _create_ecs_cluster_if_needed(self, asg_name: str):
+        """
+        ECS cluster creation should be handled by the dedicated EcsClusterStack module.
+        This method only handles SSM imports for cluster name injection.
+        """
+        # Check if ECS cluster name is available via SSM imports
+        if self.has_ssm_import("ecs_cluster_name"):
+            logger.info(f"ECS cluster name available via SSM imports")
+            # Inject cluster name into user data if available
+            if self.user_data and self.user_data_commands:
+                self._inject_cluster_name_into_user_data()
             return
         
-        # Generate cluster name from stack configuration
-        cluster_name = f"{self.deployment.build_resource_name('cluster')}"
-        
-        logger.info(f"Creating ECS cluster: {cluster_name}")
-        
-        # Create ECS cluster
-        self.ecs_cluster = ecs.Cluster(
-            self,
-            "ECSCluster",
-            cluster_name=cluster_name,
-            vpc=self.vpc,
-            container_insights=True
-        )
-        
-        # Inject the cluster name into user data if user data exists
-        if self.user_data and self.user_data_commands:
-            self._inject_cluster_name_into_user_data(cluster_name)
-        
-        # Export cluster name
-        cdk.CfnOutput(
-            self,
-            f"{cluster_name}-name",
-            value=self.ecs_cluster.cluster_name,
-            export_name=f"{self.deployment.build_resource_name(cluster_name)}-name",
-        )
-        
-        # Export cluster ARN
-        cdk.CfnOutput(
-            self,
-            f"{cluster_name}-arn",
-            value=self.ecs_cluster.cluster_arn,
-            export_name=f"{self.deployment.build_resource_name(cluster_name)}-arn",
+        logger.warning(
+            "No ECS cluster name found in SSM imports. "
+            "Use the dedicated EcsClusterStack module to create ECS clusters."
         )
 
-    def _inject_cluster_name_into_user_data(self, cluster_name: str) -> None:
-        """Inject the ECS cluster name into user data commands"""
+    def _inject_cluster_name_into_user_data(self) -> None:
+        """Inject the ECS cluster name into user data commands using SSM imports"""
+        # Check if ECS cluster name is available via SSM imports
+        if self.has_ssm_import("ecs_cluster_name"):
+            cluster_name = self.get_ssm_imported_value("ecs_cluster_name")
+            logger.info(f"Using ECS cluster name from SSM: {cluster_name}")
+        else:
+            logger.warning("No ECS cluster name found in SSM imports, skipping cluster name injection")
+            return
+        
         injected_commands = []
         cluster_name_injected = False
         

cdk_factory-0.16.12/src/cdk_factory/stack_library/ecs/__init__.py

@@ -0,0 +1,14 @@
+"""
+ECS Stack Library
+
+Contains ECS-related stack modules for creating and managing
+ECS clusters, services, and related resources.
+"""
+
+from .ecs_cluster_stack import EcsClusterStack
+from .ecs_service_stack import EcsServiceStack
+
+__all__ = [
+    "EcsClusterStack",
+    "EcsServiceStack"
+]

cdk_factory-0.16.12/src/cdk_factory/stack_library/ecs/ecs_cluster_stack.py

@@ -0,0 +1,240 @@
+"""
+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, List
+
+from aws_cdk import (
+    aws_ecs as ecs,
+    aws_ec2 as ec2,
+    aws_iam as iam,
+    aws_ssm as ssm,
+    RemovalPolicy,
+    Stack,
+    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.ssm_parameter_mixin import SsmParameterMixin
+from cdk_factory.configurations.resources.ecs_cluster import EcsClusterConfig
+
+
+logger = logging.getLogger(__name__)
+
+
+class EcsClusterStack(Stack, SsmParameterMixin):
+    """
+    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,
+        construct_id: str,
+        stack_config: StackConfig,
+        deployment: DeploymentConfig,
+        workload: WorkloadConfig,
+        **kwargs
+    ):
+        """
+        Initialize the ECS Cluster stack.
+        
+        Args:
+            scope: The CDK construct scope
+            construct_id: The construct ID
+            stack_config: Stack configuration
+            deployment: Deployment configuration
+            workload: Workload configuration
+        """
+        super().__init__(scope, construct_id, **kwargs)
+        
+        self.stack_config = stack_config
+        self.deployment = deployment
+        self.workload = workload
+        
+        # Load ECS cluster configuration
+        self.ecs_config: EcsClusterConfig = EcsClusterConfig(
+            stack_config.dictionary.get("ecs_cluster", {})
+        )
+        
+        logger.info(f"Creating ECS Cluster stack: {construct_id}")
+        
+        # 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: {construct_id}")
+    
+    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.ecs_cluster = ecs.Cluster(
+            self,
+            "ECSCluster",
+            cluster_name=self.ecs_config.name,
+            vpc=self._get_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 _get_vpc(self):
+        """Get the VPC for the ECS cluster."""
+        if self.ecs_config.vpc_id:
+            # Import VPC by ID
+            return ec2.Vpc.from_lookup(
+                self,
+                "VPC",
+                vpc_id=self.ecs_config.vpc_id
+            )
+        elif self.ecs_config.ssm_vpc_id:
+            # Import VPC from SSM
+            vpc_id = self._import_ssm_parameter_value(
+                self.ecs_config.ssm_vpc_id,
+                required=True
+            )
+            return ec2.Vpc.from_lookup(
+                self,
+                "VPC", 
+                vpc_id=vpc_id
+            )
+        else:
+            # Use default VPC
+            return ec2.Vpc.from_lookup(
+                self,
+                "VPC",
+                is_default=True
+            )
+    
+    def _export_cluster_info(self):
+        """Export cluster information via SSM parameters and CloudFormation outputs."""
+        logger.info("Exporting ECS cluster information")
+        
+        # Export cluster name
+        self.export_ssm_parameter(
+            f"/{self.deployment.name}/{self.workload.name}/ecs/cluster/name",
+            self.ecs_config.name,
+            "ECS Cluster Name"
+        )
+        
+        # Export cluster ARN
+        self.export_ssm_parameter(
+            f"/{self.deployment.name}/{self.workload.name}/ecs/cluster/arn",
+            self.ecs_cluster.cluster_arn,
+            "ECS Cluster ARN"
+        )
+        
+        # Export instance role ARN if created
+        if hasattr(self, 'instance_role'):
+            self.export_ssm_parameter(
+                f"/{self.deployment.name}/{self.workload.name}/ecs/instance-role/arn",
+                self.instance_role.role_arn,
+                "ECS Instance Role ARN"
+            )
+        
+        # CloudFormation outputs
+        CfnOutput(
+            self,
+            "cluster-name",
+            value=self.ecs_config.name,
+            description=f"Name of the ECS cluster: {self.ecs_config.name}",
+            export_name=f"{self.deployment.name}-ecs-cluster-name"
+        )
+        
+        CfnOutput(
+            self,
+            "cluster-arn",
+            value=self.ecs_cluster.cluster_arn,
+            description=f"ARN of the ECS cluster: {self.ecs_config.name}",
+            export_name=f"{self.deployment.name}-ecs-cluster-arn"
+        )
+        
+        if hasattr(self, 'instance_role'):
+            CfnOutput(
+                self,
+                "instance-role-arn",
+                value=self.instance_role.role_arn,
+                description=f"ARN of the ECS instance role: {self.ecs_config.name}",
+                export_name=f"{self.deployment.name}-ecs-instance-role-arn"
+            )

cdk_factory-0.16.12/src/cdk_factory/version.py

@@ -0,0 +1 @@
+__version__ = "0.16.12"

cdk_factory-0.16.10/src/cdk_factory/version.py

@@ -1 +0,0 @@
-__version__ = "0.16.10"