Etapa 1: configure seu AWS CDK project Etapa 2: Usar AWS CDK para criar uma máquina de estado Etapa 3: Iniciar a execução de uma máquina de estado Etapa 4: Limpeza Próximas etapas

O uso do AWS CDK para criar um fluxo de trabalho padrão em Step Functions

Você pode usar o AWS Cloud Development Kit (AWS CDK) Estrutura de infraestrutura como código (IAC), para criar um AWS Step Functions máquina de estado que contém um AWS Lambda função.

Você definirá AWS infraestrutura usando um dos CDKidiomas suportados pela. Depois de definir sua infraestrutura, você sintetizará seu aplicativo em um AWS CloudFormation modelo e implante-o em seu AWS conta.

Você usará esse método para definir uma máquina de estado Step Functions contendo uma função Lambda e, em seguida, executará a máquina de estado usando o Step Functions. AWS Management Console.

Antes de começar este tutorial, você deve configurar seu AWS CDK ambiente de desenvolvimento conforme descrito em Introdução ao AWS CDK - Pré-requisitos no AWS Cloud Development Kit (AWS CDK) Guia do desenvolvedor. Em seguida, instale o AWS CDK com o seguinte comando no AWS CLI:


npm install -g aws-cdk

Este tutorial produz o mesmo resultado que O uso do AWS CloudFormation para criar um fluxo de trabalho em Step Functions. No entanto, neste tutorial, o AWS CDK não exige que você crie nenhum IAM funções; o AWS CDK faz isso por você. A ferramenta AWS CDK A versão também inclui uma Estado bem-sucedido do fluxo de trabalho etapa para ilustrar como adicionar etapas adicionais à sua máquina de estado.

dica

Para implantar um exemplo de aplicativo sem servidor que inicia um Step Functions fluxo de trabalho usando AWS CDK com TypeScript a sua Conta da AWS, consulte o Módulo 10 - Implantar com AWS CDKdo AWS Step Functions Workshop.

Etapa 1: configure seu AWS CDK project

Em seu diretório inicial ou em outro diretório, se preferir, execute o comando a seguir para criar um diretório para seu novo AWS CDK aplicativo.

Importante
Dê ao diretório o nome step. A ferramenta AWS CDK o modelo de aplicativo usa o nome do diretório para gerar nomes para classes e arquivos de origem. Se você escolher outro nome, sua aplicação não combinará com este tutorial.
TypeScript
```
mkdir step && cd step
```
JavaScript
```
mkdir step && cd step
```
Python
```
mkdir step && cd step
```
Java
```
mkdir step && cd step
```
C#
Verifique se você instalou. NETversão 6.0 ou superior. Para obter informações, consulte Versões compatíveis.
```
mkdir step && cd step
```
Inicialize o aplicativo usando o comando cdk init. Especifique o modelo (“aplicação”) e a linguagem de programação desejados conforme mostrado nos exemplos a seguir.
TypeScript
```
cdk init --language typescript
```
JavaScript
```
cdk init --language javascript
```
Python
```
cdk init --language python
```
Depois que o projeto for inicializado, ative o ambiente virtual do projeto e instale o AWS CDKdependências básicas do.
```
source .venv/bin/activate
python -m pip install -r requirements.txt
```
Java
```
cdk init --language java
```
C#
```
cdk init --language csharp
```

Etapa 2: Usar AWS CDK para criar uma máquina de estado

Primeiro, apresentaremos as partes individuais do código que definem o Lambda função e o Step Functions máquina de estado. Em seguida, explicaremos como juntá-los em seu AWS CDK aplicativo. Por fim, você verá como sintetizar e implantar esses recursos.

Para criar um Lambda função

Os seguintes exemplos de AWS CDK o código define o Lambda função, fornecendo seu código-fonte embutido.

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)
});

Você pode ver, neste exemplo de código curto:

O nome lógico da função, MyLambdaFunction.
O código-fonte da função, incorporado como uma string no código-fonte do AWS CDK aplicativo.
Outros atributos da função, como o runtime a ser usado (Node 18.x), o ponto de entrada da função e um tempo limite.

Para criar uma máquina de estado do

Nossa máquina de estados tem dois estados: um Lambda função, tarefa e um Estado bem-sucedido do fluxo de trabalho estado. A função exige que criemos um Step Functions Estado do fluxo de trabalho da tarefaque invoca nossa função. Esse estado de tarefa é usado como a primeira etapa na máquina de estado. O estado de sucesso é adicionado à máquina de estado usando o método next() do estado da tarefa. O código a seguir primeiro invoca a função chamada MyLambdaTask e depois, usa o método next() para definir um estado de sucesso chamado GreetedWorld.

Para criar e implantar o AWS CDK aplicativo

Em seu recém-criado AWS CDK projeto, edite o arquivo que contém a definição da pilha para que se pareça com o código de exemplo a seguir. Você reconhecerá as definições do Lambda função e o Step Functions máquina de estado das seções anteriores.

Atualize a pilha como mostrado nos exemplos a seguir.

TypeScript

Atualize o lib/step-stack.ts com o código a seguir.


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

Atualize o lib/step-stack.js com o código a seguir.


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

Atualize o step/step_stack.py com o código a seguir.


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

Atualize o src/main/java/com.myorg/StepStack.java com o código a seguir.


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#

Atualize o src/Step/StepStack.cs com o código a seguir.


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")))
            });
        }
    }
}

Salve o arquivo de origem e execute o comando cdk synth no diretório principal da aplicação.

AWS CDK executa o aplicativo e sintetiza um AWS CloudFormation modelo a partir dele. AWS CDK em seguida, exibe o modelo.
nota
Se você TypeScript costumava criar seu AWS CDK projeto, a execução do cdk synth comando pode retornar o seguinte erro.
```
TSError: ⨯ Unable to compile TypeScript:
bin/step.ts:7:33 - error TS2554: Expected 2 arguments, but got 3.
```
Modifique o arquivo bin/step.ts conforme mostrado no exemplo a seguir para resolver esse erro.
```
#!/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();
```
Para implantar a função Lambda e a máquina de estado Step Functions em seu AWS conta, problemacdk deploy. Você deverá aprovar IAM as políticas do AWS CDK gerou.

Etapa 3: Iniciar a execução de uma máquina de estado

Assim que você criar sua máquina de estado, poderá iniciar sua execução.

Para iniciar a execução da máquina de estado

Abra o console Step Functions e escolha o nome da máquina de estado que você criou usando AWS CDK.
Na página da máquina de estado, escolha Iniciar execução.

A caixa de diálogo Iniciar execução é exibida.
(Opcional) Insira um nome de execução personalizado para substituir o padrão gerado.

ASCIINão-nomes e registro
Step Functions aceita nomes para máquinas de estado, execuções, atividades e rótulos que não contêm ASCII caracteres. Como esses caracteres não funcionarão com a Amazon CloudWatch, recomendamos usar somente ASCII caracteres para que você possa acompanhar as métricas CloudWatch.
Escolha Start Execution.

A execução da máquina de estado começa e uma nova página mostrando a execução em andamento é exibida.
O console do Step Functions direciona você para uma página em que o título é o ID da execução. Essa página é conhecida como página de Detalhes da execução. Nesta página, você pode revisar os resultados da execução à medida que a execução avança ou após a conclusão.

Para revisar os resultados da execução, escolha estados individuais na Exibição em gráfico e, em seguida, escolha as guias individuais no painel Detalhes da etapa para visualizar os detalhes de cada estado, incluindo entrada, saída e definição, respectivamente. Para obter detalhes sobre as informações de execução que você pode visualizar na página Detalhes da execução, consulte Visão geral dos detalhes da execução.

Etapa 4: Limpeza

Depois de testar sua máquina de estado, recomendamos que você remova sua máquina de estado e a função Lambda relacionada para liberar recursos em sua Conta da AWS. Execute o cdk destroy comando no diretório principal do seu aplicativo para remover sua máquina de estado.

Próximas etapas

Para saber mais sobre o desenvolvimento AWS infraestrutura usando AWS CDK, veja o AWS CDK Guia do desenvolvedor.

Para obter informações sobre redação AWS CDK aplicativos no idioma de sua escolha, consulte:

Para obter mais informações sobre o AWS Construa módulos de biblioteca usados neste tutorial, veja o seguinte AWS CDK APIVisões gerais de referência:

Atenção O Javascript está desativado ou não está disponível no seu navegador.

Para usar a documentação da AWS, o Javascript deve estar ativado. Consulte as páginas de Ajuda do navegador para obter instruções.

Convenções do documento

Crie uma máquina de estado com CloudFormation

Usando CDK para criar um fluxo de trabalho Express