Skip to content
Learni
View all tutorials
Cloud & Serverless

Comment orchestrer des workflows complexes avec AWS Step Functions en 2026

22 minEXPERT
AWSStep FunctionsCDK

Introduction

AWS Step Functions permet d'orchestrer des services AWS et des microservices via des machines à états visuelles. En 2026, son adoption explose pour les architectures event-driven complexes. Ce tutoriel expert vous guide de la définition ASL jusqu'au déploiement CDK avec gestion d'erreurs avancée, callbacks et intégration Lambda optimisée. Vous apprendrez à éviter les anti-patterns et à garantir la résilience en production.

Prérequis

  • AWS CLI v2 configuré avec profil admin
  • Node.js 20+ et AWS CDK v2
  • Connaissances solides en TypeScript et IAM
  • Un compte AWS avec crédits pour tests

Initialisation du projet CDK

terminal
mkdir step-functions-workflow && cd step-functions-workflow
npx aws-cdk init app --language=typescript
npm install aws-cdk-lib constructs

Initialise un projet CDK TypeScript et installe les dépendances essentielles pour définir des State Machines.

Définition de la State Machine de base

lib/workflow-stack.ts
import * as cdk from 'aws-cdk-lib';
import * as sfn from 'aws-cdk-lib/aws-stepfunctions';
import * as lambda from 'aws-cdk-lib/aws-lambda';
import { Construct } from 'constructs';

export class WorkflowStack extends cdk.Stack {
  constructor(scope: Construct, id: string, props?: cdk.StackProps) {
    super(scope, id, props);
    const processFn = new lambda.Function(this, 'ProcessFn', {
      runtime: lambda.Runtime.NODEJS_20_X,
      handler: 'index.handler',
      code: lambda.Code.fromInline('exports.handler = async () => ({ status: "ok" });'),
    });
    const definition = sfn.Chain.start(
      new sfn.Task(this, 'ProcessTask', {
        task: new sfn.LambdaInvoke(this, 'InvokeProcess', {
          lambdaFunction: processFn,
        }),
      })
    );
    new sfn.StateMachine(this, 'ComplexWorkflow', {
      definitionBody: sfn.DefinitionBody.fromChainable(definition),
      stateMachineType: sfn.StateMachineType.STANDARD,
    });
  }
}

Ce code CDK définit une State Machine STANDARD avec une tâche Lambda. Il utilise DefinitionBody pour une meilleure maintenabilité en 2026.

Ajout d'un état Choice et Parallel

lib/advanced-workflow.ts
const choice = new sfn.Choice(this, 'CheckStatus');
const parallel = new sfn.Parallel(this, 'ParallelTasks');
parallel.branch(new sfn.LambdaInvoke(this, 'Branch1', { lambdaFunction: fn1 }));
parallel.branch(new sfn.LambdaInvoke(this, 'Branch2', { lambdaFunction: fn2 }));
const definition = sfn.Chain
  .start(processTask)
  .next(choice
    .when(sfn.Condition.stringEquals('$.status', 'success'), parallel)
    .otherwise(new sfn.Fail(this, 'Failed', { error: 'ValidationError' }))
  );

Ajoute un Choice pour le routage conditionnel et un Parallel pour exécution concurrente. Évite les boucles infinies avec des conditions strictes.

Intégration de Error Handling avancé

lib/error-handling.ts
const retryPolicy = {
  maxAttempts: 3,
  interval: cdk.Duration.seconds(2),
  backoffRate: 2,
};
const catchPolicy = new sfn.Catch(this, 'CatchAll', {
  errors: ['States.TaskFailed'],
  resultPath: '$.error',
});
const taskWithRetry = new sfn.Task(this, 'ResilientTask', {
  task: new sfn.LambdaInvoke(this, 'InvokeWithRetry', {
    lambdaFunction: processFn,
  }),
}).addRetry(retryPolicy).addCatch(catchPolicy);

Implémente retry exponentiel et catch global. Garantit la résilience sans dupliquer la logique d'erreur dans chaque Lambda.

Déploiement et test de la machine

terminal
cdk deploy
aws stepfunctions start-execution \
  --state-machine-arn arn:aws:states:eu-west-1:123456789012:stateMachine:ComplexWorkflow \
  --input '{"status":"success"}'

Déploie la stack et démarre une exécution de test. Vérifiez les résultats dans la console Step Functions.

Bonnes pratiques

  • Utilisez toujours DefinitionBody.fromChainable pour la lisibilité
  • Préférez les timeouts explicites sur chaque tâche
  • Centralisez la gestion des erreurs au niveau de la State Machine
  • Versionnez vos définitions ASL avec Git
  • Surveillez avec X-Ray et CloudWatch Logs

Erreurs courantes à éviter

  • Oublier les permissions IAM entre Step Functions et Lambda
  • Définir des timeouts trop longs entraînant des coûts élevés
  • Ignorer les limites de 25 000 transitions par exécution
  • Ne pas tester les branches d'erreur en environnement de staging

Pour aller plus loin

Explorez les intégrations natives avec EventBridge et DynamoDB. Découvrez nos formations Learni sur l'architecture serverless avancée.