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 CloudFormation per creare un flusso di lavoro in Step Functions
In questo tutorial, creerai una AWS Lambda funzione usando AWS CloudFormation. Utilizzerai la CloudFormation console e un modello YAML per creare uno *stack* (ruoli IAM, funzione Lambda e macchina a stati). Quindi, utilizzerai la console Step Functions per avviare l'esecuzione della macchina a stati.
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 AWS CloudFormation per l'utente*.
## Passaggio 1: configura il CloudFormation modello
Prima di utilizzare i [modelli di esempio](#lambda-state-machine-cfn-step-2), è necessario comprendere come dichiarare le diverse parti di un modello CloudFormation .
### Per creare un ruolo IAM per Lambda
Definisci la policy di fiducia associata al ruolo IAM per la funzione Lambda. Gli esempi seguenti definiscono una politica di fiducia utilizzando YAML o JSON.
------
#### [ YAML ]
```
LambdaExecutionRole:
Type: "AWS::IAM::Role"
Properties:
AssumeRolePolicyDocument:
Version: "2012-10-17"
Statement:
- Effect: Allow
Principal:
Service: lambda.amazonaws.com
Action: "sts:AssumeRole"
```
------
#### [ JSON ]
```
"LambdaExecutionRole": {
"Type": "AWS::IAM::Role",
"Properties": {
"AssumeRolePolicyDocument": {
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"Service": "lambda.amazonaws.com"
},
"Action": "sts:AssumeRole"
}
]
}
}
```
------
### Come creare una funzione Lambda
Definisci le seguenti proprietà per una funzione Lambda che stamperà il messaggio. `Hello World`
**Importante**
Assicurati che la tua funzione Lambda utilizzi lo stesso AWS account e la tua macchina Regione AWS a stati.
------
#### [ YAML ]
```
MyLambdaFunction:
Type: "AWS::Lambda::Function"
Properties:
Handler: "index.handler"
Role: !GetAtt [ LambdaExecutionRole, Arn ]
Code:
ZipFile: |
exports.handler = (event, context, callback) => {
callback(null, "Hello World!");
};
Runtime: "nodejs12.x"
Timeout: "25"
```
------
#### [ JSON ]
```
"MyLambdaFunction": {
"Type": "AWS::Lambda::Function",
"Properties": {
"Handler": "index.handler",
"Role": {
"Fn::GetAtt": [
"LambdaExecutionRole",
"Arn"
]
},
"Code": {
"ZipFile": "exports.handler = (event, context, callback) => {\n callback(null, \"Hello World!\");\n};\n"
},
"Runtime": "nodejs12.x",
"Timeout": "25"
}
},
```
------
### Per creare un ruolo IAM per l'esecuzione della macchina a stati
Definisci la politica di fiducia associata al ruolo IAM per l'esecuzione della macchina a stati.
------
#### [ YAML ]
```
StatesExecutionRole:
Type: "AWS::IAM::Role"
Properties:
AssumeRolePolicyDocument:
Version: "2012-10-17"
Statement:
- Effect: "Allow"
Principal:
Service:
- !Sub states.${AWS::Region}.amazonaws.com
Action: "sts:AssumeRole"
Path: "/"
Policies:
- PolicyName: StatesExecutionPolicy
PolicyDocument:
Version: "2012-10-17"
Statement:
- Effect: Allow
Action:
- "lambda:InvokeFunction"
Resource: "*"
```
------
#### [ JSON ]
```
"StatesExecutionRole": {
"Type": "AWS::IAM::Role",
"Properties": {
"AssumeRolePolicyDocument": {
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"Service": [
{
"Fn::Sub": "states.${AWS::Region}.amazonaws.com"
}
]
},
"Action": "sts:AssumeRole"
}
]
},
"Path": "/",
"Policies": [
{
"PolicyName": "StatesExecutionPolicy",
"PolicyDocument": {
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"lambda:InvokeFunction"
],
"Resource": "*"
}
]
}
}
]
}
},
```
------
### Per creare una macchina a stati Lambda
Definire la macchina a stati Lambda.
------
#### [ YAML ]
```
MyStateMachine:
Type: "AWS::StepFunctions::StateMachine"
Properties:
DefinitionString:
!Sub
- |-
{
"Comment": "A Hello World example using an AWS Lambda function",
"StartAt": "HelloWorld",
"States": {
"HelloWorld": {
"Type": "Task",
"Resource": "${lambdaArn}",
"End": true
}
}
}
- {lambdaArn: !GetAtt [ MyLambdaFunction, Arn ]}
RoleArn: !GetAtt [ StatesExecutionRole, Arn ]
```
------
#### [ JSON ]
```
"MyStateMachine": {
"Type": "AWS::StepFunctions::StateMachine",
"Properties": {
"DefinitionString": {
"Fn::Sub": [
"{\n \"Comment\": \"A Hello World example using an AWS Lambda function\",\n \"StartAt\": \"HelloWorld\",\n \"States\": {\n \"HelloWorld\": {\n \"Type\": \"Task\",\n \"Resource\": \"${lambdaArn}\",\n \"End\": true\n }\n }\n}",
{
"lambdaArn": {
"Fn::GetAtt": [
"MyLambdaFunction",
"Arn"
]
}
}
]
},
"RoleArn": {
"Fn::GetAtt": [
"StatesExecutionRole",
"Arn"
]
}
}
}
```
------
## Passaggio 2: utilizzare il CloudFormation modello per creare una Lambda State Machine
Una volta compresi i componenti del CloudFormation modello, puoi metterli insieme e utilizzare il modello per creare uno CloudFormation stack.
### Per creare la macchina a stati Lambda
1. Copiare i seguenti dati di esempio in un file denominato `MyStateMachine.yaml` per l'esempio YAML o `MyStateMachine.json` per JSON.
------
#### [ YAML ]
```
AWSTemplateFormatVersion: "2010-09-09"
Description: "An example template with an IAM role for a Lambda state machine."
Resources:
LambdaExecutionRole:
Type: "AWS::IAM::Role"
Properties:
AssumeRolePolicyDocument:
Version: "2012-10-17"
Statement:
- Effect: Allow
Principal:
Service: lambda.amazonaws.com
Action: "sts:AssumeRole"
MyLambdaFunction:
Type: "AWS::Lambda::Function"
Properties:
Handler: "index.handler"
Role: !GetAtt [ LambdaExecutionRole, Arn ]
Code:
ZipFile: |
exports.handler = (event, context, callback) => {
callback(null, "Hello World!");
};
Runtime: "nodejs12.x"
Timeout: "25"
StatesExecutionRole:
Type: "AWS::IAM::Role"
Properties:
AssumeRolePolicyDocument:
Version: "2012-10-17"
Statement:
- Effect: "Allow"
Principal:
Service:
- !Sub states.${AWS::Region}.amazonaws.com
Action: "sts:AssumeRole"
Path: "/"
Policies:
- PolicyName: StatesExecutionPolicy
PolicyDocument:
Version: "2012-10-17"
Statement:
- Effect: Allow
Action:
- "lambda:InvokeFunction"
Resource: "*"
MyStateMachine:
Type: "AWS::StepFunctions::StateMachine"
Properties:
DefinitionString:
!Sub
- |-
{
"Comment": "A Hello World example using an AWS Lambda function",
"StartAt": "HelloWorld",
"States": {
"HelloWorld": {
"Type": "Task",
"Resource": "${lambdaArn}",
"End": true
}
}
}
- {lambdaArn: !GetAtt [ MyLambdaFunction, Arn ]}
RoleArn: !GetAtt [ StatesExecutionRole, Arn ]
```
------
#### [ JSON ]
```
{
"AWSTemplateFormatVersion": "2010-09-09",
"Description": "An example template with an IAM role for a Lambda state machine.",
"Resources": {
"LambdaExecutionRole": {
"Type": "AWS::IAM::Role",
"Properties": {
"AssumeRolePolicyDocument": {
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"Service": "lambda.amazonaws.com"
},
"Action": "sts:AssumeRole"
}
]
}
}
},
"MyLambdaFunction": {
"Type": "AWS::Lambda::Function",
"Properties": {
"Handler": "index.handler",
"Role": {
"Fn::GetAtt": [
"LambdaExecutionRole",
"Arn"
]
},
"Code": {
"ZipFile": "exports.handler = (event, context, callback) => {\n callback(null, \"Hello World!\");\n};\n"
},
"Runtime": "nodejs12.x",
"Timeout": "25"
}
},
"StatesExecutionRole": {
"Type": "AWS::IAM::Role",
"Properties": {
"AssumeRolePolicyDocument": {
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"Service": [
{
"Fn::Sub": "states.${AWS::Region}.amazonaws.com"
}
]
},
"Action": "sts:AssumeRole"
}
]
},
"Path": "/",
"Policies": [
{
"PolicyName": "StatesExecutionPolicy",
"PolicyDocument": {
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"lambda:InvokeFunction"
],
"Resource": "*"
}
]
}
}
]
}
},
"MyStateMachine": {
"Type": "AWS::StepFunctions::StateMachine",
"Properties": {
"DefinitionString": {
"Fn::Sub": [
"{\n \"Comment\": \"A Hello World example using an AWS Lambda function\",\n \"StartAt\": \"HelloWorld\",\n \"States\": {\n \"HelloWorld\": {\n \"Type\": \"Task\",\n \"Resource\": \"${lambdaArn}\",\n \"End\": true\n }\n }\n}",
{
"lambdaArn": {
"Fn::GetAtt": [
"MyLambdaFunction",
"Arn"
]
}
}
]
},
"RoleArn": {
"Fn::GetAtt": [
"StatesExecutionRole",
"Arn"
]
}
}
}
}
}
```
------
1. Aprire la [console CloudFormation](https://console.aws.amazon.com/cloudformation/home) e scegliere **Create Stack (Crea stack)**.
1. Nella pagina **Select Template (Seleziona modello)**, scegli **Upload a template to Amazon S3 (Carica un modello in Amazon S3)**. Scegliere il file `MyStateMachine` e quindi **Next (Avanti)**.
1. **Nella pagina **Specificare i dettagli**, per il **nome dello stack**, immettete`MyStateMachine`, quindi scegliete Avanti.**
1. Nella pagina **Opzioni**, scegli **Avanti**.
1. Nella pagina **Revisione**, scegli **Riconosco che CloudFormation potrebbe creare risorse IAM**. quindi scegli **Crea**.
CloudFormation inizia a creare lo `MyStateMachine` stack e visualizza lo stato **CREATE\$1IN\$1PROGRESS**. Al termine del processo, CloudFormation mostra lo stato **CREATE\$1COMPLETE**.
1. (Facoltativo) Per visualizzare le risorse nello stack, selezionare lo stack e scegliere la scheda **Resources (Risorse)**.
## Fase 3: Avviare l'esecuzione di una State Machine
Dopo aver creato la macchina a stati Lambda, puoi avviarne l'esecuzione.
### Per avviare l'esecuzione della macchina a stati
1. Apri la [console Step Functions](https://console.aws.amazon.com/states/home) e scegli il nome della macchina a stati che hai creato utilizzando CloudFormation.
1. Nella ***MyStateMachine-ABCDEFGHIJ1K***pagina, scegli **Nuova esecuzione**.
Viene visualizzata la pagina **New execution (Nuova esecuzione)**.
1. (Facoltativo) Inserite un nome di esecuzione personalizzato per sostituire 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. Selezionare **Start Execution (Avvia esecuzione)**.
Viene avviata una nuova esecuzione della macchina a stati e visualizzata una pagina inedita con l'esecuzione in corso.
1. (Facoltativo) In **Execution Details (Dettagli esecuzione)**, esaminare lo **Execution Status (Stato esecuzione)** e i timestamp **Started (Avviato)** e **Closed (Chiuso)**.
1. Per visualizzare i risultati dell'esecuzione, selezionare **Output (Output)**.