@liflig/cdk 2.18.5 → 2.18.6

package/lib/ecs/fargate-service.d.ts

@@ -0,0 +1,63 @@
+import * as cdk from "aws-cdk-lib";
+import * as ec2 from "aws-cdk-lib/aws-ec2";
+import * as ecs from "aws-cdk-lib/aws-ecs";
+import * as elb from "aws-cdk-lib/aws-elasticloadbalancingv2";
+import * as logs from "aws-cdk-lib/aws-logs";
+import * as constructs from "constructs";
+import { Parameter } from "../configure-parameters/configure-parameters";
+export interface FargateServiceProps {
+    serviceName: string;
+    vpc: ec2.IVpc;
+    cluster: ecs.ICluster;
+    desiredCount: number;
+    ecsImage: ecs.ContainerImage;
+    /**
+     * @default 256
+     */
+    cpu?: number;
+    /**
+     * @default 512
+     */
+    memoryLimitMiB?: number;
+    /**
+     * @default 2 weeks
+     */
+    logsRetention?: logs.RetentionDays;
+    /**
+     * @default 15 seconds
+     */
+    deregistrationDelay?: cdk.Duration;
+    /**
+     * @default 8080
+     */
+    containerPort?: number;
+    /**
+     * @default 60 seconds
+     */
+    healthCheckGracePeriod?: cdk.Duration;
+    /**
+     * Use this as workaround when adding the service to a load balancer after
+     * it has been created. For avoiding 'Health check grace period is only valid for services configured to use load balancers'
+     * Link to GitHub issue: https://github.com/aws/aws-cdk/issues/19842
+     */
+    skipHealthCheckGracePeriod?: boolean;
+    parameters?: Parameter[];
+    overrideFargateServiceProps?: Partial<ecs.FargateServiceProps>;
+    overrideHealthCheck?: Partial<elb.HealthCheck>;
+    overrideTargetGroupProps?: Partial<elb.ApplicationTargetGroupProps>;
+    overrideContainerProps?: Partial<ecs.ContainerDefinitionOptions>;
+    secrets?: Record<string, ecs.Secret>;
+    environment?: Record<string, string>;
+    /**
+     * @default false
+     */
+    skipTargetGroup?: boolean;
+}
+export declare class FargateService extends constructs.Construct {
+    readonly fargateService: ecs.FargateService;
+    readonly securityGroup: ec2.SecurityGroup;
+    readonly taskDefinition: ecs.TaskDefinition;
+    readonly targetGroup: elb.ApplicationTargetGroup | undefined;
+    readonly logGroup: logs.LogGroup;
+    constructor(scope: constructs.Construct, id: string, props: FargateServiceProps);
+}

package/lib/ecs/fargate-service.js

@@ -0,0 +1,98 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FargateService = void 0;
+const cdk = require("aws-cdk-lib");
+const aws_cdk_lib_1 = require("aws-cdk-lib");
+const ec2 = require("aws-cdk-lib/aws-ec2");
+const ecs = require("aws-cdk-lib/aws-ecs");
+const elb = require("aws-cdk-lib/aws-elasticloadbalancingv2");
+const logs = require("aws-cdk-lib/aws-logs");
+const constructs = require("constructs");
+const configure_parameters_1 = require("../configure-parameters");
+class FargateService extends constructs.Construct {
+    constructor(scope, id, props) {
+        var _a, _b, _c, _d, _e, _f, _g;
+        super(scope, id);
+        const parameters = new configure_parameters_1.ConfigureParameters(this, {
+            ssmPrefix: `/liflig-cdk/${cdk.Stack.of(this).stackName}/${this.node.addr}/parameters`,
+            parameters: (_a = props.parameters) !== null && _a !== void 0 ? _a : [],
+        });
+        this.logGroup = new logs.LogGroup(this, "LogGroup", {
+            retention: (_b = props.logsRetention) !== null && _b !== void 0 ? _b : logs.RetentionDays.TWO_WEEKS,
+        });
+        this.securityGroup = new ec2.SecurityGroup(this, "SecurityGroup", {
+            vpc: props.vpc,
+        });
+        this.taskDefinition = new ecs.FargateTaskDefinition(this, "TaskDefinition", {
+            cpu: (_c = props.cpu) !== null && _c !== void 0 ? _c : 256,
+            memoryLimitMiB: (_d = props.memoryLimitMiB) !== null && _d !== void 0 ? _d : 512,
+        });
+        parameters.grantRead(this.taskDefinition.taskRole);
+        const container = this.taskDefinition.addContainer("Container", {
+            logging: ecs.LogDriver.awsLogs({
+                logGroup: this.logGroup,
+                streamPrefix: "ecs",
+                datetimeFormat: "%Y-%m-%dT%H:%M:%S",
+            }),
+            image: props.ecsImage,
+            secrets: props.secrets,
+            environment: {
+                SSM_PREFIX: parameters.ssmPrefix,
+                // Not read by the application, only used to help with redeployments.
+                PARAMS_HASH: parameters.hashValue,
+                ...((_e = props.environment) !== null && _e !== void 0 ? _e : {}),
+            },
+            linuxParameters: new ecs.LinuxParameters(this, "LinuxParameters", {
+                initProcessEnabled: true,
+            }),
+            ...props.overrideContainerProps,
+        });
+        const port = (_f = props.containerPort) !== null && _f !== void 0 ? _f : 8080;
+        container.addPortMappings({
+            containerPort: port,
+            hostPort: port,
+        });
+        this.fargateService = new ecs.FargateService(this, "Service", {
+            serviceName: props.serviceName,
+            vpcSubnets: {
+                subnetType: ec2.SubnetType.PUBLIC,
+            },
+            taskDefinition: this.taskDefinition,
+            cluster: props.cluster,
+            minHealthyPercent: 100,
+            healthCheckGracePeriod: props.healthCheckGracePeriod,
+            desiredCount: props.desiredCount,
+            assignPublicIp: true,
+            securityGroups: [this.securityGroup],
+            platformVersion: ecs.FargatePlatformVersion.VERSION1_4,
+            enableExecuteCommand: true,
+            ...props.overrideFargateServiceProps,
+        });
+        if (props.skipHealthCheckGracePeriod) {
+            ;
+            this.fargateService.node.defaultChild.healthCheckGracePeriodSeconds = undefined;
+        }
+        for (const param of parameters.parameters) {
+            this.fargateService.node.addDependency(param);
+        }
+        if (!props.skipTargetGroup) {
+            this.targetGroup = new elb.ApplicationTargetGroup(this, "TargetGroup", {
+                protocol: elb.ApplicationProtocol.HTTP,
+                port: port,
+                vpc: props.vpc,
+                targetType: elb.TargetType.IP,
+                targets: [this.fargateService],
+                deregistrationDelay: (_g = props.deregistrationDelay) !== null && _g !== void 0 ? _g : cdk.Duration.seconds(15),
+                ...props.overrideTargetGroupProps,
+            });
+            this.targetGroup.configureHealthCheck({
+                interval: aws_cdk_lib_1.Duration.seconds(10),
+                path: "/health",
+                healthyThresholdCount: 2,
+                ...props.overrideHealthCheck,
+            });
+        }
+    }
+}
+exports.FargateService = FargateService;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"fargate-service.js","sourceRoot":"","sources":["../../src/ecs/fargate-service.ts"],"names":[],"mappings":"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","sourcesContent":["import * as cdk from \"aws-cdk-lib\"\nimport { Duration } from \"aws-cdk-lib\"\nimport * as ec2 from \"aws-cdk-lib/aws-ec2\"\nimport * as ecs from \"aws-cdk-lib/aws-ecs\"\nimport { CfnService } from \"aws-cdk-lib/aws-ecs\"\nimport * as elb from \"aws-cdk-lib/aws-elasticloadbalancingv2\"\nimport * as logs from \"aws-cdk-lib/aws-logs\"\nimport * as constructs from \"constructs\"\nimport { ConfigureParameters } from \"../configure-parameters\"\nimport { Parameter } from \"../configure-parameters/configure-parameters\"\n\nexport interface FargateServiceProps {\n  serviceName: string\n  vpc: ec2.IVpc\n  cluster: ecs.ICluster\n  desiredCount: number\n  ecsImage: ecs.ContainerImage\n  /**\n   * @default 256\n   */\n  cpu?: number\n  /**\n   * @default 512\n   */\n  memoryLimitMiB?: number\n  /**\n   * @default 2 weeks\n   */\n  logsRetention?: logs.RetentionDays\n  /**\n   * @default 15 seconds\n   */\n  deregistrationDelay?: cdk.Duration\n  /**\n   * @default 8080\n   */\n  containerPort?: number\n  /**\n   * @default 60 seconds\n   */\n  healthCheckGracePeriod?: cdk.Duration\n  /**\n   * Use this as workaround when adding the service to a load balancer after\n   * it has been created. For avoiding 'Health check grace period is only valid for services configured to use load balancers'\n   * Link to GitHub issue: https://github.com/aws/aws-cdk/issues/19842\n   */\n  skipHealthCheckGracePeriod?: boolean\n  parameters?: Parameter[]\n  overrideFargateServiceProps?: Partial<ecs.FargateServiceProps>\n  overrideHealthCheck?: Partial<elb.HealthCheck>\n  overrideTargetGroupProps?: Partial<elb.ApplicationTargetGroupProps>\n  overrideContainerProps?: Partial<ecs.ContainerDefinitionOptions>\n  secrets?: Record<string, ecs.Secret>\n  environment?: Record<string, string>\n  /**\n   * @default false\n   */\n  skipTargetGroup?: boolean\n}\n\nexport class FargateService extends constructs.Construct {\n  public readonly fargateService: ecs.FargateService\n  public readonly securityGroup: ec2.SecurityGroup\n  public readonly taskDefinition: ecs.TaskDefinition\n  public readonly targetGroup: elb.ApplicationTargetGroup | undefined\n  public readonly logGroup: logs.LogGroup\n\n  constructor(\n    scope: constructs.Construct,\n    id: string,\n    props: FargateServiceProps,\n  ) {\n    super(scope, id)\n\n    const parameters = new ConfigureParameters(this, {\n      ssmPrefix: `/liflig-cdk/${cdk.Stack.of(this).stackName}/${\n        this.node.addr\n      }/parameters`,\n      parameters: props.parameters ?? [],\n    })\n\n    this.logGroup = new logs.LogGroup(this, \"LogGroup\", {\n      retention: props.logsRetention ?? logs.RetentionDays.TWO_WEEKS,\n    })\n\n    this.securityGroup = new ec2.SecurityGroup(this, \"SecurityGroup\", {\n      vpc: props.vpc,\n    })\n\n    this.taskDefinition = new ecs.FargateTaskDefinition(\n      this,\n      \"TaskDefinition\",\n      {\n        cpu: props.cpu ?? 256,\n        memoryLimitMiB: props.memoryLimitMiB ?? 512,\n      },\n    )\n\n    parameters.grantRead(this.taskDefinition.taskRole)\n\n    const container = this.taskDefinition.addContainer(\"Container\", {\n      logging: ecs.LogDriver.awsLogs({\n        logGroup: this.logGroup,\n        streamPrefix: \"ecs\",\n        datetimeFormat: \"%Y-%m-%dT%H:%M:%S\",\n      }),\n      image: props.ecsImage,\n      secrets: props.secrets,\n      environment: {\n        SSM_PREFIX: parameters.ssmPrefix,\n        // Not read by the application, only used to help with redeployments.\n        PARAMS_HASH: parameters.hashValue,\n        ...(props.environment ?? {}),\n      },\n      linuxParameters: new ecs.LinuxParameters(this, \"LinuxParameters\", {\n        initProcessEnabled: true,\n      }),\n      ...props.overrideContainerProps,\n    })\n\n    const port = props.containerPort ?? 8080\n\n    container.addPortMappings({\n      containerPort: port,\n      hostPort: port,\n    })\n\n    this.fargateService = new ecs.FargateService(this, \"Service\", {\n      serviceName: props.serviceName,\n      vpcSubnets: {\n        subnetType: ec2.SubnetType.PUBLIC,\n      },\n      taskDefinition: this.taskDefinition,\n      cluster: props.cluster,\n      minHealthyPercent: 100,\n      healthCheckGracePeriod: props.healthCheckGracePeriod,\n      desiredCount: props.desiredCount,\n      assignPublicIp: true,\n      securityGroups: [this.securityGroup],\n      platformVersion: ecs.FargatePlatformVersion.VERSION1_4,\n      enableExecuteCommand: true,\n      ...props.overrideFargateServiceProps,\n    })\n\n    if (props.skipHealthCheckGracePeriod) {\n      ;(\n        this.fargateService.node.defaultChild as CfnService\n      ).healthCheckGracePeriodSeconds = undefined\n    }\n\n    for (const param of parameters.parameters) {\n      this.fargateService.node.addDependency(param)\n    }\n\n    if (!props.skipTargetGroup) {\n      this.targetGroup = new elb.ApplicationTargetGroup(this, \"TargetGroup\", {\n        protocol: elb.ApplicationProtocol.HTTP,\n        port: port,\n        vpc: props.vpc,\n        targetType: elb.TargetType.IP,\n        targets: [this.fargateService],\n        deregistrationDelay:\n          props.deregistrationDelay ?? cdk.Duration.seconds(15),\n        ...props.overrideTargetGroupProps,\n      })\n\n      this.targetGroup.configureHealthCheck({\n        interval: Duration.seconds(10),\n        path: \"/health\",\n        healthyThresholdCount: 2,\n        ...props.overrideHealthCheck,\n      })\n    }\n  }\n}\n"]}

package/lib/ecs/index.d.ts

@@ -0,0 +1,3 @@
+export { Cluster, ClusterProps } from "./cluster";
+export { FargateService, FargateServiceProps } from "./fargate-service";
+export { ListenerRule, ListenerRuleProps } from "./listener-rule";

package/lib/ecs/index.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ListenerRule = exports.FargateService = exports.Cluster = void 0;
+var cluster_1 = require("./cluster");
+Object.defineProperty(exports, "Cluster", { enumerable: true, get: function () { return cluster_1.Cluster; } });
+var fargate_service_1 = require("./fargate-service");
+Object.defineProperty(exports, "FargateService", { enumerable: true, get: function () { return fargate_service_1.FargateService; } });
+var listener_rule_1 = require("./listener-rule");
+Object.defineProperty(exports, "ListenerRule", { enumerable: true, get: function () { return listener_rule_1.ListenerRule; } });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvZWNzL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7OztBQUFBLHFDQUFpRDtBQUF4QyxrR0FBQSxPQUFPLE9BQUE7QUFDaEIscURBQXVFO0FBQTlELGlIQUFBLGNBQWMsT0FBQTtBQUN2QixpREFBaUU7QUFBeEQsNkdBQUEsWUFBWSxPQUFBIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0IHsgQ2x1c3RlciwgQ2x1c3RlclByb3BzIH0gZnJvbSBcIi4vY2x1c3RlclwiXG5leHBvcnQgeyBGYXJnYXRlU2VydmljZSwgRmFyZ2F0ZVNlcnZpY2VQcm9wcyB9IGZyb20gXCIuL2ZhcmdhdGUtc2VydmljZVwiXG5leHBvcnQgeyBMaXN0ZW5lclJ1bGUsIExpc3RlbmVyUnVsZVByb3BzIH0gZnJvbSBcIi4vbGlzdGVuZXItcnVsZVwiXG4iXX0=

package/lib/ecs/listener-rule.d.ts

@@ -0,0 +1,25 @@
+import * as constructs from "constructs";
+import * as elb from "aws-cdk-lib/aws-elasticloadbalancingv2";
+import * as route53 from "aws-cdk-lib/aws-route53";
+export interface ListenerRuleProps {
+    httpsListener: elb.IApplicationListener;
+    loadBalancer: elb.IApplicationLoadBalancer;
+    domainName: string;
+    listenerPriority: number;
+    targetGroup: elb.IApplicationTargetGroup;
+    /**
+     * If 'hostedZone' is an A record for 'domainName' is created with
+     * the 'loadBalancer' as target
+     */
+    hostedZone?: route53.IHostedZone;
+}
+export declare class ListenerRule extends constructs.Construct {
+    /**
+     * The rule created in the ALB Listener.
+     *
+     * Use {@link elb.ApplicationListenerRule.addCondition} to add [other conditions](https://docs.aws.amazon.com/elasticloadbalancing/latest/application/load-balancer-listeners.html#rule-condition-types)
+     * than Host-header.
+     */
+    readonly applicationListenerRule: elb.ApplicationListenerRule;
+    constructor(scope: constructs.Construct, id: string, props: ListenerRuleProps);
+}

package/lib/ecs/listener-rule.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ListenerRule = void 0;
+const constructs = require("constructs");
+const elb = require("aws-cdk-lib/aws-elasticloadbalancingv2");
+const route53 = require("aws-cdk-lib/aws-route53");
+const route53Targets = require("aws-cdk-lib/aws-route53-targets");
+class ListenerRule extends constructs.Construct {
+    constructor(scope, id, props) {
+        super(scope, id);
+        this.applicationListenerRule = new elb.ApplicationListenerRule(this, "ListenerRule", {
+            listener: props.httpsListener,
+            priority: props.listenerPriority,
+            conditions: [elb.ListenerCondition.hostHeaders([props.domainName])],
+            targetGroups: [props.targetGroup],
+        });
+        if (props.hostedZone != null) {
+            new route53.ARecord(this, "ARecord", {
+                zone: props.hostedZone,
+                recordName: `${props.domainName}.`,
+                target: route53.RecordTarget.fromAlias(new route53Targets.LoadBalancerTarget(props.loadBalancer)),
+            });
+        }
+    }
+}
+exports.ListenerRule = ListenerRule;
+//# sourceMappingURL=data:application/json;base64,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

package/lib/ecs-update-image/artifact-status.d.ts

@@ -0,0 +1,39 @@
+interface Props {
+    artifactPushedAndTagUpdated: boolean;
+}
+/**
+ * The responsibility of this class is to be a Value Object to cause
+ * more consistent usage and the importance of an artifact being published.
+ *
+ * Due to the way we build and deploy ECS services, the ECR image will
+ * not be available during the first initial account/service deployment.
+ *
+ * This causes the following sequence:
+ *
+ * 1. The ECR repository must be provisioned.
+ *
+ * 2. The tag container must be provisioned in every target account.
+ *    Before we can provision the ECS service this must be updated
+ *    to reference an existing artifact.
+ *
+ * 3. The build system must produce and upload an artifact.
+ *
+ * 4. The tag container must be updated in every target account
+ *    to contain the newly built image. This is easiest done by also
+ *    provisioning the ECS update image construct as part of step 2,
+ *    without including service and task definition details (which
+ *    does not exist yet before we can resolve the ECR image).
+ *    When the ECS update image construct is provisioned the deployment
+ *    pipeline can start a deployment, which under this state will
+ *    only store the updated tag but cause no ECS service update.
+ *
+ * 5. The ECS service can be provisioned, which will use the image
+ *    reference in the tag container as the first deployment.
+ *
+ * 6. The next time a deploy is started, the ECS service will be updated.
+ */
+export declare class EcsUpdateImageArtifactStatus {
+    readonly artifactPushedAndTagUpdated: boolean;
+    constructor(props: Props);
+}
+export {};

package/lib/ecs-update-image/artifact-status.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EcsUpdateImageArtifactStatus = void 0;
+/**
+ * The responsibility of this class is to be a Value Object to cause
+ * more consistent usage and the importance of an artifact being published.
+ *
+ * Due to the way we build and deploy ECS services, the ECR image will
+ * not be available during the first initial account/service deployment.
+ *
+ * This causes the following sequence:
+ *
+ * 1. The ECR repository must be provisioned.
+ *
+ * 2. The tag container must be provisioned in every target account.
+ *    Before we can provision the ECS service this must be updated
+ *    to reference an existing artifact.
+ *
+ * 3. The build system must produce and upload an artifact.
+ *
+ * 4. The tag container must be updated in every target account
+ *    to contain the newly built image. This is easiest done by also
+ *    provisioning the ECS update image construct as part of step 2,
+ *    without including service and task definition details (which
+ *    does not exist yet before we can resolve the ECR image).
+ *    When the ECS update image construct is provisioned the deployment
+ *    pipeline can start a deployment, which under this state will
+ *    only store the updated tag but cause no ECS service update.
+ *
+ * 5. The ECS service can be provisioned, which will use the image
+ *    reference in the tag container as the first deployment.
+ *
+ * 6. The next time a deploy is started, the ECS service will be updated.
+ */
+class EcsUpdateImageArtifactStatus {
+    constructor(props) {
+        this.artifactPushedAndTagUpdated = props.artifactPushedAndTagUpdated;
+    }
+}
+exports.EcsUpdateImageArtifactStatus = EcsUpdateImageArtifactStatus;
+//# sourceMappingURL=data:application/json;base64,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

package/lib/ecs-update-image/ecs-update-image.d.ts

@@ -0,0 +1,41 @@
+import * as constructs from "constructs";
+import * as ecr from "aws-cdk-lib/aws-ecr";
+import * as ecs from "aws-cdk-lib/aws-ecs";
+import * as iam from "aws-cdk-lib/aws-iam";
+import { EcsUpdateImageTag } from "./tag";
+interface Props {
+    cluster: ecs.ICluster;
+    service?: ecs.IService;
+    taskRole?: iam.IRole;
+    executionRole?: iam.IRole;
+    /**
+     * The role that will be granted permission to assume the deploy
+     * role. This role must have permission to assume the deploy role.
+     */
+    callerRoleArn: string;
+    /**
+     * The name that will be used for the deploy role. This is the role
+     * that the caller will assume in order to have permission to invoke
+     * the Lambda Functions.
+     */
+    roleName: string;
+    startDeployFunctionName: string;
+    statusFunctionName: string;
+    tagContainer: EcsUpdateImageTag;
+    ecrRepository: ecr.IRepository;
+}
+/**
+ * Dynamically update image of an ECS Service outside CDK.
+ *
+ * This construct sets up a Lambda Function that can be invoked
+ * from the CD pipeline to update the ECS Service to a new image.
+ *
+ * To keep resources in sync, a Secret is used to keep track of
+ * the current image, which is dynamically resolved in the CloudFormation
+ * templates to avoid infrastructure changes to cause an older/different
+ * image to be used.
+ */
+export declare class EcsUpdateImage extends constructs.Construct {
+    constructor(scope: constructs.Construct, id: string, props: Props);
+}
+export {};

package/lib/ecs-update-image/ecs-update-image.js

@@ -0,0 +1,98 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EcsUpdateImage = void 0;
+const constructs = require("constructs");
+const iam = require("aws-cdk-lib/aws-iam");
+const lambda = require("aws-cdk-lib/aws-lambda");
+const cdk = require("aws-cdk-lib");
+const start_deploy_handler_1 = require("./start-deploy-handler");
+const status_handler_1 = require("./status-handler");
+/**
+ * Dynamically update image of an ECS Service outside CDK.
+ *
+ * This construct sets up a Lambda Function that can be invoked
+ * from the CD pipeline to update the ECS Service to a new image.
+ *
+ * To keep resources in sync, a Secret is used to keep track of
+ * the current image, which is dynamically resolved in the CloudFormation
+ * templates to avoid infrastructure changes to cause an older/different
+ * image to be used.
+ */
+class EcsUpdateImage extends constructs.Construct {
+    constructor(scope, id, props) {
+        super(scope, id);
+        const account = cdk.Stack.of(this).account;
+        const region = cdk.Stack.of(this).region;
+        const roleToBeAssumed = new iam.Role(this, "Role", {
+            roleName: props.roleName,
+            assumedBy: new iam.ArnPrincipal(props.callerRoleArn),
+        });
+        const startDeployFn = new lambda.Function(this, "StartDeployFunction", {
+            functionName: props.startDeployFunctionName,
+            code: new lambda.InlineCode(`exports.handler = ${start_deploy_handler_1.startDeployHandler.toString()};`),
+            runtime: lambda.Runtime.NODEJS_16_X,
+            handler: "index.handler",
+            timeout: cdk.Duration.seconds(60),
+            environment: {
+                CLUSTER_NAME: props.cluster.clusterName,
+                SERVICE_NAME: props.service == null ? "" : props.service.serviceName,
+                REPOSITORY_URL: props.ecrRepository.repositoryUri,
+                ECR_TAG_SECRET_ARN: props.tagContainer.secretArn,
+            },
+            reservedConcurrentExecutions: 1,
+        });
+        startDeployFn.grantInvoke(roleToBeAssumed);
+        props.tagContainer.grantUpdate(startDeployFn);
+        if (props.service != null) {
+            startDeployFn.addToRolePolicy(new iam.PolicyStatement({
+                actions: [
+                    "ecs:DeregisterTaskDefinition",
+                    "ecs:DescribeServices",
+                    "ecs:DescribeTaskDefinition",
+                    "ecs:DescribeTasks",
+                    "ecs:ListTasks",
+                    "ecs:ListTaskDefinitions",
+                    "ecs:RegisterTaskDefinition",
+                ],
+                resources: ["*"],
+            }));
+            startDeployFn.addToRolePolicy(new iam.PolicyStatement({
+                actions: ["ecs:UpdateService"],
+                resources: [
+                    `arn:aws:ecs:${region}:${account}:service/${props.cluster.clusterName}/${props.service.serviceName}`,
+                ],
+            }));
+        }
+        if (props.taskRole != null) {
+            props.taskRole.grantPassRole(startDeployFn.role);
+        }
+        if (props.executionRole != null) {
+            props.executionRole.grantPassRole(startDeployFn.role);
+        }
+        const statusFn = new lambda.Function(this, "StatusFunction", {
+            functionName: props.statusFunctionName,
+            code: new lambda.InlineCode(`exports.handler = ${status_handler_1.statusHandler.toString()};`),
+            runtime: lambda.Runtime.NODEJS_16_X,
+            handler: "index.handler",
+            timeout: cdk.Duration.seconds(60),
+            environment: {
+                CLUSTER_NAME: props.cluster.clusterName,
+                SERVICE_NAME: props.service == null ? "" : props.service.serviceName,
+            },
+        });
+        statusFn.grantInvoke(roleToBeAssumed);
+        statusFn.addToRolePolicy(new iam.PolicyStatement({
+            actions: [
+                "ecs:DeregisterTaskDefinition",
+                "ecs:DescribeServices",
+                "ecs:DescribeTaskDefinition",
+                "ecs:DescribeTasks",
+                "ecs:ListTasks",
+                "ecs:ListTaskDefinitions",
+            ],
+            resources: ["*"],
+        }));
+    }
+}
+exports.EcsUpdateImage = EcsUpdateImage;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"ecs-update-image.js","sourceRoot":"","sources":["../../src/ecs-update-image/ecs-update-image.ts"],"names":[],"mappings":"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","sourcesContent":["import * as constructs from \"constructs\"\nimport * as ecr from \"aws-cdk-lib/aws-ecr\"\nimport * as ecs from \"aws-cdk-lib/aws-ecs\"\nimport * as iam from \"aws-cdk-lib/aws-iam\"\nimport * as lambda from \"aws-cdk-lib/aws-lambda\"\nimport * as cdk from \"aws-cdk-lib\"\nimport { startDeployHandler } from \"./start-deploy-handler\"\nimport { statusHandler } from \"./status-handler\"\nimport { EcsUpdateImageTag } from \"./tag\"\n\ninterface Props {\n  cluster: ecs.ICluster\n  service?: ecs.IService\n  taskRole?: iam.IRole\n  executionRole?: iam.IRole\n  /**\n   * The role that will be granted permission to assume the deploy\n   * role. This role must have permission to assume the deploy role.\n   */\n  callerRoleArn: string\n  /**\n   * The name that will be used for the deploy role. This is the role\n   * that the caller will assume in order to have permission to invoke\n   * the Lambda Functions.\n   */\n  roleName: string\n  startDeployFunctionName: string\n  statusFunctionName: string\n  tagContainer: EcsUpdateImageTag\n  ecrRepository: ecr.IRepository\n}\n\n/**\n * Dynamically update image of an ECS Service outside CDK.\n *\n * This construct sets up a Lambda Function that can be invoked\n * from the CD pipeline to update the ECS Service to a new image.\n *\n * To keep resources in sync, a Secret is used to keep track of\n * the current image, which is dynamically resolved in the CloudFormation\n * templates to avoid infrastructure changes to cause an older/different\n * image to be used.\n */\nexport class EcsUpdateImage extends constructs.Construct {\n  constructor(scope: constructs.Construct, id: string, props: Props) {\n    super(scope, id)\n\n    const account = cdk.Stack.of(this).account\n    const region = cdk.Stack.of(this).region\n\n    const roleToBeAssumed = new iam.Role(this, \"Role\", {\n      roleName: props.roleName,\n      assumedBy: new iam.ArnPrincipal(props.callerRoleArn),\n    })\n\n    const startDeployFn = new lambda.Function(this, \"StartDeployFunction\", {\n      functionName: props.startDeployFunctionName,\n      code: new lambda.InlineCode(\n        `exports.handler = ${startDeployHandler.toString()};`,\n      ),\n      runtime: lambda.Runtime.NODEJS_16_X,\n      handler: \"index.handler\",\n      timeout: cdk.Duration.seconds(60),\n      environment: {\n        CLUSTER_NAME: props.cluster.clusterName,\n        SERVICE_NAME: props.service == null ? \"\" : props.service.serviceName,\n        REPOSITORY_URL: props.ecrRepository.repositoryUri,\n        ECR_TAG_SECRET_ARN: props.tagContainer.secretArn,\n      },\n      reservedConcurrentExecutions: 1,\n    })\n\n    startDeployFn.grantInvoke(roleToBeAssumed)\n    props.tagContainer.grantUpdate(startDeployFn)\n\n    if (props.service != null) {\n      startDeployFn.addToRolePolicy(\n        new iam.PolicyStatement({\n          actions: [\n            \"ecs:DeregisterTaskDefinition\",\n            \"ecs:DescribeServices\",\n            \"ecs:DescribeTaskDefinition\",\n            \"ecs:DescribeTasks\",\n            \"ecs:ListTasks\",\n            \"ecs:ListTaskDefinitions\",\n            \"ecs:RegisterTaskDefinition\",\n          ],\n          resources: [\"*\"],\n        }),\n      )\n\n      startDeployFn.addToRolePolicy(\n        new iam.PolicyStatement({\n          actions: [\"ecs:UpdateService\"],\n          resources: [\n            `arn:aws:ecs:${region}:${account}:service/${props.cluster.clusterName}/${props.service.serviceName}`,\n          ],\n        }),\n      )\n    }\n\n    if (props.taskRole != null) {\n      props.taskRole.grantPassRole(startDeployFn.role!)\n    }\n\n    if (props.executionRole != null) {\n      props.executionRole.grantPassRole(startDeployFn.role!)\n    }\n\n    const statusFn = new lambda.Function(this, \"StatusFunction\", {\n      functionName: props.statusFunctionName,\n      code: new lambda.InlineCode(\n        `exports.handler = ${statusHandler.toString()};`,\n      ),\n      runtime: lambda.Runtime.NODEJS_16_X,\n      handler: \"index.handler\",\n      timeout: cdk.Duration.seconds(60),\n      environment: {\n        CLUSTER_NAME: props.cluster.clusterName,\n        SERVICE_NAME: props.service == null ? \"\" : props.service.serviceName,\n      },\n    })\n\n    statusFn.grantInvoke(roleToBeAssumed)\n\n    statusFn.addToRolePolicy(\n      new iam.PolicyStatement({\n        actions: [\n          \"ecs:DeregisterTaskDefinition\",\n          \"ecs:DescribeServices\",\n          \"ecs:DescribeTaskDefinition\",\n          \"ecs:DescribeTasks\",\n          \"ecs:ListTasks\",\n          \"ecs:ListTaskDefinitions\",\n        ],\n        resources: [\"*\"],\n      }),\n    )\n  }\n}\n"]}

package/lib/ecs-update-image/index.d.ts

@@ -0,0 +1,3 @@
+export { EcsUpdateImageArtifactStatus } from "./artifact-status";
+export { EcsUpdateImage } from "./ecs-update-image";
+export { EcsUpdateImageTag } from "./tag";

package/lib/ecs-update-image/index.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EcsUpdateImageTag = exports.EcsUpdateImage = exports.EcsUpdateImageArtifactStatus = void 0;
+var artifact_status_1 = require("./artifact-status");
+Object.defineProperty(exports, "EcsUpdateImageArtifactStatus", { enumerable: true, get: function () { return artifact_status_1.EcsUpdateImageArtifactStatus; } });
+var ecs_update_image_1 = require("./ecs-update-image");
+Object.defineProperty(exports, "EcsUpdateImage", { enumerable: true, get: function () { return ecs_update_image_1.EcsUpdateImage; } });
+var tag_1 = require("./tag");
+Object.defineProperty(exports, "EcsUpdateImageTag", { enumerable: true, get: function () { return tag_1.EcsUpdateImageTag; } });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvZWNzLXVwZGF0ZS1pbWFnZS9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7QUFBQSxxREFBZ0U7QUFBdkQsK0hBQUEsNEJBQTRCLE9BQUE7QUFDckMsdURBQW1EO0FBQTFDLGtIQUFBLGNBQWMsT0FBQTtBQUN2Qiw2QkFBeUM7QUFBaEMsd0dBQUEsaUJBQWlCLE9BQUEiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgeyBFY3NVcGRhdGVJbWFnZUFydGlmYWN0U3RhdHVzIH0gZnJvbSBcIi4vYXJ0aWZhY3Qtc3RhdHVzXCJcbmV4cG9ydCB7IEVjc1VwZGF0ZUltYWdlIH0gZnJvbSBcIi4vZWNzLXVwZGF0ZS1pbWFnZVwiXG5leHBvcnQgeyBFY3NVcGRhdGVJbWFnZVRhZyB9IGZyb20gXCIuL3RhZ1wiXG4iXX0=

package/lib/ecs-update-image/start-deploy-handler.d.ts

@@ -0,0 +1,6 @@
+import type { Handler } from "aws-lambda";
+interface ExpectedInput {
+    tag: string;
+}
+export declare const startDeployHandler: Handler<Partial<ExpectedInput>>;
+export {};