@fjall/components-infrastructure 0.79.3 → 0.80.4

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

@@ -0,0 +1,180 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CapacityProviderDrainWaiter = void 0;
+const aws_cdk_lib_1 = require("aws-cdk-lib");
+const aws_iam_1 = require("aws-cdk-lib/aws-iam");
+const aws_lambda_1 = require("aws-cdk-lib/aws-lambda");
+const constructs_1 = require("constructs");
+const customResource_1 = require("../utilities/customResource");
+/**
+ * Custom resource that waits for ECS services to drain before allowing
+ * capacity provider disassociation.
+ *
+ * @see https://github.com/aws/aws-cdk/issues/14732
+ */
+class CapacityProviderDrainWaiter extends constructs_1.Construct {
+    constructor(scope, id, props) {
+        super(scope, id);
+        const { clusterName, capacityProviderName } = props;
+        // Lambda inline code for the custom resource handler
+        const handlerCode = `
+const { ECSClient, ListServicesCommand, DescribeServicesCommand, PutClusterCapacityProvidersCommand, DescribeClustersCommand } = require("@aws-sdk/client-ecs");
+
+const ecsClient = new ECSClient({});
+const POLL_INTERVAL_MS = 5000;
+const MAX_WAIT_MS = 300000; // 5 minutes
+
+async function sleep(ms) {
+  return new Promise(resolve => setTimeout(resolve, ms));
+}
+
+async function getClusterCapacityProviders(clusterName) {
+  const response = await ecsClient.send(new DescribeClustersCommand({
+    clusters: [clusterName]
+  }));
+  return response.clusters?.[0]?.capacityProviders || [];
+}
+
+async function waitForServicesDrained(clusterName, capacityProviderName) {
+  const startTime = Date.now();
+
+  while (Date.now() - startTime < MAX_WAIT_MS) {
+    // List all services in the cluster
+    const listResponse = await ecsClient.send(new ListServicesCommand({
+      cluster: clusterName,
+      maxResults: 100
+    }));
+
+    const serviceArns = listResponse.serviceArns || [];
+
+    if (serviceArns.length === 0) {
+      console.log("No services found in cluster - drain complete");
+      return true;
+    }
+
+    // Describe services to check running counts
+    const describeResponse = await ecsClient.send(new DescribeServicesCommand({
+      cluster: clusterName,
+      services: serviceArns
+    }));
+
+    const activeServices = (describeResponse.services || []).filter(svc => {
+      // Check if service uses this capacity provider
+      const usesCapacityProvider = (svc.capacityProviderStrategy || [])
+        .some(strategy => strategy.capacityProvider === capacityProviderName);
+
+      // Only care about services using this capacity provider that still have running tasks
+      return usesCapacityProvider && svc.runningCount > 0;
+    });
+
+    if (activeServices.length === 0) {
+      console.log("All services using capacity provider have drained");
+      return true;
+    }
+
+    console.log(\`Waiting for \${activeServices.length} services to drain: \${activeServices.map(s => s.serviceName).join(", ")}\`);
+    await sleep(POLL_INTERVAL_MS);
+  }
+
+  console.log("Timeout waiting for services to drain, proceeding anyway");
+  return false;
+}
+
+async function disassociateCapacityProvider(clusterName, capacityProviderName) {
+  try {
+    // Get current capacity providers
+    const currentProviders = await getClusterCapacityProviders(clusterName);
+
+    // Filter out the one we want to remove
+    const remainingProviders = currentProviders.filter(cp => cp !== capacityProviderName);
+
+    if (remainingProviders.length === currentProviders.length) {
+      console.log(\`Capacity provider \${capacityProviderName} not associated with cluster\`);
+      return true;
+    }
+
+    // Ensure we keep at least FARGATE as a provider (required by ECS)
+    if (remainingProviders.length === 0) {
+      remainingProviders.push("FARGATE");
+    }
+
+    console.log(\`Disassociating \${capacityProviderName} from cluster. Remaining: \${remainingProviders.join(", ")}\`);
+
+    await ecsClient.send(new PutClusterCapacityProvidersCommand({
+      cluster: clusterName,
+      capacityProviders: remainingProviders,
+      defaultCapacityProviderStrategy: []
+    }));
+
+    console.log("Successfully disassociated capacity provider");
+    return true;
+  } catch (error) {
+    // If cluster or capacity provider doesn't exist, that's fine (already deleted)
+    if (error.name === "ClusterNotFoundException" ||
+        error.name === "ResourceNotFoundException" ||
+        error.message?.includes("does not exist")) {
+      console.log("Cluster or capacity provider not found - already cleaned up");
+      return true;
+    }
+    throw error;
+  }
+}
+
+exports.handler = async (event) => {
+  console.log("Event:", JSON.stringify(event, null, 2));
+
+  const clusterName = event.ResourceProperties.ClusterName;
+  const capacityProviderName = event.ResourceProperties.CapacityProviderName;
+  const requestType = event.RequestType;
+
+  try {
+    if (requestType === "Delete") {
+      console.log(\`Handling DELETE for capacity provider \${capacityProviderName} in cluster \${clusterName}\`);
+
+      // Wait for services to drain
+      await waitForServicesDrained(clusterName, capacityProviderName);
+
+      // Disassociate capacity provider from cluster
+      await disassociateCapacityProvider(clusterName, capacityProviderName);
+    }
+
+    // Return success for all request types
+    return {
+      PhysicalResourceId: \`\${clusterName}-\${capacityProviderName}-drain-waiter\`,
+      Data: {
+        Message: \`\${requestType} completed successfully\`
+      }
+    };
+  } catch (error) {
+    console.error("Error:", error);
+    throw error;
+  }
+};
+`;
+        new customResource_1.CustomResource(this, "DrainWaiter", {
+            runtime: aws_lambda_1.Runtime.NODEJS_22_X,
+            inlineCode: handlerCode,
+            timeout: aws_cdk_lib_1.Duration.minutes(6),
+            lambdaDescription: `Waits for ECS services to drain before capacity provider disassociation`,
+            roleDescription: `Role for ${clusterName} capacity provider drain waiter`,
+            inlinePolicy: [
+                new aws_iam_1.PolicyStatement({
+                    effect: aws_iam_1.Effect.ALLOW,
+                    actions: [
+                        "ecs:ListServices",
+                        "ecs:DescribeServices",
+                        "ecs:DescribeClusters",
+                        "ecs:PutClusterCapacityProviders"
+                    ],
+                    resources: ["*"]
+                })
+            ],
+            properties: {
+                ClusterName: clusterName,
+                CapacityProviderName: capacityProviderName
+            }
+        });
+    }
+}
+exports.CapacityProviderDrainWaiter = CapacityProviderDrainWaiter;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"capacityProviderDrainWaiter.js","sourceRoot":"","sources":["../../../../../lib/resources/aws/compute/capacityProviderDrainWaiter.ts"],"names":[],"mappings":";;;AAAA,6CAAuC;AACvC,iDAA8D;AAC9D,uDAAiD;AACjD,2CAAuC;AACvC,gEAA6D;AAY7D;;;;;GAKG;AACH,MAAa,2BAA4B,SAAQ,sBAAS;IACxD,YACE,KAAgB,EAChB,EAAU,EACV,KAAuC;QAEvC,KAAK,CAAC,KAAK,EAAE,EAAE,CAAC,CAAC;QAEjB,MAAM,EAAE,WAAW,EAAE,oBAAoB,EAAE,GAAG,KAAK,CAAC;QAEpD,qDAAqD;QACrD,MAAM,WAAW,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAqIvB,CAAC;QAEE,IAAI,+BAAc,CAAC,IAAI,EAAE,aAAa,EAAE;YACtC,OAAO,EAAE,oBAAO,CAAC,WAAW;YAC5B,UAAU,EAAE,WAAW;YACvB,OAAO,EAAE,sBAAQ,CAAC,OAAO,CAAC,CAAC,CAAC;YAC5B,iBAAiB,EAAE,yEAAyE;YAC5F,eAAe,EAAE,YAAY,WAAW,iCAAiC;YACzE,YAAY,EAAE;gBACZ,IAAI,yBAAe,CAAC;oBAClB,MAAM,EAAE,gBAAM,CAAC,KAAK;oBACpB,OAAO,EAAE;wBACP,kBAAkB;wBAClB,sBAAsB;wBACtB,sBAAsB;wBACtB,iCAAiC;qBAClC;oBACD,SAAS,EAAE,CAAC,GAAG,CAAC;iBACjB,CAAC;aACH;YACD,UAAU,EAAE;gBACV,WAAW,EAAE,WAAW;gBACxB,oBAAoB,EAAE,oBAAoB;aAC3C;SACF,CAAC,CAAC;IACL,CAAC;CACF;AA1KD,kEA0KC","sourcesContent":["import { Duration } from \"aws-cdk-lib\";\nimport { PolicyStatement, Effect } from \"aws-cdk-lib/aws-iam\";\nimport { Runtime } from \"aws-cdk-lib/aws-lambda\";\nimport { Construct } from \"constructs\";\nimport { CustomResource } from \"../utilities/customResource\";\n\n/**\n * Props for CapacityProviderDrainWaiter\n */\ninterface CapacityProviderDrainWaiterProps {\n  /** The ECS cluster name */\n  clusterName: string;\n  /** The capacity provider name to wait for */\n  capacityProviderName: string;\n}\n\n/**\n * Custom resource that waits for ECS services to drain before allowing\n * capacity provider disassociation.\n *\n * @see https://github.com/aws/aws-cdk/issues/14732\n */\nexport class CapacityProviderDrainWaiter extends Construct {\n  constructor(\n    scope: Construct,\n    id: string,\n    props: CapacityProviderDrainWaiterProps\n  ) {\n    super(scope, id);\n\n    const { clusterName, capacityProviderName } = props;\n\n    // Lambda inline code for the custom resource handler\n    const handlerCode = `\nconst { ECSClient, ListServicesCommand, DescribeServicesCommand, PutClusterCapacityProvidersCommand, DescribeClustersCommand } = require(\"@aws-sdk/client-ecs\");\n\nconst ecsClient = new ECSClient({});\nconst POLL_INTERVAL_MS = 5000;\nconst MAX_WAIT_MS = 300000; // 5 minutes\n\nasync function sleep(ms) {\n  return new Promise(resolve => setTimeout(resolve, ms));\n}\n\nasync function getClusterCapacityProviders(clusterName) {\n  const response = await ecsClient.send(new DescribeClustersCommand({\n    clusters: [clusterName]\n  }));\n  return response.clusters?.[0]?.capacityProviders || [];\n}\n\nasync function waitForServicesDrained(clusterName, capacityProviderName) {\n  const startTime = Date.now();\n\n  while (Date.now() - startTime < MAX_WAIT_MS) {\n    // List all services in the cluster\n    const listResponse = await ecsClient.send(new ListServicesCommand({\n      cluster: clusterName,\n      maxResults: 100\n    }));\n\n    const serviceArns = listResponse.serviceArns || [];\n\n    if (serviceArns.length === 0) {\n      console.log(\"No services found in cluster - drain complete\");\n      return true;\n    }\n\n    // Describe services to check running counts\n    const describeResponse = await ecsClient.send(new DescribeServicesCommand({\n      cluster: clusterName,\n      services: serviceArns\n    }));\n\n    const activeServices = (describeResponse.services || []).filter(svc => {\n      // Check if service uses this capacity provider\n      const usesCapacityProvider = (svc.capacityProviderStrategy || [])\n        .some(strategy => strategy.capacityProvider === capacityProviderName);\n\n      // Only care about services using this capacity provider that still have running tasks\n      return usesCapacityProvider && svc.runningCount > 0;\n    });\n\n    if (activeServices.length === 0) {\n      console.log(\"All services using capacity provider have drained\");\n      return true;\n    }\n\n    console.log(\\`Waiting for \\${activeServices.length} services to drain: \\${activeServices.map(s => s.serviceName).join(\", \")}\\`);\n    await sleep(POLL_INTERVAL_MS);\n  }\n\n  console.log(\"Timeout waiting for services to drain, proceeding anyway\");\n  return false;\n}\n\nasync function disassociateCapacityProvider(clusterName, capacityProviderName) {\n  try {\n    // Get current capacity providers\n    const currentProviders = await getClusterCapacityProviders(clusterName);\n\n    // Filter out the one we want to remove\n    const remainingProviders = currentProviders.filter(cp => cp !== capacityProviderName);\n\n    if (remainingProviders.length === currentProviders.length) {\n      console.log(\\`Capacity provider \\${capacityProviderName} not associated with cluster\\`);\n      return true;\n    }\n\n    // Ensure we keep at least FARGATE as a provider (required by ECS)\n    if (remainingProviders.length === 0) {\n      remainingProviders.push(\"FARGATE\");\n    }\n\n    console.log(\\`Disassociating \\${capacityProviderName} from cluster. Remaining: \\${remainingProviders.join(\", \")}\\`);\n\n    await ecsClient.send(new PutClusterCapacityProvidersCommand({\n      cluster: clusterName,\n      capacityProviders: remainingProviders,\n      defaultCapacityProviderStrategy: []\n    }));\n\n    console.log(\"Successfully disassociated capacity provider\");\n    return true;\n  } catch (error) {\n    // If cluster or capacity provider doesn't exist, that's fine (already deleted)\n    if (error.name === \"ClusterNotFoundException\" ||\n        error.name === \"ResourceNotFoundException\" ||\n        error.message?.includes(\"does not exist\")) {\n      console.log(\"Cluster or capacity provider not found - already cleaned up\");\n      return true;\n    }\n    throw error;\n  }\n}\n\nexports.handler = async (event) => {\n  console.log(\"Event:\", JSON.stringify(event, null, 2));\n\n  const clusterName = event.ResourceProperties.ClusterName;\n  const capacityProviderName = event.ResourceProperties.CapacityProviderName;\n  const requestType = event.RequestType;\n\n  try {\n    if (requestType === \"Delete\") {\n      console.log(\\`Handling DELETE for capacity provider \\${capacityProviderName} in cluster \\${clusterName}\\`);\n\n      // Wait for services to drain\n      await waitForServicesDrained(clusterName, capacityProviderName);\n\n      // Disassociate capacity provider from cluster\n      await disassociateCapacityProvider(clusterName, capacityProviderName);\n    }\n\n    // Return success for all request types\n    return {\n      PhysicalResourceId: \\`\\${clusterName}-\\${capacityProviderName}-drain-waiter\\`,\n      Data: {\n        Message: \\`\\${requestType} completed successfully\\`\n      }\n    };\n  } catch (error) {\n    console.error(\"Error:\", error);\n    throw error;\n  }\n};\n`;\n\n    new CustomResource(this, \"DrainWaiter\", {\n      runtime: Runtime.NODEJS_22_X,\n      inlineCode: handlerCode,\n      timeout: Duration.minutes(6),\n      lambdaDescription: `Waits for ECS services to drain before capacity provider disassociation`,\n      roleDescription: `Role for ${clusterName} capacity provider drain waiter`,\n      inlinePolicy: [\n        new PolicyStatement({\n          effect: Effect.ALLOW,\n          actions: [\n            \"ecs:ListServices\",\n            \"ecs:DescribeServices\",\n            \"ecs:DescribeClusters\",\n            \"ecs:PutClusterCapacityProviders\"\n          ],\n          resources: [\"*\"]\n        })\n      ],\n      properties: {\n        ClusterName: clusterName,\n        CapacityProviderName: capacityProviderName\n      }\n    });\n  }\n}\n"]}

package/dist/lib/resources/aws/compute/ecs.d.ts

@@ -3,7 +3,7 @@ import { Connections, type IConnectable, type IVpc } from "aws-cdk-lib/aws-ec2";
 import { Construct } from "constructs";
 import { type StackBuilder } from "../base/awsStack";
 import { type ApplicationListener, ApplicationLoadBalancer } from "aws-cdk-lib/aws-elasticloadbalancingv2";
-import { type IManagedPolicy, PolicyDocument } from "aws-cdk-lib/aws-iam";
+import { type IManagedPolicy, type PolicyDocument } from "aws-cdk-lib/aws-iam";
 import { Certificate } from "aws-cdk-lib/aws-certificatemanager";
 import { type GeoLocation } from "aws-cdk-lib/aws-route53";
 import { Repository } from "aws-cdk-lib/aws-ecr";
@@ -210,6 +210,17 @@ export interface EcsServiceProps {
      * Creates security group rules to allow traffic from this specific service only.
      */
     connections?: IConnectable[];
+    /**
+     * Capacity provider for this service. REQUIRED.
+     * Each service specifies its own capacity provider.
+     */
+    capacityProvider: EcsCapacityProvider;
+    /**
+     * EC2 capacity configuration for this service.
+     * Only used when service capacityProvider is "EC2".
+     * Services with matching ec2Config share an ASG for efficiency.
+     */
+    ec2Config?: Ec2CapacityConfig;
 }
 /**
  * Props for creating an ECS cluster with multiple services.
@@ -221,10 +232,6 @@ export type EcsClusterProps = {
     vpc?: IVpc;
     /** Default ECR repository or container image */
     ecrRepository: Repository | RepositoryImage | string;
-    /** Capacity provider determines Fargate vs EC2 infrastructure */
-    capacityProvider?: EcsCapacityProvider;
-    /** EC2-specific configuration. Only used when capacityProvider is "EC2" */
-    ec2Config?: Ec2CapacityConfig;
     /**
      * Cluster configuration.
      * Controls the shared ALB for all services.
@@ -233,6 +240,7 @@ export type EcsClusterProps = {
     /**
      * Services in this cluster.
      * Each service gets its own task definition, scaling, and target group.
+     * Each service MUST specify its own capacityProvider.
      * All services share the cluster's ALB (unless disabled).
      * Task role policies are configured per-service for least-privilege.
      */
@@ -286,12 +294,10 @@ export default class EcsCluster extends Construct implements IConnectable {
     private asgSecurityGroup?;
     private asgCapacityProvider?;
     private loadBalancerSecurityGroup?;
-    private drainWaiter?;
-    private fargateCapacityProviderAssociations?;
     private services;
+    private asgCapacityProviders;
     private scope;
     private props;
-    private capacityProvider;
     private loadBalancerDisabled;
     private directAccessEnabled;
     private nextPriority;
@@ -334,10 +340,58 @@ export default class EcsCluster extends Construct implements IConnectable {
     private registerServiceWithALB;
     private buildRoutingConditions;
     private addServiceScaling;
-    private isEc2;
-    private isFargate;
+    /**
+     * Checks if any service in the cluster uses EC2 capacity provider.
+     */
+    private hasAnyEc2Service;
+    /**
+     * Checks if any service in the cluster uses Fargate capacity provider.
+     */
+    private hasAnyFargateService;
+    /**
+     * Check if the VPC has NAT gateways.
+     * - For Fjall Vpc: uses hasNatGateways property
+     * - For other VPCs: checks if private subnets exist (assumes NAT if present)
+     */
+    private vpcHasNatGateways;
+    /**
+     * Create DeployableService outputs for deployment automation.
+     * Each service gets a DeployableService output so the deployment service
+     * can find and deploy all services in the cluster.
+     */
+    addDeployableServiceOutputs(props: EcsClusterProps): void;
+    /**
+     * Gets the capacity provider for a service.
+     * Each service MUST specify its own capacityProvider.
+     */
+    private getServiceCapacityProvider;
+    /**
+     * Checks if a service uses a Fargate capacity provider.
+     */
+    private isServiceFargate;
+    /**
+     * Checks if a service uses an EC2 capacity provider.
+     */
+    private isServiceEc2;
+    /**
+     * Generates a unique key for EC2 config (for ASG deduplication).
+     * Services with matching keys share an ASG.
+     */
+    private getEc2ConfigKey;
+    /**
+     * Gets or creates an ASG capacity provider for a service.
+     * Services with matching EC2 configs share the same ASG.
+     */
+    private getOrCreateAsgCapacityProvider;
+    /**
+     * Checks if any service in the cluster uses a Fargate capacity provider.
+     */
+    private anyServiceUsesFargate;
+    /**
+     * Checks if any service in the cluster uses an EC2 capacity provider.
+     */
+    private anyServiceUsesEc2;
     addCluster(props: EcsClusterProps): void;
-    addAutoScalingGroup(props: EcsClusterProps): void;
     addLoadBalancer(props: EcsClusterProps): void;
     private addDirectAccessOutputs;
     addLoadBalancerListener(props: EcsClusterProps): void;