How to debug hotswap skipping in ECS deploy?

[akbisw]

Hotswapping skipping error:

Could not perform a hotswap deployment, because the CloudFormation template could not be resolved: CloudFormation function Fn::ImportValue is not supported
Falling back to doing a full deployment

I have lambda functions with just as many "Fn::ImportValue" that hotswap just fine. Any other way to debug why i am unable to hotswap ecs docker image? I have about 40 something import values to the ecs service and lambda.

Snippet below is how I instantiate the service

class FargateServiceBuilder(object):
    def __init__(
        self,
        base_stack: Stack,
        fargate_cluster: aws_ecs.Cluster,
        service_name: str,
        vpc: aws_ec2.Vpc,
        command: List[str],
        secret: aws_secretsmanager.Secret,
        port: int = 80,
        image_directory: str = "src",
        dockerfile_name: str = "Dockerfile",
        cpu: int = "1024",
    ):

        docker_image = aws_ecr_assets.DockerImageAsset(
            scope=self.base_stack,
            id=image_id,
            directory=f"{image_directory}",
        )

        container_image = aws_ecs.ContainerImage.from_docker_image_asset(
            asset=docker_image
        )

        self.service_task_definition = aws_ecs.FargateTaskDefinition(
            scope=self.base_stack,
            id=f"{self.service_name}-task-definition",
            cpu=self.cpu,
            memory_limit_mib=self.memory,
            runtime_platform=aws_ecs.RuntimePlatform(
                cpu_architecture=aws_ecs.CpuArchitecture.ARM64,
                operating_system_family=aws_ecs.OperatingSystemFamily.LINUX,
            ),
            family=f"{self.service_name}-task-family",
        )

        self.container_definition = self.service_task_definition.add_container(
            id=f"{self.service_name}-container",
            container_name=self.service_name,
            image=container_image,
            linux_parameters=aws_ecs.LinuxParameters(
                scope=self.base_stack,
                id=f"{self.service_name}-linux-params",
                init_process_enabled=True,
            ),
            port_mappings=[
                aws_ecs.PortMapping(
                    container_port=self.port,
                    protocol=aws_ecs.Protocol.TCP,
                )
            ],
            command=self.command,
            health_check=aws_ecs.HealthCheck(
                retries=3,
                command=["CMD-SHELL", "curl -f http://localhost/health || exit 1"],
                timeout=Duration.seconds(5),
                interval=Duration.seconds(10),
                start_period=Duration.seconds(15),
            ),
            essential=True,
            logging=aws_ecs.LogDrivers.firelens(
                secret_options={
                    "apikey": aws_ecs.Secret.from_secrets_manager(secret)
                },
            ),
        )

        load_balanced_fargate_service = (
            aws_ecs_patterns.NetworkLoadBalancedFargateService(
                scope=self.base_stack,
                id=f"{self.service_name}-service",
                service_name=f"{self.service_name}",
                cluster=self.fargate_cluster,
                cpu=self.cpu,
                desired_count=self.container_count,
                memory_limit_mib=self.memory,
                public_load_balancer=False,
                task_definition=self.service_task_definition,
                listener_port=self.port,
                health_check_grace_period=Duration.seconds(30),
                enable_execute_command=False,
                circuit_breaker=aws_ecs.DeploymentCircuitBreaker(
                    rollback=True,
                ),
            )
        )