Passaggio 1: creare la macchina a stati Passaggio 2: crea la funzione Lambda Fase 3: Esegui la macchina di stato

Elaborazione di singoli elementi con una funzione Lambda in Step Functions

In questo tutorial, si utilizza il ItemBatcher (Mappa) 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 del flusso di lavoro secondario. Ciascuno di questi flussi di lavoro secondari esegue uno stato Inline Map. 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 un array di numeri interi. Supponiamo che l'array di numeri interi che fornisci come input sia [1, 2, 3, 4, 5, 6, 7, 8, 9, 10] e 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]

Passaggio 1: creare la macchina a stati

In questo passaggio, crei il prototipo del flusso di lavoro della macchina a stati che passa un singolo elemento da un batch di elementi a ogni chiamata della funzione Lambda che creerai nel passaggio 2. Passaggio 2: crea la funzione Lambda

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, consulta Fase 1: Creare il prototipo del flusso di lavoro il tutorial Guida introduttiva all'uso di Distributed Map state.

In questa macchina a stati, si definisce uno stato di mappa distribuita che accetta un array di 10 numeri interi come input e passa questi elementi dell'array alle esecuzioni del flusso di lavoro secondario in batch. Ogni esecuzione del flusso di lavoro figlio 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 moltiplica quindi l'elemento con un fattore di 7 e restituisce il risultato.

L'output di ogni esecuzione del flusso di lavoro figlio è 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 nel passaggio 2. Passaggio 2: crea la funzione Lambda


{
  "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"
        }
      }
    }
  }
}

Passaggio 2: crea la funzione Lambda

In questo passaggio, crei la funzione Lambda che elabora ogni elemento passato dal batch.

Importante

Assicurati che la tua funzione Lambda sia identica a quella della tua Regione AWS macchina a stati.

Creazione della funzione Lambda

Usa la console Lambda per creare una funzione Python Lambda denominata. ProcessSingleItem Per informazioni sulla creazione di una funzione Lambda, consulta la Fase 4: Configurazione della funzione Lambda nel tutorial Getting started with using Distributed Map state.

Copia il codice seguente per la funzione Lambda e incollalo nella sezione Code source 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
    }

Dopo aver creato la funzione Lambda, copia l'ARN della funzione visualizzato. Quello che segue è 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 1.
Scegli Deploy per distribuire le modifiche.

Fase 3: Esegui la macchina di stato

Quando si esegue la macchina a stati, lo stato Distributed Map avvia quattro esecuzioni del flusso di lavoro secondario, 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 funzione all'interno dell'esecuzione di un flusso di lavoro 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 del flusso di lavoro secondario.


[
  {
    "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 del flusso di lavoro secondario. 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 del flusso di lavoro secondario.


[
  [
    {
      "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 della moltiplicazione restituiti dalle esecuzioni del flusso di lavoro secondario in un unico array di output, è possibile utilizzare il campo. ResultSelector Definisci questo campo all'interno dello stato Distributed Map 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]
}

Avvertimento JavaScript è disabilitato o non è disponibile nel tuo browser.

Per usare la documentazione AWS, JavaScript deve essere abilitato. Consulta le pagine della guida del browser per le istruzioni.

Convenzioni dei documenti

Elabora i dati batch con Lambda

Avvia un flusso di lavoro da EventBridge