Dieser Fehler wurde abgefangen und als Eingabe an den Schritt „Fehlerbehandlung“ gesendet. Die Ausgabe des Schritts „Fehlerbehandlung“ in diesem Lauf befindet sich rechts. Diese Ausgabe hat ein „Standing”-Feld und klarere Benennung für das Fehlerbeschreibungsfeld, damit es potenziell an jedes Backend gesendet und korrekt verarbeitet werden kann.
Dieser Handler kann die Informationen bei jedem Logger-Dienst protokollieren und eine kompliziertere Antwort vorbereiten (als Teil des Eingabe-JSON). Der Handler selbst kann alles tun, was Sie brauchen.
V. Mehrere Fehlerhandler
Stellen Sie sich vor, Sie betreiben ein System, das Bestellungen für eine E-Commerce-Web site abwickelt. Bei der Bearbeitung von Bestellungen kann einiges schief gehen.
Erstens können Fehler aufgrund von Problemen mit der Bestellung selbst auftreten. Beispielsweise hat ein Kunde möglicherweise eine falsche Adresse eingegeben oder versucht, ein Produkt zu bestellen, das nicht mehr verfügbar ist („Bestellfehler“).
Auch beim Bezahlvorgang kann es zu Fehlern kommen. Beispielsweise kann die Kreditkarte des Kunden abgelehnt werden oder es liegt ein Downside mit der Zahlungsabwicklung vor („Zahlungsfehler“).
Im „Catch“-Block können wir dann verschiedene Handler für verschiedene Fehler angeben:
"Catch": [
{
"ErrorEquals": [
"OrderError"
],
"Subsequent": "Order errors Dealing with"
},
{
"ErrorEquals": [
"PaymentError"
],
"Subsequent": "Fee errors Dealing with"
},
{
"ErrorEquals": [
"States.ALL"
],
"Subsequent": "Different Error Dealing with"
}
]
Der Handler für die Behandlung anderer Fehler fängt alle Arten von Fehlern ab. Wenn wir einen bestimmten Typ anders behandeln möchten (z. B. PaymentError, OrderError), einen speziellen Handler sollte oben platziert werden Staaten.ALLE – andernfalls wird der Lauf es einfach nicht erreichen.
Aus diesem Grund sollte das State-Machine-Diagramm wie folgt aussehen:
Wenn wir für alle Arten von Fehlern eine gemeinsame Verarbeitungskomponente (Protokolle oder Warnungen/Benachrichtigungen) benötigen, können wir eine Pipeline wie folgt erstellen:
Wie im Bild oben gezeigt, verfügen diese Handler über eine separate gemeinsame Komponente, aber die Aufteilung erhöht die Sichtbarkeit der Pipeline und hilft, Duplikate zu vermeiden.
Die Verwendung separater Fehlerhandler für verschiedene Fehler in einer AWS Step Capabilities-Pipeline ermöglicht eine detailliertere Fehlerbehandlung und ermöglicht spezifische und maßgeschneiderte Fehlerbehandlungsstrategien für jeden Fehlertyp. Dieser Ansatz ermöglicht eine bessere Fehlerlösung, eine verbesserte Fehlerverfolgung und eine effizientere Fehlerbehandlung, was zu einem robusteren und zuverlässigeren Projektablauf führt.
VI. Statustransparenz der Zustandsmaschine und komplexe Pipelines
Zurück zu unserer Modell-Inferenz-Pipeline in Amazon SageMaker: Es gibt quick immer ein Backend oder eine Drittanbieter-Integration, die über erfolgreiche und fehlgeschlagene Ausführungen des Modells benachrichtigt werden sollte. Wenn wir uns dafür entscheiden, ist „Error Dealing with“ nicht mehr der letzte Schritt, additionally ersetzen wir „Finish“: true durch „Subsequent“: „Notifying“.
Die Pipeline kann so aussehen:
Mal sehen, wie es im Falle eines erfolgreichen Laufs und eines Fehlerlaufs aussieht:
Wenn der Lauf erfolgreich warfare, bedeutet dies, dass keine Fehler aufgetreten sind.
Der Fehler erschien in „Inferenz“ und wurde im Schritt „Fehlerbehandlung“ erfolgreich verarbeitet.
Die Pipeline hat wie erwartet funktioniert: Wenn im Pipeline-Lauf keine Fehler auftreten, wird der Schritt „Fehlerbehandlung“ nicht verwendet und die Ergebnisse aus dem Schritt „Inferenz“ gehen direkt zum Schritt „Benachrichtigung“. Wenn jedoch ein Fehler auftritt, erledigt der Schritt „Fehlerbehandlung“ seine Aufgabe, verarbeitet Fehler und sendet die Ergebnisse an den nächsten Schritt „Benachrichtigung“, wo alle (sowohl erfolgreichen als auch nicht erfolgreichen) Ergebnisse des Pipeline-Laufs an das Backend gesendet werden.
Was bleibt additionally in der Geschichte des Laufs übrig? Ein Fehler hat sich in die Pipeline eingeschlichen, aber der Verarbeitungsstatus warfare immer noch erfolgreich. Warum?
Bei erfolgreicher Fehlerbearbeitung wird kein „Fail“-Standing gesetzt. Wir können dies beheben, indem wir den Standing „Fehler“ zum Schritt „Fehler“ hinzufügen, in diesem Fall jedoch zum Schritt „Fehler“. sollte der letzte Schritt in der Pipeline sein. Es gibt keine Möglichkeit, eine Benachrichtigung in einem separaten Schritt zu versenden.
Die erste Lösung bietet sich sofort an: die gesamte Pipeline nach dem Fehler zu duplizieren und am Ende zu erzwingen, dass sie den Standing „Fehlgeschlagen“ zurückgibt. Es kann so aussehen:
In diesem Fall treten keine Fehler auf. Es kommt der Schritt „Erfolgsmeldung benachrichtigen“ zum Einsatz.
In „Inferenz“ ist ein Fehler aufgetreten, der im Schritt „Fehlerbehandlung“ erfolgreich verarbeitet wurde. Es wird der Schritt „Notifying Fail“ verwendet und der Standing „Fail“ gesetzt.
Diesmal wird der Standing der Pipeline-Ausführung besser der Realität entsprechen und wir werden den problematischen Lauf auf den ersten Blick erkennen.
Wenn jedoch mehrere Schritte geplant sind, wird der Parallelzweig weiter wachsen; Bei allen Änderungen müssen Sie daran denken, diese auch in parallelen Zweigen hinzuzufügen. Dieser Ansatz kann in Zukunft zu vielen Fehlern führen. Welche Possibility ist besser? AWS und seine Zustände sind die Antwort.
Wir können unser Downside lösen mit „Auswahl” Schritt. Dieser Pipeline-Schritt ermöglicht es uns, die Eingabe mit dem erwarteten Wert zu vergleichen und abhängig vom Ergebnis dieses Vergleichs den nächsten Pipeline-Schritt auszuwählen. Versuchen wir es zu verwenden:
"State Alternative": {
"Kind": "Alternative",
"Decisions": [
{
"Variable": "$.status",
"StringEquals": "ERROR",
"Next": "State Fail"
}
],
"Default": "State Succeed"
},
"State Fail": {
"Kind": "Fail"
},
"State Succeed": {
"Kind": "Succeed"
}
Die Pipeline kann so aussehen:
In anderen Pipeline-Laufszenarien erhalten wir die folgenden Ergebnisse:
Es sind keine Fehler aufgetreten. Es wurde der Zustandsschritt „Erfolgreich“ verwendet.
In „Inferenz“ ist ein Fehler aufgetreten, der im Schritt „Fehlerbehandlung“ erfolgreich verarbeitet wurde. Es wurde der Schritt „State Fail“ verwendet.
Ausführungspipelines für erfolgreiche und erfolglose Fälle verwenden dieselben Schritte für dieselben Aufgaben, sodass Duplizierungen vermieden werden.
Jetzt können wir den problematischen Lauf leicht in der Verlaufsliste finden:
Genau das wollten wir!
Der vollständige Code für die erstellte Pipeline:
{
"Remark": "An Error-Dealing with instance of the Amazon States Language",
"StartAt": "Inference",
"States": {
"Inference": {
"Kind": "Activity",
"Useful resource": "arn:aws:states:::lambda:invoke",
"OutputPath": "$.Payload",
"Parameters": {
"Payload.$": "$",
"FunctionName": "arn:aws:lambda:REGION:ACCOUNT_ID:perform:LAMBDA_NAME"
},
"Retry": [
{
"ErrorEquals": [
"Lambda.ServiceException",
"Lambda.AWSLambdaException",
"Lambda.SdkClientException"
],
"IntervalSeconds": 2,
"MaxAttempts": 6,
"BackoffRate": 2
}
],
"Catch": [
{
"ErrorEquals": [
"States.ALL"
],
"ResultPath": "$.exception",
"Subsequent": "Error Dealing with"
}
],
"Subsequent": "Notifying"
},
"Notifying": {
"Kind": "Activity",
"Useful resource": "arn:aws:states:::lambda:invoke",
"ResultPath": null,
"Parameters": {
"Payload.$": "$",
"FunctionName": "arn:aws:lambda:REGION:ACCOUNT_ID:perform:NOTIFY_LAMBDA_NAME"
},
"Retry": [
{
"ErrorEquals": [
"Lambda.ServiceException",
"Lambda.AWSLambdaException",
"Lambda.SdkClientException"
],
"IntervalSeconds": 2,
"MaxAttempts": 6,
"BackoffRate": 2
}
],
"Subsequent": "State Alternative"
},
"Error Dealing with": {
"Kind": "Activity",
"Useful resource": "arn:aws:states:::lambda:invoke",
"OutputPath": "$.Payload",
"Parameters": {
"Payload.$": "$",
"FunctionName": "arn:aws:lambda:REGION:ACCOUNT_ID:perform:ERROR_HANDLER_LAMBDA_NAME"
},
"Retry": [
{
"ErrorEquals": [
"Lambda.ServiceException",
"Lambda.AWSLambdaException",
"Lambda.SdkClientException"
],
"IntervalSeconds": 2,
"MaxAttempts": 6,
"BackoffRate": 2
}
],
"Subsequent": "Notifying"
},
"State Alternative": {
"Kind": "Alternative",
"Decisions": [
{
"Variable": "$.status",
"StringEquals": "ERROR",
"Next": "State Fail"
}
],
"Default": "State Succeed"
},
"State Fail": {
"Kind": "Fail"
},
"State Succeed": {
"Kind": "Succeed"
}
}
}
Die Fehlerbehandlung ist ein entscheidender Aspekt beim Erstellen robuster und zuverlässiger Anwendungen in AWS. Mit AWS Step Capabilities und AWS Lambda stehen Ihnen leistungsstarke Instruments zur Implementierung effektiver Fehlerbehandlungsstrategien zur Verfügung.
In diesem Artikel werden verschiedene Ansätze zur Fehlerbehandlung untersucht, von den einfachsten bis zu den komplexesten, und Codebeispiele bereitgestellt, die Ihnen den Einstieg erleichtern. Indem Sie den besten Ansatz für Ihre Anwendung auswählen, können Sie sicherstellen, dass Fehler effektiv behandelt werden und ihre Auswirkungen auf die Funktionalität Ihrer Anwendung minimiert werden.
Fassen wir die wichtigsten Ergebnisse noch einmal zusammen:
- In AWS Step Capabilities ist das möglich mit Fehlern arbeiten auf unterschiedliche Weise, je nach gewünschtem Ergebnis:
- Wiederholen: bei Netzwerkfehlern oder internen AWS-Fehlern, bei denen der Fehler möglicherweise in kurzer Zeit verschwindet
- Go: für Fehler, die keine zusätzliche Verarbeitung erfordern und ein statisches Ergebnis haben
- Eine separate Activity-Lambda-Funktion: für komplexere Fehlerbehandlungsoptionen.
- Der Fehlerstatus sollte immer an letzter Stelle stehen — Danach kann kein weiterer Schritt ausgeführt werden
- Zu vermeide Dopplungenkönnen Sie die integrierten Funktionen von AWS nutzen, insbesondere den „Alternative“-Standing
- Es wird empfohlen, die Rohrleitung gemäß zu bauen Best Practices für AWS Step Functions.
Wir hoffen, dass dieser Artikel informativ und hilfreich für Sie warfare Erstellen Sie robustere und kosteneffizientere Anwendungen auf AWS. Wenn Sie Fragen oder Anregungen haben, können Sie sich gerne an die wenden Provectus Group!
