Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich.

# Untersuchen von State-Machine-Ausführungen in Step Functions
<a name="debug-sm-exec-using-ui"></a>

In diesem Tutorial erfahren Sie, wie Sie die auf der Seite mit den *Ausführungsdetails angezeigten Ausführungsinformationen* überprüfen und den Grund für eine fehlgeschlagene Ausführung ermitteln können. Anschließend erfahren Sie, wie Sie auf verschiedene Iterationen einer `Map` Statusausführung zugreifen können. Schließlich erfahren Sie, wie Sie die Spalten in der **Tabellenansicht** konfigurieren und geeignete Filter anwenden, um nur die Informationen anzuzeigen, die für Sie von Interesse sind.

In diesem Tutorial erstellen Sie eine Zustandsmaschine vom Typ Standard, die den Preis für eine Reihe von Früchten ermittelt. Zu diesem Zweck verwendet die Zustandsmaschine drei AWS Lambda Funktionen, die eine zufällige Liste von vier Früchten, den Preis jeder Frucht und die durchschnittlichen Kosten der Früchte zurückgeben. Die Lambda-Funktionen sind so konzipiert, dass sie einen Fehler auslösen, wenn der Preis der Früchte unter oder gleich einem Schwellenwert liegt.

**Anmerkung**  
Das folgende Verfahren enthält zwar Anweisungen zur Untersuchung der Details einer Standard-Workflow-Ausführung, Sie können jedoch auch die Details von Express-Workflow-Ausführungen untersuchen. Informationen zu den Unterschieden zwischen den Ausführungsdetails für Standard- und Express-Workflowtypen finden Sie unter[Bei Standard- und Express-Konsolen gibt es Unterschiede](concepts-view-execution-details.md#console-exp-differences).

## Schritt 1: Die erforderlichen Lambda-Funktionen erstellen und testen
<a name="step-create-all-lambda-functions"></a>

1. Öffnen Sie die [Lambda-Konsole](https://console.aws.amazon.com/lambda/home) und führen Sie dann die Schritte 1 bis 4 im [Schritt 1: Erstellen einer Lambda-Funktion](tutorial-creating-lambda-state-machine.md#create-lambda-function) Abschnitt aus. Achten Sie darauf, die Lambda-Funktion **GetListOfFruits** zu benennen.

1. Nachdem Sie Ihre Lambda-Funktion erstellt haben, kopieren Sie den Amazon-Ressourcennamen (ARN) der Funktion, der in der oberen rechten Ecke der Seite angezeigt wird. Um den ARN zu kopieren, klicken Sie auf das Kopiersymbol, um den Amazon-Ressourcennamen der Lambda-Funktion zu kopieren. Im Folgenden finden Sie ein Beispiel für einen ARN, wobei der Name der Lambda-Funktion *`function-name`* steht (in diesem Fall`GetListOfFruits`):

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

1. Kopieren Sie den folgenden Code für die Lambda-Funktion in den **Codequellenbereich** der **GetListOfFruits**Seite.

   ```
   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);
   };
   ```

1. Wählen Sie **Deploy** und dann **Test**, um die Änderungen bereitzustellen und die Ausgabe Ihrer Lambda-Funktion zu sehen.

1. Erstellen Sie mit den folgenden Schritten zwei zusätzliche Lambda-Funktionen, benannt **GetFruitPrice** **CalculateAverage** bzw. benannt:

   1. Kopieren Sie den folgenden Code in den **Codequellbereich** der **GetFruitPrice**Lambda-Funktion:

      ```
      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;
      };
      ```

   1. Kopieren Sie den folgenden Code in den **Codequellbereich** der **CalculateAverage**Lambda-Funktion:

      ```
      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);
      };
      ```

   1. Stellen Sie sicher, dass Sie ARNs die beiden Lambda-Funktionen kopieren und sie dann **bereitstellen** und **testen**.

## Schritt 2: Erstellen Sie die Zustandsmaschine und führen Sie sie aus
<a name="step-create-exec-sm"></a>

Verwenden Sie die [Step Functions Functions-Konsole](https://console.aws.amazon.com/states/home?region=us-east-1#/), um eine Zustandsmaschine zu erstellen, die die [in Schritt 1 erstellten Lambda-Funktionen](#step-create-all-lambda-functions) aufruft. In dieser Zustandsmaschine sind drei `Map` Zustände definiert. Jeder dieser `Map` Zustände enthält einen `Task` Zustand, der eine Ihrer Lambda-Funktionen aufruft. Darüber hinaus ist in jedem `Task` Status ein `Retry` Feld mit einer Anzahl von Wiederholungsversuchen für jeden Status definiert. Wenn in einem `Task` Status ein Laufzeitfehler auftritt, wird er erneut ausgeführt, bis die Anzahl der für diesen Status definierten Wiederholungsversuche erreicht ist. `Task`

1. Öffnen Sie die [Step Functions Functions-Konsole](https://console.aws.amazon.com/states/home) und wählen **Sie Write your workflow in code**.
**Wichtig**  
Stellen Sie sicher, dass sich Ihr State Machine unter demselben AWS Konto und derselben Region befindet wie die zuvor erstellte Lambda-Funktion.

1. Behalten Sie für **Typ** die Standardauswahl **Standard** bei.

1. Kopieren Sie die folgende Amazon States-Sprachdefinition und fügen Sie sie unter **Definition** ein. Stellen Sie sicher, dass Sie die ARNs angezeigten durch die Lambda-Funktionen ersetzen, die Sie zuvor erstellt haben.

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

1. Geben Sie einen Namen für Ihre Zustandsmaschine ein. Behalten Sie die Standardauswahl für die anderen Optionen auf dieser Seite bei und wählen Sie **Create State Machine**.

1. Öffnen Sie die Seite mit dem Namen Ihres Zustandsmaschinen. Führen Sie die Schritte 1 bis 4 in [Schritt 4: Führen Sie die Zustandsmaschine aus](tutorial-creating-lambda-state-machine.md#start-lambda-function) diesem Abschnitt aus, verwenden Sie jedoch die folgenden Daten als Ausführungseingabe:

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

## Schritt 3: Details zur State-Machine-Ausführung anzeigen
<a name="view-sm-exec-details"></a>

Auf der Seite mit Ihrer Ausführungs-ID können Sie die Ergebnisse Ihrer Ausführung überprüfen und etwaige Fehler debuggen.

1. (Optional) Wählen Sie eine der Registerkarten, die auf der Seite mit den *Ausführungsdetails* angezeigt werden, um die Informationen zu sehen, die in den einzelnen Registerkarten enthalten sind. Um beispielsweise die State-Machine-Eingabe und deren Ausführungsausgabe anzuzeigen, wählen Sie im Abschnitt „**Ausführungsübersicht“ die Option „Eingabe und Ausgabe** *[der Ausführung](concepts-view-execution-details.md#exec-details-intf-exec-summ)*“.

1. Wenn Ihre State-Machine-Ausführung fehlgeschlagen ist, wählen Sie in der Fehlermeldung „**Ursache**“ oder „**Schrittdetails anzeigen**“. Details zum Fehler werden im Abschnitt *[Schrittdetails](concepts-view-execution-details.md#exec-details-intf-step-details)* angezeigt. Beachten Sie, dass der Schritt, der den Fehler verursacht hat, ein `Task` Status mit dem Namen **GetListofFruits**, in der **Diagrammansicht** und der **Tabellenansicht** hervorgehoben ist.
**Anmerkung**  
Da der **GetListofFruits**Schritt innerhalb eines `Map` Zustands definiert ist und der Schritt nicht erfolgreich ausgeführt werden konnte, wird der Schritt **Status** des `Map` Zustands als **Fehlgeschlagen** angezeigt.

## Schritt 4: Erkunden Sie die verschiedenen *Anzeigemodi*
<a name="sm-exec-details-exp-view-modes"></a>

Sie können einen bevorzugten Modus wählen, um entweder den State-Machine-Workflow oder den Verlauf der Ausführungsereignisse anzuzeigen. In diesen *Anzeigemodi* können Sie unter anderem folgende Aufgaben ausführen:

### **Diagrammansicht** — Wechseln Sie zwischen verschiedenen `Map` Statusiterationen
<a name="graph-view-see-map-state-iterations"></a>

Wenn Ihr **Map-Status** fünf Iterationen umfasst und Sie die Ausführungsdetails für die dritte und vierte Iteration anzeigen möchten, gehen Sie wie folgt vor:

1. Wählen Sie den `Map` Status aus, für den Sie die Iterationsdaten anzeigen möchten.

1. Wählen Sie im **Map Iteration Viewer** die Iteration aus, die Sie anzeigen möchten. Iterationen werden von Null an gezählt. Um die dritte von fünf Iterationen auszuwählen, wählen Sie **\$12** aus der Dropdownliste neben dem Namen des **Kartenstatus** aus.
**Anmerkung**  
Wenn Ihre Zustandsmaschine verschachtelte `Map` Zustände enthält, zeigt Step Functions die Iterationen des übergeordneten und untergeordneten `Map` Status als zwei separate Dropdownlisten an, die die Iterationsdaten für die verschachtelten Zustände darstellen.

1. (Optional) Wenn eine oder mehrere Ihrer `Map` State-Iterationen nicht ausgeführt werden konnten oder in einem abgebrochenen Zustand gestoppt wurden, können Sie sich Details zu der fehlgeschlagenen Iteration anzeigen lassen. Um diese Details zu sehen, wählen Sie in der Dropdownliste unter **Fehlgeschlagen** oder **Abgebrochen** die betroffenen Iterationsnummern aus.

### **Tabellenansicht** — Wechseln Sie zwischen verschiedenen Statusiterationen `Map`
<a name="table-view-see-map-state-iterations"></a>

Wenn Ihr **Map-Status** fünf Iterationen umfasst und Sie die Ausführungsdetails für die Iterationen Nummer drei und vier anzeigen möchten, gehen Sie wie folgt vor:

1. Wählen Sie den `Map` Status aus, für den Sie die verschiedenen Iterationsdaten anzeigen möchten.

1. Wählen Sie in der Strukturansicht der `Map` Status-Iterationen die Zeile für die Iteration mit dem Namen **\$12** für Iteration Nummer drei aus. Wählen Sie auf ähnliche Weise die Zeile mit dem Namen **\$13** für Iteration Nummer vier aus.

### **Tabellenansicht** — Konfigurieren Sie die anzuzeigenden Spalten
<a name="table-view-cfg-display-cols"></a>

Wählen Sie das Einstellungssymbol. Wählen Sie dann im Dialogfeld „**Einstellungen**“ unter **Sichtbare Spalten auswählen die Spalten aus**, die Sie anzeigen möchten.

In diesem Modus werden standardmäßig die Spalten „**Name**“, „**Typ**“, **„Status“, „****Ressource**“ und „**Gestartet nach**“ angezeigt.

### **Tabellenansicht** — Filtert die Ergebnisse
<a name="table-view-filter-results"></a>

Beschränken Sie die Menge der angezeigten Informationen, indem Sie einen oder mehrere Filter anwenden, die auf einer Eigenschaft wie **Status** oder einem Datums- und Zeitbereich basieren. Um beispielsweise die Schritte anzuzeigen, bei denen die Ausführung fehlgeschlagen ist, wenden Sie den folgenden Filter an:

1. Wählen Sie **Nach Eigenschaften filtern oder nach Schlüsselwörtern suchen** und wählen Sie dann unter **Eigenschaften** die Option **Status** aus.

1. Wählen Sie unter **Operatoren** die Option **Status =** aus.

1. Wählen Sie **Status = Fehlgeschlagen**.

1. (Optional) Wählen Sie **Filter löschen**, um die angewendeten Filter zu entfernen.

### **Ereignisansicht** — Filtert die Ergebnisse
<a name="event-view-filter-results"></a>

Beschränken Sie die Menge der angezeigten Informationen, indem Sie einen oder mehrere Filter anwenden, die auf einer Eigenschaft wie **Typ** oder einem Datums- und Zeitbereich basieren. Um beispielsweise die `Task` Statusschritte anzuzeigen, bei denen die Ausführung fehlgeschlagen ist, wenden Sie den folgenden Filter an:

1. Wählen Sie **Nach Eigenschaften filtern oder Nach Schlüsselwörtern suchen** und wählen Sie dann unter **Eigenschaften** die Option **Typ** aus.

1. Wählen Sie unter **Operatoren** die Option **Type =** aus.

1. Wählen Sie **Typ = TaskFailed**.

1. (Optional) Wählen Sie **Filter löschen**, um die angewendeten Filter zu entfernen.

### **Ereignisansicht** — Untersuchen Sie ein **TaskFailed**Ereignisdetail
<a name="event-view-inspect-failed-task-details"></a>

Wählen Sie das Pfeilsymbol neben der ID eines **TaskFailed**Ereignisses, um dessen Details zu überprüfen, einschließlich Eingabe, Ausgabe und Ressourcenaufruf, die in einem Dropdown-Feld angezeigt werden.