第 1 步：设置您的 AWS CDK 项目第 2 步：使用 AWS CDK 创建状态机第 3 步：启动状态机执行第 4 步：清除后续步骤

用于在 St AWS CDK ep Functions 中创建标准工作流程

可以使用 AWS Cloud Development Kit (AWS CDK)基础设施即代码（IAC）框架，来创建包含 AWS Lambda 函数的 AWS Step Functions 状态机。

您将使用支持的语言之一来定义 AWS 基础架构。CDK定义基础架构后，您需要将应用程序合成到CloudFormation模板中，然后将其部署到您的 AWS 账户。

您将使用此方法来定义包含 Lambda 函数的 Step Functions 状态机，然后通过使用 Step Functions AWS 管理控制台来运行状态机。

在开始本教程之前，您必须按照《AWS Cloud Development Kit (AWS CDK) 开发人员指南》中开始使用 AWS CDK - 先决条件所述，设置您的 AWS CDK 开发环境。然后，在 AWS CLI 中使用以下命令安装 AWS CDK：


npm install -g aws-cdk

本教程产生的结果与用于在 St CloudFormation ep Functions 中创建工作流程相同。但是，在本教程中，AWS CDK 不需要您创建任何 IAM 角色，AWS CDK 会为您创建。AWS CDK 版本还包括一个 Succeed 工作流程状态步骤，用于说明如何向状态机添加其他步骤。

提示

要部署使用和启动Step Functions工作流程的示例无服务器应用程序，请参阅在 The Worksh op AWS CDK 中使用AWS CDK部署。 TypeScript AWS Step Functions

第 1 步：设置您的 AWS CDK 项目

在您的主目录或其他目录中，运行以下命令为您的新 AWS CDK 应用程序创建一个目录。

重要
请确保将目录命名为 step。AWS CDK 应用程序模板使用目录的名称来生成源文件和类的名称。如果您使用其他名称，则您的应用将与本教程不匹配。
TypeScript
```
mkdir step && cd step
```
JavaScript
```
mkdir step && cd step
```
Python
```
mkdir step && cd step
```
Java
```
mkdir step && cd step
```
C#
确保您已安装.NET 版本 6.0 或更高版本。有关信息，请参阅受支持的版本。
```
mkdir step && cd step
```
使用 cdk init 命令初始化应用程序。指定所需的模板（“应用程序”）和编程语言，如以下示例所示。
TypeScript
```
cdk init --language typescript
```
JavaScript
```
cdk init --language javascript
```
Python
```
cdk init --language python
```
初始化项目后，激活项目的虚拟环境并安装 AWS CDK 的基线依赖关系。
```
source .venv/bin/activate
python -m pip install -r requirements.txt
```
Java
```
cdk init --language java
```
C#
```
cdk init --language csharp
```

第 2 步：使用 AWS CDK 创建状态机

首先，我们将展示定义 Lambda 函数和 Step Functions 状态机的单独代码片段。然后，我们将解释如何在您的 AWS CDK 应用程序中将它们组合在一起。最后，您将了解如何合成和部署这些资源。

创建 Lambda 函数

以下 AWS CDK 代码定义了 Lambda 函数，并提供了其内联源代码。

TypeScript


const helloFunction = new lambda.Function(this, 'MyLambdaFunction', {
    code: lambda.Code.fromInline(`
          exports.handler = (event, context, callback) => {
              callback(null, "Hello World!");
          };
      `),
    runtime: lambda.Runtime.NODEJS_18_X,
    handler: "index.handler",
    timeout: cdk.Duration.seconds(3)
});

JavaScript


const helloFunction = new lambda.Function(this, 'MyLambdaFunction', {
    code: lambda.Code.fromInline(`
          exports.handler = (event, context, callback) => {
              callback(null, "Hello World!");
          };
      `),
    runtime: lambda.Runtime.NODEJS_18_X,
    handler: "index.handler",
    timeout: cdk.Duration.seconds(3)
});

Python


hello_function = lambda_.Function(
            self, "MyLambdaFunction",
            code=lambda_.Code.from_inline("""
            exports.handler = (event, context, callback) => {
                callback(null, "Hello World!");
                }"""),
                runtime=lambda_.Runtime.NODEJS_18_X,
                handler="index.handler",
                timeout=Duration.seconds(25))

Java


final Function helloFunction = Function.Builder.create(this, "MyLambdaFunction")
        .code(Code.fromInline(
                "exports.handler = (event, context, callback) => { callback(null, 'Hello World!' );}"))
        .runtime(Runtime.NODEJS_18_X)
        .handler("index.handler")
        .timeout(Duration.seconds(25))
        .build();

C#


var helloFunction = new Function(this, "MyLambdaFunction", new FunctionProps
{
    Code = Code.FromInline(@"`
      exports.handler = (event, context, callback) => {
        callback(null, 'Hello World!');
      }"),
    Runtime = Runtime.NODEJS_12_X,
    Handler = "index.handler",
    Timeout = Duration.Seconds(25)
});

您可以在这个简短的示例代码中看到：

函数的逻辑名称 MyLambdaFunction。
函数的源代码，以字符串形式嵌入到 AWS CDK 应用程序的源代码中。
其他函数属性，例如要使用的运行时间（节点 18.x）、函数的入口点和超时。

创建状态机

我们的状态机有两种状态：Lambda 函数任务和 Succeed 工作流程状态状态。该函数要求我们创建一个 Step Functions Task 工作流程状态来调用我们的函数。此 Task 状态用作状态机的第一个步骤。使用 Task 状态的next()方法将 success 状态添加到状态机中。以下代码首先调用名为 MyLambdaTask 的函数，然后使用 next() 方法定义名为 GreetedWorld 的 success 状态。

构建并部署 AWS CDK 应用程序

在新创建的 AWS CDK 项目中，编辑包含堆栈定义的文件，使其与下面的示例代码类似。您将从前面的部分中了解 Lambda 函数和 Step Functions 状态机的定义。

如下例所示更新堆栈。

TypeScript

使用以下代码更新 lib/step-stack.ts。


import * as cdk from 'aws-cdk-lib';
import * as lambda from 'aws-cdk-lib/aws-lambda';
import * as sfn from 'aws-cdk-lib/aws-stepfunctions';
import * as tasks from 'aws-cdk-lib/aws-stepfunctions-tasks';

export class StepStack extends cdk.Stack {
  constructor(app: cdk.App, id: string) {
    super(app, id);

    const helloFunction = new lambda.Function(this, 'MyLambdaFunction', {
      code: lambda.Code.fromInline(`
          exports.handler = (event, context, callback) => {
              callback(null, "Hello World!");
          };
      `),
      runtime: lambda.Runtime.NODEJS_18_X,
      handler: "index.handler",
      timeout: cdk.Duration.seconds(3)
    });

    const stateMachine = new sfn.StateMachine(this, 'MyStateMachine', {
      definition: new tasks.LambdaInvoke(this, "MyLambdaTask", {
        lambdaFunction: helloFunction
      }).next(new sfn.Succeed(this, "GreetedWorld"))
    });
  }
}

JavaScript

使用以下代码更新 lib/step-stack.js。


import * as cdk from 'aws-cdk-lib';
import * as lambda from 'aws-cdk-lib/aws-lambda';
import * as sfn from 'aws-cdk-lib/aws-stepfunctions';
import * as tasks from 'aws-cdk-lib/aws-stepfunctions-tasks';

export class StepStack extends cdk.Stack {
  constructor(app, id) {
    super(app, id);

    const helloFunction = new lambda.Function(this, 'MyLambdaFunction', {
      code: lambda.Code.fromInline(`
          exports.handler = (event, context, callback) => {
              callback(null, "Hello World!");
          };
      `),
      runtime: lambda.Runtime.NODEJS_18_X,
      handler: "index.handler",
      timeout: cdk.Duration.seconds(3)
    });

    const stateMachine = new sfn.StateMachine(this, 'MyStateMachine', {
      definition: new tasks.LambdaInvoke(this, "MyLambdaTask", {
        lambdaFunction: helloFunction
      }).next(new sfn.Succeed(this, "GreetedWorld"))
    });
  }
}

Python

使用以下代码更新 step/step_stack.py。


from aws_cdk import (
    Duration,
    Stack,
    aws_stepfunctions as sfn,
    aws_stepfunctions_tasks as tasks,
    aws_lambda as lambda_
)
class StepStack(Stack):

    def __init__(self, scope: Construct, construct_id: str, **kwargs) -> None:
        super().__init__(scope, construct_id, **kwargs)

        hello_function = lambda_.Function(
            self, "MyLambdaFunction",
            code=lambda_.Code.from_inline("""
            exports.handler = (event, context, callback) => {
                callback(null, "Hello World!");
                }"""),
                runtime=lambda_.Runtime.NODEJS_18_X,
                handler="index.handler",
                timeout=Duration.seconds(25))

        state_machine = sfn.StateMachine(
            self, "MyStateMachine",
            definition=tasks.LambdaInvoke(
            self, "MyLambdaTask",
            lambda_function=hello_function)
            .next(sfn.Succeed(self, "GreetedWorld")))

Java

使用以下代码更新 src/main/java/com.myorg/StepStack.java。


package com.myorg;

import software.constructs.Construct;
import software.amazon.awscdk.Stack;
import software.amazon.awscdk.StackProps;
import software.amazon.awscdk.Duration;
import software.amazon.awscdk.services.lambda.Code;
import software.amazon.awscdk.services.lambda.Function;
import software.amazon.awscdk.services.lambda.Runtime;
import software.amazon.awscdk.services.stepfunctions.StateMachine;
import software.amazon.awscdk.services.stepfunctions.Succeed;
import software.amazon.awscdk.services.stepfunctions.tasks.LambdaInvoke;

public class StepStack extends Stack {
    public StepStack(final Construct scope, final String id) {
        this(scope, id, null);
    }

    public StepStack(final Construct scope, final String id, final StackProps props) {
        super(scope, id, props);

        final Function helloFunction = Function.Builder.create(this, "MyLambdaFunction")
                .code(Code.fromInline(
                        "exports.handler = (event, context, callback) => { callback(null, 'Hello World!' );}"))
                .runtime(Runtime.NODEJS_18_X)
                .handler("index.handler")
                .timeout(Duration.seconds(25))
                .build();

        final StateMachine stateMachine = StateMachine.Builder.create(this, "MyStateMachine")
                .definition(LambdaInvoke.Builder.create(this, "MyLambdaTask")
                        .lambdaFunction(helloFunction)
                        .build()
                        .next(new Succeed(this, "GreetedWorld")))
                .build();
    }
}

C#

使用以下代码更新 src/Step/StepStack.cs。


using Amazon.CDK;
using Constructs;
using Amazon.CDK.AWS.Lambda;
using Amazon.CDK.AWS.StepFunctions;
using Amazon.CDK.AWS.StepFunctions.Tasks;

namespace Step
{
    public class StepStack : Stack
    {
        internal StepStack(Construct scope, string id, IStackProps props = null) : base(scope, id, props)
        {
            var helloFunction = new Function(this, "MyLambdaFunction", new FunctionProps
            {
                Code = Code.FromInline(@"exports.handler = (event, context, callback) => {
                    callback(null, 'Hello World!');
                }"),
                Runtime = Runtime.NODEJS_18_X,
                Handler = "index.handler",
                Timeout = Duration.Seconds(25)
            });

            var stateMachine = new StateMachine(this, "MyStateMachine", new StateMachineProps
            {
                DefinitionBody = DefinitionBody.FromChainable(new LambdaInvoke(this, "MyLambdaTask", new LambdaInvokeProps
                {
                    LambdaFunction = helloFunction
                })
                .Next(new Succeed(this, "GreetedWorld")))
            });
        }
    }
}

保存源文件，然后在应用程序的主目录中运行 cdk synth 命令。

AWS CDK 运行应用程序并合成 CloudFormation 模板。然后，AWS CDK 会显示该模板。
注意
如果您曾经 TypeScript 创建过AWS CDK项目，则运行该cdk synth命令可能会返回以下错误。
```
TSError: ⨯ Unable to compile TypeScript:
bin/step.ts:7:33 - error TS2554: Expected 2 arguments, but got 3.
```
修改 bin/step.ts 文件，如以下示例所示，可解决此错误。
```
#!/usr/bin/env node
import 'source-map-support/register';
import * as cdk from 'aws-cdk-lib';
import { StepStack } from '../lib/step-stack';

const app = new cdk.App();
new StepStack(app, 'StepStack');
app.synth();
```
要将 Lambda 函数和 Step Functions 状态机部署到您的 AWS 账户，请发出 cdk deploy。系统将要求您批准 AWS CDK 已生成的 IAM 策略。

第 3 步：启动状态机执行

在创建您的状态机后，可以开始执行。

启动状态机执行

打开 Step Functions 控制台，然后选择您使用 AWS CDK 创建的状态机的名称。
在状态机页面，选择启动执行。

随即显示启动执行对话框。
（可选）输入自定义执行名称，以便覆盖生成的默认执行名称。

非 ASCII 名称和日志记录
Step Functions 对于状态机、执行、活动和标签接受包含非 ASCII 字符的名称。由于此类字符会 CloudWatch 阻止亚马逊记录数据，因此我们建议您仅使用 ASCII 字符，这样您就可以跟踪 Step Functions 的指标。
选择开始执行。

状态机的执行将启动，并显示一个说明正在运行的执行的新页面。
Step Functions 控制台会将您引导到一个以您的执行 ID 为标题的页面。该页面被称为执行详细信息页面。在此页面上，您可以随着执行的进展或者在执行完成后查看执行结果。

要查看执行结果，请在图表视图上选择各个状态，然后在步骤详细信息窗格中选择各个选项卡，分别查看每个状态的详细信息，包括输入、输出和定义。有关可在执行详细信息页面上查看的执行信息的详细信息，请参阅执行详细信息概览。

第 4 步：清除

测试状态机完成后，我们建议您删除状态机和相关的 Lambda 函数，以释放 AWS 账户中的资源。在您的应用程序的主目录中运行 cdk destroy 命令，以删除状态机。

后续步骤

要详细了解如何使用开发 AWS 基础架构AWS CDK，请参阅《AWS CDK开发人员指南》。

有关使用所选语言编写 AWS CDK 应用程序的信息，请参阅：

有关本教程中使用的 AWS 构造库模块的更多信息，请参阅以下 AWS CDK API 参考概述：

Javascript 在您的浏览器中被禁用或不可用。

要使用 Amazon Web Services 文档，必须启用 Javascript。请参阅浏览器的帮助页面以了解相关说明。

文档惯例

使用创建状态机 CloudFormation

使用 CDK 创建快速工作流程