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
1. Copiare il codice di esempio dalla sezione [CloudFormation Codice sorgente 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
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\$1IN\$1PROGRESS**. **Quando il processo è completo, visualizza lo stato CREATE\$1COMPLETE. 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
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.\]](http://docs.aws.amazon.com/it_it/step-functions/latest/dg/images/tutorial-human-approval-sub-conf.png)
## Fase 4: Eseguire la macchina a stati
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.
**Nomi e log non ASCII**
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.
```
{
"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\]](http://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 due parole separate URLs 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\]](http://docs.aws.amazon.com/it_it/step-functions/latest/dg/images/tutorial-human-approval-continue.png)
## CloudFormation Codice sorgente del modello
Utilizza questo AWS CloudFormation modello per implementare un esempio di flusso di lavoro del processo di approvazione umana.
```
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
```