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 delle attività **Gestione dello stato e trasformazione dei dati** Scopri come [passare dati tra stati con variabili](workflow-variables.md) e [Trasformare dati](transforming-data.md) con. JSONata Uno stato `Task` (`"Type": "Task"`) rappresenta una singola unità di lavoro eseguita da una macchina a stati. Un'attività esegue il lavoro utilizzando un'attività o una AWS Lambda funzione, integrandosi con altre [supportate Servizi AWS](supported-services-awssdk.md#supported-services-awssdk-list) o richiamando un'API HTTPS, come Stripe. [Amazon States Language](concepts-amazon-states-language.md) rappresenta le attività impostando il tipo di stato `Task` e fornendo all'attività l'Amazon Resource Name (ARN) dell'attività, la funzione Lambda o l'endpoint dell'API HTTPS. **Invoca una funzione con Arguments JSONata ** La seguente definizione dello stato dell'attività (JSONata) richiama una funzione Lambda denominata. `priceWatcher` Nota l'uso di JSONata espressioni per interrogare i dati di input da utilizzare in Arguments e il risultato dell'attività nel campo assign. ``` "Get Current Price": { "Type": "Task", "QueryLanguage" : "JSONata", "Resource": "arn:aws:states:::lambda:invoke", "Next": "Check Price", "Arguments": { "Payload": { "product": "{% $states.context.Execution.Input.product %}" }, "FunctionName": "arn:aws:lambda::account-id:function:priceWatcher:$LATEST" }, "Assign": { "currentPrice": "{% $states.result.Payload.current_price %}" } } ``` **Invoca una funzione con parametri JSONPath ** La seguente definizione dello stato dell'attività (JSONPath) richiama una funzione Lambda denominata. `HelloFunction` ``` "Lambda Invoke": { "Type": "Task", "Resource": "arn:aws:states:::lambda:invoke", "Parameters": { "Payload.$": "$", "FunctionName": "arn:aws:lambda:region:account-id:function:HelloFunction:$LATEST" }, "End": true } ``` ## Tipi di attività Step Functions supporta i seguenti tipi di attività che è possibile specificare in una definizione dello stato dell'attività: + [Attività](#state-task-activity) + [Funzioni Lambda](#state-task-lambda) + [A supportato Servizio AWS](#state-task-connector) + [Un'attività HTTP](call-https-apis.md) È possibile specificare un tipo di attività fornendo il relativo ARN nel `Resource` campo di una definizione dello stato dell'attività. L'esempio seguente mostra la sintassi del `Resource` campo. Tutti i tipi di Task tranne quello che richiama un'API HTTPS utilizzano la seguente sintassi. Per informazioni sulla sintassi del task HTTP, vedere. [Chiama HTTPS APIs nei flussi di lavoro Step Functions](call-https-apis.md) Nella definizione dello stato del task, sostituisci il testo in corsivo nella sintassi seguente con le informazioni specifiche della risorsa. AWS ``` arn:partition:service:region:account:task_type:name ``` L'elenco seguente illustra i singoli componenti di questa sintassi: + `partition`è la AWS Step Functions partizione da utilizzare più comunemente. `aws` + `service`indica il valore Servizio AWS utilizzato per eseguire l'operazione e può essere uno dei seguenti valori: + `states` per un'[attività](#state-task-activity) + `lambda`per una funzione [Lambda](#state-task-lambda). Se esegui l'integrazione con altri Servizi AWS, ad esempio Amazon SNS o Amazon DynamoDB, usa o. `sns` `dynamodb` + `region`è il [codice AWS regionale](https://docs.aws.amazon.com/general/latest/gr/rande.html) in cui è stata creata l'attività di Step Functions o il tipo di macchina a stati, la funzione Lambda o qualsiasi altra AWS risorsa. + `account`è l' Account AWS ID in cui è stata definita la risorsa. + `task_type` è il tipo di task da eseguire. Può essere uno dei seguenti valori: + `activity`— Un'[attività](#state-task-activity). + `function`— Una funzione [Lambda](#state-task-lambda). + `servicename`— Il nome di un servizio connesso supportato (vedi[Integrazione dei servizi con Step Functions](integrate-optimized.md)). + `name`è il nome della risorsa registrata (nome dell'attività, nome della funzione Lambda o azione dell'API del servizio). **Nota** Step Functions non supporta il riferimento ARNs tra partizioni o regioni. Ad esempio, non è `aws-cn` possibile richiamare attività nella `aws` partizione e viceversa. Nelle sezioni seguenti vengono fornite ulteriori informazioni su ogni tipo di task. ### Attività Le attività rappresentano lavoratori (processi o thread), da te implementati e ospitati, che eseguono un task specifico. Sono supportati solo dai flussi di lavoro standard, non dai flussi di lavoro Express. L'attività `Resource` ARNs utilizza la seguente sintassi. ``` arn:partition:states:region:account:activity:name ``` **Nota** È necessario creare attività con Step Functions (utilizzando un'[CreateActivity](https://docs.aws.amazon.com/step-functions/latest/apireference/API_CreateActivity.html)azione API o la [console Step Functions](https://console.aws.amazon.com/states/home?region=us-east-1#/)) prima del loro primo utilizzo. Per ulteriori informazioni sulla creazione di un'attività e l'implementazione di lavoratori, consultare [Attività](concepts-activities.md). ### Funzioni Lambda Le attività Lambda eseguono una funzione utilizzando. AWS Lambda Per specificare una funzione Lambda, usa l'ARN della funzione Lambda nel campo. `Resource` La forma del `Resource` campo della funzione Lambda varia in base al tipo di integrazione. Per un'integrazione AWS SDK standard con una funzione Lambda, `Resource` il campo conterrà il seguente valore: ``` "arn:aws:states:::aws-sdk:lambda:invoke" ``` **Ti consigliamo di** utilizzare l'integrazione ottimizzata per le tue funzioni Lambda, utilizzando il seguente valore per il `Resource` campo: ``` "arn:aws:states:::lambda:invoke" ``` La seguente definizione di `Task` stato mostra un esempio di integrazione ottimizzata con una funzione Lambda denominata `HelloWorld` using. JSONata ``` "Optimized call to Lambda function (JSONata)": { "Type": "Task", "Resource": "arn:aws:states:::lambda:invoke", "Output": "{% $states.result.Payload %}", "Arguments": { "FunctionName": "arn:aws:lambda:region:account-id:function:HelloWorld:$LATEST", "Payload": { "key": "{% $states.input.myKey %}" } }, "Next": "NextState" } ``` ### Un supportato Servizio AWS Quando si fa riferimento a una risorsa connessa, Step Functions richiama direttamente le azioni API di un servizio supportato. Specifica il servizio e l'operazione nel campo `Resource`. Il servizio connesso `Resource` ARNs utilizza la seguente sintassi. ``` arn:partition:states:region:account-id:servicename:APIname ``` **Nota** Per creare una connessione sincrona a una risorsa connessa, aggiungila `.sync` alla *APIname* voce nell'ARN. Per ulteriori informazioni, consulta [Integrazione dei servizi ](integrate-services.md). Esempio: ``` { "StartAt": "BATCH_JOB", "States": { "BATCH_JOB": { "Type": "Task", "Resource": "arn:aws:states:::batch:submitJob.sync", "Parameters": { "JobDefinition": "preprocessing", "JobName": "PreprocessingBatchJob", "JobQueue": "SecondaryQueue", "Parameters.$": "$.batchjob.parameters", "RetryStrategy": { "attempts": 5 } }, "End": true } } } ``` ## Campi relativi allo stato dell'attività Oltre ai [campi di stato comuni](statemachine-structure.md#amazon-states-language-common-fields), gli stati `Task` hanno i seguenti campi. ** `Resource` (Obbligatorio)** Un URI, in particolare un ARN che identifica in modo univoco il task specifico da eseguire. **`Arguments`( JSONata Solo facoltativo)** Utilizzato per passare le informazioni alle operazioni API delle risorse connesse. I valori possono includere JSONata espressioni. Per ulteriori informazioni, consulta [Trasformazione dei dati con Step JSONata Functions](transforming-data.md). **`Output`( JSONata Solo facoltativo)** Utilizzato per specificare e trasformare l'output dello stato. Quando specificato, il valore ha la precedenza sullo stato di output predefinito. Il campo di output accetta qualsiasi valore JSON (oggetto, array, stringa, numero, booleano, null). Qualsiasi valore di stringa, inclusi quelli all'interno di oggetti o array, verrà valutato come JSONata se fosse circondato da \$1%%\$1 caratteri. Output accetta anche direttamente un' JSONata espressione, ad esempio: «Output»: «\$1% jsonata expression%\$1» Per ulteriori informazioni, consultare [Elaborazione di input e output](concepts-input-output-filtering.md). **`Parameters`(Solo opzionale) JSONPath ** Utilizzato per passare le informazioni alle operazioni API delle risorse connesse. I parametri possono utilizzare una combinazione di JSON statico e [JsonPath](https://datatracker.ietf.org/wg/jsonpath/about/). Per ulteriori informazioni, consulta [Passaggio di parametri a un'API di servizio in Step Functions](connect-parameters.md). **`Credentials` (facoltativo).** Specifica un ruolo di destinazione che il ruolo di esecuzione della macchina a stati deve assumere prima di richiamare quello specificato. `Resource` In alternativa, puoi anche specificare un JSONPath valore o una [funzione intrinseca](intrinsic-functions.md) che si risolva in un ruolo IAM ARN in fase di esecuzione in base all'input di esecuzione. Se si specifica un JSONPath valore, è necessario prefissarlo con la notazione. `$.` Per esempi di utilizzo di questo campo nello `Task` stato, vedi. [Esempi di campi relativi alle credenziali dello stato dell'attività](#task-state-example-credentials) Per un esempio di utilizzo di questo campo per accedere a una AWS risorsa multiaccount dalla macchina a stati, vedi[Accesso alle AWS risorse di più account in Step Functions](tutorial-access-cross-acct-resources.md). Questo campo è supportato da chi utilizza le [Tipi di attività](#task-types) [funzioni Lambda e da](#state-task-lambda) [un servizio supportato AWS](integrate-services.md). ** `ResultPath`( JSONPath Solo facoltativo)** Specifica dove (nell'input) posizionare i risultati dell'esecuzione del task specificato in `Resource`. 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](concepts-input-output-filtering.md). ** `ResultSelector`( JSONPath Solo opzionale)** Passa una raccolta di coppie chiave-valore, in cui i valori sono statici o selezionati dal risultato. Per ulteriori informazioni, consulta [ResultSelector](input-output-inputpath-params.md#input-output-resultselector). ** `Retry` (facoltativo).** Un array di oggetti, denominati retrier, che definiscono una policy per i nuovi tentativi se si verificano errori di runtime nello stato. Per ulteriori informazioni, consulta [Esempi di macchine a stati che utilizzano Retry e Catch](concepts-error-handling.md#error-handling-examples). ** `Catch` (facoltativo).** Un array di oggetti, denominati catcher, che definiscono uno stato di fallback. Questo stato viene eseguito se rileva errori di runtime e la relativa policy per i nuovi tentativi è esaurita o non è definita. Per ulteriori informazioni, consulta [Stati di fallback](concepts-error-handling.md#error-handling-fallback-states). ** `TimeoutSeconds` (facoltativo).** Speciifica il tempo massimo di esecuzione di un'attività o di un'attività prima che scada con l'[States.Timeout](concepts-error-handling.md#statestimeout)errore e abbia esito negativo. Il valore di timeout deve essere positivo, un numero intero diverso da zero. Il valore predefinito è `99999999`. Il conteggio dei timeout inizia quando viene eseguito l'evento di avvio, ad esempio quando `TaskStarted``ActivityStarted`, o `LambdaFunctionStarted` gli eventi vengono registrati nella cronologia degli eventi di esecuzione. Per le attività, il conteggio inizia quando `GetActivityTask` riceve un token e `ActivityStarted` viene registrato nella cronologia degli eventi di esecuzione. All'avvio di un'attività, Step Functions attende una risposta positiva o negativa da parte dell'operatore dell'attività o dell'addetto all'attività entro la `TimeoutSeconds` durata specificata. Se l'operatore dell'attività o dell'attività non risponde entro questo periodo, Step Functions contrassegna l'esecuzione del flusso di lavoro come non riuscita. Il timeout dell'attività HTTP ha un massimo di 60 secondi, anche se `TimeoutSeconds` supera tale limite. Per informazioni, consultare [Quote relative a HTTP Task](service-quotas.md#service-limits-http-task). ** `TimeoutSecondsPath`(Solo facoltativo) JSONPath ** Se desideri fornire un valore di timeout in modo dinamico dall'input dello stato utilizzando un percorso di riferimento, usa. `TimeoutSecondsPath` Una volta risolto, il percorso di riferimento deve selezionare campi i cui valori sono numeri interi positivi. Uno `Task` stato non può includere entrambi `TimeoutSeconds` e`TimeoutSecondsPath`. Il timeout dell'attività HTTP ha un massimo di 60 secondi, anche se il `TimeoutSecondsPath` valore supera tale limite. ** `HeartbeatSeconds` (facoltativo).** Determina la frequenza dei segnali del battito cardiaco che un Activity Worker invia durante l'esecuzione di un'attività. I battiti cardiaci indicano che un'attività è ancora in esecuzione e richiede più tempo per essere completata. I battiti cardiaci impediscono che un'attività o un'attività scada entro la durata prevista. `TimeoutSeconds` `HeartbeatSeconds`deve essere un valore intero positivo, diverso da zero, inferiore al valore del campo. `TimeoutSeconds` Il valore predefinito è `99999999`. Se trascorre più tempo dei secondi specificati tra i battiti cardiaci dell'operazione, lo stato dell'operazione ha esito negativo e viene generato un errore. [States.Timeout](concepts-error-handling.md#statestimeout) Per le attività, il conteggio inizia quando `GetActivityTask` riceve un token e `ActivityStarted` viene registrato nella cronologia degli eventi di esecuzione. ** `HeartbeatSecondsPath`( JSONPath Solo facoltativo)** Se si desidera fornire un valore del battito cardiaco in modo dinamico a partire dallo stato immesso utilizzando un percorso di riferimento, utilizzare. `HeartbeatSecondsPath` Una volta risolto, il percorso di riferimento deve selezionare campi i cui valori sono numeri interi positivi. Uno `Task` stato non può includere entrambi `HeartbeatSeconds` e`HeartbeatSecondsPath`. Uno stato `Task` deve impostare il campo `End` su `true` se lo stato termina l'esecuzione oppure deve fornire uno stato nel campo `Next` che verrà eseguito al completamento dello stato `Task`. ## Esempi di definizione dello stato dell'attività Gli esempi seguenti mostrano come specificare la definizione dello stato dell'attività in base alle proprie esigenze. + [Specificazione dei timeout dello stato dell'attività e degli intervalli del battito cardiaco](#task-state-example-timeouts) + [Esempio di notifica di timeout statico e battito cardiaco](#task-state-example-static) + [Esempio di notifica dinamica di timeout delle attività e battito cardiaco](#task-state-example-dynamic) + [Utilizzo del campo Credenziali](#task-state-example-credentials) + [Specificazione dell'ARN del ruolo IAM codificato](#example-credentials-specify-role-arn) + [Specificazione dell' JSONPath ARN come ruolo IAM](#example-credentials-specify-dynamic-jsonpath) + [Specificazione di una funzione intrinseca come ARN del ruolo IAM](#example-credentials-specify-dynamic-intrinsic-function) ### Timeout dello stato delle attività e intervalli di battito cardiaco È buona norma impostare un valore di timeout e un intervallo di heartbeat per le attività di lunga durata. Questa operazione può essere eseguita specificando i valori di timeout e heartbeat o impostandoli dinamicamente. #### Esempio di notifica di timeout statico e battito cardiaco Al completamento di `HelloWorld`, verrà eseguito lo stato successivo (qui denominato `NextState`). Se non viene completato entro 300 secondi o non invia notifiche heartbeat a intervalli di 60 secondi, questo task viene contrassegnato come `failed`. ``` "ActivityState": { "Type": "Task", "Resource": "arn:aws:states:region:123456789012:activity:HelloWorld", "TimeoutSeconds": 300, "HeartbeatSeconds": 60, "Next": "NextState" } ``` #### Esempio di notifica dinamica di timeout delle attività e battito cardiaco In questo esempio, al termine del AWS Glue processo, verrà eseguito lo stato successivo. Se questa attività non viene completata entro l'intervallo impostato dinamicamente dal AWS Glue lavoro, l'attività viene contrassegnata come. `failed` ``` "GlueJobTask": { "Type": "Task", "Resource": "arn:aws:states:::glue:startJobRun.sync", "Parameters": { "JobName": "myGlueJob" }, "TimeoutSecondsPath": "$.params.maxTime", "Next": "NextState" } ``` ### Esempi di campi relativi alle credenziali dello stato dell'attività #### Specificazione dell'ARN del ruolo IAM codificato L'esempio seguente specifica un ruolo IAM di destinazione che il ruolo di esecuzione di una macchina a stati deve assumere per accedere a una funzione Lambda multiaccount denominata. `Echo` In questo esempio, l'ARN del ruolo di destinazione è specificato come valore codificato. ``` { "StartAt": "Cross-account call", "States": { "Cross-account call": { "Type": "Task", "Resource": "arn:aws:states:::lambda:invoke", "Credentials": { "RoleArn": "arn:aws:iam::111122223333:role/LambdaRole" }, "Parameters": { "FunctionName": "arn:aws:lambda:us-east-2:111122223333:function:Echo" }, "End": true } } } ``` #### Specificazione dell' JSONPath ARN come ruolo IAM L'esempio seguente specifica un JSONPath valore, che verrà risolto in un ruolo IAM ARN in fase di esecuzione. ``` { "StartAt": "Lambda", "States": { "Lambda": { "Type": "Task", "Resource": "arn:aws:states:::lambda:invoke", "Credentials": { "RoleArn.$": "$.roleArn" }, ... } } } ``` #### Specificazione di una funzione intrinseca come ARN del ruolo IAM L'esempio seguente utilizza la funzione [`States.Format`](intrinsic-functions.md#asl-intrsc-func-generic)intrinseca, che si risolve in un ruolo IAM ARN in fase di esecuzione. ``` { "StartAt": "Lambda", "States": { "Lambda": { "Type": "Task", "Resource": "arn:aws:states:::lambda:invoke", "Credentials": { "RoleArn.$": "States.Format('arn:aws:iam::{}:role/ROLENAME', $.accountId)" }, ... } } } ```