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à.
# Elaborazione di singoli articoli con una funzione Lambda in Step Functions
In questo tutorial, si utilizza il [ItemBatcher (Mappa)](input-output-itembatcher.md) campo *dello stato della mappa distribuita* per iterare sui singoli elementi presenti in un batch utilizzando una funzione Lambda. Lo *stato Distributed Map* avvia quattro esecuzioni di workflow secondarie. Ciascuno di questi flussi di lavoro secondari esegue uno stato della mappa *in linea*. Per ogni iterazione, lo *stato Inline Map* richiama una funzione Lambda e passa un singolo elemento dal batch alla funzione. La funzione Lambda elabora quindi l'elemento e restituisce il risultato.
Creerai una macchina a stati che esegue la moltiplicazione su una matrice di numeri interi. Supponiamo che l'array di numeri interi fornito come input sia `[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]` e che il fattore di moltiplicazione sia. `7` Quindi, l'array risultante formato dopo aver moltiplicato questi numeri interi per un fattore 7, sarà. `[7, 14, 21, 28, 35, 42, 49, 56, 63, 70]`
## Fase 1: Creare la macchina a stati
[In questo passaggio, crei il prototipo di flusso di lavoro della macchina a stati che passa un singolo elemento da un batch di elementi a ogni invocazione della funzione Lambda che creerai nel Passaggio 2.](#itembatcher-single-item-process-config-resource)
+ Usa la seguente definizione per creare una macchina a stati utilizzando la [console Step Functions](https://console.aws.amazon.com/states/home?region=us-east-1#/). Per informazioni sulla creazione di una macchina a stati, [Fase 1: Creare il prototipo del flusso di lavoro](tutorial-map-distributed.md#use-dist-map-create-workflow) consultate il tutorial [Guida introduttiva all'uso di Distributed Map state](tutorial-map-distributed.md) tutorial.
In questa macchina a stati, si definisce uno *stato della mappa distribuita* che accetta un array di 10 numeri interi come input e passa questi elementi dell'array alle esecuzioni secondarie del flusso di lavoro in batch. Ogni esecuzione del workflow secondario riceve un batch di tre elementi come input ed esegue uno stato *Inline* Map. Ogni iterazione dello *stato Inline Map* richiama una funzione Lambda e passa un elemento dal batch alla funzione. Questa funzione quindi moltiplica l'elemento per un fattore di e restituisce il risultato. `7`
L'output di ogni esecuzione del workflow secondario è un array JSON che contiene il risultato della moltiplicazione per ciascuno degli elementi passati.
**Importante**
[Assicurati di sostituire l'Amazon Resource Name (ARN) della funzione Lambda nel codice seguente con l'ARN della funzione che creerai nella fase 2.](#itembatcher-single-item-process-config-resource)
```
{
"StartAt": "Pass",
"States": {
"Pass": {
"Type": "Pass",
"Next": "Map",
"Result": {
"MyMultiplicationFactor": 7,
"MyItems": [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
}
},
"Map": {
"Type": "Map",
"ItemProcessor": {
"ProcessorConfig": {
"Mode": "DISTRIBUTED",
"ExecutionType": "STANDARD"
},
"StartAt": "InnerMap",
"States": {
"InnerMap": {
"Type": "Map",
"ItemProcessor": {
"ProcessorConfig": {
"Mode": "INLINE"
},
"StartAt": "Lambda Invoke",
"States": {
"Lambda Invoke": {
"Type": "Task",
"Resource": "arn:aws:states:::lambda:invoke",
"OutputPath": "$.Payload",
"Parameters": {
"Payload.$": "$",
"FunctionName": "arn:aws:lambda:region:account-id:function:functionName"
},
"Retry": [
{
"ErrorEquals": [
"Lambda.ServiceException",
"Lambda.AWSLambdaException",
"Lambda.SdkClientException",
"Lambda.TooManyRequestsException"
],
"IntervalSeconds": 2,
"MaxAttempts": 6,
"BackoffRate": 2
}
],
"End": true
}
}
},
"End": true,
"ItemsPath": "$.Items",
"ItemSelector": {
"MyMultiplicationFactor.$": "$.BatchInput.MyMultiplicationFactor",
"MyItem.$": "$$.Map.Item.Value"
}
}
}
},
"End": true,
"Label": "Map",
"MaxConcurrency": 1000,
"ItemsPath": "$.MyItems",
"ItemBatcher": {
"MaxItemsPerBatch": 3,
"BatchInput": {
"MyMultiplicationFactor.$": "$.MyMultiplicationFactor"
}
}
}
}
}
```
## Fase 2: Creare la funzione Lambda
In questo passaggio, si crea la funzione Lambda che elabora ogni elemento passato dal batch.
**Importante**
Assicurati che la tua funzione Lambda sia utilizzata Regione AWS come la tua macchina a stati.
**Creazione della funzione Lambda**
1. Usa la [console Lambda](https://console.aws.amazon.com/lambda/home) per creare una funzione Python **Lambda** denominata. **ProcessSingleItem** Per informazioni sulla creazione di una funzione Lambda, consulta [Fase 4: Configurazione della funzione Lambda](tutorial-map-distributed.md#use-dist-map-config-resource) nel tutorial [Guida introduttiva all'uso di Distributed Map state](tutorial-map-distributed.md).
1. Copia il codice seguente per la funzione Lambda e incollalo nella sezione **Codice sorgente** della tua funzione Lambda.
```
import json
def lambda_handler(event, context):
multiplication_factor = event['MyMultiplicationFactor']
item = event['MyItem']
result = multiplication_factor * item
return {
'statusCode': 200,
'multiplied': result
}
```
1. Dopo aver creato la funzione Lambda, copia l'ARN della funzione visualizzato nell'angolo superiore destro della pagina. Di seguito è riportato un esempio di ARN, dove *`function-name`* è il nome della funzione Lambda (in questo caso,): `ProcessSingleItem`
```
arn:aws:lambda:region:123456789012:function:function-name
```
Dovrai fornire la funzione ARN nella macchina a stati creata nel [passaggio](#itembatcher-single-item-process-create-state-machine) 1.
1. Scegli **Deploy** per distribuire le modifiche.
## Passaggio 3: Esegui la macchina a stati
Quando si esegue la [macchina a stati, lo stato](#itembatcher-single-item-process-create-state-machine) *Distributed Map* avvia quattro esecuzioni di workflow secondarie, in cui ogni esecuzione elabora tre elementi, mentre un'esecuzione elabora un singolo elemento.
L'esempio seguente mostra i dati passati a una delle chiamate di [`ProcessSingleItem`](#itembatcher-single-item-process-config-resource)funzione all'interno di un'esecuzione di workflow secondario.
```
{
"MyMultiplicationFactor": 7,
"MyItem": 1
}
```
Dato questo input, l'esempio seguente mostra l'output restituito dalla funzione Lambda.
```
{
"statusCode": 200,
"multiplied": 7
}
```
L'esempio seguente mostra l'array JSON di output per una delle esecuzioni secondarie del flusso di lavoro.
```
[
{
"statusCode": 200,
"multiplied": 7
},
{
"statusCode": 200,
"multiplied": 14
},
{
"statusCode": 200,
"multiplied": 21
}
]
```
La macchina a stati restituisce il seguente output che contiene quattro array per le quattro esecuzioni dei flussi di lavoro secondari. Questi array contengono i risultati della moltiplicazione dei singoli elementi di input.
Infine, l'output della macchina a stati è un array denominato `multiplied` che combina tutti i risultati di moltiplicazione restituiti per le quattro esecuzioni dei flussi di lavoro secondari.
```
[
[
{
"statusCode": 200,
"multiplied": 7
},
{
"statusCode": 200,
"multiplied": 14
},
{
"statusCode": 200,
"multiplied": 21
}
],
[
{
"statusCode": 200,
"multiplied": 28
},
{
"statusCode": 200,
"multiplied": 35
},
{
"statusCode": 200,
"multiplied": 42
}
],
[
{
"statusCode": 200,
"multiplied": 49
},
{
"statusCode": 200,
"multiplied": 56
},
{
"statusCode": 200,
"multiplied": 63
}
],
[
{
"statusCode": 200,
"multiplied": 70
}
]
]
```
Per combinare tutti i risultati di moltiplicazione restituiti dalle esecuzioni dei flussi di lavoro secondari in un unico array di output, puoi utilizzare il campo. [ResultSelector](input-output-inputpath-params.md#input-output-resultselector) Definite questo campo all'interno dello *stato della Mappa distribuita* per trovare tutti i risultati, estrarre i singoli risultati e quindi combinarli in un unico array di output denominato. `multiplied`
Per utilizzare il `ResultSelector` campo, aggiorna la definizione della macchina a stati come mostrato nell'esempio seguente.
```
{
"StartAt": "Pass",
"States": {
...
...
"Map": {
"Type": "Map",
...
...
"ItemBatcher": {
"MaxItemsPerBatch": 3,
"BatchInput": {
"MyMultiplicationFactor.$": "$.MyMultiplicationFactor"
}
},
"ItemsPath": "$.MyItems",
"ResultSelector": {
"multiplied.$": "$..multiplied"
}
}
}
}
```
La macchina a stati aggiornata restituisce un array di output consolidato come mostrato nell'esempio seguente.
```
{
"multiplied": [7, 14, 21, 28, 35, 42, 49, 56, 63, 70]
}
```