Etapa 1: configurar o modelo do CloudFormation Etapa 2: usar o modelo do CloudFormation para criar uma máquina de estado do Lambda Etapa 3: iniciar a execução de uma máquina de estado

Usar o CloudFormation para criar um fluxo de trabalho no Step Functions

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

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

Etapa 1: configurar o modelo do CloudFormation

Antes de usar os modelos de exemplo, é necessário entender como declarar as diferentes partes de um modelo do CloudFormation.

Para criar uma função do IAM para Lambda

Defina a política de confiança associada ao perfil do IAM para a função do Lambda. Os exemplos a seguir definem uma política de confiança usando YAML ou JSON.

Como criar uma função do Lambda

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

Importante

Verifique se a função do Lambda está na mesma conta da AWS e na mesma Região da AWS que a máquina de estado.

Para criar um perfil do IAM para a execução da máquina de estado

Defina a política de confiança associada ao perfil do IAM 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.

Etapa 2: usar o modelo do CloudFormation para criar uma máquina de estado do Lambda

Depois de entender os componentes do modelo do CloudFormation, você poderá associá-los e usar o modelo para criar uma pilha do CloudFormation.

Para criar a máquina de estado do Lambda

Copie os dados de exemplo a seguir em um arquivo chamado MyStateMachine.yaml para o exemplo de YAML ou MyStateMachine.json para 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"
                      ]
                  }
              }
          }
      }
  }

Abra o console do CloudFormation e escolha Create Stack (Criar pilha).
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.
Na página Specify Details (Especificar detalhes), em Stack Name (Nome da pilha), insira MyStateMachine e escolha Next (Próximo).
Na página Options (Opções), escolha Next (Avançar).
Na página Revisão, escolha Eu reconheço que o CloudFormation pode criar recursos do IAM. e, em seguida, escolha Criar.

O CloudFormation começa a criar a pilha MyStateMachine e exibe o status CREATE_IN_PROGRESS. Quando o processo é concluído, o CloudFormation exibe o status CREATE_COMPLETE.
(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

Abra o console do Step Functions e escolha o nome da máquina de estado que você criou usando o CloudFormation.
Na página MyStateMachine-ABCDEFGHIJ1K, escolha New execution.

A página New execution é exibida.
(Opcional) Insira um nome de execução personalizado para substituir o padrão gerado.

Nomes e registro em log não ASCII
O Step Functions aceita nomes de máquina de estado, execuções, atividades e rótulos que contenham caracteres não ASCII. Como esses caracteres não permitem que o Amazon CloudWatch registre dados em log, recomendamos usar somente caracteres ASCII para monitorar as métricas do Step Functions.
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.
(Opcional) Na seção Detalhes da execução, analise o Status da execução e os timestamps Iniciado e Fechado.
Para visualizar os resultados de sua execução, selecione Output (Saída).

Atenção O Javascript está desativado ou não está disponível no seu navegador.

Para usar a documentação da AWS, o Javascript deve estar ativado. Consulte as páginas de Ajuda do navegador para obter instruções.

Convenções do documento

Usar o AWS SAM

Usar o CDK para criar um fluxo de trabalho padrão