Stato del flusso di lavoro parallelo - AWS Step Functions
Esempio di stato ParallelElaborazione di input e output dello stato ParallelGestione errori

Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.

Stato del flusso di lavoro parallelo

Lo Parallel stato ("Type": "Parallel") può essere usato per aggiungere rami di esecuzione separati nella macchina a stati.

Oltre ai campi di stato comuni, gli stati Parallel includono i seguenti campi aggiuntivi.

Branches (Obbligatorio)

Un array di oggetti che specificano le macchine a stati da eseguire in parallelo. Ognuno di questi oggetti deve avere campi denominati States e StartAt, i cui significati sono esattamente uguali a quelli nel livello superiore di una macchina a stati.

ResultPath (facoltativo).

Specifica dove (nell'input) posizionare l'output dei rami. L'input viene quindi filtrato come specificato dal campo OutputPath (se presente) prima di essere utilizzato come output dello stato. Per ulteriori informazioni, consultare Elaborazione di input e output.

ResultSelector (facoltativo).

Passa una raccolta di coppie chiave-valore, in cui i valori sono statici o selezionati dal risultato. Per ulteriori informazioni, consulta ResultSelector.

Retry (facoltativo).

Un array di oggetti, denominati retrier, che definiscono una policy per i nuovi tentativi nel caso in cui si verifichino errori di runtime nello stato. Per ulteriori informazioni, consulta Esempi di macchine a stati che utilizzano Retry e Catch.

Catch (facoltativo).

Un array di oggetti, denominati catcher, che definiscono uno stato di fallback che viene eseguito se si verificano errori di runtime nello stato e la relativa policy per i nuovi tentativi risulta esaurita o non definita. Per ulteriori informazioni, consulta Stati di fallback.

Uno Parallel stato fa sì AWS Step Functions che ogni ramo, a partire dallo stato indicato nel StartAt campo di quel ramo, venga eseguito il più contemporaneamente possibile, e attendere che tutti i rami terminino (raggiungano uno stato terminale) prima di elaborare il campo Parallel dello Next stato.

Esempio di stato Parallel

{
  "Comment": "Parallel Example.",
  "StartAt": "LookupCustomerInfo",
  "States": {
    "LookupCustomerInfo": {
      "Type": "Parallel",
      "End": true,
      "Branches": [
        {
         "StartAt": "LookupAddress",
         "States": {
           "LookupAddress": {
             "Type": "Task",
             "Resource":
               "arn:aws:lambda:us-east-1:123456789012:function:AddressFinder",
             "End": true
           }
         }
       },
       {
         "StartAt": "LookupPhone",
         "States": {
           "LookupPhone": {
             "Type": "Task",
             "Resource":
               "arn:aws:lambda:us-east-1:123456789012:function:PhoneFinder",
             "End": true
           }
         }
       }
      ]
    }
  }
}

Nel presente esempio, i rami LookupAddress e LookupPhone sono eseguiti in parallelo. Ecco come appare il flusso di lavoro visivo nella console Step Functions.

Grafico visivo di un esempio di workflow parallelo.

Ogni ramo deve essere autonomo. Uno stato in un ramo di uno stato Parallel non deve avere un campo Next che utilizza come target un campo al di fuori di quel ramo, né qualsiasi altro stato al di fuori della transizione di ramo in quel ramo.

Elaborazione di input e output dello stato Parallel

Uno stato Parallel fornisce a ogni ramo una copia dei relativi dati di input (soggetti a modifica mediante il campo InputPath). Genera un output che è un array con un elemento per ogni ramo, contenente l'output di quel ramo. Tutti gli elementi non devono essere obbligatoriamente dello stesso tipo. L'array di output può essere inserito nei dati di input (e il tutto inviato come output dello stato Parallel) utilizzando un campo ResultPath nel modo consueto (vedi Elaborazione di input e output).

{
  "Comment": "Parallel Example.",
  "StartAt": "FunWithMath",
  "States": {
    "FunWithMath": {
      "Type": "Parallel",
      "End": true,
      "Branches": [
        {
          "StartAt": "Add",
          "States": {
            "Add": {
              "Type": "Task",
              "Resource": "arn:aws:states:us-east-1:123456789012:activity:Add",
              "End": true
            }
          }
        },
        {
          "StartAt": "Subtract",
          "States": {
            "Subtract": {
              "Type": "Task",
              "Resource": "arn:aws:states:us-east-1:123456789012:activity:Subtract",
              "End": true
            }
          }
        }
      ]
    }
  }
}

Se allo stato FunWithMath viene assegnato l'array [3, 2] come input, gli stati Add e Subtract ricevono quell'array come input. L'output delle Subtract attività Add e sarebbe la somma e la differenza tra gli elementi 3 e 2 dell'array, ovvero 5 e1, mentre l'output dello Parallel stato sarebbe un array.

[ 5, 1 ]
Suggerimento

Se lo stato Parallel o Map che usi nelle tue macchine a stati restituisce un array di array, puoi trasformarli in una matrice piatta con il ResultSelector campo. Per ulteriori informazioni, consulta Appiattimento di una serie di array.

Gestione errori

Se un ramo ha esito negativo, a causa di un errore non gestito o a seguito della transizione a uno stato Fail, l'intero stato Parallel viene considerato come non riuscito e tutti i relativi rami vengono arrestati. Se l'errore non viene gestito dallo Parallel stato stesso, Step Functions interrompe l'esecuzione con un errore.

Nota

Quando si verifica un errore in uno stato parallelo, le funzioni Lambda richiamate continuano a essere eseguite e gli activity worker che elaborano un task token non vengono interrotti.

  • Per interrompere le attività di lunga durata, utilizza gli heartbeats per rilevare se la succursale è stata interrotta da Step Functions e interrompi i lavoratori che stanno elaborando le attività. La chiamata di SendTaskHeartbeat, SendTaskSuccess o SendTaskFailure genererà un errore se lo stato ha esito negativo. Consulta la selezione relativa agli Errori di heartbeat.

  • L'esecuzione delle funzioni Lambda non può essere interrotta. Se hai implementato un fallback, usa uno Wait stato in modo che il lavoro di pulizia avvenga al termine della funzione Lambda.