Todos os produtos
Search

Este produto

    CloudFlow:Data passing

    Central de documentação

    CloudFlow:Data passing

    Última atualização: Jun 28, 2026

    Os estados em um fluxo de trabalho do CloudFlow funcionam como funções: cada estado recebe uma entrada, processa os dados, gera uma saída e armazena o resultado no contexto. Os dados de tempo de execução disponíveis para cada estado constituem o contexto.

    Como os dados fluem entre estados

    Um fluxo de trabalho do CloudFlow transmite dados por uma cadeia de estados. Em cada etapa:

    1. O estado atual recebe a entrada do estado anterior (ou da entrada da execução, no caso do primeiro estado).

    2. O estado processa a entrada conforme seu tipo e configuração.

    3. O estado gera uma saída e a encaminha ao próximo estado.

    Personalize a forma como os dados entram e saem de cada estado definindo um InputConstructor ou OutputConstructor. Sem esses construtores, cada tipo de estado aplica seu comportamento padrão. Consulte Entradas e saídas para obter detalhes.

    Duas categorias de dados estão disponíveis durante a execução:

    Categoria

    Conteúdo

    Dados do fluxo

    Nome do fluxo, região, nomes dos estados e função do Resource Access Management (RAM) usada para executar o fluxo

    Dados da execução

    Nome e entrada da execução, entrada e saída do estado atual, token de callback, detalhes de erro e contagem de tentativas

    Acesse dados de tempo de execução com $Context

    Use a expressão $Context para ler dados do fluxo e da execução em qualquer estado. A estrutura completa do contexto é:

    {
  "Execution": {
    "Name": "String",
    "Input": {},
    "RoleArn": "String"
  },
  "Current": {
    "Name": "String",
    "Input": {},
    "Output": {},
    "Error": {
      "Code": "String",
      "Detail": "String"
    },
    "RetryCount": "Number",
    "TaskToken": "String"
  }
}

    Campo

    Tipo

    Descrição

    Execution.Name

    String

    Nome exclusivo da execução atual

    Execution.Input

    Object

    Entrada fornecida no início da execução

    Execution.RoleArn

    String

    ARN da função RAM usada para executar o fluxo

    Current.Name

    String

    Nome do estado atual

    Current.Input

    Object

    Entrada recebida pelo estado atual

    Current.Output

    Object

    Saída gerada pelo estado atual

    Current.Error.Code

    String

    Código de erro, caso o estado tenha encontrado uma falha

    Current.Error.Detail

    String

    Mensagem detalhada do erro

    Current.RetryCount

    Number

    Quantidade de tentativas de tratamento de erros

    Current.TaskToken

    String

    Token para callbacks de tarefas assíncronas

    Onde usar $Context

    Caso de uso

    Exemplo

    Construtores de entrada e saída

    Consulte Entradas e saídas

    ItemsPath em estados Map

    $Context.Current.Input

    Condição em estados Choice

    $Context.Current.Input.Size>=1024

    Tratamento de erros

    $Context.Current.Error.Code, $Context.Current.Error.Detail

    Tokens de callback de tarefa

    $Context.Current.TaskToken

    Atalhos: $Input e $Output

    O CloudFlow oferece dois atalhos para os caminhos acessados com mais frequência:

    Atalho

    Equivalente

    Quando usar

    $Input

    $Context.Current.Input

    Para ler os dados recebidos por um estado

    $Output

    $Context.Current.Output

    Para ler os dados gerados por um estado
    Nota: $Input e $Output referem-se apenas ao estado atual . Para acessar a entrada original da execução a partir de qualquer estado, use $Context.Execution.Input .

    Comportamento padrão de entrada/saída por tipo de estado

    Na ausência de um InputConstructor ou OutputConstructor, cada tipo de estado trata os dados da seguinte maneira:

    Tipo de estado

    Entrada padrão

    Saída padrão

    Pass, Succeed, Fail, Wait

    Recebe a entrada do estado anterior

    Encaminha a entrada como saída, sem alterações

    Choice

    Recebe a entrada do estado anterior

    Repassa a entrada à ramificação correspondente (ou à ramificação Default). Não gera saída própria

    Parallel

    Copia profundamente a entrada e envia uma cópia a cada ramificação simultaneamente

    Um Map[String]Any em que as chaves são nomes implícitos das ramificações (Branch N) e os valores são os resultados de cada ramificação

    Map

    Itera sobre o array de entrada (ou, se a entrada for um Map[String]Any e nenhum ItemsPath for especificado, itera sobre seus valores)

    Um Map[String]Any em que a chave é Items e o valor é um array com os resultados da iteração

    Task

    Recebe entrada do estado anterior ou de uma fonte externa

    Resultado da execução da tarefa após executar a lógica de negócio e usar $Context para acessar e manipular dados

    Exemplo: rastreamento de dados em um estado Parallel

    Este exemplo demonstra como o InputConstructor molda os dados em um estado Parallel e como o contexto se apresenta em cada etapa da execução.

    Definição do fluxo

    Type: StateMachine
Name: DataTransferExample
SpecVersion: v1
StartAt: Step1
States:
  - Type: Pass
    Name: Step1
    Next: Step2
  - Type: Parallel
    Name: Step2
    InputConstructor:
      FieldA: 123
    Branches:
      - StartAt: Pass1
        States:
          - Type: Pass
            Name: Pass1
            End: true
      - StartAt: Pass2
        States:
          - Type: Pass
            Name: Pass2
            End: true
    Next: Step3
  - Type: Pass
    Name: Step3
    End: true

    Dados em cada etapa

    O rastro a seguir mostra os dados à medida que percorrem o fluxo de trabalho. Considere que a execução começa com uma entrada vazia {}.

    Etapa 1 -- Step1 (Pass)

    Campo

    Valor

    Motivo

    Current.Input

    {}

    Recebe diretamente a entrada da execução

    Current.Output

    {}

    Estados Pass encaminham a entrada sem modificações

    O Step1 passa {} para o Step2.

    Etapa 2 -- Step2 (Parallel) com InputConstructor

    Campo

    Valor

    Motivo

    Entrada do Step1

    {}

    Saída do estado anterior

    Após InputConstructor

    {"FieldA": 123}

    O InputConstructor substitui a entrada original por um novo objeto JSON

    O objeto construído {"FieldA": 123} é copiado profundamente e enviado a ambas as ramificações simultaneamente.

    Etapa 3 -- Pass1 e Pass2 (dentro das ramificações do Parallel)

    Cada ramificação recebe {"FieldA": 123} como entrada. Como ambos são estados Pass, cada um encaminha sua entrada inalterada como saída.

    O contexto dentro do Pass1 durante a execução:

    {
  "Execution": {
    "Name": "xxxx-xxxx-xxxx-xxxx",
    "Input": {},
    "RoleArn": "xxxx"
  },
  "Current": {
    "Name": "Pass1",
    "Input": {
      "FieldA": 123
    },
    "Output": {
      "FieldA": 123
    },
    "Error": null,
    "RetryCount": 0
  }
}

    Observações:

    • Current.Input e Current.Output contêm {"FieldA": 123} porque estados Pass repassam a entrada como saída.

    • Execution.Input permanece como {} (a entrada original da execução), sem ser afetado pelo InputConstructor.

    • Error é null e RetryCount é 0 pois não ocorreram erros.

    Etapa 4 -- Step2 coleta resultados, Step3 (Pass) os recebe

    O Step2 reúne as saídas das ramificações em um resultado Map[String]Any. Cada resultado de ramificação usa um nome implícito (Branch N) como sua entrada no mapa. O Step3 recebe esse resultado combinado e o encaminha sem alterações.

    Próximos passos