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.

Umgang mit Fehlern in Step Functions Functions-Workflows

In allen Zuständen, mit Ausnahme Pass Wait von Staaten, kann es zu Laufzeitfehlern kommen. Fehler können aus verschiedenen Gründen auftreten, unter anderem aus den folgenden:

Wenn ein Status einen Fehler meldet, schlägt Step Functions standardmäßig die gesamte State-Machine-Ausführung fehl. Step Functions bietet auch erweiterte Funktionen zur Fehlerbehandlung. Sie können Ihre Zustandsmaschine so einrichten, dass sie Fehler abfängt, fehlgeschlagene Zustände wiederholt und Fehlerbehandlungsprotokolle ordnungsgemäß implementiert.

Step Functions Functions-Catcher sind für den Status Task, Parallel und Map verfügbar, jedoch nicht für Fehler bei der Ausführung von Zustandsmaschinen auf oberster Ebene. Um Ausführungen zu verarbeiten, von denen Sie erwarten, dass sie fehlschlagen könnten, kann Ihr Aufrufer den Fehler behandeln, oder Sie können diese Ausführungen in untergeordneten Workflows verschachteln, um Fehler in Ihrem übergeordneten Workflow abzufangen. Alternativ können Sie sich dafür entscheiden, TIMED_OUT Ereignisse aus Standard-Workflows mit einem EventBridge Bus abzuhören und eine Aktion zur Behandlung der fehlgeschlagenen Ausführung aufzurufen.

Namen der Fehler

Step Functions identifiziert Fehler mithilfe von Zeichenketten, bei denen Groß- und Kleinschreibung beachtet wird, die als Fehlernamen bezeichnet werden. Die Amazon States Language definiert eine Reihe von integrierten Zeichenketten, die bekannte Fehler benennen, die alle mit dem States. Präfix beginnen.

Zustände können Fehler mit anderen Namen melden. Die Fehlernamen dürfen jedoch nicht mit dem States. Präfix beginnen.

Stellen Sie sicher, dass Ihr Produktionscode AWS Lambda Serviceausnahmen (Lambda.ServiceExceptionundLambda.SdkClientException) verarbeiten kann. Weitere Informationen finden Sie unter Bewährte Methoden. Behandeln Sie vorübergehende Lambda-Serviceausnahmen

Erneuter Versuch nach einem Fehler

TaskParallel, und Map Staaten können ein benanntes Feld habenRetry, dessen Wert ein Array von Objekten sein muss, die als Retrier bezeichnet werden. Eine einzelner Retrier steht für eine bestimmte Anzahl von erneuten Versuchen, in der Regel in zunehmenden Zeitintervallen.

Wenn einer dieser Zustände einen Fehler meldet und es ein Retry Feld gibt, durchsucht Step Functions die Retrier in der Reihenfolge, die im Array aufgeführt ist. Wenn der Name des Fehlers im Wert eines ErrorEquals Retrier-Felds erscheint, versucht die State Machine erneut, wie im Feld definiert. Retry

Wenn Ihre redriven Ausführung einenWorkflow-Status der Aufgabe, Status des parallelen Workflows oder Inline-Map-Status wiederholt, für den Sie Wiederholungen definiert haben, wird die Anzahl der Wiederholungsversuche für diese Zustände auf 0 zurückgesetzt, um die maximale Anzahl von Versuchen zu ermöglichen. redrive Bei einer redriven Ausführung können Sie einzelne Wiederholungsversuche in diesen Zuständen mithilfe der Konsole verfolgen. Weitere Informationen finden Sie unter Verhalten von Ausführungen wiederholen redriven in State-Machine-Ausführungen mit redrive In-Step-Funktionen neu starten.

Ein Retrier enthält die folgenden Felder:

Feldbeispiele erneut versuchen

Dieser Abschnitt enthält die folgenden Retry Feldbeispiele.

Beispiel 1 — Versuchen Sie es erneut mit BackoffRate

Das folgende Beispiel für a Retry führt zwei Wiederholungsversuche durch, wobei der erste Versuch nach einer Wartezeit von drei Sekunden erfolgt. Je nachdem, was BackoffRate Sie angeben, erhöht Step Functions das Intervall zwischen den einzelnen Wiederholungsversuchen, bis die maximale Anzahl von Wiederholungsversuchen erreicht ist. Im folgenden Beispiel beginnt der zweite Wiederholungsversuch, nachdem nach dem ersten Versuch drei Sekunden gewartet wurden.

"Retry": [ {
   "ErrorEquals": [ "States.Timeout" ],
   "IntervalSeconds": 3,
   "MaxAttempts": 2,
   "BackoffRate": 1
} ]

Beispiel 2 — Versuchen Sie es erneut mit MaxDelaySeconds

Im folgenden Beispiel werden drei Wiederholungsversuche durchgeführt und die daraus resultierende Wartezeit BackoffRate auf 5 Sekunden begrenzt. Der erste Wiederholungsversuch erfolgt nach einer Wartezeit von drei Sekunden. Der zweite und dritte Wiederholungsversuch finden nach einer Wartezeit fünf Sekunden nach dem vorherigen Wiederholungsversuch statt, da die maximale Wartezeit von MaxDelaySeconds festgelegt ist.

"Retry": [ {
    "ErrorEquals": [ "States.Timeout" ],
    "IntervalSeconds": 3,
    "MaxAttempts": 3,
    "BackoffRate":2,
    "MaxDelaySeconds": 5,
    "JitterStrategy": "FULL"
} ]

Ohne MaxDelaySeconds würde der zweite Wiederholungsversuch sechs Sekunden nach dem ersten Versuch stattfinden, und der dritte Wiederholungsversuch würde 12 Sekunden nach dem zweiten Versuch stattfinden.

Beispiel 3 — Alle Fehler mit Ausnahme von States.Timeout wiederholen

Der reservierte Name States.ALL, der im Feld ErrorEquals eines Retriers angezeigt wird, ist ein Platzhalter, der mit jedem Fehlernamen übereinstimmt. Er muss allein im Array ErrorEquals erscheinen und er muss im letzten Retrier im Array Retry erscheinen. Der Name dient States.TaskFailed auch als Platzhalter und entspricht allen Fehlern mit Ausnahme von. States.Timeout

Das folgende Beispiel für ein Retry Feld wiederholt jeden Fehler mit Ausnahme von. States.Timeout

"Retry": [ {
   "ErrorEquals": [ "States.Timeout" ],
   "MaxAttempts": 0
}, {
   "ErrorEquals": [ "States.ALL" ]
} ]

Beispiel 4 — Komplexes Wiederholungsszenario

Die Parameter eines Retriers gelten für alle Besuche des Retriers im Kontext einer einzelnen Zustandsausführung.

Beachten Sie den folgenden Task-Zustand.

"X": {
   "Type": "Task",
   "Resource": "arn:aws:states:region:123456789012:task:X",
   "Next": "Y",
   "Retry": [ {
      "ErrorEquals": [ "ErrorA", "ErrorB" ],
      "IntervalSeconds": 1,
      "BackoffRate": 2.0,
      "MaxAttempts": 2
   }, {
      "ErrorEquals": [ "ErrorC" ],
      "IntervalSeconds": 5
   } ],
   "Catch": [ {
      "ErrorEquals": [ "States.ALL" ],
      "Next": "Z"
   } ]
}

Diese Aufgabe schlägt viermal hintereinander fehl und gibt die folgenden Fehlernamen aus:ErrorA, ErrorBErrorC, und. ErrorB Infolgedessen geschieht Folgendes:

Fallback-Zustände

Task, Map und Parallel Staaten können jeweils ein Catch benanntes Feld haben. Der Wert dieses Felds muss eine Reihe von Objekten sein, die als Catcher bekannt sind.

Ein Catcher enthält die folgenden Felder.

Wenn ein Status einen Fehler meldet und entweder kein Retry Feld vorhanden ist oder wenn der Fehler durch erneute Versuche nicht behoben werden kann, durchsucht Step Functions die Catcher in der Reihenfolge, die im Array aufgeführt ist. Wenn der Fehlername im Feld ErrorEquals eines Catchers erscheint, wechselt der Zustandsautomat in den Zustand, der im Feld Next genannt ist.

Der reservierte Name States.ALL, der im Feld ErrorEquals des Catchers erscheint, ist ein Platzhalter, der mit jedem Fehlernamen übereinstimmt. Er muss allein im Array ErrorEquals erscheinen und er muss im letzten Catcher im Array Catch erscheinen. Der Name dient States.TaskFailed auch als Platzhalter und entspricht allen Fehlern mit Ausnahme von. States.Timeout

Im folgenden Beispiel wechselt ein Catch-Feld in den Zustand namens RecoveryState, wenn eine Lambda-Funktion eine nicht behandelte Java-Ausnahme ausgibt. Andernfalls wechselt das Feld in den Zustand EndState.

"Catch": [ {
   "ErrorEquals": [ "java.lang.Exception" ],
   "ResultPath": "$.error-info",
   "Next": "RecoveryState"
}, {
   "ErrorEquals": [ "States.ALL" ],
   "Next": "EndState"
} ]

Fehlerausgabe

Wenn Step Functions in den in einem Fangnamen angegebenen Status übergeht, enthält das Objekt normalerweise das FeldCause. Der Wert dieses Felds ist eine für Menschen lesbare Beschreibung des Fehlers. Das Objekt ist als Fehlerausgabe bekannt.

Im vorherigen JSONPath Beispiel enthält der erste Catcher ein ResultPath Feld. Dies funktioniert ähnlich wie ein ResultPath-Feld im obersten Level eines Zustands, wodurch sich zwei Möglichkeiten ergeben:

Für den ersten Catcher im Beispiel fügt der Catcher der Eingabe also die Fehlerausgabe als Feld mit dem Namen hinzu, error-info falls es nicht bereits ein Feld mit diesem Namen in der Eingabe gibt. Dann sendet der Catcher die gesamte Eingabe anRecoveryState. Beim zweiten Catcher überschreibt die Fehlerausgabe die Eingabe und der Catcher sendet nur die Fehlerausgabe anEndState.

Wenn Sie bei JSONPath Workflows das ResultPath Feld nicht angeben, wird standardmäßig der Wert verwendet$, wodurch die gesamte Eingabe ausgewählt und überschrieben wird.

Wenn ein Status Retry sowohl als auch Catch Felder enthält, verwendet Step Functions zuerst alle geeigneten Retrier. Wenn die Wiederholungsrichtlinie den Fehler nicht beheben kann, wendet Step Functions den passenden Catcher-Übergang an.

Verursacht Payloads und Serviceintegrationen

Ein Catcher gibt eine Zeichenketten-Payload als Ausgabe zurück. Wenn Sie mit Serviceintegrationen wie Amazon Athena oder arbeiten AWS CodeBuild, möchten Sie die Cause Zeichenfolge möglicherweise in JSON konvertieren. Das folgende Beispiel für einen Pass Status mit systemeigenen Funktionen zeigt, wie eine Cause Zeichenfolge in JSON konvertiert wird.

"Handle escaped JSON with JSONtoString": {
  "Type": "Pass",
  "Parameters": {
    "Cause.$": "States.StringToJson($.Cause)"
  },
  "Next": "Pass State with Pass Processing"
},

Beispiele für Zustandsmaschinen mit Retry und Catch

Die in den folgenden Beispielen definierten Zustandsmaschinen setzen die Existenz von zwei Lambda-Funktionen voraus: eine, die immer fehlschlägt, und eine, die lange genug wartet, bis ein in der Zustandsmaschine definierter Timeout eintritt.

Dies ist eine Definition einer Lambda-Funktion von Node.js, die immer fehlschlägt und die Nachricht error zurückgibt. In den folgenden State-Machine-Beispielen wird diese Lambda-Funktion benanntFailFunction. Informationen zum Erstellen einer Lambda-Funktion finden Sie Schritt 1: Erstellen einer Lambda-Funktion im Abschnitt.

exports.handler = (event, context, callback) => {
    callback("error");
};

Dies ist eine Definition einer Lambda-Funktion von Node.js, die 10 Sekunden lang in den Ruhemodus wechselt. In den folgenden State-Machine-Beispielen wird diese Lambda-Funktion benanntsleep10.

exports.handler = (event, context, callback) => {
    setTimeout(function(){
    }, 11000);
};

Behandlung eines Fehlers mit Retry

Dieser Zustandsautomat verwendet ein Retry-Feld, das eine fehlgeschlagene Funktion erneut versucht und den Fehlernamen HandledError ausgibt. Diese Funktion wird zweimal wiederholt, wobei zwischen den Wiederholungen ein exponentieller Backoff auftritt.

{
   "Comment": "A Hello World example invoking Lambda function",
   "StartAt": "HelloWorld",
   "States": {
      "HelloWorld": {
         "Type": "Task",
         "Resource": "arn:aws:lambda:region:123456789012:function:FailFunction",
         "Retry": [ {
            "ErrorEquals": ["HandledError"],
            "IntervalSeconds": 1,
            "MaxAttempts": 2,
            "BackoffRate": 2.0
         } ],
      "End": true
      }
   }
}

Diese Variante verwendet den vordefinierten FehlercodeStates.TaskFailed, der jedem Fehler entspricht, den eine Lambda-Funktion ausgibt.

{
   "Comment": "Hello World example which invokes a AWS Lambda function",
   "StartAt": "HelloWorld",
   "States": {
      "HelloWorld": {
         "Type": "Task",
         "Resource": "arn:aws:lambda:region:123456789012:function:FailFunction",
         "Retry": [ {
            "ErrorEquals": ["States.TaskFailed"],
            "IntervalSeconds": 1,
            "MaxAttempts": 2,
            "BackoffRate": 2.0
         } ],
         "End": true
      }
   }
}

Behandlung eines Fehlers mit Catch

In diesem Beispiel wird ein Catch-Feld verwendet. Wenn eine Lambda-Funktion einen Fehler ausgibt, fängt sie den Fehler ab und die Zustandsmaschine wechselt in den fallback Status.

{
   "Comment": "Hello World example which invokes a AWS Lambda function",
   "StartAt": "HelloWorld",
   "States": {
      "HelloWorld": {
         "Type": "Task",
         "Resource": "arn:aws:lambda:region:123456789012:function:FailFunction",
         "Catch": [ {
            "ErrorEquals": ["HandledError"],
            "Next": "fallback"
         } ],
         "End": true
      },
      "fallback": {
         "Type": "Pass",
         "Result": "Hello, AWS Step Functions!",
         "End": true
      }
   }
}

Diese Variante verwendet den vordefinierten FehlercodeStates.TaskFailed, der jedem Fehler entspricht, den eine Lambda-Funktion ausgibt.

{
   "Comment": "Hello World example which invokes a AWS Lambda function",
   "StartAt": "HelloWorld",
   "States": {
      "HelloWorld": {
         "Type": "Task",
         "Resource": "arn:aws:lambda:region:123456789012:function:FailFunction",
         "Catch": [ {
            "ErrorEquals": ["States.TaskFailed"],
            "Next": "fallback"
         } ],
      "End": true
      },
      "fallback": {
         "Type": "Pass",
         "Result": "Hello, AWS Step Functions!",
         "End": true
      }
   }
}

Behandlung eines Timeouts mithilfe von Retry

Diese Zustandsmaschine verwendet ein Retry Feld, um einen Task Status, bei dem das Timeout überschritten wurde, erneut zu versuchen, basierend auf dem in angegebenen Timeout-Wert. TimeoutSeconds Step Functions wiederholt den Lambda-Funktionsaufruf in diesem Task Zustand zweimal, mit einem exponentiellen Backoff zwischen den Wiederholungen.

{
   "Comment": "Hello World example which invokes a AWS Lambda function",
   "StartAt": "HelloWorld",
   "States": {
      "HelloWorld": {
         "Type": "Task",
         "Resource": "arn:aws:lambda:region:123456789012:function:sleep10",
         "TimeoutSeconds": 2,
         "Retry": [ {
            "ErrorEquals": ["States.Timeout"],
            "IntervalSeconds": 1,
            "MaxAttempts": 2,
            "BackoffRate": 2.0
         } ],
         "End": true
      }
   }
}

Behandlung eines Timeouts mit Catch

In diesem Beispiel wird ein Catch-Feld verwendet. Wenn ein Timeout aufgetreten ist, wechsel der Zustandsautomat in den Zustand fallback.

{
   "Comment": "Hello World example which invokes a AWS Lambda function",
   "StartAt": "HelloWorld",
   "States": {
      "HelloWorld": {
         "Type": "Task",
         "Resource": "arn:aws:lambda:region:123456789012:function:sleep10",
         "TimeoutSeconds": 2,
         "Catch": [ {
            "ErrorEquals": ["States.Timeout"],
            "Next": "fallback"
         } ],
         "End": true
      },
      "fallback": {
         "Type": "Pass",
         "Result": "Hello, AWS Step Functions!",
         "End": true
      }
   }
}