Utilisation AWS CDK pour créer un flux de travail standard dans Step Functions

Mode de mise au point

Utilisation AWS CDK pour créer un flux de travail standard dans Step Functions - AWS Step Functions

Étape 1 : Configurez votre AWS CDK project Étape 2 : Utilisation AWS CDK pour créer une machine à états Étape 3 : démarrer l'exécution d'une machine à états Étape 4 : nettoyage Étapes suivantes

Vous pouvez utiliser le plugin AWS Cloud Development Kit (AWS CDK) Framework d'infrastructure en tant que code (IAC), pour créer un AWS Step Functions machine à états qui contient un AWS Lambda .

Vous allez définir AWS l'infrastructure à l'aide de l'un des CDKlangues prises en charge. Après avoir défini votre infrastructure, vous synthétiserez votre application en un AWS CloudFormation modélisez et déployez-le sur votre AWS compte.

Vous allez utiliser cette méthode pour définir une machine à états Step Functions contenant une fonction Lambda, puis exécuter la machine à états à partir de use the Step Functions. AWS Management Console

Avant de commencer ce didacticiel, vous devez configurer votre AWS CDK environnement de développement tel que décrit dans Getting Started With the AWS CDK - Prérequis indiqués dans le guide du AWS Cloud Development Kit (AWS CDK) développeur. Ensuite, installez AWS CDK avec la commande suivante dans AWS CLI:


npm install -g aws-cdk

Ce didacticiel produit le même résultat queUtilisation AWS CloudFormation pour créer un flux de travail dans Step Functions. Toutefois, dans ce didacticiel, AWS CDK ne vous oblige pas à en créer IAM les rôles ; les AWS CDK le fait pour toi. Le AWS CDK La version inclut également une État du flux de travail réussi étape pour illustrer comment ajouter des étapes supplémentaires à votre machine à états.

Astuce

Pour déployer un exemple d'application sans serveur qui démarre un Step Functions flux de travail utilisant AWS CDK avec TypeScript, voir Déployer avec AWS CDKdans The AWS Step Functions Workshop.

Étape 1 : Configurez votre AWS CDK project

Dans votre répertoire personnel, ou dans un autre répertoire si vous préférez, exécutez la commande suivante pour créer un répertoire pour votre nouveau AWS CDK appli.

Important
Assurez-vous de donner un nom au répertoirestep. Le AWS CDK un modèle d'application utilise le nom du répertoire pour générer des noms pour les classes et les fichiers sources. Si vous utilisez un nom différent, votre appli ne correspondra pas à ce didacticiel.
TypeScript
```
mkdir step && cd step
```
JavaScript
```
mkdir step && cd step
```
Python
```
mkdir step && cd step
```
Java
```
mkdir step && cd step
```
C#
Assurez-vous d'avoir installé .NET version 6.0 ou supérieure. Pour plus d'informations, consultez la section Versions prises en charge.
```
mkdir step && cd step
```
anchor anchor anchor anchor anchor
mkdir step && cd step
Initialisez l'application à l'aide de la commande cdk init. Spécifiez le modèle (« app ») et le langage de programmation souhaités, comme indiqué dans les exemples suivants.
TypeScript
```
cdk init --language typescript
```
JavaScript
```
cdk init --language javascript
```
Python
```
cdk init --language python
```
Une fois le projet initialisé, activez l'environnement virtuel du projet et installez AWS CDKles dépendances de base.
```
source .venv/bin/activate
python -m pip install -r requirements.txt
```
Java
```
cdk init --language java
```
C#
```
cdk init --language csharp
```
anchor anchor anchor anchor anchor
cdk init --language typescript

Étape 2 : Utilisation AWS CDK pour créer une machine à états

Tout d'abord, nous allons présenter les différents éléments de code qui définissent le Lambda fonction et Step Functions machine d'État. Ensuite, nous vous expliquerons comment les assembler dans votre AWS CDK appli. Enfin, vous allez voir comment synthétiser et déployer ces ressources.

Pour créer un Lambda fonction

Procédez comme suit : AWS CDK le code définit le Lambda fonction, fournissant son code source en ligne.

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

anchor anchor anchor anchor anchor


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

Vous pouvez voir dans ce court exemple de code :

Le nom logique de la fonction,MyLambdaFunction.
Le code source de la fonction, intégré sous forme de chaîne dans le code source du AWS CDK appli.
Autres attributs de fonction, tels que le temps d'exécution à utiliser (Node 18.x), le point d'entrée de la fonction et un délai d'attente.

Pour créer une machine d'état

Notre machine étatique comporte deux états : un Lambda fonction, tâche et État du flux de travail réussi état. La fonction nécessite que nous créions un Step Functions État du flux de travail des tâchesqui invoque notre fonction. Cet état de tâche est utilisé comme première étape dans la machine à états. L'état de réussite est ajouté à la machine d'état à l'aide de la next() méthode de l'état des tâches. Le code suivant appelle d'abord la fonction nomméeMyLambdaTask, puis utilise la next() méthode pour définir un état de réussite nomméGreetedWorld.

anchor anchor anchor anchor anchor


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

Pour créer et déployer le AWS CDK app

Dans votre nouvelle création AWS CDK projet, modifiez le fichier contenant la définition de la pile pour qu'il ressemble à l'exemple de code suivant. Vous reconnaîtrez les définitions de Lambda fonction et Step Functions machine à états des sections précédentes.

Mettez à jour la pile comme indiqué dans les exemples suivants.

TypeScript

Effectuez la mise à jour lib/step-stack.ts avec le code suivant.


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

Effectuez la mise à jour lib/step-stack.js avec le code suivant.


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

Effectuez la mise à jour step/step_stack.py avec le code suivant.


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

Effectuez la mise à jour src/main/java/com.myorg/StepStack.java avec le code suivant.


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#

Effectuez la mise à jour src/Step/StepStack.cs avec le code suivant.


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

anchor anchor anchor anchor anchor

Effectuez la mise à jour lib/step-stack.ts avec le code suivant.


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

Enregistrez le fichier source, puis exécutez la cdk synth commande dans le répertoire principal de l'application.

AWS CDK exécute l'application et synthétise un AWS CloudFormation modèle à partir de celui-ci. AWS CDK affiche ensuite le modèle.
Note
Si vous aviez TypeScript l'habitude de créer votre AWS CDK projet, l'exécution de la cdk synth commande peut renvoyer l'erreur suivante.
```
TSError: ⨯ Unable to compile TypeScript:
bin/step.ts:7:33 - error TS2554: Expected 2 arguments, but got 3.
```
Modifiez le bin/step.ts fichier comme indiqué dans l'exemple suivant pour résoudre cette erreur.
```
#!/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();
```
Pour déployer la fonction Lambda et la machine d'état Step Functions sur votre AWS compte, lancez. cdk deploy Il vous sera demandé d'approuver les politiques IAM générées. AWS CDK

Étape 3 : démarrer l'exécution d'une machine à états

Après avoir créé votre machine d'état, vous pouvez commencer son exécution.

Pour démarrer l'exécution de la machine d'état

Ouvrez la console Step Functions et choisissez le nom de la machine à états que vous avez créée à l'aide de AWS CDK.
Sur la page State Machine, choisissez Démarrer l'exécution.

La boîte de dialogue Démarrer l'exécution s'affiche.
(Facultatif) Entrez un nom d'exécution personnalisé pour remplacer le nom par défaut généré.

Noms non ASCII et journalisation
Step Functions accepte les noms des machines à états, des exécutions, des activités et des étiquettes contenant des caractères non ASCII. Comme ces caractères ne fonctionnent pas avec Amazon CloudWatch, nous vous recommandons de n'utiliser que des caractères ASCII afin de pouvoir suivre les statistiques. CloudWatch
Choisissez Démarrer une exécution.

L'exécution de votre machine d'état démarre et une nouvelle page indiquant votre exécution en cours s'affiche.
La console Step Functions vous dirige vers une page intitulée avec votre ID d'exécution. Cette page est connue sous le nom de page Détails de l'exécution. Sur cette page, vous pouvez consulter les résultats de l'exécution au fur et à mesure que l'exécution progresse ou une fois celle-ci terminée.

Pour consulter les résultats de l'exécution, choisissez des états individuels dans la vue graphique, puis choisissez les onglets individuels du Détails de l'étape volet pour afficher les détails de chaque état, y compris les entrées, les sorties et la définition respectivement. Pour plus de détails sur les informations d'exécution que vous pouvez consulter sur la page Détails de l'exécution, voirVue d'ensemble des détails d'exécution.

Étape 4 : nettoyage

Après avoir testé votre machine à états, nous vous recommandons de supprimer à la fois votre machine d'état et la fonction Lambda associée afin de libérer des ressources dans votre. Compte AWS Exécutez la cdk destroy commande dans le répertoire principal de votre application pour supprimer votre machine d'état.

Étapes suivantes

Pour en savoir plus sur le développement d'une AWS infrastructure à l'aide de AWS CDK, consultez le AWS CDK Guide du développeur.

Pour plus d'informations sur la rédaction AWS CDK applications dans la langue de votre choix, voir :

anchor anchor anchor anchor anchor

Travailler avec AWS CDK dans TypeScript

Pour plus d'informations sur les modules AWS Construct Library utilisés dans ce didacticiel, consultez ce qui suit AWS CDK Vue d'ensemble des références d'API :

Avertissement JavaScript est désactivé ou n'est pas disponible dans votre navigateur.

Pour que vous puissiez utiliser la documentation AWS, Javascript doit être activé. Vous trouverez des instructions sur les pages d'aide de votre navigateur.

Conventions de rédaction

Créez une machine à états avec CloudFormation

Utilisation du CDK pour créer un flux de travail Express

Sur cette page

Sélectionner vos préférences de cookies

Personnaliser les préférences de cookies

Essentiels

Performances

Fonctionnels

Publicitaires

Impossible d'enregistrer les préférences concernant les cookies

Utilisation AWS CDK pour créer un flux de travail standard dans Step Functions

Astuce

Étape 1 : Configurez votre AWS CDK project

Important

Étape 2 : Utilisation AWS CDK pour créer une machine à états

Pour créer un Lambda fonction

Pour créer une machine d'état

Pour créer et déployer le AWS CDK app

Note

Étape 3 : démarrer l'exécution d'une machine à états

Pour démarrer l'exécution de la machine d'état

Noms non ASCII et journalisation

Étape 4 : nettoyage

Étapes suivantes

Sur cette page

Cette page vous a-t-elle été utile ?

Rubrique suivante :

Rubrique précédente :

Avez-vous besoin d’aide ?