Paso 1: Configurar el proyecto de AWS CDK Paso 2: Usar AWS CDK para crear una máquina de estado Paso 3: Iniciar la ejecución de una máquina de estado Paso 4: Eliminación Pasos a seguir a continuación

Uso AWS CDK para crear un flujo de trabajo estándar en Step Functions

Puede utilizar el marco de infraestructura como código (IAC) de AWS Cloud Development Kit (AWS CDK) para crear una máquina de estado AWS Step Functions que contenga una función de AWS Lambda.

Definirá AWS la infraestructura utilizando uno CDK de los lenguajes compatibles. Después de definir la infraestructura, sintetizará la aplicación en una AWS CloudFormation plantilla y la implementará en su AWS cuenta.

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

Antes de comenzar este tutorial, debe configurar su entorno de desarrollo de AWS CDK tal y como se describe en Getting Started With the AWS CDK - Prerequisites en la AWS Cloud Development Kit (AWS CDK) Developer Guide. A continuación, instale el AWS CDK con el siguiente comando en la 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, no se necesita que AWS CDK cree ningún rol de IAM; el AWS CDK lo hace por usted. La versión de AWS CDK también incluye un paso Estado Succeed de un flujo de trabajo para ilustrar cómo añadir pasos adicionales a su máquina de estado.

sugerencia

Para implementar un ejemplo de aplicación sin servidor que inicie un Step Functions flujo de trabajo AWS CDK con TypeScript, consulte Implementar con AWS CDK en The AWS Step Functions Workshop.

Paso 1: Configurar el proyecto de AWS CDK

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

importante
Asegúrese de asignarle al directorio el nombre step. La plantilla de la aplicación de AWS CDK utiliza el nombre del directorio para generar nombres para los archivos y las clases 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 haber instalado la versión 6.0 o superior de .NET. 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
```
Después de inicializar el proyecto, active el entorno virtual del proyecto e instale las dependencias de referencia del AWS CDK.
```
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 estado

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

Para crear una función Lambda

El siguiente código de AWS CDK define la función Lambda y proporciona 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 de la aplicación de AWS CDK.
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 estado tiene dos estados: una tarea de función de Lambda, una tarea y un estado Estado Succeed de un flujo de trabajo. La función requiere que creemos una Estado de un flujo de trabajo de tarea de Step Functions que invoque 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 compilar e implementar la aplicación de AWS CDK

En el proyecto de AWS CDK recién creado, edite el archivo que contiene la definición de pila para que tenga el aspecto de uno de los siguientes códigos de ejemplo. Reconocerá las definiciones de la función de Lambda y la máquina de estado de Step Functions 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.

El AWS CDK ejecuta la aplicación y sintetiza una plantilla de AWS CloudFormation y, a continuación, AWS CDK la muestra.
nota
Si solías TypeScript crear tu AWS CDK proyecto, al ejecutar el cdk synth comando se puede producir 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 de Lambda y la máquina de estado de Step Functions en su cuenta de AWS , procese cdk deploy. Se le pedirá que apruebe las políticas de IAM que AWS CDK haya 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 de Step Functions y elija el nombre de la máquina de estado que creó 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.

Nombres y registros con caracteres no ASCII
Step Functions acepta nombres para máquinas de estado, ejecuciones, actividades y etiquetas que contengan caracteres no ASCII. Como estos caracteres no funcionan con Amazon CloudWatch, te recomendamos que utilices únicamente caracteres ASCII para poder realizar un seguimiento de las CloudWatch métricas.
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 Información general sobre los detalles de ejecución.

Paso 4: Eliminación

Una vez que haya probado la máquina de estado, le recomendamos que la elimine junto con la función de Lambda relacionada para liberar recursos en su Cuenta de AWS. Ejecute el comando cdk destroy en el directorio principal de la aplicación para eliminar la máquina de estado.

Pasos a seguir a continuación

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

Para obtener información acerca de cómo escribir aplicaciones AWS CDK en el lenguaje que elija, consulte:

Para obtener más información sobre los módulos de AWS Construct Library que se utilizan en este tutorial, consulte las siguientes descripciones generales de las referencias de AWS CDK API:

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

Uso de CDK para crear un flujo de trabajo rápido