Paso 1: Configura tu AWS CDK project Paso 2: usar AWS CDK para crear una máquina de estados Paso 3: Iniciar la ejecución de una máquina de estado Paso 4: Eliminación Siguientes pasos

Utilización AWS CDK para crear un flujo de trabajo estándar en Step Functions

Puede utilizar el AWS Cloud Development Kit (AWS CDK) Infraestructura como marco de código (IAC), para crear un AWS Step Functions máquina de estados que contiene un AWS Lambda función.

Definirás AWS infraestructura mediante uno de los CDKsus idiomas compatibles. Después de definir la infraestructura, sintetizará la aplicación en un AWS CloudFormation diseñe una plantilla e impleméntela en su AWS account.

Utilizará este método para definir una máquina de estados de Step Functions que contenga una función Lambda y, a continuación, ejecutará la máquina de estados desde el uso de Step Functions AWS Management Console.

Antes de comenzar este tutorial, debe configurar su AWS CDK entorno de desarrollo tal y como se describe en Cómo empezar con AWS CDK - Requisitos previos en el AWS Cloud Development Kit (AWS CDK) Guía para desarrolladores. A continuación, instale el AWS CDK con el siguiente comando en el AWS CLI:


npm install -g aws-cdk

Este tutorial produce el mismo resultado que Utilización AWS CloudFormation para crear un flujo de trabajo en Step Functions. Sin embargo, en este tutorial, el AWS CDK no requiere que crees ninguna IAM roles; los AWS CDK lo hace por ti. La AWS CDK la versión también incluye un Estado de flujo de trabajo exitoso paso para ilustrar cómo agregar pasos adicionales a su máquina de estados.

sugerencia

Para implementar un ejemplo de aplicación sin servidor que inicie un Step Functions flujo de trabajo mediante AWS CDK TypeScript con tu Cuenta de AWS, consulte el Módulo 10: Implementar con AWS CDKde The AWS Step Functions Taller.

Paso 1: Configura tu AWS CDK project

En su directorio principal, o en otro directorio si lo prefiere, ejecute el siguiente comando para crear un directorio para su nuevo AWS CDK aplicación.

importante
Asegúrese de asignarle al directorio el nombre step. La AWS CDK la plantilla de la aplicación utiliza el nombre del directorio para generar nombres para las clases y los archivos fuente. Si utiliza otro nombre, la aplicación no coincidirá con este tutorial.
TypeScript
```
mkdir step && cd step
```
JavaScript
```
mkdir step && cd step
```
Python
```
mkdir step && cd step
```
Java
```
mkdir step && cd step
```
C#
Asegúrese de que lo ha instalado. NETversión 6.0 o superior. Para obtener información, consulte Versiones compatibles.
```
mkdir step && cd step
```
Inicialice la aplicación mediante el comando cdk init. Especifique la plantilla ("aplicación") y el lenguaje de programación que desee, tal y como se muestra en los siguientes ejemplos.
TypeScript
```
cdk init --language typescript
```
JavaScript
```
cdk init --language javascript
```
Python
```
cdk init --language python
```
Una vez inicializado el proyecto, active el entorno virtual del proyecto e instale el AWS CDKsus dependencias de referencia.
```
source .venv/bin/activate
python -m pip install -r requirements.txt
```
Java
```
cdk init --language java
```
C#
```
cdk init --language csharp
```

Paso 2: usar AWS CDK para crear una máquina de estados

En primer lugar, presentaremos los fragmentos individuales de código que definen el Lambda función y el Step Functions máquina de estados. Luego, te explicaremos cómo unirlos en tu AWS CDK aplicación. Por último, verá cómo sintetizar e implementar estos recursos.

Para crear un Lambda función

Los siguientes ejemplos de AWS CDK el código define el Lambda función, proporcionando su código fuente en línea.

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

En este breve ejemplo de código, puede ver lo siguiente:

El nombre lógico de la función, MyLambdaFunction.
El código fuente de la función, incrustado como una cadena en el código fuente del AWS CDK aplicación.
Otros atributos de la función, como el tiempo de ejecución que se va a utilizar (Node 18.x), el punto de entrada de la función y el tiempo de espera.

Para crear una máquina de estado

Nuestra máquina de estados tiene dos estados: a Lambda función, tarea y Estado de flujo de trabajo exitoso estado. La función requiere que creemos un Step Functions Estado del flujo de trabajo de tareasque invoca nuestra función. Este estado de tarea se usa como primer paso en la máquina de estado. El estado de éxito se agrega a la máquina de estado mediante el método next() del estado de la tarea. El código siguiente invoca primero a la función nombrada MyLambdaTask y, a continuación, utiliza el método next() para definir un estado de éxito denominado GreetedWorld.

Para crear e implementar el AWS CDK Aplicación

En tu recién creado AWS CDK proyecto, edita el archivo que contiene la definición de la pila para que se parezca al siguiente código de ejemplo. Reconocerás las definiciones de Lambda función y el Step Functions máquina de estados de las secciones anteriores.

Actualice la pila como se muestra en los siguientes ejemplos.

TypeScript

Actualice lib/step-stack.ts con el siguiente código.


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

Actualice lib/step-stack.js con el siguiente código.


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

Actualice step/step_stack.py con el siguiente código.


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

Actualice src/main/java/com.myorg/StepStack.java con el siguiente código.


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#

Actualice src/Step/StepStack.cs con el siguiente código.


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

Guarde el archivo de código fuente y a continuación ejecute el comando cdk synth en el directorio principal de la aplicación.

AWS CDK ejecuta la aplicación y sintetiza un AWS CloudFormation plantilla a partir de ella. AWS CDK luego muestra la plantilla.
nota
Si solía TypeScript crear su AWS CDK Al ejecutar el cdk synth comando, es posible que se devuelva el siguiente error.
```
TSError: ⨯ Unable to compile TypeScript:
bin/step.ts:7:33 - error TS2554: Expected 2 arguments, but got 3.
```
Vuelva a formalizar el archivo bin/step.ts como se muestra en el ejemplo siguiente para resolver este error.
```
#!/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 implementar la función Lambda y la máquina de estados Step Functions en su AWS cuenta, emisión. cdk deploy Se te pedirá que apruebes las IAM políticas del AWS CDK ha generado.

Paso 3: Iniciar la ejecución de una máquina de estado

Después de crear la máquina de estado, puede iniciar su ejecución.

Para iniciar la ejecución de la máquina de estado

Abra la consola Step Functions y elija el nombre de la máquina de estados que ha creado mediante AWS CDK.
En la página de la máquina de estado, seleccione Iniciar ejecución.

Aparece el cuadro de diálogo Iniciar ejecución.
(Opcional) Introduzca un nombre de ejecución personalizado para anular el valor predeterminado generado.

ASCIINombres no identificables y registro
Step Functions acepta nombres para máquinas de estados, ejecuciones, actividades y etiquetas que no contengan ASCII caracteres. Como estos personajes no funcionan con Amazon CloudWatch, te recomendamos que utilices solo ASCII caracteres para poder hacer un seguimiento de las métricas CloudWatch.
Seleccione Iniciar ejecución.

Se inicia la ejecución de su máquina de estado y aparece una nueva página que muestra la ejecución en funcionamiento.
La consola de Step Functions le dirige a una página cuyo título es su ID de ejecución. Esta página se conoce como Detalles de la ejecución. En esta página, puede revisar los resultados de la ejecución a medida que avanza la ejecución o una vez finalizada.

Para revisar los resultados de la ejecución, elija los estados individuales en la Vista de gráfico y, a continuación, elija las pestañas individuales del panel Detalles del paso para ver los detalles de cada estado, incluidas la entrada, la salida y la definición, respectivamente. Para obtener más información sobre la ejecución que puede ver en la página Detalles de la ejecución, consulte Descripción general de los detalles de ejecución.

Paso 4: Eliminación

Después de probar la máquina de estados, le recomendamos que la quite y la función Lambda relacionada para liberar recursos en su Cuenta de AWS. Ejecuta el cdk destroy comando en el directorio principal de la aplicación para eliminar la máquina de estados.

Siguientes pasos

Para obtener más información sobre el desarrollo AWS uso de la infraestructura AWS CDK, consulte la AWS CDK Guía para desarrolladores.

Para obtener información sobre la escritura AWS CDK aplicaciones en el idioma que prefiera, consulte:

Para obtener más información sobre el AWS Los módulos de biblioteca de construcción utilizados en este tutorial, consulte lo siguiente AWS CDK APIResúmenes de referencia:

Aviso JavaScript está desactivado o no está disponible en su navegador.

Para utilizar la documentación de AWS, debe estar habilitado JavaScript. Para obtener más información, consulte las páginas de ayuda de su navegador.

Convenciones del documento

Cree una máquina de estados con CloudFormation

Se utiliza CDK para crear un flujo de trabajo exprés