Tutorial: Esame delle esecuzioni delle macchine a stati in Step Functions - AWS Step Functions
Fase 1: Creare e testare le funzioni Lambda richiesteFase 2: Creare ed eseguire la macchina a statiFase 3: Visualizzare i dettagli di esecuzione della macchina a statiPassaggio 4: Esplora le diverse modalità di visualizzazione

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à.

Tutorial: Esame delle esecuzioni delle macchine a stati in Step Functions

In questo tutorial, imparerai come controllare le informazioni sull'esecuzione visualizzate nella pagina Dettagli di esecuzione e visualizzare il motivo di un'esecuzione non riuscita. Quindi, imparerai come accedere a diverse iterazioni di un'esecuzione di Map stato. Infine, imparerai come configurare le colonne nella vista Tabella e applicare filtri adeguati per visualizzare solo le informazioni di tuo interesse.

In questo tutorial, creerai una macchina a stati di tipo Standard, che ottiene il prezzo di un set di frutta. Per fare ciò, la macchina a stati utilizza tre AWS Lambda funzioni che restituiscono un elenco casuale di quattro frutti, il prezzo di ogni frutto e il costo medio dei frutti. Le funzioni Lambda sono progettate per generare un errore se il prezzo dei frutti è inferiore o uguale a un valore di soglia.

Nota

Sebbene la procedura seguente contenga istruzioni su come esaminare i dettagli dell'esecuzione di un flusso di lavoro Standard, è possibile esaminare anche i dettagli per le esecuzioni del flusso di lavoro Express. Per informazioni sulle differenze tra i dettagli di esecuzione per i tipi di flusso di lavoro Standard ed Express, vedereVisualizzazione dei dettagli sull'esecuzione del flusso di lavoro in Step Functions.

Fase 1: Creare e testare le funzioni Lambda richieste

  1. Apri la console Lambda ed esegui i passaggi da 1 a 4 della Fase 1: Creazione di una funzione Lambda sezione. Assicurati di assegnare un nome alla funzione Lambda. GetListOfFruits

  2. Dopo aver creato la funzione Lambda, copia l'Amazon Resource Name (ARN) della funzione visualizzato nell'angolo in alto a destra della pagina. Per copiareARN, fai clic sull'icona di copia per copiare l'Amazon Resource Name della funzione Lambda. Di seguito è riportato un esempioARN, in cui nome della funzione è il nome della funzione Lambda (in questo caso,GetListOfFruits):

    arn:aws:lambda:us-east-1:123456789012:function:function-name

  3. Copia il codice seguente per la funzione Lambda nell'area Codice sorgente della GetListOfFruitspagina.

    function getRandomSubarray(arr, size) {
    var shuffled = arr.slice(0), i = arr.length, temp, index;
    while (i--) {
        index = Math.floor((i + 1) * Math.random());
        temp = shuffled[index];
        shuffled[index] = shuffled[i];
        shuffled[i] = temp;
    }
    return shuffled.slice(0, size);
}

exports.handler = async function(event, context) {
    
    const fruits = ['Abiu','Açaí','Acerola','Ackee','African cucumber','Apple','Apricot','Avocado','Banana','Bilberry','Blackberry','Blackcurrant','Jostaberry'];

    
     const errorChance = 45;
    
    const waitTime = Math.floor( 100 * Math.random() );

    await new Promise( r => setTimeout(() => r(), waitTime));

    const num = Math.floor( 100 * Math.random() );
    // const num = 51;
     if (num <= errorChance) {
         throw(new Error('Error'));
     }

    return getRandomSubarray(fruits, 4);
};

  4. Scegli Deploy, quindi scegli Test, per distribuire le modifiche e vedere l'output della tua funzione Lambda.

  5. Crea due funzioni Lambda aggiuntive, denominate GetFruitPrice e CalculateAverage rispettivamente, con i seguenti passaggi:

    1. Copia il codice seguente nell'area Codice sorgente della funzione GetFruitPriceLambda:

      exports.handler = async function(event, context) {
    
    const errorChance = 0;
    const waitTime = Math.floor( 100 * Math.random() );

    await new Promise( r => setTimeout(() => r(), waitTime));

    const num = Math.floor( 100 * Math.random() );
    if (num <= errorChance) {
        throw(new Error('Error'));
    }

    return Math.floor(Math.random()*100)/10;
};

    2. Copia il codice seguente nell'area Codice sorgente della funzione CalculateAverageLambda:

      function getRandomSubarray(arr, size) {
    var shuffled = arr.slice(0), i = arr.length, temp, index;
    while (i--) {
        index = Math.floor((i + 1) * Math.random());
        temp = shuffled[index];
        shuffled[index] = shuffled[i];
        shuffled[i] = temp;
    }
    return shuffled.slice(0, size);
}

const average = arr => arr.reduce( ( p, c ) => p + c, 0 ) / arr.length;
    
exports.handler = async function(event, context) {
        const errors = [
        "Error getting data from DynamoDB",
        "Error connecting to DynamoDB",
        "Network error",
        "MemoryError - Low memory"
        ]
        
    const errorChance = 0;
    
    const waitTime = Math.floor( 100 * Math.random() );

    await new Promise( r => setTimeout(() => r(), waitTime));

    const num = Math.floor( 100 * Math.random() );
    if (num <= errorChance) {
        throw(new Error(getRandomSubarray(errors, 1)[0]));
    }

    return average(event);
};

    3. Assicurati ARNs di copiare queste due funzioni Lambda, quindi distribuiscile e testale.

Fase 2: Creare ed eseguire la macchina a stati

Usa la console Step Functions per creare una macchina a stati che richiami le funzioni Lambda che hai creato nello Step 1. In questa macchina a stati, sono definiti tre Map stati. Ciascuno di questi Map stati contiene uno Task stato che richiama una delle tue funzioni Lambda. Inoltre, viene definito un Retry campo in ogni Task stato con un numero di tentativi di nuovo tentativo definiti per ogni stato. Se uno Task stato rileva un errore di runtime, viene eseguito nuovamente fino al numero di tentativi di nuovo tentativo definito per quello stato. Task

  1. Apri la console Step Functions e scegli Scrivi il tuo flusso di lavoro nel codice.

    Importante

    Assicurati che la tua macchina a stati utilizzi lo stesso AWS account e la stessa regione della funzione Lambda che hai creato in precedenza.

  2. Per Tipo, mantieni la selezione predefinita di Standard.

  3. Copia la seguente definizione di Amazon States Language e incollala in Definition. Assicurati di sostituire le funzioni ARNs mostrate con quelle delle funzioni Lambda che hai creato in precedenza.

    {
    "StartAt": "LoopOverStores",
    "States": {
        "LoopOverStores": {
            "Type": "Map",
            "Iterator": {
                "StartAt": "GetListOfFruits",
                "States": {
                    "GetListOfFruits": {
                        "Type": "Task",
                        "Resource": "arn:aws:states:::lambda:invoke",
                        "OutputPath": "$.Payload",
                        "Parameters": {
                            "FunctionName": "arn:aws:lambda:us-east-1:123456789012:function:GetListofFruits:$LATEST",
                            "Payload": {
                                "storeName.$": "$"
                            }
                        },
                        "Retry": [
                            {
                                "ErrorEquals": [
                                    "States.ALL"
                                ],
                                "IntervalSeconds": 2,
                                "MaxAttempts": 1,
                                "BackoffRate": 1.3
                            }
                        ],
                        "Next": "LoopOverFruits"
                    },
                    "LoopOverFruits": {
                        "Type": "Map",
                        "Iterator": {
                            "StartAt": "GetFruitPrice",
                            "States": {
                                "GetFruitPrice": {
                                    "Type": "Task",
                                    "Resource": "arn:aws:states:::lambda:invoke",
                                    "OutputPath": "$.Payload",
                                    "Parameters": {
                                        "FunctionName": "arn:aws:lambda:us-east-1:123456789012:function:GetFruitPrice:$LATEST",
                                        "Payload": {
                                            "fruitName.$": "$"
                                        }
                                    },
                                    "Retry": [
                                        {
                                            "ErrorEquals": [
                                                "States.ALL"
                                            ],
                                            "IntervalSeconds": 2,
                                            "MaxAttempts": 3,
                                            "BackoffRate": 1.3
                                        }
                                    ],
                                    "End": true
                                }
                            }
                        },
                        "ItemsPath": "$",
                        "End": true
                    }
                }
            },
            "ItemsPath": "$.stores",
            "Next": "LoopOverStoreFruitsPrice",
            "ResultPath": "$.storesFruitsPrice"
        },
        "LoopOverStoreFruitsPrice": {
            "Type": "Map",
            "End": true,
            "Iterator": {
                "StartAt": "CalculateAverage",
                "States": {
                    "CalculateAverage": {
                        "Type": "Task",
                        "Resource": "arn:aws:states:::lambda:invoke",
                        "OutputPath": "$.Payload",
                        "Parameters": {
                            "FunctionName": "arn:aws:lambda:us-east-1:123456789012:function:Calculate-average:$LATEST",
                            "Payload.$": "$"
                        },
                        "Retry": [
                            {
                                "ErrorEquals": [
                                    "States.ALL"
                                ],
                                "IntervalSeconds": 2,
                                "MaxAttempts": 2,
                                "BackoffRate": 1.3
                            }
                        ],
                        "End": true
                    }
                }
            },
            "ItemsPath": "$.storesFruitsPrice",
            "ResultPath": "$.storesPriceAverage",
            "MaxConcurrency": 1
        }
    }
}

  4. Inserisci un nome per la tua macchina a stati. Mantieni le selezioni predefinite per le altre opzioni in questa pagina e scegli Crea macchina a stati.

  5. Apri la pagina intitolata con il nome della tua macchina a stati. Eseguite i passaggi da 1 a 4 della Passaggio 4: Esegui la macchina a stati sezione, ma utilizzate i seguenti dati come input per l'esecuzione:

    {
    "stores": [
      "Store A",
      "Store B",
      "Store C",
      "Store D"
    ]
}

Fase 3: Visualizzare i dettagli di esecuzione della macchina a stati

Nella pagina denominata con il tuo ID di esecuzione, puoi esaminare i risultati dell'esecuzione ed eseguire il debug di eventuali errori.

  1. (Facoltativo) Scegliete tra le schede visualizzate nella pagina Dettagli di esecuzione per visualizzare le informazioni presenti in ciascuna di esse. Ad esempio, per visualizzare l'input della macchina a stati e il relativo output di esecuzione, scegliete Input e output di esecuzione nella sezione Riepilogo dell'esecuzione.

  2. Se l'esecuzione della macchina a stati non è riuscita, scegli Causa o Mostra i dettagli del passaggio nel messaggio di errore. I dettagli sull'errore sono visualizzati nella sezione Dettagli del passaggio. Notate che il passaggio che ha causato l'errore, ovvero uno Task stato denominato GetListofFruits, è evidenziato nella vista Grafico e nella vista Tabella.

    Nota

    Poiché il GetListofFruitspassaggio è definito all'interno di uno Map stato e l'esecuzione non è riuscita, il passaggio MapStato dello stato viene visualizzato come Non riuscito.

Passaggio 4: Esplora le diverse modalità di visualizzazione

È possibile scegliere una modalità preferita per visualizzare il flusso di lavoro della macchina a stati o la cronologia degli eventi di esecuzione. Alcune delle attività che è possibile eseguire in queste modalità di visualizzazione sono le seguenti:

Se lo stato della mappa ha cinque iterazioni e desideri visualizzare i dettagli di esecuzione per la terza e la quarta iterazione, procedi come segue:

  1. Scegli lo Map stato per cui desideri visualizzare i dati di iterazione.

  2. Dal Map Iteration Viewer, scegli l'iterazione che desideri visualizzare. Le iterazioni vengono contate da zero. Per scegliere la terza iterazione su cinque, scegli #2 dall'elenco a discesa accanto al nome dello stato della mappa.

    Nota

    Se la macchina a stati contiene Map stati nidificati, Step Functions visualizza le iterazioni Map dello stato principale e figlio come due elenchi a discesa separati che rappresentano i dati di iterazione per gli stati nidificati.

  3. (Facoltativo) Se una o più iterazioni di Map stato non sono state eseguite o sono state interrotte in uno stato interrotto, è possibile visualizzare i dettagli sull'iterazione non riuscita. Per visualizzare questi dettagli, scegli i numeri di iterazione interessati in Non riuscito o Interrotto nell'elenco a discesa.

Se lo stato della mappa ha cinque iterazioni e desideri visualizzare i dettagli di esecuzione per l'iterazione numero tre e quattro, procedi come segue:

  1. Scegli lo Map stato per il quale desideri visualizzare i diversi dati di iterazione.

  2. Nella visualizzazione ad albero delle iterazioni di Map stato, scegliete la riga per l'iterazione denominata #2 per l'iterazione numero tre. Allo stesso modo, scegli la riga denominata #3 per l'iterazione numero quattro.

Scegli l'icona delle impostazioni. Quindi, nella finestra di dialogo Preferenze, scegli le colonne che desideri visualizzare in Seleziona colonne visibili.

Per impostazione predefinita, questa modalità visualizza le colonne Nome, Tipo, Stato, Risorsa e Started After.

Limita la quantità di informazioni visualizzate applicando uno o più filtri in base a una proprietà, ad esempio Status, o a un intervallo di data e ora. Ad esempio, per visualizzare i passaggi che hanno avuto esito negativo nell'esecuzione, applica il seguente filtro:

  1. Scegli Filtra per proprietà o cerca per parola chiave, quindi scegli Stato in Proprietà.

  2. In Operatori, scegli Status =.

  3. Scegliete Status = Failed.

  4. (Facoltativo) Scegliete Cancella filtri per rimuovere i filtri applicati.

Limita la quantità di informazioni visualizzate applicando uno o più filtri in base a una proprietà, ad esempio Type, o a un intervallo di data e ora. Ad esempio, per visualizzare i passaggi di Task stato che hanno avuto esito negativo nell'esecuzione, applica il seguente filtro:

  1. Scegliete Filtra per proprietà o Cerca per parola chiave, quindi scegliete Tipo in Proprietà.

  2. In Operatori, scegli Tipo =.

  3. Scegliete Tipo = TaskFailed.

  4. (Facoltativo) Scegliete Cancella filtri per rimuovere i filtri applicati.

Scegliete l'icona a forma di freccia accanto all'ID di un TaskFailedevento per esaminarne i dettagli, inclusi input, output e richiamo delle risorse visualizzati in una casella a discesa.