Étape 1 : Configurer votre projet AWS CDK É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

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

Vous pouvez utiliser le framework AWS Cloud Development Kit (AWS CDK) Infrastructure as Code (IAC) pour créer une machine à AWS Step Functions états contenant une AWS Lambda fonction.

Vous allez définir l' AWS infrastructure en utilisant l'une des CDK langues prises en charge. Après avoir défini votre infrastructure, vous synthétiserez votre application sous forme de AWS CloudFormation modèle et vous la déploierez 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 environnement de AWS CDK développement comme décrit dans la section Getting Started With the AWS CDK - Preuisites du manuel du AWS Cloud Development Kit (AWS CDK) développeur. Ensuite, installez le AWS CDK avec la commande suivante sur 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. Cependant, dans ce didacticiel, vous AWS CDK n'êtes pas obligé de créer des IAM rôles ; il le AWS CDK fait pour vous. La AWS CDK version inclut également une État du flux de travail réussi étape illustrant comment ajouter des étapes supplémentaires à votre machine d'état.

Astuce

Pour déployer un exemple d'application sans serveur qui démarre un Step Functions flux de travail à l'aide de AWS CDK with TypeScript, voir Déployer avec AWS CDK dans The AWS Step Functions Workshop.

Étape 1 : Configurer votre projet AWS CDK

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 nouvelle AWS CDK application.

Important
Assurez-vous de nommer le répertoirestep. Le modèle AWS CDK 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
```
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 ses dépendances AWS CDK de base.
```
source .venv/bin/activate
python -m pip install -r requirements.txt
```
Java
```
cdk init --language java
```
C#
```
cdk init --language csharp
```

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

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

Pour créer une fonction Lambda

Le AWS CDK code suivant définit la Lambda fonction en 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)
});

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 de l'AWS CDKapplication.
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 à états possède deux états : une tâche Lambda fonctionnelle et un É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âches qui 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.

Pour créer et déployer l'AWS CDKapplication

Dans le AWS CDK projet que vous venez de créer, 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 la Lambda fonction et de la machine à Step Functions états figurant dans les 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")))
            });
        }
    }
}

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

AWS CDKexécute l'application et synthétise un AWS CloudFormation modèle à partir de celle-ci. AWS CDKaffiche ensuite le modèle.
Note
Si vous avez TypeScript créé 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 avecAWS 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 AWS d'une infrastructure à l'aideAWS CDK, consultez le guide du AWS CDK développeur.

Pour plus d'informations sur l'écriture d'applis AWS CDK dans la langue de votre choix, veuillez consulter :

Pour plus d'informations sur les modules AWS Construct Library utilisés dans ce didacticiel, consultez les aperçus des références AWS CDK d'API suivants :

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