[AWS Step Functions] タスクの開始時刻を制御してみた

> tree
.
├── .gitignore
├── .npmignore
├── README.md
├── bin
│   └── app.ts
├── cdk.json
├── jest.config.js
├── lib
│   ├── lambda-stack.ts
│   └── state-machine-stack.ts
├── package-lock.json
├── package.json
├── src
│   └── lambda
│       └── functions
│           └── calculate-waiting-time-for-target-time.ts
├── test
│   └── app.test.ts
└── tsconfig.json

6 directories, 13 files

{
  "name": "app",
  "version": "0.1.0",
  "bin": {
    "app": "bin/app.js"
  },
  "scripts": {
    "build": "tsc",
    "watch": "tsc -w",
    "test": "jest",
    "cdk": "cdk"
  },
  "devDependencies": {
    "@types/jest": "^26.0.10",
    "@types/node": "10.17.27",
    "jest": "^26.4.2",
    "ts-jest": "^26.2.0",
    "aws-cdk": "2.2.0",
    "ts-node": "^9.0.0",
    "typescript": "~3.9.7"
  },
  "dependencies": {
    "aws-cdk-lib": "2.2.0",
    "constructs": "^10.0.0",
    "source-map-support": "^0.5.16"
  }
}

#!/usr/bin/env node
import "source-map-support/register";
import * as cdk from "aws-cdk-lib";
import { LambdaStack } from "../lib/lambda-stack";
import { StateMachineStack } from "../lib/state-machine-stack";

const app = new cdk.App();
const lambdaStack = new LambdaStack(app, "LambdaStack");
new StateMachineStack(app, "StateMachineStack", {
  calculateWaitingTimeForTargetTimeFunction:
    lambdaStack.calculateWaitingTimeForTargetTimeFunction,
});

import { Stack, StackProps } from "aws-cdk-lib";
import { Construct } from "constructs";
import * as iam from "aws-cdk-lib/aws-iam";
import * as lambda from "aws-cdk-lib/aws-lambda";
import * as nodejs from "aws-cdk-lib/aws-lambda-nodejs";

export class LambdaStack extends Stack {
  public readonly calculateWaitingTimeForTargetTimeFunction: nodejs.NodejsFunction;

  constructor(scope: Construct, id: string, props?: StackProps) {
    super(scope, id, props);

    // Create an IAM role for Lambda functions.
    const lambdaIamRole = new iam.Role(this, "LambdaIamRole", {
      assumedBy: new iam.ServicePrincipal("lambda.amazonaws.com"),
      managedPolicies: [
        iam.ManagedPolicy.fromAwsManagedPolicyName(
          "service-role/AWSLambdaBasicExecutionRole"
        ),
      ],
    });

    // Lambda function
    this.calculateWaitingTimeForTargetTimeFunction = new nodejs.NodejsFunction(
      this,
      "CalculateWaitingTimeForTargetTimeFunction",
      {
        entry: "src/lambda/functions/calculate-waiting-time-for-target-time.ts",
        runtime: lambda.Runtime.NODEJS_14_X,
        bundling: {
          minify: true,
        },
        environment: {
          UTC_OFFSET: "9",
          BASE_LOCAL_TIME: "07:30",
        },
        role: lambdaIamRole,
      }
    );
  }
}

import { Stack, StackProps, ScopedAws, Fn } from "aws-cdk-lib";
import { Construct } from "constructs";
import * as logs from "aws-cdk-lib/aws-logs";
import * as sfn from "aws-cdk-lib/aws-stepfunctions";
import * as tasks from "aws-cdk-lib/aws-stepfunctions-tasks";
import * as nodejs from "aws-cdk-lib/aws-lambda-nodejs";

interface StateMachineStackProps extends StackProps {
  calculateWaitingTimeForTargetTimeFunction: nodejs.NodejsFunction;
}

export class StateMachineStack extends Stack {
  public readonly controlStateMachineToRunOnlyOnceADayFunction: nodejs.NodejsFunction;

  constructor(scope: Construct, id: string, props: StateMachineStackProps) {
    super(scope, id, props);

    // Get the string after the stack name in the stack id to append to the end of the Log Group name to make it unique.
    const stackId = new ScopedAws(this).stackId;
    const stackIdAfterStackName = Fn.select(2, Fn.split("/", stackId));

    // Create CloudWatch Logs for Step Functions
    const testStateMachineLogGroup = new logs.LogGroup(
      this,
      "TestStateMachineLogGroup",
      {
        logGroupName: `/aws/vendedlogs/states/testStateMachineLogGroup-${stackIdAfterStackName}`,
        retention: logs.RetentionDays.ONE_WEEK,
      }
    );

    const succeed = new sfn.Succeed(this, "SucceedState");

    new sfn.StateMachine(this, "TestStateMachine", {
      definition: new tasks.LambdaInvoke(
        this,
        "CalculateWaitingTimeForTargetTimeState",
        {
          resultPath: "$.Payload",
          lambdaFunction: props.calculateWaitingTimeForTargetTimeFunction,
          payload: sfn.TaskInput.fromObject({
            "targetLocalTime.$": "$$.Execution.Input.targetLocalTime",
          }),
        }
      ).next(
        new sfn.Choice(this, "ChoiceState")
          .otherwise(new sfn.Fail(this, "FailState"))
          .when(
            sfn.Condition.numberGreaterThanEquals("$.Payload.Payload", 0),
            new sfn.Wait(this, "Wait For Trigger Time", {
              time: sfn.WaitTime.secondsPath("$.Payload.Payload"),
            }).next(succeed)
          )
          .when(sfn.Condition.numberLessThan("$.Payload.Payload", 0), succeed)
      ),
      logs: {
        destination: testStateMachineLogGroup,
        level: sfn.LogLevel.ALL,
      },
    });
  }
}