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 i dati con](transforming-data.md) 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](supported-services-awssdk.md#supported-services-awssdk-list) o richiamando un'API HTTPS Servizi AWS, 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 JSONata Arguments**
La seguente definizione dello stato dell'attività (JSonata) richiama una funzione Lambda denominata. `{{priceWatcher}}`
Nota l'uso delle espressioni JSonata 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 JsonPath Parameters**
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 supportata 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 agli ARN 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.
Gli ARN `Resource` di attività utilizzano 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}}` utilizzando 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"
}
```
### A supportata 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`.
Gli ARN `Resource` del servizio connesso utilizzano 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`(Facoltativo, solo JSonata)**
Utilizzato per passare le informazioni alle operazioni API delle risorse connesse. I valori possono includere espressioni JSonata. Per ulteriori informazioni, consulta [Trasformazione dei dati con JSonata in Step Functions](transforming-data.md).
**`Output`(Facoltativo, solo JSonata)**
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 circondato da {%%} caratteri.
Output accetta anche direttamente un'espressione JSonata, ad esempio: «Output»: «{% jsonata expression%}»
Per ulteriori informazioni, consultare [Elaborazione di input e output](concepts-input-output-filtering.md).
**`Parameters`(Facoltativo, solo 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 valore JSONPath o una [funzione intrinseca](intrinsic-functions.md) che si risolve in un ruolo IAM ARN in fase di esecuzione in base all'input di esecuzione. Se specifichi un valore JSONPath, devi prefissarlo con la notazione. `$.`
Per esempi di utilizzo di questo campo nello stato, vedi. `Task` [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 tra account diversi 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`(Facoltativo, solo JSONPath)**
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`(Facoltativo, solo JsonPath)**
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 è 99.999.999.
Il conteggio dei timeout inizia quando viene eseguito l'evento di avvio, ad esempio quando `TaskStarted``ActivityStarted`, oppure `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`(Facoltativo, solo 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 è 99.999.999. 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`(Facoltativo, solo JsonPath)**
Se desideri fornire un valore del battito cardiaco in modo dinamico dall'input dello stato utilizzando un percorso di riferimento, usa. `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 del timeout delle attività e del 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 di JSONPath come ARN del 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 del timeout delle attività e del 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 di JSONPath come ARN del ruolo IAM
L'esempio seguente specifica un valore JSONPath, 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)"
},
...
}
}
}
```