Usar o AWS SAM para criar fluxos de trabalho do Step Functions

É possível usar o AWS Serverless Application Model com o Step Functions para criar fluxos de trabalho e implantar a infraestrutura de que precisa, como funções do Lambda, APIs e eventos, com o objetivo de criar aplicações sem servidor.

Também é possível usar a CLI do AWS Serverless Application Model em conjunto com o AWS Toolkit for Visual Studio Code como parte de uma experiência integrada para criar e implantar máquinas de estado do AWS Step Functions. É possível criar uma aplicação de tecnologia sem servidor com o AWS SAM e compilar a máquina de estado no IDE do VS Code. Depois, você pode validar, empacotar e implantar recursos.

dica

Para implantar um exemplo de aplicação de tecnologia sem servidor que inicia um fluxo de trabalho do Step Functions usando o AWS SAM na sua Conta da AWS, consulte o Módulo 11 – Implantar com AWS SAM do The AWS Step Functions Workshop.

Por que usar Step Functions com o AWS SAM?

Ao usar o Step Functions com o AWS SAM, você pode:

• Começar usando um modelo de exemplo do AWS SAM.

• Compilar a máquina de estado no aplicativo sem servidor.

• Usar a substituição de variáveis para substituir ARNs na máquina de estado no momento da implantação.

  O AWS CloudFormation é compatível com DefinitionSubstitutions que permitem adicionar referências dinâmicas na definição de fluxo de trabalho a um valor fornecido no modelo do CloudFormation. É possível adicionar referências dinâmicas incluindo substituições na definição de fluxo de trabalho usando a notação ${dollar_sign_brace}. Também é necessário definir essas referências dinâmicas na propriedade DefinitionSubstitutions do recurso StateMachine no modelo do CloudFormation. Essas substituições são substituídas por valores reais durante o processo de criação da pilha do CloudFormation. Para ter mais informações, consulte DefinitionSubstitutions em modelos do AWS SAM.

• Especificar o perfil da máquina de estado usando modelos de política do AWS SAM.

• Iniciar execuções de máquina de estado com o API Gateway, os eventos do EventBridge ou em uma programação no modelo do AWS SAM.

Integração do Step Functions com a especificação do AWS SAM

É possível usar os Modelos de política do AWS SAM para adicionar permissões à máquina de estado. Com essas permissões, você pode orquestrar as funções do Lambda e outros recursos da AWS para formar fluxos de trabalho complexos e robustos.

Integração do Step Functions à CLI do SAM

O Step Functions é integrado à CLI do AWS SAM. Use isso para desenvolver rapidamente uma máquina de estado no aplicativo sem servidor.

Tente o tutorial Criar uma máquina de estado do Step Functions usando AWS SAM para saber como usar o AWS SAM para criar máquinas de estado.

As funções compatíveis da CLI do AWS SAM incluem:

Comando da CLI	Descrição
sam init	Inicializa uma aplicação de tecnologia sem servidor com um modelo do AWS SAM. Pode ser usado com um modelo do SAM para o Step Functions.
sam validate	Valida um modelo do AWS SAM.
sam package	Empacota um aplicativo do AWS SAM. Cria um arquivo ZIP do código e das dependências e faz upload dele no Amazon S3. Depois, ele retorna uma cópia do modelo do AWS SAM, substituindo referências a artefatos locais pelo local do Amazon S3 onde o comando fez upload dos artefatos.
sam deploy	Implanta uma aplicação AWS SAM.
sam publish	Publique uma aplicação AWS SAM no AWS Serverless Application Repository. Esse comando usa um modelo do AWS SAM empacotado e publica a aplicação na região especificada.

nota

Ao usar o AWS SAM local, você pode emular o Lambda e o API Gateway localmente. No entanto, não é possível emular o Step Functions localmente usando o AWS SAM.

DefinitionSubstitutions em modelos do AWS SAM

É possível definir máquinas de estado usando modelos do CloudFormation com o AWS SAM. Ao usar o AWS SAM, é possível definir a máquina de estado em linha no modelo ou em um arquivo separado. O modelo do AWS SAM a seguir inclui uma máquina de estado que simula um fluxo de trabalho de negociação de ações. Essa máquina de estado invoca três funções do Lambda para conferir o preço de uma ação e determinar se deve comprar ou vender a ação. Essa transação é então registrada em uma tabela do Amazon DynamoDB. Os ARNs das funções do Lambda e da tabela do DynamoDB no modelo a seguir são especificados usando 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

O código a seguir é a definição da máquina de estado no arquivo stock_trader.asl.json usado no tutorial Criar uma máquina de estado do Step Functions usando AWS SAM. Essa definição da máquina de estado contém várias DefinitionSubstitutions indicadas pela notação ${dollar_sign_brace}. Por exemplo, em vez de especificar um ARN de função estática do Lambda para a tarefa Check Stock Value, a substituição ${StockCheckerFunctionArn} é usada. Essa substituição é definida na propriedade DefinitionSubstitutions do modelo. DefinitionSubstitutions é um mapa de pares de chave-valor para o recurso de máquina de estado. Em DefinitionSubstitutions, ${StockCheckerFunctionArn} é associado ao ARN do recurso StockCheckerFunction usando a função intrínseca do CloudFormation !GetAtt. Ao implantar o modelo do AWS SAM, as DefinitionSubstitutions do modelo são substituídas pelos valores reais.

{
    "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
        }
    }
}

Próximas etapas

Você pode aprender mais sobre o uso do Step Functions com o AWS SAM com os seguintes recursos:

• Conclua o tutorial Criar uma máquina de estado do Step Functions usando AWS SAM para criar uma máquina de estado com o AWS SAM.

• Especifique um recurso AWS::Serverless::StateMachine.

• Localize os Modelos de política do AWS SAM a serem usados.

• Use o AWS Toolkit for Visual Studio Code com o Step Functions.

• Analise a referência da CLI do AWS SAM para saber mais sobre os recursos disponíveis no AWS SAM.

Também é possível projetar e criar fluxos de trabalho na infraestrutura como código (IaC) usando criadores visuais, como o Workflow Studio no Infrastructure Composer. Para ter mais informações, consulte Usando o Workflow Studio em Infrastructure Composer para criar fluxos de trabalho do Step Functions.