Punkt-zu-Punkt-Messaging mit Amazon SQS

Einführung

Das Punkt-zu-Punkt-Messaging-Muster ist ein gängiges Kommunikationsmodell in modernen Web- und Cloud-Architekturen. Es ermöglicht asynchrone Interaktionen zwischen verschiedenen Komponenten, z. B. serverlosen Funktionen oder Microservices, sodass diese Nachrichten austauschen können, ohne dass eine sofortige Antwort erforderlich ist.

In diesem Muster wird die Komponente, die die Nachricht sendet, als Produzent bezeichnet, während die Komponente, die die Nachricht empfängt und verarbeitet, als Konsument bezeichnet wird. Produzent und Konsument können sich im selben System oder in verschiedenen Systemen befinden, was diesen Kommunikationsansatz flexibel und skalierbar macht.

Ähnlich wie E-Mails an Empfänger zugestellt werden, werden Nachrichten von einem Sender an einen bestimmten Empfänger gesendet. Dies ermöglicht eine effiziente und zuverlässige Kommunikation selbst in komplexen verteilten Systemen. Typischerweise wird dieses Verfahren in Szenarien eingesetzt, in denen der Sender genau weiß, welcher Empfänger die Nachricht erhalten soll, aber keine sofortige Antwort benötigt.

Das Punkt-zu-Punkt-Messaging-Muster erleichtert effektiv die Kommunikation und Koordination zwischen den Komponenten und verbessert so die Gesamtleistung, Zuverlässigkeit und Skalierbarkeit moderner Web- und Cloud-Architekturen.

Was wir bauen werden

In diesem Schritt-für-Schritt-Tutorial implementieren wir dieses Muster mithilfe von zwei AWS Lambda-Funktionen und einer Amazon SQS-Warteschlange.

In diesem Schritt-für-Schritt-Tutorial implementieren wir ein einfaches Beispiel mit zwei AWS Lambda-Funktionen und einer Amazon SQS-Warteschlange.

Sie werden das Beispiel mit TypeScript und dem AWS Cloud Development Kit (AWS CDK) erstellen.

Das Beispiel besteht aus drei Komponenten:

Ein Produzent, der Nachrichten an den Konsumenten senden kann
Ein Konsument, der Nachrichten vom Produzenten empfangen kann.
Eine Nachrichtenwarteschlange, die einen Kommunikationskanal zwischen Produzent und Konsument herstellt.

Neben der Implementierung dieses Musters werden wir auch die Leistungsfähigkeit des AWS Cloud Development Kit (CDK) zur Definition der gesamten Infrastruktur als Code hervorheben. Weitere Informationen zum AWS CDK finden Sie im AWS CDK-Entwicklerhandbuch.

Am Ende dieses Tutorials verfügen Sie über ein umfassendes Verständnis der einzelnen Komponenten der warteschlangenbasierten Punkt-zu-Punkt-Kommunikation, haben erfolgreich asynchrone Kommunikation zwischen zwei Lambda-Funktionen mithilfe von SQS implementiert und praktische Erfahrung im Infrastrukturaufbau gesammelt. (Code with CDK)

Bevor wir mit dem Programmieren beginnen, werfen wir einen kurzen Blick auf die Vor- und Nachteile des asynchronen Punkt-zu-Punkt-Messaging-Musters.

Vor- und Nachteile des asynchronen Punkt-zu-Punkt-Messaging-Paradigmas

Vorteile

Lose Kopplung: Das asynchrone Punkt-zu-Punkt-Messaging-Muster fördert eine lose Kopplung zwischen Anwendungen und ermöglicht deren unabhängige Kommunikation ohne enge Integration. Diese Flexibilität erleichtert die Skalierung und Anpassung einzelner Komponenten, ohne das Gesamtsystem zu beeinträchtigen.
Skalierbarkeit: Dieses Muster ermöglicht eine effiziente horizontale Skalierung, da mehrere Verbraucheranwendungen hinzugefügt werden können, um Arbeitslasten asynchron zu verarbeiten. Dadurch kann das System große Mengen gleichzeitiger Nachrichten und Anfragen effektiver bewältigen.
Zuverlässigkeit: Bei asynchroner Nachrichtenübermittlung kann eine Nachricht, die nicht zugestellt oder verarbeitet wird, erneut gesendet oder zur späteren Verarbeitung in eine Fehlerwarteschlange gestellt werden, wodurch die Zuverlässigkeit des Systems erhöht wird.
Fehlertoleranz: Asynchrone Nachrichtenübermittlung bietet Fehlertoleranz durch die Trennung von Nachrichtenproduzenten und -empfängern. Stürzt eine Anwendung oder Komponente ab, können Nachrichten gespeichert und nach der Wiederherstellung des Systems verarbeitet werden, wodurch Datenverlust verhindert wird.

Nachteile

Komplexität: Die Implementierung des asynchronen Punkt-zu-Punkt-Messaging-Musters kann im Vergleich zu anderen Integrationsmustern komplexer sein und erfordert zusätzliche Logik zur Nachrichtenverarbeitung.
Nachrichtenabhängigkeiten und mögliche Duplikate: Die Verwaltung von Abhängigkeiten zwischen Nachrichten und die Gewährleistung der korrekten Nachrichtenlöschung können in einem asynchronen Nachrichtensystem eine Herausforderung darstellen. Sorgfältige Planung und Implementierung sind erforderlich, um potenzielle Probleme wie Nachrichtenreihenfolge, Nachrichtenduplizierung und Abhängigkeiten in der Nachrichtenverarbeitung zu beheben.
Erhöhte Latenz: Asynchrone Nachrichtenübermittlung führt zu einer Verzögerung zwischen dem Senden einer Nachricht und dem Empfangen einer Antwort, da die Verarbeitung der Nachrichten länger dauern kann. Diese Latenz kann Echtzeitinteraktionen beeinträchtigen und ist möglicherweise nicht für Anwendungen geeignet, die sofortiges Feedback erfordern.

Bei Architekturentscheidungen ist es stets wichtig, diese Abwägungen zu berücksichtigen und das Kommunikationsmuster zu wählen, das am besten zu den spezifischen Anforderungen und Einschränkungen passt. Viele moderne Anwendungen nutzen verschiedene Integrationsmuster, darunter asynchrone Punkt-zu-Punkt-Kommunikation, synchrone Anfrage-Antwort-Kommunikation und ereignisgesteuerte Kommunikation.

Doch nun beginnen wir mit dem Tutorial und lernen, wie man dieses Muster mit AWS Lambda und Amazon SQS implementiert.

Hinweis zu den Ressourcenkosten beim Programmieren: Dieses Tutorial verwendet nur die minimale Menge an Ressourcen, die alle im kostenlosen Kontingent von AWS für die ersten 12 Monate nach Erstellung jedes Kontos enthalten sind:

Ein paar Kilobyte Code werden in Amazon S3 gespeichert, das 5 GB kostenlosen Speicherplatz bietet.
Wir rufen SQS einige Male auf, das 1 Million kostenlose Anfragen pro Monat anbietet.
Wir werden zwei Funktionen in AWS Lambda aufrufen, das auch 1 Million kostenlose Aufrufe pro Monat bietet.

Wenn Sie also der Schritt-für-Schritt-Anleitung folgen, bleiben Sie definitiv im kostenlosen Tarif. Ich habe am Ende außerdem einen Abschnitt hinzugefügt, der Ihnen hilft, alle während dieses Tutorials erstellten Ressourcen zu löschen.

Voraussetzungen

Wenn Sie die CLI und das CDK installiert haben, sollten die Versionen Ihrer Installationen angezeigt werden. Andernfalls erhalten Sie eine Fehlermeldung, dass der Befehl nicht gefunden wurde.

Bevor Sie mit diesem Tutorial beginnen, benötigen Sie Folgendes:

AWS-Konto
AWS Cloud Development Kit (AWS CDK)

Für dieses Tutorial werden mindestens Version 2 der AWS CLI und des AWS CDK benötigt.

Die AWS CLI-Version können Sie ermitteln, indem Sie folgenden Befehl im Terminal ausführen:

aws --version

Und die AWS CDK-Version durch Ausführen des folgenden Befehls:

cdk --version

Schritt 1 – Erstellen der CDK-Anwendung

1.1 – Starten Sie das CDK-Programm

Zuerst müssen Sie sich um die Ersteinrichtung kümmern und den CDK den Code automatisch generieren lassen, der das Projekt erstellt.

Erstellen Sie über die Befehlszeile ein Verzeichnis für das Projekt, wechseln Sie in dieses Verzeichnis und initialisieren Sie das Projekt:

mkdir point-to-point-example
cd point-to-point-example
cdk init app --language typescript

Dadurch wird die Hauptdateistruktur für das Projekt erstellt und die benötigten Pakete installiert.

Jetzt ist ein guter Zeitpunkt, das Projekt in Ihrer bevorzugten IDE zu öffnen und einen Blick auf das generierte Projekt und insbesondere auf die folgenden beiden Dateien zu werfen:

point-to-point-example/
├── bin/
│ └── point-to-point-example.ts
├── lib/
│ └── point-to-point-example-stack.ts
└── ...

Datei bin\point-to-point-example.ts Dies ist der Einstiegspunkt für das CDK-Programm. Wir werden diese Datei in diesem Tutorial nicht mehr benötigen.

Datei lib\point-to-point-example-stack.ts Hier wird der Hauptstapel des Programms definiert. In dieser Datei verbringen wir die meiste Zeit.

Im weiteren Verlauf dieses Tutorials werden wir der Klasse die Infrastruktur unserer Anwendung vorstellen. Punkt-zu-Punkt-Beispielstapel In dieser Datei fügen wir Folgendes hinzu. Öffnen Sie sie in Ihrem Editor und sehen Sie sich das an:

import * as cdk from 'aws-cdk-lib';
import { Construct } from 'constructs';
// import * as sqs from 'aws-cdk-lib/aws-sqs';
export class PointToPointExampleStack extends cdk.Stack {
constructor(scope: Construct, id: string, props?: cdk.StackProps) {
super(scope, id, props);
// The code that defines your stack goes here
// ...
}
}

1.2 – Die Umgebung einrichten

Wenn Sie eine AWS CDK-Anwendung zum ersten Mal in einer Umgebung bereitstellen, d. h. in einem bestimmten AWS-Konto und einer bestimmten Region, müssen Sie die Umgebung mit einem CDKToolkit-Stack starten. Dieser Stack stellt einen S3-Bucket bereit, der während des eigentlichen Anwendungsbereitstellungsprozesses zum Speichern von Vorlagen und Ressourcen verwendet wird.

Um die Umgebung einzurichten, stellen Sie sicher, dass Sie sich noch im Beispielverzeichnis befinden, und führen Sie den folgenden Befehl aus:

cdk bootstrap

Dies wird eine Weile dauern und ist abgeschlossen, wenn die folgende Ausgabe in Ihrer Befehlszeile angezeigt wird:

✅ Environment aws://[account_id]/[region] bootstrapped.

1.3 – Bereitstellung des initialen Stacks

Um den Stack bereitzustellen, stellen Sie sicher, dass Sie sich noch im Beispielverzeichnis für die Punkt-zu-Punkt-Konfiguration befinden, und führen Sie den folgenden Befehl aus:

cdk deploy

Dieser Befehl kompiliert die Anwendung in eine AWS CloudFormation-Vorlage und stellt sie in Ihrem AWS-Konto bereit.

Öffnen Sie nun die Stack-Details und sehen Sie sich diese an. Auf der Registerkarte „Ressourcen“ sehen Sie, dass außer einer Ressource namens CDKMetadata, die lediglich einige anfängliche Konfigurationsdetails für unseren Stack enthält, nichts bereitgestellt wurde.

Schritt 2 – SQS-Warteschlange erstellen

Sobald alles eingerichtet ist, können Sie Ihre erste echte Ressource erstellen, und zwar eine SQS-Warteschlange.

2.1 – Füge die Warteschlange dem Stapel hinzu

Zunächst die Datei lib\point-to-point-example-stack.ts Offen.

Je nach Version der CDK-Vorlage sind möglicherweise bereits Importanweisungen, einschließlich `aws-cdk-lib/aws-sqs`, in einem Kommentar enthalten. Entfernen Sie in diesem Fall die Kommentarzeichen `//` vor `import * as sqs from 'aws-cdk-lib/aws-sqs'`. Andernfalls fügen Sie die Anweisung selbst hinzu, sodass die ersten drei Zeilen der Datei wie folgt aussehen:

import * as cdk from 'aws-cdk-lib';
import { Construct } from 'constructs';
import * as sqs from 'aws-cdk-lib/aws-sqs';

Nun zu den Kommentaren im Unterricht. Punkt-zu-Punkt-Beispielstapel Löschen und ersetzen Sie den folgenden Code und speichern Sie Ihre Änderungen:

const queue = new sqs.Queue(this, 'Queue', {
queueName: 'MyQueue',
});

2.2 – Warteschlange bereitstellen

Um die Warteschlange bereitzustellen, führen Sie folgenden Befehl in Ihrem Projektverzeichnis aus:

cdk deploy

Sie können den Bereitstellungsprozess nun in der Terminalausgabe verfolgen; er sollte nach ein bis zwei Minuten abgeschlossen sein.

Sobald die Bereitstellung abgeschlossen ist, rufen Sie in der AWS Management Console Ihre SQS-Warteschlangenliste auf und suchen Sie nach einer Warteschlange mit dem Namen SqsTutorialStack-Queue:

2.3 – Überprüfen Sie die Warteschlange „Bereitgestellt“.

Rufen Sie das SQS-Dashboard in der AWS Management Console auf und sehen Sie sich die Liste der Warteschlangen an. Falls Ihre Warteschlange nicht angezeigt wird, stellen Sie sicher, dass Sie sich in der richtigen Region befinden.

Schritt 3 – Erstellen Sie die Producer-Funktion und verbinden Sie sie mit der Warteschlange.

3.1 – Schreiben Sie den Quellcode der Generatorfunktion

Wir verwenden JavaScript für die Lambda-Funktion und speichern den Quellcode in einem eigenen Ordner innerhalb der CDK-Anwendung. Später referenzieren wir diesen Ordner in unserem CDK-Stack, sodass dieser die Inhalte automatisch packen, hochladen und in AWS bereitstellen kann.

Stellen Sie sicher, dass Sie sich im Projektverzeichnis befinden und erstellen Sie die folgenden Verzeichnisse sowie die Datei selbst:

mkdir lambda-src
mkdir lambda-src/producer
touch lambda-src/producer/send_message_to_sqs.js

Ihre Projektverzeichnisstruktur sollte nun wie folgt aussehen:

point-to-point-example/
├── bin/
│ └── point-to-point-example.ts
├── lambda-src/
│ └── producer/
│ └── send_message_to_sqs.js
├── lib/
│ └── point-to-point-example-stack.ts
└── ...

Neue Datei erstellt. lambda-src/producer/send_message_to_sqs.js Öffnen Sie die Datei in Ihrem Editor und fügen Sie folgenden Code hinzu:

const sqs = require("@aws-sdk/client-sqs");
// Create an Amazon SQS service client
const client = new sqs.SQSClient();
exports.handler = async (event, context) => {
// Create a message, including the function's name from
// its execution context
const myMessage = 'Hello World from ' + context.functionName
// Get the queue URL from the execution environment
const queueUrl = process.env.SQSQueueUrl
// Create a SendMessageCommand containing the message
// and the queue URL
const command = new sqs.SendMessageCommand({
MessageBody: JSON.stringify({ message: myMessage }),
QueueUrl: queueUrl
});
// Send the message and return the result 
const result = await client.send(command);
return result;
}

Dies ist ein einfacher Lambda-Funktionshandler, der eine Nachricht an unsere SQS-Warteschlange sendet und das Ergebnis zurückgibt.

Da wir beim Erstellen dieser Funktion nicht unbedingt wissen, welche Warteschlange verwendet werden soll, oder diese später ändern möchten, ohne den Funktionscode anpassen zu müssen, rufen wir die Warteschlangen-URL zur Laufzeit ab. Dadurch können wir sie während der Bereitstellung der Lambda-Funktion im CDK-Stack dynamisch definieren.

3.2 – Die Producer-Funktion zum Stack hinzufügen

Um eine echte Lambda-Funktion in AWS zu erstellen, müssen Sie sie dem Stack hinzufügen. Öffnen Sie dazu die Datei lib/point-to-point-example-stack.ts.

Fügen Sie zunächst eine weitere Importanweisung am Anfang der Datei hinzu:

import * as lambda from 'aws-cdk-lib/aws-lambda';

Fügen Sie anschließend den folgenden Codeausschnitt innerhalb des Konstruktors unterhalb der Warteschlange ein:

const producerFunction = new lambda.Function(this, 'Producer', {
functionName: 'Producer',
runtime: lambda.Runtime.NODEJS_18_X,
code: lambda.Code.fromAsset('lambda-src/producer'),
handler: 'send_message_to_sqs.handler',
environment: {
SQSQueueUrl: queue.queueUrl,
}
});

Dadurch werden eine Funktion, Pakete und der Inhalt des Verzeichnisses lambda-src/producer erstellt und die Funktion so konfiguriert, dass beim Aufruf der in send_message_to_sqs.js definierte Handler verwendet wird.

Außerdem wird die Umgebungsvariable SQSQueueUrl dynamisch auf die tatsächliche URL der SQS-Warteschlange gesetzt, sodass innerhalb der Funktion über process.env.SQSQueueUrl darauf zugegriffen werden kann.

3.3 – Lizenzierung der Darbietung des Produzenten

Jede Lambda-Funktion benötigt einige grundlegende IAM-Berechtigungen, die das CDK standardmäßig über eine einfache Ausführungsrolle bereitstellt.

Unsere Producer-Funktion benötigt jedoch zusätzliche Berechtigungen, um Nachrichten an die Warteschlange zu senden. Glücklicherweise müssen wir in CDK IAM-Richtlinien nicht manuell verwalten. Wir können die Methode `grantSendMessages` der SQS-Warteschlange mit unserer Lambda-Funktion verwenden.

Fügen Sie dazu die folgende Zeile unterhalb Ihrer producerFunction ein:

queue.grantSendMessages(producerFunction);

3.4 – Bereitstellung der Produzentenfunktion

Um die Funktion zusammen mit ihrem Quellcode bereitzustellen, führen Sie folgenden Befehl im Projektverzeichnis aus:

cdk deploy

Dies bereitet den Einsatz aller neuen oder geänderten Ressourcen vor.

Falls Änderungen an Ihrem Stack das Erstellen oder Ändern von IAM-Berechtigungen erfordern, fordert CDK Sie aus Sicherheitsgründen auf, diese Änderungen erneut zu prüfen.

Im folgenden Bild ist zu sehen, dass CDK drei Änderungen vornehmen möchte, die sich auf die IAM-Berechtigungen auswirken:

Erlauben Sie dem Lambda-Dienst (lambda.amazon.aws), die Ausführungsrolle der Producer-Funktion zu übernehmen.
Fügen Sie die erforderlichen Berechtigungen direkt hinzu, um der Führungsrolle den Zugriff auf die SQS-Warteschlange und das Senden von Nachrichten an diese zu ermöglichen.
Fügen Sie der Ausführungsrolle eine verwaltete Richtlinie mit anfänglichen Berechtigungen hinzu.

Geben Sie y ein, um zu bestätigen, und CDK wird die neue Lambda-Funktion zusammen mit ihrer IAM-Rolle bereitstellen.

3.5 – Testen Sie die Leistung des Herstellers

Nach dem Ausführen der Funktion rufen Sie die Liste der Funktionen im AWS Lambda-Dashboard auf.

Der Funktionsname entspricht dem, den wir im Stack definiert haben: Producer. Falls Sie die Funktion nicht finden, überprüfen Sie bitte, ob Sie sich im richtigen Bereich befinden.

Klicken Sie auf den Funktionsnamen, um die Details zu öffnen und zum Quellcode zu gelangen.

Der Ordner im Datei-Explorer auf der linken Seite enthält eine Datei namens send_message_to_sqs.js.

Doppelklicken Sie auf den Dateinamen, um den Quelltext zu öffnen. Dort sehen Sie, dass es sich um eine exakte Kopie der Datei handelt, die wir im Ordner lambda-src/producer in unserem CDK-Projekt erstellt haben.

Nun konfigurieren wir ein Testereignis.

Klicken Sie dazu auf die Schaltfläche “Testen”. Falls Sie noch kein Testereignis konfiguriert haben, wird die Seite „Testkonfiguration“ geöffnet. Geben Sie den Ereignisnamen ein, z. B. „test-event“, und klicken Sie auf „Speichern“.

Sobald das Testereignis konfiguriert ist, klicken Sie erneut auf „Testen“. Dadurch wird die Lambda-Funktion direkt aufgerufen.

Dadurch wird eine Registerkarte „Ausführungsergebnisse“ erstellt, die die Antwort enthält:

{
"$metadata": {
"httpStatusCode": 200,
"requestId": "cb033b2a-1234-5678-9012-66188359d280",
"attempts": 1,
"totalRetryDelay": 0
},
"MD5OfMessageBody": "b5357af0c1c816b2d41275537cc0d1af",
"MessageId": "4a76e538-1234-5678-9012-749f0f4b9294"
}

Erinnern Sie sich an den Codeausschnitt in der Lambda-Funktion?

const result = await client.send(command);
return result;

Das JSON-Objekt in den obigen Ausführungsergebnissen ist genau das, was SQS als Antwort auf client.send(command) zurückgegeben hat, einschließlich interessanter Informationen wie “httpStatusCode”: 200, was bedeutet, dass die Warteschlange die Nachricht erfolgreich empfangen hat.

3.6 – Manuelles Abrufen von Nachrichten aus SQS

Die Warteschlange ist derzeit nicht mit dem Empfänger verbunden, daher wird die Nachricht nicht empfangen. Wir können die Nachricht jedoch manuell abrufen.

Gehen Sie zum SQS-Dashboard, klicken Sie auf die Warteschlange, um deren Detailseite zu öffnen, und klicken Sie auf die Schaltfläche „Nachrichten senden und empfangen“.

Gehen Sie auf der nächsten Seite zum Abschnitt „Nachrichten empfangen“ und klicken Sie auf die Schaltfläche „Nachrichten abfragen“. Daraufhin sollten alle aktuell gesendeten Nachrichten angezeigt werden, einschließlich der Nachrichten, die Ihre Builder-Funktion beim Testen gesendet hat:

Klicken Sie auf die Nachrichten-ID, um die Nachricht zu öffnen. Sie sollte folgenden Inhalt haben:

{"message":"Hello World from Producer"}

Herzlichen Glückwunsch! Sie haben erfolgreich eine Lambda-Funktion bereitgestellt und getestet, die Nachrichten an eine SQS-Warteschlange sendet.

Als Nächstes erstellen wir die Verbraucherfunktion und konfigurieren sie so, dass sie automatisch aufgerufen wird, sobald eine neue Nachricht in der Warteschlange eintrifft.

Schritt 4 – Erstellen Sie die Consumer-Funktion und verbinden Sie sie mit der Warteschlange.

4.1 – Schreiben Sie den Quellcode der Verbraucherfunktion

Der Code der Verbraucherfunktion wird in einem eigenen Ordner innerhalb von lambda-src gespeichert, sodass das CDK ihn automatisch packen und in die neue Lambda-Funktion hochladen kann.

Stellen Sie sicher, dass Sie sich im Projektverzeichnis befinden (nicht in bin/ oder lib/) und erstellen Sie das folgende Verzeichnis mit der Quelldatei:

mkdir lambda-src/consumer
touch lambda-src/consumer/receive_message_from_sqs.js

Öffnen Sie lambda-src/consumer/receive_message_from_sqs.js in Ihrem Editor und geben Sie folgenden Code ein:

exports.handler = async (event) => {
// Retrieve the message from the event and log it to the console
const message = event.Records[0].body;
console.log(message);
}

Dies ist ein sehr einfacher Lambda-Funktionshandler, der die SQS-Nachricht öffnet und sie im Bericht ausgibt.

4.2 – Füge die Consumer-Funktion zum Stack hinzu.

Um eine echte Lambda-Funktion in AWS zu erstellen, müssen Sie sie dem Stack hinzufügen. Öffnen Sie dazu die Datei lib/point-to-point-example-stack.ts.

Fügen Sie den folgenden Codeausschnitt innerhalb des Producers unterhalb von queue.grantSendMessages(producerFunction) ein:

 const consumerFunction = new lambda.Function(this, 'Consumer', {
functionName: 'Consumer',
runtime: lambda.Runtime.NODEJS_18_X,
code: lambda.Code.fromAsset('lambda-src/consumer'),
handler: 'receive_message_from_sqs.handler'
});

Diese Consumer-Funktion erstellt die Pakete und Inhalte des Verzeichnisses lambda-src/consumer und konfiguriert die Funktion so, dass beim Aufruf der in receive_message_from_sqs.js definierte Handler verwendet wird.

4.3 – Die SQS-Warteschlange als Ereignisquelle zum Consumer hinzufügen

Diese Funktion soll immer dann ausgelöst werden, wenn eine neue Nachricht in unserer Warteschlange eingeht. Dazu müssen wir die Warteschlange als Ereignisquelle für die Funktion hinzufügen und ihr alle erforderlichen Berechtigungen zum Verarbeiten von Nachrichten erteilen.

Fügen Sie zunächst eine weitere Importanweisung am Anfang der Datei hinzu:

import { SqsEventSource } from 'aws-cdk-lib/aws-lambda-event-sources';

Fügen Sie als Nächstes die folgenden zwei Zeilen unterhalb der Definition von customersFunction hinzu:

consumerFunction.addEventSource(new SqsEventSource(queue));
queue.grantConsumeMessages(consumerFunction);

4.4 – Bereitstellung der Verbraucherfunktion

Um die Funktion zusammen mit ihrem Quellcode bereitzustellen, führen Sie folgenden Befehl im Projektverzeichnis aus:

cdk deploy

Dadurch wird die Bereitstellung aller neuen oder geänderten Ressourcen vorbereitet und Sie werden erneut aufgefordert, die neuen IAM-Berechtigungen zu überprüfen.

Geben Sie y ein, um zu bestätigen. CDK wird dann die neue Lambda-Funktion zusammen mit ihrer Ausführungsrolle ausführen und sie der SQS-Warteschlange hinzufügen.

Sobald die Bereitstellung abgeschlossen ist, ist alles einsatzbereit und verbunden. Mal sehen, ob es funktioniert.

Schritt 5 – End-to-End-Test der Anwendung

Um die Anwendung zu testen, rufen wir die Produzentenfunktion manuell auf, um eine weitere Nachricht an die Warteschlange zu senden. Anschließend überprüfen wir die Ausführungsprotokolle der Konsumentenfunktion, um festzustellen, ob sie automatisch gestartet wurde und die Nachricht verarbeitet hat.

5.1 – Die Funktion „Produzent“ aufrufen

Führen Sie die in Abschnitt 3.5 – Testen der Produzentenfunktion – beschriebenen Schritte aus, um die Produzentenfunktion erneut aufzurufen. Hier eine kurze Zusammenfassung:

Gehen Sie zur Funktionsliste im AWS Lambda-Dashboard.
Öffnen Sie die Funktion „Produzent“, indem Sie auf ihren Namen klicken.
Gehen Sie zum Quellcodeabschnitt.
Klicken Sie auf die Schaltfläche „Testen“.
Stellen Sie sicher, dass die Funktion erfolgreich ausgeführt wird.

5.2 – Verbraucherleistungsbericht prüfen

Gehen Sie zurück zur Funktionsliste im AWS Lambda-Dashboard und öffnen Sie diesmal die Consumer-Funktion.

Scrollen Sie nach unten, öffnen Sie den Tab „Monitor“, öffnen Sie innerhalb dieses Tabs den Tab „Logs“ und schauen Sie sich „Recent Invocations“ an. Dort sollten Sie einen Link zum letzten LogStream der Funktion finden.

Klicken Sie anschließend auf den Link „Protokollfluss“. Dadurch wird der Protokolleintrag selbst angezeigt, was etwas verwirrend wirken kann, wenn Sie das Format nicht gewohnt sind.

Suchen Sie einfach nach dem Eintrag genau in der Mitte zwischen diesen beiden, beginnend mit START RequestId: … und END Request ID: ….

Klicken Sie auf den Pfeil, um den Eintrag zu erweitern, in dem Sie die Originalnachricht finden sollten:

Ergebnis

Herzlichen Glückwunsch! Sie haben alles erstellt, was Sie benötigen, um eine asynchrone Punkt-zu-Punkt-Kommunikation zwischen zwei Lambda-Funktionen mithilfe von SQS einzurichten.

Mit SQS lassen sich noch viele weitere Funktionen nutzen, z. B. Nachrichten kategorisieren, die Nachrichtenreihenfolge sicherstellen und fehlerhafte Nachrichten automatisch an eine Deadline Queue (DLQ) weiterleiten. Weitere Informationen finden Sie im Amazon SQS-Entwicklerhandbuch.