

Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.

# Utilizzo AWS SAM per creare flussi di lavoro Step Functions
<a name="concepts-sam-sfn"></a>

Puoi utilizzarlo AWS Serverless Application Model con Step Functions per creare flussi di lavoro e distribuire l'infrastruttura di cui hai bisogno, comprese le funzioni Lambda APIs e gli eventi, per creare applicazioni serverless.

Puoi anche utilizzare la AWS Serverless Application Model CLI insieme a AWS Toolkit for Visual Studio Code come parte di un'esperienza integrata per creare e distribuire AWS Step Functions macchine a stati. Puoi creare un'applicazione serverless con AWS SAM, quindi creare la tua macchina a stati nell'IDE VS Code. Quindi puoi convalidare, impacchettare e distribuire le tue risorse. 

**Suggerimento**  
*Per distribuire un'applicazione serverless di esempio che avvia un flusso di lavoro Step Functions utilizzando AWS SAM, vedi [Deploy with AWS SAM](https://catalog.workshops.aws/stepfunctions/iac/deploy-with-sam) in The Workshop. AWS Step Functions *

## Perché usare Step Functions con AWS SAM?
<a name="concepts-sam-sfn-integration"></a>

Quando usi Step Functions con AWS SAM puoi:
+ Inizia a utilizzare un modello AWS SAM di esempio.
+ Costruire la tua macchina a stati nella tua applicazione serverless.
+ Utilizza la sostituzione delle variabili per sostituirla ARNs nella tua macchina a stati al momento della distribuzione.

   AWS CloudFormationsupporti [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)che consentono di aggiungere riferimenti dinamici nella definizione del flusso di lavoro a un valore fornito nel modello. CloudFormation È possibile aggiungere riferimenti dinamici aggiungendo sostituzioni alla definizione del flusso di lavoro utilizzando la `${dollar_sign_brace}` notazione. È inoltre necessario definire questi riferimenti dinamici nella `DefinitionSubstitutions` proprietà della StateMachine risorsa nel modello. CloudFormation Queste sostituzioni vengono sostituite con valori effettivi durante il processo di creazione dello CloudFormation stack. Per ulteriori informazioni, consulta [DefinitionSubstitutions nei modelli AWS SAM](#sam-definition-substitution-eg). 
+ Specificate il ruolo della vostra macchina a stati utilizzando AWS SAM i modelli di policy.
+ Avvia esecuzioni di macchine a stati con API Gateway, EventBridge eventi o in base a una pianificazione all'interno del tuo AWS SAM modello. 

## Integrazione di Step Functions con le AWS SAM specifiche
<a name="concepts-sam-sfn-ots2"></a>

È possibile utilizzare i [modelli di AWS SAM policy](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/serverless-policy-templates.html) per aggiungere autorizzazioni alla macchina a stati. Con queste autorizzazioni, puoi orchestrare le funzioni Lambda e AWS altre risorse per formare flussi di lavoro complessi e solidi. 

## Integrazione delle funzioni a fasi con l’interfaccia a riga di comando SAM
<a name="concepts-sam-sfn-ots3"></a>

Step Functions è integrato con la AWS SAM CLI. Utilizzare questa opzione per sviluppare rapidamente una macchina a stati nell'applicazione serverless.

Prova il [Creare una macchina a stati Step Functions utilizzando AWS SAM](tutorial-state-machine-using-sam.md) tutorial per imparare a usare per creare macchine AWS SAM a stati.

Le funzioni AWS SAM CLI supportate includono: 


| Comando CLI | Description | 
| --- | --- | 
| sam init |  Inizializza un'applicazione serverless con un modello. AWS SAM Può essere utilizzata con un modello SAM per le funzioni Step.  | 
| sam validate | Convalida un modello. AWS SAM  | 
| sam package |  Pacchettizza un' AWS SAM applicazione. Crea un file ZIP del codice e delle dipendenze, quindi lo carica su Amazon S3. Restituisce quindi una copia del modello AWS SAM , sostituendo i riferimenti agli artefatti locali con la posizione Amazon S3 in cui il comando ha caricato gli artefatti.  | 
| sam deploy | Distribuisce un'applicazione. AWS SAM  | 
| sam publish |  Pubblica un' AWS SAM applicazione su. AWS Serverless Application Repository Questo comando accetta un AWS SAM modello impacchettato e pubblica l'applicazione nella regione specificata.  | 

**Nota**  
Quando si utilizza AWS SAM local, è possibile emulare Lambda e API Gateway localmente. Tuttavia, non è possibile emulare Step Functions localmente utilizzando AWS SAM.

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

È possibile definire macchine a stati utilizzando CloudFormation modelli conAWS SAM. Con AWS SAM, è possibile definire la macchina a stati in linea nel modello o in un file separato. Il AWS SAM modello seguente include una macchina a stati che simula un flusso di lavoro di compravendita di azioni. Questa macchina a stati richiama tre Lambda funzioni per controllare il prezzo di un'azione e determinare se acquistare o vendere l'azione. Questa transazione viene quindi registrata in una Amazon DynamoDB tabella. Le ARNs Lambda funzioni e la DynamoDB tabella riportate nel modello seguente vengono specificate utilizzando [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
```

Il codice seguente è la definizione della macchina a stati nel file `stock_trader.asl.json` utilizzato nel [Creare una macchina a stati Step Functions utilizzando AWS SAM](tutorial-state-machine-using-sam.md) tutorial. Questa definizione di macchina a stati ne contiene diverse `DefinitionSubstitutions` denotate dalla notazione. `${dollar_sign_brace}` Ad esempio, invece di specificare una Lambda funzione statica ARN per `Check Stock Value` l'attività, viene utilizzata la `${StockCheckerFunctionArn}` sostituzione. Questa sostituzione è definita nella proprietà del modello. [DefinitionSubstitutions](#sam-template-def-substitution) `DefinitionSubstitutions`è una mappa di coppie chiave-valore per la risorsa della macchina a stati. In`DefinitionSubstitutions`, \$1 \$1StockCheckerFunctionArn\$1 esegue il mapping all'ARN della `StockCheckerFunction` risorsa utilizzando la funzione CloudFormation intrinseca. [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) Quando si distribuisce il AWS SAM modello, i valori contenuti `DefinitionSubstitutions` nel modello vengono sostituiti con i valori effettivi.

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

## Fasi successive
<a name="concepts-sam-sfn-next-steps"></a>

Puoi saperne di più sull'utilizzo di Step Functions AWS SAM con le seguenti risorse:
+ Completa il [Creare una macchina a stati Step Functions utilizzando AWS SAM](tutorial-state-machine-using-sam.md) tutorial per creare una macchina a stati con AWS SAM.
+ Specificate una [AWS::Serverless::StateMachine](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/sam-resource-statemachine.html)risorsa.
+ Trova [modelli di criteri AWS SAM](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/serverless-policy-templates.html) da utilizzare.
+ Utilizzare [AWS Toolkit for Visual Studio Code](https://docs.aws.amazon.com/toolkit-for-vscode/latest/userguide/stepfunctions.html)con Step Functions. 
+ Consulta il [riferimento AWS SAM CLI](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/serverless-sam-cli-command-reference.html) per saperne di più sulle funzionalità disponibili in. AWS SAM

Puoi anche progettare e creare i tuoi flussi di lavoro in Infrastructure as Code (IaC) utilizzando strumenti di creazione visivi, come Workflow Studio in. Infrastructure Composer Per ulteriori informazioni, consulta [Utilizzo di Workflow Studio Infrastructure Composer per creare flussi di lavoro Step Functions](use-wfs-in-app-composer.md).