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à. # Utilizzo dello stato della mappa in modalità Inline nei flussi di lavoro Step Functions **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 Per impostazione predefinita, `Map` gli stati vengono eseguiti in modalità **Inline**. In modalità Inline, lo stato della mappa accetta solo un array JSON come input. Riceve questo array da una fase precedente del flusso di lavoro. In questa modalità, ogni iterazione dello `Map` stato viene eseguita nel contesto del flusso di lavoro che contiene lo `Map` stato. Step Functions aggiunge la cronologia di esecuzione di queste iterazioni alla cronologia di esecuzione del flusso di lavoro principale. In questa modalità, lo `Map` stato supporta fino a 40 iterazioni simultanee. Uno `Map` stato impostato su **Inline** è noto come stato *Inline* Map. Utilizza lo `Map` stato in modalità Inline se la cronologia di esecuzione del flusso di lavoro non supera le 25.000 voci o se non sono necessarie più di 40 iterazioni simultanee. Per un'introduzione all'uso *dello stato della mappa in linea*, consulta il tutorial. [Ripeti le azioni con Inline Map](tutorial-map-inline.md) **Topics** + [Concetti chiave in questo argomento](#key-concepts-inline-map) + [Campi di stato della mappa in linea](#map-state-inline-additional-fields) + [Campi obsoleti](#map-state-inline-deprecated-fields) + [Esempio di stato della mappa in linea () JSONPath](#inline-map-state-examples) + [Esempio di stato della mappa in linea con `ItemSelector`](#inline-map-state-example-params) + [Elaborazione di input e `Map` output in stato di linea](#inline-map-state-output) ## Concetti chiave in questo argomento **Modalità in linea** Una modalità di concorrenza limitata dello stato. `Map` In questa modalità, ogni iterazione dello `Map` stato viene eseguita nel contesto del flusso di lavoro che contiene lo stato. `Map` Step Functions aggiunge la cronologia di esecuzione di queste iterazioni alla cronologia di esecuzione del flusso di lavoro principale. `Map`gli stati vengono eseguiti in modalità Inline per impostazione predefinita. Questa modalità accetta solo un array JSON come input e supporta fino a 40 iterazioni simultanee. **Stato della mappa in linea** Uno `Map` stato impostato sulla modalità **Inline**. **Mappa il flusso di lavoro** L'insieme di passaggi eseguiti dallo `Map` stato per ogni iterazione. **Iterazione dello stato della mappa** Una ripetizione del flusso di lavoro definito all'interno dello `Map` stato. ## Campi di stato della mappa in linea Per utilizzare lo *stato Inline Map* nei flussi di lavoro, specifica uno o più di questi campi. Specificate questi campi oltre ai campi di [stato comuni](statemachine-structure.md#amazon-states-language-common-fields). **`Type` (Obbligatorio)** Imposta il tipo di stato, ad esempio`Map`. **`ItemProcessor` (Obbligatorio)** Contiene i seguenti oggetti JSON che specificano la modalità e la definizione di elaborazione `Map` dello stato. La definizione contiene l'insieme di passaggi da ripetere per l'elaborazione di ogni elemento dell'array. + `ProcessorConfig`— Un oggetto JSON opzionale che specifica la modalità di elaborazione per lo `Map` stato. Questo oggetto contiene il sottocampo`Mode`. Il valore predefinito di questo campo è`INLINE`, che utilizza `Map` lo stato in modalità Inline. In questa modalità, l'errore di qualsiasi iterazione causa il fallimento dello `Map` stato. Tutte le iterazioni si interrompono quando lo `Map` stato fallisce. + `StartAt`— specifica una stringa che indica il primo stato di un flusso di lavoro. Questa stringa fa distinzione tra maiuscole e minuscole e deve corrispondere al nome di uno degli oggetti di stato. Questo stato viene eseguito per primo per ogni elemento del set di dati. Qualsiasi input di esecuzione fornito allo `Map` stato passa per primo allo `StartAt` stato. + `States`[— Un oggetto JSON contenente un set di stati delimitato da virgole.](workflow-states.md) In questo oggetto, si definisce il. [Map workflow](#mapwflow) **Nota** Gli stati all'interno del `ItemProcessor` campo possono solo passare l'uno dall'altro. Nessuno stato esterno al `ItemProcessor` campo può passare a uno stato al suo interno. Il `ItemProcessor` campo sostituisce il campo ora obsoleto`Iterator`. Sebbene sia possibile continuare a includere `Map` gli stati che utilizzano il `Iterator` campo, si consiglia vivamente di sostituirlo con. `ItemProcessor` [Step Functions Local](sfn-local.md) attualmente non supporta il `ItemProcessor` campo. Si consiglia di utilizzare il `Iterator` campo con Step Functions Local. **`Items`( JSONata Solo facoltativo)** Un array JSON o un' JSONata espressione che deve restituire un array. **`ItemsPath`( JSONPath Solo facoltativo)** Specificate un [percorso di riferimento](amazon-states-language-paths.md#amazon-states-language-reference-paths) utilizzando la [JsonPath](https://datatracker.ietf.org/wg/jsonpath/about/)sintassi. Questo percorso seleziona il nodo JSON che contiene l'array di elementi all'interno dell'input di stato. Per ulteriori informazioni, consulta [ItemsPath ( JSONPath Solo mappa)](input-output-itemspath.md). **`ItemSelector` (facoltativo).** Sostituisce i valori degli elementi dell'array di input prima che vengano passati a ciascuna iterazione di stato. `Map` In questo campo, si specifica un JSON valido che contiene una raccolta di coppie chiave-valore. Queste coppie possono contenere uno dei seguenti elementi: + Valori statici definiti nella definizione della macchina a stati. + Valori selezionati dall'input dello stato utilizzando un [percorso](amazon-states-language-paths.md). + Valori a cui si accede dall'[oggetto contestuale](input-output-contextobject.md). Per ulteriori informazioni, consulta [ItemSelector (Mappa)](input-output-itemselector.md). Il `ItemSelector` campo sostituisce il campo ora obsoleto`Parameters`. Sebbene sia possibile continuare a includere `Map` gli stati che utilizzano il `Parameters` campo, si consiglia vivamente di sostituirlo con. `ItemSelector` **`MaxConcurrency` (facoltativo).** Specifica un valore intero che fornisce il limite superiore del numero di iterazioni di `Map` stato che possono essere eseguite in parallelo. Ad esempio, un `MaxConcurrency` valore pari a 10 limita lo `Map` stato a 10 iterazioni simultanee eseguite contemporaneamente. Negli JSONata stati, è possibile specificare un' JSONata espressione che restituisca un numero intero. Le iterazioni simultanee possono essere limitate. Quando ciò si verifica, alcune iterazioni non inizieranno fino al completamento delle iterazioni precedenti. La probabilità che ciò si verifichi aumenta quando l'array di input contiene più di 40 elementi. Per ottenere una maggiore concorrenza, considera. [Modalità distribuita](state-map-distributed.md) Il valore predefinito è`0`, che non pone limiti alla concorrenza. Step Functions richiama le iterazioni il più simultaneamente possibile. `MaxConcurrency`Il valore di `1` invoca una volta per ogni elemento dell'`ItemProcessor`array. Gli elementi dell'array vengono elaborati nell'ordine in cui appaiono nell'input. Step Functions non avvia una nuova iterazione finché non completa l'iterazione precedente. **`MaxConcurrencyPath`(Solo facoltativo) JSONPath ** Se desideri fornire un valore di concorrenza massimo in modo dinamico dall'input dello stato utilizzando un percorso di riferimento, usa. `MaxConcurrencyPath` Una volta risolto, il percorso di riferimento deve selezionare un campo il cui valore è un numero intero non negativo. Uno `Map` stato non può includere entrambi `MaxConcurrency` e. `MaxConcurrencyPath` **`ResultPath`( JSONPath Solo facoltativo)** Speciifica dove, nell'input, deve essere memorizzato l'output delle iterazioni dello `Map` stato. Lo stato Mappa filtra quindi l'input come specificato dal [`OutputPath`](input-output-example.md#input-output-outputpath)campo, se specificato. Quindi, utilizza l'input filtrato come output dello stato. Per ulteriori informazioni, consultare [Elaborazione di input e output](concepts-input-output-filtering.md). **`ResultSelector`( JSONPath Solo facoltativo)** 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). Se lo stato Parallel o Map che usi nelle tue macchine a stati restituisce un array di array, puoi trasformarli in un array flat con il [ResultSelector](input-output-inputpath-params.md#input-output-resultselector) campo. Per ulteriori informazioni, consulta [Appiattimento di una serie di array](input-output-inputpath-params.md#flatten-array-of-arrays-result-selector). **`Retry` (facoltativo).** Una serie di oggetti, denominati Retriers, che definiscono una politica di nuovi tentativi. Gli stati utilizzano una politica di nuovo tentativo quando riscontrano errori di runtime. Per ulteriori informazioni, consulta [Esempi di macchine a stati che utilizzano Retry e Catch](concepts-error-handling.md#error-handling-examples). Se definisci Retriers per *lo stato Inline Map*, la politica di riprova si applica a tutte le iterazioni di `Map` stato, anziché solo alle iterazioni fallite. Ad esempio, `Map` lo stato contiene due iterazioni riuscite e un'iterazione fallita. Se avete definito il `Retry` campo per `Map` lo stato, la politica di riprova si applica a tutte e tre le iterazioni di `Map` stato anziché solo all'iterazione fallita. **`Catch` (facoltativo).** Un array di oggetti, denominati catcher, che definiscono uno stato di fallback. Gli stati eseguono un catcher se riscontrano errori di runtime e non dispongono di una politica di ripetizione dei tentativi oppure la politica di ripetizione dei tentativi è esaurita. Per ulteriori informazioni, consulta [Stati di fallback](concepts-error-handling.md#error-handling-fallback-states). **`Output`(Solo facoltativo) 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 fosse circondato da \$1%%\$1 caratteri. Output accetta anche direttamente un' JSONata espressione, ad esempio: «Output»: «\$1% jsonata expression%\$1» Per ulteriori informazioni, consulta [Trasformazione dei dati con Step JSONata Functions](transforming-data.md). ** `Assign` (facoltativo).** Utilizzato per memorizzare variabili. Il `Assign` campo accetta un oggetto JSON con key/value coppie che definiscono i nomi delle variabili e i valori assegnati. Qualsiasi valore di stringa, compresi quelli all'interno di oggetti o matrici, verrà valutato come JSONata se fosse circondato da caratteri `{% %}` Per ulteriori informazioni, consulta [Passaggio di dati tra stati con variabili](workflow-variables.md). ## Campi obsoleti **Nota** Sebbene sia possibile continuare a includere `Map` stati che utilizzano i seguenti campi, consigliamo vivamente di sostituirli `Iterator` con e con`ItemProcessor`. `Parameters` `ItemSelector` ** `Iterator`** Specifica un oggetto JSON che definisce una serie di passaggi che elaborano ogni elemento dell'array. **`Parameters`** Specifica una raccolta di coppie chiave-valore, in cui i valori possono contenere uno dei seguenti elementi: + Valori statici definiti nella definizione della macchina a stati. + Valori selezionati dall'input utilizzando un [percorso](amazon-states-language-paths.md). ## Esempio di stato della mappa in linea () JSONPath Considerate i seguenti dati di input per uno `Map` stato in esecuzione in modalità **Inline**. ``` { "ship-date": "2016-03-14T01:59:00Z", "detail": { "delivery-partner": "UQS", "shipped": [ { "prod": "R31", "dest-code": 9511, "quantity": 1344 }, { "prod": "S39", "dest-code": 9511, "quantity": 40 }, { "prod": "R31", "dest-code": 9833, "quantity": 12 }, { "prod": "R40", "dest-code": 9860, "quantity": 887 }, { "prod": "R40", "dest-code": 9511, "quantity": 1220 } ] } } ``` Dato l'input precedente, lo `Map` stato dell'esempio seguente richiama una AWS Lambda funzione denominata `ship-val` una volta per ogni elemento dell'array nel campo. `shipped` ``` "Validate All": { "Type": "Map", "InputPath": "$.detail", "ItemProcessor": { "ProcessorConfig": { "Mode": "INLINE" }, "StartAt": "Validate", "States": { "Validate": { "Type": "Task", "Resource": "arn:aws:states:::lambda:invoke", "OutputPath": "$.Payload", "Parameters": { "FunctionName": "arn:aws:lambda:us-east-2:account-id:function:ship-val:$LATEST" }, "End": true } } }, "End": true, "ResultPath": "$.detail.shipped", "ItemsPath": "$.shipped" } ``` Ogni iterazione dello `Map` stato invia un elemento dell'array, selezionato con il [`ItemsPath`](input-output-itemspath.md)campo, come input per la funzione `ship-val` Lambda. I seguenti valori sono un esempio di input che lo `Map` stato invia a una chiamata della funzione Lambda: ``` { "prod": "R31", "dest-code": 9511, "quantity": 1344 } ``` Al termine, l'output dello stato `Map` è un array JSON, dove ogni item è l'output di un'iterazione. In questo caso, questo array contiene l'output della funzione `ship-val` Lambda. ## Esempio di stato della mappa in linea con `ItemSelector` Supponiamo che la funzione `ship-val` Lambda dell'esempio precedente richieda anche informazioni sul corriere della spedizione. Queste informazioni si aggiungono agli elementi dell'array per ogni iterazione. È possibile includere informazioni provenienti dall'input, insieme a informazioni specifiche sull'iterazione corrente dello `Map` stato. Notate il `ItemSelector` campo nell'esempio seguente: ``` "Validate-All": { "Type": "Map", "InputPath": "$.detail", "ItemsPath": "$.shipped", "MaxConcurrency": 0, "ResultPath": "$.detail.shipped", "ItemSelector": { "parcel.$": "$$.Map.Item.Value", "courier.$": "$.delivery-partner" }, "ItemProcessor": { "StartAt": "Validate", "States": { "Validate": { "Type": "Task", "Resource": "arn:aws:lambda:region:account-id:function:ship-val", "End": true } } }, "End": true } ``` Il `ItemSelector` blocco sostituisce l'input delle iterazioni con un nodo JSON. Questo nodo contiene sia i dati dell'articolo corrente dall'[oggetto Context](input-output-contextobject.md#contextobject-map) sia le informazioni sul corriere dal campo dell'input dello `Map` stato. `delivery-partner` Di seguito è riportato un esempio di input per una singola iterazione. Lo `Map` stato passa questo input a una chiamata della funzione Lambda`ship-val`. ``` { "parcel": { "prod": "R31", "dest-code": 9511, "quantity": 1344 }, "courier": "UQS" } ``` Nel precedente esempio di *stato Inline Map*, il `ResultPath` campo produce un output nello stesso formato dell'input. Tuttavia, sovrascrive il `detail.shipped` campo con un array in cui ogni elemento è l'output della chiamata Lambda `ship-val` di ogni iterazione. Per ulteriori informazioni sull'utilizzo *dello stato dello stato della mappa inline* e dei relativi campi, consulta quanto segue. + [Ripeti le azioni con Inline Map](tutorial-map-inline.md) + [Elaborazione di input e output in Step Functions](concepts-input-output-filtering.md) + [ItemsPath ( JSONPath Solo mappa)](input-output-itemspath.md) + [Dati contestuali degli oggetti per gli stati della mappa](input-output-contextobject.md#contextobject-map) ## Elaborazione di input e `Map` output in stato di linea Per un determinato `Map` stato, [`InputPath`](input-output-inputpath-params.md#input-output-inputpath)seleziona un sottoinsieme dell'input dello stato. L'input di uno `Map` stato deve includere un array JSON. Lo `Map` stato esegue la `ItemProcessor` sezione una volta per ogni elemento dell'array. Se si specifica il [`ItemsPath`](input-output-itemspath.md)campo, `Map` lo stato seleziona la posizione dell'input per trovare l'array su cui eseguire l'iterazione. Se non è specificato, il valore di `ItemsPath` è `$` e la sezione `ItemProcessor` prevede che l'array sia l'unico input. Se specificate il `ItemsPath` campo, il suo valore deve essere un percorso di [riferimento.](amazon-states-language-paths.md#amazon-states-language-reference-paths) Lo `Map` stato applica questo percorso all'input effettivo dopo aver applicato il`InputPath`. `ItemsPath`Deve identificare un campo il cui valore è un array JSON. L'input per ogni iterazione, per impostazione predefinita, è un singolo elemento del campo dell'array identificato dal `ItemsPath` valore. È possibile sovrascrivere questo valore con il `ItemSelector (Mappa)` campo. Al termine, l'output dello stato `Map` è un array JSON, dove ogni item è l'output di un'iterazione. Per ulteriori informazioni sugli input e gli output dello stato di Inline Map, consulta quanto segue: + [Ripeti le azioni con Inline Map](tutorial-map-inline.md) + [Esempio di stato della mappa in linea con `ItemSelector`](#inline-map-state-example-params) + [Elaborazione di input e output in Step Functions](concepts-input-output-filtering.md) + [Dati contestuali degli oggetti per gli stati della mappa](input-output-contextobject.md#contextobject-map) + [Elabora i dati da una coda con uno stato della mappa in Step Functions](sample-map-state.md)