Skip to content
Learni
View all tutorials
Cloud AWS

Comment orchestrer des workflows avec AWS Step Functions en 2026

22 minADVANCED
AWSServerlessStep FunctionsCDK

Introduction

AWS Step Functions est un service serverless d'orchestration qui coordonne les workflows distribués via des state machines définies en Amazon States Language (ASL), un JSON standardisé. Contrairement aux Lambda simples, il gère nativement les états, les transitions, les erreurs et les boucles, idéal pour des microservices complexes comme les ETL, les sagas de transactions ou les pipelines ML.

Pourquoi l'utiliser en 2026 ? Avec l'essor des architectures event-driven, Step Functions réduit le code boilerplate de 70 % (selon AWS benchmarks), intègre 200+ services AWS et offre une visibilité graphique via l'Execution Console. Ce tutoriel avancé couvre les patterns essentiels : tâches Lambda, retries, Parallel, Map et déploiement CDK. À la fin, vous déploierez une state machine scalable bookmarquée par tout architecte cloud. (128 mots)

Prérequis

  • Compte AWS avec IAM admin (ou StepFunctionsFullAccess)
  • AWS CLI v2 installé et configuré (aws configure)
  • Node.js 20+ et AWS CDK v2 (npm i -g aws-cdk)
  • Connaissances avancées en Lambda, IAM et serverless
  • Région AWS eu-west-1 pour les exemples

Installer et configurer AWS CLI

setup-aws.sh
#!/bin/bash

# Installer AWS CLI v2 si pas présent (macOS/Linux)
if ! command -v aws &> /dev/null; then
    curl "https://awscli.amazonaws.com/awscli-exe-linux-x86_64.zip" -o "awscliv2.zip"
    unzip awscliv2.zip
    sudo ./aws/install
fi

# Configurer les credentials
aws configure set aws_access_key_id YOUR_ACCESS_KEY
aws configure set aws_secret_access_key YOUR_SECRET_KEY
aws configure set default.region eu-west-1
aws configure set default.output json

# Vérifier
aws sts get-caller-identity

Ce script installe AWS CLI v2, configure les credentials et vérifie l'identité. Remplacez YOUR_ACCESS_KEY et YOUR_SECRET_KEY par vos valeurs IAM. Évitez les root keys ; utilisez un rôle IAM dédié pour la sécurité.

Première state machine : Hello World

Commencez par une machine d'états triviale avec un Pass state pour valider la syntaxe ASL. Copiez le JSON suivant et déployez-le via CLI.

Définir une state machine simple

hello-world.json
{
  "Comment": "Hello World Step Function",
  "StartAt": "Hello",
  "States": {
    "Hello": {
      "Type": "Pass",
      "Result": "Hello, AWS Step Functions!",
      "End": true
    }
  }
}

Cette ASL définit un workflow unique avec un Pass state qui renvoie un résultat fixe. Le champ StartAt pointe vers le premier état ; End: true termine l'exécution. Testez-la avant complexité pour valider le rôle IAM StepFunctionsFullAccess.

Déployer et exécuter la state machine

deploy-hello.sh
#!/bin/bash

# Créer la state machine
ARN=$(aws stepfunctions create-state-machine \
  --name HelloWorldStateMachine \
  --definition file://hello-world.json \
  --role-arn arn:aws:iam::YOUR_ACCOUNT:role/StepFunctionsExecutionRole \
  --query 'stateMachineArn' --output text)

echo "State Machine ARN: $ARN"

# Exécuter
EXECUTION_ARN=$(aws stepfunctions start-execution \
  --state-machine-arn $ARN \
  --input '{}' \
  --query 'executionArn' --output text)

echo "Execution ARN: $EXECUTION_ARN"

# Attendre et obtenir output
aws stepfunctions wait-execution-started --execution-arn $EXECUTION_ARN
aws stepfunctions get-execution-history --execution-arn $EXECUTION_ARN --query 'events[-1].stateEnteredEventDetails.output'

Ce script crée la state machine, l'exécute avec input vide et récupère l'output. Remplacez YOUR_ACCOUNT et créez préalablement le rôle IAM avec StepFunctionsExecutionRole (trust policy Step Functions). Utilisez --no-cli-pager pour les logs longs.

Intégrer une tâche Lambda avec gestion d'erreurs

Passez à un Task state appelant une Lambda. Nous gérons les erreurs avec Catch et Retry, essentiels pour la résilience en prod.

State machine avec Lambda, Retry et Catch

lambda-workflow.json
{
  "Comment": "Workflow avec Lambda, Retry et Catch",
  "StartAt": "ProcessData",
  "States": {
    "ProcessData": {
      "Type": "Task",
      "Resource": "arn:aws:states:::lambda:invoke",
      "Parameters": {
        "FunctionName": "arn:aws:lambda:eu-west-1:YOUR_ACCOUNT:function:ProcessFunction",
        "Payload.$": "$"
      },
      "Retry": [
        {
          "ErrorEquals": ["States.TaskFailed"],
          "IntervalSeconds": 2,
          "MaxAttempts": 3,
          "BackoffRate": 2.0
        }
      ],
      "Catch": [
        {
          "ErrorEquals": ["States.ALL"],
          "Next": "ErrorHandler",
          "ResultPath": "$.error"
        }
      ],
      "Next": "Success"
    },
    "Success": {
      "Type": "Succeed",
      "End": true
    },
    "ErrorHandler": {
      "Type": "Fail",
      "Error": "WorkflowError",
      "Cause": "$.error"
    }
  }
}

Ce workflow invoque une Lambda via Resource ARN standard, retry 3 fois avec backoff exponentiel sur TaskFailed, et catch toutes erreurs vers un Fail state. Créez d'abord la Lambda ProcessFunction. ResultPath préserve l'input original.

Workflows parallèles et itératifs

Parallel exécute des branches concurrently ; Map itère sur arrays (jusqu'à 40 items par défaut, configurable). Parfait pour ETL parallèles.

State machine avec Parallel et Map

parallel-map.json
{
  "Comment": "Parallel et Map Example",
  "StartAt": "ParallelProcess",
  "States": {
    "ParallelProcess": {
      "Type": "Parallel",
      "Branches": [
        {
          "StartAt": "Branch1",
          "States": {
            "Branch1": {
              "Type": "Pass",
              "Result": "Branch 1 done",
              "End": true
            }
          }
        },
        {
          "StartAt": "Branch2",
          "States": {
            "Branch2": {
              "Type": "Pass",
              "Result": "Branch 2 done",
              "End": true
            }
          }
        }
      ],
      "Next": "MapProcess"
    },
    "MapProcess": {
      "Type": "Map",
      "ItemsPath": "$.inputArray",
      "MaxConcurrency": 5,
      "Iterator": {
        "StartAt": "ProcessItem",
        "States": {
          "ProcessItem": {
            "Type": "Task",
            "Resource": "arn:aws:states:::lambda:invoke",
            "Parameters": {
              "FunctionName": "arn:aws:lambda:eu-west-1:YOUR_ACCOUNT:function:ProcessItem",
              "Payload.$": "$"
            },
            "End": true
          }
        }
      },
      "ResultPath": "$.results",
      "End": true
    }
  }
}

Parallel lance deux branches simultanées ; Map itère sur $.inputArray avec 5 concurrences max, invoquant une Lambda par item. Utilisez ItemsPath pour cibler l'array input ; ResultPath agrège les résultats. Scalez via MaxConcurrency.

Déployer via AWS CDK (IaC)

lib/step-functions-stack.ts
import * as cdk from 'aws-cdk-lib';
import * as stepfunctions from 'aws-cdk-lib/aws-stepfunctions';
import * as tasks from 'aws-cdk-lib/aws-stepfunctions-tasks';
import * as lambda from 'aws-cdk-lib/aws-lambda';

export class StepFunctionsStack extends cdk.Stack {
  constructor(scope: cdk.App, 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 () => ({ statusCode: 200, body: "Processed" });')
    });

    const definition = new stepfunctions.Chain.start(new tasks.LambdaInvoke(this, 'ProcessTask', {
      lambdaFunction: processFn
    }));

    const stateMachine = new stepfunctions.StateMachine(this, 'AdvancedStateMachine', {
      definition,
      timeout: cdk.Duration.minutes(5)
    });

    processFn.grantInvoke(stateMachine);
  }
}

Ce stack CDK crée une Lambda inline et une state machine Chain simple. Synthétisez (cdk synth) et déployez (cdk deploy). Avantage : IaC avec diff, versioning et grants IAM auto. Étendez avec fromJson pour ASL custom.

Déployer le stack CDK

deploy-cdk.sh
#!/bin/bash

cdk bootstrap aws://YOUR_ACCOUNT/eu-west-1
npm init -y
npm install aws-cdk-lib constructs
npx tsx lib/step-functions-stack.ts  # Pour test
cdk init app --language typescript
# Copier le code TS dans stacks/StepFunctionsStack.ts
cdk synth
cdk deploy StepFunctionsStack

# Obtenir ARN et exécuter
ARN=$(aws stepfunctions list-state-machines --query 'stateMachines[0].stateMachineArn' --output text)
aws stepfunctions start-execution --state-machine-arn $ARN --input '{"key":"value"}'

Initialise CDK app TS, bootstrap, synth et déploie. Remplacez YOUR_ACCOUNT. Exécute la machine post-déploiement. CDK gère les updates sans downtime via versioning.

Bonnes pratiques

  • Toujours utiliser IaC : CDK/Terraform pour versioning et audits.
  • Timeouts et limites : Définissez timeout par état (max 1 an pour machine).
  • Logging CloudWatch : Activez Insights pour queries SQL sur exécutions.
  • Input/OutputPath : Filtrez payloads pour éviter bloat (limite 256 KB).
  • Rôles granulaires : Least privilege IAM avec conditions (e.g., via sourceArn).

Erreurs courantes à éviter

  • Oublier ResultPath : Perte de contexte input dans Catch/Retry.
  • MaxConcurrency trop haut : Throttling Lambda (limitez à 1000).
  • Pas de Catch global : Exécutions orphelines sur States.Timeout.
  • ASL malformé : Validez JSON via AWS Console avant CLI (erreur ParseError).

Pour aller plus loin