@liflig/cdk 2.18.4 → 2.18.6

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

@@ -0,0 +1,211 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CloudTrailSlackIntegration = void 0;
+const constructs = require("constructs");
+const cdk = require("aws-cdk-lib");
+const iam = require("aws-cdk-lib/aws-iam");
+const logs = require("aws-cdk-lib/aws-logs");
+const cloudwatch = require("aws-cdk-lib/aws-cloudwatch");
+const lambda = require("aws-cdk-lib/aws-lambda");
+const events = require("aws-cdk-lib/aws-events");
+const sources = require("aws-cdk-lib/aws-lambda-event-sources");
+const sqs = require("aws-cdk-lib/aws-sqs");
+const targets = require("aws-cdk-lib/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 constructs.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),
+                FRIENDLY_NAMES: JSON.stringify(props.friendlyNames || {}),
+                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 constructs from \"constructs\"\nimport * as cdk from \"aws-cdk-lib\"\nimport * as iam from \"aws-cdk-lib/aws-iam\"\nimport * as logs from \"aws-cdk-lib/aws-logs\"\nimport * as cloudwatch from \"aws-cdk-lib/aws-cloudwatch\"\nimport * as lambda from \"aws-cdk-lib/aws-lambda\"\nimport * as events from \"aws-cdk-lib/aws-events\"\nimport * as sources from \"aws-cdk-lib/aws-lambda-event-sources\"\nimport * as sqs from \"aws-cdk-lib/aws-sqs\"\nimport * as targets from \"aws-cdk-lib/aws-events-targets\"\nimport * as path from \"path\"\n\nexport interface CloudTrailSlackIntegrationProps extends cdk.StackProps {\n  /**\n   * A key-value pair of values to augment (e.g., AWS account IDs, principal IDs) with friendly names\n   * to use when sending messages to Slack.\n   *\n   * NOTE: A simple heuristic is used to avoid replacing values inside of ARNs etc. as this can\n   * lead to unpleasant formatting of various fields in the Slack message.\n   */\n  friendlyNames?: {\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 constructs.Construct {\n  constructor(\n    scope: constructs.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          FRIENDLY_NAMES: JSON.stringify(props.friendlyNames || {}),\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/configure-parameters/configure-parameters.d.ts

@@ -0,0 +1,61 @@
+import * as constructs from "constructs";
+import * as iam from "aws-cdk-lib/aws-iam";
+import * as secretsmanager from "aws-cdk-lib/aws-secretsmanager";
+import * as ssm from "aws-cdk-lib/aws-ssm";
+/**
+ * A plain text application parameter that will be stored
+ * in AWS Parameter Store. Only used for non-sensitive values,
+ * typically those commited directly in the IaC code.
+ */
+export interface PlainTextParameter {
+    key: string;
+    value: string;
+}
+/**
+ * An AWS Secret that should hold a JSON object.
+ *
+ * This will provide a secret that liflig-properties can read. The final
+ * parameter seen by the application will be the key given here and the
+ * keys from the secret JSON object appended.
+ */
+export interface SecretParameter {
+    key: string;
+    secret: secretsmanager.ISecret;
+}
+/**
+ * An AWS Secret that should hold a JSON object.
+ *
+ * This will provide a secret that liflig-properties can read. The final
+ * parameter seen by the application will be the key given here and the
+ * keys from the secret JSON object appended.
+ */
+export interface SecretByNameParameter {
+    key: string;
+    secretName: string;
+}
+export type Parameter = PlainTextParameter | SecretParameter | SecretByNameParameter;
+export interface ConfigureParametersProps {
+    /**
+     * Prefix used for parameter names.
+     * Should start with '/' and end without '/'.
+     */
+    ssmPrefix: string;
+    parameters: Parameter[];
+}
+export declare class ConfigureParameters {
+    parameters: ssm.IParameter[];
+    ssmPrefix: string;
+    private secrets;
+    private configParameters;
+    private secretParameters;
+    constructor(scope: constructs.Construct, props: ConfigureParametersProps);
+    grantRead(grantable: iam.IGrantable & constructs.IConstruct): void;
+    /**
+     * Produce a checksum-value that can be used as a kind of
+     * nonce to trigger redeployment on parameter changes.
+     *
+     * Note: If the parameter references a token no change will be visible,
+     * and a manual redeployment might be needed.
+     */
+    get hashValue(): string;
+}

package/lib/configure-parameters/configure-parameters.js

@@ -0,0 +1,94 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConfigureParameters = void 0;
+const iam = require("aws-cdk-lib/aws-iam");
+const secretsmanager = require("aws-cdk-lib/aws-secretsmanager");
+const ssm = require("aws-cdk-lib/aws-ssm");
+const cdk = require("aws-cdk-lib");
+const crypto = require("crypto");
+class ConfigureParameters {
+    constructor(scope, props) {
+        if (!props.ssmPrefix.startsWith("/") || props.ssmPrefix.endsWith("/")) {
+            throw new Error("ssmPrefix should start with '/' and end without '/'");
+        }
+        this.ssmPrefix = props.ssmPrefix;
+        this.configParameters = [];
+        this.secretParameters = [];
+        for (const parameter of props.parameters) {
+            if ("value" in parameter) {
+                this.configParameters.push(parameter);
+            }
+            else if ("secret" in parameter) {
+                this.secretParameters.push(parameter);
+            }
+            else if ("secretName" in parameter) {
+                this.secretParameters.push({
+                    key: parameter.key,
+                    secret: secretsmanager.Secret.fromSecretNameV2(scope, `SecretRef${parameter.key}`, parameter.secretName),
+                });
+            }
+        }
+        const result = [];
+        this.configParameters.forEach((it) => {
+            const param = new ssm.StringParameter(scope, `Config${it.key}`, {
+                stringValue: it.value,
+                parameterName: `${this.ssmPrefix}/config/${it.key}`,
+            });
+            result.push(param);
+        });
+        this.secretParameters.forEach((it) => {
+            const param = new ssm.StringParameter(scope, `Secret${it.key}`, {
+                stringValue: it.secret.secretArn,
+                parameterName: `${this.ssmPrefix}/secrets/${it.key}`,
+            });
+            result.push(param);
+        });
+        this.secrets = this.secretParameters.map((it) => it.secret);
+        this.parameters = result;
+    }
+    grantRead(grantable) {
+        grantable.grantPrincipal.addToPrincipalPolicy(new iam.PolicyStatement({
+            effect: iam.Effect.ALLOW,
+            actions: ["ssm:GetParametersByPath"],
+            resources: [
+                `arn:aws:ssm:${cdk.Stack.of(grantable).region}:${cdk.Stack.of(grantable).account}:parameter${this.ssmPrefix}/*`,
+            ],
+        }));
+        for (const secret of this.secrets) {
+            secret.grantRead(grantable);
+        }
+    }
+    /**
+     * Produce a checksum-value that can be used as a kind of
+     * nonce to trigger redeployment on parameter changes.
+     *
+     * Note: If the parameter references a token no change will be visible,
+     * and a manual redeployment might be needed.
+     */
+    get hashValue() {
+        const hash = crypto.createHash("sha256");
+        if (this.configParameters) {
+            this.configParameters.forEach((it) => {
+                hash.update("|");
+                hash.update(it.key);
+                hash.update("|");
+                if (!cdk.Token.isUnresolved(it.value)) {
+                    hash.update(it.value);
+                }
+            });
+        }
+        if (this.secretParameters) {
+            this.secretParameters.forEach((it) => {
+                hash.update("|");
+                hash.update(it.key);
+                hash.update("|");
+                if (!cdk.Token.isUnresolved(it.secret.secretArn)) {
+                    hash.update(it.secret.secretArn);
+                }
+            });
+        }
+        return hash.digest("hex");
+    }
+}
+exports.ConfigureParameters = ConfigureParameters;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"configure-parameters.js","sourceRoot":"","sources":["../../src/configure-parameters/configure-parameters.ts"],"names":[],"mappings":";;;AACA,2CAA0C;AAC1C,iEAAgE;AAChE,2CAA0C;AAC1C,mCAAkC;AAClC,iCAAgC;AAkDhC,MAAa,mBAAmB;IAQ9B,YAAY,KAA2B,EAAE,KAA+B;QACtE,IAAI,CAAC,KAAK,CAAC,SAAS,CAAC,UAAU,CAAC,GAAG,CAAC,IAAI,KAAK,CAAC,SAAS,CAAC,QAAQ,CAAC,GAAG,CAAC,EAAE,CAAC;YACtE,MAAM,IAAI,KAAK,CAAC,qDAAqD,CAAC,CAAA;QACxE,CAAC;QAED,IAAI,CAAC,SAAS,GAAG,KAAK,CAAC,SAAS,CAAA;QAEhC,IAAI,CAAC,gBAAgB,GAAG,EAAE,CAAA;QAC1B,IAAI,CAAC,gBAAgB,GAAG,EAAE,CAAA;QAE1B,KAAK,MAAM,SAAS,IAAI,KAAK,CAAC,UAAU,EAAE,CAAC;YACzC,IAAI,OAAO,IAAI,SAAS,EAAE,CAAC;gBACzB,IAAI,CAAC,gBAAgB,CAAC,IAAI,CAAC,SAAS,CAAC,CAAA;YACvC,CAAC;iBAAM,IAAI,QAAQ,IAAI,SAAS,EAAE,CAAC;gBACjC,IAAI,CAAC,gBAAgB,CAAC,IAAI,CAAC,SAAS,CAAC,CAAA;YACvC,CAAC;iBAAM,IAAI,YAAY,IAAI,SAAS,EAAE,CAAC;gBACrC,IAAI,CAAC,gBAAgB,CAAC,IAAI,CAAC;oBACzB,GAAG,EAAE,SAAS,CAAC,GAAG;oBAClB,MAAM,EAAE,cAAc,CAAC,MAAM,CAAC,gBAAgB,CAC5C,KAAK,EACL,YAAY,SAAS,CAAC,GAAG,EAAE,EAC3B,SAAS,CAAC,UAAU,CACrB;iBACF,CAAC,CAAA;YACJ,CAAC;QACH,CAAC;QAED,MAAM,MAAM,GAAqB,EAAE,CAAA;QAEnC,IAAI,CAAC,gBAAgB,CAAC,OAAO,CAAC,CAAC,EAAE,EAAE,EAAE;YACnC,MAAM,KAAK,GAAG,IAAI,GAAG,CAAC,eAAe,CAAC,KAAK,EAAE,SAAS,EAAE,CAAC,GAAG,EAAE,EAAE;gBAC9D,WAAW,EAAE,EAAE,CAAC,KAAK;gBACrB,aAAa,EAAE,GAAG,IAAI,CAAC,SAAS,WAAW,EAAE,CAAC,GAAG,EAAE;aACpD,CAAC,CAAA;YACF,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,CAAA;QACpB,CAAC,CAAC,CAAA;QAEF,IAAI,CAAC,gBAAgB,CAAC,OAAO,CAAC,CAAC,EAAE,EAAE,EAAE;YACnC,MAAM,KAAK,GAAG,IAAI,GAAG,CAAC,eAAe,CAAC,KAAK,EAAE,SAAS,EAAE,CAAC,GAAG,EAAE,EAAE;gBAC9D,WAAW,EAAE,EAAE,CAAC,MAAM,CAAC,SAAS;gBAChC,aAAa,EAAE,GAAG,IAAI,CAAC,SAAS,YAAY,EAAE,CAAC,GAAG,EAAE;aACrD,CAAC,CAAA;YACF,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,CAAA;QACpB,CAAC,CAAC,CAAA;QAEF,IAAI,CAAC,OAAO,GAAG,IAAI,CAAC,gBAAgB,CAAC,GAAG,CAAC,CAAC,EAAE,EAAE,EAAE,CAAC,EAAE,CAAC,MAAM,CAAC,CAAA;QAE3D,IAAI,CAAC,UAAU,GAAG,MAAM,CAAA;IAC1B,CAAC;IAED,SAAS,CAAC,SAAiD;QACzD,SAAS,CAAC,cAAc,CAAC,oBAAoB,CAC3C,IAAI,GAAG,CAAC,eAAe,CAAC;YACtB,MAAM,EAAE,GAAG,CAAC,MAAM,CAAC,KAAK;YACxB,OAAO,EAAE,CAAC,yBAAyB,CAAC;YACpC,SAAS,EAAE;gBACT,eAAe,GAAG,CAAC,KAAK,CAAC,EAAE,CAAC,SAAS,CAAC,CAAC,MAAM,IAC3C,GAAG,CAAC,KAAK,CAAC,EAAE,CAAC,SAAS,CAAC,CAAC,OAC1B,aAAa,IAAI,CAAC,SAAS,IAAI;aAChC;SACF,CAAC,CACH,CAAA;QAED,KAAK,MAAM,MAAM,IAAI,IAAI,CAAC,OAAO,EAAE,CAAC;YAClC,MAAM,CAAC,SAAS,CAAC,SAAS,CAAC,CAAA;QAC7B,CAAC;IACH,CAAC;IAED;;;;;;OAMG;IACH,IAAI,SAAS;QACX,MAAM,IAAI,GAAG,MAAM,CAAC,UAAU,CAAC,QAAQ,CAAC,CAAA;QAExC,IAAI,IAAI,CAAC,gBAAgB,EAAE,CAAC;YAC1B,IAAI,CAAC,gBAAgB,CAAC,OAAO,CAAC,CAAC,EAAE,EAAE,EAAE;gBACnC,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,CAAA;gBAChB,IAAI,CAAC,MAAM,CAAC,EAAE,CAAC,GAAG,CAAC,CAAA;gBACnB,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,CAAA;gBAEhB,IAAI,CAAC,GAAG,CAAC,KAAK,CAAC,YAAY,CAAC,EAAE,CAAC,KAAK,CAAC,EAAE,CAAC;oBACtC,IAAI,CAAC,MAAM,CAAC,EAAE,CAAC,KAAK,CAAC,CAAA;gBACvB,CAAC;YACH,CAAC,CAAC,CAAA;QACJ,CAAC;QAED,IAAI,IAAI,CAAC,gBAAgB,EAAE,CAAC;YAC1B,IAAI,CAAC,gBAAgB,CAAC,OAAO,CAAC,CAAC,EAAE,EAAE,EAAE;gBACnC,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,CAAA;gBAChB,IAAI,CAAC,MAAM,CAAC,EAAE,CAAC,GAAG,CAAC,CAAA;gBACnB,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,CAAA;gBAEhB,IAAI,CAAC,GAAG,CAAC,KAAK,CAAC,YAAY,CAAC,EAAE,CAAC,MAAM,CAAC,SAAS,CAAC,EAAE,CAAC;oBACjD,IAAI,CAAC,MAAM,CAAC,EAAE,CAAC,MAAM,CAAC,SAAS,CAAC,CAAA;gBAClC,CAAC;YACH,CAAC,CAAC,CAAA;QACJ,CAAC;QAED,OAAO,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,CAAA;IAC3B,CAAC;CACF;AAhHD,kDAgHC","sourcesContent":["import * as constructs from \"constructs\"\nimport * as iam from \"aws-cdk-lib/aws-iam\"\nimport * as secretsmanager from \"aws-cdk-lib/aws-secretsmanager\"\nimport * as ssm from \"aws-cdk-lib/aws-ssm\"\nimport * as cdk from \"aws-cdk-lib\"\nimport * as crypto from \"crypto\"\n\n/**\n * A plain text application parameter that will be stored\n * in AWS Parameter Store. Only used for non-sensitive values,\n * typically those commited directly in the IaC code.\n */\nexport interface PlainTextParameter {\n  key: string\n  value: string\n}\n\n/**\n * An AWS Secret that should hold a JSON object.\n *\n * This will provide a secret that liflig-properties can read. The final\n * parameter seen by the application will be the key given here and the\n * keys from the secret JSON object appended.\n */\nexport interface SecretParameter {\n  key: string\n  secret: secretsmanager.ISecret\n}\n\n/**\n * An AWS Secret that should hold a JSON object.\n *\n * This will provide a secret that liflig-properties can read. The final\n * parameter seen by the application will be the key given here and the\n * keys from the secret JSON object appended.\n */\nexport interface SecretByNameParameter {\n  key: string\n  secretName: string\n}\n\nexport type Parameter =\n  | PlainTextParameter\n  | SecretParameter\n  | SecretByNameParameter\n\nexport interface ConfigureParametersProps {\n  /**\n   * Prefix used for parameter names.\n   * Should start with '/' and end without '/'.\n   */\n  ssmPrefix: string\n  parameters: Parameter[]\n}\n\nexport class ConfigureParameters {\n  public parameters: ssm.IParameter[]\n  public ssmPrefix: string\n  private secrets: secretsmanager.ISecret[]\n\n  private configParameters: PlainTextParameter[]\n  private secretParameters: SecretParameter[]\n\n  constructor(scope: constructs.Construct, props: ConfigureParametersProps) {\n    if (!props.ssmPrefix.startsWith(\"/\") || props.ssmPrefix.endsWith(\"/\")) {\n      throw new Error(\"ssmPrefix should start with '/' and end without '/'\")\n    }\n\n    this.ssmPrefix = props.ssmPrefix\n\n    this.configParameters = []\n    this.secretParameters = []\n\n    for (const parameter of props.parameters) {\n      if (\"value\" in parameter) {\n        this.configParameters.push(parameter)\n      } else if (\"secret\" in parameter) {\n        this.secretParameters.push(parameter)\n      } else if (\"secretName\" in parameter) {\n        this.secretParameters.push({\n          key: parameter.key,\n          secret: secretsmanager.Secret.fromSecretNameV2(\n            scope,\n            `SecretRef${parameter.key}`,\n            parameter.secretName,\n          ),\n        })\n      }\n    }\n\n    const result: ssm.IParameter[] = []\n\n    this.configParameters.forEach((it) => {\n      const param = new ssm.StringParameter(scope, `Config${it.key}`, {\n        stringValue: it.value,\n        parameterName: `${this.ssmPrefix}/config/${it.key}`,\n      })\n      result.push(param)\n    })\n\n    this.secretParameters.forEach((it) => {\n      const param = new ssm.StringParameter(scope, `Secret${it.key}`, {\n        stringValue: it.secret.secretArn,\n        parameterName: `${this.ssmPrefix}/secrets/${it.key}`,\n      })\n      result.push(param)\n    })\n\n    this.secrets = this.secretParameters.map((it) => it.secret)\n\n    this.parameters = result\n  }\n\n  grantRead(grantable: iam.IGrantable & constructs.IConstruct): void {\n    grantable.grantPrincipal.addToPrincipalPolicy(\n      new iam.PolicyStatement({\n        effect: iam.Effect.ALLOW,\n        actions: [\"ssm:GetParametersByPath\"],\n        resources: [\n          `arn:aws:ssm:${cdk.Stack.of(grantable).region}:${\n            cdk.Stack.of(grantable).account\n          }:parameter${this.ssmPrefix}/*`,\n        ],\n      }),\n    )\n\n    for (const secret of this.secrets) {\n      secret.grantRead(grantable)\n    }\n  }\n\n  /**\n   * Produce a checksum-value that can be used as a kind of\n   * nonce to trigger redeployment on parameter changes.\n   *\n   * Note: If the parameter references a token no change will be visible,\n   * and a manual redeployment might be needed.\n   */\n  get hashValue(): string {\n    const hash = crypto.createHash(\"sha256\")\n\n    if (this.configParameters) {\n      this.configParameters.forEach((it) => {\n        hash.update(\"|\")\n        hash.update(it.key)\n        hash.update(\"|\")\n\n        if (!cdk.Token.isUnresolved(it.value)) {\n          hash.update(it.value)\n        }\n      })\n    }\n\n    if (this.secretParameters) {\n      this.secretParameters.forEach((it) => {\n        hash.update(\"|\")\n        hash.update(it.key)\n        hash.update(\"|\")\n\n        if (!cdk.Token.isUnresolved(it.secret.secretArn)) {\n          hash.update(it.secret.secretArn)\n        }\n      })\n    }\n\n    return hash.digest(\"hex\")\n  }\n}\n"]}

package/lib/configure-parameters/index.d.ts

@@ -0,0 +1 @@
+export { ConfigureParameters, ConfigureParametersProps, PlainTextParameter, SecretParameter, SecretByNameParameter, Parameter, } from "./configure-parameters";

package/lib/configure-parameters/index.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConfigureParameters = void 0;
+var configure_parameters_1 = require("./configure-parameters");
+Object.defineProperty(exports, "ConfigureParameters", { enumerable: true, get: function () { return configure_parameters_1.ConfigureParameters; } });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvY29uZmlndXJlLXBhcmFtZXRlcnMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7O0FBQUEsK0RBTytCO0FBTjdCLDJIQUFBLG1CQUFtQixPQUFBIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0IHtcbiAgQ29uZmlndXJlUGFyYW1ldGVycyxcbiAgQ29uZmlndXJlUGFyYW1ldGVyc1Byb3BzLFxuICBQbGFpblRleHRQYXJhbWV0ZXIsXG4gIFNlY3JldFBhcmFtZXRlcixcbiAgU2VjcmV0QnlOYW1lUGFyYW1ldGVyLFxuICBQYXJhbWV0ZXIsXG59IGZyb20gXCIuL2NvbmZpZ3VyZS1wYXJhbWV0ZXJzXCJcbiJdfQ==

package/lib/cross-region-ssm-parameter.d.ts

@@ -0,0 +1,13 @@
+import * as constructs from "constructs";
+interface Props {
+    region: string;
+    name: string;
+    value: string;
+}
+/**
+ * SSM Parameter stored in another region.
+ */
+export declare class CrossRegionSsmParameter extends constructs.Construct {
+    constructor(scope: constructs.Construct, id: string, props: Props);
+}
+export {};

package/lib/cross-region-ssm-parameter.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CrossRegionSsmParameter = void 0;
+const constructs = require("constructs");
+const cr = require("aws-cdk-lib/custom-resources");
+/**
+ * SSM Parameter stored in another region.
+ */
+class CrossRegionSsmParameter extends constructs.Construct {
+    constructor(scope, id, props) {
+        super(scope, id);
+        const physicalResourceId = cr.PhysicalResourceId.of(props.name);
+        // TODO: Can we somehow propagate tags as well?
+        new cr.AwsCustomResource(this, "Resoure", {
+            onUpdate: {
+                service: "SSM",
+                action: "putParameter",
+                parameters: {
+                    Name: props.name,
+                    Value: props.value,
+                    Type: "String",
+                    Overwrite: true,
+                },
+                region: props.region,
+                physicalResourceId,
+            },
+            onDelete: {
+                service: "SSM",
+                action: "deleteParameter",
+                parameters: {
+                    Name: props.name,
+                },
+                region: props.region,
+                physicalResourceId,
+            },
+            policy: cr.AwsCustomResourcePolicy.fromSdkCalls({
+                // We grant the Custom Resource access to write to any
+                // parameter, as this is needed to be able to rename
+                // a parameter later.
+                resources: cr.AwsCustomResourcePolicy.ANY_RESOURCE,
+            }),
+        });
+    }
+}
+exports.CrossRegionSsmParameter = CrossRegionSsmParameter;
+//# sourceMappingURL=data:application/json;base64,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

package/lib/ecs/cluster.d.ts

@@ -0,0 +1,25 @@
+import * as constructs from "constructs";
+import * as cloudwatch from "aws-cdk-lib/aws-cloudwatch";
+import * as ec2 from "aws-cdk-lib/aws-ec2";
+import * as ecs from "aws-cdk-lib/aws-ecs";
+import * as logs from "aws-cdk-lib/aws-logs";
+export interface ClusterProps {
+    /**
+     * @default will be generated
+     */
+    clusterName?: string;
+    vpc: ec2.IVpc;
+    /**
+     * @default no alarms will be set up
+     */
+    alarmAction?: cloudwatch.IAlarmAction;
+}
+export declare class Cluster extends constructs.Construct {
+    readonly cluster: ecs.Cluster;
+    readonly clusterEventLogs: logs.LogGroup;
+    constructor(scope: constructs.Construct, id: string, props: ClusterProps);
+    /**
+     * Monitor high number of restarts which typically signal a failing task.
+     */
+    private addRestartFrequencyAlarm;
+}

package/lib/ecs/cluster.js

@@ -0,0 +1,70 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Cluster = void 0;
+const constructs = require("constructs");
+const cloudwatch = require("aws-cdk-lib/aws-cloudwatch");
+const ecs = require("aws-cdk-lib/aws-ecs");
+const events = require("aws-cdk-lib/aws-events");
+const targets = require("aws-cdk-lib/aws-events-targets");
+const logs = require("aws-cdk-lib/aws-logs");
+const cdk = require("aws-cdk-lib");
+class Cluster extends constructs.Construct {
+    constructor(scope, id, props) {
+        super(scope, id);
+        this.cluster = new ecs.Cluster(this, "Resource", {
+            clusterName: props.clusterName,
+            vpc: props.vpc,
+            executeCommandConfiguration: {
+                // The default would log to the same awslogs setup as
+                // the tasks, which would produce different types of
+                // outputs in the same log group.
+                // We have not set up specific logging for this.
+                logging: ecs.ExecuteCommandLogging.NONE,
+            },
+        });
+        // The details in ECS console is available only for short time,
+        // so we store it to S3 to improve insight.
+        this.clusterEventLogs = new logs.LogGroup(this, "EventLogs", {
+            retention: logs.RetentionDays.ONE_MONTH,
+            removalPolicy: cdk.RemovalPolicy.DESTROY,
+        });
+        new events.Rule(this, "StateRule", {
+            eventPattern: {
+                source: ["aws.ecs"],
+                detail: {
+                    clusterArn: [this.cluster.clusterArn],
+                },
+            },
+            targets: [new targets.CloudWatchLogGroup(this.clusterEventLogs)],
+        });
+        if (props.alarmAction) {
+            this.addRestartFrequencyAlarm(props.alarmAction);
+        }
+    }
+    /**
+     * Monitor high number of restarts which typically signal a failing task.
+     */
+    addRestartFrequencyAlarm(action) {
+        const errorMetricFilter = this.clusterEventLogs.addMetricFilter("ProvisioningErrorMetricFilter", {
+            filterPattern: logs.FilterPattern.all(logs.FilterPattern.stringValue("$.detail-type", "=", "ECS Task State Change"), logs.FilterPattern.stringValue("$.detail.lastStatus", "=", "PROVISIONING")),
+            metricName: "Provisioning",
+            metricNamespace: `ECS/Cluster/${this.cluster.clusterName}`,
+        });
+        const alarm = errorMetricFilter
+            .metric()
+            .with({
+            statistic: "Sum",
+            period: cdk.Duration.minutes(10),
+        })
+            .createAlarm(this, "RestartFrequencyAlarm", {
+            alarmDescription: `Tasks in ${this.cluster.clusterName} is frequently provisioning`,
+            evaluationPeriods: 1,
+            threshold: 25,
+            treatMissingData: cloudwatch.TreatMissingData.NOT_BREACHING,
+        });
+        alarm.addAlarmAction(action);
+        alarm.addOkAction(action);
+    }
+}
+exports.Cluster = Cluster;
+//# sourceMappingURL=data:application/json;base64,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