@fjall/components-infrastructure 0.77.3 → 0.78.3

package/dist/lib/resources/aws/compute/ecs.js

@@ -14,8 +14,11 @@ const aws_certificatemanager_1 = require("aws-cdk-lib/aws-certificatemanager");
 const aws_route53_1 = require("aws-cdk-lib/aws-route53");
 const aws_route53_targets_1 = require("aws-cdk-lib/aws-route53-targets");
 const aws_ecr_1 = require("aws-cdk-lib/aws-ecr");
+const aws_autoscaling_1 = require("aws-cdk-lib/aws-autoscaling");
 const cfnOutput_1 = require("../utilities/cfnOutput");
 const hostedZone_1 = require("../../../patterns/aws/hostedZone");
+const securityGroup_1 = require("../iam/securityGroup");
+const capacityProviderDrainWaiter_1 = require("./utilities/capacityProviderDrainWaiter");
 var Protocol;
 (function (Protocol) {
     Protocol[Protocol["HTTP"] = 0] = "HTTP";
@@ -26,43 +29,593 @@ var ScalingType;
     ScalingType["CPU"] = "ECSServiceAverageCPUUtilization";
     ScalingType["MEMORY"] = "ECSServiceAverageMemoryUtilization";
 })(ScalingType || (exports.ScalingType = ScalingType = {}));
-class FargateCluster extends constructs_1.Construct {
+/**
+ * ECS Cluster supporting multiple services with a shared ALB.
+ *
+ * @example
+ * // Single service cluster
+ * new EcsCluster(scope, "WebCluster", {
+ *   clusterName: "WebCluster",
+ *   ecrRepository: ecr,
+ *   services: [
+ *     { name: "web", containers: [{ name: "app", port: 3000 }] }
+ *   ]
+ * });
+ *
+ * @example
+ * // Multi-service cluster with routing
+ * new EcsCluster(scope, "ApiCluster", {
+ *   clusterName: "ApiCluster",
+ *   cluster: { domain: "api.example.com" },
+ *   ecrRepository: ecr,
+ *   services: [
+ *     { name: "users", containers: [{ name: "app", port: 3000 }], routing: { path: "/users/*" } },
+ *     { name: "orders", containers: [{ name: "app", port: 3001 }], routing: { path: "/orders/*" } }
+ *   ]
+ * });
+ *
+ * @example
+ * // Worker cluster (no ALB)
+ * new EcsCluster(scope, "Workers", {
+ *   clusterName: "Workers",
+ *   cluster: { loadBalancer: false },
+ *   ecrRepository: ecr,
+ *   services: [
+ *     { name: "processor", containers: [{ name: "worker" }] }
+ *   ]
+ * });
+ */
+class EcsCluster extends constructs_1.Construct {
     constructor(scope, id, props) {
         super(scope, id);
-        this.secrets = {};
+        // Per-service tracking
+        this.services = new Map();
+        this.nextPriority = 100;
         this.scope = scope;
+        this.props = props;
+        this.capacityProvider = props.capacityProvider || "FARGATE";
+        this.directAccessEnabled = props.cluster?.directAccess === true;
+        this.loadBalancerDisabled =
+            props.cluster?.loadBalancer === false || this.directAccessEnabled;
+        this.validateProps(props);
+        // 1. Create the ECS cluster
         this.addCluster(props);
-        this.addSecrets(props);
-        this.importSecrets(props);
-        this.addExecutionRole(props);
-        this.addTaskDefinition(props);
-        this.addContainerDefinition(props);
-        this.addFargateService(props);
-        this.addLoadBalancer(props);
-        if (props.domainConfig)
-            this.addHostedZone(props);
-        this.addLoadBalancerListener(props);
-        this.registerLoadBalancerTargets(props);
-        const containerPort = props.containerPort || 80;
+        // 2. Set up EC2 infrastructure if needed
+        if (this.isEc2()) {
+            this.addAutoScalingGroup(props);
+        }
+        // 3. Create ALB if not disabled (shared by all services)
+        if (!this.loadBalancerDisabled) {
+            this.addLoadBalancer(props);
+            // Set up domain/HTTPS if configured
+            if (props.cluster?.domain || props.cluster?.domainConfig) {
+                this.addHostedZone(props);
+            }
+            this.addLoadBalancerListener(props);
+        }
+        else if (this.directAccessEnabled) {
+            this.addDirectAccessOutputs(props);
+        }
+        // 4. Create each service
+        for (const serviceProps of props.services) {
+            this.addServiceToCluster(serviceProps);
+        }
+        // 5. Set up connections
+        this.setupConnections(props);
+    }
+    /** Get the cluster's load balancer. Undefined if disabled. */
+    getLoadBalancer() {
+        return this.loadBalancer;
+    }
+    /** Get the load balancer's listener. Undefined if disabled. */
+    getListener() {
+        return this.loadBalancerListener;
+    }
+    /** Get a specific service by name. */
+    getService(name) {
+        return this.services.get(name)?.service;
+    }
+    /** Get all services in this cluster. */
+    getServices() {
+        const result = new Map();
+        for (const [name, data] of this.services) {
+            result.set(name, data.service);
+        }
+        return result;
+    }
+    /** Get the ECS cluster construct. */
+    getCluster() {
+        return this.cluster;
+    }
+    /** Get the ALB URL (http:// or https://). */
+    getUrl() {
+        if (!this.loadBalancer)
+            return undefined;
+        const protocol = this.certificate ? "https" : "http";
+        const domain = this.props.cluster?.domain || this.loadBalancer.loadBalancerDnsName;
+        return `${protocol}://${domain}`;
+    }
+    /**
+     * Add a service to the cluster.
+     * Each service gets its own task definition, containers, and target group.
+     */
+    addServiceToCluster(serviceProps) {
+        const serviceName = serviceProps.name;
+        // Create separate roles for security best practice
+        const executionRole = this.createExecutionRole(serviceName);
+        const taskRole = this.createTaskRole(serviceName, serviceProps);
+        // Create task definition with both roles
+        const taskDefinition = this.createTaskDefinition(serviceName, serviceProps, executionRole, taskRole);
+        // Add containers to task definition
+        const { containers, primaryContainer } = this.addContainersToTask(serviceName, serviceProps, taskDefinition);
+        // Create the ECS service
+        const service = this.createService(serviceName, serviceProps, taskDefinition);
+        // Register with ALB if enabled and has primary container with port
+        let targetGroup;
+        if (!this.loadBalancerDisabled &&
+            primaryContainer &&
+            this.loadBalancerListener) {
+            targetGroup = this.registerServiceWithALB(serviceName, serviceProps, service, primaryContainer);
+        }
+        // Add scaling if configured
+        let scalingPolicy;
+        if (serviceProps.scalingType) {
+            scalingPolicy = this.addServiceScaling(serviceName, serviceProps, service);
+        }
+        // Store service data
+        this.services.set(serviceName, {
+            service,
+            taskDefinition,
+            executionRole,
+            taskRole,
+            containers,
+            primaryContainer,
+            targetGroup,
+            scalingPolicy
+        });
+        // Add service level connections
+        if (serviceProps.connections && serviceProps.connections.length > 0) {
+            for (const connectable of serviceProps.connections) {
+                service.connections.allowToDefaultPort(connectable);
+            }
+        }
+    }
+    validateProps(props) {
+        // Validate services array
+        if (!props.services || props.services.length === 0) {
+            throw new Error("At least one service must be specified.");
+        }
+        // Check for duplicate service names
+        const serviceNames = props.services.map((s) => s.name);
+        const duplicateServices = serviceNames.filter((name, index) => serviceNames.indexOf(name) !== index);
+        if (duplicateServices.length > 0) {
+            throw new Error(`Duplicate service names: ${[...new Set(duplicateServices)].join(", ")}`);
+        }
+        // Validate routing when multiple services have ports
+        const servicesWithPorts = props.services.filter((s) => s.containers.some((c) => c.port !== undefined));
+        if (servicesWithPorts.length > 1 && !this.loadBalancerDisabled) {
+            const missingRouting = servicesWithPorts.filter((s) => !s.routing?.path && !s.routing?.host);
+            if (missingRouting.length > 0) {
+                throw new Error(`Services with ports require routing config when cluster has multiple services: ` +
+                    `${missingRouting.map((s) => s.name).join(", ")}. ` +
+                    "Add routing: { path: '/...' } to each service.");
+            }
+        }
+        // Validate each service's containers
+        for (const service of props.services) {
+            if (!service.containers || service.containers.length === 0) {
+                throw new Error(`Service '${service.name}': At least one container must be specified.`);
+            }
+            // Check for duplicate container names within service
+            const containerNames = service.containers.map((c) => c.name);
+            const duplicateContainers = containerNames.filter((name, index) => containerNames.indexOf(name) !== index);
+            if (duplicateContainers.length > 0) {
+                throw new Error(`Service '${service.name}': Duplicate container names: ` +
+                    `${[...new Set(duplicateContainers)].join(", ")}`);
+            }
+        }
+    }
+    setupConnections(props) {
+        // Find the first service with a port for default connection
+        let defaultPort = 80;
+        for (const service of props.services) {
+            const primaryContainer = service.containers.find((c) => c.port !== undefined);
+            if (primaryContainer?.port) {
+                defaultPort = primaryContainer.port;
+                break;
+            }
+        }
+        let securityGroups = [];
+        if (this.isEc2()) {
+            securityGroups = [this.asgSecurityGroup];
+        }
+        else {
+            const firstService = this.services.values().next().value;
+            securityGroups = firstService?.service?.connections?.securityGroups || [];
+        }
         this.connections = new aws_ec2_1.Connections({
-            securityGroups: this.fargateService.connections.securityGroups,
-            defaultPort: aws_ec2_1.Port.tcp(containerPort)
+            securityGroups,
+            defaultPort: aws_ec2_1.Port.tcp(defaultPort)
+        });
+    }
+    /**
+     * Creates the execution role for ECS infrastructure operations.
+     * Used by the ECS agent to pull images, write logs, and inject secrets.
+     * NOT used by application code - that's the task role.
+     */
+    createExecutionRole(serviceName) {
+        const executionRole = new aws_iam_1.Role(this, `${serviceName}ExecutionRole`, {
+            assumedBy: new aws_iam_1.ServicePrincipal("ecs-tasks.amazonaws.com")
+        });
+        // ECR pull permissions
+        executionRole.addToPolicy(new aws_iam_1.PolicyStatement({
+            effect: aws_iam_1.Effect.ALLOW,
+            actions: [
+                "ecr:GetAuthorizationToken",
+                "ecr:BatchCheckLayerAvailability",
+                "ecr:GetDownloadUrlForLayer",
+                "ecr:BatchGetImage"
+            ],
+            resources: ["*"]
+        }));
+        // CloudWatch Logs permissions
+        executionRole.addToPolicy(new aws_iam_1.PolicyStatement({
+            effect: aws_iam_1.Effect.ALLOW,
+            actions: [
+                "logs:CreateLogStream",
+                "logs:PutLogEvents",
+                "logs:CreateLogGroup"
+            ],
+            resources: ["*"]
+        }));
+        // Secrets Manager access for injecting secrets into containers
+        executionRole.addToPolicy(new aws_iam_1.PolicyStatement({
+            effect: aws_iam_1.Effect.ALLOW,
+            actions: [
+                "secretsmanager:GetSecretValue",
+                "secretsmanager:DescribeSecret"
+            ],
+            resources: ["*"]
+        }));
+        // KMS decrypt for secrets encrypted with customer-managed keys
+        executionRole.addToPolicy(new aws_iam_1.PolicyStatement({
+            effect: aws_iam_1.Effect.ALLOW,
+            actions: ["kms:Decrypt"],
+            resources: ["*"]
+        }));
+        return executionRole;
+    }
+    /**
+     * Creates the task role for application code running in the container.
+     * This role is assumed by the application, not the ECS agent.
+     * Includes default ECS Exec permissions plus any service-specific policies.
+     */
+    createTaskRole(serviceName, serviceProps) {
+        const taskRole = new aws_iam_1.Role(this, `${serviceName}TaskRole`, {
+            assumedBy: new aws_iam_1.ServicePrincipal("ecs-tasks.amazonaws.com")
+        });
+        // Default: SSM permissions for ECS Exec (ecs execute-command)
+        taskRole.addToPolicy(new aws_iam_1.PolicyStatement({
+            effect: aws_iam_1.Effect.ALLOW,
+            actions: [
+                "ssmmessages:CreateControlChannel",
+                "ssmmessages:CreateDataChannel",
+                "ssmmessages:OpenControlChannel",
+                "ssmmessages:OpenDataChannel"
+            ],
+            resources: ["*"]
+        }));
+        // Add service-specific inline policies
+        if (serviceProps.taskRoleInlinePolicies) {
+            for (const [policyName, policyDocument] of Object.entries(serviceProps.taskRoleInlinePolicies)) {
+                taskRole.attachInlinePolicy(new aws_iam_1.Policy(this, `${serviceName}${policyName}`, {
+                    document: policyDocument
+                }));
+            }
+        }
+        // Add service-specific managed policies
+        if (serviceProps.taskRoleManagedPolicies) {
+            for (const policy of serviceProps.taskRoleManagedPolicies) {
+                taskRole.addManagedPolicy(policy);
+            }
+        }
+        return taskRole;
+    }
+    createTaskDefinition(serviceName, serviceProps, executionRole, taskRole) {
+        const cpu = serviceProps.cpu || 256;
+        const memoryLimitMiB = serviceProps.memoryLimitMiB || 512;
+        if (this.isFargate()) {
+            return new aws_ecs_1.FargateTaskDefinition(this, `${serviceName}TaskDefinition`, {
+                family: `${this.props.clusterName}-${serviceName}`,
+                cpu,
+                memoryLimitMiB,
+                executionRole,
+                taskRole,
+                runtimePlatform: {
+                    cpuArchitecture: aws_ecs_1.CpuArchitecture.ARM64,
+                    operatingSystemFamily: aws_ecs_1.OperatingSystemFamily.LINUX
+                }
+            });
+        }
+        else {
+            return new aws_ecs_1.Ec2TaskDefinition(this, `${serviceName}TaskDefinition`, {
+                family: `${this.props.clusterName}-${serviceName}`,
+                executionRole,
+                taskRole,
+                ...(this.directAccessEnabled && { networkMode: aws_ecs_1.NetworkMode.HOST })
+            });
+        }
+    }
+    addContainersToTask(serviceName, serviceProps, taskDefinition) {
+        const containers = [];
+        let primaryContainer;
+        for (const containerConfig of serviceProps.containers) {
+            const image = this.getContainerImage(serviceName, containerConfig, serviceProps);
+            const isFirstWithPort = !primaryContainer && containerConfig.port !== undefined;
+            // Build secrets
+            const secrets = {};
+            if (containerConfig.secretsImport) {
+                for (const [key, secretImport] of Object.entries(containerConfig.secretsImport)) {
+                    const secret = aws_secretsmanager_1.Secret.fromSecretNameV2(this, `${serviceName}${containerConfig.name}${key}Secret`, secretImport.name);
+                    secrets[key] = aws_ecs_2.Secret.fromSecretsManager(secret, secretImport.field);
+                }
+            }
+            const container = taskDefinition.addContainer(`${serviceName}${containerConfig.name}`, {
+                image,
+                containerName: containerConfig.name,
+                logging: new aws_ecs_1.AwsLogDriver({
+                    streamPrefix: `/ecs/${this.props.clusterName}/${serviceName}/${containerConfig.name}`,
+                    logRetention: 14
+                }),
+                environment: containerConfig.environment,
+                secrets,
+                command: containerConfig.command,
+                entryPoint: containerConfig.entryPoint,
+                essential: containerConfig.essential ?? true,
+                healthCheck: containerConfig.healthCheck
+                    ? {
+                        command: containerConfig.healthCheck.command,
+                        interval: containerConfig.healthCheck.interval
+                            ? aws_cdk_lib_1.Duration.seconds(containerConfig.healthCheck.interval)
+                            : undefined,
+                        timeout: containerConfig.healthCheck.timeout
+                            ? aws_cdk_lib_1.Duration.seconds(containerConfig.healthCheck.timeout)
+                            : undefined,
+                        retries: containerConfig.healthCheck.retries,
+                        startPeriod: containerConfig.healthCheck.startPeriod
+                            ? aws_cdk_lib_1.Duration.seconds(containerConfig.healthCheck.startPeriod)
+                            : undefined
+                    }
+                    : undefined,
+                ...(this.isEc2() && {
+                    memoryLimitMiB: this.props.ec2Config?.memoryLimitMiB || 1024
+                })
+            });
+            if (containerConfig.port) {
+                container.addPortMappings({
+                    containerPort: containerConfig.port
+                });
+            }
+            if (isFirstWithPort) {
+                primaryContainer = container;
+            }
+            containers.push(container);
+        }
+        return { containers, primaryContainer };
+    }
+    getContainerImage(serviceName, containerConfig, serviceProps) {
+        // Priority: container.image > service.image > cluster default
+        const imageSource = containerConfig.image || serviceProps.image || this.props.ecrRepository;
+        if (!imageSource) {
+            return aws_ecs_1.ContainerImage.fromRegistry("amazon/amazon-ecs-sample");
+        }
+        // For multi-service deployments, use service-prefixed tags
+        const isMultiService = this.props.services.length > 1;
+        const imageTag = isMultiService ? `${serviceName}-latest` : "latest";
+        if (typeof imageSource === "string") {
+            // Check if it's an ECR repository name or a public image
+            if (imageSource.includes("/") && !imageSource.includes(".")) {
+                return aws_ecs_1.ContainerImage.fromRegistry(imageSource);
+            }
+            return aws_ecs_1.ContainerImage.fromEcrRepository(aws_ecr_1.Repository.fromRepositoryName(this, `${serviceName}${containerConfig.name}EcrRepo`, imageSource), imageTag);
+        }
+        if (imageSource instanceof aws_ecr_1.Repository) {
+            return aws_ecs_1.ContainerImage.fromEcrRepository(imageSource, imageTag);
+        }
+        // RepositoryImage extends ContainerImage, so this is a safe upcast
+        return imageSource;
+    }
+    createService(serviceName, serviceProps, taskDefinition) {
+        const desiredCount = serviceProps.desiredCount ?? 2;
+        if (this.isFargate()) {
+            const service = new aws_ecs_1.FargateService(this, `${serviceName}Service`, {
+                cluster: this.cluster,
+                taskDefinition: taskDefinition,
+                desiredCount,
+                serviceName,
+                capacityProviderStrategies: [
+                    {
+                        capacityProvider: this.capacityProvider,
+                        weight: 1
+                    }
+                ],
+                propagateTags: aws_ecs_1.PropagatedTagSource.SERVICE,
+                circuitBreaker: { enable: true, rollback: true },
+                enableECSManagedTags: true,
+                enableExecuteCommand: true,
+                healthCheckGracePeriod: aws_cdk_lib_1.Duration.seconds(120),
+                minHealthyPercent: 100,
+                maxHealthyPercent: 200
+            });
+            new cfnOutput_1.CfnOutput(this, `${serviceName}ServiceArn`, {
+                key: `${serviceName}ServiceArn`,
+                exportName: `${this.props.clusterName}${serviceName}ServiceArn`,
+                value: service.serviceArn,
+                description: `ECS Service ARN for ${serviceName}`
+            });
+            // Fargate service depends on capacity provider associations:
+            // - CREATE: Associations created first, then Service (correct - providers ready before service)
+            // - DELETE: Service deleted first, then Associations (correct - services gone before disassociation)
+            // This ensures CloudFormation deletes all services BEFORE attempting to remove
+            // the FARGATE/FARGATE_SPOT capacity provider associations from the cluster.
+            // See: https://github.com/aws/aws-cdk/issues/15366
+            if (this.fargateCapacityProviderAssociations) {
+                service.node.addDependency(this.fargateCapacityProviderAssociations);
+            }
+            return service;
+        }
+        else {
+            const service = new aws_ecs_1.Ec2Service(this, `${serviceName}Service`, {
+                cluster: this.cluster,
+                taskDefinition: taskDefinition,
+                desiredCount,
+                serviceName,
+                capacityProviderStrategies: [
+                    {
+                        capacityProvider: this.asgCapacityProvider.capacityProviderName,
+                        weight: 1
+                    }
+                ],
+                propagateTags: aws_ecs_1.PropagatedTagSource.SERVICE,
+                circuitBreaker: { enable: true, rollback: true },
+                placementStrategies: [aws_ecs_1.PlacementStrategy.spreadAcrossInstances()],
+                enableECSManagedTags: true,
+                enableExecuteCommand: true,
+                healthCheckGracePeriod: aws_cdk_lib_1.Duration.seconds(120),
+                minHealthyPercent: 100,
+                maxHealthyPercent: 200
+            });
+            new cfnOutput_1.CfnOutput(this, `${serviceName}ServiceArn`, {
+                key: `${serviceName}ServiceArn`,
+                exportName: `${this.props.clusterName}${serviceName}ServiceArn`,
+                value: service.serviceArn,
+                description: `ECS Service ARN for ${serviceName}`
+            });
+            // Service depends on DrainWaiter:
+            // - CREATE: DrainWaiter created first, then Service (correct - infra ready before service)
+            // - DELETE: Service deleted first, then DrainWaiter runs (correct - services gone before drain)
+            // This ensures CloudFormation deletes all services BEFORE the DrainWaiter Lambda runs,
+            // which then disassociates the capacity provider before it's deleted.
+            if (this.drainWaiter) {
+                service.node.addDependency(this.drainWaiter);
+            }
+            return service;
+        }
+    }
+    registerServiceWithALB(serviceName, serviceProps, service, primaryContainer) {
+        const containerPort = primaryContainer.containerPort;
+        const healthCheckPath = serviceProps.routing?.healthCheckPath || "/";
+        // Determine routing conditions
+        const servicesWithPorts = this.props.services.filter((s) => s.containers.some((c) => c.port !== undefined));
+        const isSingleService = servicesWithPorts.length === 1;
+        const healthCheckConfig = this.isEc2()
+            ? {
+                interval: aws_cdk_lib_1.Duration.seconds(30),
+                healthyThresholdCount: 3,
+                unhealthyThresholdCount: 3,
+                path: healthCheckPath,
+                port: "traffic-port",
+                timeout: aws_cdk_lib_1.Duration.seconds(15)
+            }
+            : {
+                interval: aws_cdk_lib_1.Duration.seconds(120),
+                path: healthCheckPath,
+                port: `${containerPort}`,
+                timeout: aws_cdk_lib_1.Duration.seconds(10)
+            };
+        if (isSingleService) {
+            // Single service - create target group with service as default target
+            return this.loadBalancerListener.addTargets(`${serviceName}TargetGroup`, {
+                targets: [
+                    service.loadBalancerTarget({
+                        containerName: primaryContainer.containerName,
+                        containerPort
+                    })
+                ],
+                port: containerPort,
+                protocol: aws_elasticloadbalancingv2_1.ApplicationProtocol.HTTP,
+                healthCheck: healthCheckConfig
+            });
+        }
+        else {
+            // Multi-service - create target group with routing rules
+            const priority = serviceProps.routing?.priority || this.nextPriority++;
+            const targetGroup = this.loadBalancerListener.addTargets(`${serviceName}Targets`, {
+                targets: [
+                    service.loadBalancerTarget({
+                        containerName: primaryContainer.containerName,
+                        containerPort
+                    })
+                ],
+                port: containerPort,
+                protocol: aws_elasticloadbalancingv2_1.ApplicationProtocol.HTTP,
+                healthCheck: healthCheckConfig,
+                conditions: this.buildRoutingConditions(serviceProps),
+                priority
+            });
+            return targetGroup;
+        }
+    }
+    buildRoutingConditions(serviceProps) {
+        const conditions = [];
+        if (serviceProps.routing?.path) {
+            conditions.push(aws_elasticloadbalancingv2_1.ListenerCondition.pathPatterns([serviceProps.routing.path]));
+        }
+        if (serviceProps.routing?.host) {
+            conditions.push(aws_elasticloadbalancingv2_1.ListenerCondition.hostHeaders([serviceProps.routing.host]));
+        }
+        return conditions;
+    }
+    addServiceScaling(serviceName, serviceProps, service) {
+        const scalableTarget = new aws_applicationautoscaling_1.ScalableTarget(this, `${serviceName}ScalableTarget`, {
+            serviceNamespace: aws_applicationautoscaling_1.ServiceNamespace.ECS,
+            resourceId: `service/${this.cluster.clusterName}/${service.serviceName}`,
+            scalableDimension: "ecs:service:DesiredCount",
+            minCapacity: serviceProps.minCapacity ?? 2,
+            maxCapacity: serviceProps.maxCapacity ?? 10
         });
+        return new aws_applicationautoscaling_1.TargetTrackingScalingPolicy(this, `${serviceName}ScalingPolicy`, {
+            scalingTarget: scalableTarget,
+            predefinedMetric: serviceProps.scalingType === ScalingType.MEMORY
+                ? aws_applicationautoscaling_1.PredefinedMetric.ECS_SERVICE_AVERAGE_MEMORY_UTILIZATION
+                : aws_applicationautoscaling_1.PredefinedMetric.ECS_SERVICE_AVERAGE_CPU_UTILIZATION,
+            targetValue: 50,
+            scaleInCooldown: aws_cdk_lib_1.Duration.seconds(60),
+            scaleOutCooldown: aws_cdk_lib_1.Duration.seconds(60)
+        });
+    }
+    isEc2() {
+        return this.capacityProvider === "EC2";
+    }
+    isFargate() {
+        return (this.capacityProvider === "FARGATE" ||
+            this.capacityProvider === "FARGATE_SPOT");
     }
     addCluster(props) {
         this.cluster = new aws_ecs_1.Cluster(this, `${props.clusterName}`, {
             vpc: props.vpc,
             clusterName: props.clusterName,
             containerInsightsV2: aws_ecs_1.ContainerInsights.ENABLED,
-            enableFargateCapacityProviders: true
+            enableFargateCapacityProviders: this.isFargate()
         });
-        // Output used to auto-detect deployable cluter
+        // For Fargate clusters, find the internal CfnClusterCapacityProviderAssociations
+        // that CDK creates when enableFargateCapacityProviders is true.
+        // We need this reference to establish proper deletion dependencies.
+        if (this.isFargate()) {
+            // CDK creates this as a child of the cluster with a specific naming pattern
+            const children = this.cluster.node.children;
+            for (const child of children) {
+                if (child instanceof aws_ecs_1.CfnClusterCapacityProviderAssociations) {
+                    this.fargateCapacityProviderAssociations = child;
+                    break;
+                }
+            }
+        }
         new cfnOutput_1.CfnOutput(this, `${props.clusterName}DeployableCluster`, {
             key: `${props.clusterName}DeployableCluster`,
             exportName: `${props.clusterName}DeployableCluster`,
             value: this.cluster.clusterArn
         });
-        // Export cluster ARN for monitoring
         new cfnOutput_1.CfnOutput(this, `${props.clusterName}ClusterArn`, {
             key: "ClusterArn",
             exportName: `${props.clusterName}ClusterArn`,
@@ -70,207 +623,110 @@ class FargateCluster extends constructs_1.Construct {
             description: `ECS Cluster ARN for ${props.clusterName}`
         });
     }
-    /**
-     * #todo: change this to create new secrets instead
-     * @deprecated use importSecrets instead
-     */
-    addSecrets(props) {
-        // Container Secrets
-        const containerSecret = aws_secretsmanager_1.Secret.fromSecretNameV2(this, `${props.clusterName}Secret`, `/${props.clusterName}/${props.serviceName}`);
-        for (const secretField in props.containerSecrets) {
-            this.secrets[secretField] = aws_ecs_2.Secret.fromSecretsManager(containerSecret, secretField);
-        }
-    }
-    /**
-     * Automatically import secrets from another resource or stack
-     */
-    importSecrets(props) {
-        if (!props.containerSecretsImport)
-            return;
-        for (const key in props.containerSecretsImport) {
-            const importSecret = props.containerSecretsImport[key];
-            // todo: I think ID needs to be a new value as it ID's the IMPORT not the secret itself?
-            // Construct the AWS ISecret object
-            const iSecret = aws_secretsmanager_1.Secret.fromSecretNameV2(this, importSecret.id, importSecret.name);
-            this.secrets[key] = aws_ecs_2.Secret.fromSecretsManager(iSecret, importSecret.field);
-        }
-    }
-    addExecutionRole(props) {
-        this.executionRole = new aws_iam_1.Role(this, `${props.serviceName}ExecutionRole${aws_cdk_lib_1.Stack.of(this).region}`, {
-            roleName: `${props.serviceName}ExecutionRole${aws_cdk_lib_1.Stack.of(this).region}`,
-            description: `${props.serviceName} Execution Role`,
-            managedPolicies: [
-                {
-                    managedPolicyArn: "arn:aws:iam::aws:policy/service-role/AmazonECSTaskExecutionRolePolicy"
-                }
-            ],
-            inlinePolicies: {
-                ["readSecrets"]: new aws_iam_1.PolicyDocument({
-                    statements: [
-                        new aws_iam_1.PolicyStatement({
-                            actions: [
-                                "secretsmanager:GetSecretValue",
-                                "secretsmanager:DescribeSecret"
-                            ],
-                            resources: ["*"] // TODO: Set this to the secret ARN
-                        })
-                    ]
-                }),
-                ["decryptSecrets"]: new aws_iam_1.PolicyDocument({
-                    statements: [
-                        new aws_iam_1.PolicyStatement({
-                            actions: ["kms:Decrypt"],
-                            resources: ["*"] // TODO: Set this to the KMS Arn
-                        })
-                    ]
-                }),
-                ["ecsExecuteCommand"]: new aws_iam_1.PolicyDocument({
-                    statements: [
-                        new aws_iam_1.PolicyStatement({
-                            actions: [
-                                "ssmmessages:CreateControlChannel",
-                                "ssmmessages:CreateDataChannel",
-                                "ssmmessages:OpenControlChannel",
-                                "ssmmessages:OpenDataChannel"
-                            ],
-                            effect: aws_iam_1.Effect.ALLOW,
-                            resources: ["*"]
-                        })
-                    ]
-                })
-            },
-            assumedBy: new aws_iam_1.CompositePrincipal(new aws_iam_1.ServicePrincipal("ecs-tasks.amazonaws.com"))
-        });
-    }
-    addTaskDefinition(props) {
-        this.taskDefinition = new aws_ecs_1.FargateTaskDefinition(this, `${props.serviceName}TaskDefinition`, {
-            cpu: props.cpu || 256,
-            executionRole: this.executionRole,
-            taskRole: new aws_iam_1.Role(this, `${props.serviceName}TaskRole${aws_cdk_lib_1.Stack.of(this).region}`, {
-                roleName: `${props.serviceName}TaskRole${aws_cdk_lib_1.Stack.of(this).region}`,
-                description: `${props.serviceName} Task Role`,
-                inlinePolicies: props.taskRoleInlinePolicies,
-                managedPolicies: props.taskRoleManagedPolicies,
-                assumedBy: new aws_iam_1.CompositePrincipal(new aws_iam_1.ServicePrincipal("ecs-tasks.amazonaws.com"))
-            }),
-            memoryLimitMiB: props.memoryLimitMiB || 512
+    addAutoScalingGroup(props) {
+        const ec2Config = props.ec2Config || {};
+        const instanceType = ec2Config.instanceType || "t3.micro";
+        const amiHardwareType = ec2Config.amiHardwareType === "STANDARD"
+            ? aws_ecs_1.AmiHardwareType.STANDARD
+            : aws_ecs_1.AmiHardwareType.ARM;
+        const minCapacity = ec2Config.minCapacity ?? 2;
+        const maxCapacity = ec2Config.maxCapacity ?? 3;
+        this.asgSecurityGroup = new securityGroup_1.SecurityGroup(this, `AsgSecurityGroup`, {
+            vpc: this.cluster.vpc,
+            description: `Security group for the ${props.clusterName} auto scaling group`
         });
-    }
-    addContainerDefinition(props) {
-        this.containerDefinition = this.taskDefinition.addContainer(`${props.serviceName}ContainerDefinition`, {
-            image: this.getImage(props),
-            containerName: props.serviceName,
-            environment: {
-                ...props.containerEnvironment
-            },
-            command: props.containerCommand,
-            secrets: {
-                ...this.secrets
-            },
-            //todo: provide health check options
-            healthCheck: {
-                command: [
-                    "CMD-SHELL",
-                    // https://docs.aws.amazon.com/AmazonECS/latest/developerguide/view-container-health.html
-                    //  >> proc/1/fd/1 2>&1 redirects stdout and stderr of the health check to CloudWatch logs
-                    // `curl -f http://localhost:${props.containerPort}/ >> /proc/1/fd/1 2>&1  || exit 1`
-                    `curl -f http://localhost:${props.containerPort}/ || exit 1`
-                ]
+        // Open container ports for direct EC2 access
+        if (this.directAccessEnabled) {
+            for (const service of props.services) {
+                for (const container of service.containers) {
+                    if (container.port) {
+                        this.asgSecurityGroup.addIngressRule(aws_ec2_1.Peer.anyIpv4(), aws_ec2_1.Port.tcp(container.port), `Direct access to container port ${container.port}`);
+                    }
+                }
+            }
+        }
+        this.autoScalingGroup = new aws_autoscaling_1.AutoScalingGroup(this, "AutoScalingGroup", {
+            autoScalingGroupName: `${props.clusterName}AutoScalingGroup`,
+            vpc: this.cluster.vpc,
+            vpcSubnets: {
+                subnetType: aws_ec2_1.SubnetType.PUBLIC
             },
-            logging: new aws_ecs_1.AwsLogDriver({
-                streamPrefix: `/ecs/${props.clusterName}/${props.serviceName}`,
-                logRetention: 14
-            }),
-            portMappings: props.containerPort
-                ? [{ containerPort: props.containerPort }]
-                : [{ containerPort: 80 }]
-        });
-    }
-    addFargateService(props) {
-        this.fargateService = new aws_ecs_1.FargateService(this, `${props.serviceName}FargateService`, {
-            circuitBreaker: { rollback: true },
-            cluster: this.cluster,
-            desiredCount: 2,
-            enableECSManagedTags: true,
-            enableExecuteCommand: true,
-            propagateTags: aws_ecs_1.PropagatedTagSource.SERVICE,
-            serviceName: `${props.serviceName}`,
-            taskDefinition: this.taskDefinition,
-            minHealthyPercent: 100,
-            maxHealthyPercent: 200
+            securityGroup: this.asgSecurityGroup,
+            minCapacity,
+            maxCapacity,
+            instanceType: new aws_ec2_1.InstanceType(instanceType),
+            capacityRebalance: true,
+            instanceMonitoring: aws_autoscaling_1.Monitoring.BASIC,
+            machineImage: aws_ecs_1.EcsOptimizedImage.amazonLinux2(amiHardwareType)
         });
-        // Output used to detect deployable service
-        new cfnOutput_1.CfnOutput(this, `${props.clusterName}DeployableService`, {
-            key: `${props.clusterName}DeployableService`,
-            exportName: `${props.clusterName}DeployableService`,
-            value: this.fargateService.serviceArn
-        });
-        // Export service ARN for monitoring
-        new cfnOutput_1.CfnOutput(this, `${props.clusterName}ServiceArn`, {
-            key: "ServiceArn",
-            exportName: `${props.clusterName}ServiceArn`,
-            value: this.fargateService.serviceArn,
-            description: `ECS Service ARN for ${props.serviceName}`
-        });
-    }
-    addScalingPolicy(props) {
-        this.scalingPolicy = new aws_applicationautoscaling_1.TargetTrackingScalingPolicy(this, `${props.serviceName}ScalingPolicy`, {
-            policyName: `${props.serviceName}ScalingPolicy`,
-            scalingTarget: new aws_applicationautoscaling_1.ScalableTarget(this, `${props.serviceName}scalableTarget`, {
-                maxCapacity: 10,
-                minCapacity: 2,
-                resourceId: `service/${this.cluster.clusterName}/${this.fargateService.serviceName}`,
-                scalableDimension: "ecs:service:DesiredCount",
-                serviceNamespace: aws_applicationautoscaling_1.ServiceNamespace.ECS
-            }),
-            targetValue: 50,
-            scaleOutCooldown: aws_cdk_lib_1.Duration.seconds(60),
-            scaleInCooldown: aws_cdk_lib_1.Duration.seconds(60),
-            predefinedMetric: props.scalingType == ScalingType.MEMORY
-                ? aws_applicationautoscaling_1.PredefinedMetric.ECS_SERVICE_AVERAGE_MEMORY_UTILIZATION
-                : aws_applicationautoscaling_1.PredefinedMetric.ECS_SERVICE_AVERAGE_CPU_UTILIZATION
+        this.asgCapacityProvider = new aws_ecs_1.AsgCapacityProvider(this, "AsgCapacityProvider", {
+            autoScalingGroup: this.autoScalingGroup,
+            enableManagedDraining: true,
+            enableManagedTerminationProtection: false
         });
-    }
-    registerLoadBalancerTargets(props) {
-        this.fargateService.registerLoadBalancerTargets({
-            containerName: this.containerDefinition.containerName,
-            containerPort: this.containerDefinition.containerPort,
-            newTargetGroupId: `${props.serviceName}TargetGroup`,
-            listener: aws_ecs_1.ListenerConfig.applicationListener(this.loadBalancerListener, {
-                port: props.containerPort,
-                protocol: aws_elasticloadbalancingv2_1.ApplicationProtocol.HTTP,
-                healthCheck: {
-                    interval: aws_cdk_lib_1.Duration.seconds(120),
-                    path: props.healthCheckPath || "/",
-                    port: props.containerPort ? `${props.containerPort}` : "traffic-port",
-                    timeout: aws_cdk_lib_1.Duration.seconds(10)
-                }
-            })
+        this.cluster.addAsgCapacityProvider(this.asgCapacityProvider);
+        // Create drain waiter custom resource that handles capacity provider cleanup during deletion.
+        // This resource waits for ECS services to drain, then disassociates the capacity provider
+        // from the cluster before CloudFormation attempts to delete the AsgCapacityProvider.
+        //
+        // Dependency chain for DELETE order:
+        //   Services deleted → DrainWaiter runs → AsgCapacityProvider deleted → Cluster deleted
+        //
+        // The drain waiter must depend on AsgCapacityProvider so it runs BEFORE the provider is deleted.
+        // Services must depend on the drain waiter so they're deleted BEFORE the drain waiter runs.
+        this.drainWaiter = new capacityProviderDrainWaiter_1.CapacityProviderDrainWaiter(this, "CapacityProviderDrainWaiter", {
+            clusterName: props.clusterName,
+            capacityProviderName: this.asgCapacityProvider.capacityProviderName
         });
+        // DrainWaiter depends on AsgCapacityProvider:
+        // - CREATE: AsgCapacityProvider created first, then DrainWaiter
+        // - DELETE: DrainWaiter deleted first (runs Lambda), then AsgCapacityProvider
+        this.drainWaiter.node.addDependency(this.asgCapacityProvider);
     }
     addLoadBalancer(props) {
-        // Truncate the load balancer name to ensure it does not exceed the 32 character AWS limit
-        const defaultLoadBalancerName = `${props.serviceName}LoadBalancer`;
+        const defaultLoadBalancerName = `${props.clusterName}LoadBalancer`;
         const supportedNameLength = 32;
         let truncatedLoadBalancerName = defaultLoadBalancerName.length > supportedNameLength
             ? defaultLoadBalancerName.substring(0, supportedNameLength)
             : defaultLoadBalancerName;
-        // Remove any trailing hyphens that might be introduced by truncation
         truncatedLoadBalancerName = truncatedLoadBalancerName.replace(/-+$/, "");
-        this.loadBalancer = new aws_elasticloadbalancingv2_1.ApplicationLoadBalancer(this, `${props.clusterName}LoadBalancer`, {
-            vpc: this.cluster.vpc,
-            internetFacing: true,
-            loadBalancerName: truncatedLoadBalancerName,
-            vpcSubnets: {
-                subnetType: aws_ec2_1.SubnetType.PUBLIC
-            }
-        });
+        const isInternal = props.cluster?.loadBalancer === "internal";
+        if (this.isEc2()) {
+            this.loadBalancerSecurityGroup = new securityGroup_1.SecurityGroup(this, `LoadBalancerSecurityGroup`, {
+                vpc: this.cluster.vpc,
+                description: `Security group for the ${props.clusterName} load balancer`
+            });
+            this.loadBalancerSecurityGroup.connections.allowTo(this.asgSecurityGroup, aws_ec2_1.Port.allTcp());
+            this.loadBalancer = new aws_elasticloadbalancingv2_1.ApplicationLoadBalancer(this, `${props.clusterName}LoadBalancer`, {
+                vpc: this.cluster.vpc,
+                internetFacing: !isInternal,
+                securityGroup: this.loadBalancerSecurityGroup,
+                loadBalancerName: truncatedLoadBalancerName,
+                vpcSubnets: {
+                    subnetType: isInternal
+                        ? aws_ec2_1.SubnetType.PRIVATE_WITH_EGRESS
+                        : aws_ec2_1.SubnetType.PUBLIC
+                }
+            });
+            this.asgSecurityGroup.connections.allowFrom(this.loadBalancerSecurityGroup, aws_ec2_1.Port.tcpRange(49152, 65535));
+        }
+        else {
+            this.loadBalancer = new aws_elasticloadbalancingv2_1.ApplicationLoadBalancer(this, `${props.clusterName}LoadBalancer`, {
+                vpc: this.cluster.vpc,
+                internetFacing: !isInternal,
+                loadBalancerName: truncatedLoadBalancerName,
+                vpcSubnets: {
+                    subnetType: isInternal
+                        ? aws_ec2_1.SubnetType.PRIVATE_WITH_EGRESS
+                        : aws_ec2_1.SubnetType.PUBLIC
+                }
+            });
+        }
         new cfnOutput_1.CfnOutput(this, `${props.clusterName}LoadBalancerDnsName`, {
             key: `${props.clusterName}LoadBalancerDnsName`,
             exportName: `${props.clusterName}LoadBalancerDnsName`,
             value: this.loadBalancer.loadBalancerDnsName
         });
-        // Export load balancer URL for monitoring
         new cfnOutput_1.CfnOutput(this, `${props.clusterName}LoadBalancerUrl`, {
             key: "LoadBalancerUrl",
             exportName: `${props.clusterName}LoadBalancerUrl`,
@@ -278,84 +734,114 @@ class FargateCluster extends constructs_1.Construct {
             description: `Load Balancer URL for ${props.clusterName}`
         });
     }
+    addDirectAccessOutputs(props) {
+        if (!this.directAccessEnabled || !this.autoScalingGroup)
+            return;
+        // Get the first container port (for user instructions)
+        const containerPort = props.services.flatMap((s) => s.containers).find((c) => c.port)?.port ||
+            3000;
+        new cfnOutput_1.CfnOutput(this, `${props.clusterName}AutoScalingGroupName`, {
+            key: "AutoScalingGroupName",
+            exportName: `${props.clusterName}AutoScalingGroupName`,
+            value: this.autoScalingGroup.autoScalingGroupName,
+            description: `Run: aws autoscaling describe-auto-scaling-groups --auto-scaling-group-names <name> to find instance IP`
+        });
+        new cfnOutput_1.CfnOutput(this, `${props.clusterName}DirectAccessPort`, {
+            key: "DirectAccessPort",
+            exportName: `${props.clusterName}DirectAccessPort`,
+            value: String(containerPort),
+            description: `Access your app at http://<EC2-PUBLIC-IP>:${containerPort}`
+        });
+    }
     addLoadBalancerListener(props) {
+        if (!this.loadBalancer)
+            return;
+        // Determine port based on whether HTTPS is configured (domain + cert)
+        const port = this.certificate ? 443 : 80;
+        // Default action for requests that don't match any routing rule
+        // Returns 404 for multi-service clusters with routing rules
+        const defaultAction = aws_elasticloadbalancingv2_1.ListenerAction.fixedResponse(404, {
+            contentType: "text/plain",
+            messageBody: "Not Found"
+        });
         if (this.certificate) {
-            this.loadBalancerListener = this.loadBalancer.addListener(`${props.serviceName}Listener`, {
-                port: props.protocol == Protocol.HTTP ? 80 : 443,
-                certificates: [this.certificate]
+            this.loadBalancerListener = this.loadBalancer.addListener(`${props.clusterName}Listener`, {
+                port,
+                certificates: [this.certificate],
+                defaultAction
             });
         }
         else {
-            this.loadBalancerListener = this.loadBalancer.addListener(`${props.serviceName}Listener`, {
-                port: props.protocol == Protocol.HTTP ? 80 : 443
+            this.loadBalancerListener = this.loadBalancer.addListener(`${props.clusterName}Listener`, {
+                port,
+                defaultAction
             });
         }
     }
     addHostedZone(props) {
-        if (!props.domainConfig)
+        // Support both new cluster.domain and advanced cluster.domainConfig
+        const domainConfig = props.cluster?.domainConfig;
+        const simpleDomain = props.cluster?.domain;
+        if (!domainConfig && !simpleDomain)
             return;
-        if (!props.domainConfig.hostedZone) {
-            // Create a new hosted zone if one is not provided
-            const hostedZone = new hostedZone_1.HostedZone(this, `${props.serviceName}HostedZone`, {
-                zoneName: props.domainConfig.domainName
+        const domainName = domainConfig?.domainName || simpleDomain;
+        if (!domainConfig?.hostedZone) {
+            const hostedZone = new hostedZone_1.HostedZone(this, `${props.clusterName}HostedZone`, {
+                zoneName: domainName
             });
             this.hostedZone = hostedZone.getInternalHostedZone();
         }
         else {
-            // Otherwise use the provided hosted zone
-            this.hostedZone = props.domainConfig.hostedZone.getInternalHostedZone();
+            this.hostedZone = domainConfig.hostedZone.getInternalHostedZone();
         }
-        if (!props.domainConfig.certificate) {
-            // If no certificate is provided - create a new one
-            this.certificate = new aws_certificatemanager_1.Certificate(this, `${props.serviceName}Certificate`, {
-                domainName: props.domainConfig.domainName,
+        if (!domainConfig?.certificate) {
+            this.certificate = new aws_certificatemanager_1.Certificate(this, `${props.clusterName}Certificate`, {
+                domainName,
                 validation: aws_certificatemanager_1.CertificateValidation.fromDns(this.hostedZone)
             });
         }
-        // Check if this is a multi-region/weighted/geo routing configuration
-        const latencyConfig = props.domainConfig;
-        const weightedConfig = props.domainConfig;
-        const geoConfig = props.domainConfig;
-        const hasRoutingPolicy = !!latencyConfig?.region ||
-            weightedConfig?.weight !== undefined ||
-            !!geoConfig?.geoLocation;
-        // Generate setIdentifier if not provided and using routing policies
-        // AWS requires setIdentifier for all routing policies (latency, weighted, geo, failover, multivalue)
-        let setIdentifier = props.domainConfig.setIdentifier;
-        if (hasRoutingPolicy && !setIdentifier) {
-            if (latencyConfig?.region) {
-                setIdentifier = `${props.serviceName}-${latencyConfig.region}`;
-            }
-            else if (weightedConfig?.weight !== undefined) {
-                setIdentifier = `${props.serviceName}-weight-${weightedConfig.weight}`;
+        // Handle advanced routing policies (latency, weighted, geo)
+        if (domainConfig) {
+            const latencyConfig = domainConfig;
+            const weightedConfig = domainConfig;
+            const geoConfig = domainConfig;
+            const hasRoutingPolicy = !!latencyConfig?.region ||
+                weightedConfig?.weight !== undefined ||
+                !!geoConfig?.geoLocation;
+            let setIdentifier = domainConfig.setIdentifier;
+            if (hasRoutingPolicy && !setIdentifier) {
+                if (latencyConfig?.region) {
+                    setIdentifier = `${props.clusterName}${latencyConfig.region}`;
+                }
+                else if (weightedConfig?.weight !== undefined) {
+                    setIdentifier = `${props.clusterName}Weight${weightedConfig.weight}`;
+                }
+                else if (geoConfig?.geoLocation) {
+                    setIdentifier = `${props.clusterName}Geo`;
+                }
             }
-            else if (geoConfig?.geoLocation) {
-                setIdentifier = `${props.serviceName}-geo`;
+            if (this.loadBalancer) {
+                this.aRecord = new aws_route53_1.ARecord(this, `${props.clusterName}ARecord`, {
+                    recordName: domainName,
+                    zone: this.hostedZone,
+                    target: aws_route53_1.RecordTarget.fromAlias(new aws_route53_targets_1.LoadBalancerTarget(this.loadBalancer, {
+                        evaluateTargetHealth: hasRoutingPolicy
+                    })),
+                    region: latencyConfig?.region,
+                    weight: weightedConfig?.weight,
+                    geoLocation: geoConfig?.geoLocation,
+                    setIdentifier: setIdentifier
+                });
             }
         }
-        // Always create a new ARecord for this domain and attach it to the load balancer
-        this.aRecord = new aws_route53_1.ARecord(this, `${props.serviceName}.${props.clusterName}.${props.domainConfig.domainName}ARecord`, {
-            recordName: props.domainConfig.domainName,
-            zone: this.hostedZone,
-            target: aws_route53_1.RecordTarget.fromAlias(new aws_route53_targets_1.LoadBalancerTarget(this.loadBalancer, {
-                evaluateTargetHealth: hasRoutingPolicy
-            })),
-            region: latencyConfig?.region,
-            weight: weightedConfig?.weight,
-            geoLocation: geoConfig?.geoLocation,
-            // Set identifier is required for routing policies (latency, weighted, geo, failover, multivalue)
-            setIdentifier: setIdentifier
-        });
-    }
-    getImage(props) {
-        if (!props.ecrRepository)
-            return aws_ecs_1.ContainerImage.fromRegistry("amazon/amazon-ecs-sample");
-        if (props.ecrRepository instanceof aws_ecs_1.ContainerImage)
-            return props.ecrRepository;
-        if (props.ecrRepository instanceof aws_ecr_1.Repository) {
-            return aws_ecs_1.ContainerImage.fromEcrRepository(props.ecrRepository, "latest");
+        else if (simpleDomain && this.loadBalancer) {
+            // Simple domain - just create A record
+            this.aRecord = new aws_route53_1.ARecord(this, `${props.clusterName}ARecord`, {
+                recordName: domainName,
+                zone: this.hostedZone,
+                target: aws_route53_1.RecordTarget.fromAlias(new aws_route53_targets_1.LoadBalancerTarget(this.loadBalancer))
+            });
         }
-        return aws_ecs_1.ContainerImage.fromRegistry("amazon/amazon-ecs-sample");
     }
     static build(id, props) {
         return (sb) => {
@@ -369,5 +855,5 @@ class FargateCluster extends constructs_1.Construct {
         };
     }
 }
-exports.default = FargateCluster;
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"ecs.js","sourceRoot":"","sources":["../../../../../lib/resources/aws/compute/ecs.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  AwsLogDriver,\n  Cluster as CdkCluster,\n  ContainerImage,\n  FargateService,\n  FargateTaskDefinition,\n  ListenerConfig,\n  PropagatedTagSource,\n  type RepositoryImage,\n  type ContainerDefinition,\n  ContainerInsights\n} from \"aws-cdk-lib/aws-ecs\";\nimport {\n  Connections,\n  type IConnectable,\n  type IVpc,\n  Port,\n  SubnetType\n} from \"aws-cdk-lib/aws-ec2\";\nimport { Construct } from \"constructs\";\nimport { type StackBuilder } from \"../base/awsStack\";\nimport { Duration, type SecretValue, Stack } from \"aws-cdk-lib\";\nimport {\n  type ApplicationListener,\n  ApplicationLoadBalancer,\n  ApplicationProtocol\n} from \"aws-cdk-lib/aws-elasticloadbalancingv2\";\nimport {\n  CompositePrincipal,\n  Effect,\n  type IManagedPolicy,\n  PolicyDocument,\n  PolicyStatement,\n  Role,\n  ServicePrincipal\n} from \"aws-cdk-lib/aws-iam\";\nimport {\n  PredefinedMetric,\n  ScalableTarget,\n  ServiceNamespace,\n  TargetTrackingScalingPolicy\n} from \"aws-cdk-lib/aws-applicationautoscaling\";\nimport { Secret as EcsSecret } from \"aws-cdk-lib/aws-ecs\";\nimport { Secret } from \"aws-cdk-lib/aws-secretsmanager\";\nimport {\n  Certificate,\n  CertificateValidation\n} from \"aws-cdk-lib/aws-certificatemanager\";\nimport {\n  ARecord,\n  RecordTarget,\n  type IHostedZone,\n  type GeoLocation\n} from \"aws-cdk-lib/aws-route53\";\nimport { LoadBalancerTarget } from \"aws-cdk-lib/aws-route53-targets\";\nimport { Repository } from \"aws-cdk-lib/aws-ecr\";\n\nimport { type KeyValue } from \"../../../types\";\nimport { CfnOutput } from \"../utilities/cfnOutput\";\nimport { HostedZone as FjallHostedZone } from \"../../../patterns/aws/hostedZone\";\n\nimport { type SecretImport } from \"../secrets\";\n\nexport enum Protocol {\n  HTTP,\n  HTTPS\n}\n\nexport enum ScalingType {\n  CPU = PredefinedMetric.ECS_SERVICE_AVERAGE_CPU_UTILIZATION,\n  MEMORY = PredefinedMetric.ECS_SERVICE_AVERAGE_MEMORY_UTILIZATION\n}\n\nexport interface ContainerSecret {\n  [key: string]: SecretValue;\n}\n\n/**\n * DomainConfiguration\n * - When supplied a domain name, a hosted zone, certificate and ARecord will be created\n * - When supplied a domain name and hosted zone, a certificate and ARecord will be created\n * - When all properties are supplied only a target will be created\n */\n\nexport interface DomainBaseConfig {\n  domainName: string;\n  hostedZone?: FjallHostedZone;\n  certificate?: Certificate;\n  // Optional: Set identifier for routing policies (auto-generated if not provided)\n  setIdentifier?: string;\n}\n\nexport interface LatencyDomainConfig extends DomainBaseConfig {\n  // Set to enable latency based routing\n  region: string;\n}\n\nexport interface WeightedDomainConfig extends DomainBaseConfig {\n  // Set to enable weighted routing\n  weight: number;\n}\n\nexport interface GeoLocationDomainConfig extends DomainBaseConfig {\n  // Set to enable geolocation based routing\n  geoLocation: GeoLocation;\n}\n\nexport type DomainConfig =\n  | DomainBaseConfig\n  | LatencyDomainConfig\n  | WeightedDomainConfig\n  | GeoLocationDomainConfig;\n\nexport type FargateClusterProps = {\n  ecrRepository: Repository | RepositoryImage;\n  clusterName: string;\n  containerCommand?: string[];\n  containerEnvironment?: KeyValue;\n  containerSecrets?: ContainerSecret;\n  containerSecretsImport?: {\n    [key: string]: SecretImport;\n  };\n  containerPort?: number;\n  cpu?: number;\n  domainConfig?: DomainConfig;\n  desiredCount?: number;\n  healthCheckPath?: string;\n  listenerPort?: number;\n  memoryLimitMiB?: number;\n  publicLoadBalancer?: boolean;\n  protocol: Protocol;\n  scalingType?: ScalingType;\n  serviceName: string;\n  taskRoleInlinePolicies?: {\n    [name: string]: PolicyDocument;\n  };\n  taskRoleManagedPolicies?: IManagedPolicy[];\n  vpc?: IVpc;\n};\n\nexport default class FargateCluster extends Construct implements IConnectable {\n  public connections: Connections;\n\n  private cluster: CdkCluster;\n  private loadBalancer: ApplicationLoadBalancer;\n  private executionRole: Role;\n  private taskDefinition: FargateTaskDefinition;\n  private containerDefinition: ContainerDefinition;\n  private fargateService: FargateService;\n  private scalingPolicy: TargetTrackingScalingPolicy;\n  private hostedZone: IHostedZone;\n  private certificate: Certificate;\n  private aRecord: ARecord;\n  private loadBalancerListener: ApplicationListener;\n\n  private secrets: {\n    [key: string]: EcsSecret;\n  } = {};\n\n  private scope: Construct;\n\n  constructor(scope: Construct, id: string, props: FargateClusterProps) {\n    super(scope, id);\n\n    this.scope = scope;\n\n    this.addCluster(props);\n    this.addSecrets(props);\n    this.importSecrets(props);\n    this.addExecutionRole(props);\n    this.addTaskDefinition(props);\n    this.addContainerDefinition(props);\n    this.addFargateService(props);\n    this.addLoadBalancer(props);\n\n    if (props.domainConfig) this.addHostedZone(props);\n\n    this.addLoadBalancerListener(props);\n    this.registerLoadBalancerTargets(props);\n\n    const containerPort = props.containerPort || 80;\n    this.connections = new Connections({\n      securityGroups: this.fargateService.connections.securityGroups,\n      defaultPort: Port.tcp(containerPort)\n    });\n  }\n\n  addCluster(props: FargateClusterProps) {\n    this.cluster = new CdkCluster(this, `${props.clusterName}`, {\n      vpc: props.vpc,\n      clusterName: props.clusterName,\n      containerInsightsV2: ContainerInsights.ENABLED,\n      enableFargateCapacityProviders: true\n    });\n\n    // Output used to auto-detect deployable cluter\n    new CfnOutput(this, `${props.clusterName}DeployableCluster`, {\n      key: `${props.clusterName}DeployableCluster`,\n      exportName: `${props.clusterName}DeployableCluster`,\n      value: this.cluster.clusterArn\n    });\n\n    // Export cluster ARN for monitoring\n    new CfnOutput(this, `${props.clusterName}ClusterArn`, {\n      key: \"ClusterArn\",\n      exportName: `${props.clusterName}ClusterArn`,\n      value: this.cluster.clusterArn,\n      description: `ECS Cluster ARN for ${props.clusterName}`\n    });\n  }\n\n  /**\n   * #todo: change this to create new secrets instead\n   * @deprecated use importSecrets instead\n   */\n  addSecrets(props: FargateClusterProps) {\n    // Container Secrets\n    const containerSecret = Secret.fromSecretNameV2(\n      this,\n      `${props.clusterName}Secret`,\n      `/${props.clusterName}/${props.serviceName}`\n    );\n\n    for (const secretField in props.containerSecrets) {\n      this.secrets[secretField] = EcsSecret.fromSecretsManager(\n        containerSecret,\n        secretField\n      );\n    }\n  }\n\n  /**\n   * Automatically import secrets from another resource or stack\n   */\n  importSecrets(props: FargateClusterProps) {\n    if (!props.containerSecretsImport) return;\n\n    for (const key in props.containerSecretsImport) {\n      const importSecret = props.containerSecretsImport[key];\n\n      // todo: I think ID needs to be a new value as it ID's the IMPORT not the secret itself?\n\n      // Construct the AWS ISecret object\n      const iSecret = Secret.fromSecretNameV2(\n        this,\n        importSecret.id,\n        importSecret.name\n      );\n\n      this.secrets[key] = EcsSecret.fromSecretsManager(\n        iSecret,\n        importSecret.field\n      );\n    }\n  }\n\n  addExecutionRole(props: FargateClusterProps) {\n    this.executionRole = new Role(\n      this,\n      `${props.serviceName}ExecutionRole${Stack.of(this).region}`,\n      {\n        roleName: `${props.serviceName}ExecutionRole${Stack.of(this).region}`,\n        description: `${props.serviceName} Execution Role`,\n        managedPolicies: [\n          {\n            managedPolicyArn:\n              \"arn:aws:iam::aws:policy/service-role/AmazonECSTaskExecutionRolePolicy\"\n          }\n        ],\n        inlinePolicies: {\n          [\"readSecrets\"]: new PolicyDocument({\n            statements: [\n              new PolicyStatement({\n                actions: [\n                  \"secretsmanager:GetSecretValue\",\n                  \"secretsmanager:DescribeSecret\"\n                ],\n                resources: [\"*\"] // TODO: Set this to the secret ARN\n              })\n            ]\n          }),\n          [\"decryptSecrets\"]: new PolicyDocument({\n            statements: [\n              new PolicyStatement({\n                actions: [\"kms:Decrypt\"],\n                resources: [\"*\"] // TODO: Set this to the KMS Arn\n              })\n            ]\n          }),\n          [\"ecsExecuteCommand\"]: new PolicyDocument({\n            statements: [\n              new PolicyStatement({\n                actions: [\n                  \"ssmmessages:CreateControlChannel\",\n                  \"ssmmessages:CreateDataChannel\",\n                  \"ssmmessages:OpenControlChannel\",\n                  \"ssmmessages:OpenDataChannel\"\n                ],\n                effect: Effect.ALLOW,\n                resources: [\"*\"]\n              })\n            ]\n          })\n        },\n        assumedBy: new CompositePrincipal(\n          new ServicePrincipal(\"ecs-tasks.amazonaws.com\")\n        )\n      }\n    );\n  }\n\n  addTaskDefinition(props: FargateClusterProps) {\n    this.taskDefinition = new FargateTaskDefinition(\n      this,\n      `${props.serviceName}TaskDefinition`,\n      {\n        cpu: props.cpu || 256,\n        executionRole: this.executionRole,\n        taskRole: new Role(\n          this,\n          `${props.serviceName}TaskRole${Stack.of(this).region}`,\n          {\n            roleName: `${props.serviceName}TaskRole${Stack.of(this).region}`,\n            description: `${props.serviceName} Task Role`,\n            inlinePolicies: props.taskRoleInlinePolicies,\n            managedPolicies: props.taskRoleManagedPolicies,\n            assumedBy: new CompositePrincipal(\n              new ServicePrincipal(\"ecs-tasks.amazonaws.com\")\n            )\n          }\n        ),\n        memoryLimitMiB: props.memoryLimitMiB || 512\n      }\n    );\n  }\n\n  addContainerDefinition(props: FargateClusterProps) {\n    this.containerDefinition = this.taskDefinition.addContainer(\n      `${props.serviceName}ContainerDefinition`,\n      {\n        image: this.getImage(props),\n        containerName: props.serviceName,\n        environment: {\n          ...props.containerEnvironment\n        },\n        command: props.containerCommand,\n        secrets: {\n          ...this.secrets\n        },\n        //todo: provide health check options\n        healthCheck: {\n          command: [\n            \"CMD-SHELL\",\n            // https://docs.aws.amazon.com/AmazonECS/latest/developerguide/view-container-health.html\n            //  >> proc/1/fd/1 2>&1 redirects stdout and stderr of the health check to CloudWatch logs\n            // `curl -f http://localhost:${props.containerPort}/ >> /proc/1/fd/1 2>&1  || exit 1`\n            `curl -f http://localhost:${props.containerPort}/ || exit 1`\n          ]\n        },\n        logging: new AwsLogDriver({\n          streamPrefix: `/ecs/${props.clusterName}/${props.serviceName}`,\n          logRetention: 14\n        }),\n        portMappings: props.containerPort\n          ? [{ containerPort: props.containerPort }]\n          : [{ containerPort: 80 }]\n      }\n    );\n  }\n\n  addFargateService(props: FargateClusterProps) {\n    this.fargateService = new FargateService(\n      this,\n      `${props.serviceName}FargateService`,\n      {\n        circuitBreaker: { rollback: true },\n        cluster: this.cluster,\n        desiredCount: 2,\n        enableECSManagedTags: true,\n        enableExecuteCommand: true,\n        propagateTags: PropagatedTagSource.SERVICE,\n        serviceName: `${props.serviceName}`,\n        taskDefinition: this.taskDefinition,\n        minHealthyPercent: 100,\n        maxHealthyPercent: 200\n      }\n    );\n\n    // Output used to detect deployable service\n    new CfnOutput(this, `${props.clusterName}DeployableService`, {\n      key: `${props.clusterName}DeployableService`,\n      exportName: `${props.clusterName}DeployableService`,\n      value: this.fargateService.serviceArn\n    });\n\n    // Export service ARN for monitoring\n    new CfnOutput(this, `${props.clusterName}ServiceArn`, {\n      key: \"ServiceArn\",\n      exportName: `${props.clusterName}ServiceArn`,\n      value: this.fargateService.serviceArn,\n      description: `ECS Service ARN for ${props.serviceName}`\n    });\n  }\n\n  addScalingPolicy(props: FargateClusterProps) {\n    this.scalingPolicy = new TargetTrackingScalingPolicy(\n      this,\n      `${props.serviceName}ScalingPolicy`,\n      {\n        policyName: `${props.serviceName}ScalingPolicy`,\n        scalingTarget: new ScalableTarget(\n          this,\n          `${props.serviceName}scalableTarget`,\n          {\n            maxCapacity: 10,\n            minCapacity: 2,\n            resourceId: `service/${this.cluster.clusterName}/${this.fargateService.serviceName}`,\n            scalableDimension: \"ecs:service:DesiredCount\",\n            serviceNamespace: ServiceNamespace.ECS\n          }\n        ),\n        targetValue: 50,\n        scaleOutCooldown: Duration.seconds(60),\n        scaleInCooldown: Duration.seconds(60),\n        predefinedMetric:\n          props.scalingType == ScalingType.MEMORY\n            ? PredefinedMetric.ECS_SERVICE_AVERAGE_MEMORY_UTILIZATION\n            : PredefinedMetric.ECS_SERVICE_AVERAGE_CPU_UTILIZATION\n      }\n    );\n  }\n\n  registerLoadBalancerTargets(props: FargateClusterProps) {\n    this.fargateService.registerLoadBalancerTargets({\n      containerName: this.containerDefinition.containerName,\n      containerPort: this.containerDefinition.containerPort,\n      newTargetGroupId: `${props.serviceName}TargetGroup`,\n      listener: ListenerConfig.applicationListener(this.loadBalancerListener, {\n        port: props.containerPort,\n        protocol: ApplicationProtocol.HTTP,\n        healthCheck: {\n          interval: Duration.seconds(120),\n          path: props.healthCheckPath || \"/\",\n          port: props.containerPort ? `${props.containerPort}` : \"traffic-port\",\n          timeout: Duration.seconds(10)\n        }\n      })\n    });\n  }\n\n  addLoadBalancer(props: FargateClusterProps) {\n    // Truncate the load balancer name to ensure it does not exceed the 32 character AWS limit\n    const defaultLoadBalancerName = `${props.serviceName}LoadBalancer`;\n    const supportedNameLength = 32;\n\n    let truncatedLoadBalancerName =\n      defaultLoadBalancerName.length > supportedNameLength\n        ? defaultLoadBalancerName.substring(0, supportedNameLength)\n        : defaultLoadBalancerName;\n\n    // Remove any trailing hyphens that might be introduced by truncation\n    truncatedLoadBalancerName = truncatedLoadBalancerName.replace(/-+$/, \"\");\n\n    this.loadBalancer = new ApplicationLoadBalancer(\n      this,\n      `${props.clusterName}LoadBalancer`,\n      {\n        vpc: this.cluster.vpc,\n        internetFacing: true,\n        loadBalancerName: truncatedLoadBalancerName,\n        vpcSubnets: {\n          subnetType: SubnetType.PUBLIC\n        }\n      }\n    );\n\n    new CfnOutput(this, `${props.clusterName}LoadBalancerDnsName`, {\n      key: `${props.clusterName}LoadBalancerDnsName`,\n      exportName: `${props.clusterName}LoadBalancerDnsName`,\n      value: this.loadBalancer.loadBalancerDnsName\n    });\n\n    // Export load balancer URL for monitoring\n    new CfnOutput(this, `${props.clusterName}LoadBalancerUrl`, {\n      key: \"LoadBalancerUrl\",\n      exportName: `${props.clusterName}LoadBalancerUrl`,\n      value: `http://${this.loadBalancer.loadBalancerDnsName}`,\n      description: `Load Balancer URL for ${props.clusterName}`\n    });\n  }\n\n  addLoadBalancerListener(props: FargateClusterProps) {\n    if (this.certificate) {\n      this.loadBalancerListener = this.loadBalancer.addListener(\n        `${props.serviceName}Listener`,\n        {\n          port: props.protocol == Protocol.HTTP ? 80 : 443,\n          certificates: [this.certificate]\n        }\n      );\n    } else {\n      this.loadBalancerListener = this.loadBalancer.addListener(\n        `${props.serviceName}Listener`,\n        {\n          port: props.protocol == Protocol.HTTP ? 80 : 443\n        }\n      );\n    }\n  }\n\n  addHostedZone(props: FargateClusterProps) {\n    if (!props.domainConfig) return;\n\n    if (!props.domainConfig.hostedZone) {\n      // Create a new hosted zone if one is not provided\n      const hostedZone = new FjallHostedZone(\n        this,\n        `${props.serviceName}HostedZone`,\n        {\n          zoneName: props.domainConfig.domainName\n        }\n      );\n\n      this.hostedZone = hostedZone.getInternalHostedZone();\n    } else {\n      // Otherwise use the provided hosted zone\n      this.hostedZone = props.domainConfig.hostedZone.getInternalHostedZone();\n    }\n\n    if (!props.domainConfig.certificate) {\n      // If no certificate is provided - create a new one\n      this.certificate = new Certificate(\n        this,\n        `${props.serviceName}Certificate`,\n        {\n          domainName: props.domainConfig.domainName,\n          validation: CertificateValidation.fromDns(this.hostedZone)\n        }\n      );\n    }\n\n    // Check if this is a multi-region/weighted/geo routing configuration\n    const latencyConfig = props.domainConfig as LatencyDomainConfig;\n    const weightedConfig = props.domainConfig as WeightedDomainConfig;\n    const geoConfig = props.domainConfig as GeoLocationDomainConfig;\n\n    const hasRoutingPolicy: boolean =\n      !!latencyConfig?.region ||\n      weightedConfig?.weight !== undefined ||\n      !!geoConfig?.geoLocation;\n\n    // Generate setIdentifier if not provided and using routing policies\n    // AWS requires setIdentifier for all routing policies (latency, weighted, geo, failover, multivalue)\n    let setIdentifier = props.domainConfig.setIdentifier;\n    if (hasRoutingPolicy && !setIdentifier) {\n      if (latencyConfig?.region) {\n        setIdentifier = `${props.serviceName}-${latencyConfig.region}`;\n      } else if (weightedConfig?.weight !== undefined) {\n        setIdentifier = `${props.serviceName}-weight-${weightedConfig.weight}`;\n      } else if (geoConfig?.geoLocation) {\n        setIdentifier = `${props.serviceName}-geo`;\n      }\n    }\n\n    // Always create a new ARecord for this domain and attach it to the load balancer\n    this.aRecord = new ARecord(\n      this,\n      `${props.serviceName}.${props.clusterName}.${props.domainConfig.domainName}ARecord`,\n      {\n        recordName: props.domainConfig.domainName,\n        zone: this.hostedZone,\n        target: RecordTarget.fromAlias(\n          new LoadBalancerTarget(this.loadBalancer, {\n            evaluateTargetHealth: hasRoutingPolicy\n          })\n        ),\n        region: latencyConfig?.region,\n        weight: weightedConfig?.weight,\n        geoLocation: geoConfig?.geoLocation,\n        // Set identifier is required for routing policies (latency, weighted, geo, failover, multivalue)\n        setIdentifier: setIdentifier\n      }\n    );\n  }\n\n  getImage(props: FargateClusterProps): ContainerImage {\n    if (!props.ecrRepository)\n      return ContainerImage.fromRegistry(\"amazon/amazon-ecs-sample\");\n    if (props.ecrRepository instanceof ContainerImage)\n      return props.ecrRepository;\n    if (props.ecrRepository instanceof Repository) {\n      return ContainerImage.fromEcrRepository(props.ecrRepository, \"latest\");\n    }\n    return ContainerImage.fromRegistry(\"amazon/amazon-ecs-sample\");\n  }\n\n  static build(\n    id: string,\n    props: FargateClusterProps\n  ): (sb: StackBuilder) => Construct {\n    return (sb: StackBuilder) => {\n      const newProps: FargateClusterProps = {\n        ...props,\n        ...{\n          vpc: (sb.getNetwork() as IVpc) || props.vpc\n        }\n      };\n      return new this(sb.getStack(), id, newProps);\n    };\n  }\n}\n"]}
+exports.default = EcsCluster;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"ecs.js","sourceRoot":"","sources":["../../../../../lib/resources/aws/compute/ecs.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  AwsLogDriver,\n  Cluster as CdkCluster,\n  ContainerImage,\n  FargateService,\n  FargateTaskDefinition,\n  Ec2Service,\n  Ec2TaskDefinition,\n  NetworkMode,\n  PropagatedTagSource,\n  type RepositoryImage,\n  type ContainerDefinition,\n  ContainerInsights,\n  PlacementStrategy,\n  AsgCapacityProvider,\n  EcsOptimizedImage,\n  AmiHardwareType,\n  CpuArchitecture,\n  OperatingSystemFamily,\n  CfnClusterCapacityProviderAssociations\n} from \"aws-cdk-lib/aws-ecs\";\nimport {\n  Connections,\n  type IConnectable,\n  type ISecurityGroup,\n  type IVpc,\n  InstanceType,\n  Peer,\n  Port,\n  SubnetType\n} from \"aws-cdk-lib/aws-ec2\";\nimport { Construct } from \"constructs\";\nimport { type StackBuilder } from \"../base/awsStack\";\nimport { Duration, Stack } from \"aws-cdk-lib\";\nimport {\n  type ApplicationListener,\n  ApplicationLoadBalancer,\n  ApplicationProtocol,\n  type IApplicationTargetGroup,\n  ListenerAction,\n  ListenerCondition\n} from \"aws-cdk-lib/aws-elasticloadbalancingv2\";\nimport {\n  Effect,\n  type IManagedPolicy,\n  Policy,\n  PolicyDocument,\n  PolicyStatement,\n  Role,\n  ServicePrincipal\n} from \"aws-cdk-lib/aws-iam\";\nimport {\n  PredefinedMetric,\n  ScalableTarget,\n  ServiceNamespace,\n  TargetTrackingScalingPolicy\n} from \"aws-cdk-lib/aws-applicationautoscaling\";\nimport { Secret as EcsSecret } from \"aws-cdk-lib/aws-ecs\";\nimport { Secret } from \"aws-cdk-lib/aws-secretsmanager\";\nimport {\n  Certificate,\n  CertificateValidation\n} from \"aws-cdk-lib/aws-certificatemanager\";\nimport {\n  ARecord,\n  RecordTarget,\n  type IHostedZone,\n  type GeoLocation\n} from \"aws-cdk-lib/aws-route53\";\nimport { LoadBalancerTarget } from \"aws-cdk-lib/aws-route53-targets\";\nimport { Repository } from \"aws-cdk-lib/aws-ecr\";\nimport { AutoScalingGroup, Monitoring } from \"aws-cdk-lib/aws-autoscaling\";\n\nimport { CfnOutput } from \"../utilities/cfnOutput\";\nimport { HostedZone as FjallHostedZone } from \"../../../patterns/aws/hostedZone\";\nimport { SecurityGroup } from \"../iam/securityGroup\";\nimport { CapacityProviderDrainWaiter } from \"./utilities/capacityProviderDrainWaiter\";\n\nimport { type SecretImport } from \"../secrets\";\n\nexport enum Protocol {\n  HTTP,\n  HTTPS\n}\n\nexport enum ScalingType {\n  CPU = PredefinedMetric.ECS_SERVICE_AVERAGE_CPU_UTILIZATION,\n  MEMORY = PredefinedMetric.ECS_SERVICE_AVERAGE_MEMORY_UTILIZATION\n}\n\nexport type EcsCapacityProvider = \"FARGATE\" | \"FARGATE_SPOT\" | \"EC2\";\n\n/**\n * EC2 capacity configuration for ECS EC2-backed clusters.\n * Only used when capacityProvider is \"EC2\".\n */\nexport interface Ec2CapacityConfig {\n  /** EC2 instance type. Default: \"t3.micro\" */\n  instanceType?: string;\n  /** AMI hardware type. Default: \"ARM\" (Graviton - better cost/performance) */\n  amiHardwareType?: \"ARM\" | \"STANDARD\";\n  /** Minimum number of instances. Default: 2 */\n  minCapacity?: number;\n  /** Maximum number of instances. Default: 3 */\n  maxCapacity?: number;\n  /** Memory limit in MiB for the container. Default: 1024 */\n  memoryLimitMiB?: number;\n}\n\n/**\n * Domain configuration for HTTPS and DNS.\n */\nexport interface DomainBaseConfig {\n  domainName: string;\n  hostedZone?: FjallHostedZone;\n  certificate?: Certificate;\n  setIdentifier?: string;\n}\n\nexport interface LatencyDomainConfig extends DomainBaseConfig {\n  region: string;\n}\n\nexport interface WeightedDomainConfig extends DomainBaseConfig {\n  weight: number;\n}\n\nexport interface GeoLocationDomainConfig extends DomainBaseConfig {\n  geoLocation: GeoLocation;\n}\n\nexport type DomainConfig =\n  | DomainBaseConfig\n  | LatencyDomainConfig\n  | WeightedDomainConfig\n  | GeoLocationDomainConfig;\n\n/**\n * Internal configuration for a container in a multi-container ECS task.\n *\n * In multi-container tasks, the first container with a `port` is the **primary container**\n * that receives load balancer traffic. All other containers are **sidecars** that provide\n * supporting functionality (logging, monitoring, proxies, etc.).\n *\n * @example\n * // Primary container (has port) + sidecar (no port)\n * containers: [\n *   { name: \"app\", port: 3000 },           // Primary - receives ALB traffic\n *   { name: \"datadog\", image: \"datadog/agent\" }  // Sidecar - monitoring\n * ]\n *\n * @internal\n */\nexport interface EcsClusterContainerConfig {\n  /** Unique container name */\n  name: string;\n  /**\n   * Container image. Options:\n   * - Omit: Uses default ECR repository (primary container only)\n   * - string: ECR repository name or public image URL\n   * - Repository: CDK ECR Repository construct\n   */\n  image?: string | Repository;\n  /**\n   * Port the container listens on.\n   * The first container with a port becomes the **primary container**\n   * and is registered with the load balancer.\n   */\n  port?: number;\n  /** Environment variables */\n  environment?: Record<string, string>;\n  /** Secrets imported from other resources */\n  secretsImport?: { [key: string]: SecretImport };\n  /** Command to run in the container */\n  command?: string[];\n  /** Entry point for the container */\n  entryPoint?: string[];\n  /**\n   * Whether this container is essential.\n   * If an essential container stops, all containers in the task stop.\n   * Default: true for primary container, true for sidecars\n   */\n  essential?: boolean;\n  /**\n   * Health check configuration.\n   * Default: For primary container with port, uses curl health check.\n   */\n  healthCheck?: {\n    command: string[];\n    interval?: number;\n    timeout?: number;\n    retries?: number;\n    startPeriod?: number;\n  };\n}\n\n/**\n * Cluster-level configuration.\n * Controls the shared ALB for all services in this cluster.\n */\nexport interface EcsClusterClusterConfig {\n  /**\n   * Domain for HTTPS access.\n   * - Omit: ALB created with default DNS (*.elb.amazonaws.com)\n   * - Specified: Creates ACM certificate + Route53 DNS A record\n   */\n  domain?: string;\n\n  /**\n   * Load balancer configuration.\n   * - false: No ALB (for workers/internal services)\n   * - \"public\": Internet-facing ALB (default)\n   * - \"internal\": VPC-only ALB\n   */\n  loadBalancer?: false | \"public\" | \"internal\";\n\n  /**\n   * Enable direct EC2 access without ALB.\n   * Opens container ports on security group for direct access via EC2 public IP.\n   * Uses host network mode for predictable port mapping (container:3000 → host:3000).\n   * Only valid with EC2 capacity provider.\n   */\n  directAccess?: boolean;\n\n  /**\n   * Domain configuration for advanced routing policies (latency, weighted, geo).\n   * Only used when domain is specified.\n   */\n  domainConfig?: DomainConfig;\n}\n\n/**\n * Routing configuration for path/host-based routing on the ALB.\n */\nexport interface EcsRoutingConfig {\n  /** Path pattern for routing (e.g., \"/api/*\", \"/users/*\") */\n  path?: string;\n  /** Host header for routing (e.g., \"api.example.com\") */\n  host?: string;\n  /** Priority for this routing rule (1-50000). Lower = higher priority. */\n  priority?: number;\n  /** Health check path for this service's target group. Default: \"/\" */\n  healthCheckPath?: string;\n}\n\n/**\n * Configuration for a service in an ECS cluster.\n * Each service gets its own task definition, scaling, and target group.\n */\nexport interface EcsServiceProps {\n  /** Service name (unique within cluster) */\n  name: string;\n\n  /**\n   * Container image for this service.\n   * - Omit: Uses cluster's default ECR repository\n   * - string: ECR repository name or public image URL\n   * - Repository: CDK ECR Repository construct\n   */\n  image?: string | Repository;\n\n  /**\n   * Container configurations for this service.\n   * The first container with a port is the **primary container** (receives ALB traffic).\n   */\n  containers: EcsClusterContainerConfig[];\n\n  /** CPU units for this service's tasks (256-4096) */\n  cpu?: number;\n\n  /** Memory in MiB for this service's tasks (512-30720) */\n  memoryLimitMiB?: number;\n\n  /** Desired number of tasks. Default: 2 */\n  desiredCount?: number;\n\n  /** Scaling type (CPU or MEMORY). Omit to disable auto-scaling. */\n  scalingType?: ScalingType;\n\n  /** Minimum number of tasks for auto-scaling. Default: 2 */\n  minCapacity?: number;\n\n  /** Maximum number of tasks for auto-scaling. Default: 10 */\n  maxCapacity?: number;\n\n  /**\n   * Routing rules for this service on the cluster's ALB.\n   * Required when cluster has multiple services with ports.\n   */\n  routing?: EcsRoutingConfig;\n\n  /**\n   * Additional inline policies for this service's task role.\n   * Added on top of the default ECS Exec permissions.\n   */\n  taskRoleInlinePolicies?: {\n    [name: string]: PolicyDocument;\n  };\n\n  /**\n   * Additional managed policies for this service's task role.\n   * Added on top of the default ECS Exec permissions.\n   */\n  taskRoleManagedPolicies?: IManagedPolicy[];\n\n  /**\n   * Resources this service needs to connect to (e.g., databases).\n   * Creates security group rules to allow traffic from this specific service only.\n   */\n  connections?: IConnectable[];\n}\n\n/**\n * Props for creating an ECS cluster with multiple services.\n */\nexport type EcsClusterProps = {\n  /** Cluster name */\n  clusterName: string;\n\n  /** VPC to deploy into */\n  vpc?: IVpc;\n\n  /** Default ECR repository or container image */\n  ecrRepository: Repository | RepositoryImage | string;\n\n  /** Capacity provider determines Fargate vs EC2 infrastructure */\n  capacityProvider?: EcsCapacityProvider;\n\n  /** EC2-specific configuration. Only used when capacityProvider is \"EC2\" */\n  ec2Config?: Ec2CapacityConfig;\n\n  /**\n   * Cluster configuration.\n   * Controls the shared ALB for all services.\n   */\n  cluster?: EcsClusterClusterConfig;\n\n  /**\n   * Services in this cluster.\n   * Each service gets its own task definition, scaling, and target group.\n   * All services share the cluster's ALB (unless disabled).\n   * Task role policies are configured per-service for least-privilege.\n   */\n  services: EcsServiceProps[];\n};\n\n/**\n * Data tracked for each service in the cluster.\n */\ninterface ServiceData {\n  service: FargateService | Ec2Service;\n  taskDefinition: FargateTaskDefinition | Ec2TaskDefinition;\n  /** Role for ECS agent (pull images, write logs, inject secrets) */\n  executionRole: Role;\n  /** Role for application code (user policies, ECS Exec) */\n  taskRole: Role;\n  containers: ContainerDefinition[];\n  primaryContainer?: ContainerDefinition;\n  targetGroup?: IApplicationTargetGroup;\n  scalingPolicy?: TargetTrackingScalingPolicy;\n}\n\n/**\n * ECS Cluster supporting multiple services with a shared ALB.\n *\n * @example\n * // Single service cluster\n * new EcsCluster(scope, \"WebCluster\", {\n *   clusterName: \"WebCluster\",\n *   ecrRepository: ecr,\n *   services: [\n *     { name: \"web\", containers: [{ name: \"app\", port: 3000 }] }\n *   ]\n * });\n *\n * @example\n * // Multi-service cluster with routing\n * new EcsCluster(scope, \"ApiCluster\", {\n *   clusterName: \"ApiCluster\",\n *   cluster: { domain: \"api.example.com\" },\n *   ecrRepository: ecr,\n *   services: [\n *     { name: \"users\", containers: [{ name: \"app\", port: 3000 }], routing: { path: \"/users/*\" } },\n *     { name: \"orders\", containers: [{ name: \"app\", port: 3001 }], routing: { path: \"/orders/*\" } }\n *   ]\n * });\n *\n * @example\n * // Worker cluster (no ALB)\n * new EcsCluster(scope, \"Workers\", {\n *   clusterName: \"Workers\",\n *   cluster: { loadBalancer: false },\n *   ecrRepository: ecr,\n *   services: [\n *     { name: \"processor\", containers: [{ name: \"worker\" }] }\n *   ]\n * });\n */\nexport default class EcsCluster extends Construct implements IConnectable {\n  public connections: Connections;\n\n  // Cluster-level resources\n  private cluster: CdkCluster;\n  private loadBalancer?: ApplicationLoadBalancer;\n  private loadBalancerListener?: ApplicationListener;\n  private hostedZone?: IHostedZone;\n  private certificate?: Certificate;\n  private aRecord?: ARecord;\n\n  // EC2-specific\n  private autoScalingGroup?: AutoScalingGroup;\n  private asgSecurityGroup?: SecurityGroup;\n  private asgCapacityProvider?: AsgCapacityProvider;\n  private loadBalancerSecurityGroup?: SecurityGroup;\n  private drainWaiter?: CapacityProviderDrainWaiter;\n\n  // Fargate-specific - reference to CDK's internal capacity provider associations\n  private fargateCapacityProviderAssociations?: CfnClusterCapacityProviderAssociations;\n\n  // Per-service tracking\n  private services = new Map<string, ServiceData>();\n\n  // Configuration\n  private scope: Construct;\n  private props: EcsClusterProps;\n  private capacityProvider: EcsCapacityProvider;\n  private loadBalancerDisabled: boolean;\n  private directAccessEnabled: boolean;\n  private nextPriority: number = 100;\n\n  constructor(scope: Construct, id: string, props: EcsClusterProps) {\n    super(scope, id);\n\n    this.scope = scope;\n    this.props = props;\n    this.capacityProvider = props.capacityProvider || \"FARGATE\";\n    this.directAccessEnabled = props.cluster?.directAccess === true;\n    this.loadBalancerDisabled =\n      props.cluster?.loadBalancer === false || this.directAccessEnabled;\n\n    this.validateProps(props);\n\n    // 1. Create the ECS cluster\n    this.addCluster(props);\n\n    // 2. Set up EC2 infrastructure if needed\n    if (this.isEc2()) {\n      this.addAutoScalingGroup(props);\n    }\n\n    // 3. Create ALB if not disabled (shared by all services)\n    if (!this.loadBalancerDisabled) {\n      this.addLoadBalancer(props);\n\n      // Set up domain/HTTPS if configured\n      if (props.cluster?.domain || props.cluster?.domainConfig) {\n        this.addHostedZone(props);\n      }\n\n      this.addLoadBalancerListener(props);\n    } else if (this.directAccessEnabled) {\n      this.addDirectAccessOutputs(props);\n    }\n\n    // 4. Create each service\n    for (const serviceProps of props.services) {\n      this.addServiceToCluster(serviceProps);\n    }\n\n    // 5. Set up connections\n    this.setupConnections(props);\n  }\n\n  /** Get the cluster's load balancer. Undefined if disabled. */\n  getLoadBalancer(): ApplicationLoadBalancer | undefined {\n    return this.loadBalancer;\n  }\n\n  /** Get the load balancer's listener. Undefined if disabled. */\n  getListener(): ApplicationListener | undefined {\n    return this.loadBalancerListener;\n  }\n\n  /** Get a specific service by name. */\n  getService(name: string): FargateService | Ec2Service | undefined {\n    return this.services.get(name)?.service;\n  }\n\n  /** Get all services in this cluster. */\n  getServices(): Map<string, FargateService | Ec2Service> {\n    const result = new Map<string, FargateService | Ec2Service>();\n    for (const [name, data] of this.services) {\n      result.set(name, data.service);\n    }\n    return result;\n  }\n\n  /** Get the ECS cluster construct. */\n  getCluster(): CdkCluster {\n    return this.cluster;\n  }\n\n  /** Get the ALB URL (http:// or https://). */\n  getUrl(): string | undefined {\n    if (!this.loadBalancer) return undefined;\n    const protocol = this.certificate ? \"https\" : \"http\";\n    const domain =\n      this.props.cluster?.domain || this.loadBalancer.loadBalancerDnsName;\n    return `${protocol}://${domain}`;\n  }\n\n  /**\n   * Add a service to the cluster.\n   * Each service gets its own task definition, containers, and target group.\n   */\n  private addServiceToCluster(serviceProps: EcsServiceProps): void {\n    const serviceName = serviceProps.name;\n\n    // Create separate roles for security best practice\n    const executionRole = this.createExecutionRole(serviceName);\n    const taskRole = this.createTaskRole(serviceName, serviceProps);\n\n    // Create task definition with both roles\n    const taskDefinition = this.createTaskDefinition(\n      serviceName,\n      serviceProps,\n      executionRole,\n      taskRole\n    );\n\n    // Add containers to task definition\n    const { containers, primaryContainer } = this.addContainersToTask(\n      serviceName,\n      serviceProps,\n      taskDefinition\n    );\n\n    // Create the ECS service\n    const service = this.createService(\n      serviceName,\n      serviceProps,\n      taskDefinition\n    );\n\n    // Register with ALB if enabled and has primary container with port\n    let targetGroup: IApplicationTargetGroup | undefined;\n    if (\n      !this.loadBalancerDisabled &&\n      primaryContainer &&\n      this.loadBalancerListener\n    ) {\n      targetGroup = this.registerServiceWithALB(\n        serviceName,\n        serviceProps,\n        service,\n        primaryContainer\n      );\n    }\n\n    // Add scaling if configured\n    let scalingPolicy: TargetTrackingScalingPolicy | undefined;\n    if (serviceProps.scalingType) {\n      scalingPolicy = this.addServiceScaling(\n        serviceName,\n        serviceProps,\n        service\n      );\n    }\n\n    // Store service data\n    this.services.set(serviceName, {\n      service,\n      taskDefinition,\n      executionRole,\n      taskRole,\n      containers,\n      primaryContainer,\n      targetGroup,\n      scalingPolicy\n    });\n\n    // Add service level connections\n    if (serviceProps.connections && serviceProps.connections.length > 0) {\n      for (const connectable of serviceProps.connections) {\n        service.connections.allowToDefaultPort(connectable);\n      }\n    }\n  }\n\n  private validateProps(props: EcsClusterProps): void {\n    // Validate services array\n    if (!props.services || props.services.length === 0) {\n      throw new Error(\"At least one service must be specified.\");\n    }\n\n    // Check for duplicate service names\n    const serviceNames = props.services.map((s) => s.name);\n    const duplicateServices = serviceNames.filter(\n      (name, index) => serviceNames.indexOf(name) !== index\n    );\n    if (duplicateServices.length > 0) {\n      throw new Error(\n        `Duplicate service names: ${[...new Set(duplicateServices)].join(\", \")}`\n      );\n    }\n\n    // Validate routing when multiple services have ports\n    const servicesWithPorts = props.services.filter((s) =>\n      s.containers.some((c) => c.port !== undefined)\n    );\n\n    if (servicesWithPorts.length > 1 && !this.loadBalancerDisabled) {\n      const missingRouting = servicesWithPorts.filter(\n        (s) => !s.routing?.path && !s.routing?.host\n      );\n      if (missingRouting.length > 0) {\n        throw new Error(\n          `Services with ports require routing config when cluster has multiple services: ` +\n            `${missingRouting.map((s) => s.name).join(\", \")}. ` +\n            \"Add routing: { path: '/...' } to each service.\"\n        );\n      }\n    }\n\n    // Validate each service's containers\n    for (const service of props.services) {\n      if (!service.containers || service.containers.length === 0) {\n        throw new Error(\n          `Service '${service.name}': At least one container must be specified.`\n        );\n      }\n\n      // Check for duplicate container names within service\n      const containerNames = service.containers.map((c) => c.name);\n      const duplicateContainers = containerNames.filter(\n        (name, index) => containerNames.indexOf(name) !== index\n      );\n      if (duplicateContainers.length > 0) {\n        throw new Error(\n          `Service '${service.name}': Duplicate container names: ` +\n            `${[...new Set(duplicateContainers)].join(\", \")}`\n        );\n      }\n    }\n  }\n\n  private setupConnections(props: EcsClusterProps): void {\n    // Find the first service with a port for default connection\n    let defaultPort = 80;\n    for (const service of props.services) {\n      const primaryContainer = service.containers.find(\n        (c) => c.port !== undefined\n      );\n      if (primaryContainer?.port) {\n        defaultPort = primaryContainer.port;\n        break;\n      }\n    }\n\n    let securityGroups: ISecurityGroup[] = [];\n    if (this.isEc2()) {\n      securityGroups = [this.asgSecurityGroup!];\n    } else {\n      const firstService = this.services.values().next().value;\n      securityGroups = firstService?.service?.connections?.securityGroups || [];\n    }\n\n    this.connections = new Connections({\n      securityGroups,\n      defaultPort: Port.tcp(defaultPort)\n    });\n  }\n\n  /**\n   * Creates the execution role for ECS infrastructure operations.\n   * Used by the ECS agent to pull images, write logs, and inject secrets.\n   * NOT used by application code - that's the task role.\n   */\n  private createExecutionRole(serviceName: string): Role {\n    const executionRole = new Role(this, `${serviceName}ExecutionRole`, {\n      assumedBy: new ServicePrincipal(\"ecs-tasks.amazonaws.com\")\n    });\n\n    // ECR pull permissions\n    executionRole.addToPolicy(\n      new PolicyStatement({\n        effect: Effect.ALLOW,\n        actions: [\n          \"ecr:GetAuthorizationToken\",\n          \"ecr:BatchCheckLayerAvailability\",\n          \"ecr:GetDownloadUrlForLayer\",\n          \"ecr:BatchGetImage\"\n        ],\n        resources: [\"*\"]\n      })\n    );\n\n    // CloudWatch Logs permissions\n    executionRole.addToPolicy(\n      new PolicyStatement({\n        effect: Effect.ALLOW,\n        actions: [\n          \"logs:CreateLogStream\",\n          \"logs:PutLogEvents\",\n          \"logs:CreateLogGroup\"\n        ],\n        resources: [\"*\"]\n      })\n    );\n\n    // Secrets Manager access for injecting secrets into containers\n    executionRole.addToPolicy(\n      new PolicyStatement({\n        effect: Effect.ALLOW,\n        actions: [\n          \"secretsmanager:GetSecretValue\",\n          \"secretsmanager:DescribeSecret\"\n        ],\n        resources: [\"*\"]\n      })\n    );\n\n    // KMS decrypt for secrets encrypted with customer-managed keys\n    executionRole.addToPolicy(\n      new PolicyStatement({\n        effect: Effect.ALLOW,\n        actions: [\"kms:Decrypt\"],\n        resources: [\"*\"]\n      })\n    );\n\n    return executionRole;\n  }\n\n  /**\n   * Creates the task role for application code running in the container.\n   * This role is assumed by the application, not the ECS agent.\n   * Includes default ECS Exec permissions plus any service-specific policies.\n   */\n  private createTaskRole(\n    serviceName: string,\n    serviceProps: EcsServiceProps\n  ): Role {\n    const taskRole = new Role(this, `${serviceName}TaskRole`, {\n      assumedBy: new ServicePrincipal(\"ecs-tasks.amazonaws.com\")\n    });\n\n    // Default: SSM permissions for ECS Exec (ecs execute-command)\n    taskRole.addToPolicy(\n      new PolicyStatement({\n        effect: Effect.ALLOW,\n        actions: [\n          \"ssmmessages:CreateControlChannel\",\n          \"ssmmessages:CreateDataChannel\",\n          \"ssmmessages:OpenControlChannel\",\n          \"ssmmessages:OpenDataChannel\"\n        ],\n        resources: [\"*\"]\n      })\n    );\n\n    // Add service-specific inline policies\n    if (serviceProps.taskRoleInlinePolicies) {\n      for (const [policyName, policyDocument] of Object.entries(\n        serviceProps.taskRoleInlinePolicies\n      )) {\n        taskRole.attachInlinePolicy(\n          new Policy(this, `${serviceName}${policyName}`, {\n            document: policyDocument\n          })\n        );\n      }\n    }\n\n    // Add service-specific managed policies\n    if (serviceProps.taskRoleManagedPolicies) {\n      for (const policy of serviceProps.taskRoleManagedPolicies) {\n        taskRole.addManagedPolicy(policy);\n      }\n    }\n\n    return taskRole;\n  }\n\n  private createTaskDefinition(\n    serviceName: string,\n    serviceProps: EcsServiceProps,\n    executionRole: Role,\n    taskRole: Role\n  ): FargateTaskDefinition | Ec2TaskDefinition {\n    const cpu = serviceProps.cpu || 256;\n    const memoryLimitMiB = serviceProps.memoryLimitMiB || 512;\n\n    if (this.isFargate()) {\n      return new FargateTaskDefinition(this, `${serviceName}TaskDefinition`, {\n        family: `${this.props.clusterName}-${serviceName}`,\n        cpu,\n        memoryLimitMiB,\n        executionRole,\n        taskRole,\n        runtimePlatform: {\n          cpuArchitecture: CpuArchitecture.ARM64,\n          operatingSystemFamily: OperatingSystemFamily.LINUX\n        }\n      });\n    } else {\n      return new Ec2TaskDefinition(this, `${serviceName}TaskDefinition`, {\n        family: `${this.props.clusterName}-${serviceName}`,\n        executionRole,\n        taskRole,\n        ...(this.directAccessEnabled && { networkMode: NetworkMode.HOST })\n      });\n    }\n  }\n\n  private addContainersToTask(\n    serviceName: string,\n    serviceProps: EcsServiceProps,\n    taskDefinition: FargateTaskDefinition | Ec2TaskDefinition\n  ): {\n    containers: ContainerDefinition[];\n    primaryContainer?: ContainerDefinition;\n  } {\n    const containers: ContainerDefinition[] = [];\n    let primaryContainer: ContainerDefinition | undefined;\n\n    for (const containerConfig of serviceProps.containers) {\n      const image = this.getContainerImage(\n        serviceName,\n        containerConfig,\n        serviceProps\n      );\n      const isFirstWithPort =\n        !primaryContainer && containerConfig.port !== undefined;\n\n      // Build secrets\n      const secrets: Record<string, EcsSecret> = {};\n      if (containerConfig.secretsImport) {\n        for (const [key, secretImport] of Object.entries(\n          containerConfig.secretsImport\n        )) {\n          const secret = Secret.fromSecretNameV2(\n            this,\n            `${serviceName}${containerConfig.name}${key}Secret`,\n            secretImport.name\n          );\n          secrets[key] = EcsSecret.fromSecretsManager(\n            secret,\n            secretImport.field\n          );\n        }\n      }\n\n      const container = taskDefinition.addContainer(\n        `${serviceName}${containerConfig.name}`,\n        {\n          image,\n          containerName: containerConfig.name,\n          logging: new AwsLogDriver({\n            streamPrefix: `/ecs/${this.props.clusterName}/${serviceName}/${containerConfig.name}`,\n            logRetention: 14\n          }),\n          environment: containerConfig.environment,\n          secrets,\n          command: containerConfig.command,\n          entryPoint: containerConfig.entryPoint,\n          essential: containerConfig.essential ?? true,\n          healthCheck: containerConfig.healthCheck\n            ? {\n                command: containerConfig.healthCheck.command,\n                interval: containerConfig.healthCheck.interval\n                  ? Duration.seconds(containerConfig.healthCheck.interval)\n                  : undefined,\n                timeout: containerConfig.healthCheck.timeout\n                  ? Duration.seconds(containerConfig.healthCheck.timeout)\n                  : undefined,\n                retries: containerConfig.healthCheck.retries,\n                startPeriod: containerConfig.healthCheck.startPeriod\n                  ? Duration.seconds(containerConfig.healthCheck.startPeriod)\n                  : undefined\n              }\n            : undefined,\n          ...(this.isEc2() && {\n            memoryLimitMiB: this.props.ec2Config?.memoryLimitMiB || 1024\n          })\n        }\n      );\n\n      if (containerConfig.port) {\n        container.addPortMappings({\n          containerPort: containerConfig.port\n        });\n      }\n\n      if (isFirstWithPort) {\n        primaryContainer = container;\n      }\n\n      containers.push(container);\n    }\n\n    return { containers, primaryContainer };\n  }\n\n  private getContainerImage(\n    serviceName: string,\n    containerConfig: EcsClusterContainerConfig,\n    serviceProps: EcsServiceProps\n  ): ContainerImage {\n    // Priority: container.image > service.image > cluster default\n    const imageSource =\n      containerConfig.image || serviceProps.image || this.props.ecrRepository;\n\n    if (!imageSource) {\n      return ContainerImage.fromRegistry(\"amazon/amazon-ecs-sample\");\n    }\n\n    // For multi-service deployments, use service-prefixed tags\n    const isMultiService = this.props.services.length > 1;\n    const imageTag = isMultiService ? `${serviceName}-latest` : \"latest\";\n\n    if (typeof imageSource === \"string\") {\n      // Check if it's an ECR repository name or a public image\n      if (imageSource.includes(\"/\") && !imageSource.includes(\".\")) {\n        return ContainerImage.fromRegistry(imageSource);\n      }\n      return ContainerImage.fromEcrRepository(\n        Repository.fromRepositoryName(\n          this,\n          `${serviceName}${containerConfig.name}EcrRepo`,\n          imageSource\n        ),\n        imageTag\n      );\n    }\n\n    if (imageSource instanceof Repository) {\n      return ContainerImage.fromEcrRepository(imageSource, imageTag);\n    }\n\n    // RepositoryImage extends ContainerImage, so this is a safe upcast\n    return imageSource as ContainerImage;\n  }\n\n  private createService(\n    serviceName: string,\n    serviceProps: EcsServiceProps,\n    taskDefinition: FargateTaskDefinition | Ec2TaskDefinition\n  ): FargateService | Ec2Service {\n    const desiredCount = serviceProps.desiredCount ?? 2;\n\n    if (this.isFargate()) {\n      const service = new FargateService(this, `${serviceName}Service`, {\n        cluster: this.cluster,\n        taskDefinition: taskDefinition as FargateTaskDefinition,\n        desiredCount,\n        serviceName,\n        capacityProviderStrategies: [\n          {\n            capacityProvider: this.capacityProvider,\n            weight: 1\n          }\n        ],\n        propagateTags: PropagatedTagSource.SERVICE,\n        circuitBreaker: { enable: true, rollback: true },\n        enableECSManagedTags: true,\n        enableExecuteCommand: true,\n        healthCheckGracePeriod: Duration.seconds(120),\n        minHealthyPercent: 100,\n        maxHealthyPercent: 200\n      });\n\n      new CfnOutput(this, `${serviceName}ServiceArn`, {\n        key: `${serviceName}ServiceArn`,\n        exportName: `${this.props.clusterName}${serviceName}ServiceArn`,\n        value: service.serviceArn,\n        description: `ECS Service ARN for ${serviceName}`\n      });\n\n      // Fargate service depends on capacity provider associations:\n      // - CREATE: Associations created first, then Service (correct - providers ready before service)\n      // - DELETE: Service deleted first, then Associations (correct - services gone before disassociation)\n      // This ensures CloudFormation deletes all services BEFORE attempting to remove\n      // the FARGATE/FARGATE_SPOT capacity provider associations from the cluster.\n      // See: https://github.com/aws/aws-cdk/issues/15366\n      if (this.fargateCapacityProviderAssociations) {\n        service.node.addDependency(this.fargateCapacityProviderAssociations);\n      }\n\n      return service;\n    } else {\n      const service = new Ec2Service(this, `${serviceName}Service`, {\n        cluster: this.cluster,\n        taskDefinition: taskDefinition as Ec2TaskDefinition,\n        desiredCount,\n        serviceName,\n        capacityProviderStrategies: [\n          {\n            capacityProvider: this.asgCapacityProvider!.capacityProviderName,\n            weight: 1\n          }\n        ],\n        propagateTags: PropagatedTagSource.SERVICE,\n        circuitBreaker: { enable: true, rollback: true },\n        placementStrategies: [PlacementStrategy.spreadAcrossInstances()],\n        enableECSManagedTags: true,\n        enableExecuteCommand: true,\n        healthCheckGracePeriod: Duration.seconds(120),\n        minHealthyPercent: 100,\n        maxHealthyPercent: 200\n      });\n\n      new CfnOutput(this, `${serviceName}ServiceArn`, {\n        key: `${serviceName}ServiceArn`,\n        exportName: `${this.props.clusterName}${serviceName}ServiceArn`,\n        value: service.serviceArn,\n        description: `ECS Service ARN for ${serviceName}`\n      });\n\n      // Service depends on DrainWaiter:\n      // - CREATE: DrainWaiter created first, then Service (correct - infra ready before service)\n      // - DELETE: Service deleted first, then DrainWaiter runs (correct - services gone before drain)\n      // This ensures CloudFormation deletes all services BEFORE the DrainWaiter Lambda runs,\n      // which then disassociates the capacity provider before it's deleted.\n      if (this.drainWaiter) {\n        service.node.addDependency(this.drainWaiter);\n      }\n\n      return service;\n    }\n  }\n\n  private registerServiceWithALB(\n    serviceName: string,\n    serviceProps: EcsServiceProps,\n    service: FargateService | Ec2Service,\n    primaryContainer: ContainerDefinition\n  ): IApplicationTargetGroup {\n    const containerPort = primaryContainer.containerPort;\n    const healthCheckPath = serviceProps.routing?.healthCheckPath || \"/\";\n\n    // Determine routing conditions\n    const servicesWithPorts = this.props.services.filter((s) =>\n      s.containers.some((c) => c.port !== undefined)\n    );\n    const isSingleService = servicesWithPorts.length === 1;\n\n    const healthCheckConfig = this.isEc2()\n      ? {\n          interval: Duration.seconds(30),\n          healthyThresholdCount: 3,\n          unhealthyThresholdCount: 3,\n          path: healthCheckPath,\n          port: \"traffic-port\" as const,\n          timeout: Duration.seconds(15)\n        }\n      : {\n          interval: Duration.seconds(120),\n          path: healthCheckPath,\n          port: `${containerPort}`,\n          timeout: Duration.seconds(10)\n        };\n\n    if (isSingleService) {\n      // Single service - create target group with service as default target\n      return this.loadBalancerListener!.addTargets(\n        `${serviceName}TargetGroup`,\n        {\n          targets: [\n            service.loadBalancerTarget({\n              containerName: primaryContainer.containerName,\n              containerPort\n            })\n          ],\n          port: containerPort,\n          protocol: ApplicationProtocol.HTTP,\n          healthCheck: healthCheckConfig\n        }\n      );\n    } else {\n      // Multi-service - create target group with routing rules\n      const priority = serviceProps.routing?.priority || this.nextPriority++;\n\n      const targetGroup = this.loadBalancerListener!.addTargets(\n        `${serviceName}Targets`,\n        {\n          targets: [\n            service.loadBalancerTarget({\n              containerName: primaryContainer.containerName,\n              containerPort\n            })\n          ],\n          port: containerPort,\n          protocol: ApplicationProtocol.HTTP,\n          healthCheck: healthCheckConfig,\n          conditions: this.buildRoutingConditions(serviceProps),\n          priority\n        }\n      );\n\n      return targetGroup;\n    }\n  }\n\n  private buildRoutingConditions(\n    serviceProps: EcsServiceProps\n  ): ListenerCondition[] {\n    const conditions: ListenerCondition[] = [];\n\n    if (serviceProps.routing?.path) {\n      conditions.push(\n        ListenerCondition.pathPatterns([serviceProps.routing.path])\n      );\n    }\n    if (serviceProps.routing?.host) {\n      conditions.push(\n        ListenerCondition.hostHeaders([serviceProps.routing.host])\n      );\n    }\n\n    return conditions;\n  }\n\n  private addServiceScaling(\n    serviceName: string,\n    serviceProps: EcsServiceProps,\n    service: FargateService | Ec2Service\n  ): TargetTrackingScalingPolicy {\n    const scalableTarget = new ScalableTarget(\n      this,\n      `${serviceName}ScalableTarget`,\n      {\n        serviceNamespace: ServiceNamespace.ECS,\n        resourceId: `service/${this.cluster.clusterName}/${service.serviceName}`,\n        scalableDimension: \"ecs:service:DesiredCount\",\n        minCapacity: serviceProps.minCapacity ?? 2,\n        maxCapacity: serviceProps.maxCapacity ?? 10\n      }\n    );\n\n    return new TargetTrackingScalingPolicy(\n      this,\n      `${serviceName}ScalingPolicy`,\n      {\n        scalingTarget: scalableTarget,\n        predefinedMetric:\n          serviceProps.scalingType === ScalingType.MEMORY\n            ? PredefinedMetric.ECS_SERVICE_AVERAGE_MEMORY_UTILIZATION\n            : PredefinedMetric.ECS_SERVICE_AVERAGE_CPU_UTILIZATION,\n        targetValue: 50,\n        scaleInCooldown: Duration.seconds(60),\n        scaleOutCooldown: Duration.seconds(60)\n      }\n    );\n  }\n\n  private isEc2(): boolean {\n    return this.capacityProvider === \"EC2\";\n  }\n\n  private isFargate(): boolean {\n    return (\n      this.capacityProvider === \"FARGATE\" ||\n      this.capacityProvider === \"FARGATE_SPOT\"\n    );\n  }\n\n  addCluster(props: EcsClusterProps) {\n    this.cluster = new CdkCluster(this, `${props.clusterName}`, {\n      vpc: props.vpc,\n      clusterName: props.clusterName,\n      containerInsightsV2: ContainerInsights.ENABLED,\n      enableFargateCapacityProviders: this.isFargate()\n    });\n\n    // For Fargate clusters, find the internal CfnClusterCapacityProviderAssociations\n    // that CDK creates when enableFargateCapacityProviders is true.\n    // We need this reference to establish proper deletion dependencies.\n    if (this.isFargate()) {\n      // CDK creates this as a child of the cluster with a specific naming pattern\n      const children = this.cluster.node.children;\n      for (const child of children) {\n        if (child instanceof CfnClusterCapacityProviderAssociations) {\n          this.fargateCapacityProviderAssociations = child;\n          break;\n        }\n      }\n    }\n\n    new CfnOutput(this, `${props.clusterName}DeployableCluster`, {\n      key: `${props.clusterName}DeployableCluster`,\n      exportName: `${props.clusterName}DeployableCluster`,\n      value: this.cluster.clusterArn\n    });\n\n    new CfnOutput(this, `${props.clusterName}ClusterArn`, {\n      key: \"ClusterArn\",\n      exportName: `${props.clusterName}ClusterArn`,\n      value: this.cluster.clusterArn,\n      description: `ECS Cluster ARN for ${props.clusterName}`\n    });\n  }\n\n  addAutoScalingGroup(props: EcsClusterProps) {\n    const ec2Config = props.ec2Config || {};\n    const instanceType = ec2Config.instanceType || \"t3.micro\";\n    const amiHardwareType =\n      ec2Config.amiHardwareType === \"STANDARD\"\n        ? AmiHardwareType.STANDARD\n        : AmiHardwareType.ARM;\n    const minCapacity = ec2Config.minCapacity ?? 2;\n    const maxCapacity = ec2Config.maxCapacity ?? 3;\n\n    this.asgSecurityGroup = new SecurityGroup(this, `AsgSecurityGroup`, {\n      vpc: this.cluster.vpc,\n      description: `Security group for the ${props.clusterName} auto scaling group`\n    });\n\n    // Open container ports for direct EC2 access\n    if (this.directAccessEnabled) {\n      for (const service of props.services) {\n        for (const container of service.containers) {\n          if (container.port) {\n            this.asgSecurityGroup.addIngressRule(\n              Peer.anyIpv4(),\n              Port.tcp(container.port),\n              `Direct access to container port ${container.port}`\n            );\n          }\n        }\n      }\n    }\n\n    this.autoScalingGroup = new AutoScalingGroup(this, \"AutoScalingGroup\", {\n      autoScalingGroupName: `${props.clusterName}AutoScalingGroup`,\n      vpc: this.cluster.vpc,\n      vpcSubnets: {\n        subnetType: SubnetType.PUBLIC\n      },\n      securityGroup: this.asgSecurityGroup,\n      minCapacity,\n      maxCapacity,\n      instanceType: new InstanceType(instanceType),\n      capacityRebalance: true,\n      instanceMonitoring: Monitoring.BASIC,\n      machineImage: EcsOptimizedImage.amazonLinux2(amiHardwareType)\n    });\n\n    this.asgCapacityProvider = new AsgCapacityProvider(\n      this,\n      \"AsgCapacityProvider\",\n      {\n        autoScalingGroup: this.autoScalingGroup,\n        enableManagedDraining: true,\n        enableManagedTerminationProtection: false\n      }\n    );\n\n    this.cluster.addAsgCapacityProvider(this.asgCapacityProvider);\n\n    // Create drain waiter custom resource that handles capacity provider cleanup during deletion.\n    // This resource waits for ECS services to drain, then disassociates the capacity provider\n    // from the cluster before CloudFormation attempts to delete the AsgCapacityProvider.\n    //\n    // Dependency chain for DELETE order:\n    //   Services deleted → DrainWaiter runs → AsgCapacityProvider deleted → Cluster deleted\n    //\n    // The drain waiter must depend on AsgCapacityProvider so it runs BEFORE the provider is deleted.\n    // Services must depend on the drain waiter so they're deleted BEFORE the drain waiter runs.\n    this.drainWaiter = new CapacityProviderDrainWaiter(\n      this,\n      \"CapacityProviderDrainWaiter\",\n      {\n        clusterName: props.clusterName,\n        capacityProviderName: this.asgCapacityProvider.capacityProviderName\n      }\n    );\n\n    // DrainWaiter depends on AsgCapacityProvider:\n    // - CREATE: AsgCapacityProvider created first, then DrainWaiter\n    // - DELETE: DrainWaiter deleted first (runs Lambda), then AsgCapacityProvider\n    this.drainWaiter.node.addDependency(this.asgCapacityProvider);\n  }\n\n  addLoadBalancer(props: EcsClusterProps) {\n    const defaultLoadBalancerName = `${props.clusterName}LoadBalancer`;\n    const supportedNameLength = 32;\n\n    let truncatedLoadBalancerName =\n      defaultLoadBalancerName.length > supportedNameLength\n        ? defaultLoadBalancerName.substring(0, supportedNameLength)\n        : defaultLoadBalancerName;\n\n    truncatedLoadBalancerName = truncatedLoadBalancerName.replace(/-+$/, \"\");\n\n    const isInternal = props.cluster?.loadBalancer === \"internal\";\n\n    if (this.isEc2()) {\n      this.loadBalancerSecurityGroup = new SecurityGroup(\n        this,\n        `LoadBalancerSecurityGroup`,\n        {\n          vpc: this.cluster.vpc,\n          description: `Security group for the ${props.clusterName} load balancer`\n        }\n      );\n\n      this.loadBalancerSecurityGroup.connections.allowTo(\n        this.asgSecurityGroup!,\n        Port.allTcp()\n      );\n\n      this.loadBalancer = new ApplicationLoadBalancer(\n        this,\n        `${props.clusterName}LoadBalancer`,\n        {\n          vpc: this.cluster.vpc,\n          internetFacing: !isInternal,\n          securityGroup: this.loadBalancerSecurityGroup,\n          loadBalancerName: truncatedLoadBalancerName,\n          vpcSubnets: {\n            subnetType: isInternal\n              ? SubnetType.PRIVATE_WITH_EGRESS\n              : SubnetType.PUBLIC\n          }\n        }\n      );\n\n      this.asgSecurityGroup!.connections.allowFrom(\n        this.loadBalancerSecurityGroup,\n        Port.tcpRange(49152, 65535)\n      );\n    } else {\n      this.loadBalancer = new ApplicationLoadBalancer(\n        this,\n        `${props.clusterName}LoadBalancer`,\n        {\n          vpc: this.cluster.vpc,\n          internetFacing: !isInternal,\n          loadBalancerName: truncatedLoadBalancerName,\n          vpcSubnets: {\n            subnetType: isInternal\n              ? SubnetType.PRIVATE_WITH_EGRESS\n              : SubnetType.PUBLIC\n          }\n        }\n      );\n    }\n\n    new CfnOutput(this, `${props.clusterName}LoadBalancerDnsName`, {\n      key: `${props.clusterName}LoadBalancerDnsName`,\n      exportName: `${props.clusterName}LoadBalancerDnsName`,\n      value: this.loadBalancer.loadBalancerDnsName\n    });\n\n    new CfnOutput(this, `${props.clusterName}LoadBalancerUrl`, {\n      key: \"LoadBalancerUrl\",\n      exportName: `${props.clusterName}LoadBalancerUrl`,\n      value: `http://${this.loadBalancer.loadBalancerDnsName}`,\n      description: `Load Balancer URL for ${props.clusterName}`\n    });\n  }\n\n  private addDirectAccessOutputs(props: EcsClusterProps) {\n    if (!this.directAccessEnabled || !this.autoScalingGroup) return;\n\n    // Get the first container port (for user instructions)\n    const containerPort =\n      props.services.flatMap((s) => s.containers).find((c) => c.port)?.port ||\n      3000;\n\n    new CfnOutput(this, `${props.clusterName}AutoScalingGroupName`, {\n      key: \"AutoScalingGroupName\",\n      exportName: `${props.clusterName}AutoScalingGroupName`,\n      value: this.autoScalingGroup.autoScalingGroupName,\n      description: `Run: aws autoscaling describe-auto-scaling-groups --auto-scaling-group-names <name> to find instance IP`\n    });\n\n    new CfnOutput(this, `${props.clusterName}DirectAccessPort`, {\n      key: \"DirectAccessPort\",\n      exportName: `${props.clusterName}DirectAccessPort`,\n      value: String(containerPort),\n      description: `Access your app at http://<EC2-PUBLIC-IP>:${containerPort}`\n    });\n  }\n\n  addLoadBalancerListener(props: EcsClusterProps) {\n    if (!this.loadBalancer) return;\n\n    // Determine port based on whether HTTPS is configured (domain + cert)\n    const port = this.certificate ? 443 : 80;\n\n    // Default action for requests that don't match any routing rule\n    // Returns 404 for multi-service clusters with routing rules\n    const defaultAction = ListenerAction.fixedResponse(404, {\n      contentType: \"text/plain\",\n      messageBody: \"Not Found\"\n    });\n\n    if (this.certificate) {\n      this.loadBalancerListener = this.loadBalancer.addListener(\n        `${props.clusterName}Listener`,\n        {\n          port,\n          certificates: [this.certificate],\n          defaultAction\n        }\n      );\n    } else {\n      this.loadBalancerListener = this.loadBalancer.addListener(\n        `${props.clusterName}Listener`,\n        {\n          port,\n          defaultAction\n        }\n      );\n    }\n  }\n\n  addHostedZone(props: EcsClusterProps) {\n    // Support both new cluster.domain and advanced cluster.domainConfig\n    const domainConfig = props.cluster?.domainConfig;\n    const simpleDomain = props.cluster?.domain;\n\n    if (!domainConfig && !simpleDomain) return;\n\n    const domainName = domainConfig?.domainName || simpleDomain!;\n\n    if (!domainConfig?.hostedZone) {\n      const hostedZone = new FjallHostedZone(\n        this,\n        `${props.clusterName}HostedZone`,\n        {\n          zoneName: domainName\n        }\n      );\n\n      this.hostedZone = hostedZone.getInternalHostedZone();\n    } else {\n      this.hostedZone = domainConfig.hostedZone.getInternalHostedZone();\n    }\n\n    if (!domainConfig?.certificate) {\n      this.certificate = new Certificate(\n        this,\n        `${props.clusterName}Certificate`,\n        {\n          domainName,\n          validation: CertificateValidation.fromDns(this.hostedZone)\n        }\n      );\n    }\n\n    // Handle advanced routing policies (latency, weighted, geo)\n    if (domainConfig) {\n      const latencyConfig = domainConfig as LatencyDomainConfig;\n      const weightedConfig = domainConfig as WeightedDomainConfig;\n      const geoConfig = domainConfig as GeoLocationDomainConfig;\n\n      const hasRoutingPolicy: boolean =\n        !!latencyConfig?.region ||\n        weightedConfig?.weight !== undefined ||\n        !!geoConfig?.geoLocation;\n\n      let setIdentifier = domainConfig.setIdentifier;\n      if (hasRoutingPolicy && !setIdentifier) {\n        if (latencyConfig?.region) {\n          setIdentifier = `${props.clusterName}${latencyConfig.region}`;\n        } else if (weightedConfig?.weight !== undefined) {\n          setIdentifier = `${props.clusterName}Weight${weightedConfig.weight}`;\n        } else if (geoConfig?.geoLocation) {\n          setIdentifier = `${props.clusterName}Geo`;\n        }\n      }\n\n      if (this.loadBalancer) {\n        this.aRecord = new ARecord(this, `${props.clusterName}ARecord`, {\n          recordName: domainName,\n          zone: this.hostedZone,\n          target: RecordTarget.fromAlias(\n            new LoadBalancerTarget(this.loadBalancer, {\n              evaluateTargetHealth: hasRoutingPolicy\n            })\n          ),\n          region: latencyConfig?.region,\n          weight: weightedConfig?.weight,\n          geoLocation: geoConfig?.geoLocation,\n          setIdentifier: setIdentifier\n        });\n      }\n    } else if (simpleDomain && this.loadBalancer) {\n      // Simple domain - just create A record\n      this.aRecord = new ARecord(this, `${props.clusterName}ARecord`, {\n        recordName: domainName,\n        zone: this.hostedZone,\n        target: RecordTarget.fromAlias(\n          new LoadBalancerTarget(this.loadBalancer)\n        )\n      });\n    }\n  }\n\n  static build(\n    id: string,\n    props: EcsClusterProps\n  ): (sb: StackBuilder) => Construct {\n    return (sb: StackBuilder) => {\n      const newProps: EcsClusterProps = {\n        ...props,\n        ...{\n          vpc: (sb.getNetwork() as IVpc) || props.vpc\n        }\n      };\n      return new this(sb.getStack(), id, newProps);\n    };\n  }\n}\n"]}