

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à.

# Implementazione di un flusso di lavoro in attesa dell'approvazione umana in Step Functions

Questa esercitazione mostra come distribuire un progetto di approvazione umana che consente all’esecuzione AWS Step Functions di essere messa in pausa durante un'attività e di attendere che l’utente risponda a un'e-mail. Il flusso di lavoro passa allo stato successivo dopo che l'utente ha approvato l'attività per continuare. 

L'implementazione dello CloudFormation stack incluso in questo tutorial creerà tutte le risorse necessarie, tra cui:
+ Risorse Amazon API Gateway
+ E AWS Lambda funzioni
+ Una macchina AWS Step Functions statale
+ Un argomento e-mail di Amazon Simple Notification Service
+  AWS Identity and Access Management Ruoli e autorizzazioni correlati

**Nota**  
Dovrai fornire un indirizzo email valido a cui avere accesso quando crei lo CloudFormation stack.

Per ulteriori informazioni, consulta [Lavorare con CloudFormation i modelli](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/template-guide.html) e la `[AWS::StepFunctions::StateMachine](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-stepfunctions-statemachine.html)` risorsa nella *Guida per l'AWS CloudFormation utente*.

## Fase 1: Creare un CloudFormation modello
<a name="human-approval-deploy"></a>

1. Copiare il codice di esempio dalla sezione [CloudFormation Codice di origine del modello](#human-approval-yaml).

1. Incolla il codice sorgente del CloudFormation modello in un file sul tuo computer locale.

   Per questo esempio, il file è denominato `human-approval.yaml`.

## Fase 2: Creare una pila
<a name="human-approval-create-stack"></a>

1. Accedi alla [console CloudFormation](https://console.aws.amazon.com/cloudformation/home).

1. Scegli **Crea pila**, quindi scegli **Con nuove risorse (standard)**.

1. Nella pagina **Create stack** (Crea stack), esegui le operazioni seguenti:

   1. Nella sezione **Prerequisito - Prepara modello**, assicurati che sia selezionato **Template is ready**.

   1. Nella sezione **Specificare il modello**, scegli **Carica un file modello**, quindi scegli **Scegli file** per caricare il `human-approval.yaml` file creato in precedenza che include il [codice sorgente del modello](#human-approval-yaml).

1. Scegli **Next (Successivo)**.

1. Nella pagina **Specify stack details (Specifica dettagli)**, procedere come segue:

   1. Per il **nome dello stack**, inserisci un nome per lo stack.

   1. In **Parametri**, inserisci un indirizzo email valido. Utilizzerai questo indirizzo e-mail per iscriverti all'argomento Amazon SNS.

1. Scegli **Avanti**, quindi scegli nuovamente **Avanti**.

1. Nella pagina **Revisione**, scegli **Riconosco che CloudFormation potrebbe creare risorse IAM**, quindi scegli **Crea**.

   CloudFormation inizia a creare lo stack e visualizza lo stato **CREATE\_IN\_PROGRESS**. **Quando il processo è completo, visualizza lo stato CREATE\_COMPLETE. CloudFormation **

1. (Facoltativo) Per visualizzare le risorse nello stack, selezionare lo stack e scegliere la scheda **Resources (Risorse)**.

## Fase 3: approvare l'abbonamento Amazon SNS
<a name="human-approval-approve-sub"></a>

Una volta creato l'argomento Amazon SNS, riceverai un'e-mail di richiesta di conferma dell'iscrizione.

1. Apri l'account e-mail che hai fornito quando hai creato lo CloudFormation stack.

1. **Apri il messaggio **AWS Notifica - Conferma dell'abbonamento** da no-reply@sns.amazonaws.com**

   L'e-mail riporterà l'Amazon Resource Name per l'argomento Amazon SNS e un link di conferma.

1. Scegli il link **conferma abbonamento**.  
![Schermata illustrativa di un'e-mail di conferma dell'iscrizione.](https://docs.aws.amazon.com/it_it/step-functions/latest/dg/images/tutorial-human-approval-sub-conf.png)

## Fase 4: Eseguire la macchina a stati
<a name="human-approval-run"></a>

1. Nella **HumanApprovalLambdaStateMachine**pagina, scegli **Avvia esecuzione**.

   Viene visualizzata la finestra di dialogo **Avvia esecuzione**.

1. Nella finestra di dialogo **Avvia esecuzione**, effettuate le seguenti operazioni:

   1. (Facoltativo) Immettete un nome di esecuzione personalizzato per sovrascrivere il valore predefinito generato.
**Non-ASCII nomi e registrazione**  
Step Functions accetta nomi per macchine a stati, esecuzioni, attività ed etichette che contengono caratteri non ASCII. Poiché tali caratteri impediranno ad Amazon CloudWatch di registrare i dati, consigliamo di utilizzare solo caratteri ASCII per tenere traccia delle metriche di Step Functions.

   1. Nella casella **Input**, inserisci il seguente input JSON per eseguire il flusso di lavoro.

      ```json
      {
          "Comment": "Testing the human approval tutorial."
      }
      ```

   1. Selezionare **Start execution (Avvia esecuzione)**.

      L'esecuzione della macchina a **ApprovalTest**stati si avvia e si interrompe durante l'attività **Lambda** Callback.

   1. La console Step Functions ti indirizza a una pagina intitolata con il tuo ID di esecuzione. Questa pagina è nota come pagina dei *dettagli di esecuzione*. In questa pagina è possibile esaminare i risultati dell'esecuzione man mano che l'esecuzione procede o dopo il suo completamento.

      Per esaminare i risultati dell'esecuzione, scegliete i singoli stati nella **vista Grafico**, quindi scegliete le singole schede [Dettagli del passaggio](concepts-view-execution-details.md#exec-details-intf-step-details) nel riquadro per visualizzare i dettagli di ogni stato, inclusi rispettivamente input, output e definizione. Per i dettagli sulle informazioni sull'esecuzione che è possibile visualizzare nella pagina *Dettagli di esecuzione*, vedere[Panoramica dei dettagli di esecuzione](concepts-view-execution-details.md#exec-details-interface-overview).  
![Esecuzione in attesa di un callback](https://docs.aws.amazon.com/it_it/step-functions/latest/dg/images/tutorial-human-approval-pause.png)

1. Nell'account e-mail che hai usato in precedenza per l'argomento Amazon SNS, apri il messaggio con l'oggetto da cui è **richiesta l'approvazione**. AWS Step Functions

   Il messaggio include URL separati per **Approva** e **Rifiuta**.

1. Scegliere l’URL **Approva**.

   Il flusso di lavoro prosegue in base alla tua scelta.  
![Esecuzione in attesa di un callback](https://docs.aws.amazon.com/it_it/step-functions/latest/dg/images/tutorial-human-approval-continue.png)

## CloudFormation Codice di origine del modello
<a name="human-approval-yaml"></a>

Utilizza questo AWS CloudFormation modello per implementare un esempio di flusso di lavoro basato su un processo di approvazione umana.

```yaml
AWSTemplateFormatVersion: "2010-09-09"
Description: "AWS Step Functions Human based task example. It sends an email with an HTTP URL for approval."
Parameters:
  Email:
    Type: String
    AllowedPattern: "^[a-zA-Z0-9_.+-]+@[a-zA-Z0-9-]+\\.[a-zA-Z0-9-.]+$"
    ConstraintDescription: Must be a valid email address.
Resources:
  # Begin API Gateway Resources
  ExecutionApi:
    Type: "AWS::ApiGateway::RestApi"
    Properties:
      Name: "Human approval endpoint"
      Description: "HTTP Endpoint backed by API Gateway and Lambda"
      FailOnWarnings: true

  ExecutionResource:
    Type: 'AWS::ApiGateway::Resource'
    Properties:
      RestApiId: !Ref ExecutionApi
      ParentId: !GetAtt "ExecutionApi.RootResourceId"
      PathPart: execution

  ExecutionMethod:
    Type: "AWS::ApiGateway::Method"
    Properties:
      AuthorizationType: NONE
      HttpMethod: GET
      Integration:
        Type: AWS
        IntegrationHttpMethod: POST
        Uri: !Sub "arn:aws:apigateway:${AWS::Region}:lambda:path/2015-03-31/functions/${LambdaApprovalFunction.Arn}/invocations"
        IntegrationResponses:
          - StatusCode: 302
            ResponseParameters:
              method.response.header.Location: "integration.response.body.headers.Location"
        RequestTemplates:
          application/json: |
            {
              "body" : $input.json('$'),
              "headers": {
                #foreach($header in $input.params().header.keySet())
                "$header": "$util.escapeJavaScript($input.params().header.get($header))" #if($foreach.hasNext),#end

                #end
              },
              "method": "$context.httpMethod",
              "params": {
                #foreach($param in $input.params().path.keySet())
                "$param": "$util.escapeJavaScript($input.params().path.get($param))" #if($foreach.hasNext),#end

                #end
              },
              "query": {
                #foreach($queryParam in $input.params().querystring.keySet())
                "$queryParam": "$util.escapeJavaScript($input.params().querystring.get($queryParam))" #if($foreach.hasNext),#end

                #end
              }  
            }
      ResourceId: !Ref ExecutionResource
      RestApiId: !Ref ExecutionApi
      MethodResponses:
        - StatusCode: 302
          ResponseParameters:
            method.response.header.Location: true

  ApiGatewayAccount:
    Type: 'AWS::ApiGateway::Account'
    Properties:
      CloudWatchRoleArn: !GetAtt "ApiGatewayCloudWatchLogsRole.Arn"
  
  ApiGatewayCloudWatchLogsRole:
    Type: 'AWS::IAM::Role'
    Properties:
      AssumeRolePolicyDocument:
        Version: "2012-10-17"		 	 	 
        Statement:
          - Effect: Allow
            Principal:
              Service:
                - apigateway.amazonaws.com
            Action:
              - 'sts:AssumeRole'
      Policies:
        - PolicyName: ApiGatewayLogsPolicy
          PolicyDocument:
            Version: 2012-10-17
            Statement:
              - Effect: Allow
                Action:
                  - "logs:*"
                Resource: !Sub "arn:${AWS::Partition}:logs:*:*:*"

  ExecutionApiStage:
    DependsOn:
      - ApiGatewayAccount
    Type: 'AWS::ApiGateway::Stage'
    Properties:
      DeploymentId: !Ref ApiDeployment
      MethodSettings:
        - DataTraceEnabled: true
          HttpMethod: '*'
          LoggingLevel: INFO
          ResourcePath: /*
      RestApiId: !Ref ExecutionApi
      StageName: states

  ApiDeployment:
    Type: "AWS::ApiGateway::Deployment"
    DependsOn:
      - ExecutionMethod
    Properties:
      RestApiId: !Ref ExecutionApi
      StageName: DummyStage
  # End API Gateway Resources

  # Begin
  # Lambda that will be invoked by API Gateway
  LambdaApprovalFunction:
    Type: 'AWS::Lambda::Function'
    Properties:
      Code:
        ZipFile:
          Fn::Sub: |
            const { SFN: StepFunctions } = require("@aws-sdk/client-sfn");
            var redirectToStepFunctions = function(lambdaArn, statemachineName, executionName, callback) {
              const lambdaArnTokens = lambdaArn.split(":");
              const partition = lambdaArnTokens[1];
              const region = lambdaArnTokens[3];
              const accountId = lambdaArnTokens[4];

              console.log("partition=" + partition);
              console.log("region=" + region);
              console.log("accountId=" + accountId);

              const executionArn = "arn:" + partition + ":states:" + region + ":" + accountId + ":execution:" + statemachineName + ":" + executionName;
              console.log("executionArn=" + executionArn);

              const url = "https://console.aws.amazon.com/states/home?region=" + region + "#/executions/details/" + executionArn;
              callback(null, {
                  statusCode: 302,
                  headers: {
                    Location: url
                  }
              });
            };

            exports.handler = (event, context, callback) => {
              console.log('Event= ' + JSON.stringify(event));
              const action = event.query.action;
              const taskToken = event.query.taskToken;
              const statemachineName = event.query.sm;
              const executionName = event.query.ex;

              const stepfunctions = new StepFunctions();

              var message = "";

              if (action === "approve") {
                message = { "Status": "Approved! Task approved by ${Email}" };
              } else if (action === "reject") {
                message = { "Status": "Rejected! Task rejected by ${Email}" };
              } else {
                console.error("Unrecognized action. Expected: approve, reject.");
                callback({"Status": "Failed to process the request. Unrecognized Action."});
              }

              stepfunctions.sendTaskSuccess({
                output: JSON.stringify(message),
                taskToken: event.query.taskToken
              })
              .then(function(data) {
                redirectToStepFunctions(context.invokedFunctionArn, statemachineName, executionName, callback);
              }).catch(function(err) {
                console.error(err, err.stack);
                callback(err);
              });
            }
      Description: Lambda function that callback to AWS Step Functions
      FunctionName: LambdaApprovalFunction
      Handler: index.handler
      Role: !GetAtt "LambdaApiGatewayIAMRole.Arn"
      Runtime: nodejs18.x

  LambdaApiGatewayInvoke:
    Type: "AWS::Lambda::Permission"
    Properties:
      Action: "lambda:InvokeFunction"
      FunctionName: !GetAtt "LambdaApprovalFunction.Arn"
      Principal: "apigateway.amazonaws.com"
      SourceArn: !Sub "arn:aws:execute-api:${AWS::Region}:${AWS::AccountId}:${ExecutionApi}/*"

  LambdaApiGatewayIAMRole:
    Type: "AWS::IAM::Role"
    Properties:
      AssumeRolePolicyDocument:
        Version: "2012-10-17"		 	 	 
        Statement:
          - Action:
              - "sts:AssumeRole"
            Effect: "Allow"
            Principal:
              Service:
                - "lambda.amazonaws.com"
      Policies:
        - PolicyName: CloudWatchLogsPolicy
          PolicyDocument:
            Statement:
              - Effect: Allow
                Action:
                  - "logs:*"
                Resource: !Sub "arn:${AWS::Partition}:logs:*:*:*"
        - PolicyName: StepFunctionsPolicy
          PolicyDocument:
            Statement:
              - Effect: Allow
                Action:
                  - "states:SendTaskFailure"
                  - "states:SendTaskSuccess"
                Resource: "*"
  # End Lambda that will be invoked by API Gateway

  # Begin state machine that publishes to Lambda and sends an email with the link for approval
  HumanApprovalLambdaStateMachine:
    Type: AWS::StepFunctions::StateMachine
    Properties:
      RoleArn: !GetAtt LambdaStateMachineExecutionRole.Arn
      DefinitionString:
        Fn::Sub: |
          {
              "StartAt": "Lambda Callback",
              "TimeoutSeconds": 3600,
              "States": {
                  "Lambda Callback": {
                      "Type": "Task",
                      "Resource": "arn:${AWS::Partition}:states:::lambda:invoke.waitForTaskToken",
                      "Parameters": {
                        "FunctionName": "${LambdaHumanApprovalSendEmailFunction.Arn}",
                        "Payload": {
                          "ExecutionContext.$": "$$",
                          "APIGatewayEndpoint": "https://${ExecutionApi}.execute-api.${AWS::Region}.amazonaws.com/states"
                        }
                      },
                      "Next": "ManualApprovalChoiceState"
                  },
                  "ManualApprovalChoiceState": {
                    "Type": "Choice",
                    "Choices": [
                      {
                        "Variable": "$.Status",
                        "StringEquals": "Approved! Task approved by ${Email}",
                        "Next": "ApprovedPassState"
                      },
                      {
                        "Variable": "$.Status",
                        "StringEquals": "Rejected! Task rejected by ${Email}",
                        "Next": "RejectedPassState"
                      }
                    ]
                  },
                  "ApprovedPassState": {
                    "Type": "Pass",
                    "End": true
                  },
                  "RejectedPassState": {
                    "Type": "Pass",
                    "End": true
                  }
              }
          }

  SNSHumanApprovalEmailTopic:
    Type: AWS::SNS::Topic
    Properties:
      Subscription:
        -
           Endpoint: !Sub ${Email}
           Protocol: email
  
  LambdaHumanApprovalSendEmailFunction:
    Type: "AWS::Lambda::Function"
    Properties:
      Handler: "index.lambda_handler"
      Role: !GetAtt LambdaSendEmailExecutionRole.Arn
      Runtime: "nodejs18.x"
      Timeout: "25"
      Code:
        ZipFile:
          Fn::Sub: |
            console.log('Loading function');
            const { SNS } = require("@aws-sdk/client-sns");
            exports.lambda_handler = (event, context, callback) => {
                console.log('event= ' + JSON.stringify(event));
                console.log('context= ' + JSON.stringify(context));

                const executionContext = event.ExecutionContext;
                console.log('executionContext= ' + executionContext);

                const executionName = executionContext.Execution.Name;
                console.log('executionName= ' + executionName);

                const statemachineName = executionContext.StateMachine.Name;
                console.log('statemachineName= ' + statemachineName);

                const taskToken = executionContext.Task.Token;
                console.log('taskToken= ' + taskToken);

                const apigwEndpint = event.APIGatewayEndpoint;
                console.log('apigwEndpint = ' + apigwEndpint)

                const approveEndpoint = apigwEndpint + "/execution?action=approve&ex=" + executionName + "&sm=" + statemachineName + "&taskToken=" + encodeURIComponent(taskToken);
                console.log('approveEndpoint= ' + approveEndpoint);

                const rejectEndpoint = apigwEndpint + "/execution?action=reject&ex=" + executionName + "&sm=" + statemachineName + "&taskToken=" + encodeURIComponent(taskToken);
                console.log('rejectEndpoint= ' + rejectEndpoint);

                const emailSnsTopic = "${SNSHumanApprovalEmailTopic}";
                console.log('emailSnsTopic= ' + emailSnsTopic);

                var emailMessage = 'Welcome! \n\n';
                emailMessage += 'This is an email requiring an approval for a step functions execution. \n\n'
                emailMessage += 'Check the following information and click "Approve" link if you want to approve. \n\n'
                emailMessage += 'Execution Name -> ' + executionName + '\n\n'
                emailMessage += 'Approve ' + approveEndpoint + '\n\n'
                emailMessage += 'Reject ' + rejectEndpoint + '\n\n'
                emailMessage += 'Thanks for using Step functions!'
                
                const sns = new SNS();
                var params = {
                  Message: emailMessage,
                  Subject: "Required approval from AWS Step Functions",
                  TopicArn: emailSnsTopic
                };

                sns.publish(params)
                  .then(function(data) {
                    console.log("MessageID is " + data.MessageId);
                    callback(null);
                  }).catch(
                    function(err) {
                    console.error(err, err.stack);
                    callback(err);
                  });
            }

  LambdaStateMachineExecutionRole:
    Type: "AWS::IAM::Role"
    Properties:
      AssumeRolePolicyDocument:
        Version: "2012-10-17"		 	 	 
        Statement:
          - Effect: Allow
            Principal:
              Service: states.amazonaws.com
            Action: "sts:AssumeRole"
      Policies:
        - PolicyName: InvokeCallbackLambda
          PolicyDocument:
            Statement:
              - Effect: Allow
                Action:
                  - "lambda:InvokeFunction"
                Resource:
                  - !Sub "${LambdaHumanApprovalSendEmailFunction.Arn}"

  LambdaSendEmailExecutionRole:
    Type: "AWS::IAM::Role"
    Properties:
      AssumeRolePolicyDocument:
        Version: "2012-10-17"		 	 	 
        Statement:
          - Effect: Allow
            Principal:
              Service: lambda.amazonaws.com
            Action: "sts:AssumeRole"
      Policies:
        - PolicyName: CloudWatchLogsPolicy
          PolicyDocument:
            Statement:
              - Effect: Allow
                Action:
                  - "logs:CreateLogGroup"
                  - "logs:CreateLogStream"
                  - "logs:PutLogEvents"
                Resource: !Sub "arn:${AWS::Partition}:logs:*:*:*"
        - PolicyName: SNSSendEmailPolicy
          PolicyDocument:
            Statement:
              - Effect: Allow
                Action:
                  - "SNS:Publish"
                Resource:
                  - !Sub "${SNSHumanApprovalEmailTopic}"

# End state machine that publishes to Lambda and sends an email with the link for approval
Outputs:
  ApiGatewayInvokeURL:
    Value: !Sub "https://${ExecutionApi}.execute-api.${AWS::Region}.amazonaws.com/states"
  StateMachineHumanApprovalArn:
    Value: !Ref HumanApprovalLambdaStateMachine
```