É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

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

Vous pouvez utiliser le plugin AWS Cloud Development Kit (AWS CDK) Framework Infrastructure as Code (IAC), pour créer un AWS Step Functions machine à états qui contient un AWS Lambda .

Vous allez définir AWS infrastructure utilisant 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 .

Vous allez utiliser cette méthode pour définir une machine à états Step Functions contenant une fonction Lambda, puis exécuter la machine à états en utilisant les 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 dans le AWS Cloud Development Kit (AWS CDK) Guide du 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 votre Compte AWS, voir Module 10 - Déployer avec AWS CDKde The AWS Step Functions Atelier.

É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é. NETversion 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 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
```

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

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.

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

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 à états Step Functions sur votre AWS compte, problèmecdk deploy. Il vous sera demandé d'approuver les IAM politiques AWS CDK a généré.

É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é.

ASCIINon-noms et journalisation
Step Functions accepte les noms des machines d'état, des exécutions, des activités et des étiquettes contenant des caractères autres que des ASCII caractères. Comme ces caractères ne fonctionneront pas avec Amazon CloudWatch, nous vous recommandons de n'utiliser que des ASCII caractères 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 infrastructure utilisant 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 :

Pour plus d'informations sur AWS Construct les modules de bibliothèque utilisés dans ce didacticiel, voir ce qui suit AWS CDK APIAperçus de référence :

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 CDK pour créer un flux de travail Express