Desenvolver fluxos de trabalho com o Step Functions

Recomendamos começar a criar fluxos de trabalho no console do Step Functions e no editor visual do Workflow Studio. É possível começar em uma tela em branco ou escolher modelos iniciais para cenários comuns.

O processo de criação dos fluxos de trabalho exige as seguintes tarefas:

Defina uma máquina de estado na Amazon States Language. É possível criar manualmente as definições da Amazon States Language, mas o Workflow Studio será apresentado em tutoriais. Com o Workflow Studio, é possível definir a máquina, visualizar e editar as etapas, executar e depurar o fluxo de trabalho e visualizar os resultados, tudo no console do Step Functions.

Também é possível usar vários recursos do Step Functions por meio da AWS Command Line Interface (AWS CLI). Por exemplo, é possível usar uma máquina de estado e listar as máquinas de estado existentes. Você pode usar comandos do Step Functions na AWS CLI para iniciar e gerenciar execuções, sondar atividades, registrar heartbeats de tarefas e assim por diante. Para ter uma lista completa de comandos do Step Functions, descrições dos argumentos disponíveis e exemplos que mostram o uso, consulte a Referência de comandos da AWS CLI. AWS CLI Os comandos da Referência de comandos

Os comandos da AWS CLI seguem rigorosamente a Amazon States Language. Portanto, você pode usar a AWS CLI para saber mais sobre as ações de API do Step Functions. Você pode usar também o que já conhece sobre API para fazer protótipos de código ou executar ações do Step Functions por meio da linha de comando.

Para começar com uma configuração mínima, é possível seguir o tutorial Creating a Lambda State Machine, que mostra como definir um fluxo de trabalho com uma única etapa que chama uma função do Lambda, depois executar o fluxo de trabalho e visualizar os resultados.

Definir o fluxo de trabalho

A primeira etapa no desenvolvimento do fluxo de trabalho é definir as etapas na Amazon States Language. Dependendo da preferência e da ferramenta, é possível definir as máquinas de estado do Step Functions em JSON, em YAML ou como uma definição com strings da Amazon States Language (ASL).

As tabelas a seguir mostram o formato de definição baseado em ASL aceito pela ferramenta.

Os comentários de uma linha YAML na definição da máquina de estado de um modelo não serão transferidos para a definição do recurso criado. Se precisar manter um comentário, você deverá usar a propriedade Comment na definição de máquina de estado. Para mais informações, consulte Estrutura da máquina de estado.

Com o CloudFormation e o AWS SAM, é possível fazer upload das definições de máquina de estado no Amazon S3 (no formato JSON ou YAML) e fornecer a localização do Amazon S3 da definição no modelo. Para ter mais informações, consulte a página AWS::StepFunctions::StateMachine S3Location.

Os modelos de exemplo CloudFormation a seguir mostram como você pode fornecer a mesma definição de máquina de estado usando diferentes formatos de entrada.

JSON with Definition

{
  "AWSTemplateFormatVersion": "2010-09-09",
  "Description": "AWS Step Functions sample template.",
  "Resources": {
    "MyStateMachine": {
      "Type": "AWS::StepFunctions::StateMachine",
      "Properties": {
        "RoleArn": {
          "Fn::GetAtt": [ "StateMachineRole", "Arn" ]
        },
        "TracingConfiguration": {
          "Enabled": true
        },
        "Definition": {
          "StartAt": "HelloWorld",
          "States": {
            "HelloWorld": {
              "Type": "Pass",
              "End": true
            }
          }
        }
      }
    },
    "StateMachineRole": {
      "Type": "AWS::IAM::Role",
      "Properties": {
        "AssumeRolePolicyDocument": {
          "Version": "2012-10-17",		 	 	 
          "Statement": [
            {
              "Action": [
                "sts:AssumeRole"
              ],
              "Effect": "Allow",
              "Principal": {
                "Service": [
                  "states.amazonaws.com"
                ]
              }
            }
          ]
        },
        "ManagedPolicyArns": [],
        "Policies": [
          {
            "PolicyName": "StateMachineRolePolicy",
            "PolicyDocument": {
              "Statement": [
                {
                  "Action": [
                    "lambda:InvokeFunction"
                  ],
                  "Resource": "*",
                  "Effect": "Allow"
                }
              ]
            }
          }
        ]
      }
    }
  },
  "Outputs": {
    "StateMachineArn": {
      "Value": {
        "Ref": "MyStateMachine"
      }
    }
  }
}

JSON with DefinitionString

{
  "AWSTemplateFormatVersion": "2010-09-09",
  "Description": "AWS Step Functions sample template.",
  "Resources": {
    "MyStateMachine": {
      "Type": "AWS::StepFunctions::StateMachine",
      "Properties": {
        "RoleArn": {
          "Fn::GetAtt": [ "StateMachineRole", "Arn" ]
        },
        "TracingConfiguration": {
          "Enabled": true
        },
        "DefinitionString": "{\n  \"StartAt\": \"HelloWorld\",\n  \"States\": {\n    \"HelloWorld\": {\n      \"Type\": \"Pass\",\n      \"End\": true\n    }\n  }\n}"
      }
    },
    "StateMachineRole": {
      "Type": "AWS::IAM::Role",
      "Properties": {
        "AssumeRolePolicyDocument": {
          "Version": "2012-10-17",		 	 	 
          "Statement": [
            {
              "Action": [
                "sts:AssumeRole"
              ],
              "Effect": "Allow",
              "Principal": {
                "Service": [
                  "states.amazonaws.com"
                ]
              }
            }
          ]
        },
        "ManagedPolicyArns": [],
        "Policies": [
          {
            "PolicyName": "StateMachineRolePolicy",
            "PolicyDocument": {
              "Statement": [
                {
                  "Action": [
                    "lambda:InvokeFunction"
                  ],
                  "Resource": "*",
                  "Effect": "Allow"
                }
              ]
            }
          }
        ]
      }
    }
  },
  "Outputs": {
    "StateMachineArn": {
      "Value": {
        "Ref": "MyStateMachine"
      }
    }
  }
}

YAML with Definition

AWSTemplateFormatVersion: 2010-09-09
Description: AWS Step Functions sample template.
Resources:
  MyStateMachine:
    Type: 'AWS::StepFunctions::StateMachine'
    Properties:
      RoleArn: !GetAtt
        - StateMachineRole
        - Arn
      TracingConfiguration:
        Enabled: true
      Definition:
        # This is a YAML comment. This will not be preserved in the state machine resource's definition.
        Comment: This is an ASL comment. This will be preserved in the state machine resource's definition.
        StartAt: HelloWorld
        States:
          HelloWorld:
            Type: Pass
            End: true
  StateMachineRole:
    Type: 'AWS::IAM::Role'
    Properties:
      AssumeRolePolicyDocument:
        Version: 2012-10-17
        Statement:
          - Action:
              - 'sts:AssumeRole'
            Effect: Allow
            Principal:
              Service:
                - states.amazonaws.com
      ManagedPolicyArns: []
      Policies:
        - PolicyName: StateMachineRolePolicy
          PolicyDocument:
            Statement:
              - Action:
                  - 'lambda:InvokeFunction'
                Resource: "*"
                Effect: Allow

Outputs:
  StateMachineArn:
    Value:
      Ref: MyStateMachine

YAML with DefinitionString

AWSTemplateFormatVersion: 2010-09-09
Description: AWS Step Functions sample template.
Resources:
  MyStateMachine:
    Type: 'AWS::StepFunctions::StateMachine'
    Properties:
      RoleArn: !GetAtt
        - StateMachineRole
        - Arn
      TracingConfiguration:
        Enabled: true
      DefinitionString: |
        {
            "StartAt": "HelloWorld",
            "States": {
                "HelloWorld": {
                    "Type": "Pass",
                    "End": true
                }
            }
        }
  StateMachineRole:
    Type: 'AWS::IAM::Role'
    Properties:
      AssumeRolePolicyDocument:
        Version: 2012-10-17
        Statement:
          - Action:
              - 'sts:AssumeRole'
            Effect: Allow
            Principal:
              Service:
                - states.amazonaws.com
      ManagedPolicyArns: []
      Policies:
        - PolicyName: StateMachineRolePolicy
          PolicyDocument:
            Statement:
              - Action:
                  - 'lambda:InvokeFunction'
                Resource: "*"
                Effect: Allow

Outputs:
  StateMachineArn:
    Value:
      Ref: MyStateMachinele

Desenvolver fluxos de trabalho com SDKs da AWS

O Step Functions é compatível com os AWS SDKs para Java, .NET, Ruby, PHP, Python (Boto 3), JavaScript, Go e C++. Esses SDKs oferecem uma forma conveniente de usar as ações de API HTTPS do Step Functions em várias linguagens de programação. Você pode desenvolver máquinas de estado, atividades ou iniciadores de máquina de estado usando as ações de API expostas por essas bibliotecas de SDK. Você pode também acessar as operações de visibilidade usando essas bibliotecas para desenvolver ferramentas próprias de monitoramento e de relatório do Step Functions. Consulte a documentação de referência dos SDKs atuais da AWS e Ferramentas para criar com a AWS.

Desenvolver fluxos de trabalho por meio de solicitações HTTPS

O Step Functions fornece operações de serviço que são acessíveis por meio de solicitações HTTPS. É possível usar essas operações para se comunicar diretamente com o Step Functions por meio das próprias bibliotecas. Você pode desenvolver máquinas de estado, operadores ou iniciadores de máquina de estado usando as ações de API do serviço. Você pode também acessar as operações de visibilidade usando as ações de API para desenvolver ferramentas próprias de monitoramento e de relatório. Para ter detalhes, consulte a Referência de API do AWS Step Functions.

Desenvolver fluxos de trabalho com o SDK de ciência de dados do AWS Step Functions

Cientistas de dados podem criar fluxos de trabalho que processam e publicam modelos de machine learning usando o SageMaker AI e o Step Functions. Também é possível criar fluxos de trabalho de machine learning com várias etapas em Python que orquestram a infraestrutura da AWS em escala. O AWS Step Functions Data Science SDK fornece uma API do Python que pode criar e invocar fluxos de trabalho do Step Functions. Você pode gerenciar e executar esses fluxos de trabalho diretamente no Python, assim como em cadernos Jupyter. Para obter mais informações, consulte: Projeto de ciência de dados do AWS Step Functions no GitHub, documentação do SDK de ciência de dados e exemplos de cadernos Jupyter e exemplos do SageMaker AI no GitHub.

Executar e depurar os fluxos de trabalho

É possível iniciar fluxos de trabalho de várias maneiras, inclusive do console, de uma chamada de API (por exemplo, de uma função do Lambda), do Amazon EventBridge e do EventBridge Scheduler e de outra máquina de estado do Step Functions. Os fluxos de trabalho em execução podem se conectar a serviços de terceiros, usar SDKs da AWS e manipular dados durante a execução. Existem várias ferramentas para executar e depurar as etapas de execução e os dados que fluem pela máquina de estado. As seções a seguir fornecem mais recursos para executar e depurar os fluxos de trabalho.

Para saber mais sobre as formas de iniciar execuções de máquinas de estado, consulte Iniciar as execuções de uma máquina de estado no Step Functions.

Escolher um endpoint para executar os fluxos de trabalho

Para reduzir a latência e armazenar dados em um local que atende às suas necessidades, o Step Functions oferece endpoints em diferentes regiões AWS. Cada endpoint no Step Functions é totalmente independente. Uma máquina de estado ou atividade só existe na região em que ela foi criada. As máquinas de estado e as atividades criadas em uma região não compartilham dados nem atributos com as que são criadas em outra região. Por exemplo, você pode registrar uma máquina de estado nomeada STATES-Flows-1 em duas regiões diferentes. A máquina de estado STATES-Flows-1 em uma região não compartilhará dados ou atributos com a máquina de estado STATES-Flow-1 na outra região. Para obter uma lista dos endpoints do Step Functions, consulte Regiões e endpoints do AWS Step Functions na Referência geral da AWS.

Desenvolvimento no VS Code

Com o kit de ferramentas da AWS, você pode usar o Workflow Studio pelo VS Code para visualizar, criar e até mesmo testar estados individuais em suas máquinas de estado. Você também pode usar as substituições de definição do SAM e do CloudFormation. Você fornece entradas de estado e define variáveis, inicia o teste e pode ver como os dados são transformados. Na guia Definição de estado, você pode ajustar o fluxo de trabalho e testar novamente. Quando terminar, é possível aplicar as alterações para atualizar a máquina de estado. Para obter mais informações, consulte Trabalhar com o Step Functions e Trabalhar com o Workflow Studio no AWS Toolkit for Visual Studio Code.

Implantar os fluxos de trabalho

Depois que você definir e depurar os fluxos de trabalho, provavelmente desejará implantar usando frameworks de infraestrutura como código. É possível optar por implantar máquinas de estado usando uma série de opções de IaC, como AWS Serverless Application Model, CloudFormation, AWS CDK e Terraform.