Usando AWS CloudFormation para criar um fluxo de trabalho em Step Functions

Modo de foco

Usando AWS CloudFormation para criar um fluxo de trabalho em Step Functions - AWS Step Functions

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

Neste tutorial, você criará uma AWS Lambda função usando AWS CloudFormation o. Você usará o AWS CloudFormation console e um modelo YAML para criar uma pilha (funções do IAM, a função 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 Trabalhando com CloudFormation modelos e o AWS::StepFunctions::StateMachine recurso no Guia AWS CloudFormation do usuário.

Etapa 1: configurar seu AWS CloudFormation modelo

Antes de usar os modelos de exemplo, é necessário entender como declarar as diferentes partes de um modelo do AWS 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.

anchor anchor


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 na mesma AWS conta e em sua máquina Região da AWS de estado.

anchor anchor


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"

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

anchor anchor


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: "*"

Para criar uma máquina de estado do Lambda

Defina a máquina de estado do Lambda.

anchor anchor


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 ]

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

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

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

anchor anchor


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 ]

Abra o console do AWS 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 AWS CloudFormation pode criar recursos do IAM. e, em seguida, escolha Criar.

AWS CloudFormation começa a criar a MyStateMachine pilha e exibe o status CREATE_IN_PROGRESS. Quando o processo é concluído, o AWS 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 Step Functions e escolha o nome da máquina de estado que você criou usando AWS CloudFormation.
Na MyStateMachine-ABCDEFGHIJ1Kpágina, escolha Nova execução.

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 funcionarão com a Amazon CloudWatch, recomendamos usar somente caracteres ASCII para que você possa acompanhar as métricas. CloudWatch
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 Execution Details (Detalhes da execução), examine o Execution Status (Status da execução) e os timestamps Started (Iniciado) e Closed (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

Usando AWS SAM

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

Nesta página

Selecione suas preferências de cookies

Personalizar preferências de cookies

Essenciais

Desempenho

Funcionais

Publicidade

Não foi possível salvar as preferências de cookie

Usando AWS CloudFormation para criar um fluxo de trabalho em Step Functions

Etapa 1: configurar seu AWS CloudFormation modelo

Para criar uma função do IAM para Lambda

Criar uma função do Lambda

Importante

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

Para criar uma máquina de estado do Lambda

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

Para criar a máquina de estado do Lambda

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

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

Nomes e registro em log não ASCII

Nesta página

Esta página foi útil?

Próximo tópico:

Tópico anterior:

Precisa de ajuda?