rds-database-auto-start-preventer 0.1.1

package/lib/constructs/rds-database-auto-start-preventer.d.ts

@@ -0,0 +1,42 @@
+import { Construct } from 'constructs';
+/**
+ * Tag-based criteria to select which RDS instances or clusters are subject to auto-start prevention.
+ */
+export interface TargetResource {
+    /** Tag key to match (e.g. "Environment", "AutoStartPrevent"). */
+    readonly tagKey: string;
+    /** Tag values that indicate the resource should be protected (e.g. ["production"]). */
+    readonly tagValues: string[];
+}
+/**
+ * External secrets required for notifications (e.g. Slack).
+ */
+export interface Secrets {
+    /** Name of the Secrets Manager secret containing Slack token and channel. */
+    readonly slackSecretName: string;
+}
+/**
+ * Props for the RDS database auto-start preventer construct.
+ */
+export interface RDSDatabaseAutoStartPreventerProps {
+    /** Tag-based target resource criteria for RDS instances/clusters to protect. */
+    readonly targetResource: TargetResource;
+    /** Whether the EventBridge rules are enabled. Defaults to true if omitted. */
+    readonly enableRule?: boolean;
+    /** Secrets used for notifications (e.g. Slack). */
+    readonly secrets: Secrets;
+}
+/**
+ * Construct that deploys EventBridge rules and a Durable Lambda to prevent RDS DB instances
+ * and clusters from staying running after an auto-start event (RDS-EVENT-0154 / RDS-EVENT-0153).
+ */
+export declare class RDSDatabaseAutoStartPreventer extends Construct {
+    /**
+     * Creates the construct: Lambda (with Params and Secrets), EventBridge rules, and IAM.
+     *
+     * @param scope - Parent construct.
+     * @param id - Construct id.
+     * @param props - Target resource (tag key/values), enable rule flag, and secrets.
+     */
+    constructor(scope: Construct, id: string, props: RDSDatabaseAutoStartPreventerProps);
+}

package/lib/constructs/rds-database-auto-start-preventer.js

@@ -0,0 +1,141 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RDSDatabaseAutoStartPreventer = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+const aws_cdk_lib_1 = require("aws-cdk-lib");
+const events = require("aws-cdk-lib/aws-events");
+const targets = require("aws-cdk-lib/aws-events-targets");
+const iam = require("aws-cdk-lib/aws-iam");
+const lambda = require("aws-cdk-lib/aws-lambda");
+const logs = require("aws-cdk-lib/aws-logs");
+const aws_secretsmanager_1 = require("aws-cdk-lib/aws-secretsmanager");
+const constructs_1 = require("constructs");
+const auto_start_prevent_function_1 = require("../funcs/auto-start-prevent-function");
+/**
+ * Construct that deploys EventBridge rules and a Durable Lambda to prevent RDS DB instances
+ * and clusters from staying running after an auto-start event (RDS-EVENT-0154 / RDS-EVENT-0153).
+ */
+class RDSDatabaseAutoStartPreventer extends constructs_1.Construct {
+    /**
+     * Creates the construct: Lambda (with Params and Secrets), EventBridge rules, and IAM.
+     *
+     * @param scope - Parent construct.
+     * @param id - Construct id.
+     * @param props - Target resource (tag key/values), enable rule flag, and secrets.
+     */
+    constructor(scope, id, props) {
+        super(scope, id);
+        const slackSecret = aws_secretsmanager_1.Secret.fromSecretNameV2(this, 'SlackSecret', props.secrets.slackSecretName);
+        // Durable Functions-based Running Scheduler (previous Step Functions logic implemented in Lambda).
+        // Durable Execution requires Node.js 22+.
+        const autoStartPreventFunction = new auto_start_prevent_function_1.AutoStartPreventFunction(this, 'AutoStartPreventFunction', {
+            description: 'A function to prevent the RDS Database or Cluster from starting automatically.',
+            architecture: lambda.Architecture.ARM_64,
+            timeout: aws_cdk_lib_1.Duration.minutes(15),
+            memorySize: 512,
+            retryAttempts: 2,
+            durableConfig: {
+                executionTimeout: aws_cdk_lib_1.Duration.hours(2),
+                retentionPeriod: aws_cdk_lib_1.Duration.days(1),
+            },
+            environment: {
+                SLACK_SECRET_NAME: slackSecret.secretName,
+            },
+            paramsAndSecrets: lambda.ParamsAndSecretsLayerVersion.fromVersion(lambda.ParamsAndSecretsVersions.V1_0_103, {
+                cacheSize: 500,
+                logLevel: lambda.ParamsAndSecretsLogLevel.INFO,
+            }),
+            role: new iam.Role(this, 'AutoStartPreventFunctionRole', {
+                description: 'A role to control the RDS Database or Cluster.',
+                assumedBy: new iam.ServicePrincipal('lambda.amazonaws.com'),
+                managedPolicies: [
+                    iam.ManagedPolicy.fromAwsManagedPolicyName('service-role/AWSLambdaBasicExecutionRole'),
+                    iam.ManagedPolicy.fromAwsManagedPolicyName('service-role/AWSLambdaBasicDurableExecutionRolePolicy'),
+                ],
+            }),
+            logGroup: new logs.LogGroup(this, 'AutoStartPreventFunctionLogGroup', {
+                retention: logs.RetentionDays.THREE_MONTHS,
+                removalPolicy: aws_cdk_lib_1.RemovalPolicy.DESTROY,
+            }),
+            loggingFormat: lambda.LoggingFormat.JSON,
+            systemLogLevelV2: lambda.SystemLogLevel.INFO,
+            applicationLogLevelV2: lambda.ApplicationLogLevel.INFO,
+        });
+        autoStartPreventFunction.addToRolePolicy(new iam.PolicyStatement({
+            sid: 'GetResources',
+            effect: iam.Effect.ALLOW,
+            actions: [
+                'tag:GetResources',
+            ],
+            resources: ['*'],
+        }));
+        // Grant read access to the RDS API
+        autoStartPreventFunction.addToRolePolicy(new iam.PolicyStatement({
+            sid: 'RdsAutoStartControl',
+            effect: iam.Effect.ALLOW,
+            actions: [
+                'rds:DescribeDBInstances',
+                'rds:DescribeDBClusters',
+                'rds:StopDBInstance',
+                'rds:StopDBCluster',
+            ],
+            resources: ['*'],
+        }));
+        // Grant read access to the Slack secret
+        slackSecret.grantRead(autoStartPreventFunction);
+        // See: https://docs.aws.amazon.com/lambda/latest/dg/durable-getting-started-iac.html
+        const autoStartPreventFunctionAlias = autoStartPreventFunction.addAlias('live');
+        const enableRule = (() => {
+            return props.enableRule === undefined || props.enableRule;
+        })();
+        // Convert the rule input to pass { event, params } to the Lambda (tag conditions are injected by the Rule).
+        const lambdaInput = events.RuleTargetInput.fromObject({
+            event: events.EventField.fromPath('$'),
+            params: {
+                tagKey: props.targetResource.tagKey,
+                tagValues: props.targetResource.tagValues,
+            },
+        });
+        // 👇 EventBridge by RDS DB Instance auto start event
+        new events.Rule(this, 'DBInstanceEvent', {
+            description: 'rds db instance auto start event catch rule.',
+            enabled: enableRule,
+            eventPattern: {
+                source: ['aws.rds'],
+                detailType: ['RDS DB Instance Event'],
+                detail: {
+                    EventID: ['RDS-EVENT-0154'],
+                },
+            },
+            targets: [
+                new targets.LambdaFunction(autoStartPreventFunctionAlias, {
+                    retryAttempts: 2,
+                    event: lambdaInput,
+                }),
+            ],
+        });
+        // 👇 EventBridge by RDS DB Cluster auto start event
+        new events.Rule(this, 'DBClusterEvent', {
+            description: 'db cluster auto start event catch rule',
+            enabled: enableRule,
+            eventPattern: {
+                source: ['aws.rds'],
+                detailType: ['RDS DB Cluster Event'],
+                detail: {
+                    EventID: ['RDS-EVENT-0153'],
+                },
+            },
+            targets: [
+                new targets.LambdaFunction(autoStartPreventFunctionAlias, {
+                    retryAttempts: 2,
+                    event: lambdaInput,
+                }),
+            ],
+        });
+    }
+}
+exports.RDSDatabaseAutoStartPreventer = RDSDatabaseAutoStartPreventer;
+_a = JSII_RTTI_SYMBOL_1;
+RDSDatabaseAutoStartPreventer[_a] = { fqn: "rds-database-auto-start-preventer.RDSDatabaseAutoStartPreventer", version: "0.1.1" };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"rds-database-auto-start-preventer.js","sourceRoot":"","sources":["../../src/constructs/rds-database-auto-start-preventer.ts"],"names":[],"mappings":"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","sourcesContent":["import { Duration, RemovalPolicy } from 'aws-cdk-lib';\nimport * as events from 'aws-cdk-lib/aws-events';\nimport * as targets from 'aws-cdk-lib/aws-events-targets';\nimport * as iam from 'aws-cdk-lib/aws-iam';\nimport * as lambda from 'aws-cdk-lib/aws-lambda';\nimport * as logs from 'aws-cdk-lib/aws-logs';\nimport { Secret } from 'aws-cdk-lib/aws-secretsmanager';\nimport { Construct } from 'constructs';\nimport { AutoStartPreventFunction } from '../funcs/auto-start-prevent-function';\n\n/**\n * Tag-based criteria to select which RDS instances or clusters are subject to auto-start prevention.\n */\nexport interface TargetResource {\n  /** Tag key to match (e.g. \"Environment\", \"AutoStartPrevent\"). */\n  readonly tagKey: string;\n  /** Tag values that indicate the resource should be protected (e.g. [\"production\"]). */\n  readonly tagValues: string[];\n}\n\n/**\n * External secrets required for notifications (e.g. Slack).\n */\nexport interface Secrets {\n  /** Name of the Secrets Manager secret containing Slack token and channel. */\n  readonly slackSecretName: string;\n}\n\n/**\n * Props for the RDS database auto-start preventer construct.\n */\nexport interface RDSDatabaseAutoStartPreventerProps {\n  /** Tag-based target resource criteria for RDS instances/clusters to protect. */\n  readonly targetResource: TargetResource;\n  /** Whether the EventBridge rules are enabled. Defaults to true if omitted. */\n  readonly enableRule?: boolean;\n  /** Secrets used for notifications (e.g. Slack). */\n  readonly secrets: Secrets;\n}\n\n/**\n * Construct that deploys EventBridge rules and a Durable Lambda to prevent RDS DB instances\n * and clusters from staying running after an auto-start event (RDS-EVENT-0154 / RDS-EVENT-0153).\n */\nexport class RDSDatabaseAutoStartPreventer extends Construct {\n\n  /**\n   * Creates the construct: Lambda (with Params and Secrets), EventBridge rules, and IAM.\n   *\n   * @param scope - Parent construct.\n   * @param id - Construct id.\n   * @param props - Target resource (tag key/values), enable rule flag, and secrets.\n   */\n  constructor(scope: Construct, id: string, props: RDSDatabaseAutoStartPreventerProps) {\n    super(scope, id);\n\n    const slackSecret = Secret.fromSecretNameV2(this, 'SlackSecret', props.secrets.slackSecretName);\n\n    // Durable Functions-based Running Scheduler (previous Step Functions logic implemented in Lambda).\n    // Durable Execution requires Node.js 22+.\n    const autoStartPreventFunction = new AutoStartPreventFunction(this, 'AutoStartPreventFunction', {\n      description: 'A function to prevent the RDS Database or Cluster from starting automatically.',\n      architecture: lambda.Architecture.ARM_64,\n      timeout: Duration.minutes(15),\n      memorySize: 512,\n      retryAttempts: 2,\n      durableConfig: {\n        executionTimeout: Duration.hours(2),\n        retentionPeriod: Duration.days(1),\n      },\n      environment: {\n        SLACK_SECRET_NAME: slackSecret.secretName,\n      },\n      paramsAndSecrets: lambda.ParamsAndSecretsLayerVersion.fromVersion(lambda.ParamsAndSecretsVersions.V1_0_103, {\n        cacheSize: 500,\n        logLevel: lambda.ParamsAndSecretsLogLevel.INFO,\n      }),\n      role: new iam.Role(this, 'AutoStartPreventFunctionRole', {\n        description: 'A role to control the RDS Database or Cluster.',\n        assumedBy: new iam.ServicePrincipal('lambda.amazonaws.com'),\n        managedPolicies: [\n          iam.ManagedPolicy.fromAwsManagedPolicyName('service-role/AWSLambdaBasicExecutionRole'),\n          iam.ManagedPolicy.fromAwsManagedPolicyName('service-role/AWSLambdaBasicDurableExecutionRolePolicy'),\n        ],\n      }),\n      logGroup: new logs.LogGroup(this, 'AutoStartPreventFunctionLogGroup', {\n        retention: logs.RetentionDays.THREE_MONTHS,\n        removalPolicy: RemovalPolicy.DESTROY,\n      }),\n      loggingFormat: lambda.LoggingFormat.JSON,\n      systemLogLevelV2: lambda.SystemLogLevel.INFO,\n      applicationLogLevelV2: lambda.ApplicationLogLevel.INFO,\n    });\n    autoStartPreventFunction.addToRolePolicy(new iam.PolicyStatement({\n      sid: 'GetResources',\n      effect: iam.Effect.ALLOW,\n      actions: [\n        'tag:GetResources',\n      ],\n      resources: ['*'],\n    }));\n    // Grant read access to the RDS API\n    autoStartPreventFunction.addToRolePolicy(new iam.PolicyStatement({\n      sid: 'RdsAutoStartControl',\n      effect: iam.Effect.ALLOW,\n      actions: [\n        'rds:DescribeDBInstances',\n        'rds:DescribeDBClusters',\n        'rds:StopDBInstance',\n        'rds:StopDBCluster',\n      ],\n      resources: ['*'],\n    }));\n    // Grant read access to the Slack secret\n    slackSecret.grantRead(autoStartPreventFunction);\n\n    // See: https://docs.aws.amazon.com/lambda/latest/dg/durable-getting-started-iac.html\n    const autoStartPreventFunctionAlias = autoStartPreventFunction.addAlias('live');\n\n    const enableRule: boolean = (() => {\n      return props.enableRule === undefined || props.enableRule;\n    })();\n\n    // Convert the rule input to pass { event, params } to the Lambda (tag conditions are injected by the Rule).\n    const lambdaInput = events.RuleTargetInput.fromObject({\n      event: events.EventField.fromPath('$'),\n      params: {\n        tagKey: props.targetResource.tagKey,\n        tagValues: props.targetResource.tagValues,\n      },\n    });\n\n    // 👇 EventBridge by RDS DB Instance auto start event\n    new events.Rule(this, 'DBInstanceEvent', {\n      description: 'rds db instance auto start event catch rule.',\n      enabled: enableRule,\n      eventPattern: {\n        source: ['aws.rds'],\n        detailType: ['RDS DB Instance Event'],\n        detail: {\n          EventID: ['RDS-EVENT-0154'],\n        },\n      },\n      targets: [\n        new targets.LambdaFunction(autoStartPreventFunctionAlias, {\n          retryAttempts: 2,\n          event: lambdaInput,\n        }),\n      ],\n    });\n\n    // 👇 EventBridge by RDS DB Cluster auto start event\n    new events.Rule(this, 'DBClusterEvent', {\n      description: 'db cluster auto start event catch rule',\n      enabled: enableRule,\n      eventPattern: {\n        source: ['aws.rds'],\n        detailType: ['RDS DB Cluster Event'],\n        detail: {\n          EventID: ['RDS-EVENT-0153'],\n        },\n      },\n      targets: [\n        new targets.LambdaFunction(autoStartPreventFunctionAlias, {\n          retryAttempts: 2,\n          event: lambdaInput,\n        }),\n      ],\n    });\n  }\n}\n"]}

package/lib/funcs/auto-start-prevent-function.d.ts

@@ -0,0 +1,13 @@
+import * as lambda from 'aws-cdk-lib/aws-lambda';
+import { Construct } from 'constructs';
+/**
+ * Props for AutoStartPreventFunction
+ */
+export interface AutoStartPreventFunctionProps extends lambda.FunctionOptions {
+}
+/**
+ * An AWS Lambda function which executes src/funcs/auto-start-prevent.
+ */
+export declare class AutoStartPreventFunction extends lambda.Function {
+    constructor(scope: Construct, id: string, props?: AutoStartPreventFunctionProps);
+}

package/lib/funcs/auto-start-prevent-function.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AutoStartPreventFunction = void 0;
+// ~~ Generated by projen. To modify, edit .projenrc.ts and run "npx projen".
+const path = require("path");
+const lambda = require("aws-cdk-lib/aws-lambda");
+/**
+ * An AWS Lambda function which executes src/funcs/auto-start-prevent.
+ */
+class AutoStartPreventFunction extends lambda.Function {
+    constructor(scope, id, props) {
+        super(scope, id, {
+            description: 'src/funcs/auto-start-prevent.lambda.ts',
+            ...props,
+            runtime: new lambda.Runtime('nodejs24.x', lambda.RuntimeFamily.NODEJS),
+            handler: 'index.handler',
+            code: lambda.Code.fromAsset(path.join(__dirname, '../../assets/funcs/auto-start-prevent.lambda')),
+        });
+        this.addEnvironment('AWS_NODEJS_CONNECTION_REUSE_ENABLED', '1', { removeInEdge: true });
+    }
+}
+exports.AutoStartPreventFunction = AutoStartPreventFunction;
+//# sourceMappingURL=data:application/json;base64,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

package/lib/funcs/auto-start-prevent.lambda.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Durable Lambda handler: on RDS auto-start events, waits for the resource to become available
+ * (or already stopped), checks tag match, stops the instance/cluster if needed, then posts to Slack.
+ *
+ * @param input - EventBridge event plus params (tagKey, tagValues).
+ * @param context - Durable execution context for steps and waits.
+ * @returns Result with action ('stopped' | 'no-op'), finalStatus, account, region, identifier.
+ */
+export declare const handler: import("@aws/durable-execution-sdk-js").DurableLambdaHandler;

package/lib/funcs/auto-start-prevent.lambda.js

@@ -0,0 +1,255 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handler = void 0;
+const durable_execution_sdk_js_1 = require("@aws/durable-execution-sdk-js");
+const client_rds_1 = require("@aws-sdk/client-rds");
+const web_api_1 = require("@slack/web-api");
+const aws_lambda_secret_fetcher_1 = require("aws-lambda-secret-fetcher");
+/** Detect if the payload is the raw EventBridge event (has detail + detail-type). */
+const isRawEvent = (input) => typeof input === 'object' &&
+    input != null &&
+    'detail' in input &&
+    'detail-type' in input;
+/** Build params from environment (set by CDK from targetResource). */
+const paramsFromEnv = () => {
+    const tagKey = process.env.TAG_KEY;
+    const tagValuesJson = process.env.TAG_VALUES;
+    if (!tagKey || !tagValuesJson) {
+        throw new Error('missing environment variables TAG_KEY or TAG_VALUES.');
+    }
+    let tagValues;
+    try {
+        tagValues = JSON.parse(tagValuesJson);
+    }
+    catch {
+        throw new Error('TAG_VALUES must be a JSON array of strings.');
+    }
+    if (!Array.isArray(tagValues)) {
+        throw new Error('TAG_VALUES must be a JSON array of strings.');
+    }
+    return { tagKey, tagValues };
+};
+/** Normalize invocation input to AutoStartPreventInput (event + params). */
+const normalizeInput = (input) => {
+    if (isRawEvent(input)) {
+        return { event: input, params: paramsFromEnv() };
+    }
+    const candidate = input;
+    if (typeof candidate === 'object' &&
+        candidate != null &&
+        candidate.event != null &&
+        candidate.params != null) {
+        return candidate;
+    }
+    throw new Error('Invalid input: expected RDS event or { event, params }.');
+};
+const rdsClient = new client_rds_1.RDSClient({});
+/** RDS statuses that indicate a transition in progress; we poll every 5 minutes while in these states. */
+const TRANSITIONAL_STATUSES = new Set([
+    'starting',
+    'configuring-enhanced-monitoring',
+    'backing-up',
+    'modifying',
+    'stopping',
+]);
+/**
+ * Returns true if the resource has a tag with the given key and a value in the allowed list.
+ *
+ * @param params - Tag key and allowed values.
+ * @param tags - Resource tag list (e.g. from DescribeDBInstances / DescribeDBClusters).
+ * @returns Whether the tag matches.
+ */
+const matchTag = (params, tags) => {
+    if (!tags || tags.length === 0) {
+        return false;
+    }
+    const value = tags.find(t => t.Key === params.tagKey)?.Value;
+    if (!value) {
+        return false;
+    }
+    return params.tagValues.includes(value);
+};
+/**
+ * Durable Lambda handler: on RDS auto-start events, waits for the resource to become available
+ * (or already stopped), checks tag match, stops the instance/cluster if needed, then posts to Slack.
+ *
+ * @param input - EventBridge event plus params (tagKey, tagValues).
+ * @param context - Durable execution context for steps and waits.
+ * @returns Result with action ('stopped' | 'no-op'), finalStatus, account, region, identifier.
+ */
+exports.handler = (0, durable_execution_sdk_js_1.withDurableExecution)(async (input, context) => {
+    const { event, params } = normalizeInput(input);
+    const { detail, 'detail-type': detailType } = event;
+    const slackSecretName = process.env.SLACK_SECRET_NAME;
+    if (!slackSecretName) {
+        throw new Error('missing environment variable SLACK_SECRET_NAME.');
+    }
+    const slackSecretValue = await context.step('fetch-slack-secret', async () => {
+        return aws_lambda_secret_fetcher_1.secretFetcher.getSecretValue(slackSecretName);
+    });
+    if (!slackSecretValue?.token || !slackSecretValue?.channel) {
+        throw new Error('Slack secret must contain token and channel.');
+    }
+    const isInstance = detailType === 'RDS DB Instance Event' &&
+        detail.SourceType === 'DB_INSTANCE' &&
+        detail.EventID === 'RDS-EVENT-0154';
+    const isCluster = detailType === 'RDS DB Cluster Event' &&
+        detail.SourceType === 'CLUSTER' &&
+        detail.EventID === 'RDS-EVENT-0153';
+    if (!isInstance && !isCluster) {
+        throw new Error(`Unsupported event: detail-type=${detailType}, SourceType=${detail.SourceType}, EventID=${detail.EventID}`);
+    }
+    // Step Functions の StartingWait (1 分待つ) に相当
+    await context.wait({ minutes: 1 });
+    // Step Functions の DescribeTypeChoice + TagMatchChoice + StatusChoice の前半に相当
+    const firstDescribe = await context.waitForCondition(async (_state, _ctx) => {
+        if (isInstance) {
+            const res = await rdsClient.send(new client_rds_1.DescribeDBInstancesCommand({
+                DBInstanceIdentifier: detail.SourceIdentifier,
+            }));
+            const db = res.DBInstances?.[0];
+            return {
+                status: db?.DBInstanceStatus ?? 'unknown',
+                identifier: db?.DBInstanceIdentifier ?? detail.SourceIdentifier,
+                tags: (db?.TagList ?? []),
+            };
+        }
+        const res = await rdsClient.send(new client_rds_1.DescribeDBClustersCommand({
+            DBClusterIdentifier: detail.SourceIdentifier,
+        }));
+        const cluster = res.DBClusters?.[0];
+        return {
+            status: cluster?.Status ?? 'unknown',
+            identifier: cluster?.DBClusterIdentifier ?? detail.SourceIdentifier,
+            tags: (cluster?.TagList ?? []),
+        };
+    }, {
+        initialState: {
+            status: 'starting',
+            identifier: detail.SourceIdentifier,
+        },
+        waitStrategy: state => {
+            // ステータスが遷移中であれば 5 分おきにポーリング
+            if (TRANSITIONAL_STATUSES.has(state.status)) {
+                return { shouldContinue: true, delay: { minutes: 5 } };
+            }
+            // available / stopped / その他 → ここで一旦ループ終了し、後続ロジックへ
+            return { shouldContinue: false };
+        },
+    });
+    // タグが存在しない or マッチしない場合は何もせず終了
+    if (!matchTag(params, firstDescribe.tags)) {
+        return {
+            action: 'no-op',
+            reason: 'tag not matched or not found',
+            status: firstDescribe.status,
+        };
+    }
+    let finalStatus = firstDescribe.status;
+    // available の場合は stop API を呼び、その後 stopped になるまで待機
+    if (firstDescribe.status === 'available') {
+        if (isInstance) {
+            await context.step('stop-db-instance', async () => {
+                await rdsClient.send(new client_rds_1.StopDBInstanceCommand({
+                    DBInstanceIdentifier: detail.SourceIdentifier,
+                }));
+            });
+        }
+        else {
+            await context.step('stop-db-cluster', async () => {
+                await rdsClient.send(new client_rds_1.StopDBClusterCommand({
+                    DBClusterIdentifier: detail.SourceIdentifier,
+                }));
+            });
+        }
+        const stopped = await context.waitForCondition(async (_state, _ctx) => {
+            if (isInstance) {
+                const res = await rdsClient.send(new client_rds_1.DescribeDBInstancesCommand({
+                    DBInstanceIdentifier: detail.SourceIdentifier,
+                }));
+                const db = res.DBInstances?.[0];
+                return {
+                    status: db?.DBInstanceStatus ?? 'unknown',
+                    identifier: db?.DBInstanceIdentifier ?? detail.SourceIdentifier,
+                };
+            }
+            const res = await rdsClient.send(new client_rds_1.DescribeDBClustersCommand({
+                DBClusterIdentifier: detail.SourceIdentifier,
+            }));
+            const cluster = res.DBClusters?.[0];
+            return {
+                status: cluster?.Status ?? 'unknown',
+                identifier: cluster?.DBClusterIdentifier ?? detail.SourceIdentifier,
+            };
+        }, {
+            initialState: {
+                status: firstDescribe.status,
+                identifier: firstDescribe.identifier,
+            },
+            waitStrategy: state => {
+                if (state.status === 'stopped') {
+                    return { shouldContinue: false };
+                }
+                if (TRANSITIONAL_STATUSES.has(state.status)) {
+                    return { shouldContinue: true, delay: { minutes: 5 } };
+                }
+                throw new Error(`Unexpected status while waiting for stop: ${state.status}`);
+            },
+        });
+        finalStatus = stopped.status;
+    }
+    // stopped になっていなければ通知は出さない（Step Functions の Fail 相当）
+    if (finalStatus !== 'stopped') {
+        throw new Error(`DB status is not stopped after processing: ${finalStatus}`);
+    }
+    // 通知用の account/region 取得（Slack 投稿用）
+    const sourceArnParts = detail.SourceArn.split(':');
+    const region = sourceArnParts[3];
+    const account = sourceArnParts[4];
+    // const sourceTypeHuman = humanReadableSourceType(detail.SourceType);
+    const client = new web_api_1.WebClient(slackSecretValue.token);
+    const channel = slackSecretValue.channel;
+    // send slack message
+    // const slackParentMessageResult =
+    await context.step('post-slack-messages', async () => {
+        return client.chat.postMessage({
+            channel,
+            attachments: [
+                {
+                    color: '#36a64f',
+                    pretext: `😴 Successfully stopped the automatically running RDS ${detail.SourceType} ${detail.SourceIdentifier}.`,
+                    fields: [
+                        {
+                            title: 'Account',
+                            value: account,
+                            short: true,
+                        },
+                        {
+                            title: 'Region',
+                            value: region,
+                            short: true,
+                        },
+                        {
+                            title: 'Type',
+                            value: detail.SourceType,
+                            short: true,
+                        },
+                        {
+                            title: 'Identifier',
+                            value: detail.SourceIdentifier,
+                            short: true,
+                        },
+                    ],
+                },
+            ],
+        });
+    });
+    return {
+        action: 'stopped',
+        finalStatus,
+        account,
+        region,
+        identifier: detail.SourceIdentifier,
+    };
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"auto-start-prevent.lambda.js","sourceRoot":"","sources":["../../src/funcs/auto-start-prevent.lambda.ts"],"names":[],"mappings":"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","sourcesContent":["import { withDurableExecution, DurableContext } from '@aws/durable-execution-sdk-js';\nimport {\n  RDSClient,\n  DescribeDBInstancesCommand,\n  DescribeDBClustersCommand,\n  StopDBInstanceCommand,\n  StopDBClusterCommand,\n} from '@aws-sdk/client-rds';\nimport { WebClient } from '@slack/web-api';\nimport { secretFetcher } from 'aws-lambda-secret-fetcher';\n\n/**\n * Detail payload of an RDS auto-start event from EventBridge (subset used by this handler).\n */\ninterface RdsAutoStartDetail {\n  EventID: 'RDS-EVENT-0154' | 'RDS-EVENT-0153';\n  SourceType: 'DB_INSTANCE' | 'CLUSTER';\n  SourceArn: string;\n  SourceIdentifier: string;\n}\n\n/**\n * RDS auto-start event as received from EventBridge.\n */\ninterface RdsAutoStartEvent {\n  'detail-type': 'RDS DB Instance Event' | 'RDS DB Cluster Event';\n  'source': 'aws.rds';\n  'detail': RdsAutoStartDetail;\n}\n\n/**\n * Parameters equivalent to those previously passed from Step Functions (tag-based filtering).\n */\ninterface AutoStartParams {\n  tagKey: string;\n  tagValues: string[];\n}\n\n/**\n * Slack secret shape stored in Secrets Manager (token and channel).\n */\ninterface SlackSecret {\n  token: string;\n  channel: string;\n}\n\n/**\n * Input to the Lambda Durable Function. Either:\n * - EventBridge passes the raw RDS event; params are taken from env (TAG_KEY, TAG_VALUES).\n * - Or caller can pass { event, params } directly.\n */\ninterface AutoStartPreventInput {\n  event: RdsAutoStartEvent;\n  params: AutoStartParams;\n}\n\n/** Detect if the payload is the raw EventBridge event (has detail + detail-type). */\nconst isRawEvent = (input: unknown): input is RdsAutoStartEvent =>\n  typeof input === 'object' &&\n  input != null &&\n  'detail' in input &&\n  'detail-type' in input;\n\n/** Build params from environment (set by CDK from targetResource). */\nconst paramsFromEnv = (): AutoStartParams => {\n  const tagKey = process.env.TAG_KEY;\n  const tagValuesJson = process.env.TAG_VALUES;\n  if (!tagKey || !tagValuesJson) {\n    throw new Error('missing environment variables TAG_KEY or TAG_VALUES.');\n  }\n  let tagValues: string[];\n  try {\n    tagValues = JSON.parse(tagValuesJson) as string[];\n  } catch {\n    throw new Error('TAG_VALUES must be a JSON array of strings.');\n  }\n  if (!Array.isArray(tagValues)) {\n    throw new Error('TAG_VALUES must be a JSON array of strings.');\n  }\n  return { tagKey, tagValues };\n};\n\n/** Normalize invocation input to AutoStartPreventInput (event + params). */\nconst normalizeInput = (input: unknown): AutoStartPreventInput => {\n  if (isRawEvent(input)) {\n    return { event: input, params: paramsFromEnv() };\n  }\n  const candidate = input as AutoStartPreventInput;\n  if (\n    typeof candidate === 'object' &&\n    candidate != null &&\n    candidate.event != null &&\n    candidate.params != null\n  ) {\n    return candidate;\n  }\n  throw new Error('Invalid input: expected RDS event or { event, params }.');\n};\n\n/**\n * AWS-style tag (Key/Value).\n */\ninterface Tag {\n  Key?: string;\n  Value?: string;\n}\n\n/**\n * State used when polling RDS describe results (status, identifier, optional tags).\n */\ninterface PollState {\n  status: string;\n  identifier: string;\n  tags?: Tag[];\n}\n\nconst rdsClient = new RDSClient({});\n\n/** RDS statuses that indicate a transition in progress; we poll every 5 minutes while in these states. */\nconst TRANSITIONAL_STATUSES = new Set([\n  'starting',\n  'configuring-enhanced-monitoring',\n  'backing-up',\n  'modifying',\n  'stopping',\n]);\n\n/**\n * Returns true if the resource has a tag with the given key and a value in the allowed list.\n *\n * @param params - Tag key and allowed values.\n * @param tags - Resource tag list (e.g. from DescribeDBInstances / DescribeDBClusters).\n * @returns Whether the tag matches.\n */\nconst matchTag = (params: AutoStartParams, tags?: Tag[]): boolean => {\n  if (!tags || tags.length === 0) {\n    return false;\n  }\n  const value = tags.find(t => t.Key === params.tagKey)?.Value;\n  if (!value) {\n    return false;\n  }\n  return params.tagValues.includes(value);\n};\n\n/**\n * Durable Lambda handler: on RDS auto-start events, waits for the resource to become available\n * (or already stopped), checks tag match, stops the instance/cluster if needed, then posts to Slack.\n *\n * @param input - EventBridge event plus params (tagKey, tagValues).\n * @param context - Durable execution context for steps and waits.\n * @returns Result with action ('stopped' | 'no-op'), finalStatus, account, region, identifier.\n */\nexport const handler = withDurableExecution(\n  async (input: unknown, context: DurableContext) => {\n    const { event, params } = normalizeInput(input);\n    const { detail, 'detail-type': detailType } = event;\n\n    const slackSecretName = process.env.SLACK_SECRET_NAME;\n    if (!slackSecretName) {\n      throw new Error('missing environment variable SLACK_SECRET_NAME.');\n    }\n    const slackSecretValue = await context.step('fetch-slack-secret', async () => {\n      return secretFetcher.getSecretValue<SlackSecret>(slackSecretName);\n    });\n\n    if (!slackSecretValue?.token || !slackSecretValue?.channel) {\n      throw new Error('Slack secret must contain token and channel.');\n    }\n\n    const isInstance =\n      detailType === 'RDS DB Instance Event' &&\n      detail.SourceType === 'DB_INSTANCE' &&\n      detail.EventID === 'RDS-EVENT-0154';\n\n    const isCluster =\n      detailType === 'RDS DB Cluster Event' &&\n      detail.SourceType === 'CLUSTER' &&\n      detail.EventID === 'RDS-EVENT-0153';\n\n    if (!isInstance && !isCluster) {\n      throw new Error(\n        `Unsupported event: detail-type=${detailType}, SourceType=${detail.SourceType}, EventID=${detail.EventID}`,\n      );\n    }\n\n    // Step Functions の StartingWait (1 分待つ) に相当\n    await context.wait({ minutes: 1 });\n\n    // Step Functions の DescribeTypeChoice + TagMatchChoice + StatusChoice の前半に相当\n    const firstDescribe = await context.waitForCondition<PollState>(\n      async (_state, _ctx) => {\n        if (isInstance) {\n          const res = await rdsClient.send(\n            new DescribeDBInstancesCommand({\n              DBInstanceIdentifier: detail.SourceIdentifier,\n            }),\n          );\n          const db = res.DBInstances?.[0];\n          return {\n            status: db?.DBInstanceStatus ?? 'unknown',\n            identifier: db?.DBInstanceIdentifier ?? detail.SourceIdentifier,\n            tags: (db?.TagList ?? []) as Tag[],\n          };\n        }\n\n        const res = await rdsClient.send(\n          new DescribeDBClustersCommand({\n            DBClusterIdentifier: detail.SourceIdentifier,\n          }),\n        );\n        const cluster = res.DBClusters?.[0];\n        return {\n          status: cluster?.Status ?? 'unknown',\n          identifier: cluster?.DBClusterIdentifier ?? detail.SourceIdentifier,\n          tags: (cluster?.TagList ?? []) as Tag[],\n        };\n      },\n      {\n        initialState: {\n          status: 'starting',\n          identifier: detail.SourceIdentifier,\n        },\n        waitStrategy: state => {\n          // ステータスが遷移中であれば 5 分おきにポーリング\n          if (TRANSITIONAL_STATUSES.has(state.status)) {\n            return { shouldContinue: true, delay: { minutes: 5 } };\n          }\n          // available / stopped / その他 → ここで一旦ループ終了し、後続ロジックへ\n          return { shouldContinue: false };\n        },\n      },\n    );\n\n    // タグが存在しない or マッチしない場合は何もせず終了\n    if (!matchTag(params, firstDescribe.tags)) {\n      return {\n        action: 'no-op',\n        reason: 'tag not matched or not found',\n        status: firstDescribe.status,\n      };\n    }\n\n    let finalStatus = firstDescribe.status;\n\n    // available の場合は stop API を呼び、その後 stopped になるまで待機\n    if (firstDescribe.status === 'available') {\n      if (isInstance) {\n        await context.step('stop-db-instance', async () => {\n          await rdsClient.send(\n            new StopDBInstanceCommand({\n              DBInstanceIdentifier: detail.SourceIdentifier,\n            }),\n          );\n        });\n      } else {\n        await context.step('stop-db-cluster', async () => {\n          await rdsClient.send(\n            new StopDBClusterCommand({\n              DBClusterIdentifier: detail.SourceIdentifier,\n            }),\n          );\n        });\n      }\n\n      const stopped = await context.waitForCondition<PollState>(\n        async (_state, _ctx) => {\n          if (isInstance) {\n            const res = await rdsClient.send(\n              new DescribeDBInstancesCommand({\n                DBInstanceIdentifier: detail.SourceIdentifier,\n              }),\n            );\n            const db = res.DBInstances?.[0];\n            return {\n              status: db?.DBInstanceStatus ?? 'unknown',\n              identifier: db?.DBInstanceIdentifier ?? detail.SourceIdentifier,\n            };\n          }\n\n          const res = await rdsClient.send(\n            new DescribeDBClustersCommand({\n              DBClusterIdentifier: detail.SourceIdentifier,\n            }),\n          );\n          const cluster = res.DBClusters?.[0];\n          return {\n            status: cluster?.Status ?? 'unknown',\n            identifier: cluster?.DBClusterIdentifier ?? detail.SourceIdentifier,\n          };\n        },\n        {\n          initialState: {\n            status: firstDescribe.status,\n            identifier: firstDescribe.identifier,\n          },\n          waitStrategy: state => {\n            if (state.status === 'stopped') {\n              return { shouldContinue: false };\n            }\n            if (TRANSITIONAL_STATUSES.has(state.status)) {\n              return { shouldContinue: true, delay: { minutes: 5 } };\n            }\n            throw new Error(`Unexpected status while waiting for stop: ${state.status}`);\n          },\n        },\n      );\n\n      finalStatus = stopped.status;\n    }\n\n    // stopped になっていなければ通知は出さない（Step Functions の Fail 相当）\n    if (finalStatus !== 'stopped') {\n      throw new Error(`DB status is not stopped after processing: ${finalStatus}`);\n    }\n\n    // 通知用の account/region 取得（Slack 投稿用）\n    const sourceArnParts = detail.SourceArn.split(':');\n    const region = sourceArnParts[3];\n    const account = sourceArnParts[4];\n\n    // const sourceTypeHuman = humanReadableSourceType(detail.SourceType);\n\n    const client = new WebClient(slackSecretValue.token);\n    const channel = slackSecretValue.channel;\n\n    // send slack message\n    // const slackParentMessageResult =\n    await context.step('post-slack-messages', async () => {\n      return client.chat.postMessage({\n        channel,\n        attachments: [\n          {\n            color: '#36a64f',\n            pretext: `😴 Successfully stopped the automatically running RDS ${detail.SourceType} ${detail.SourceIdentifier}.`,\n            fields: [\n              {\n                title: 'Account',\n                value: account,\n                short: true,\n              },\n              {\n                title: 'Region',\n                value: region,\n                short: true,\n              },\n              {\n                title: 'Type',\n                value: detail.SourceType,\n                short: true,\n              },\n              {\n                title: 'Identifier',\n                value: detail.SourceIdentifier,\n                short: true,\n              },\n            ],\n          },\n        ],\n      });\n    });\n\n    return {\n      action: 'stopped',\n      finalStatus,\n      account,\n      region,\n      identifier: detail.SourceIdentifier,\n    };\n  },\n);\n\n"]}

package/lib/index.d.ts

@@ -0,0 +1,2 @@
+export * from './constructs/rds-database-auto-start-preventer';
+export * from './stacks/rds-database-auto-start-prevent-stack';

package/lib/index.js

@@ -0,0 +1,19 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./constructs/rds-database-auto-start-preventer"), exports);
+__exportStar(require("./stacks/rds-database-auto-start-prevent-stack"), exports);
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi9zcmMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7Ozs7Ozs7OztBQUFBLGlGQUErRDtBQUMvRCxpRkFBK0QiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tICcuL2NvbnN0cnVjdHMvcmRzLWRhdGFiYXNlLWF1dG8tc3RhcnQtcHJldmVudGVyJztcbmV4cG9ydCAqIGZyb20gJy4vc3RhY2tzL3Jkcy1kYXRhYmFzZS1hdXRvLXN0YXJ0LXByZXZlbnQtc3RhY2snOyJdfQ==

package/lib/stacks/rds-database-auto-start-prevent-stack.d.ts

@@ -0,0 +1,27 @@
+import { Stack, StackProps } from 'aws-cdk-lib';
+import { Construct } from 'constructs';
+import { TargetResource, Secrets } from '../constructs/rds-database-auto-start-preventer';
+/**
+ * Props for the RDS database auto start prevent CDK stack.
+ */
+export interface RDSDatabaseAutoStartPreventStackProps extends StackProps {
+    /** Tag-based target resource criteria for RDS instances/clusters to protect. */
+    readonly targetResource: TargetResource;
+    /** Whether the EventBridge rules are enabled. Defaults to true if omitted. */
+    readonly enableRule?: boolean;
+    /** Secrets (e.g. Slack) for notifications. */
+    readonly secrets: Secrets;
+}
+/**
+ * CDK Stack that deploys the RDS database auto start prevent (EventBridge Rule + Durable Lambda).
+ */
+export declare class RDSDatabaseAutoStartPreventStack extends Stack {
+    /**
+     * Creates the stack and the RDSDatabaseAutoStartPreventer construct.
+     *
+     * @param scope - Parent construct.
+     * @param id - Stack id.
+     * @param props - Stack props (target resource, enable rule, secrets).
+     */
+    constructor(scope: Construct, id: string, props: RDSDatabaseAutoStartPreventStackProps);
+}