O uso do AWS CloudFormation para criar um fluxo de trabalho em Step Functions - AWS Step Functions
Etapa 1: configure seu AWS CloudFormation modeloEtapa 2: use o AWS CloudFormation modelo para criar uma Lambda State MachineEtapa 3: iniciar a execução de uma máquina de estado

As traduções são geradas por tradução automática. Em caso de conflito entre o conteúdo da tradução e da versão original em inglês, a versão em inglês prevalecerá.

O uso do AWS CloudFormation para criar um fluxo de trabalho em Step Functions

Neste tutorial, você criará um AWS Lambda função usando AWS CloudFormation. Você usará o AWS CloudFormation console e um YAML modelo para criar uma pilha (IAMfunções, a função Lambda e a máquina de estado). Em seguida, você usará o console Step Functions para iniciar a execução da máquina de estado.

Para obter mais informações, consulte Trabalhando com CloudFormation modelos e o AWS::StepFunctions::StateMachine recurso no AWS CloudFormation Guia do usuário.

Etapa 1: configure seu AWS CloudFormation modelo

Antes de usar os modelos de exemplo, você deve entender como declarar as diferentes partes de um AWS CloudFormation modelo.

Para criar uma IAM função para o Lambda

Defina a política de confiança associada à IAM função Lambda. Os exemplos a seguir definem uma política de confiança usando YAML ouJSON.

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"
                          }
                      ]
                  }
              }

Criar uma função do Lambda

Defina as propriedades a seguir da função do Lambda que imprimirão a mensagem Hello World.

Importante

Certifique-se de que sua função Lambda esteja sob a mesma AWS conta e Região da AWS como sua máquina estatal.

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"
              }
          },

Para criar uma IAM função para a execução da máquina de estado

Defina a política de confiança associada à IAM função para a execução da máquina de estado.

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": "*"
                                  }
                              ]
                          }
                      }
                  ]
              }
          },

Para criar uma máquina de estado do Lambda

Defina a máquina de estado do 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"
                      ]
                  }
              }
          }

Etapa 2: use o AWS CloudFormation modelo para criar uma Lambda State Machine

Depois de entender os componentes do AWS CloudFormation modelo, você pode juntá-los e usar o modelo para criar um AWS CloudFormation pilha.

Para criar a máquina de estado do Lambda

  1. Copie os dados de exemplo a seguir em um arquivo chamado MyStateMachine.yaml para o YAML exemplo ou MyStateMachine.json paraJSON.

    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. Abra as AWS CloudFormation console e escolha Create Stack.

  3. Na página Select Template (Selecionar modelo), selecione Upload a template to Amazon S3 (Fazer upload de um modelo para o Amazon S3). Escolha seu arquivo MyStateMachine e, em seguida, Next.

  4. Na página Specify Details (Especificar detalhes), em Stack Name (Nome da pilha), insira MyStateMachine e escolha Next (Próximo).

  5. Na página Options (Opções), escolha Next (Avançar).

  6. Na página de revisão, escolha Eu reconheço que AWS CloudFormation pode criar IAM recursos. e, em seguida, escolha Criar.

    AWS CloudFormation começa a criar a MyStateMachine pilha e exibe o status CREATE_IN_ PROGRESS. Quando o processo estiver concluído, AWS CloudFormation exibe o COMPLETE status CREATE_.

  7. (Opcional) Para exibir os recursos em sua pilha, selecione a pilha e escolha a guia Resources.

Etapa 3: iniciar a execução de uma máquina de estado

Assim que você criar a máquina de estado do Lambda, poderá iniciar uma execução.

Para iniciar a execução da máquina de estado

  1. Abra o console Step Functions e escolha o nome da máquina de estado que você criou usando AWS CloudFormation.

  2. Sobre o MyStateMachine-ABCDEFGHIJ1Kpágina, escolha Nova execução.

    A página New execution é exibida.

  3. (Opcional) Insira um nome de execução personalizado para substituir o padrão gerado.

    ASCIINão-nomes e registro

    Step Functions aceita nomes para máquinas de estado, execuções, atividades e rótulos que não contenham ASCII caracteres. Como esses caracteres não funcionarão com a Amazon CloudWatch, recomendamos usar somente ASCII caracteres para que você possa acompanhar as métricas CloudWatch.

  4. Escolha Start Execution.

    Uma nova execução de sua máquina de estado inicia-se e uma nova página mostrando a execução em andamento é exibida.

  5. (Opcional) Na seção Execution Details (Detalhes da execução), examine o Execution Status (Status da execução) e os timestamps Started (Iniciado) e Closed (Fechado).

  6. Para visualizar os resultados de sua execução, selecione Output (Saída).