Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.

Développement de flux de travail avec Step Functions

Nous vous recommandons de commencer à créer des flux de travail dans la console Step Functions et l'éditeur visuel Workflow Studio. Vous pouvez partir de zéro ou choisir des modèles de démarrage pour les scénarios courants.

La création de vos flux de travail nécessite les tâches suivantes :

Vous définissez une machine à états dans Amazon States Language. Vous pouvez créer manuellement vos définitions linguistiques Amazon States, mais Workflow Studio sera présenté dans des didacticiels. Avec Workflow Studio, vous pouvez définir la définition de votre machine, visualiser et modifier les étapes, exécuter et déboguer votre flux de travail et afficher les résultats depuis la console Step Functions.

Vous pouvez également utiliser de nombreuses fonctionnalités Step Functions à partir du AWS Command Line Interface (AWS CLI). Par exemple, vous pouvez créer une machine à états et répertorier vos machines à états existantes. Vous pouvez utiliser les commandes Step Functions AWS CLI pour démarrer et gérer les exécutions, effectuer des sondages sur les activités, enregistrer les battements cardiaques des tâches, etc. Pour une liste complète des commandes Step Functions, une description des arguments disponibles et des exemples illustrant leur utilisation, consultez la référence des AWS CLI commandes. AWS CLI Référence de commande

AWS CLI les commandes suivent de près le langage Amazon States. Vous pouvez donc les utiliser AWS CLI pour en savoir plus sur les actions de l'API Step Functions. Vous pouvez également utiliser vos connaissances existantes en matière d'API pour prototyper du code ou effectuer des actions Step Functions à partir de la ligne de commande.

Pour démarrer avec une configuration minimale, vous pouvez suivre le didacticiel Creating a Lambda State Machine, qui explique comment définir un flux de travail en une seule étape qui appelle une fonction Lambda, puis exécuter le flux de travail et afficher les résultats.

Définition de votre flux de travail

La première étape du développement de votre flux de travail consiste à définir les étapes dans Amazon States Language. Selon vos préférences et l'outil que vous utilisez, vous pouvez définir vos machines à états Step Functions au format JSON, YAML ou sous forme de définition stringifiée en Amazon States Language (ASL).

Le tableau suivant présente la prise en charge des formats de ASL-based définition par outil.

Les commentaires d'une seule ligne YAML dans la définition de la machine à états d'un modèle ne seront pas reportés dans la définition de la ressource créée. Si vous devez conserver un commentaire, vous devez utiliser la Comment propriété dans la définition de la machine à états. Pour plus d'informations, consultez Structure de la machine d'État.

Avec CloudFormation et AWS SAM, vous pouvez télécharger les définitions de vos machines d'état sur Amazon S3 (format JSON ou YAML) et indiquer l'emplacement Amazon S3 de la définition dans le modèle. Pour plus d'informations, consultez la AWS::StepFunctions page : : StateMachine S3Location.

Les exemples de CloudFormation modèles suivants montrent comment fournir la même définition de machine à états en utilisant différents formats d'entrée.

JSON with Definition

{
  "AWSTemplateFormatVersion": "2010-09-09",
  "Description": "AWS Step Functions sample template.",
  "Resources": {
    "MyStateMachine": {
      "Type": "AWS::StepFunctions::StateMachine",
      "Properties": {
        "RoleArn": {
          "Fn::GetAtt": [ "StateMachineRole", "Arn" ]
        },
        "TracingConfiguration": {
          "Enabled": true
        },
        "Definition": {
          "StartAt": "HelloWorld",
          "States": {
            "HelloWorld": {
              "Type": "Pass",
              "End": true
            }
          }
        }
      }
    },
    "StateMachineRole": {
      "Type": "AWS::IAM::Role",
      "Properties": {
        "AssumeRolePolicyDocument": {
          "Version": "2012-10-17",
          "Statement": [
            {
              "Action": [
                "sts:AssumeRole"
              ],
              "Effect": "Allow",
              "Principal": {
                "Service": [
                  "states.amazonaws.com"
                ]
              }
            }
          ]
        },
        "ManagedPolicyArns": [],
        "Policies": [
          {
            "PolicyName": "StateMachineRolePolicy",
            "PolicyDocument": {
              "Statement": [
                {
                  "Action": [
                    "lambda:InvokeFunction"
                  ],
                  "Resource": "*",
                  "Effect": "Allow"
                }
              ]
            }
          }
        ]
      }
    }
  },
  "Outputs": {
    "StateMachineArn": {
      "Value": {
        "Ref": "MyStateMachine"
      }
    }
  }
}

JSON with DefinitionString

{
  "AWSTemplateFormatVersion": "2010-09-09",
  "Description": "AWS Step Functions sample template.",
  "Resources": {
    "MyStateMachine": {
      "Type": "AWS::StepFunctions::StateMachine",
      "Properties": {
        "RoleArn": {
          "Fn::GetAtt": [ "StateMachineRole", "Arn" ]
        },
        "TracingConfiguration": {
          "Enabled": true
        },
        "DefinitionString": "{\n  \"StartAt\": \"HelloWorld\",\n  \"States\": {\n    \"HelloWorld\": {\n      \"Type\": \"Pass\",\n      \"End\": true\n    }\n  }\n}"
      }
    },
    "StateMachineRole": {
      "Type": "AWS::IAM::Role",
      "Properties": {
        "AssumeRolePolicyDocument": {
          "Version": "2012-10-17",
          "Statement": [
            {
              "Action": [
                "sts:AssumeRole"
              ],
              "Effect": "Allow",
              "Principal": {
                "Service": [
                  "states.amazonaws.com"
                ]
              }
            }
          ]
        },
        "ManagedPolicyArns": [],
        "Policies": [
          {
            "PolicyName": "StateMachineRolePolicy",
            "PolicyDocument": {
              "Statement": [
                {
                  "Action": [
                    "lambda:InvokeFunction"
                  ],
                  "Resource": "*",
                  "Effect": "Allow"
                }
              ]
            }
          }
        ]
      }
    }
  },
  "Outputs": {
    "StateMachineArn": {
      "Value": {
        "Ref": "MyStateMachine"
      }
    }
  }
}

YAML with Definition

AWSTemplateFormatVersion: 2010-09-09
Description: AWS Step Functions sample template.
Resources:
  MyStateMachine:
    Type: 'AWS::StepFunctions::StateMachine'
    Properties:
      RoleArn: !GetAtt
        - StateMachineRole
        - Arn
      TracingConfiguration:
        Enabled: true
      Definition:
        # This is a YAML comment. This will not be preserved in the state machine resource's definition.
        Comment: This is an ASL comment. This will be preserved in the state machine resource's definition.
        StartAt: HelloWorld
        States:
          HelloWorld:
            Type: Pass
            End: true
  StateMachineRole:
    Type: 'AWS::IAM::Role'
    Properties:
      AssumeRolePolicyDocument:
        Version: 2012-10-17
        Statement:
          - Action:
              - 'sts:AssumeRole'
            Effect: Allow
            Principal:
              Service:
                - states.amazonaws.com
      ManagedPolicyArns: []
      Policies:
        - PolicyName: StateMachineRolePolicy
          PolicyDocument:
            Statement:
              - Action:
                  - 'lambda:InvokeFunction'
                Resource: "*"
                Effect: Allow

Outputs:
  StateMachineArn:
    Value:
      Ref: MyStateMachine

YAML with DefinitionString

AWSTemplateFormatVersion: 2010-09-09
Description: AWS Step Functions sample template.
Resources:
  MyStateMachine:
    Type: 'AWS::StepFunctions::StateMachine'
    Properties:
      RoleArn: !GetAtt
        - StateMachineRole
        - Arn
      TracingConfiguration:
        Enabled: true
      DefinitionString: |
        {
            "StartAt": "HelloWorld",
            "States": {
                "HelloWorld": {
                    "Type": "Pass",
                    "End": true
                }
            }
        }
  StateMachineRole:
    Type: 'AWS::IAM::Role'
    Properties:
      AssumeRolePolicyDocument:
        Version: 2012-10-17
        Statement:
          - Action:
              - 'sts:AssumeRole'
            Effect: Allow
            Principal:
              Service:
                - states.amazonaws.com
      ManagedPolicyArns: []
      Policies:
        - PolicyName: StateMachineRolePolicy
          PolicyDocument:
            Statement:
              - Action:
                  - 'lambda:InvokeFunction'
                Resource: "*"
                Effect: Allow

Outputs:
  StateMachineArn:
    Value:
      Ref: MyStateMachinele

Développez des flux de travail avec AWS Kits SDK

Step Functions est pris en charge par AWS les SDK pour Java, .NET, Ruby, PHP, Python (Boto 3) JavaScript, Go et C++. Ces kits de développement logiciel constituent un moyen pratique d'utiliser les actions de l'API HTTPS de Step Functions dans plusieurs langages de programmation. Vous pouvez développer des machines d'état, des activités ou des démarreurs de machine d'état à l'aide des actions d'API proposées par les bibliothèques de kits SDK. Vous pouvez également accéder aux opérations de visibilité à l'aide de ces bibliothèques pour développer vos propres outils de surveillance et de création de rapports Step Functions. Consultez la documentation de référence pour les AWS kits de développement logiciel et les outils actuels pour Amazon Web Services.

Développez des flux de travail via des requêtes HTTPS

Step Functions fournit des opérations de service accessibles via des requêtes HTTPS. Vous pouvez utiliser ces opérations pour communiquer directement avec Step Functions depuis vos propres bibliothèques. Vous pouvez développer des machines d'état, des activités ou des démarreurs de machine d'état à l'aide des actions d'API de service. Vous pouvez également accéder aux opérations de visibilité via les actions d'API pour développer vos propres outils de surveillance et de reporting. Pour plus de détails, consultez la référence de AWS Step Functions l'API.

Développez des flux de travail avec le AWS Step Functions Kit SDK Data Science

Les data scientists peuvent créer des flux de travail qui traitent et publient des modèles d'apprentissage automatique à l'aide de l' SageMaker IA et de Step Functions. Vous pouvez également créer des flux de travail d'apprentissage automatique en plusieurs étapes en Python qui orchestrent AWS l'infrastructure à grande échelle. Le SDK AWS Step Functions Data Science fournit une API Python qui permet de créer et d'invoquer des flux de travail Step Functions. Vous pouvez gérer et exécuter ces flux de travail directement dans Python, ainsi que dans les blocs-notes Jupyter. Pour plus d'informations, consultez le projet de science des données AWS Step Functions sur Github, la documentation du SDK pour la science des données, ainsi que des exemples de blocs-notes Jupyter et d'IA sur. SageMaker GitHub

Exécution et débogage de vos flux de travail

Vous pouvez démarrer des flux de travail de différentes manières, notamment depuis la console, un appel d'API (par exemple, depuis une fonction Lambda), depuis Amazon EventBridge et EventBridge Scheduler, depuis une autre machine d'état Step Functions. Les flux de travail en cours d'exécution peuvent se connecter à des services tiers, utiliser AWS des kits de développement logiciel et manipuler des données pendant l'exécution. Différents outils existent pour exécuter et déboguer les étapes d'exécution et les données circulant dans votre machine à états. Les sections suivantes fournissent des ressources supplémentaires pour exécuter et déboguer vos flux de travail.

Pour en savoir plus sur les méthodes de démarrage des exécutions de State Machine, consultezDémarrage des exécutions par machine à états dans Step Functions.

Choisissez un terminal pour exécuter vos flux de travail

Pour réduire la latence et stocker les données dans un emplacement qui répond à vos besoins, Step Functions fournit des points de terminaison dans différentes AWS régions. Chaque point de terminaison de Step Functions est totalement indépendant. Une machine d'état ou une activité n'existe que dans la région où elle a été créée. Les machines à états et les activités que vous créez dans une région ne partagent aucune donnée ni aucun attribut avec celles créées dans une autre région. Par exemple, vous pouvez enregistrer une machine d'état nommée STATES-Flows-1 dans deux régions différentes. La machine STATES-Flows-1 d'état d'une région ne partagera pas de données ou d'attributs avec la machine d'STATES-Flow-1état de l'autre région. Pour une liste des points de terminaison Step Functions, voir AWS Step Functions Régions et points de terminaison dans le. Références générales AWS

Développement avec VS Code

Grâce AWS à cette boîte à outils, vous pouvez utiliser Workflow Studio depuis VS Code pour visualiser, créer et même tester des états individuels dans vos machines à états. Vous pouvez également utiliser votre SAM et vos substitutions de CloudFormation définitions. Vous fournissez des entrées d'état et définissez des variables, lancez le test, puis vous pouvez voir comment vos données sont transformées. Dans l'onglet Définition de l'état, vous pouvez ajuster le flux de travail et effectuer un nouveau test. Lorsque vous avez terminé, vous pouvez appliquer les modifications pour mettre à jour la machine d'état. Pour plus d'informations, consultez Utilisation des fonctions Step et Utilisation de Workflow Studio dans le AWS Toolkit for Visual Studio Code.

Déploiement de vos workflows

Après avoir défini et débogué vos flux de travail, vous souhaiterez probablement les déployer à l'aide de frameworks Infrastructure as Code. Vous pouvez choisir de déployer vos machines d'état à l'aide de diverses options IaC, notamment : AWS Serverless Application Model, CloudFormation AWS CDK, et Terraform.