View a markdown version of this page

Esame delle esecuzioni di macchine a stati in Step Functions - AWS Step Functions
Fase 1: Creare e testare le funzioni Lambda richiestePassaggio 2: crea ed esegui la macchina a statiPassaggio 3: visualizza i dettagli di esecuzione della macchina a statiFase 4: Esplorate 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à.

Esame delle esecuzioni di 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 ciascun 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, puoi anche esaminare i dettagli per le esecuzioni di un flusso di lavoro Express. Per informazioni sulle differenze tra i dettagli di esecuzione per i tipi di workflow Standard ed Express, vedereDifferenze di esperienza tra console Standard ed Express.

Fase 1: Creare e testare le funzioni Lambda richieste

  1. Apri la console Lambda e quindi esegui i passaggi da 1 a 4 nella Fase 1: creare 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. Per copiare l'ARN, scegli l'icona di copia per copiare il nome Amazon Resource Name della funzione Lambda. Quello che segue è un esempio di ARN, dove function-name è il nome della funzione Lambda (in questo caso,): GetListOfFruits

    arn:aws:lambda:region:123456789012:function:function-name

  3. Copia il codice seguente per la funzione Lambda nell'area Code source della pagina. GetListOfFruits 

    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 implementare 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 Code source della funzione GetFruitPrice Lambda:

      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 Code source della funzione CalculateAverage Lambda:

      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 di copiare gli ARN di queste due funzioni Lambda, quindi di distribuirle e testarle.

Passaggio 2: crea ed esegui la macchina a stati

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

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

    Importante

    Assicurati che la tua macchina statale si trovi nello stesso AWS account e nella 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 Definizione. Assicurati di sostituire gli ARN mostrati con quelli 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:region: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:region: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:region: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. Esegui i passaggi da 1 a 4 nella Fase 4: Esegui la macchina di stato sezione, ma usa i seguenti dati come input di esecuzione:

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

Passaggio 3: visualizza i dettagli di esecuzione della macchina a stati

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

  1. (Facoltativo) Scegli 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, scegli Input e output dell'esecuzione nella sezione di riepilogo dell'esecuzione.

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

    Nota

    Poiché il GetListofFruits passaggio è definito all'interno di uno Map stato e non è stato eseguito correttamente, il passaggio Map Stato dello stato viene visualizzato come Non riuscito.

Fase 4: Esplorate 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 a partire 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, puoi visualizzare i dettagli sull'iterazione non riuscita. Per visualizzare questi dettagli, scegli i numeri delle iterazioni interessate in Fallita o Interrotta 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. Analogamente, scegliete la riga denominata #3 per l'iterazione numero quattro.

Scegli l'icona delle impostazioni. Quindi, nella finestra di dialogo Preferenze, scegliete le colonne da 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 la cui esecuzione non è riuscita, 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 = Fallito.

  4. (Facoltativo) Scegli 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 Tipo, o a un intervallo di data e ora. Ad esempio, per visualizzare i passaggi relativi allo Task stato in cui l'esecuzione non è riuscita, applica il seguente filtro:

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

  2. In Operatori, scegli Tipo =.

  3. Scegliete Tipo = TaskFailed.

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

Scegli l'icona a forma di freccia accanto all'ID di un TaskFailed evento per controllarne i dettagli, inclusi input, output e richiamo delle risorse che appaiono in una casella a discesa.