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

cdk_factory/configurations/resources/ecs_service.py

@@ -83,14 +83,27 @@ class EcsServiceConfig:
         """Whether to assign public IP addresses"""
         return self._config.get("assign_public_ip", False)
 
+    @property
+    def load_balancer_config(self) -> Dict[str, Any]:
+        """Load balancer configuration"""
+        return self._config.get("load_balancer", {})
+
     @property
     def target_group_arns(self) -> List[str]:
         """Target group ARNs for load balancing"""
+        # Check if load_balancer config has target_group_arn
+        if self.load_balancer_config and self.load_balancer_config.get("target_group_arn"):
+            arn = self.load_balancer_config["target_group_arn"]
+            if arn and arn != "arn:aws:elasticloadbalancing:placeholder":
+                return [arn]
         return self._config.get("target_group_arns", [])
 
     @property
     def container_port(self) -> int:
         """Container port for load balancer"""
+        # Check load_balancer config first
+        if self.load_balancer_config and self.load_balancer_config.get("container_port"):
+            return self.load_balancer_config["container_port"]
         return self._config.get("container_port", 80)
 
     @property
@@ -138,8 +151,17 @@ class EcsServiceConfig:
         """SSM parameter imports"""
         # Check both nested and flat structures for backwards compatibility
         if "ssm" in self._config and "imports" in self._config["ssm"]:
-            return self._config["ssm"]["imports"]
-        return self.ssm.get("imports", {})
+            imports = self._config["ssm"]["imports"]
+        else:
+            imports = self.ssm.get("imports", {})
+        
+        # Add load_balancer SSM imports if they exist
+        if self.load_balancer_config and "ssm" in self.load_balancer_config:
+            lb_ssm = self.load_balancer_config["ssm"]
+            if "imports" in lb_ssm:
+                imports.update(lb_ssm["imports"])
+        
+        return imports
 
     @property
     def deployment_type(self) -> str:

cdk_factory/configurations/resources/route53.py

@@ -106,3 +106,8 @@ class Route53Config:
     def tags(self) -> Dict[str, str]:
         """Tags to apply to the Route53 resources"""
         return self.__config.get("tags", {})
+    
+    @property
+    def records(self) -> List[Dict[str, Any]]:
+        """Records to create"""
+        return self.__config.get("records", [])

cdk_factory/interfaces/standardized_ssm_mixin.py

@@ -119,6 +119,7 @@ class StandardizedSsmMixin:
         """Export multiple resource values to SSM Parameter Store."""
         params = {}
         
+        invalid_export_keys = []
         # Only export parameters that are explicitly configured in ssm_exports
         if not hasattr(config, 'ssm_exports') or not config.ssm_exports:
             logger.debug("No SSM exports configured")
@@ -138,8 +139,17 @@ class StandardizedSsmMixin:
                 )
                 params[key] = param
             else:
+                invalid_export_keys.append(key)
                 logger.warning(f"SSM export configured for '{key}' but no value found in resource_values")
         
+        if invalid_export_keys:
+            message = f"Export SSM Error\n🚨 SSM exports configured for '{invalid_export_keys}' but no values found in resource_values"
+            available_keys = list(resource_values.keys())
+            message = f"{message}\n✅ Available keys: {available_keys}"
+            message = f"{message}\n👉 Please update to the correct key or remove from the export list."
+            logger.warning(message)
+            raise ValueError(message)
+            
         return params
 
     def normalize_resource_name(self, name: str, for_export: bool = False) -> str:
@@ -269,6 +279,23 @@ class StandardizedSsmMixin:
         
         return exported_params
     
+    def resolve_ssm_value(self, scope: Construct, value: str, unique_id: str)-> str:
+        if isinstance(value, str) and value.startswith("{{ssm:") and value.endswith("}}"):
+            # Extract SSM parameter path
+            ssm_param_path = value[6:-2]  # Remove {{ssm: and }}
+            
+            # Import SSM parameter - this creates a token that resolves at deployment time
+            param = ssm.StringParameter.from_string_parameter_name(
+                scope=scope,
+                id=f"{unique_id}-env-{hash(ssm_param_path) % 10000}",
+                string_parameter_name=ssm_param_path
+            )
+            resolved_value = param.string_value
+            logger.info(f"Resolved SSM parameter {ssm_param_path}")
+            return resolved_value
+        else:
+            return value
+
     def _resolve_ssm_import(self, import_value: Union[str, List[str]], import_key: str) -> Union[str, List[str]]:
         """
         Resolve SSM import value with proper error handling and validation.

cdk_factory/stack_library/auto_scaling/auto_scaling_stack.py

@@ -358,8 +358,11 @@ class AutoScalingStack(IStack, VPCProviderMixin, StandardizedSsmMixin):
             elif self.asg_config.ami_type.upper() == "AMAZON-LINUX-2":
                 machine_image = ec2.MachineImage.latest_amazon_linux2()
             elif self.asg_config.ami_type.upper() == "ECS_OPTIMIZED":
-                # Use actual ECS-optimized AMI (Amazon Linux 2 based)
-                machine_image = ec2.MachineImage.lookup(name="amzn2-ami-ecs-hvm-*-x86_64-ebs")
+                # Use ECS-optimized AMI from SSM parameter
+                from aws_cdk import aws_ssm as ssm
+                machine_image = ec2.MachineImage.from_ssm_parameter(
+                    parameter_name="/aws/service/ecs/optimized-ami/amazon-linux-2023/recommended/image_id"
+                )
             else:
                 # Default to latest Amazon Linux
                 machine_image = ec2.MachineImage.latest_amazon_linux2023()

cdk_factory/stack_library/cloudfront/cloudfront_stack.py

@@ -13,6 +13,7 @@ from aws_cdk import (
     aws_cloudfront as cloudfront,
     aws_cloudfront_origins as origins,
     aws_certificatemanager as acm,
+    aws_route53 as route53,
     aws_lambda as _lambda,
     aws_ssm as ssm,
     CfnOutput,
@@ -161,8 +162,36 @@ class CloudFrontStack(IStack):
             logger.info(f"Using certificate from SSM: {ssm_param}")
             return
 
+        # Create new certificate from domain name
+        domain_name = cert_config.get("domain_name")
+        if domain_name and self.cf_config.aliases:
+            # CloudFront certificates must be in us-east-1
+            if self.region != "us-east-1":
+                logger.warning(
+                    f"Certificate creation requested but stack is in {self.region}. "
+                    "CloudFront certificates must be created in us-east-1"
+                )
+                return
+            
+            # Create the certificate
+            # Get hosted zone from SSM imports
+            hosted_zone_id = cert_config.get("hosted_zone_id")
+            hosted_zone = route53.HostedZone.from_hosted_zone_id(
+                self, "HostedZone", hosted_zone_id
+            )
+            
+            self.certificate = acm.Certificate(
+                self,
+                "Certificate",
+                domain_name=domain_name,
+                subject_alternative_names=self.cf_config.aliases,
+                validation=acm.CertificateValidation.from_dns(hosted_zone=hosted_zone),
+            )
+            logger.info(f"Created new ACM certificate for domain: {domain_name}")
+            return
+
         logger.warning(
-            "No certificate ARN provided - CloudFront will use default certificate"
+            "No certificate ARN or domain name provided - CloudFront will use default certificate"
         )
 
     def _create_origins(self) -> None:

cdk_factory/stack_library/ecs/ecs_service_stack.py

@@ -563,7 +563,7 @@ class EcsServiceStack(IStack, VPCProviderMixin, StandardizedSsmMixin):
         for param_key, param_name in ssm_imports.items():
             if 'target_group' in param_key.lower() or 'tg' in param_key.lower():
                 try:
-                    param_value = self.get_ssm_parameter_value(param_name)
+                    param_value = self.get_ssm_imported_value(param_name)
                     if param_value and param_value.startswith('arn:'):
                         target_group_arns.append(param_value)
                 except Exception as e:

cdk_factory/stack_library/lambda_edge/lambda_edge_stack.py

@@ -329,7 +329,7 @@ class LambdaEdgeStack(IStack, StandardizedSsmMixin):
         )
         
         # SSM Parameter Store exports (if configured)
-        ssm_exports = self.edge_config.dictionary.get("ssm_exports", {})
+        ssm_exports = self.edge_config.dictionary.get("ssm", {}).get("exports", {})
         if ssm_exports:
             export_values = {
                 "function_name": self.function.function_name,

cdk_factory/stack_library/route53/route53_stack.py

@@ -7,10 +7,15 @@ 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_route53 as route53
-from aws_cdk import aws_route53_targets as targets
-from aws_cdk import aws_certificatemanager as acm
-from aws_cdk import aws_elasticloadbalancingv2 as elbv2
+from aws_cdk import (
+    aws_route53 as route53,
+    aws_route53_targets as targets,
+    aws_certificatemanager as acm,
+    aws_elasticloadbalancingv2 as elbv2,
+    aws_cloudfront as cloudfront,
+    Duration,
+    CfnOutput,
+)
 from aws_lambda_powertools import Logger
 from constructs import Construct
 
@@ -35,6 +40,7 @@ class Route53Stack(IStack, StandardizedSsmMixin):
 
     def __init__(self, scope: Construct, id: str, **kwargs) -> None:
         super().__init__(scope, id, **kwargs)
+        
         self.route53_config = None
         self.stack_config = None
         self.deployment = None
@@ -42,6 +48,7 @@ class Route53Stack(IStack, StandardizedSsmMixin):
         self.hosted_zone = None
         self.certificate = None
         self.records = {}
+        self._distribution_cache = {}  # Cache for reusing distributions
 
     def build(self, stack_config: StackConfig, deployment: DeploymentConfig, workload: WorkloadConfig) -> None:
         """Build the Route53 stack"""
@@ -112,6 +119,232 @@ class Route53Stack(IStack, StandardizedSsmMixin):
         return certificate
 
     def _create_dns_records(self) -> None:
+        self._create_dns_records_old()
+        self._create_dns_records_new()
+
+    
+    def _get_or_create_cloudfront_distribution(self, distribution_domain: str, distribution_id: str) -> cloudfront.Distribution:
+        """Get or create a CloudFront distribution, reusing if already created"""
+        # Create a unique cache key from distribution domain and ID
+        cache_key = f"{distribution_domain}-{distribution_id}"
+        
+        if cache_key not in self._distribution_cache:
+            # Create the distribution construct with a unique ID
+            unique_id = f"CF-{distribution_domain.replace('.', '-').replace('*', 'wildcard')}-{hash(cache_key) % 10000}"
+            distribution = cloudfront.Distribution.from_distribution_attributes(
+                self, unique_id,
+                domain_name=distribution_domain,
+                distribution_id=distribution_id
+            )
+            self._distribution_cache[cache_key] = distribution
+            logger.info(f"Created CloudFront distribution construct for {distribution_domain}")
+        
+        return self._distribution_cache[cache_key]
+
+    def _create_dns_records_new(self) -> None:
+        """Create DNS records based on configuration - generic implementation"""
+        
+        missing_configurations = []
+
+        for record in self.route53_config.records:
+            record_name = record.get("name", "")
+            record_type = record.get("type", "")
+            
+            if not record_name or not record_type:
+                message = f"Record missing name or type: {record}"
+                logger.warning(message)
+                missing_configurations.append(message)
+                continue
+            
+            # Handle alias records
+            if "alias" in record:
+                alias_config = record["alias"]
+                target_type = alias_config.get("target_type", "")
+                target_value = alias_config.get("target_value", "")
+                hosted_zone_id = alias_config.get("hosted_zone_id", "")
+                
+                unique_id = f"{record_name}-{record_type}"
+                # Handle SSM parameter references in target_value                
+                target_value = self.resolve_ssm_value(self, target_value, unique_id=unique_id)
+                
+                if not target_type or not target_value:
+                    message = f"Alias record missing target_type or target_value: {record}"
+                    logger.warning(message)
+                    missing_configurations.append(message)
+                    continue
+                
+                # Create appropriate target based on type
+                alias_target = None
+                if target_type == "cloudfront":
+                    # CloudFront distribution target
+                    distribution_domain = target_value
+                    distribution_id = alias_config.get("distribution_id", "")
+                    if not distribution_id:
+                        message = f"Alias record missing distribution_id: {record}"
+                        logger.warning(message)
+                        missing_configurations.append(message)
+                        continue
+                    
+                    # Get or create the distribution (reuses if already created)
+                    distribution = self._get_or_create_cloudfront_distribution(distribution_domain, distribution_id)
+                    alias_target = route53.RecordTarget.from_alias(
+                        targets.CloudFrontTarget(distribution)
+                    )
+                elif target_type == "loadbalancer" or target_type == "alb":
+                    # Load Balancer target
+                    alias_target = route53.RecordTarget.from_alias(
+                        targets.LoadBalancerTarget(
+                            elbv2.ApplicationLoadBalancer.from_load_balancer_attributes(
+                                self, f"ALB-{record_name}",
+                                load_balancer_dns_name=target_value,
+                                load_balancer_canonical_hosted_zone_id=hosted_zone_id
+                            )
+                        )
+                    )
+                elif target_type == "elbv2":
+                    # Generic ELBv2 target
+                    alias_target = route53.RecordTarget.from_alias(
+                        targets.LoadBalancerTarget(
+                            elbv2.ApplicationLoadBalancer.from_load_balancer_attributes(
+                                self, f"ELB-{record_name}",
+                                load_balancer_dns_name=target_value,
+                                load_balancer_canonical_hosted_zone_id=hosted_zone_id
+                            )
+                        )
+                    )
+                else:
+                    message = f"Unsupported alias target type: {target_type}"
+                    logger.warning(message)
+                    missing_configurations.append(message)
+                    continue
+                
+                # Create the alias record
+                route53.ARecord(
+                    self,
+                    f"AliasRecord-{record_name}-{record_type}",
+                    zone=self.hosted_zone,
+                    record_name=record_name,
+                    target=alias_target,
+                    ttl=cdk.Duration.seconds(record.get("ttl", 300))
+                ) if record_type == "A" else route53.AaaaRecord(
+                    self,
+                    f"AliasRecord-{record_name}-{record_type}",
+                    zone=self.hosted_zone,
+                    record_name=record_name,
+                    target=alias_target,
+                    ttl=cdk.Duration.seconds(record.get("ttl", 300))
+                )
+                
+            # Handle standard records with values
+            elif "values" in record:
+                values = record["values"]
+                if not isinstance(values, list):
+                    values = [values]
+                
+                # Handle SSM parameter references in values
+                processed_values = []
+                for value in values:
+                    if "{{ssm:" in str(value) and "}}" in str(value):
+                        # Extract SSM parameter path from template like {{ssm:/path/to/parameter}}
+                        ssm_path = str(value).split("{{ssm:")[1].split("}}")[0]
+                        resolved_value = self.get_ssm_imported_value(ssm_path)
+                        processed_values.append(resolved_value)
+                    else:
+                        processed_values.append(value)
+                
+                values = processed_values
+                ttl = record.get("ttl", 300)
+                
+                # Create standard record based on type
+                if record_type == "A":
+                    route53.ARecord(
+                        self,
+                        f"Record-{record_name}",
+                        zone=self.hosted_zone,
+                        record_name=record_name,
+                        target=route53.RecordTarget.from_ip_addresses(*values),
+                        ttl=cdk.Duration.seconds(ttl)
+                    )
+                elif record_type == "AAAA":
+                    route53.AaaaRecord(
+                        self,
+                        f"Record-{record_name}",
+                        zone=self.hosted_zone,
+                        record_name=record_name,
+                        target=route53.RecordTarget.from_ip_addresses(*values),
+                        ttl=cdk.Duration.seconds(ttl)
+                    )
+                elif record_type == "CNAME":
+                    route53.CnameRecord(
+                        self,
+                        f"Record-{record_name}",
+                        zone=self.hosted_zone,
+                        record_name=record_name,
+                        domain_name=values[0],  # CNAME only supports single value
+                        ttl=cdk.Duration.seconds(ttl)
+                    )
+                elif record_type == "MX":
+                    # MX records need special handling for preference values
+                    mx_targets = []
+                    for value in values:
+                        if isinstance(value, str) and " " in value:
+                            preference, domain = value.split(" ", 1)
+                            mx_targets.append(route53.MxRecordValue(
+                                domain_name=domain.strip(),
+                                preference=int(preference.strip())
+                            ))
+                        else:
+                            logger.warning(f"Invalid MX record format: {value}")
+                    
+                    if mx_targets:
+                        route53.MxRecord(
+                            self,
+                            f"Record-{record_name}",
+                            zone=self.hosted_zone,
+                            record_name=record_name,
+                            values=mx_targets,
+                            ttl=cdk.Duration.seconds(ttl)
+                        )
+                elif record_type == "TXT":
+                    route53.TxtRecord(
+                        self,
+                        f"Record-{record_name}",
+                        zone=self.hosted_zone,
+                        record_name=record_name,
+                        values=values,
+                        ttl=cdk.Duration.seconds(ttl)
+                    )
+                elif record_type == "NS":
+                    route53.NsRecord(
+                        self,
+                        f"Record-{record_name}",
+                        zone=self.hosted_zone,
+                        record_name=record_name,
+                        values=values,
+                        ttl=cdk.Duration.seconds(ttl)
+                    )
+                else:
+                    message = f"Unsupported record type: {record_type}"
+                    logger.warning(message)
+                    missing_configurations.append(message)
+                    continue
+            
+            else:
+                message = f"Record missing 'alias' or 'values' configuration: {record}"
+                logger.warning(message)
+                missing_configurations.append(message)
+                continue
+
+        if missing_configurations and len(missing_configurations) > 0:
+            # print all missing configurations
+            print("Missing configurations:")
+            for message in missing_configurations:
+                print(message)
+            
+            messages = "\n".join(missing_configurations)
+            raise ValueError(f"Missing Configurations:\n{messages}")
+
+    def _create_dns_records_old(self) -> None:
         """Create DNS records based on configuration"""
         # Create alias records
         for alias_record in self.route53_config.aliases:
@@ -119,6 +352,12 @@ class Route53Stack(IStack, StandardizedSsmMixin):
             target_type = alias_record.get("target_type", "")
             target_value = alias_record.get("target_value", "")
             
+            # target value needs to handle SSM parameters
+            if "{{ssm:" in target_value and "}}" in target_value:
+                # Extract SSM parameter path from template like {{ssm:/path/to/parameter}}
+                ssm_path = target_value.split("{{ssm:")[1].split("}}")[0]
+                target_value = self.get_ssm_imported_value(ssm_path)
+
             if not record_name or not target_type or not target_value:
                 continue
                 

cdk_factory/version.py

@@ -1 +1 @@
-__version__ = "0.18.9"
+__version__ = "0.18.16"

{cdk_factory-0.18.9.dist-info → cdk_factory-0.18.16.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cdk_factory
-Version: 0.18.9
+Version: 0.18.16
 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.18.9.dist-info → cdk_factory-0.18.16.dist-info}/RECORD

@@ -2,7 +2,7 @@ cdk_factory/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 cdk_factory/app.py,sha256=RnX0-pwdTAPAdKJK_j13Zl8anf9zYKBwboR0KA8K8xM,10346
 cdk_factory/cdk.json,sha256=SKZKhJ2PBpFH78j-F8S3VDYW-lf76--Q2I3ON-ZIQfw,3106
 cdk_factory/cli.py,sha256=FGbCTS5dYCNsfp-etshzvFlGDCjC28r6rtzYbe7KoHI,6407
-cdk_factory/version.py,sha256=IVIKMh_0rk9joVhw8HHbpQn8gqEpjdsiBt0jOCyi8os,23
+cdk_factory/version.py,sha256=u2VedG3riNPA57kZZvEOLXswrx3sIcK-W_Ka3KvPDzg,24
 cdk_factory/builds/README.md,sha256=9BBWd7bXpyKdMU_g2UljhQwrC9i5O_Tvkb6oPvndoZk,90
 cdk_factory/commands/command_loader.py,sha256=QbLquuP_AdxtlxlDy-2IWCQ6D-7qa58aphnDPtp_uTs,3744
 cdk_factory/configurations/base_config.py,sha256=eJ3Pl3GWk1jVr_bYQaaWlw4_-ZiFGaiXllI_fOOX1i0,9323
@@ -32,7 +32,7 @@ cdk_factory/configurations/resources/docker.py,sha256=hUbuxkuhcQu9LnLX7I8_57eTmH
 cdk_factory/configurations/resources/dynamodb.py,sha256=HsZMOaRwfuNPwKIzokeeE3f5zAQLTB5hRb_GzYq2ibg,2903
 cdk_factory/configurations/resources/ecr.py,sha256=iJEtKqBT7vQU0LU4urIglraIR7cPZqp3HQBs_2An7kA,8303
 cdk_factory/configurations/resources/ecs_cluster.py,sha256=mQYJu7SUPDl5E4dMR6HCPFoWvFA3RGIb0iMNn-K7LX8,3635
-cdk_factory/configurations/resources/ecs_service.py,sha256=iwUVewUy9fQSLpkfRTNuIaWy7eQYWTHFiiD1jIYt9zU,5452
+cdk_factory/configurations/resources/ecs_service.py,sha256=bOWjVECd6Kbc5NGGSnDaopnKrjRsUfmaZ6-qrsmTs3Q,6468
 cdk_factory/configurations/resources/exisiting.py,sha256=EVOLnkB-DGfTlmDgyQ5DD5k2zYfpFxqI3gugDR7mifI,478
 cdk_factory/configurations/resources/lambda_edge.py,sha256=MjmiwDkys4aoRvDQhH3MT6BgeShzJXNWL7761HJrLtQ,3404
 cdk_factory/configurations/resources/lambda_function.py,sha256=VENZ9-ABJ5mjcN8J8wdLH4KHDYr1kWO0iFDH0B2mJXA,14659
@@ -44,7 +44,7 @@ cdk_factory/configurations/resources/rds.py,sha256=ap2sbrcPsesfaPSluzyomGgT70_PU
 cdk_factory/configurations/resources/resource_mapping.py,sha256=cwv3n63RJ6E59ErsmSTdkW4i-g8huhHtKI0ExbRhJxA,2182
 cdk_factory/configurations/resources/resource_naming.py,sha256=VE9S2cpzp11qqPL2z1sX79wXH0o1SntO2OG74nEmWC8,5508
 cdk_factory/configurations/resources/resource_types.py,sha256=1WQHyDoErb-M-tETZZzyLDtbq_jdC85-I403dM48pgE,2317
-cdk_factory/configurations/resources/route53.py,sha256=FwfAL90amoQqn7DSGcIprlfNhbJ08T80joplxLg99Ko,3453
+cdk_factory/configurations/resources/route53.py,sha256=u63kw9cLBdOQrvxnULmopFqiArIYNvoWhrILNWvhD7w,3599
 cdk_factory/configurations/resources/route53_hosted_zone.py,sha256=qjEYPCSxSOx5blr9EULv892ezxkCs--yrLa1ngWbyXM,880
 cdk_factory/configurations/resources/rum.py,sha256=KgC2Mxhtr5XrICVXdgOXmxYp0GKu9lBs7izfG-Re9Ck,5294
 cdk_factory/configurations/resources/s3.py,sha256=kLY0XNCfErNYnOwekefFJxEJ_AKPifA-wSaaNczDp94,6036
@@ -66,7 +66,7 @@ cdk_factory/constructs/sqs/policies/sqs_policies.py,sha256=4p0G8G-fqNKSr68I55fvq
 cdk_factory/interfaces/istack.py,sha256=3xqGw5kNTt_KeLHdMxI7rIR0YORqcWQOqsacmDlTAv0,1167
 cdk_factory/interfaces/live_ssm_resolver.py,sha256=3FIr9a02SXqZmbFs3RT0WxczWEQR_CF7QSt7kWbDrVE,8163
 cdk_factory/interfaces/networked_stack_mixin.py,sha256=CtWT7Nhy73f0goQQG02jG7lsEucq5OrtZ0ltrp7XTFA,2884
-cdk_factory/interfaces/standardized_ssm_mixin.py,sha256=Vzry6QWOYCJf5ZZeAJM9QKwj1L3-JWG9SUzB4Tsi1HM,24378
+cdk_factory/interfaces/standardized_ssm_mixin.py,sha256=kbl8fTDSBBSUARnKjruYB7KEgsw1Xns7g6fI5Jh8Vio,25763
 cdk_factory/interfaces/vpc_provider_mixin.py,sha256=Kj0mmZd54NINprixJLs8zL-WWiSd0AQBtGdwNg8cz14,8207
 cdk_factory/lambdas/health_handler.py,sha256=dd40ykKMxWCFEIyp2ZdQvAGNjw_ylI9CSm1N24Hp2ME,196
 cdk_factory/lambdas/edge/ip_gate/handler.py,sha256=gUevgX462mqGYddtQIyJ1-Jk3oXhFmbmd46jlqjai9E,10657
@@ -86,12 +86,12 @@ cdk_factory/stack_library/acm/__init__.py,sha256=4FNRLykblcKZvq_wieYwvv9N_jgrZnJ
 cdk_factory/stack_library/acm/acm_stack.py,sha256=QJ3GkT17PmWoGkfO5Um02hvrfyJ9HbiPMnclwDP7IbA,5846
 cdk_factory/stack_library/api_gateway/api_gateway_stack.py,sha256=PvLdGvcopGpLP0FwpfUcfXNiTIfYLTXqrG-TniE38yc,39643
 cdk_factory/stack_library/auto_scaling/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-cdk_factory/stack_library/auto_scaling/auto_scaling_stack.py,sha256=Ct1LkIlKKAi-F6CRNo2oJI0V-yLWvnHAokA367NtGsU,21851
+cdk_factory/stack_library/auto_scaling/auto_scaling_stack.py,sha256=6QDVkv6Zz-qCbT6h2MU9Sp1diFXDEyjJNk1-xWMbMJg,21990
 cdk_factory/stack_library/aws_lambdas/lambda_stack.py,sha256=SFbBPvvCopbyiuYtq-O5sQkFCf94Wzua6aDUXiFDSB4,26161
 cdk_factory/stack_library/buckets/README.md,sha256=XkK3UNVtRLE7NtUvbhCOBBYUYi8hlrrSaI1s3GJVrqI,78
 cdk_factory/stack_library/buckets/bucket_stack.py,sha256=SLoZqSffAqmeBBEVUQg54D_8Ad5UKdkjEAmKAVgAqQo,1778
 cdk_factory/stack_library/cloudfront/__init__.py,sha256=Zfx50q4xIJ4ZEoVIzUBDTKbRE9DKDM6iyVIFhtQXvww,153
-cdk_factory/stack_library/cloudfront/cloudfront_stack.py,sha256=kBMWxHlB48aRcFGIX71mRso0tEuEaQxcTBr3YCJOr4s,30210
+cdk_factory/stack_library/cloudfront/cloudfront_stack.py,sha256=yuNs_W5b85JSXXv6_17OAD-e-wUitDPrRlZV4bxjChU,31459
 cdk_factory/stack_library/code_artifact/code_artifact_stack.py,sha256=k831b_fAFoXSiwj5cencnCQzUSeuKIUyVCp6Ev_TMgI,6274
 cdk_factory/stack_library/cognito/cognito_stack.py,sha256=3tjKCNcIwXZn7fd4EDQdY6H9m6CnZohI4uTQ4TpacRQ,25327
 cdk_factory/stack_library/dynamodb/dynamodb_stack.py,sha256=-_Ij1zXIxUuZIWgdevam_1vD3LEJ6pFs9U0hmw0KwIw,6743
@@ -99,9 +99,9 @@ cdk_factory/stack_library/ecr/README.md,sha256=xw2wPx9WN03Y4BBwqvbi9lAFGNyaD1FUN
 cdk_factory/stack_library/ecr/ecr_stack.py,sha256=KLbd5WN5-ZiojsS5wJ4PX-tIL0cCylCSvXjO6sVrgWY,2102
 cdk_factory/stack_library/ecs/__init__.py,sha256=o5vGDtD_h-gVXb3-Ysr8xUNpEcMsnmMVgZv2Pupcdow,219
 cdk_factory/stack_library/ecs/ecs_cluster_stack.py,sha256=sAPTLU5CAwMoLTW_pNy_cd0OtVkfDR7IxxsSq5AE0yo,12091
-cdk_factory/stack_library/ecs/ecs_service_stack.py,sha256=3en447kWBOqd0d_i2C8mRRBscO2GqN9-B2l_PW7kZuM,27409
+cdk_factory/stack_library/ecs/ecs_service_stack.py,sha256=NWBSB-0GTWa0rHDO2o2KTIqvWDCR93CV9ghU-0Xm7Dk,27408
 cdk_factory/stack_library/lambda_edge/__init__.py,sha256=ByBJ_CWdc4UtTmFBZH-6pzBMNkjkdtE65AmnB0Fs6lM,156
-cdk_factory/stack_library/lambda_edge/lambda_edge_stack.py,sha256=ft5AxHy8__F90ZYDaoJwTjACGIfrn2Sd9Zr2CdHO7GE,16398
+cdk_factory/stack_library/lambda_edge/lambda_edge_stack.py,sha256=C_h2Xb2_zaCGiw5otbeSozOLNbxaciMLo8FX_TQOAlw,16409
 cdk_factory/stack_library/load_balancer/__init__.py,sha256=wZpKw2OecLJGdF5mPayCYAEhu2H3c2gJFFIxwXftGDU,52
 cdk_factory/stack_library/load_balancer/load_balancer_stack.py,sha256=o0sxQIayyvOVBIiBrNpY5GvENqnWiYQ16_rn2CGA6yk,29900
 cdk_factory/stack_library/monitoring/__init__.py,sha256=k1G_KDx47Aw0UugaL99PN_TKlyLK4nkJVApCaAK7GJg,153
@@ -109,7 +109,7 @@ cdk_factory/stack_library/monitoring/monitoring_stack.py,sha256=N_1YvEXE7fboH_S3
 cdk_factory/stack_library/rds/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 cdk_factory/stack_library/rds/rds_stack.py,sha256=5dk_SUMkbnSalD2AKI0c-LrKbaHB4OOgq6DmRa4QMbM,15377
 cdk_factory/stack_library/route53/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-cdk_factory/stack_library/route53/route53_stack.py,sha256=mPUJta6maUNlkXup7xKsqq7gefsRI1w_ulInE29wJs4,8387
+cdk_factory/stack_library/route53/route53_stack.py,sha256=4OeJxBTchcXHZznUQ6IIMuFmbsWtOoR0cIfDIIdHs8o,19624
 cdk_factory/stack_library/rum/__init__.py,sha256=gUrWQdzd4rZ2J0YzAQC8PsEGAS7QgyYjB2ZCUKWasy4,90
 cdk_factory/stack_library/rum/rum_stack.py,sha256=c67m0Jbyx8hx9TTx9TBBhZMDqtSK7QCqKx_Ec1t8LgY,14067
 cdk_factory/stack_library/security_group/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -136,8 +136,8 @@ cdk_factory/utilities/os_execute.py,sha256=5Op0LY_8Y-pUm04y1k8MTpNrmQvcLmQHPQITE
 cdk_factory/utils/api_gateway_utilities.py,sha256=If7Xu5s_UxmuV-kL3JkXxPLBdSVUKoLtohm0IUFoiV8,4378
 cdk_factory/validation/config_validator.py,sha256=Pb0TkLiPFzUplBOgMorhRCVm08vEzZhRU5xXCDTa5CA,17602
 cdk_factory/workload/workload_factory.py,sha256=yDI3cRhVI5ELNDcJPLpk9UY54Uind1xQoV3spzT4z7E,6068
-cdk_factory-0.18.9.dist-info/METADATA,sha256=P8DYXu4KJp-D52Bkdvg7mN9aFNDlC8toyp8Ls7gwvrE,2451
-cdk_factory-0.18.9.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-cdk_factory-0.18.9.dist-info/entry_points.txt,sha256=S1DPe0ORcdiwEALMN_WIo3UQrW_g4YdQCLEsc_b0Swg,53
-cdk_factory-0.18.9.dist-info/licenses/LICENSE,sha256=NOtdOeLwg2il_XBJdXUPFPX8JlV4dqTdDGAd2-khxT8,1066
-cdk_factory-0.18.9.dist-info/RECORD,,
+cdk_factory-0.18.16.dist-info/METADATA,sha256=_5MumwvtcwxpK7-7j2fkX349pq9kshbn49bFqaC7RLU,2452
+cdk_factory-0.18.16.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+cdk_factory-0.18.16.dist-info/entry_points.txt,sha256=S1DPe0ORcdiwEALMN_WIo3UQrW_g4YdQCLEsc_b0Swg,53
+cdk_factory-0.18.16.dist-info/licenses/LICENSE,sha256=NOtdOeLwg2il_XBJdXUPFPX8JlV4dqTdDGAd2-khxT8,1066
+cdk_factory-0.18.16.dist-info/RECORD,,