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.

Utilisation AWS SAM pour créer des flux de travail Step Functions

Vous pouvez utiliser AWS Serverless Application Model Step Functions pour créer des flux de travail et déployer l'infrastructure dont vous avez besoin, y compris les fonctions Lambda APIs et les événements, pour créer des applications sans serveur.

Vous pouvez également l'utiliser conjointement avec le AWS Serverless Application Model CLI dans le AWS Toolkit for Visual Studio Code cadre d'une expérience intégrée pour créer et déployer des machines AWS Step Functions d'état. Vous pouvez créer une application sans serveur avec AWS SAM, puis créer votre machine d'état dans le VS CodeIDE. Vous pouvez ensuite valider, empaqueter et déployer vos ressources.

Pourquoi utiliser Step Functions avec AWS SAM ?

Lorsque vous utilisez Step Functions avec, AWS SAM vous pouvez :

Step Functions : intégration avec la AWS SAM spécification

Vous pouvez utiliser les modèles AWS SAM de politique pour ajouter des autorisations à votre machine d'état. Avec ces autorisations, vous pouvez orchestrer les fonctions Lambda et AWS d'autres ressources pour créer des flux de travail complexes et robustes.

Intégration de Step Functions avec SAM CLI

Step Functions est intégré au AWS SAM CLI. Utilisez cela pour développer rapidement une machine d'état dans votre application sans serveur.

Essayez le Créez une machine d'état Step Functions en utilisant AWS SAM didacticiel pour apprendre à l'utiliser AWS SAM pour créer des machines à états.

Les AWS SAM CLI fonctions prises en charge incluent :

DefinitionSubstitutions dans AWS SAM modèles

Vous pouvez définir des machines à états à l'aide de CloudFormation modèles avec AWS SAM. En utilisant AWS SAM, vous pouvez définir la machine à états en ligne dans le modèle ou dans un fichier séparé. Procédez comme suit : AWS SAM le modèle inclut une machine à états qui simule un flux de travail de négociation d'actions. Cette machine à états invoque trois Lambda fonctions permettant de vérifier le prix d'une action et de déterminer s'il faut acheter ou vendre l'action. Cette transaction est ensuite enregistrée dans un Amazon DynamoDB table. Le ARNs pour Lambda fonctions et DynamoDB les tables du modèle suivant sont spécifiées à l'aide de DefinitionSubstitutions.

AWSTemplateFormatVersion: '2010-09-09'
Transform: AWS::Serverless-2016-10-31
Description: |
  step-functions-stock-trader
  Sample SAM Template for step-functions-stock-trader
Resources:
  StockTradingStateMachine:
    Type: AWS::Serverless::StateMachine
    Properties:
      DefinitionSubstitutions:
        StockCheckerFunctionArn: !GetAtt StockCheckerFunction.Arn
        StockSellerFunctionArn: !GetAtt StockSellerFunction.Arn
        StockBuyerFunctionArn: !GetAtt StockBuyerFunction.Arn
        DDBPutItem: !Sub arn:${AWS::Partition}:states:::dynamodb:putItem
        DDBTable: !Ref TransactionTable
      Policies:
        - DynamoDBWritePolicy:
            TableName: !Ref TransactionTable
        - LambdaInvokePolicy:
            FunctionName: !Ref StockCheckerFunction
        - LambdaInvokePolicy:
            FunctionName: !Ref StockBuyerFunction
        - LambdaInvokePolicy:
            FunctionName: !Ref StockSellerFunction
      DefinitionUri: statemachine/stock_trader.asl.json
  StockCheckerFunction:
    Type: AWS::Serverless::Function
    Properties:
      CodeUri: functions/stock-checker/
      Handler: app.lambdaHandler
      Runtime: nodejs18.x
      Architectures:
        - x86_64
  StockSellerFunction:
    Type: AWS::Serverless::Function
    Properties:
      CodeUri: functions/stock-seller/
      Handler: app.lambdaHandler
      Runtime: nodejs18.x
      Architectures:
        - x86_64
  StockBuyerFunction:
    Type: AWS::Serverless::Function
    Properties:
      CodeUri: functions/stock-buyer/
      Handler: app.lambdaHandler
      Runtime: nodejs18.x
      Architectures:
        - x86_64
  TransactionTable:
    Type: AWS::DynamoDB::Table
    Properties:
      AttributeDefinitions:
        - AttributeName: id
          AttributeType: S

Le code suivant est la définition de la machine à états dans le fichier stock_trader.asl.json utilisé dans le Créez une machine d'état Step Functions en utilisant AWS SAM didacticiel. Cette définition de machine à états contient plusieurs définitions DefinitionSubstitutions désignées par la notation. ${dollar_sign_brace} Par exemple, au lieu de spécifier une valeur statique Lambda fonction ARN de la Check Stock Value tâche, la substitution ${StockCheckerFunctionArn} est utilisée. Cette substitution est définie dans la DefinitionSubstitutions propriété du modèle. DefinitionSubstitutionsest une carte de paires clé-valeur pour la ressource State Machine. DansDefinitionSubstitutions, $ {StockCheckerFunctionArn} correspond à ARN la StockCheckerFunction ressource à l'aide du CloudFormation fonction intrinsèque !GetAtt. Lorsque vous déployez AWS SAM modèle, les valeurs DefinitionSubstitutions contenues dans le modèle sont remplacées par les valeurs réelles.

{
    "Comment": "A state machine that does mock stock trading.",
    "StartAt": "Check Stock Value",
    "States": {
        "Check Stock Value": {
            "Type": "Task",
            "Resource": "arn:aws:states:::lambda:invoke",
            "OutputPath": "$.Payload",
            "Parameters": {
                "Payload.$": "$",
                "FunctionName": "${StockCheckerFunctionArn}"
            },
            "Next": "Buy or Sell?"
        },
        "Buy or Sell?": {
            "Type": "Choice",
            "Choices": [
                {
                    "Variable": "$.stock_price",
                    "NumericLessThanEquals": 50,
                    "Next": "Buy Stock"
                }
            ],
            "Default": "Sell Stock"
        },
        "Buy Stock": {
            "Type": "Task",
            "Resource": "arn:aws:states:::lambda:invoke",
            "OutputPath": "$.Payload",
            "Parameters": {
                "Payload.$": "$",
                "FunctionName": "${StockBuyerFunctionArn}"
            },
            "Retry": [
                {
                    "ErrorEquals": [
                        "Lambda.ServiceException",
                        "Lambda.AWSLambdaException",
                        "Lambda.SdkClientException",
                        "Lambda.TooManyRequestsException"
                    ],
                    "IntervalSeconds": 1,
                    "MaxAttempts": 3,
                    "BackoffRate": 2
                }
            ],
            "Next": "Record Transaction"
        },
        "Sell Stock": {
            "Type": "Task",
            "Resource": "arn:aws:states:::lambda:invoke",
            "OutputPath": "$.Payload",
            "Parameters": {
                "Payload.$": "$",
                "FunctionName": "${StockSellerFunctionArn}"
            },
            "Next": "Record Transaction"
        },
        "Record Transaction": {
            "Type": "Task",
            "Resource": "arn:aws:states:::dynamodb:putItem",
            "Parameters": {
                "TableName": "${DDBTable}",
                "Item": {
                    "Id": {
                        "S.$": "$.id"
                    },
                    "Type": {
                        "S.$": "$.type"
                    },
                    "Price": {
                        "N.$": "$.price"
                    },
                    "Quantity": {
                        "N.$": "$.qty"
                    },
                    "Timestamp": {
                        "S.$": "$.timestamp"
                    }
                }
            },
            "End": true
        }
    }
}

Étapes suivantes

Pour en savoir plus sur l'utilisation de Step Functions, consultez les ressources suivantes : AWS SAM

Vous pouvez également concevoir et créer vos flux de travail dans l'infrastructure sous forme de code (IaC) à l'aide de générateurs visuels, tels que Workflow Studio dans Infrastructure Composer. Pour plus d'informations, consultezUtilisation de Workflow Studio dans Infrastructure Composer pour créer des flux de travail Step Functions.