Desenvolvendo fluxos de trabalho com Step Functions

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

A criação de seus fluxos de trabalho exige as seguintes tarefas:

• Definindo seu fluxo de trabalho

• Executando e depurando seu fluxo de trabalho

• Implantando seu fluxo de trabalho

Você define uma máquina de estado na Amazon States Language. Você pode criar manualmente suas definições da Amazon States Language, mas o Workflow Studio aparecerá em tutoriais. Com o Workflow Studio, você pode definir a definição de sua máquina, visualizar e editar as etapas, executar e depurar seu fluxo de trabalho e visualizar os resultados, tudo de dentro do console Step Functions.

Você também pode usar muitos recursos do Step Functions do AWS Command Line Interface (AWS CLI). Por exemplo, você pode criar uma máquina de estado e listar suas máquinas de estado existentes. Você pode usar os comandos Step Functions no AWS CLI para iniciar e gerenciar execuções, pesquisar atividades, registrar batimentos cardíacos de tarefas e muito mais. Para obter uma lista completa dos comandos do Step Functions, descrições dos argumentos disponíveis e exemplos mostrando seu uso, consulte o AWS CLI Referência de comando. AWS CLI Referência de comando

AWS CLI os comandos seguem de perto o idioma dos Estados da Amazônia, então você pode usar o AWS CLI para saber mais sobre as API ações do Step Functions. Você também pode usar seu API conhecimento existente para criar um protótipo de código ou realizar ações do Step Functions na linha de comando.

Validando as definições da máquina de estado

Você pode usar o API para validar máquinas de estado e encontrar possíveis problemas antes de criar seu fluxo de trabalho.

Para saber mais sobre a validação de fluxos de trabalho, consulte ValidateStateMachineDefinitionna Step Functions API Reference.

Para começar com uma configuração mínima, você pode seguir o tutorial Criando uma máquina de estado Lambda, que mostra como definir um fluxo de trabalho com uma única etapa que chama uma função Lambda, depois executar o fluxo de trabalho e visualizar os resultados.

Definindo seu fluxo de trabalho

A primeira etapa no desenvolvimento do seu fluxo de trabalho é definir as etapas no Amazon States Language. Dependendo de sua preferência e ferramenta, você pode definir suas máquinas de estado do Step Functions em JSONYAML, ou como uma definição sequencial da Amazon States Language ASL ().

A tabela a seguir mostra o suporte ao formato de definição ASL baseado por ferramenta.

AWS Ferramenta	Formato (s) compatível (s)
Console do Step Functions	JSON
HTTPSServiço API	Stringificado ASL
AWS CLI	Stringificado ASL
Step Functions Local	Stringificado ASL
AWS Toolkit for Visual Studio Code	JSON, YAML
AWS SAM	JSON, YAML
AWS CloudFormation	JSON,YAML, Stringificado ASL

YAMLcomentários de linha única 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 persistir em um comentário, use a Comment propriedade na definição da máquina de estado. Para ter mais informações, consulte Estrutura da máquina de estado.

Com AWS CloudFormation e AWS SAM, você pode carregar suas definições de máquina de estado para o Amazon S3 (JSONou YAML formato) e fornecer a localização da definição no Amazon S3 no modelo. Para obter informações, consulte a AWSpágina:StepFunctions:: StateMachine S3Location.

O exemplo a seguir AWS CloudFormation os modelos 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

Desenvolva fluxos de trabalho com AWS SDKs

Step Functions é suportado pelo AWS SDKspara Java,. NET, RubyPHP, Python (Boto 3) JavaScript, Go e C++. Eles SDKs fornecem uma maneira conveniente de usar as HTTPS API ações do Step Functions em várias linguagens de programação. Você pode desenvolver máquinas de estado, atividades ou iniciadores de máquinas de estado usando as API ações expostas por essas SDK bibliotecas. 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 para a versão atual AWS SDKse ferramentas para Amazon Web Services.

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

O Step Functions fornece operações de serviço que podem ser acessadas por meio de HTTPS solicitações. Você pode usar essas operações para se comunicar diretamente com Step Functions a partir de suas próprias bibliotecas. Você pode desenvolver máquinas de estado, trabalhadores ou iniciadores de máquinas de estado usando as API ações de serviço. Você também pode acessar as operações de visibilidade por meio de API ações para desenvolver suas próprias ferramentas de monitoramento e geração de relatórios. Para obter detalhes, consulte o AWS Step Functions APIReferência.

Desenvolva fluxos de trabalho com o AWS Step Functions Ciência de dados SDK

Os cientistas de dados podem criar fluxos de trabalho que processam e publicam modelos de aprendizado de máquina usando SageMaker Step Functions. Você também pode criar fluxos de trabalho de aprendizado de máquina em várias etapas em Python que orquestram AWS infraestrutura em grande escala. A ferramenta AWS Step Functions O Data Science SDK fornece um Python API 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: AWSStep Functions Data Science Project no Github, SDKdocumentação de ciência de dados e exemplos de notebooks Jupyter e exemplos em. SageMaker GitHub

Executando e depurando seus fluxos de trabalho

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

Para saber mais sobre as formas de iniciar execuções de máquinas de estado, consulteIniciando execuções de máquinas de estado em Step Functions.

Escolha um endpoint para executar seus fluxos de trabalho

Para reduzir a latência e armazenar dados em um local que atenda aos seus requisitos, o Step Functions fornece endpoints em diferentes AWS Regiões. Cada endpoint no Step Functions é totalmente independente. Uma máquina de estado ou atividade só existe na região em que ela foi criada. Todas as máquinas de estado e atividades que você cria em uma região não compartilham dados ou atributos com aquelas 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 AWS Step Functions Regiões e endpoints no Referência geral da AWS.

Controle o fluxo de dados em seus fluxos de trabalho

Você pode usar o simulador de fluxo de dados no console Step Functions para ver como as informações fluem de um estado para outro e entender como filtrar e manipular dados. Com o simulador de fluxo de dados, você pode simular cada um dos campos que o Step Functions usa para processar dadosInputPath, comoParameters, ResultSelectorOutputPath, e. ResultPath Para ter mais informações, consulte Usando o simulador de fluxo de dados para testar o fluxo de dados em Step Functions.

Versão de desenvolvimento local do Step Functions

Para fins de teste e desenvolvimento, você tem a opção de instalar e executar o Step Functions em sua máquina local. A versão local do Step Functions pode invocar AWS Lambda funções, tanto em AWS e quando executado localmente. Você também pode coordenar outros suportados AWS serviços. Para obter mais informações, consulte Testando máquinas de estado localmente em Step Functions.

Desenvolvimento local e remoto com o VS Code

Você também pode usar o VS Code para interagir com máquinas de estado remotas e desenvolver máquinas de estado localmente. É possível criar ou atualizar máquinas de estado, listar máquinas de estado existentes, executá-las e fazer download delas. O VS Code também permite que você crie máquinas de estado com base em modelos e veja uma visualização da máquina de estado, além de fornecer trechos de código, preenchimento de código e validação de código. Para obter mais informações, consulte o AWS Toolkit for Visual Studio Code Guia do usuário

Implantando seus fluxos de trabalho

Depois de definir e depurar seus fluxos de trabalho, você provavelmente desejará implantar usando estruturas de Infraestrutura como Código. Você pode optar por implantar suas máquinas de estado usando uma variedade de opções de IaC, incluindo: AWS Serverless Application Model, AWS CloudFormation, AWS CDK e Terraform.

AWS Serverless Application Model

Você pode usar: AWS Serverless Application Model com Step Functions para criar fluxos de trabalho e implantar a infraestrutura de que você precisa, incluindo funções e eventos LambdaAPIs, para criar aplicativos sem servidor. Você também pode usar o AWS SAM CLIem conjunto com o AWS Toolkit for Visual Studio Code como parte de uma experiência integrada.

Para obter mais informações, consulte Usando AWS SAM para criar fluxos de trabalho de Step Functions.

AWS CloudFormation

Você pode usar suas definições de máquina de estado diretamente no AWS CloudFormation modelos.

Para obter mais informações, consulte O uso do AWS CloudFormation para criar um fluxo de trabalho em Step Functions.

AWS CDK

Você pode criar máquinas de estado Standard e Express com AWS CDK.

Para criar um fluxo de trabalho padrão, consulteUsando CDK para criar um fluxo de trabalho padrão.

Para criar um fluxo de trabalho Express, consulteUsando CDK para criar um fluxo de trabalho Express.

Terraforma

O Terraform by HashiCorp é uma estrutura para criar aplicativos usando infraestrutura como código (IaC). Com o Terraform, você pode criar máquinas de estado e usar recursos, como visualizar implantações de infraestrutura e criar modelos reutilizáveis. Os modelos do Terraform ajudam você a manter e reutilizar o código dividindo-o em partes menores.

Para obter mais informações, consulte Usando o Terraform para implantar máquinas de estado em Step Functions.