

As traduções são geradas por tradução automática. Em caso de conflito entre o conteúdo da tradução e da versão original em inglês, a versão em inglês prevalecerá.

# Usando AWS SAM para criar fluxos de trabalho do Step Functions
<a name="concepts-sam-sfn"></a>

Você pode usar o AWS Serverless Application Model Step Functions para criar fluxos de trabalho e implantar a infraestrutura de que precisa, incluindo funções e eventos Lambda APIs , para criar aplicativos sem servidor.

Você também pode usar a AWS Serverless Application Model CLI em conjunto com o AWS Toolkit for Visual Studio Code como parte de uma experiência integrada para criar e implantar AWS Step Functions máquinas de estado. É 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 aplicativo sem servidor que inicia um fluxo de trabalho do Step Functions usando AWS SAM, consulte [Deploy with AWS SAM](https://catalog.workshops.aws/stepfunctions/iac/deploy-with-sam) no *The AWS Step Functions * Workshop.

## Por que usar Step Functions com AWS SAM?
<a name="concepts-sam-sfn-integration"></a>

Ao usar o Step Functions com AWS SAM você pode:
+ Comece a usar um modelo AWS SAM de amostra.
+ Compilar a máquina de estado no aplicativo sem servidor.
+ Use a substituição de variáveis para substituí-la ARNs em sua máquina de estado no momento da implantação.

   O AWS CloudFormation é compatível com [https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-stepfunctions-statemachine.html#cfn-stepfunctions-statemachine-definitionsubstitutions](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-stepfunctions-statemachine.html#cfn-stepfunctions-statemachine-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}`. Você também precisa definir essas referências dinâmicas na `DefinitionSubstitutions` propriedade do StateMachine recurso em seu CloudFormation modelo. Essas substituições são substituídas por valores reais durante o processo de criação da pilha do CloudFormation. Para obter mais informações, consulte [DefinitionSubstitutions em AWS SAM modelos](#sam-definition-substitution-eg). 
+ Especifique a função da sua máquina de estado usando modelos AWS SAM de política.
+ Inicie execuções de máquinas de estado com o API Gateway, EventBridge eventos ou em um cronograma dentro do seu AWS SAM modelo. 

## Integração do Step Functions com a AWS SAM especificação
<a name="concepts-sam-sfn-ots2"></a>

É possível usar os [Modelos de política do AWS SAM](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/serverless-policy-templates.html) para adicionar permissões à máquina de estado. Com essas permissões, você pode orquestrar funções do Lambda e outros AWS recursos para formar fluxos de trabalho complexos e robustos. 

## Integração do Step Functions à CLI do SAM
<a name="concepts-sam-sfn-ots3"></a>

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

Experimente o [Crie uma máquina de estado Step Functions usando AWS SAM](tutorial-state-machine-using-sam.md) tutorial para aprender a usar AWS SAM para criar máquinas de estado.

As funções de AWS SAM CLI suportadas incluem: 


| Comando da CLI | Description | 
| --- | --- | 
| sam init |  Inicializa um aplicativo sem servidor com um modelo. AWS SAM Pode ser usado com um modelo do SAM para o Step Functions.  | 
| sam validate | Valida um AWS SAM modelo. | 
| sam package |  Empacota um AWS SAM aplicativo. 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 um AWS SAM aplicativo. | 
| sam publish |  Publique um AWS SAM aplicativo no AWS Serverless Application Repository. Esse comando usa um AWS SAM modelo empacotado e publica o aplicativo na região especificada.  | 

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

## DefinitionSubstitutions em AWS SAM modelos
<a name="sam-definition-substitution-eg"></a>

É 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. As ARNs Lambda funções e a DynamoDB tabela do modelo a seguir são especificadas usando [https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-stepfunctions-statemachine.html#cfn-stepfunctions-statemachine-definitionsubstitutions](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-stepfunctions-statemachine.html#cfn-stepfunctions-statemachine-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 [Crie uma máquina de estado Step Functions usando AWS SAM](tutorial-state-machine-using-sam.md). 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](#sam-template-def-substitution) do modelo. `DefinitionSubstitutions` é um mapa de pares de chave-valor para o recurso de máquina de estado. Em`DefinitionSubstitutions`, \$1 \$1StockCheckerFunctionArn\$1 mapeia para o ARN do `StockCheckerFunction` recurso usando a função CloudFormation intrínseca. [https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/intrinsic-function-reference-getatt.html](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/intrinsic-function-reference-getatt.html) 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
<a name="concepts-sam-sfn-next-steps"></a>

Você pode aprender mais sobre o uso do Step Functions AWS SAM com os seguintes recursos:
+ Conclua o [Crie uma máquina de estado Step Functions usando AWS SAM](tutorial-state-machine-using-sam.md) tutorial para criar uma máquina de estado com AWS SAM o.
+ Especifique um [AWS::Serverless::StateMachine](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/sam-resource-statemachine.html)recurso.
+ Localize os [Modelos de política do AWS SAM](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/serverless-policy-templates.html) a serem usados.
+ Use o [AWS Toolkit for Visual Studio Code](https://docs.aws.amazon.com/toolkit-for-vscode/latest/userguide/stepfunctions.html) com o Step Functions. 
+ Analise a [referência da CLI do AWS SAM](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/serverless-sam-cli-command-reference.html) 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 obter mais informações, consulte [Usar o Workflow Studio no Infrastructure Composer para criar fluxos de trabalho do Step Functions](use-wfs-in-app-composer.md).