AWS SNS: Der vollständige Leitfaden für Echtzeit-Benachrichtigungen

Einrichten von AWS SNS

Bevor du deine erste Benachrichtigung mit SNS verschicken kannst, musst du ein paar Einrichtungsschritte befolgen, um alles vorzubereiten.

Schritt 1: Ein AWS-Konto erstellen

Wenn du noch kein AWS-Konto hast, musst du erst eines erstellen, bevor du SNS nutzen kannst.

Gehe auf die AWS-Homepage und klicke aufauf die Schaltfläche "AWS-Konto erstellen" in der oberen rechten Ecke. Du musst deine E-Mail-Adresse angeben, ein Passwort erstellen und einige grundlegende Kontoinformationen eingeben. AWS wird dich auch nach deinen Kreditkartendaten fragen - keine Sorge, SNS hat ein ziemlich großzügiges kostenloses Angebot, das dir nur dann in Rechnung gestellt wird, wenn du dieses Limit überschreitest.

Sobald dein Konto eingerichtet ist, kannst du weitermachen. Ich empfehle jedoch dringend, eineneigenen IAM-Benutzer zu erstellen, anstatt dein Root-Konto zu verwenden. Das würde den Rahmen des heutigen Artikels sprengen, aber in der offiziellen Anleitungfindest dudetaillierte Richtlinien.

Schritt 2: Einrichten von SNS in der AWS Management Konsole

Jetzt, wo du ein AWS-Konto hast, ist es an der Zeit, auf den SNS-Service zuzugreifen.

Melde dich mit deinen Anmeldedaten bei der AWS Management Console an und suche SNS. Du kannst dies auf drei Arten tun:

• Gib "SNS" in die Suchleiste oben in der Konsole ein
• Klicke in der oberen Navigationsleiste auf "Dienste" und finde SNS unter der Kategorie "Anwendungsintegration".
• Gehe direkt zur SNS-Konsole

Egal wie, dies ist der Bildschirm, den du sehen solltest:

Abbildung 1 - AWS SNS-Service-Seite

Sobald du im SNS-Dashboard bist, siehst du auf der linken Seite ein Menü mit Optionen wie "Themen", "Abonnements" und "Mobil". Das Dashboard gibt dir einen Überblick über deine SNS-Ressourcen und deine letzten Aktivitäten.

Für ein neues Konto wird es ziemlich leer sein - das ist zu erwarten. Lass uns nun unser erstes SNS-Thema erstellen.

Schritt 3: Ein SNS-Thema erstellen

Ein SNS-Thema ist im Grunde ein Kommunikationskanal, an den Publisher Nachrichten senden und Subscriber zuhören.

Stell dir das wie einen Radiosender vor - der Sender sendet auf einer bestimmten Frequenz (dem Thema), und jeder, der auf diese Frequenz eingestellt ist, empfängt die Sendung. In der SNS-Sprache veröffentlicht deine Anwendung Nachrichten in einem Thema, und alle Endpunkte, die dieses Thema abonniert haben, erhalten diese Nachrichten.

Hier erfährst du, wie du dein erstes SNS-Thema erstellst:

1. Auf dem Bildschirm, den du in Bild 1gibst du einen Themennamen ein.
2. Klicke auf die Schaltfläche "Nächster Schritt".
3. Wähle "Standard" für den Typ (FIFO-Themen haben verschiedene Anwendungsfälle, die wir später behandeln).
4. (Optional) Gib einen Anzeigenamen ein. Dies wird in die Nachrichten aufgenommen, die an SMS- oder E-Mail-Abonnenten gesendet werden.
5. Lass alle anderen Einstellungen vorerst auf den Standardwerten.
6. Klicke auf "Thema erstellen".

Wenn du Bilder dem Text vorziehst, sollte dein Bildschirm so aussehen:

Bild 2 - Erstellung von SNS-Themen

Wenn du mit den Werten zufrieden bist, scrolle nach unten, bis du die Schaltfläche "Thema erstellen" siehst:

Abbildung 3 - Erstellung von SNS-Themen (2)

Und das war's! Dein SNS-Thema ist jetzt einsatzbereit. Du siehst Details wie den ARN (Amazon Resource Name) des Themas, der dein Thema eindeutig identifiziert:

Abbildung 4 - Erstellte Details zum Thema

Dein neues Thema ist bereit für Abonnements, aber es hat noch keine. Das bedeutet, dass alle Nachrichten, die du veröffentlichst, nirgendwo hingehen. Keine Sorge, du wirst das im nächsten Abschnitt beheben, wenn du Abonnenten hinzufügst.

SNS-Abonnenten und Abonnements

Wie ich schon sagte, ist dein SNS-Thema wie ein Radiosender. Zurzeit gibt es keine Zuhörer, aber das wird sich ändern, wenn du Abonnenten hinzufügst, die deine Nachrichten erhalten sollen.

Was ist ein SNS-Abonnent?

Ein Abonnent ist ein Endpunkt, der von deinem SNS-Thema benachrichtigt wird, wenn eine Nachricht veröffentlicht wird.

Betrachte die Analogie eines Newsletters. Jedes Mal, wenn du eine neue Ausgabe (Nachricht) veröffentlichst, wird sie an alle in deiner Mailingliste zugestellt. SNS macht diesen Prozess automatisch und skalierbar und übernimmt die gesamte Lieferlogistik für dich.

AWS unterstützt eine Vielzahl von Abonnententypen, sodass du flexibel entscheiden kannst, wie deine Nachrichten verarbeitet werden. Ich liste die wichtigsten Arten unten auf:

• E-Mail-Adressen: Sende Benachrichtigungen im Klartext direkt an den E-Mail-Posteingang.
• SMS-Nummern: Benachrichtigungen per Textnachricht an Handys senden.
• SQS-Warteschlangen: Leite Nachrichten zur weiteren Verarbeitung an andere AWS-Services weiter.
• Lambda-Funktionen: Löse die Ausführung von serverlosem Code als Reaktion auf Benachrichtigungen aus.
• HTTP/HTTPS Endpunkte: Sende Nachrichten an Webanwendungen oder APIs.
• Mobile Push: Sende Benachrichtigungen direkt an mobile Apps.

Jeder Teilnehmertyp hat seine eigenen Vorteile und Anwendungsfälle. E-Mail und SMS eignen sich zum Beispiel gut für menschliche Empfänger, während SQS-Warteschlangen und Lambda-Funktionen besser für die System-zu-System-Kommunikation geeignet sind.

Schritt 1: Hinzufügen eines Abonnenten

Jetzt, wo du weißt, was Abonnenten sind, fügen wir einen zu deinem Thema hinzu. Für dieses Tutorial verwende ich E-Mail, da es am einfachsten einzurichten ist.

Hier erfährst du, wie du einen E-Mail-Abonnenten zu deinem SNS-Thema hinzufügst:

1. Auf der Detailseite deines Themas (die Seite, die in Abbildung 4), klickst du auf die Schaltfläche "Abonnement erstellen".
2. Wähle in der Dropdown-Liste "Protokoll" die Option "E-Mail".
3. Gib im Feld "Endpunkt" die E-Mail-Adresse ein, die Benachrichtigungen erhalten soll.
4. Belasse alle anderen Einstellungen auf ihren Standardwerten.
5. Klicke auf "Abonnement erstellen".

Dein Bildschirm sollte in etwa so aussehen:

Abbildung 5 - Erstellen eines E-Mail-Abonnements

Sobald du auf "Abonnement erstellen" klickst, fügt AWS das Abonnement zu deinem Thema hinzu, aber es befindet sich noch im Status "Bestätigung ausstehend":

Abbildung 6 - Status der ausstehenden Bestätigung

Dies ist eine wichtige Sicherheitsfunktion, da AWS sicherstellen will, dass der Inhaber der E-Mail-Adresse diese Benachrichtigungen auch wirklich erhalten möchte.

Schritt 2: Bestätigen von Abonnements

Nachdem du einen Abonnenten hinzugefügt hast, muss er bestätigen, dass er Benachrichtigungen von deinem SNS-Thema erhalten möchte.

Bei E-Mail-Abonnements sendet AWS automatisch eine Bestätigungs-E-Mail an die von dir angegebene Adresse. Die E-Mail enthält einen Link, den der Empfänger anklicken muss, um das Abonnement zu aktivieren. Solange dies nicht geschieht, werden keine Nachrichten, die für das Thema veröffentlicht wurden, an diesen Endpunkt geliefert.

Hier siehst du, wie eine typische Bestätigungs-E-Mail aussieht:

Bild 7 - SNS-Bestätigungsmail

Der Empfänger muss nur auf den Link "Abonnement bestätigen" in der E-Mail klicken. Sie werden zu einer Seite weitergeleitet, die bestätigt, dass ihr Abonnement jetzt aktiv ist:

Abbildung 8 - Bestätigungsnachricht für die Anmeldung

Für SMS-Abonnenten ist der Prozess ähnlich - AWS sendet eine Textnachricht mit einem Bestätigungslink, dem der Empfänger folgen muss. HTTP/HTTPS-Endpunkte müssen auf eine Bestätigungsanfrage von AWS reagieren, während AWS-Ressourcen wie Lambda-Funktionen und SQS-Warteschlangen für eine automatische Bestätigung konfiguriert werden können.

Du kannst den Status deiner Abonnements überprüfen, indem du in der linken Seitenleiste der SNS-Konsole auf den Abschnitt "Abonnements" klickst. Bestätigte Abonnements haben den Status "Bestätigt", während diejenigen, die auf eine Bestätigung warten, den Status "Ausstehend" haben.

Abbildung 9 - Abonnementstatus

Sobald dein Abonnement bestätigt ist, kannst du anfangen, Nachrichten zu verschicken! Jede Nachricht, die in diesem Thema veröffentlicht wird, wird an alle bestätigten Abonnenten mit dem von ihnen angegebenen Protokoll zugestellt.

Das ist alles, was es zum Einrichten von SNS-Abonnements braucht. Im nächsten Abschnitt erfährst du, wie du Nachrichten zu deinem Thema veröffentlichst und testest, ob deine Abonnenten sie richtig empfangen.

Nachrichten in SNS-Themen veröffentlichen

Jetzt, wo du dein SNS-Thema eingerichtet und Abonnenten hinzugefügt hast, ist es an der Zeit, deine erste Benachrichtigung zu versenden.

Schritt 1: Eine Nachricht veröffentlichen

Ein guter Einstieg ist die Veröffentlichung einer Nachricht über die AWS-Konsole.

Um deine erste Nachricht zu senden, navigiere zur Detailseite deines Themas und klicke oben rechts auf die Schaltfläche "Nachricht veröffentlichen" (siehe Abbildung 4). Dadurch wird das Formular zur Veröffentlichung von Nachrichten geöffnet, in dem du deine Benachrichtigung gestalten kannst. Du siehst Felder für den Betreff und den Text der Nachricht. Der Betreff ist optional, aber hilfreich für E-Mail-Benachrichtigungen, da er die Betreffzeile der E-Mail wird.

Für eine einfache Testnachricht könntest du etwas wie das Folgende eingeben:

Abbildung 10 - Inhalt der ersten Nachricht

Wenn du mit deiner Nachricht zufrieden bist, scrollst du nach unten und klickst unten im Formular auf die Schaltfläche "Nachricht veröffentlichen":

Abbildung 11 - Veröffentlichen einer Nachricht über die Konsole

Nachdem du geklickt hast, verteilt SNS deine Nachricht sofort an alle bestätigten Abonnenten. Wenn du ein E-Mail-Abonnement eingerichtet hast, solltest du die Testnachricht innerhalb weniger Sekunden in deinem Posteingang erhalten:

Abbildung 12 - Nachricht per E-Mail erhalten

Einfach, nicht wahr? Schauen wir uns nun an, wie wir sie weiter anpassen können.

Schritt 2: Versand von SMS- und E-Mail-Benachrichtigungen

Mit SNS kannst du anpassen, wie deine Nachrichten für verschiedene Arten von Abonnenten erscheinen.

Wenn du eine Nachricht veröffentlichst, wirst du die Option "Nachrichtenstruktur" bemerken. Standardmäßig ist sie auf "Identische Nutzlast für alle Zustellprotokolle" eingestellt, was bedeutet, dass alle Abonnenten genau dieselbe Nachricht erhalten. Du kannst aber auch "Benutzerdefinierte Nutzdaten für jedes Zustellungsprotokoll" auswählen, damit du das Nachrichtenformat für jeden Teilnehmertyp anpassen kannst.

Für E-Mail-Benachrichtigungen hast du zwei Formatoptionen:

• Email-JSON: Sendet den rohen JSON-Payload an den E-Mail-Endpunkt.
• E-Mail: Sendet eine formatierte E-Mail mit dem Betreff und dem Nachrichtentext.

Bild 13 - Anpassung der Nutzlast

Bei SMS-Benachrichtigungen solltest du beachten, dass die Zeichenanzahl auf 160 begrenzt ist. SNS liefert längere Nachrichten, aber sie werden wie mehrere Nachrichten behandelt. Du kannst auch den SMS-Nachrichtentyp auf "Werbe-" oder "Transaktionsnachricht" einstellen, was sich auf die Optimierung der Zustellung auswirkt:

Abbildung 14 - SMS-Optionen

Du weißt jetzt, wie du E-Mail-Benachrichtigungen über die AWS Console versendest und anpasst. Als Nächstes lernst du, wie du das auch mit der CLI und Python machen kannst.

Schritt 3: Verwendung der AWS CLI oder des SDK zur Veröffentlichung von Nachrichten

Die Konsole eignet sich hervorragend für manuelle Tests, aber in der realen Welt wirst du die Nachrichten programmatisch veröffentlichen wollen.

Die AWS-Befehlszeilenschnittstelle (CLI) macht es einfach, SNS-Nachrichten von deinem Terminal oder deinen Automatisierungsskripten aus zu versenden. 

Vorausgesetzt, du hastdie AWS CLI installiert und konfiguriert, führe diesen Befehl aus, um eine Nachricht über die CLI zu veröffentlichen:

aws sns publish --topic-arn "sns-arn" --subject "CLI Notification" --message "Hello from the AWS CLI!"

Abbildung 15 - Veröffentlichung von Nachrichten über AWS CLI

Im Handumdrehen wirst du eine ähnliche Nachricht in deinem Posteingang sehen:

Abbildung 16 - Veröffentlichung von Nachrichten über AWS CLI (2)

Für fortgeschrittene Anwendungen bieten die AWS SDKs programmatischen Zugriff auf SNS in vielen Programmiersprachen. 

Hier ist ein einfaches Beispiel für die Veröffentlichung einer Nachricht mit Python und der Bibliothek boto3:

import boto3

# Initialize the SNS client
sns_client = boto3.client("sns", region_name="eu-central-1")

# Topic ARN (Amazon Resource Name)
topic_arn = "sns-arn"

# Publish a simple message
response = sns_client.publish(
    TopicArn=topic_arn, Message="Hello from Python!", Subject="Python Notification"
)

# Check if the message was sent successfully
if "MessageId" in response:
    print(f"Message published successfully! Message ID: {response['MessageId']}")

Abbildung 17 - Veröffentlichung von Nachrichten über das Python SDK

Auch hier landet die Nachricht sofort in meinem Posteingang:

Abbildung 18 - Veröffentlichung von Nachrichten über Python SDK (2)

Das ist alles, was es zum Veröffentlichen von Nachrichten mit SNS gibt! Du hast jetzt mehrere Möglichkeiten, Benachrichtigungen zu senden, von der einfachen Konsolenschnittstelle bis zur programmatischen Veröffentlichung mit der AWS CLI oder dem SDK. 

> Neu bei AWS Boto in Python? Melde dich für unseren Kurs an, um in kürzester Zeit kompetent zu werden.

Im nächsten Abschnitt werden wir einige fortgeschrittene Funktionen von SNS erkunden, die deine Benachrichtigungen auf die nächste Stufe heben werden.

Erweiterte SNS-Funktionen

Bis jetzt hast du die Grundlagen von SNS gelernt. In diesem Abschnitt lernst du einige fortgeschrittene Funktionen kennen, die SNS wirklich leistungsstark machen.

SNS-Nachrichtenfilterung

Wenn du dieselbe Benachrichtigung an alle Abonnenten schickst, erhalten die Endpunkte oft Nachrichten, die sie nicht interessieren.

Die Nachrichtenfilterung löst dieses Problem, indem sie es den Abonnenten ermöglicht, die Nachrichten, die sie erhalten, anhand von Nachrichtenattributen zu filtern. Stell dir das so vor, als würdest du E-Mail-Filter einrichten - du erstellst Regeln, die bestimmen, welche Nachrichten durchgelassen werden. Bei SNS werden diese Regeln Filterrichtlinien genannt.

Für den Anfang kannst du Filterrichtlinien für deine Abonnements einrichten, damit sie nur relevante Nachrichten erhalten:

Abbildung 19 - Richtlinien für Benachrichtigungsfilter

In diesem Beispiel erhält der Abonnent nur Benachrichtigungen für Nachrichten, die ein Attribut order_value mit einem numerischen Wert von 1500 und mehr haben.

Um eine solche Benachrichtigung zu senden, kannst du den folgenden Python-Code verwenden:

import boto3

# Initialize the SNS client
sns_client = boto3.client("sns", region_name="eu-central-1")

# Topic ARN (Amazon Resource Name)
topic_arn = "arn:aws:sns:eu-central-1:105036517833:TestTopic"

response = sns_client.publish(
    TopicArn=topic_arn,
    Message="A new high-value order has been placed",
    Subject="New Order Notification",
    MessageAttributes={
        "order_value": {"DataType": "Number", "StringValue": "2000"},
        "region": {"DataType": "String", "StringValue": "EU"},
        "category": {"DataType": "String", "StringValue": "Electronics"},
    },
)

print(response)

Das siehst du, nachdem du das Python-Skript ausgeführt hast:

Abbildung 20 - Versenden einer Benachrichtigung über Python

Nur wenn der Wert von order_value 1500 oder höher ist, erhältst du die Benachrichtigung:

Abbildung 21 - Inhalt der Benachrichtigung

Kurz gesagt: Mit Filterrichtlinien kannst du gezielte Benachrichtigungen versenden, ohne deinen Veröffentlichungscode zu ändern. Das Beste daran ist, dass die Filterung auf der Seite von AWS stattfindet und nicht in deiner Anwendung, was die Effizienz verbessert und unnötigen Datenverkehr reduziert.

SNS-Warteschlangen für tote Buchstaben (DLQ)

Selbst bei den zuverlässigsten Systemen kann die Zustellung von Nachrichten manchmal fehlschlagen.

Eine Dead Letter Queue (DLQ) ist eine spezielle Amazon SQS-Warteschlange, in der SNS Nachrichten versenden können, die nicht an ihre Abonnenten zugestellt werden konnten. Das passiert normalerweise, wenn ein Teilnehmer nicht verfügbar ist oder einen Fehler meldet. Anstatt diese fehlgeschlagenen Nachrichten für immer zu verlieren, leitet SNS sie an das DLQ weiter, wo du sie später analysieren oder die Zustellung erneut versuchen kannst.

Das Einrichten eines DLQ umfasst zwei Schritte. Als erstes erstellst du eine SQS-Warteschlange, die als DLQ dient:

Abbildung 22 - Erstellen einer SQS-Warteschlange

Konfiguriere dann dein SNS-Abonnement so, dass es diese Warteschlange für unzustellbare Nachrichten verwendet:

Abbildung 23 - Hinzufügen der Redrive-Richtlinie zur SQS-Warteschlange

Diese Konfiguration erfordert die richtigen Berechtigungen, da SNS in der Lage sein muss, Nachrichten an die SQS-Warteschlange zu senden. In der AWS-Konsole kannst du dies über ein einfaches Kontrollkästchen einrichten, aber wenn du CloudFormation oder andere Infrastructure-as-Code-Tools verwendest, musst du die entsprechenden IAM-Berechtigungen hinzufügen.

Mit einer DLQ kannst du Lieferausfälle überwachen und bei Bedarf Maßnahmen ergreifen. Du könntest zum Beispiel einen Alarm einrichten, der ausgelöst wird, wenn Nachrichten in deinem DLQ auftauchen, um dich auf mögliche Probleme mit deinen Abonnenten aufmerksam zu machen, aber das würde den Rahmen dieses Abschnitts sprengen.

Verwendung von AWS Lambda mit SNS

Lambda-Funktionen eröffnen eine Welt von Möglichkeiten für die Verarbeitung von SNS-Nachrichten.

Wenn du eine Lambda-Funktion für ein SNS-Thema abonnierst, wird die Funktion automatisch ausgelöst, sobald eine Nachricht veröffentlicht wird. Der serverlose Ansatz von Lambda bedeutet, dass du keine Infrastruktur für die Nachrichtenverarbeitung verwalten musst, da sie automatisch auf Basis des Nachrichtenvolumens skaliert.

Um zu beginnen, erstelle zunächst eine Lambda-Funktion:

Abbildung 24 - Erstellen einer Lambda-Funktion

Dann füllst du ihn mit einem ähnlichen Code aus wie diesen:

def lambda_handler(event, context):
    # SNS messages come in the 'Records' array
    for record in event["Records"]:
        # Extract the message
        message = record["Sns"]["Message"]
        subject = record["Sns"]["Subject"]
        timestamp = record["Sns"]["Timestamp"]

        # Process the message
        print(f"Received message: {message}")
        print(f"Subject: {subject}")
        print(f"Timestamp: {timestamp}")

        # Your business logic here
        # For example, store the message in a database
        # or trigger another AWS service
        print("ALL DONE!")

    # Return success
    return {"statusCode": 200, "body": "Message processed successfully"}

Abbildung 25 - Code der Lambda-Funktion

Wenn dein Code fertig ist, klicke auf die Schaltfläche "Trigger hinzufügen", um die Lambda-Funktion mit SNS zu verbinden:

Abbildung 26 - Verbindung zwischen SNS und Lambda

Die Funktion ist jetzt mit der Warteschlange verbunden, was bedeutet, dass du eine Testbenachrichtigung senden kannst:

Abbildung 27 - Testbenachrichtigung

Mit Lambda-Funktionen kannst du die Logs überwachen, d.h. du kannst die letzten Funktionsaufrufe sehen - das Ergebnis des Sendens einer Benachrichtigung:

Abbildung 28 - Lambda-Funktionsprotokolle

Lambda-Funktionen können praktisch alles mit diesen Nachrichten machen - sie in einer Datenbank speichern, andere AWS-Services auslösen, E-Mails versenden oder sogar externe APIs aufrufen. Das macht SNS und Lambda zu einer leistungsstarken Kombination für den Aufbau ereignisgesteuerter Architekturen. Mehr über Lambda-Funktionen erfährst du im Tutorial " Erste Schritte mit AWS Lambda ". 

Als Nächstes lernst du die Grundlagen der SNS-Überwachung und -Protokollierung kennen.

Überwachung und Protokollierung von SNS-Aktivitäten

Um ein zuverlässiges Benachrichtigungssystem zu erhalten, ist es wichtig, dass du deine SNS-Aktivitäten im Auge behältst.

Verwendung von Amazon CloudWatch mit SNS

Amazon CloudWatch bietet eine umfassende Überwachung für alle deine AWS-Services, einschließlich SNS. Wenn du CloudWatch mit SNS einrichtest, erhältst du Einblick in wichtige Betriebsmetriken wie Nachrichtenzustellungsraten, Ausfälle und API-Nutzungsmuster.

Um mit der CloudWatch-Überwachung für SNS zu beginnen, navigiere zur CloudWatch-Konsole in deinem AWS-Konto. Von dort aus kannst du auf die vorkonfigurierten SNS-Metriken zugreifen, die AWS automatisch für dich sammelt.

Zu den wichtigsten SNS-Kennzahlen, die du überwachen solltest, gehören:

• NumberOfMessagesPublished: Verfolgt, wie viele Nachrichten in deinen Themen veröffentlicht werden.
• NumberOfNotificationsDelivered: Zeigt die erfolgreiche Zustellung von Nachrichten an die Abonnenten an.
• NumberOfNotificationsFailed: Hebt fehlgeschlagene Zustellversuche hervor, die auf Konfigurationsprobleme hinweisen könnten.
• PublishSize: Misst die Größe der veröffentlichten Nachrichten und hilft dir, die Servicegrenzen einzuhalten.

Abbildung 29 - Standard Cloudwatch Dashboard für SNS

Durch die Einrichtung von CloudWatch-Alarmen kannst du schnell auf mögliche Probleme reagieren, bevor sie sich auf deine Nutzer auswirken. Du könntest zum Beispiel einen Alarm erstellen, der ausgelöst wird, wenn die Zustellung von Nachrichten einen bestimmten Schwellenwert überschreitet:

1. In der CloudWatch-Konsole navigierst du zum Abschnitt "Alarme".
2. Klicke auf "Alarm erstellen" und wähle die SNS-Metrik aus, die du überwachen möchtest.
3. Lege deinen Schwellenwert fest (z. B. mehr als 5 fehlgeschlagene Lieferungen in 5 Minuten).
4. Konfiguriere Benachrichtigungsaktionen, wie z.B. das Senden eines Alarms an ein Betriebsteam.

Wenn du Bilder den Anweisungen vorziehst, erstelle zunächst einen Alarm für eine Kennzahl, die dich interessiert, z. B. NumberOfNotificationsFailed. Richte Schwellenwerte ein, die den Alarm auslösen:

Bild 30 - Erstellung eines Alarms

Und das war's - der Alarm ist jetzt erstellt und aktiv:

Abbildung 31 - Erstellung eines Alarms (2)

Diese Alarme können den Unterschied ausmachen, ob ein Problem proaktiv angegangen wird oder ob du von unzufriedenen Nutzern davon erfährst.

Überprüfung der SNS-Protokolle

AWS CloudTrail erfasst alle API-Aktivitäten in deinem AWS-Konto, einschließlich der Aktionen, die innerhalb des SNS-Service durchgeführt werden.

Jede Operation, die du an deinen SNS-Themen durchführst - egal ob über die Konsole, die CLI oder das SDK - erzeugt einen Eintrag in den CloudTrail-Protokollen. Diese Protokolle liefern wertvolle Informationen für die Sicherheitsanalyse, die Verfolgung von Ressourcenänderungen und die Prüfung der Einhaltung von Vorschriften.

Um auf SNS-Protokolle in CloudTrail zuzugreifen:

1. Öffne die CloudTrail-Konsole in deinem AWS-Konto (wahrscheinlich musst du einen neuen Trail erstellen).
2. Navigiere zu "Ereignisverlauf", um die letzten SNS-Aktivitäten zu sehen.
3. Filtere die Ereignisse, indem du "Ereignisquelle" auswählst und "sns.amazonaws.com" eingibst.

Auch hier gilt: Wenn dir der Text nicht ausreicht, schau dir die Bilder unten an. Beginne damit, einen neuen Pfad zu erstellen:

Abbildung 32 - Einen neuen Trail erstellen

Filtere dann unter "Ereignisverlauf" die Ereignisse so, dass nur die für SNS enthalten sind:

Abbildung 33 - Filtern von Protokollen

Die Logs werden automatisch in einem S3-Bucket gespeichert, was bedeutet, dass dieser Ansatz eine dauerhafte Speicherung deiner Logs und erweiterte Abfragefunktionen ermöglicht.

> Wie funktioniert die Speicherung auf AWSork? Lies unseren Leitfaden zu S3 und EFS.

Zusammenfassend lässt sich sagen, dass du durch die Kombination von CloudWatch-Metriken mit CloudTrail-Protokollen ein umfassendes Überwachungssystem schaffst, das dazu beiträgt, dass deine SNS-Infrastruktur zuverlässig funktioniert.

Best Practices für die Verwendung von AWS SNS

Du kennst jetzt die grundlegenden und erweiterten Funktionen von AWS SNS. Was noch zu besprechen ist, sind die besten Praktiken für das Erstellen von Themen und das Versenden von Nachrichten.

Sichern von SNS-Themen

Die Sicherheit sollte beim Aufbau deiner SNS-Infrastruktur oberste Priorität haben. Ohne angemessene Kontrollen könnten deine Themen für unbefugte Zugriffe anfällig sein, was ein massives Sicherheitsrisiko darstellt.

AWS Identity and Access Management (IAM) bietet die Tools, die du brauchst, um deine SNS-Themen zu sichern. Beginne damit, Richtlinien zu erstellen, die dem Prinzip der geringsten Privilegien folgen - gewähre nur die spezifischen Berechtigungen, die für jeden Benutzer oder Dienst benötigt werden. Du möchtest zum Beispiel, dass einige Anwendungen nur Nachrichten veröffentlichen, während andere nur Themen abonnieren müssen.

Hier ist ein Beispiel für eine IAM-Richtlinie, die die Veröffentlichung auf ein bestimmtes Thema beschränkt:

{
    "Version": "2012-10-17",
    "Statement": [
        {
            "Effect": "Allow",
            "Action": "sns:Publish",
            "Resource": "sns-arn"
        }
    ]
}

Du kannst auch Themenrichtlinien verwenden, um zu kontrollieren, welche AWS-Konten deine Themen abonnieren können. Das ist besonders wichtig, wenn du Daten über Unternehmensgrenzen hinweg austauschen willst.

Vergiss nicht, die Berechtigungen regelmäßig mit AWS CloudTrail zu überprüfen und nicht mehr benötigte Zugriffe zu entfernen. 

Nachrichtenvolumen verwalten

Ein hohes Nachrichtenaufkommen kann die Abonnenten überfordern, wenn es nicht richtig gehandhabt wird. An dieser Stelle wird die Kombination von SNS mit anderen AWS-Diensten unerlässlich.

Ein beliebtes Muster ist die "Fanout"-Architektur, bei der du Nachrichten in einem SNS-Topic veröffentlichst, das mehrere SQS-Warteschlangen abonniert hat. Jede Warteschlange kann dann in ihrem eigenen Tempo in verschiedene Verarbeitungssysteme eingespeist werden. Das entkoppelt deine Publisher von deinen Konsumenten und bietet einen Puffer bei Traffic-Spitzen.

Wenn du eine Echtzeitverarbeitung benötigst, solltest du in Erwägung ziehen, deine Topics mit Lambda-Funktionen zu versehen. Lambda skaliert automatisch mit deinem Nachrichtenvolumen, sodass du keine Server mehr bereitstellen und verwalten musst.

Die Kosten senken

SNS ist zwar kostengünstig, aber die Kosten können sich schnell summieren, wenn dein Nachrichtenvolumen wächst. Ein paar strategische Entscheidungen können dir helfen, deine Kosten im Griff zu behalten.

Erstens: Sei wählerisch bei deinen Abonnementprotokollen. HTTP/HTTPS-Endpunkte sind in der Regel die kostengünstigste Option. E-Mail-Benachrichtigungen sind zwar praktisch, sollten aber mit Bedacht eingesetzt werden, da sie mit höheren Kosten pro Nachricht verbunden sind.

Das Filtern von Nachrichten ist ein weiteres wirksames Instrument zur Kosteneinsparung. Indem du Filterrichtlinien für deine Abonnements implementierst, stellst du sicher, dass die Nachrichten nur an interessierte Abonnenten zugestellt werden. Wenn du z.B. ein Thema für alle Systemwarnungen hast, möchtest du vielleicht, dass deine Bereitschaftstechniker während ihrer Schicht nur kritische Warnmeldungen erhalten und nicht jede Benachrichtigung:

# Subscribe with a filter policy
response = sns.subscribe(
    TopicArn="sns-arn",
    Protocol="email",
    Endpoint="oncall@example.com",
    Attributes={"FilterPolicy": '{"severity": ["critical"]}'},
)

Überprüfe schließlich regelmäßig deine SNS-Nutzung im AWS Cost Explorer und suche nach Möglichkeiten, Themen zu konsolidieren oder ungenutzte Abonnements zu entfernen. Ungenutzte oder doppelte Ressourcen verursachen nicht nur unnötige Kosten, sondern verkomplizieren auch deine Architektur.

Wenn du diese Best Practices befolgst, wirst du eine SNS-Implementierung schaffen, die sicher, skalierbar und kosteneffizient ist - alles, was du brauchst, um einen zuverlässigen Benachrichtigungsdienst ohne unerwartete Kosten oder Sicherheitsbedenken zu haben.

Zusammenfassung von AWS SNS

Wenn du Echtzeit-Benachrichtigungen für verteilte Anwendungen benötigst, ist AWS SNS genau das Richtige für dich. Sie ist einfach zu bedienen, lässt sich gut mit anderen AWS-Diensten integrieren und lässt sich stufenlos an deine Bedürfnisse anpassen.

Das Publish-Subscribe-Modell in SNS macht es einfach, Benachrichtigungssysteme zu implementieren, die mehrere Kanäle gleichzeitig erreichen können. Von der Erstellung von Themen und der Verwaltung von Abonnenten bis hin zur Implementierung fortgeschrittener Funktionen wie Nachrichtenfilterung und Dead-Letter-Warteschlangen hast du jetzt das Wissen, um eine robuste Benachrichtigungsinfrastruktur aufzubauen.

Du hast auch die wichtigen Aspekte der Überwachung, der Sicherheit und des Kostenmanagements kennengelernt, die sicherstellen, dass deine SNS-Implementierung in Produktionsumgebungen zuverlässig und effizient bleibt.

Da Anwendungen immer häufiger ereignisgesteuerte Architekturen verwenden, werden Dienste wie SNS immer wertvoller. Egal, ob du ein einfaches Alarmsystem oder komplexe Microservices aufbaust, die Muster in diesem Tutorial bilden die Grundlage für eine effektive Kommunikation zwischen deinen Systemkomponenten.

Um mehr über AWS zu erfahren, besuche diese Kurse von DataCamp:

• Einführung in AWS
• AWS Cloud Technologie und Dienste
• AWS Sicherheit und Kostenmanagement

Du kannst dich mit DataCamp sogar auf die AWS-Zertifizierungsprüfungen vorbereiten - AWS Cloud Practitioner (CLF-C02).