aws-ec2-instance-running-scheduler 3.0.2

package/lib/constructs/ec2-instance-running-scheduler.d.ts

@@ -0,0 +1,59 @@
+import { TimeZone } from 'aws-cdk-lib';
+import { Construct } from 'constructs';
+/**
+ * Cron-style schedule configuration for start/stop actions.
+ */
+export interface Schedule {
+    /** Time zone for the schedule (e.g. ETC_UTC). */
+    readonly timezone: TimeZone;
+    /** Cron minute (0–59). */
+    readonly minute?: string;
+    /** Cron hour (0–23). */
+    readonly hour?: string;
+    /** Cron day of week (e.g. MON-FRI). */
+    readonly week?: string;
+}
+/**
+ * Defines which EC2 instances are targeted by tag key and values.
+ */
+export interface TargetResource {
+    /** Tag key used to select instances (e.g. Schedule). */
+    readonly tagKey: string;
+    /** Tag values that match instances to include. */
+    readonly tagValues: string[];
+}
+/**
+ * Secret identifiers required by the scheduler (e.g. Slack).
+ */
+export interface Secrets {
+    /** Name of the Secrets Manager secret containing Slack token and channel. */
+    readonly slackSecretName: string;
+}
+/**
+ * Properties for creating an EC2 instance running scheduler.
+ */
+export interface EC2InstanceRunningSchedulerProps {
+    /** Tag-based targeting for EC2 instances to start/stop. */
+    readonly targetResource: TargetResource;
+    /** Whether EventBridge Scheduler rules are enabled. Defaults to true if omitted. */
+    readonly enableScheduling?: boolean;
+    /** Secrets (e.g. Slack) used for notifications. */
+    readonly secrets: Secrets;
+    /** Cron schedule for stopping instances. */
+    readonly stopSchedule?: Schedule;
+    /** Cron schedule for starting instances. */
+    readonly startSchedule?: Schedule;
+}
+/**
+ * Construct that schedules EC2 instance start/stop via EventBridge Scheduler and a Durable Lambda.
+ */
+export declare class EC2InstanceRunningScheduler extends Construct {
+    /**
+     * Creates an EC2 instance running scheduler with start/stop schedules and a Durable Lambda.
+     *
+     * @param scope - Parent construct.
+     * @param id - Construct id.
+     * @param props - Scheduler configuration (target resource, schedules, secrets).
+     */
+    constructor(scope: Construct, id: string, props: EC2InstanceRunningSchedulerProps);
+}

package/lib/constructs/ec2-instance-running-scheduler.js

@@ -0,0 +1,140 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EC2InstanceRunningScheduler = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+const aws_cdk_lib_1 = require("aws-cdk-lib");
+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 scheduler = require("aws-cdk-lib/aws-scheduler");
+const targets = require("aws-cdk-lib/aws-scheduler-targets");
+const aws_secretsmanager_1 = require("aws-cdk-lib/aws-secretsmanager");
+const constructs_1 = require("constructs");
+const running_scheduler_function_1 = require("../funcs/running-scheduler-function");
+/**
+ * Construct that schedules EC2 instance start/stop via EventBridge Scheduler and a Durable Lambda.
+ */
+class EC2InstanceRunningScheduler extends constructs_1.Construct {
+    /**
+     * Creates an EC2 instance running scheduler with start/stop schedules and a Durable Lambda.
+     *
+     * @param scope - Parent construct.
+     * @param id - Construct id.
+     * @param props - Scheduler configuration (target resource, schedules, 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 runningScheduleFunction = new running_scheduler_function_1.RunningSchedulerFunction(this, 'RunningSchedulerFunction', {
+            description: 'A function to run the scheduled RDS Database or Cluster.',
+            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: props.secrets.slackSecretName,
+            },
+            paramsAndSecrets: lambda.ParamsAndSecretsLayerVersion.fromVersion(lambda.ParamsAndSecretsVersions.V1_0_103, {
+                cacheSize: 500,
+                logLevel: lambda.ParamsAndSecretsLogLevel.INFO,
+            }),
+            role: new iam.Role(this, 'RunningSchedulerFunctionRole', {
+                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, 'RunningSchedulerFunctionLogGroup', {
+                retention: logs.RetentionDays.THREE_MONTHS,
+                removalPolicy: aws_cdk_lib_1.RemovalPolicy.DESTROY,
+            }),
+            loggingFormat: lambda.LoggingFormat.JSON,
+            systemLogLevelV2: lambda.SystemLogLevel.INFO,
+            applicationLogLevelV2: lambda.ApplicationLogLevel.INFO,
+        });
+        runningScheduleFunction.addToRolePolicy(new iam.PolicyStatement({
+            sid: 'GetResources',
+            effect: iam.Effect.ALLOW,
+            actions: [
+                'tag:GetResources',
+            ],
+            resources: ['*'],
+        }));
+        // Grant read access to the RDS API
+        runningScheduleFunction.addToRolePolicy(new iam.PolicyStatement({
+            sid: 'RdsRunningControl',
+            effect: iam.Effect.ALLOW,
+            actions: [
+                'ec2:DescribeInstances',
+                'ec2:StartInstances',
+                'ec2:StopInstances',
+            ],
+            resources: ['*'],
+        }));
+        // Grant read access to the Slack secret
+        slackSecret.grantRead(runningScheduleFunction);
+        // See: https://docs.aws.amazon.com/lambda/latest/dg/durable-getting-started-iac.html
+        const runningScheduleFunctionAlias = runningScheduleFunction.addAlias('live');
+        // Whether schedules are enabled (default true unless explicitly disabled).
+        const scheduleEnabled = (() => {
+            if (props.enableScheduling === undefined || props.enableScheduling) {
+                return true;
+            }
+            else {
+                return false;
+            }
+        })();
+        // Durable Functions: Lambda performs tag lookup and instance start/stop in a single run.
+        new scheduler.Schedule(this, 'RunningStartSchedule', {
+            description: 'running start schedule',
+            enabled: scheduleEnabled,
+            schedule: scheduler.ScheduleExpression.cron({
+                minute: props.startSchedule?.minute ?? '50',
+                hour: props.startSchedule?.hour ?? '7',
+                weekDay: props.startSchedule?.week ?? 'MON-FRI',
+                timeZone: props.startSchedule?.timezone ?? aws_cdk_lib_1.TimeZone.ETC_UTC,
+            }),
+            target: new targets.LambdaInvoke(runningScheduleFunctionAlias, {
+                input: scheduler.ScheduleTargetInput.fromObject({
+                    Params: {
+                        TagKey: props.targetResource.tagKey,
+                        TagValues: props.targetResource.tagValues,
+                        Mode: 'Start',
+                    },
+                }),
+            }),
+        });
+        new scheduler.Schedule(this, 'RunningStopSchedule', {
+            description: 'running stop schedule',
+            enabled: scheduleEnabled,
+            schedule: scheduler.ScheduleExpression.cron({
+                minute: props.stopSchedule?.minute ?? '5',
+                hour: props.stopSchedule?.hour ?? '19',
+                weekDay: props.stopSchedule?.week ?? 'MON-FRI',
+                timeZone: props.stopSchedule?.timezone ?? aws_cdk_lib_1.TimeZone.ETC_UTC,
+            }),
+            target: new targets.LambdaInvoke(runningScheduleFunctionAlias, {
+                input: scheduler.ScheduleTargetInput.fromObject({
+                    Params: {
+                        TagKey: props.targetResource.tagKey,
+                        TagValues: props.targetResource.tagValues,
+                        Mode: 'Stop',
+                    },
+                }),
+            }),
+        });
+    }
+}
+exports.EC2InstanceRunningScheduler = EC2InstanceRunningScheduler;
+_a = JSII_RTTI_SYMBOL_1;
+EC2InstanceRunningScheduler[_a] = { fqn: "aws-ec2-instance-running-scheduler.EC2InstanceRunningScheduler", version: "3.0.2" };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"ec2-instance-running-scheduler.js","sourceRoot":"","sources":["../../src/constructs/ec2-instance-running-scheduler.ts"],"names":[],"mappings":"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","sourcesContent":["import { Duration, RemovalPolicy, TimeZone } from 'aws-cdk-lib';\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 * as scheduler from 'aws-cdk-lib/aws-scheduler';\nimport * as targets from 'aws-cdk-lib/aws-scheduler-targets';\nimport { Secret } from 'aws-cdk-lib/aws-secretsmanager';\nimport { Construct } from 'constructs';\nimport { RunningSchedulerFunction } from '../funcs/running-scheduler-function';\n\n/**\n * Cron-style schedule configuration for start/stop actions.\n */\nexport interface Schedule {\n  /** Time zone for the schedule (e.g. ETC_UTC). */\n  readonly timezone: TimeZone;\n  /** Cron minute (0–59). */\n  readonly minute?: string;\n  /** Cron hour (0–23). */\n  readonly hour?: string;\n  /** Cron day of week (e.g. MON-FRI). */\n  readonly week?: string;\n}\n\n/**\n * Defines which EC2 instances are targeted by tag key and values.\n */\nexport interface TargetResource {\n  /** Tag key used to select instances (e.g. Schedule). */\n  readonly tagKey: string;\n  /** Tag values that match instances to include. */\n  readonly tagValues: string[];\n}\n\n/**\n * Secret identifiers required by the scheduler (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 * Properties for creating an EC2 instance running scheduler.\n */\nexport interface EC2InstanceRunningSchedulerProps {\n  /** Tag-based targeting for EC2 instances to start/stop. */\n  readonly targetResource: TargetResource;\n  /** Whether EventBridge Scheduler rules are enabled. Defaults to true if omitted. */\n  readonly enableScheduling?: boolean;\n  /** Secrets (e.g. Slack) used for notifications. */\n  readonly secrets: Secrets;\n  /** Cron schedule for stopping instances. */\n  readonly stopSchedule?: Schedule;\n  /** Cron schedule for starting instances. */\n  readonly startSchedule?: Schedule;\n}\n\n/**\n * Construct that schedules EC2 instance start/stop via EventBridge Scheduler and a Durable Lambda.\n */\nexport class EC2InstanceRunningScheduler extends Construct {\n  /**\n   * Creates an EC2 instance running scheduler with start/stop schedules and a Durable Lambda.\n   *\n   * @param scope - Parent construct.\n   * @param id - Construct id.\n   * @param props - Scheduler configuration (target resource, schedules, secrets).\n   */\n  constructor(scope: Construct, id: string, props: EC2InstanceRunningSchedulerProps) {\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 runningScheduleFunction = new RunningSchedulerFunction(this, 'RunningSchedulerFunction', {\n      description: 'A function to run the scheduled RDS Database or Cluster.',\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: props.secrets.slackSecretName,\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, 'RunningSchedulerFunctionRole', {\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, 'RunningSchedulerFunctionLogGroup', {\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    runningScheduleFunction.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    runningScheduleFunction.addToRolePolicy(new iam.PolicyStatement({\n      sid: 'RdsRunningControl',\n      effect: iam.Effect.ALLOW,\n      actions: [\n        'ec2:DescribeInstances',\n        'ec2:StartInstances',\n        'ec2:StopInstances',\n      ],\n      resources: ['*'],\n    }));\n    // Grant read access to the Slack secret\n    slackSecret.grantRead(runningScheduleFunction);\n\n    // See: https://docs.aws.amazon.com/lambda/latest/dg/durable-getting-started-iac.html\n    const runningScheduleFunctionAlias = runningScheduleFunction.addAlias('live');\n\n    // Whether schedules are enabled (default true unless explicitly disabled).\n    const scheduleEnabled: boolean = (() => {\n      if (props.enableScheduling === undefined || props.enableScheduling) {\n        return true;\n      } else {\n        return false;\n      }\n    })();\n\n    // Durable Functions: Lambda performs tag lookup and instance start/stop in a single run.\n    new scheduler.Schedule(this, 'RunningStartSchedule', {\n      description: 'running start schedule',\n      enabled: scheduleEnabled,\n      schedule: scheduler.ScheduleExpression.cron({\n        minute: props.startSchedule?.minute ?? '50',\n        hour: props.startSchedule?.hour ?? '7',\n        weekDay: props.startSchedule?.week ?? 'MON-FRI',\n        timeZone: props.startSchedule?.timezone ?? TimeZone.ETC_UTC,\n      }),\n      target: new targets.LambdaInvoke(runningScheduleFunctionAlias, {\n        input: scheduler.ScheduleTargetInput.fromObject({\n          Params: {\n            TagKey: props.targetResource.tagKey,\n            TagValues: props.targetResource.tagValues,\n            Mode: 'Start',\n          },\n        }),\n      }),\n    });\n\n    new scheduler.Schedule(this, 'RunningStopSchedule', {\n      description: 'running stop schedule',\n      enabled: scheduleEnabled,\n      schedule: scheduler.ScheduleExpression.cron({\n        minute: props.stopSchedule?.minute ?? '5',\n        hour: props.stopSchedule?.hour ?? '19',\n        weekDay: props.stopSchedule?.week ?? 'MON-FRI',\n        timeZone: props.stopSchedule?.timezone ?? TimeZone.ETC_UTC,\n      }),\n      target: new targets.LambdaInvoke(runningScheduleFunctionAlias, {\n        input: scheduler.ScheduleTargetInput.fromObject({\n          Params: {\n            TagKey: props.targetResource.tagKey,\n            TagValues: props.targetResource.tagValues,\n            Mode: 'Stop',\n          },\n        }),\n      }),\n    });\n  }\n}\n"]}

package/lib/funcs/running-scheduler-function.d.ts

@@ -0,0 +1,18 @@
+import * as lambda from 'aws-cdk-lib/aws-lambda';
+import { Construct } from 'constructs';
+/**
+ * Props for RunningSchedulerFunction
+ */
+export interface RunningSchedulerFunctionProps extends lambda.FunctionOptions {
+    /**
+     * The Lambda runtime to use.
+     * @default - Latest Node.js runtime available in the deployment region
+     */
+    readonly runtime?: lambda.Runtime;
+}
+/**
+ * An AWS Lambda function which executes src/funcs/running-scheduler.
+ */
+export declare class RunningSchedulerFunction extends lambda.Function {
+    constructor(scope: Construct, id: string, props?: RunningSchedulerFunctionProps);
+}

package/lib/funcs/running-scheduler-function.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RunningSchedulerFunction = 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");
+const aws_lambda_1 = require("aws-cdk-lib/aws-lambda");
+/**
+ * An AWS Lambda function which executes src/funcs/running-scheduler.
+ */
+class RunningSchedulerFunction extends lambda.Function {
+    constructor(scope, id, props) {
+        super(scope, id, {
+            description: 'src/funcs/running-scheduler.lambda.ts',
+            ...props,
+            runtime: props?.runtime ?? (0, aws_lambda_1.determineLatestNodeRuntime)(scope),
+            handler: 'index.handler',
+            code: lambda.Code.fromAsset(path.join(__dirname, '../../assets/funcs/running-scheduler.lambda')),
+        });
+        this.addEnvironment('AWS_NODEJS_CONNECTION_REUSE_ENABLED', '1', { removeInEdge: true });
+    }
+}
+exports.RunningSchedulerFunction = RunningSchedulerFunction;
+//# sourceMappingURL=data:application/json;base64,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

package/lib/funcs/running-scheduler.lambda.d.ts

@@ -0,0 +1,28 @@
+/**
+ * EC2 Running Scheduler – Durable Functions implementation.
+ *
+ * Implements the running-control flow using AWS Lambda Durable Execution.
+ * Step checkpoints, wait (no charge), and parallel map provide a flow equivalent to Step Functions.
+ *
+ * @see https://docs.aws.amazon.com/lambda/latest/dg/durable-execution-sdk.html
+ */
+/** Event payload from EventBridge Scheduler invoking this Lambda. */
+export interface SchedulerEvent {
+    Params: {
+        /** Tag key used to select EC2 instances. */
+        TagKey: string;
+        /** Tag values to match. */
+        TagValues: string[];
+        /** Whether to start or stop instances. */
+        Mode: 'Start' | 'Stop';
+    };
+}
+/**
+ * Durable Lambda handler for the EC2 running scheduler.
+ * Fetches target resources by tag, starts or stops instances per Mode, and posts results to Slack.
+ *
+ * @param event - SchedulerEvent with Params.TagKey, Params.TagValues, Params.Mode.
+ * @param context - Durable execution context.
+ * @returns Status and list of processed resources, or TargetResourcesNotFound if none match.
+ */
+export declare const handler: import("@aws/durable-execution-sdk-js").DurableLambdaHandler;

package/lib/funcs/running-scheduler.lambda.js

@@ -0,0 +1,182 @@
+"use strict";
+/**
+ * EC2 Running Scheduler – Durable Functions implementation.
+ *
+ * Implements the running-control flow using AWS Lambda Durable Execution.
+ * Step checkpoints, wait (no charge), and parallel map provide a flow equivalent to Step Functions.
+ *
+ * @see https://docs.aws.amazon.com/lambda/latest/dg/durable-execution-sdk.html
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handler = void 0;
+const durable_execution_sdk_js_1 = require("@aws/durable-execution-sdk-js");
+const client_ec2_1 = require("@aws-sdk/client-ec2");
+const client_resource_groups_tagging_api_1 = require("@aws-sdk/client-resource-groups-tagging-api");
+const web_api_1 = require("@slack/web-api");
+const aws_lambda_secret_fetcher_1 = require("aws-lambda-secret-fetcher");
+/** Mapping of EC2 instance state to display name and emoji for Slack. */
+const STATE_LIST = [
+    { name: 'RUNNING', emoji: '😆', state: 'running' },
+    { name: 'STOPPED', emoji: '😴', state: 'stopped' },
+];
+/** Seconds to wait between polling instance state after start/stop. */
+const STATUS_CHANGE_WAIT_SECONDS = 20;
+/**
+ * Returns display name and emoji for an EC2 instance state.
+ *
+ * @param current - Current instance state (e.g. 'running', 'stopped').
+ * @returns Display info or undefined if state is not in STATE_LIST.
+ */
+const getStateDisplay = (current) => {
+    const found = STATE_LIST.find((s) => s.state === current);
+    return found ? { emoji: found.emoji, name: found.name } : undefined;
+};
+/**
+ * Processes a single EC2 instance: describes state, starts or stops as needed, and polls until stable.
+ *
+ * @param ctx - Durable execution context for steps and wait.
+ * @param targetResource - EC2 instance ARN.
+ * @param params - Scheduler params (TagKey, TagValues, Mode).
+ * @param resourceIndex - Index of this resource (used for step names).
+ * @returns Resource ARN, final status, account, region, and instance id.
+ */
+const processOneResource = async (ctx, targetResource, params, resourceIndex) => {
+    const parts = targetResource.split('/');
+    const identifier = parts[parts.length - 1] ?? 'unknown';
+    const arnParts = targetResource.split(':');
+    const account = arnParts[4] ?? '';
+    const region = arnParts[3] ?? '';
+    const stepPrefix = `resource-${resourceIndex}-${identifier}`;
+    let loopCount = 0;
+    for (;;) {
+        const currentState = await ctx.step(`${stepPrefix}-describe-${loopCount}`, async () => {
+            const ec2 = new client_ec2_1.EC2Client({});
+            const out = await ec2.send(new client_ec2_1.DescribeInstancesCommand({ InstanceIds: [identifier] }));
+            return out.Reservations?.[0]?.Instances?.[0]?.State?.Name ?? 'unknown';
+        });
+        const mode = params.Mode;
+        if (mode === 'Start' && currentState === 'stopped') {
+            await ctx.step(`${stepPrefix}-start-${loopCount}`, async () => {
+                const ec2 = new client_ec2_1.EC2Client({});
+                await ec2.send(new client_ec2_1.StartInstancesCommand({ InstanceIds: [identifier] }));
+            });
+            await ctx.wait({ seconds: STATUS_CHANGE_WAIT_SECONDS });
+            loopCount += 1;
+            continue;
+        }
+        if (mode === 'Stop' && (currentState === 'running')) {
+            await ctx.step(`${stepPrefix}-stop-${loopCount}`, async () => {
+                const ec2 = new client_ec2_1.EC2Client({});
+                await ec2.send(new client_ec2_1.StopInstancesCommand({ InstanceIds: [identifier] }));
+            });
+            await ctx.wait({ seconds: STATUS_CHANGE_WAIT_SECONDS });
+            loopCount += 1;
+            continue;
+        }
+        if ((mode === 'Start' && currentState === 'running') ||
+            (mode === 'Stop' && currentState === 'stopped')) {
+            return {
+                identifier,
+                account,
+                region,
+                resource: targetResource,
+                status: currentState,
+            };
+        }
+        const transitioning = (mode === 'Start' && currentState === 'pending') ||
+            (mode === 'Stop' && (currentState === 'stopping' || currentState === 'shutting-down'));
+        if (transitioning) {
+            await ctx.wait({ seconds: STATUS_CHANGE_WAIT_SECONDS });
+            loopCount += 1;
+            continue;
+        }
+        throw new Error(`instance status fail: mode=${mode} currentState=${currentState}`);
+    }
+};
+/**
+ * Durable Lambda handler for the EC2 running scheduler.
+ * Fetches target resources by tag, starts or stops instances per Mode, and posts results to Slack.
+ *
+ * @param event - SchedulerEvent with Params.TagKey, Params.TagValues, Params.Mode.
+ * @param context - Durable execution context.
+ * @returns Status and list of processed resources, or TargetResourcesNotFound if none match.
+ */
+exports.handler = (0, durable_execution_sdk_js_1.withDurableExecution)(async (event, context) => {
+    const params = event.Params;
+    if (!params?.TagKey || !params?.TagValues || !params?.Mode) {
+        throw new Error('Invalid event: Params.TagKey, Params.TagValues, Params.Mode are required.');
+    }
+    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 targetResources = await context.step('get-target-resources', async () => {
+        const client = new client_resource_groups_tagging_api_1.ResourceGroupsTaggingAPIClient({});
+        const result = await client.send(new client_resource_groups_tagging_api_1.GetResourcesCommand({
+            ResourceTypeFilters: ['ec2:instance'],
+            TagFilters: [{ Key: params.TagKey, Values: params.TagValues }],
+        }));
+        return (result.ResourceTagMappingList ?? [])
+            .map((m) => m.ResourceARN)
+            .filter((arn) => arn != null);
+    });
+    if (targetResources.length === 0) {
+        return { status: 'TargetResourcesNotFound' };
+    }
+    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,
+            text: `${params.Mode === 'Start' ? '😆 Starts' : '🥱 Stops'} the scheduled EC2 Instance.`,
+        });
+    });
+    const results = await context.map(targetResources, 
+    // async (ctx: DurableContext, targetResource: string, index: number) =>
+    //   ctx.step(`process-resource-${index}`, async () =>
+    //     processOneResource(ctx, targetResource, params, index),
+    //   ),
+    async (ctx, targetResource, index) => {
+        return ctx.runInChildContext(`resource-${index}`, async (childCtx) => {
+            const result = await processOneResource(childCtx, targetResource, params, index);
+            // if (result.status === 'skipped') {
+            //   return result;
+            // }
+            // send slack thread message
+            await childCtx.step('post-slack-child-messages', async () => {
+                const display = getStateDisplay(result.status);
+                return client.chat.postMessage({
+                    channel,
+                    thread_ts: slackParentMessageResult?.ts,
+                    attachments: [
+                        {
+                            color: '#36a64f',
+                            pretext: `${display?.emoji} The status of the EC2 Instance ${result.identifier} changed to ${display?.name} due to the schedule.`,
+                            fields: [
+                                { title: 'Account', value: result.account, short: true },
+                                { title: 'Region', value: result.region, short: true },
+                                { title: 'Identifier', value: result.identifier, short: true },
+                                { title: 'Status', value: (display?.name ?? 'Unknown'), short: true },
+                            ],
+                        },
+                    ],
+                });
+            });
+            return result;
+        });
+    }, { maxConcurrency: 10 });
+    const resultList = Array.isArray(results) ? results : [];
+    return {
+        status: 'Completed',
+        processed: targetResources.length,
+        results: resultList,
+    };
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"running-scheduler.lambda.js","sourceRoot":"","sources":["../../src/funcs/running-scheduler.lambda.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * EC2 Running Scheduler – Durable Functions implementation.\n *\n * Implements the running-control flow using AWS Lambda Durable Execution.\n * Step checkpoints, wait (no charge), and parallel map provide a flow equivalent to Step Functions.\n *\n * @see https://docs.aws.amazon.com/lambda/latest/dg/durable-execution-sdk.html\n */\n\nimport { withDurableExecution, type DurableContext } from '@aws/durable-execution-sdk-js';\nimport {\n  EC2Client,\n  DescribeInstancesCommand,\n  StartInstancesCommand,\n  StopInstancesCommand,\n} from '@aws-sdk/client-ec2';\nimport { GetResourcesCommand, ResourceGroupsTaggingAPIClient } from '@aws-sdk/client-resource-groups-tagging-api';\nimport { WebClient } from '@slack/web-api';\nimport { secretFetcher } from 'aws-lambda-secret-fetcher';\n\n/** Mapping of EC2 instance state to display name and emoji for Slack. */\nconst STATE_LIST = [\n  { name: 'RUNNING', emoji: '😆', state: 'running' },\n  { name: 'STOPPED', emoji: '😴', state: 'stopped' },\n] as const;\n\n/** Seconds to wait between polling instance state after start/stop. */\nconst STATUS_CHANGE_WAIT_SECONDS = 20;\n\n/** Event payload from EventBridge Scheduler invoking this Lambda. */\nexport interface SchedulerEvent {\n  Params: {\n    /** Tag key used to select EC2 instances. */\n    TagKey: string;\n    /** Tag values to match. */\n    TagValues: string[];\n    /** Whether to start or stop instances. */\n    Mode: 'Start' | 'Stop';\n  };\n}\n\n/** Shape of the Slack secret stored in Secrets Manager. */\ninterface SlackSecret {\n  token: string;\n  channel: string;\n}\n\n/**\n * Returns display name and emoji for an EC2 instance state.\n *\n * @param current - Current instance state (e.g. 'running', 'stopped').\n * @returns Display info or undefined if state is not in STATE_LIST.\n */\nconst getStateDisplay = (current: string): { emoji: string; name: string } | undefined => {\n  const found = STATE_LIST.find((s) => s.state === current);\n  return found ? { emoji: found.emoji, name: found.name } : undefined;\n};\n\n/**\n * Processes a single EC2 instance: describes state, starts or stops as needed, and polls until stable.\n *\n * @param ctx - Durable execution context for steps and wait.\n * @param targetResource - EC2 instance ARN.\n * @param params - Scheduler params (TagKey, TagValues, Mode).\n * @param resourceIndex - Index of this resource (used for step names).\n * @returns Resource ARN, final status, account, region, and instance id.\n */\nconst processOneResource = async (\n  ctx: DurableContext,\n  targetResource: string,\n  params: SchedulerEvent['Params'],\n  resourceIndex: number,\n): Promise<{ resource: string; status: string; account: string; region: string; identifier: string }> => {\n  const parts = targetResource.split('/');\n  const identifier = parts[parts.length - 1] ?? 'unknown';\n  const arnParts = targetResource.split(':');\n  const account = arnParts[4] ?? '';\n  const region = arnParts[3] ?? '';\n  const stepPrefix = `resource-${resourceIndex}-${identifier}`;\n\n  let loopCount = 0;\n  for (;;) {\n    const currentState = await ctx.step(`${stepPrefix}-describe-${loopCount}`, async () => {\n      const ec2 = new EC2Client({});\n      const out = await ec2.send(new DescribeInstancesCommand({ InstanceIds: [identifier] }));\n      return out.Reservations?.[0]?.Instances?.[0]?.State?.Name ?? 'unknown';\n    });\n\n    const mode = params.Mode;\n\n    if (mode === 'Start' && currentState === 'stopped') {\n      await ctx.step(`${stepPrefix}-start-${loopCount}`, async () => {\n        const ec2 = new EC2Client({});\n        await ec2.send(new StartInstancesCommand({ InstanceIds: [identifier] }));\n      });\n      await ctx.wait({ seconds: STATUS_CHANGE_WAIT_SECONDS });\n      loopCount += 1;\n      continue;\n    }\n\n    if (mode === 'Stop' && (currentState === 'running')) {\n      await ctx.step(`${stepPrefix}-stop-${loopCount}`, async () => {\n        const ec2 = new EC2Client({});\n        await ec2.send(new StopInstancesCommand({ InstanceIds: [identifier] }));\n      });\n      await ctx.wait({ seconds: STATUS_CHANGE_WAIT_SECONDS });\n      loopCount += 1;\n      continue;\n    }\n\n    if (\n      (mode === 'Start' && currentState === 'running') ||\n      (mode === 'Stop' && currentState === 'stopped')\n    ) {\n      return {\n        identifier,\n        account,\n        region,\n        resource: targetResource,\n        status: currentState,\n      };\n    }\n\n    const transitioning =\n      (mode === 'Start' && currentState === 'pending') ||\n      (mode === 'Stop' && (currentState === 'stopping' || currentState === 'shutting-down'));\n\n    if (transitioning) {\n      await ctx.wait({ seconds: STATUS_CHANGE_WAIT_SECONDS });\n      loopCount += 1;\n      continue;\n    }\n\n    throw new Error(`instance status fail: mode=${mode} currentState=${currentState}`);\n  }\n};\n\n/**\n * Durable Lambda handler for the EC2 running scheduler.\n * Fetches target resources by tag, starts or stops instances per Mode, and posts results to Slack.\n *\n * @param event - SchedulerEvent with Params.TagKey, Params.TagValues, Params.Mode.\n * @param context - Durable execution context.\n * @returns Status and list of processed resources, or TargetResourcesNotFound if none match.\n */\nexport const handler = withDurableExecution(async (event: SchedulerEvent, context: DurableContext) => {\n\n  const params = event.Params;\n\n  if (!params?.TagKey || !params?.TagValues || !params?.Mode) {\n    throw new Error('Invalid event: Params.TagKey, Params.TagValues, Params.Mode are required.');\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 targetResources = await context.step('get-target-resources', async () => {\n    const client = new ResourceGroupsTaggingAPIClient({});\n    const result = await client.send(\n      new GetResourcesCommand({\n        ResourceTypeFilters: ['ec2:instance'],\n        TagFilters: [{ Key: params.TagKey, Values: params.TagValues }],\n      }),\n    );\n    return (result.ResourceTagMappingList ?? [])\n      .map((m: { ResourceARN?: string }) => m.ResourceARN)\n      .filter((arn: string | undefined): arn is string => arn != null);\n  });\n\n  if (targetResources.length === 0) {\n    return { status: 'TargetResourcesNotFound' as const };\n  }\n\n  const client = new WebClient(slackSecretValue.token);\n  const channel = slackSecretValue.channel;\n\n  // send slack message\n  const slackParentMessageResult = await context.step('post-slack-messages', async () => {\n    return client.chat.postMessage({\n      channel,\n      text: `${params.Mode === 'Start' ? '😆 Starts' : '🥱 Stops'} the scheduled EC2 Instance.`,\n    });\n  });\n\n  const results = await context.map(\n    targetResources,\n    // async (ctx: DurableContext, targetResource: string, index: number) =>\n    //   ctx.step(`process-resource-${index}`, async () =>\n    //     processOneResource(ctx, targetResource, params, index),\n    //   ),\n    async (ctx: DurableContext, targetResource: string, index: number) => {\n      return ctx.runInChildContext(`resource-${index}`, async (childCtx: DurableContext) => {\n        const result = await processOneResource(childCtx, targetResource, params, index);\n        // if (result.status === 'skipped') {\n        //   return result;\n        // }\n        // send slack thread message\n        await childCtx.step('post-slack-child-messages', async () => {\n          const display = getStateDisplay(result.status);\n\n          return client.chat.postMessage({\n            channel,\n            thread_ts: slackParentMessageResult?.ts,\n            attachments: [\n              {\n                color: '#36a64f',\n                pretext: `${display?.emoji} The status of the EC2 Instance ${result.identifier} changed to ${display?.name} due to the schedule.`,\n                fields: [\n                  { title: 'Account', value: result.account, short: true },\n                  { title: 'Region', value: result.region, short: true },\n                  { title: 'Identifier', value: result.identifier, short: true },\n                  { title: 'Status', value: (display?.name ?? 'Unknown'), short: true },\n                ],\n              },\n            ],\n          });\n        });\n        return result;\n      });\n    },\n    { maxConcurrency: 10 },\n  );\n\n  const resultList = Array.isArray(results) ? results : [];\n  return {\n    status: 'Completed' as const,\n    processed: targetResources.length,\n    results: resultList,\n  };\n});\n"]}

package/lib/index.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Public API: EC2 instance running scheduler construct and stack.
+ */
+export * from './constructs/ec2-instance-running-scheduler';
+export * from './stacks/ec2-instance-running-schedule-stack';

package/lib/index.js

@@ -0,0 +1,22 @@
+"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 });
+/**
+ * Public API: EC2 instance running scheduler construct and stack.
+ */
+__exportStar(require("./constructs/ec2-instance-running-scheduler"), exports);
+__exportStar(require("./stacks/ec2-instance-running-schedule-stack"), exports);
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi9zcmMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7Ozs7Ozs7OztBQUFBOztHQUVHO0FBQ0gsOEVBQTREO0FBQzVELCtFQUE2RCIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogUHVibGljIEFQSTogRUMyIGluc3RhbmNlIHJ1bm5pbmcgc2NoZWR1bGVyIGNvbnN0cnVjdCBhbmQgc3RhY2suXG4gKi9cbmV4cG9ydCAqIGZyb20gJy4vY29uc3RydWN0cy9lYzItaW5zdGFuY2UtcnVubmluZy1zY2hlZHVsZXInO1xuZXhwb3J0ICogZnJvbSAnLi9zdGFja3MvZWMyLWluc3RhbmNlLXJ1bm5pbmctc2NoZWR1bGUtc3RhY2snOyJdfQ==

package/lib/stacks/ec2-instance-running-schedule-stack.d.ts

@@ -0,0 +1,31 @@
+import { Stack, StackProps } from 'aws-cdk-lib';
+import { Construct } from 'constructs';
+import { TargetResource, Secrets, Schedule } from '../constructs/ec2-instance-running-scheduler';
+/**
+ * Props for the EC2 instance running schedule CDK stack.
+ */
+export interface EC2InstanceRunningScheduleStackProps extends StackProps {
+    /** Tag-based target resource for EC2 instances to start/stop. */
+    readonly targetResource: TargetResource;
+    /** Whether scheduling is enabled. Defaults to true if omitted. */
+    readonly enableScheduling?: boolean;
+    /** Secrets (e.g. Slack) for the scheduler. */
+    readonly secrets: Secrets;
+    /** Cron schedule for stopping instances. */
+    readonly stopSchedule?: Schedule;
+    /** Cron schedule for starting instances. */
+    readonly startSchedule?: Schedule;
+}
+/**
+ * CDK Stack that deploys the EC2 instance running scheduler (EventBridge Scheduler + Durable Lambda).
+ */
+export declare class EC2InstanceRunningScheduleStack extends Stack {
+    /**
+     * Creates the stack and the EC2InstanceRunningScheduler construct.
+     *
+     * @param scope - Parent construct.
+     * @param id - Stack id.
+     * @param props - Stack props (target resource, schedules, secrets).
+     */
+    constructor(scope: Construct, id: string, props: EC2InstanceRunningScheduleStackProps);
+}

package/lib/stacks/ec2-instance-running-schedule-stack.js

@@ -0,0 +1,33 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EC2InstanceRunningScheduleStack = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+const aws_cdk_lib_1 = require("aws-cdk-lib");
+const ec2_instance_running_scheduler_1 = require("../constructs/ec2-instance-running-scheduler");
+/**
+ * CDK Stack that deploys the EC2 instance running scheduler (EventBridge Scheduler + Durable Lambda).
+ */
+class EC2InstanceRunningScheduleStack extends aws_cdk_lib_1.Stack {
+    /**
+     * Creates the stack and the EC2InstanceRunningScheduler construct.
+     *
+     * @param scope - Parent construct.
+     * @param id - Stack id.
+     * @param props - Stack props (target resource, schedules, secrets).
+     */
+    constructor(scope, id, props) {
+        super(scope, id, props);
+        new ec2_instance_running_scheduler_1.EC2InstanceRunningScheduler(this, 'EC2InstanceRunningScheduler', {
+            targetResource: props.targetResource,
+            enableScheduling: props.enableScheduling,
+            secrets: props.secrets,
+            stopSchedule: props.stopSchedule,
+            startSchedule: props.startSchedule,
+        });
+    }
+}
+exports.EC2InstanceRunningScheduleStack = EC2InstanceRunningScheduleStack;
+_a = JSII_RTTI_SYMBOL_1;
+EC2InstanceRunningScheduleStack[_a] = { fqn: "aws-ec2-instance-running-scheduler.EC2InstanceRunningScheduleStack", version: "3.0.2" };
+//# sourceMappingURL=data:application/json;base64,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