Utilizzo AWS CloudFormation per creare un flusso di lavoro in Step Functions - AWS Step Functions
Passaggio 1: configura il AWS CloudFormation modelloPassaggio 2: utilizzare il AWS CloudFormation modello per creare una Lambda State MachineFase 3: Avviare l'esecuzione di una State Machine

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 CloudFormation per creare un flusso di lavoro in Step Functions

In questo tutorial, creerai una AWS Lambda funzione usando AWS CloudFormation. Utilizzerai la AWS 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 e la AWS::StepFunctions::StateMachine risorsa nella Guida AWS CloudFormation per l'utente.

Passaggio 1: configura il AWS CloudFormation modello

Prima di utilizzare i modelli di esempio, è necessario comprendere come dichiarare le diverse parti di un modello AWS 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"
                          }
                      ]
                  }
              }

Per 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 AWS CloudFormation modello per creare una Lambda State Machine

Una volta compresi i componenti del AWS CloudFormation modello, puoi metterli insieme e utilizzare il modello per creare uno AWS 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"
                      ]
                  }
              }
          }
      }
  }

  2. Aprire la console AWS CloudFormation e scegliere Create Stack (Crea stack).

  3. 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).

  4. Nella pagina Specificare i dettagli, per il nome dello stack, immetteteMyStateMachine, quindi scegliete Avanti.

  5. Nella pagina Opzioni, scegli Avanti.

  6. Nella pagina Revisione, scegli Riconosco che AWS CloudFormation potrebbe creare risorse IAM. quindi scegli Crea.

    AWS CloudFormation inizia a creare lo MyStateMachine stack e visualizza lo stato CREATE_IN_PROGRESS. Al termine del processo, AWS CloudFormation mostra lo stato CREATE_COMPLETE.

  7. (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 e scegli il nome della macchina a stati che hai creato utilizzando AWS CloudFormation.

  2. Nella MyStateMachine-ABCDEFGHIJ1Kpagina, scegli Nuova esecuzione.

    Viene visualizzata la pagina New execution (Nuova esecuzione).

  3. (Facoltativo) Inserite 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.

  4. Selezionare Start Execution (Avvia esecuzione).

    Viene avviata una nuova esecuzione della macchina a stati e visualizzata una pagina inedita con l'esecuzione in corso.

  5. (Facoltativo) In Execution Details (Dettagli esecuzione), esaminare lo Execution Status (Stato esecuzione) e i timestamp Started (Avviato) e Closed (Chiuso).

  6. Per visualizzare i risultati dell'esecuzione, selezionare Output (Output).