@liflig/cdk 1.48.1 → 1.51.0

package/assets/cloudtrail-slack-integration-lambda/main.py

@@ -0,0 +1,249 @@
+#!/usr/bin/env python
+
+"""
+Transform CloudTrail events to payloads formatted for Slack's API, and send them
+directly to Slack or through an SQS FIFO queue for deduplication.
+
+The code below contains entrypoints for two Lambda functions (prefixed with `handler_`).
+"""
+
+import os
+import logging
+import json
+import urllib.request
+import boto3
+
+logger = logging.getLogger()
+logger.setLevel(logging.INFO)
+
+
+def get_slack_payload_for_assume_role_event(event, account_friendly_names):
+    """Parse a CloudTrail event related to the API call sts:AssumeRole,
+    and return a Slack-formatted attachment"""
+    event_account_id = event["account"]
+    event_detail = event["detail"]
+    request_parameters = event_detail.get("requestParameters", {}) or {}
+
+    timestamp = event_detail["eventTime"]
+    user_identity = event_detail["userIdentity"]
+    principal_id = user_identity["principalId"]
+    principal_account_id = user_identity["accountId"]
+    source_identity = request_parameters.get("sourceIdentity", "")
+    source_ip = event_detail.get("sourceIPAddress", "")
+    role_arn = request_parameters.get("roleArn", "")
+
+    fallback = f"Sensitive role accessed in '{event_account_id}'"
+    pretext_messages = [f":warning: Sensitive role in `{event_account_id}` assumed by"]
+    if principal_id.startswith("AIDA"):
+        pretext_messages.append("IAM user")
+    elif principal_id.startswith("AROA"):
+        pretext_messages.append("IAM role")
+    else:
+        pretext_messages.append("principal")
+    pretext_messages.append(f"in `{principal_account_id}`")
+    pretext = " ".join(pretext_messages)
+
+    text = [
+        f"*Role ARN:* `{role_arn}`",
+        f"*Principal Account ID:* `{principal_account_id}`",
+        f"*Principal ID:* `{principal_id}`",
+        f"*Source IP:* `{source_ip}`",
+        f"*Source Identity:* `{source_identity}`" if source_identity else "",
+        f"*Timestamp:* `{timestamp}`",
+    ]
+    text = "\n".join(line for line in text if line)
+    for account_id, friendly_name in account_friendly_names.items():
+        pretext = pretext.replace(account_id, friendly_name)
+        fallback = fallback.replace(account_id, friendly_name)
+    return {
+        "attachments": [
+            {
+                "pretext": pretext,
+                "color": "warning",
+                "text": text,
+                "fallback": fallback,
+                "mrkdwn_in": ["pretext", "text"],
+            }
+        ]
+    }
+
+
+def get_fallback_slack_payload_for_event(
+    event, account_friendly_names, fallback_parse_behavior=""
+):
+    """Parse a generic CloudTrail event related to an API call
+    and return a Slack-formatted attachment"""
+    event_account_id = event["account"]
+    event_detail = event["detail"]
+    event_name = event_detail["eventName"]
+    event_type = event_detail["eventType"]
+    event_time = event_detail["eventTime"]
+    pretext = f":warning: CloudTrail event in account `{event_account_id}`"
+    fallback = f"CloudTrail event in account '{event_account_id}'"
+    if fallback_parse_behavior == "DUMP_EVENT":
+        text = "\n".join(
+            ["*Event:*", "```", json.dumps(event, sort_keys=True, indent=2), "```"]
+        )
+    else:
+        error_message = event_detail.get("errorMessage", "")
+        # This may be None, in which case we force it to an empty dict instead
+        response_element = (event_detail.get("responseElements", {}) or {}).get(
+            event_name, ""
+        )
+        user_identity = event_detail["userIdentity"]
+        principal_id = user_identity.get("principalId", "")
+        principal_type = user_identity.get("type", "")
+        principal_account_id = user_identity.get("accountId", "")
+        principal_arn = user_identity.get("arn", "")
+        source_ip = event_detail.get("sourceIPAddress", "")
+        resources = event_detail.get("resources", []) or []
+        text = [
+            f"*Event Type:* `{event_type}`",
+            f"*Event Name:* `{event_name}`",
+            f"*Event Time:* `{event_time}`",
+            f"*Error Message:* `{error_message}`" if error_message else "",
+            f"*Response Code:* `{response_element}`" if response_element else "",
+            f"*Principal Type:* `{principal_type}`" if principal_type else "",
+            f"*Principal Account ID:* `{principal_account_id}`"
+            if principal_account_id
+            else "",
+            f"*Principal ARN:* `{principal_arn}`" if principal_arn else "",
+            f"*Principal ID:* `{principal_id}`" if principal_id else "",
+            f"*Source IP:* `{source_ip}`" if source_ip else "",
+            f"*Resources:*\n```{json.dumps(resources, indent=2, sort_keys=True)}\n```"
+            if len(resources)
+            else "",
+        ]
+        # Filter out empty strings
+        text = "\n".join(line for line in text if line)
+
+    for account_id, friendly_name in account_friendly_names.items():
+        pretext = pretext.replace(account_id, friendly_name)
+        fallback = fallback.replace(account_id, friendly_name)
+    return {
+        "attachments": [
+            {
+                "pretext": pretext,
+                "color": "warning",
+                "text": text,
+                "fallback": fallback,
+                "mrkdwn_in": ["pretext", "text"],
+            }
+        ]
+    }
+
+
+def get_augmented_account_friendly_names(event, account_friendly_names):
+    """Return an augmented dictionary containing the alias of the current
+    AWS account if relevant"""
+    augmented_account_friendly_names = {**account_friendly_names}
+    try:
+        event_account_id = event["account"]
+        event_detail = event["detail"]
+        recipient_account_id = event_detail["recipientAccountId"]
+        if (
+            not augmented_account_friendly_names.get(event_account_id, "")
+            and event_account_id == recipient_account_id
+        ):
+            logger.info(
+                "No friendly name was supplied for current account '%s', so looking up account alias",
+                event_account_id,
+            )
+            iam = boto3.client("iam")
+            aliases = iam.list_account_aliases()["AccountAliases"]
+            if len(aliases):
+                augmented_account_friendly_names[event_account_id] = aliases[0]
+    except:
+        logger.exception("Failed to look up alias of current AWS account")
+
+    return augmented_account_friendly_names
+
+
+def post_to_slack(slack_payload, slack_webhook_url):
+    """Post a payload to Slack's webhook API"""
+    encoded_slack_payload = json.dumps(slack_payload).encode("utf-8")
+    try:
+        slack_request = urllib.request.Request(
+            slack_webhook_url,
+            data=encoded_slack_payload,
+            headers={"Content-Type": "application/json"},
+        )
+        urllib.request.urlopen(slack_request)
+    except:
+        logger.exception("Failed to post to Slack")
+        raise
+
+
+def handler_event_transformer(event, context):
+    """Lambda handler for the event transformer Lambda"""
+    logger.info("Triggered with event: %s", json.dumps(event, indent=2))
+
+    account_friendly_names = json.loads(os.environ["ACCOUNT_FRIENDLY_NAMES"])
+    slack_webhook_url = os.environ["SLACK_WEBHOOK_URL"]
+    slack_channel = os.environ["SLACK_CHANNEL"]
+    sqs_queue_url = os.environ.get("SQS_QUEUE_URL", "")
+    fallback_parse_behavior = os.environ.get("FALLBACK_PARSE_BEHAVIOR", "")
+    deduplicate_events = os.environ.get("DEDUPLICATE_EVENTS", "false") == "true"
+
+    account_friendly_names = get_augmented_account_friendly_names(
+        event, account_friendly_names
+    )
+
+    if not event["detail-type"].endswith("via CloudTrail"):
+        logger.warn("Invalid event received")
+        return
+
+    slack_payload = {}
+    try:
+        if event["detail"]["eventName"] == "AssumeRole":
+            slack_payload = get_slack_payload_for_assume_role_event(
+                event, account_friendly_names
+            )
+    except:
+        logger.exception("Failed to parse event using predefined schema")
+    if not slack_payload:
+        logger.warn("Using a fallback schema to parse event")
+        slack_payload = get_fallback_slack_payload_for_event(
+            event,
+            account_friendly_names,
+            fallback_parse_behavior=fallback_parse_behavior,
+        )
+    slack_payload = {**slack_payload, "channel": slack_channel}
+
+    if deduplicate_events and sqs_queue_url:
+        logger.info("Sending message to SQS for deduplication")
+        deduplication_id = (
+            event["detail"].get("requestID", "")
+            or event["detail"].get("eventID", "")
+            or event["id"]
+        )
+        body = {
+            "slackWebhookUrl": slack_webhook_url,
+            "slackPayload": slack_payload,
+        }
+
+        sqs = boto3.client("sqs")
+        sqs.send_message(
+            QueueUrl=sqs_queue_url,
+            MessageBody=json.dumps(body),
+            MessageDeduplicationId=deduplication_id,
+            MessageGroupId=deduplication_id,
+        )
+    else:
+        logger.info("Sending message directly to Slack")
+        post_to_slack(slack_payload, slack_webhook_url)
+
+
+def handler_slack_forwarder(event, context):
+    """Lambda handler for the Slack forwarder Lambda"""
+    logger.info("Triggered with event: %s", json.dumps(event, indent=2))
+    records = event["Records"]
+    for record in records:
+        body = json.loads(record["body"])
+        slack_channel = body.get("slackChannel", "")
+        slack_webhook_url = body.get("slackWebhookUrl", "")
+        slack_payload = {
+            **body["slackPayload"],
+            **({"channel": slack_channel} if slack_channel else {}),
+        }
+        post_to_slack(slack_payload, slack_webhook_url)

package/lib/cdk-deploy/start-deploy-handler.js

@@ -69,4 +69,4 @@ const startDeployHandler = async (event, context) => {
     };
 };
 exports.startDeployHandler = startDeployHandler;
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic3RhcnQtZGVwbG95LWhhbmRsZXIuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvY2RrLWRlcGxveS9zdGFydC1kZXBsb3ktaGFuZGxlci50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7QUFhQSxtREFBbUQ7QUFDbkQsNkJBQTZCO0FBQ3RCLE1BQU0sa0JBQWtCLEdBRTNCLEtBQUssRUFBRSxLQUFLLEVBQUUsT0FBTyxFQUFFLEVBQUU7O0lBQzNCLE1BQU0sR0FBRyxHQUFHLE9BQU8sQ0FBQyxTQUFTLENBQUMsQ0FBQTtJQUU5QixNQUFNLFNBQVMsR0FBRyxJQUFJLEdBQUcsQ0FBQyxTQUFTLEVBQW9CLENBQUE7SUFDdkQsTUFBTSxFQUFFLEdBQUcsSUFBSSxHQUFHLENBQUMsRUFBRSxFQUFhLENBQUE7SUFFbEMsU0FBUyxVQUFVLENBQUMsSUFBWTtRQUM5QixNQUFNLEtBQUssR0FBRyxPQUFPLENBQUMsR0FBRyxDQUFDLElBQUksQ0FBQyxDQUFBO1FBQy9CLElBQUksS0FBSyxLQUFLLFNBQVMsRUFBRTtZQUN2QixNQUFNLElBQUksS0FBSyxDQUFDLFdBQVcsSUFBSSxFQUFFLENBQUMsQ0FBQTtTQUNuQztRQUNELE9BQU8sS0FBSyxDQUFBO0lBQ2QsQ0FBQztJQUVELE1BQU0sV0FBVyxHQUFHLFVBQVUsQ0FBQyxjQUFjLENBQUMsQ0FBQTtJQUM5QyxNQUFNLFVBQVUsR0FBRyxVQUFVLENBQUMsYUFBYSxDQUFDLENBQUE7SUFDNUMsTUFBTSxVQUFVLEdBQUcsSUFBSSxDQUFDLEtBQUssQ0FBQyxVQUFVLENBQUMsYUFBYSxDQUFDLENBQUMsQ0FBQTtJQUV4RCx5REFBeUQ7SUFDekQsdURBQXVEO0lBQ3ZELE1BQU0sY0FBYyxHQUFHLDBCQUEwQixDQUFBO0lBRWpELE1BQU0sV0FBVyxHQUFHLEdBQUcsT0FBTyxDQUFDLFlBQVksR0FBRyxDQUFBO0lBRTlDLHNCQUFzQjtJQUN0QixJQUNFLE9BQU8sS0FBSyxDQUFDLFVBQVUsS0FBSyxRQUFRO1FBQ3BDLE9BQU8sS0FBSyxDQUFDLFNBQVMsS0FBSyxRQUFRO1FBQ25DLENBQUMsS0FBSyxDQUFDLE9BQU8sQ0FBQyxLQUFLLENBQUMsVUFBVSxDQUFDO1FBQ2hDLENBQUMsS0FBSyxDQUFDLFVBQVUsQ0FBQyxLQUFLLENBQ3JCLENBQUMsRUFBRSxFQUFFLEVBQUUsQ0FBQyxPQUFPLEVBQUUsS0FBSyxRQUFRLElBQUksY0FBYyxDQUFDLElBQUksQ0FBQyxFQUFFLENBQUMsQ0FDMUQsRUFDRDtRQUNBLE1BQU0sSUFBSSxLQUFLLENBQUMsaUJBQWlCLEdBQUcsSUFBSSxDQUFDLFNBQVMsQ0FBQyxLQUFLLEVBQUUsU0FBUyxFQUFFLElBQUksQ0FBQyxDQUFDLENBQUE7S0FDNUU7SUFFRCxLQUFLLFVBQVUsR0FBRyxDQUFDLElBQVksRUFBRSxJQUFpQjtRQUNoRCxNQUFNLEVBQUU7YUFDTCxTQUFTLENBQUM7WUFDVCxNQUFNLEVBQUUsVUFBVTtZQUNsQixHQUFHLEVBQUUsR0FBRyxXQUFXLEdBQUcsSUFBSSxFQUFFO1lBQzVCLElBQUksRUFBRSxJQUFJO1NBQ1gsQ0FBQzthQUNELE9BQU8sRUFBRSxDQUFBO0lBQ2QsQ0FBQztJQUVELE1BQU0sR0FBRyxDQUFDLGlCQUFpQixFQUFFLEtBQUssQ0FBQyxVQUFVLENBQUMsSUFBSSxDQUFDLEdBQUcsQ0FBQyxDQUFDLENBQUE7SUFDeEQsMERBQTBEO0lBQzFELE1BQU0sR0FBRyxDQUNQLFVBQVUsRUFDVixJQUFJLENBQUMsU0FBUyxDQUFDO1FBQ2IsT0FBTyxFQUFFLFVBQVU7S0FDcEIsQ0FBQyxDQUNILENBQUE7SUFFRCxNQUFNLEtBQUssR0FBRyxNQUFNLFNBQVM7U0FDMUIsVUFBVSxDQUFDO1FBQ1YsV0FBVztRQUNYLGtCQUFrQixFQUFFLElBQUk7UUFDeEIsc0JBQXNCLEVBQUUsR0FBRyxVQUFVLElBQUksV0FBVyxFQUFFO1FBQ3RELHdCQUF3QixFQUFFO1lBQ3hCO2dCQUNFLElBQUksRUFBRSxJQUFJO2dCQUNWLFFBQVEsRUFBRSxHQUFHLEtBQUssQ0FBQyxVQUFVLElBQUksS0FBSyxDQUFDLFNBQVMsRUFBRTtnQkFDbEQsZ0JBQWdCLEVBQUUsZUFBZTthQUNsQztTQUNGO0tBQ0YsQ0FBQztTQUNELE9BQU8sRUFBRSxDQUFBO0lBRVosTUFBTSxPQUFPLEdBQUcsTUFBQSxLQUFLLENBQUMsS0FBSywwQ0FBRSxFQUFFLENBQUE7SUFDL0IsSUFBSSxPQUFPLElBQUksSUFBSSxFQUFFO1FBQ25CLE1BQU0sSUFBSSxLQUFLLENBQUMsa0JBQWtCLENBQUMsQ0FBQTtLQUNwQztJQUVELE9BQU87UUFDTCxpRUFBaUU7UUFDakUsb0VBQW9FO1FBQ3BFLG9DQUFvQztRQUNwQyxLQUFLLEVBQUUsT0FBTztLQUNmLENBQUE7QUFDSCxDQUFDLENBQUE7QUFuRlksUUFBQSxrQkFBa0Isc0JBbUY5QiIsInNvdXJjZXNDb250ZW50IjpbIi8qIGVzbGludC1kaXNhYmxlIEB0eXBlc2NyaXB0LWVzbGludC9uby11bnNhZmUtYXNzaWdubWVudCAqL1xuLyogZXNsaW50LWRpc2FibGUgQHR5cGVzY3JpcHQtZXNsaW50L25vLXVuc2FmZS1jYWxsICovXG4vKiBlc2xpbnQtZGlzYWJsZSBAdHlwZXNjcmlwdC1lc2xpbnQvbm8tdW5zYWZlLW1lbWJlci1hY2Nlc3MgKi9cbi8qIGVzbGludC1kaXNhYmxlIEB0eXBlc2NyaXB0LWVzbGludC9uby12YXItcmVxdWlyZXMgKi9cbmltcG9ydCB7IEhhbmRsZXIgfSBmcm9tIFwiYXdzLWxhbWJkYVwiXG5pbXBvcnQgdHlwZSAqIGFzIF9BV1MgZnJvbSBcImF3cy1zZGtcIlxuXG5pbnRlcmZhY2UgU3RhcnREZXBsb3lFeHBlY3RlZElucHV0IHtcbiAgYnVja2V0TmFtZTogc3RyaW5nXG4gIGJ1Y2tldEtleTogc3RyaW5nXG4gIHN0YWNrTmFtZXM6IHN0cmluZ1tdXG59XG5cbi8vIFRoaXMgZnVuY3Rpb24gaXMgaW5saW5lLWNvbXBpbGVkIGZvciB0aGUgbGFtYmRhLlxuLy8gSXQgbXVzdCBiZSBzZWxmLWNvbnRhaW5lZC5cbmV4cG9ydCBjb25zdCBzdGFydERlcGxveUhhbmRsZXI6IEhhbmRsZXI8XG4gIFBhcnRpYWw8U3RhcnREZXBsb3lFeHBlY3RlZElucHV0PlxuPiA9IGFzeW5jIChldmVudCwgY29udGV4dCkgPT4ge1xuICBjb25zdCBBV1MgPSByZXF1aXJlKFwiYXdzLXNka1wiKVxuXG4gIGNvbnN0IGNvZGVidWlsZCA9IG5ldyBBV1MuQ29kZUJ1aWxkKCkgYXMgX0FXUy5Db2RlQnVpbGRcbiAgY29uc3QgczMgPSBuZXcgQVdTLlMzKCkgYXMgX0FXUy5TM1xuXG4gIGZ1bmN0aW9uIHJlcXVpcmVFbnYobmFtZTogc3RyaW5nKTogc3RyaW5nIHtcbiAgICBjb25zdCB2YWx1ZSA9IHByb2Nlc3MuZW52W25hbWVdXG4gICAgaWYgKHZhbHVlID09PSB1bmRlZmluZWQpIHtcbiAgICAgIHRocm93IG5ldyBFcnJvcihgTWlzc2luZyAke25hbWV9YClcbiAgICB9XG4gICAgcmV0dXJuIHZhbHVlXG4gIH1cblxuICBjb25zdCBwcm9qZWN0TmFtZSA9IHJlcXVpcmVFbnYoXCJQUk9KRUNUX05BTUVcIilcbiAgY29uc3QgYnVja2V0TmFtZSA9IHJlcXVpcmVFbnYoXCJCVUNLRVRfTkFNRVwiKVxuICBjb25zdCBjZGtDb250ZXh0ID0gSlNPTi5wYXJzZShyZXF1aXJlRW52KFwiQ0RLX0NPTlRFWFRcIikpXG5cbiAgLy8gU2luY2Ugd2UgcGFzcyB0aGUgc3RhY2sgbmFtZXMgYXMgc3RyaW5ncyB0byB0aGUgc2hlbGwsXG4gIC8vIGJlIGEgYml0IHJlc3RyaWN0aXZlIG9mIHRoZSB2YWxpZCB2YWx1ZXMgd2UgY2FuIHVzZS5cbiAgY29uc3QgdmFsaWRTdGFja05hbWUgPSAvXlthLXowLTlfXVthLXowLTlcXC1fXSokL2lcblxuICBjb25zdCBzM0tleVByZWZpeCA9IGAke2NvbnRleHQuYXdzUmVxdWVzdElkfS9gXG5cbiAgLy8gVmFsaWRhdGUgdGhlIGlucHV0LlxuICBpZiAoXG4gICAgdHlwZW9mIGV2ZW50LmJ1Y2tldE5hbWUgIT09IFwic3RyaW5nXCIgfHxcbiAgICB0eXBlb2YgZXZlbnQuYnVja2V0S2V5ICE9PSBcInN0cmluZ1wiIHx8XG4gICAgIUFycmF5LmlzQXJyYXkoZXZlbnQuc3RhY2tOYW1lcykgfHxcbiAgICAhZXZlbnQuc3RhY2tOYW1lcy5ldmVyeShcbiAgICAgIChpdCkgPT4gdHlwZW9mIGl0ID09PSBcInN0cmluZ1wiICYmIHZhbGlkU3RhY2tOYW1lLnRlc3QoaXQpLFxuICAgIClcbiAgKSB7XG4gICAgdGhyb3cgbmV3IEVycm9yKFwiSW5wdXQgaW52YWxpZDogXCIgKyBKU09OLnN0cmluZ2lmeShldmVudCwgdW5kZWZpbmVkLCBcIiAgXCIpKVxuICB9XG5cbiAgYXN5bmMgZnVuY3Rpb24gcHV0KG5hbWU6IHN0cmluZywgZGF0YTogQVdTLlMzLkJvZHkpIHtcbiAgICBhd2FpdCBzM1xuICAgICAgLnB1dE9iamVjdCh7XG4gICAgICAgIEJ1Y2tldDogYnVja2V0TmFtZSxcbiAgICAgICAgS2V5OiBgJHtzM0tleVByZWZpeH0ke25hbWV9YCxcbiAgICAgICAgQm9keTogZGF0YSxcbiAgICAgIH0pXG4gICAgICAucHJvbWlzZSgpXG4gIH1cblxuICBhd2FpdCBwdXQoXCJzdGFjay1uYW1lcy50eHRcIiwgZXZlbnQuc3RhY2tOYW1lcy5qb2luKFwiIFwiKSlcbiAgLy8gRW5zdXJlIHRoYXQgd2UgcnVuIHRoZSBzY3JpcHQgdXNpbmcgc2FtZSBmZWF0dXJlIGZsYWdzLlxuICBhd2FpdCBwdXQoXG4gICAgXCJjZGsuanNvblwiLFxuICAgIEpTT04uc3RyaW5naWZ5KHtcbiAgICAgIGNvbnRleHQ6IGNka0NvbnRleHQsXG4gICAgfSksXG4gIClcblxuICBjb25zdCBidWlsZCA9IGF3YWl0IGNvZGVidWlsZFxuICAgIC5zdGFydEJ1aWxkKHtcbiAgICAgIHByb2plY3ROYW1lLFxuICAgICAgc291cmNlVHlwZU92ZXJyaWRlOiBcIlMzXCIsXG4gICAgICBzb3VyY2VMb2NhdGlvbk92ZXJyaWRlOiBgJHtidWNrZXROYW1lfS8ke3MzS2V5UHJlZml4fWAsXG4gICAgICBzZWNvbmRhcnlTb3VyY2VzT3ZlcnJpZGU6IFtcbiAgICAgICAge1xuICAgICAgICAgIHR5cGU6IFwiUzNcIixcbiAgICAgICAgICBsb2NhdGlvbjogYCR7ZXZlbnQuYnVja2V0TmFtZX0vJHtldmVudC5idWNrZXRLZXl9YCxcbiAgICAgICAgICBzb3VyY2VJZGVudGlmaWVyOiBcIkNMT1VEQVNTRU1CTFlcIixcbiAgICAgICAgfSxcbiAgICAgIF0sXG4gICAgfSlcbiAgICAucHJvbWlzZSgpXG5cbiAgY29uc3QgYnVpbGRJZCA9IGJ1aWxkLmJ1aWxkPy5pZFxuICBpZiAoYnVpbGRJZCA9PSBudWxsKSB7XG4gICAgdGhyb3cgbmV3IEVycm9yKFwiVW5rbm93biBidWlsZCBJRFwiKVxuICB9XG5cbiAgcmV0dXJuIHtcbiAgICAvLyBUaGlzIGlzIHRoZSB2YWx1ZSB0aGUgY2FsbGVyIHdpbGwgdXNlIHRvIGZldGNoIHVwZGF0ZWQgc3RhdHVzLlxuICAgIC8vIEF2b2lkIGV4cG9zaW5nIHdoYXQga2luZCBvZiBJRCB0aGlzIGlzLCBiZWNhdXNlIHdlIHNob3VsZCBiZSBmcmVlXG4gICAgLy8gdG8gY2hhbmdlIGltcGxlbWVudGF0aW9uIGRldGFpbHMuXG4gICAgam9iSWQ6IGJ1aWxkSWQsXG4gIH1cbn1cbiJdfQ==

package/lib/cloudtrail-slack-integration/cloudtrail-slack-integration.d.ts

@@ -0,0 +1,43 @@
+import * as cdk from "@aws-cdk/core";
+import * as cloudwatch from "@aws-cdk/aws-cloudwatch";
+export interface CloudTrailSlackIntegrationProps extends cdk.StackProps {
+    /**
+     * A key-value pair of AWS account IDs and friendly names of these accounts
+     * to use when sending messages to Slack.
+     */
+    accountFriendlyNames?: {
+        [key: string]: string;
+    };
+    slackWebhookUrl: string;
+    slackChannel: string;
+    /**
+     * A list of ARNs of roles in the current account to monitor usage of.
+     */
+    rolesToMonitor?: string[];
+    /**
+     * Whether to monitor various IAM API calls associated with the current account's root user (e.g., console login, password reset, etc.)
+     *
+     * @default true
+     */
+    monitorRootUserActions?: boolean;
+    /**
+     * Whether to set up additional AWS infrastructure to deduplicate CloudTrail events in order to avoid duplicate Slack messages. May be used to decrease noise.
+     *
+     * @default false
+     */
+    deduplicateEvents?: boolean;
+    /**
+     * If supplied, CloudWatch alarms will be created for the construct's underlying infrastructure (e.g., Lambda functions) and the action will be used to notify on OK and ALARM actions.
+     */
+    infrastructureAlarmAction?: cloudwatch.IAlarmAction;
+}
+/**
+ * Forward a predefined set of CloudTrail API events to Slack using EventBridge, Lambda
+ * and an optional SQS FIFO queue for deduplicating events.
+ * The API events are limited to monitoring access to the current account's root user and/or specific IAM roles.
+ *
+ * NOTE: The construct needs to be provisioned in us-east-1, and requires an existing CloudTrail set up in that region.
+ */
+export declare class CloudTrailSlackIntegration extends cdk.Construct {
+    constructor(scope: cdk.Construct, id: string, props: CloudTrailSlackIntegrationProps);
+}

package/lib/cloudtrail-slack-integration/cloudtrail-slack-integration.js

@@ -0,0 +1,210 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CloudTrailSlackIntegration = void 0;
+const cdk = require("@aws-cdk/core");
+const iam = require("@aws-cdk/aws-iam");
+const logs = require("@aws-cdk/aws-logs");
+const cloudwatch = require("@aws-cdk/aws-cloudwatch");
+const lambda = require("@aws-cdk/aws-lambda");
+const events = require("@aws-cdk/aws-events");
+const sources = require("@aws-cdk/aws-lambda-event-sources");
+const sqs = require("@aws-cdk/aws-sqs");
+const targets = require("@aws-cdk/aws-events-targets");
+const path = require("path");
+/**
+ * Forward a predefined set of CloudTrail API events to Slack using EventBridge, Lambda
+ * and an optional SQS FIFO queue for deduplicating events.
+ * The API events are limited to monitoring access to the current account's root user and/or specific IAM roles.
+ *
+ * NOTE: The construct needs to be provisioned in us-east-1, and requires an existing CloudTrail set up in that region.
+ */
+class CloudTrailSlackIntegration extends cdk.Construct {
+    constructor(scope, id, props) {
+        super(scope, id);
+        const eventTransformer = new lambda.Function(this, "EventTransformerLambda", {
+            code: lambda.Code.fromAsset(path.join(__dirname, "../../assets/cloudtrail-slack-integration-lambda")),
+            description: "Formats CloudTrail API calls sent through EventBridge, and posts them directly to Slack or first to an SQS FIFO queue for deduplication",
+            handler: "main.handler_event_transformer",
+            runtime: lambda.Runtime.PYTHON_3_9,
+            timeout: cdk.Duration.seconds(15),
+            logRetention: logs.RetentionDays.SIX_MONTHS,
+            environment: {
+                SLACK_CHANNEL: props.slackChannel,
+                DEDUPLICATE_EVENTS: JSON.stringify(!!props.deduplicateEvents),
+                ACCOUNT_FRIENDLY_NAMES: JSON.stringify(props.accountFriendlyNames || {}),
+                SLACK_WEBHOOK_URL: props.slackWebhookUrl,
+            },
+        });
+        eventTransformer.addToRolePolicy(new iam.PolicyStatement({
+            actions: ["iam:ListAccountAliases"],
+            resources: ["*"],
+        }));
+        if (props.infrastructureAlarmAction) {
+            const eventTransformerAlarm = eventTransformer
+                .metricErrors({
+                period: cdk.Duration.minutes(5),
+                statistic: cloudwatch.Statistic.SUM,
+            })
+                .createAlarm(this, "EventTransformerErrorAlarm", {
+                threshold: 1,
+                evaluationPeriods: 1,
+                alarmDescription: "Triggers if the Lambda function that transforms CloudTrail API calls received through EventBridge fails (e.g., it fails to process the event)",
+                datapointsToAlarm: 1,
+                treatMissingData: cloudwatch.TreatMissingData.IGNORE,
+            });
+            eventTransformerAlarm.addOkAction(props.infrastructureAlarmAction);
+            eventTransformerAlarm.addAlarmAction(props.infrastructureAlarmAction);
+        }
+        if (props.deduplicateEvents) {
+            const deduplicationQueue = new sqs.Queue(this, "Queue", {
+                // We explicitly give the queue a name due to bug https://github.com/aws/aws-cdk/issues/5860
+                queueName: `${this.node.id.substring(0, 33)}${this.node.addr}`.substring(0, 75) +
+                    ".fifo",
+                fifo: true,
+            });
+            eventTransformer.addEnvironment("SQS_QUEUE_URL", deduplicationQueue.queueUrl);
+            deduplicationQueue.grantSendMessages(eventTransformer);
+            const slackForwarder = new lambda.Function(this, "SlackForwarderLambda", {
+                code: lambda.Code.fromAsset(path.join(__dirname, "../../assets/cloudtrail-slack-integration-lambda")),
+                description: "Polls from an SQS FIFO queue containing formatted CloudTrail API calls and sends them to Slack.",
+                handler: "main.handler_slack_forwarder",
+                runtime: lambda.Runtime.PYTHON_3_9,
+                timeout: cdk.Duration.seconds(15),
+                logRetention: logs.RetentionDays.TWO_WEEKS,
+            });
+            if (props.infrastructureAlarmAction) {
+                const slackForwarderAlarm = slackForwarder
+                    .metricErrors({
+                    period: cdk.Duration.minutes(5),
+                    statistic: cloudwatch.Statistic.SUM,
+                })
+                    .createAlarm(this, "SlackForwarderErrorAlarm", {
+                    threshold: 1,
+                    alarmDescription: "Triggers if the Lambda function that polls from SQS and posts deduplicated CloudTrail API calls received through EventBridge to Slack fails (e.g., invalid Slack webhook URL)",
+                    evaluationPeriods: 1,
+                    datapointsToAlarm: 1,
+                    treatMissingData: cloudwatch.TreatMissingData.IGNORE,
+                });
+                slackForwarderAlarm.addOkAction(props.infrastructureAlarmAction);
+                slackForwarderAlarm.addAlarmAction(props.infrastructureAlarmAction);
+            }
+            slackForwarder.addEventSource(new sources.SqsEventSource(deduplicationQueue));
+        }
+        if (props.rolesToMonitor && props.rolesToMonitor.length > 0) {
+            new events.Rule(this, "RuleForAssumeRole", {
+                enabled: true,
+                targets: [new targets.LambdaFunction(eventTransformer)],
+                eventPattern: {
+                    detail: {
+                        eventName: ["AssumeRole"],
+                        requestParameters: {
+                            roleArn: props.rolesToMonitor,
+                        },
+                    },
+                },
+            });
+        }
+        if (props.monitorRootUserActions !== false) {
+            // Triggers when the root password has been changed
+            new events.Rule(this, "RuleForRootUserPasswordChange", {
+                enabled: true,
+                targets: [new targets.LambdaFunction(eventTransformer)],
+                eventPattern: {
+                    detail: {
+                        userIdentity: {
+                            type: ["Root"],
+                        },
+                        eventName: ["PasswordUpdated"],
+                        eventType: ["AwsConsoleSignIn"],
+                    },
+                },
+            });
+            // Triggers when MFA for the root user has been set up
+            new events.Rule(this, "RuleForRootUserMfaChange", {
+                enabled: true,
+                targets: [new targets.LambdaFunction(eventTransformer)],
+                eventPattern: {
+                    detail: {
+                        userIdentity: {
+                            type: ["Root"],
+                        },
+                        eventName: ["EnableMFADevice"],
+                        requestParameters: {
+                            userName: ["AWS ROOT USER"],
+                        },
+                    },
+                },
+            });
+            // Triggers when a root user succesfully logs in to the console
+            new events.Rule(this, "RuleForRootUserSuccessfulLogin", {
+                enabled: true,
+                targets: [new targets.LambdaFunction(eventTransformer)],
+                eventPattern: {
+                    detail: {
+                        userIdentity: {
+                            type: ["Root"],
+                        },
+                        eventName: ["ConsoleLogin"],
+                        eventType: ["AwsConsoleSignIn"],
+                        responseElements: {
+                            ConsoleLogin: ["Success"],
+                        },
+                    },
+                },
+            });
+            // Triggers for bad login attemps for root user (e.g., wrong password)
+            new events.Rule(this, "RuleForRootUserUnsuccessfulLogin", {
+                enabled: true,
+                targets: [new targets.LambdaFunction(eventTransformer)],
+                eventPattern: {
+                    detail: {
+                        userIdentity: {
+                            type: ["Root"],
+                        },
+                        eventName: ["ConsoleLogin"],
+                        eventType: ["AwsConsoleSignIn"],
+                        responseElements: {
+                            ConsoleLogin: ["Failure"],
+                        },
+                    },
+                },
+            });
+            // Triggered when password reset has been requested
+            new events.Rule(this, "RuleForRootUserPasswordRecoveryRequest", {
+                enabled: true,
+                targets: [new targets.LambdaFunction(eventTransformer)],
+                eventPattern: {
+                    detail: {
+                        userIdentity: {
+                            type: ["Root"],
+                        },
+                        eventName: ["PasswordRecoveryRequested"],
+                        eventType: ["AwsConsoleSignIn"],
+                        responseElements: {
+                            PasswordRecoveryRequested: ["Success"],
+                        },
+                    },
+                },
+            });
+            // Triggered when password has been successfully reset
+            new events.Rule(this, "RuleForRootUserPasswordRecoveryComplete", {
+                enabled: true,
+                targets: [new targets.LambdaFunction(eventTransformer)],
+                eventPattern: {
+                    detail: {
+                        userIdentity: {
+                            type: ["Root"],
+                        },
+                        eventName: ["PasswordRecoveryCompleted"],
+                        eventType: ["AwsConsoleSignIn"],
+                        responseElements: {
+                            PasswordRecoveryCompleted: ["Success"],
+                        },
+                    },
+                },
+            });
+        }
+    }
+}
+exports.CloudTrailSlackIntegration = CloudTrailSlackIntegration;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"cloudtrail-slack-integration.js","sourceRoot":"","sources":["../../src/cloudtrail-slack-integration/cloudtrail-slack-integration.ts"],"names":[],"mappings":"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","sourcesContent":["import * as cdk from \"@aws-cdk/core\"\nimport * as iam from \"@aws-cdk/aws-iam\"\nimport * as logs from \"@aws-cdk/aws-logs\"\nimport * as cloudwatch from \"@aws-cdk/aws-cloudwatch\"\nimport * as lambda from \"@aws-cdk/aws-lambda\"\nimport * as events from \"@aws-cdk/aws-events\"\nimport * as sources from \"@aws-cdk/aws-lambda-event-sources\"\nimport * as sqs from \"@aws-cdk/aws-sqs\"\nimport * as targets from \"@aws-cdk/aws-events-targets\"\nimport * as path from \"path\"\n\nexport interface CloudTrailSlackIntegrationProps extends cdk.StackProps {\n  /**\n   * A key-value pair of AWS account IDs and friendly names of these accounts\n   * to use when sending messages to Slack.\n   */\n  accountFriendlyNames?: {\n    [key: string]: string\n  }\n  slackWebhookUrl: string\n  slackChannel: string\n  /**\n   * A list of ARNs of roles in the current account to monitor usage of.\n   */\n  rolesToMonitor?: string[]\n  /**\n   * Whether to monitor various IAM API calls associated with the current account's root user (e.g., console login, password reset, etc.)\n   *\n   * @default true\n   */\n  monitorRootUserActions?: boolean\n  /**\n   * Whether to set up additional AWS infrastructure to deduplicate CloudTrail events in order to avoid duplicate Slack messages. May be used to decrease noise.\n   *\n   * @default false\n   */\n  deduplicateEvents?: boolean\n  /**\n   * If supplied, CloudWatch alarms will be created for the construct's underlying infrastructure (e.g., Lambda functions) and the action will be used to notify on OK and ALARM actions.\n   */\n  infrastructureAlarmAction?: cloudwatch.IAlarmAction\n}\n\n/**\n * Forward a predefined set of CloudTrail API events to Slack using EventBridge, Lambda\n * and an optional SQS FIFO queue for deduplicating events.\n * The API events are limited to monitoring access to the current account's root user and/or specific IAM roles.\n *\n * NOTE: The construct needs to be provisioned in us-east-1, and requires an existing CloudTrail set up in that region.\n */\nexport class CloudTrailSlackIntegration extends cdk.Construct {\n  constructor(\n    scope: cdk.Construct,\n    id: string,\n    props: CloudTrailSlackIntegrationProps,\n  ) {\n    super(scope, id)\n\n    const eventTransformer = new lambda.Function(\n      this,\n      \"EventTransformerLambda\",\n      {\n        code: lambda.Code.fromAsset(\n          path.join(\n            __dirname,\n            \"../../assets/cloudtrail-slack-integration-lambda\",\n          ),\n        ),\n        description:\n          \"Formats CloudTrail API calls sent through EventBridge, and posts them directly to Slack or first to an SQS FIFO queue for deduplication\",\n        handler: \"main.handler_event_transformer\",\n        runtime: lambda.Runtime.PYTHON_3_9,\n        timeout: cdk.Duration.seconds(15),\n        logRetention: logs.RetentionDays.SIX_MONTHS,\n        environment: {\n          SLACK_CHANNEL: props.slackChannel,\n          DEDUPLICATE_EVENTS: JSON.stringify(!!props.deduplicateEvents),\n          ACCOUNT_FRIENDLY_NAMES: JSON.stringify(\n            props.accountFriendlyNames || {},\n          ),\n          SLACK_WEBHOOK_URL: props.slackWebhookUrl,\n        },\n      },\n    )\n    eventTransformer.addToRolePolicy(\n      new iam.PolicyStatement({\n        actions: [\"iam:ListAccountAliases\"],\n        resources: [\"*\"],\n      }),\n    )\n    if (props.infrastructureAlarmAction) {\n      const eventTransformerAlarm = eventTransformer\n        .metricErrors({\n          period: cdk.Duration.minutes(5),\n          statistic: cloudwatch.Statistic.SUM,\n        })\n        .createAlarm(this, \"EventTransformerErrorAlarm\", {\n          threshold: 1,\n          evaluationPeriods: 1,\n          alarmDescription:\n            \"Triggers if the Lambda function that transforms CloudTrail API calls received through EventBridge fails (e.g., it fails to process the event)\",\n          datapointsToAlarm: 1,\n          treatMissingData: cloudwatch.TreatMissingData.IGNORE,\n        })\n      eventTransformerAlarm.addOkAction(props.infrastructureAlarmAction)\n      eventTransformerAlarm.addAlarmAction(props.infrastructureAlarmAction)\n    }\n    if (props.deduplicateEvents) {\n      const deduplicationQueue = new sqs.Queue(this, \"Queue\", {\n        // We explicitly give the queue a name due to bug https://github.com/aws/aws-cdk/issues/5860\n        queueName:\n          `${this.node.id.substring(0, 33)}${this.node.addr}`.substring(0, 75) +\n          \".fifo\",\n        fifo: true,\n      })\n      eventTransformer.addEnvironment(\n        \"SQS_QUEUE_URL\",\n        deduplicationQueue.queueUrl,\n      )\n      deduplicationQueue.grantSendMessages(eventTransformer)\n      const slackForwarder = new lambda.Function(this, \"SlackForwarderLambda\", {\n        code: lambda.Code.fromAsset(\n          path.join(\n            __dirname,\n            \"../../assets/cloudtrail-slack-integration-lambda\",\n          ),\n        ),\n        description:\n          \"Polls from an SQS FIFO queue containing formatted CloudTrail API calls and sends them to Slack.\",\n        handler: \"main.handler_slack_forwarder\",\n        runtime: lambda.Runtime.PYTHON_3_9,\n        timeout: cdk.Duration.seconds(15),\n        logRetention: logs.RetentionDays.TWO_WEEKS,\n      })\n\n      if (props.infrastructureAlarmAction) {\n        const slackForwarderAlarm = slackForwarder\n          .metricErrors({\n            period: cdk.Duration.minutes(5),\n            statistic: cloudwatch.Statistic.SUM,\n          })\n          .createAlarm(this, \"SlackForwarderErrorAlarm\", {\n            threshold: 1,\n            alarmDescription:\n              \"Triggers if the Lambda function that polls from SQS and posts deduplicated CloudTrail API calls received through EventBridge to Slack fails (e.g., invalid Slack webhook URL)\",\n            evaluationPeriods: 1,\n            datapointsToAlarm: 1,\n            treatMissingData: cloudwatch.TreatMissingData.IGNORE,\n          })\n        slackForwarderAlarm.addOkAction(props.infrastructureAlarmAction)\n        slackForwarderAlarm.addAlarmAction(props.infrastructureAlarmAction)\n      }\n      slackForwarder.addEventSource(\n        new sources.SqsEventSource(deduplicationQueue),\n      )\n    }\n\n    if (props.rolesToMonitor && props.rolesToMonitor.length > 0) {\n      new events.Rule(this, \"RuleForAssumeRole\", {\n        enabled: true,\n        targets: [new targets.LambdaFunction(eventTransformer)],\n        eventPattern: {\n          detail: {\n            eventName: [\"AssumeRole\"],\n            requestParameters: {\n              roleArn: props.rolesToMonitor,\n            },\n          },\n        },\n      })\n    }\n\n    if (props.monitorRootUserActions !== false) {\n      // Triggers when the root password has been changed\n      new events.Rule(this, \"RuleForRootUserPasswordChange\", {\n        enabled: true,\n        targets: [new targets.LambdaFunction(eventTransformer)],\n        eventPattern: {\n          detail: {\n            userIdentity: {\n              type: [\"Root\"],\n            },\n            eventName: [\"PasswordUpdated\"],\n            eventType: [\"AwsConsoleSignIn\"],\n          },\n        },\n      })\n\n      // Triggers when MFA for the root user has been set up\n      new events.Rule(this, \"RuleForRootUserMfaChange\", {\n        enabled: true,\n        targets: [new targets.LambdaFunction(eventTransformer)],\n        eventPattern: {\n          detail: {\n            userIdentity: {\n              type: [\"Root\"],\n            },\n            eventName: [\"EnableMFADevice\"],\n            requestParameters: {\n              userName: [\"AWS ROOT USER\"],\n            },\n          },\n        },\n      })\n\n      // Triggers when a root user succesfully logs in to the console\n      new events.Rule(this, \"RuleForRootUserSuccessfulLogin\", {\n        enabled: true,\n        targets: [new targets.LambdaFunction(eventTransformer)],\n        eventPattern: {\n          detail: {\n            userIdentity: {\n              type: [\"Root\"],\n            },\n            eventName: [\"ConsoleLogin\"],\n            eventType: [\"AwsConsoleSignIn\"],\n            responseElements: {\n              ConsoleLogin: [\"Success\"],\n            },\n          },\n        },\n      })\n\n      // Triggers for bad login attemps for root user (e.g., wrong password)\n      new events.Rule(this, \"RuleForRootUserUnsuccessfulLogin\", {\n        enabled: true,\n        targets: [new targets.LambdaFunction(eventTransformer)],\n        eventPattern: {\n          detail: {\n            userIdentity: {\n              type: [\"Root\"],\n            },\n            eventName: [\"ConsoleLogin\"],\n            eventType: [\"AwsConsoleSignIn\"],\n            responseElements: {\n              ConsoleLogin: [\"Failure\"],\n            },\n          },\n        },\n      })\n\n      // Triggered when password reset has been requested\n      new events.Rule(this, \"RuleForRootUserPasswordRecoveryRequest\", {\n        enabled: true,\n        targets: [new targets.LambdaFunction(eventTransformer)],\n        eventPattern: {\n          detail: {\n            userIdentity: {\n              type: [\"Root\"],\n            },\n            eventName: [\"PasswordRecoveryRequested\"],\n            eventType: [\"AwsConsoleSignIn\"],\n            responseElements: {\n              PasswordRecoveryRequested: [\"Success\"],\n            },\n          },\n        },\n      })\n\n      // Triggered when password has been successfully reset\n      new events.Rule(this, \"RuleForRootUserPasswordRecoveryComplete\", {\n        enabled: true,\n        targets: [new targets.LambdaFunction(eventTransformer)],\n        eventPattern: {\n          detail: {\n            userIdentity: {\n              type: [\"Root\"],\n            },\n            eventName: [\"PasswordRecoveryCompleted\"],\n            eventType: [\"AwsConsoleSignIn\"],\n            responseElements: {\n              PasswordRecoveryCompleted: [\"Success\"],\n            },\n          },\n        },\n      })\n    }\n  }\n}\n"]}

package/lib/cloudtrail-slack-integration/index.d.ts

@@ -0,0 +1 @@
+export { CloudTrailSlackIntegration, CloudTrailSlackIntegrationProps, } from "./cloudtrail-slack-integration";

package/lib/cloudtrail-slack-integration/index.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CloudTrailSlackIntegration = void 0;
+var cloudtrail_slack_integration_1 = require("./cloudtrail-slack-integration");
+Object.defineProperty(exports, "CloudTrailSlackIntegration", { enumerable: true, get: function () { return cloudtrail_slack_integration_1.CloudTrailSlackIntegration; } });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvY2xvdWR0cmFpbC1zbGFjay1pbnRlZ3JhdGlvbi9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7QUFBQSwrRUFHdUM7QUFGckMsMElBQUEsMEJBQTBCLE9BQUEiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQge1xuICBDbG91ZFRyYWlsU2xhY2tJbnRlZ3JhdGlvbixcbiAgQ2xvdWRUcmFpbFNsYWNrSW50ZWdyYXRpb25Qcm9wcyxcbn0gZnJvbSBcIi4vY2xvdWR0cmFpbC1zbGFjay1pbnRlZ3JhdGlvblwiXG4iXX0=

package/lib/ecs-update-image/start-deploy-handler.js

@@ -54,7 +54,6 @@ const startDeployHandler = async (event) => {
             "status",
             "taskDefinitionArn",
         ];
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
         const updatedSpec = {
             ...Object.fromEntries(Object.entries(prevTaskDefinition).filter(([key]) => !exclude.includes(key))),
             containerDefinitions: [
@@ -102,4 +101,4 @@ const startDeployHandler = async (event) => {
     return {};
 };
 exports.startDeployHandler = startDeployHandler;
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"start-deploy-handler.js","sourceRoot":"","sources":["../../src/ecs-update-image/start-deploy-handler.ts"],"names":[],"mappings":"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","sourcesContent":["/* eslint-disable @typescript-eslint/no-unsafe-assignment */\n/* eslint-disable @typescript-eslint/no-unsafe-call */\n/* eslint-disable @typescript-eslint/no-unsafe-member-access */\n/* eslint-disable @typescript-eslint/no-unsafe-return */\n/* eslint-disable @typescript-eslint/no-var-requires */\nimport type { Handler } from \"aws-lambda\"\nimport type * as _AWS from \"aws-sdk\"\n\ninterface ExpectedInput {\n  tag: string\n}\n\n// This function is inline-compiled for the lambda.\n// It must be self-contained.\nexport const startDeployHandler: Handler<Partial<ExpectedInput>> = async (\n  event,\n) => {\n  const AWS = require(\"aws-sdk\")\n  const ecs = new AWS.ECS() as _AWS.ECS\n  const sm = new AWS.SecretsManager() as _AWS.SecretsManager\n\n  function requireEnv(name: string): string {\n    const value = process.env[name]\n    if (value === undefined) {\n      throw new Error(`Missing ${name}`)\n    }\n    return value\n  }\n\n  async function getService(\n    clusterName: string,\n    serviceName: string,\n  ): Promise<AWS.ECS.Service> {\n    const services = await ecs\n      .describeServices({\n        cluster: clusterName,\n        services: [serviceName],\n      })\n      .promise()\n\n    if (services.services?.length !== 1) {\n      throw new Error(`Service not found: ${clusterName}/${serviceName}`)\n    }\n\n    return services.services[0]\n  }\n\n  async function getTaskDefinition(\n    taskDefinition: string,\n  ): Promise<AWS.ECS.TaskDefinition> {\n    return (\n      await ecs\n        .describeTaskDefinition({\n          taskDefinition: taskDefinition,\n        })\n        .promise()\n    ).taskDefinition!\n  }\n\n  async function updateServiceToImage(\n    clusterName: string,\n    serviceName: string,\n    image: string,\n  ) {\n    console.log(`Cluster name: ${clusterName}`)\n    console.log(`Service name: ${serviceName}`)\n\n    const service = await getService(clusterName, serviceName)\n    const prevTaskDefinition = await getTaskDefinition(service.taskDefinition!)\n\n    // Don't bother updating the service if the image is already the latest.\n    const prevImage = prevTaskDefinition.containerDefinitions![0].image!\n    if (prevImage === image) {\n      return\n    }\n\n    console.log(\n      `Updating image for service '${serviceName}' from '${prevImage}' to '${image}'`,\n    )\n\n    const exclude = [\n      \"registeredAt\",\n      \"registeredBy\",\n      \"compatibilities\",\n      \"requiresAttributes\",\n      \"revision\",\n      \"status\",\n      \"taskDefinitionArn\",\n    ]\n\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    const updatedSpec: any = {\n      ...Object.fromEntries(\n        Object.entries(prevTaskDefinition).filter(\n          ([key]) => !exclude.includes(key),\n        ),\n      ),\n      containerDefinitions: [\n        {\n          ...prevTaskDefinition.containerDefinitions![0],\n          image,\n        },\n      ],\n    }\n\n    const updatedTaskDefinition = (\n      await ecs.registerTaskDefinition(updatedSpec).promise()\n    ).taskDefinition!\n\n    await ecs\n      .updateService({\n        cluster: clusterName,\n        service: serviceName,\n        taskDefinition: updatedTaskDefinition.taskDefinitionArn,\n      })\n      .promise()\n\n    console.log(\"Service is updated\")\n  }\n\n  const clusterName = requireEnv(\"CLUSTER_NAME\")\n  const serviceName = requireEnv(\"SERVICE_NAME\")\n  const repositoryUrl = requireEnv(\"REPOSITORY_URL\")\n  const ecrTagSecretArn = requireEnv(\"ECR_TAG_SECRET_ARN\")\n\n  // Validate the input.\n  if (typeof event.tag !== \"string\") {\n    throw new Error(\"Input invalid: \" + JSON.stringify(event, undefined, \"  \"))\n  }\n\n  // Register tag as current target.\n  // This is needed so that CloudFormation deployments, e.g.\n  // updates to the Task Definition, will use the same image.\n  await sm\n    .updateSecret({\n      SecretId: ecrTagSecretArn,\n      SecretString: JSON.stringify({\n        tag: event.tag,\n      }),\n    })\n    .promise()\n\n  // Update the service if we know the service name. This is unknown\n  // during initial deployment of the stack.\n  if (serviceName !== \"\") {\n    const image = `${repositoryUrl}:${event.tag}`\n    await updateServiceToImage(clusterName, serviceName, image)\n  }\n\n  return {}\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"start-deploy-handler.js","sourceRoot":"","sources":["../../src/ecs-update-image/start-deploy-handler.ts"],"names":[],"mappings":"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","sourcesContent":["/* eslint-disable @typescript-eslint/no-unsafe-assignment */\n/* eslint-disable @typescript-eslint/no-unsafe-call */\n/* eslint-disable @typescript-eslint/no-unsafe-member-access */\n/* eslint-disable @typescript-eslint/no-unsafe-return */\n/* eslint-disable @typescript-eslint/no-var-requires */\nimport type { Handler } from \"aws-lambda\"\nimport type * as _AWS from \"aws-sdk\"\nimport { RegisterTaskDefinitionRequest } from \"aws-sdk/clients/ecs\"\n\ninterface ExpectedInput {\n  tag: string\n}\n\n// This function is inline-compiled for the lambda.\n// It must be self-contained.\nexport const startDeployHandler: Handler<Partial<ExpectedInput>> = async (\n  event,\n) => {\n  const AWS = require(\"aws-sdk\")\n  const ecs = new AWS.ECS() as _AWS.ECS\n  const sm = new AWS.SecretsManager() as _AWS.SecretsManager\n\n  function requireEnv(name: string): string {\n    const value = process.env[name]\n    if (value === undefined) {\n      throw new Error(`Missing ${name}`)\n    }\n    return value\n  }\n\n  async function getService(\n    clusterName: string,\n    serviceName: string,\n  ): Promise<AWS.ECS.Service> {\n    const services = await ecs\n      .describeServices({\n        cluster: clusterName,\n        services: [serviceName],\n      })\n      .promise()\n\n    if (services.services?.length !== 1) {\n      throw new Error(`Service not found: ${clusterName}/${serviceName}`)\n    }\n\n    return services.services[0]\n  }\n\n  async function getTaskDefinition(\n    taskDefinition: string,\n  ): Promise<AWS.ECS.TaskDefinition> {\n    return (\n      await ecs\n        .describeTaskDefinition({\n          taskDefinition: taskDefinition,\n        })\n        .promise()\n    ).taskDefinition!\n  }\n\n  async function updateServiceToImage(\n    clusterName: string,\n    serviceName: string,\n    image: string,\n  ) {\n    console.log(`Cluster name: ${clusterName}`)\n    console.log(`Service name: ${serviceName}`)\n\n    const service = await getService(clusterName, serviceName)\n    const prevTaskDefinition = await getTaskDefinition(service.taskDefinition!)\n\n    // Don't bother updating the service if the image is already the latest.\n    const prevImage = prevTaskDefinition.containerDefinitions![0].image!\n    if (prevImage === image) {\n      return\n    }\n\n    console.log(\n      `Updating image for service '${serviceName}' from '${prevImage}' to '${image}'`,\n    )\n\n    const exclude = [\n      \"registeredAt\",\n      \"registeredBy\",\n      \"compatibilities\",\n      \"requiresAttributes\",\n      \"revision\",\n      \"status\",\n      \"taskDefinitionArn\",\n    ]\n\n    const updatedSpec: RegisterTaskDefinitionRequest = {\n      ...Object.fromEntries(\n        Object.entries(prevTaskDefinition).filter(\n          ([key]) => !exclude.includes(key),\n        ),\n      ),\n      containerDefinitions: [\n        {\n          ...prevTaskDefinition.containerDefinitions![0],\n          image,\n        },\n      ],\n    } as RegisterTaskDefinitionRequest\n\n    const updatedTaskDefinition = (\n      await ecs.registerTaskDefinition(updatedSpec).promise()\n    ).taskDefinition!\n\n    await ecs\n      .updateService({\n        cluster: clusterName,\n        service: serviceName,\n        taskDefinition: updatedTaskDefinition.taskDefinitionArn,\n      })\n      .promise()\n\n    console.log(\"Service is updated\")\n  }\n\n  const clusterName = requireEnv(\"CLUSTER_NAME\")\n  const serviceName = requireEnv(\"SERVICE_NAME\")\n  const repositoryUrl = requireEnv(\"REPOSITORY_URL\")\n  const ecrTagSecretArn = requireEnv(\"ECR_TAG_SECRET_ARN\")\n\n  // Validate the input.\n  if (typeof event.tag !== \"string\") {\n    throw new Error(\"Input invalid: \" + JSON.stringify(event, undefined, \"  \"))\n  }\n\n  // Register tag as current target.\n  // This is needed so that CloudFormation deployments, e.g.\n  // updates to the Task Definition, will use the same image.\n  await sm\n    .updateSecret({\n      SecretId: ecrTagSecretArn,\n      SecretString: JSON.stringify({\n        tag: event.tag,\n      }),\n    })\n    .promise()\n\n  // Update the service if we know the service name. This is unknown\n  // during initial deployment of the stack.\n  if (serviceName !== \"\") {\n    const image = `${repositoryUrl}:${event.tag}`\n    await updateServiceToImage(clusterName, serviceName, image)\n  }\n\n  return {}\n}\n"]}