Verwenden Sie StepFunctions zur Vereinfachung Ihrer serverlosen Anwendungen

Verwenden Sie StepFunctions zur Vereinfachung Ihrer serverlosen Anwendungen

AWS StepFunctions ist ein großartiges Orchestrierungstool für Ihre serverlosen Anwendungen. Wenn Sie Lambda-Funktionen schreiben, die nur die Logik für eine einzige Aufgabe enthalten, sind sie einfacher zu testen. Vor allem, wenn Ihre Funktion keine Orchestrationslogik enthält.

Die Orchestrierung wird dann von StepFunctions durch die Definition eines Zustandsautomaten durchgeführt. Dieser Zustandsautomat ist nichts anderes als eine JSON-Definition, die auf der Amazon State Language basiert. Er beschreibt den Fluss zwischen den Funktionen für Ihren spezifischen Anwendungsfall.

Lassen Sie uns ein Beispiel verwenden

Nehmen wir an, einer der Eingabeparameter ist ein Objektstandort auf S3. Wir füttern damit Ihren Zustandsautomaten. Eine Lambda-Funktion kann dann verwendet werden, um dieses Objekt zu lesen und eine Geschäftslogik mit diesen Daten auszuführen.

Oder Sie können die AWS SDK Service-Integration verwenden. Durch die Verwendung der Service-Integration können Sie Ihre Geschäftslogik nochmals vereinfachen. Anstatt ein Objekt aus S3 zu lesen und einige Aktionen auszuführen. Sie müssen nur die Aktion für die Daten ausführen, die Sie erhalten. Damit entfällt die Notwendigkeit, S3 GetObject-Aufrufe in Ihren Unit-Tests zu spiegeln. Außerdem müssen Sie nicht für die Zeit aufkommen, die für das Lesen der Daten aus S3 benötigt wird. Dies geschieht außerhalb des Geltungsbereichs der Lambda-Funktion, so dass Sie dafür nicht bezahlen müssen.

Klingt gut, haben Sie ein Beispiel für mich?

Nehmen wir an, die folgende Nutzlast ist gegeben:

{
  "Bucket": "my-bucket-name",
  "ObjectKey": "my-path/to-my-file.json"
}

Und wir haben die folgende Aufgabe in unserem Zustandsautomaten:

{
  "Read From S3": {
    "Type": "Task",
    "Resource": "arn:aws:states:::aws-sdk:s3:getObject",
    "Parameters": {
      "Bucket": "$.Bucket",
      "Key": "$.ObjectKey"
    },
    "OutputPath": "$.Body",
    "ResultPath": "$.ObjectBody",
    "Next": "My Lambda"
  }
}

Dies führt eine s3:getObject-Aktion für s3://mein-bucket-name/mein-pfad/zu-meiner-datei.json aus. Die Aktion gibt den Inhalt der Datei im Parameter Body zurück. Und wir werden diesen Inhalt in den Parameter ObjectBody des Ereignisses einfügen. Das Ereignis wird also wie folgt aussehen:

{
  "Bucket": "my-bucket-name",
  "ObjectKey": "my-path/to-my-file.json",
  "ObjectBody": "{"Foo": "Bar"}",
  "TransformedBody": "{"Foo": "Bar"}"
}

Wir können nun eine Lambda-Funktion aufrufen, um etwas mit dieser Nutzlast zu tun:

{
  "My Lambda": {
    "Type": "Task",
    "Resource": "arn:aws:states:::lambda:invoke",
    "InputPath": "$.ObjectBody",
    "Parameters": {
      "FunctionName": "arn:aws:lambda:eu-west-1:123456789012:function:my-function"
    },
    "ResultPath": "$.TransformedBody",
    "Next": "Write to S3"
  }
}

Nehmen wir an, dass wir in der Lambda-Funktion das Objekt mit einem zusätzlichen Parameter angereichert haben. Das Ereignis sieht also jetzt so aus:

{
  "Bucket": "my-bucket-name",
  "ObjectKey": "my-path/to-my-file.json",
  "ObjectBody": "{"Foo": "Bar"}",
  "TransformedBody": "{"Foo": "Bar", "Bar": "Foo"}"
}

Wir können nun das umgewandelte Ereignis auf S3 speichern:

{
  "Write to S3": {
    "Type": "Task",
    "Resource": "arn:aws:states:::aws-sdk:s3:putObject",
    "Parameters": {
      "Bucket": "$.Bucket",
      "Key": "$.ObjectKey",
      "Body.$": "$.TransformedBody"
    }
  },
  "End": true
}

Und schon wird das vorhandene Objekt mit dem zusätzlichen Parameter in der json-Struktur aktualisiert.

Fazit

Sie können StepFunctions verwenden, um Folgendes aus Ihren Lambda-Funktionen zu entfernen:

• Logik der Orchestrierung
• AWS API-Aufrufe

So können Sie sich auf Ihre eigentliche Aufgabe konzentrieren und den Code, den Sie schreiben und pflegen müssen, vereinfachen.

Foto von Baskin Creative Studios