AWS SNS: De complete gids voor realtime meldingen

AWS SNS instellen

Voordat je je eerste melding met SNS kunt versturen, moet je een paar stappen doorlopen om alles gereed te maken.

Stap 1: Een AWS-account aanmaken

Als je nog geen AWS-account hebt, moet je er een aanmaken voordat je SNS kunt gebruiken.

Ga naar de AWS-homepage en klik rechtsboven op de knop "Create an AWS Account". Je moet je e-mailadres opgeven, een wachtwoord aanmaken en enkele basisgegevens invullen. AWS vraagt ook om je creditcardgegevens—maak je geen zorgen, SNS heeft een vrij royaal gratis tier en je wordt pas gefactureerd als je die limieten overschrijdt.

Zodra je account is ingesteld, kun je verder. Ik raad echter sterk aan om een aparte IAM-gebruiker te maken in plaats van je rootaccount te gebruiken. Dat valt buiten de scope van dit artikel, maar verwijs naar de officiële instructies voor uitgebreide richtlijnen.

Stap 2: SNS instellen in de AWS Management Console

Nu je een AWS-account hebt, is het tijd om de SNS-service te openen.

Log in op de AWS Management Console met je inloggegevens en zoek SNS. Dat kan op drie manieren:

• Typ "SNS" in de zoekbalk bovenin de console
• Klik op "Services" in de bovenste navigatiebalk en zoek SNS onder de categorie "Application Integration"
• Ga direct naar de SNS-console

Hoe je er ook komt, dit is het scherm dat je zou moeten zien:

Afbeelding 1 - AWS SNS-servicepagina

Eenmaal in het SNS-dashboard zie je links een menu met opties zoals "Topics", "Subscriptions" en "Mobile". Het dashboard geeft een overzicht van je SNS-resources en recente activiteit.

Voor een nieuw account is dit behoorlijk leeg—dat is te verwachten. Laten we nu ons eerste SNS-topic aanmaken.

Stap 3: Een SNS-topic aanmaken

Een SNS-topic is in feite een communicatiekanaal waar publishers berichten naartoe sturen en subscribers naar luisteren.

Denk aan een radiostation: het station zendt uit op een specifieke frequentie (het topic), en iedereen die daarop is afgestemd, ontvangt de uitzending. In SNS-terminologie publiceert je applicatie berichten naar een topic en alle endpoints die op dat topic geabonneerd zijn, ontvangen die berichten.

Zo maak je je eerste SNS-topic aan:

1. Voer op het scherm dat je zag in Afbeelding 1 een topicnaam in.
2. Klik op de knop "Next step".
3. Selecteer "Standard" voor het type (FIFO-topics hebben andere use-cases die we later behandelen).
4. (Optioneel) Voer een displaynaam in. Deze wordt opgenomen in berichten die naar sms- of e-mail-subscribers worden gestuurd.
5. Laat alle andere instellingen voorlopig op de standaardwaarden staan.
6. Klik op "Create topic".

Ben je meer van de plaatjes? Zo zou je scherm eruit moeten zien:

Afbeelding 2 - SNS-topic aanmaken

Als je tevreden bent met de waarden, scroll naar beneden tot je de knop "Create topic" ziet:

Afbeelding 3 - SNS-topic aanmaken (2)

En dat is het! Je SNS-topic is nu klaar voor gebruik. Je ziet details zoals de topic ARN (Amazon Resource Name), die je topic uniek identificeert:

Afbeelding 4 - Gemaakte topicdetails

Je nieuwe topic is klaar voor subscriptions, maar heeft er nog geen, wat betekent dat berichten nergens heen gaan. Geen zorgen—dat los je in de volgende sectie op wanneer je subscribers toevoegt.

SNS-subscribers en subscriptions

Zoals ik eerder zei, is je SNS-topic als een radiostation. Het heeft nu nog geen luisteraars, maar dat verandert zodra je subscribers toevoegt om je berichten te ontvangen.

Wat is een SNS-subscriber?

Een subscriber is elk endpoint dat meldingen ontvangt van je SNS-topic wanneer een bericht wordt gepubliceerd.

Denk aan de analogie van een nieuwsbrief. Elke keer dat je een nieuwe editie (bericht) publiceert, wordt die bezorgd bij iedereen op je mailinglijst. SNS automatiseert en schaalt dit proces, en regelt de volledige bezorglogistiek voor je.

AWS ondersteunt een breed scala aan subscribe-typen, wat je flexibiliteit geeft in hoe je berichten worden verwerkt. De belangrijkste typen:

• E-mailadressen: Stuur platte-tekstmeldingen rechtstreeks naar inboxen.
• Sms-nummers: Lever tekstberichten aan mobiele telefoons.
• SQS-queues: Routeer berichten naar andere AWS-services voor verdere verwerking.
• Lambda-functies: Trigger serverloze code-uitvoering als reactie op meldingen.
• HTTP/HTTPS-endpoints: Stuur berichten naar webapplicaties of API's.
• Mobiele push: Lever meldingen rechtstreeks aan mobiele apps.

Elk subscribertype heeft eigen voordelen en use-cases. E-mail en sms zijn bijvoorbeeld ideaal voor menselijke ontvangers, terwijl SQS-queues en Lambda-functies beter zijn voor systeem-naar-systeem-communicatie.

Stap 1: Een subscriber toevoegen

Nu je weet wat subscribers zijn, voegen we er één toe aan je topic. Voor deze tutorial gebruik ik e-mail omdat dat het eenvoudigst is om op te zetten.

Zo voeg je een e-mail-subscriber toe aan je SNS-topic:

1. Klik op de detailpagina van je topic (die uit Afbeelding 4) op de knop "Create subscription".
2. Selecteer in de dropdown "Protocol" de optie "Email".
3. Vul in het veld "Endpoint" het e-mailadres in dat meldingen moet ontvangen.
4. Laat alle andere instellingen op de standaardwaarden staan.
5. Klik op "Create subscription".

Je scherm zou er ongeveer zo uit moeten zien:

Afbeelding 5 - Een e-mailabonnement aanmaken

Zodra je op "Create subscription" klikt, voegt AWS de subscription toe aan je topic, maar in de status "pending confirmation":

Afbeelding 6 - Status in afwachting van bevestiging

Dit is een belangrijke beveiligingsfunctie: AWS wil zeker weten dat de eigenaar van het e-mailadres deze meldingen inderdaad wil ontvangen.

Stap 2: Subscriptions bevestigen

Na het toevoegen van een subscriber moet die bevestigen dat hij meldingen van je SNS-topic wil ontvangen.

Voor e-mailabonnementen stuurt AWS automatisch een bevestigingsmail naar het opgegeven adres. De e-mail bevat een link waarop de ontvanger moet klikken om het abonnement te activeren. Totdat dit gebeurt, worden geen berichten die naar het topic worden gepubliceerd aan dit endpoint geleverd.

Zo ziet een typische bevestigingsmail eruit:

Afbeelding 7 - SNS-bevestigingsmail

De ontvanger hoeft alleen op de link "Confirm subscription" in de e-mail te klikken. Er verschijnt dan een pagina die bevestigt dat het abonnement nu actief is:

Afbeelding 8 - Bericht met abonnementsbevestiging

Het proces is vergelijkbaar voor sms-subscribers—AWS stuurt een tekstbericht met een bevestigingslink die de ontvanger moet volgen. HTTP/HTTPS-endpoints moeten reageren op een bevestigingsverzoek van AWS, terwijl AWS-resources zoals Lambda-functies en SQS-queues geconfigureerd kunnen worden voor automatische bevestiging.

Je kunt de status van je subscriptions controleren door in de linkerzijbalk van de SNS-console op "Subscriptions" te klikken. Bevestigde subscriptions tonen de status "Confirmed", terwijl wachtende "Pending confirmation" tonen.

Afbeelding 9 - Abonnementsstatus

Zodra je abonnement is bevestigd, kun je berichten gaan sturen! Elk bericht dat naar het topic wordt gepubliceerd, wordt geleverd aan alle bevestigde subscribers via hun gekozen protocol.

Dat is alles wat nodig is om SNS-subscriptions op te zetten. In de volgende sectie leer je hoe je berichten naar je topic publiceert en test of je subscribers ze correct ontvangen.

Berichten publiceren naar SNS-topics

Nu je je SNS-topic hebt ingesteld en subscribers hebt toegevoegd, is het tijd om je eerste melding te versturen.

Stap 1: Een bericht publiceren

Een goede manier om te beginnen is door een bericht via de AWS Console te publiceren.

Ga naar de detailpagina van je topic en klik rechtsboven op de knop "Publish message" (zie Afbeelding 4). Hiermee open je het publicatieformulier waarin je je melding kunt opstellen. Je ziet velden voor het onderwerp en de berichttekst. Het onderwerp is optioneel, maar handig voor e-mailmeldingen, omdat het de onderwerpregel van de e-mail wordt.

Voor een eenvoudige test kun je zoiets invullen:

Afbeelding 10 - Inhoud van het eerste bericht

Als je tevreden bent met je bericht, scroll dan naar beneden en klik onderaan het formulier op de knop "Publish message":

Afbeelding 11 - Een bericht publiceren via de console

Na het klikken distribueert SNS je bericht direct naar alle bevestigde subscribers. Als je een e-mailabonnement hebt ingesteld, zou je het testbericht binnen enkele seconden in je inbox moeten ontvangen:

Afbeelding 12 - Bericht ontvangen via e-mail

Simpel, toch? Laten we nu kijken hoe je dit verder kunt aanpassen.

Stap 2: Sms- en e-mailmeldingen versturen

SNS laat je aanpassen hoe je berichten eruitzien voor verschillende typen subscribers.

Bij het publiceren zie je de optie "Message structure". Standaard staat die op "Identical payload for all delivery protocols", wat betekent dat alle subscribers exact hetzelfde bericht ontvangen. Je kunt ook "Custom payload for each delivery protocol" kiezen, zodat je het berichtformaat per subscribertype kunt afstemmen.

Voor e-mailmeldingen heb je twee indelingsopties:

• Email-JSON: Stuurt de ruwe JSON-payload naar het e-mailendpoint.
• Email: Stuurt een opgemaakte e-mail met onderwerp en berichttekst.

Afbeelding 13 - Payload aanpassen

Voor sms-meldingen geldt een limiet van 160 tekens. SNS levert langere berichten wel, maar ze tellen dan als meerdere berichten. Je kunt ook het sms-berichttype instellen op "Promotional" of "Transactional", wat invloed heeft op de optimalisatie van de levering:

Afbeelding 14 - Sms-opties

Je weet nu hoe je e-mailmeldingen via de AWS Console verstuurt en aanpast. Straks leer je hetzelfde via de CLI en Python.

Stap 3: De AWS CLI of SDK gebruiken om berichten te publiceren

De console is geweldig voor handmatige tests, maar in de praktijk wil je berichten programmatisch publiceren.

Met de AWS Command Line Interface (CLI) kun je eenvoudig SNS-berichten versturen vanuit je terminal of automatiseringsscripts. 

Als je de AWS CLI hebt geïnstalleerd en geconfigureerd, voer dan dit commando uit om een bericht via de CLI te publiceren:

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

Afbeelding 15 - Berichten publiceren via AWS CLI

Binnen een oogwenk zie je een vergelijkbaar bericht in je inbox:

Afbeelding 16 - Berichten publiceren via AWS CLI (2)

Voor geavanceerdere toepassingen bieden de AWS SDK's programmatische toegang tot SNS in veel programmeertalen. 

Hier is een eenvoudig voorbeeld om een bericht te publiceren met Python en de boto3-bibliotheek:

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']}")

Afbeelding 17 - Berichten publiceren via de Python SDK

Wederom wordt het bericht direct aan mijn inbox geleverd:

Afbeelding 18 - Berichten publiceren via de Python SDK (2)

Dat is alles wat erbij komt kijken om berichten te publiceren met SNS! Je hebt nu meerdere manieren om meldingen te sturen, van de eenvoudige console-interface tot programmatisch publiceren met de AWS CLI of SDK. 

> Nieuw met AWS Boto in Python? Schrijf je in voor onze cursus en word razendsnel vaardig.

In de volgende sectie verkennen we enkele geavanceerde functies van SNS die je meldingen naar een hoger niveau tillen.

Geavanceerde SNS-functies

Tot nu toe heb je de basis van SNS geleerd. In deze sectie bekijken we een paar geavanceerde functies die SNS echt krachtig maken.

SNS-berichtfiltering

Hetzelfde bericht naar alle subscribers sturen zorgt er vaak voor dat endpoints berichten ontvangen die niet relevant zijn.

Berichtfiltering lost dit op door subscribers toe te staan te filteren welke berichten ze ontvangen op basis van berichtattributen. Zie het als e-mailfilters instellen—je maakt regels die bepalen welke berichten doorkomen. Voor SNS heten deze regels filter policies.

Je kunt filter policies instellen op je subscriptions zodat ze alleen relevante berichten ontvangen:

Afbeelding 19 - Filter policies voor meldingen

In dit voorbeeld ontvangt de subscriber alleen meldingen voor berichten met een attribuut order_value met een numerieke waarde van 1500 of hoger.

Om zo'n melding te versturen, kun je de volgende Python-code gebruiken:

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)

Dit is wat je ziet na het uitvoeren van het Python-script:

Afbeelding 20 - Een melding versturen met Python

Alleen als de waarde van order_value 1500 of hoger is, ontvang je de melding:

Afbeelding 21 - Inhoud van de melding

Kortom, met filter policies kun je gerichte meldingen sturen zonder je publicatiecode te wijzigen. Het beste is dat filtering aan de AWS-kant gebeurt, niet in je applicatie, wat efficiënter is en onnodig verkeer vermindert.

SNS dead-letter queues (DLQ)

Zelfs bij de meest betrouwbare systemen kan berichtbezorging soms falen.

Een Dead Letter Queue (DLQ) is een speciale Amazon SQS-queue waar SNS berichten naartoe kan sturen die niet aan hun subscribers konden worden geleverd. Dit gebeurt doorgaans wanneer een subscriber niet beschikbaar is of een fout retourneert. In plaats van deze mislukte berichten voorgoed kwijt te raken, leidt SNS ze om naar de DLQ, waar je ze later kunt analyseren of opnieuw kunt proberen te leveren.

Het instellen van een DLQ bestaat uit twee stappen. Maak eerst een SQS-queue aan die als DLQ dient:

Afbeelding 22 - Een SQS-queue aanmaken

Configureer vervolgens je SNS-subscription om deze queue te gebruiken voor niet-leverbare berichten:

Afbeelding 23 - Redrive policy toevoegen aan de SQS-queue

Deze configuratie vereist de juiste permissies, omdat SNS berichten naar de SQS-queue moet kunnen sturen. In de AWS-console kun je dit met een simpel selectievakje instellen, maar als je CloudFormation of andere infrastructure-as-code tools gebruikt, moet je de juiste IAM-permissies toevoegen.

Met een DLQ kun je leveringsfouten monitoren en indien nodig actie ondernemen. Je kunt bijvoorbeeld een alarm instellen dat afgaat wanneer er berichten in je DLQ verschijnen, zodat je wordt gewaarschuwd voor mogelijke problemen bij subscribers—maar dat valt buiten de scope van deze sectie.

AWS Lambda gebruiken met SNS

Lambda-functies openen een wereld aan mogelijkheden voor het verwerken van SNS-berichten.

Wanneer je een Lambda-functie abonneert op een SNS-topic, wordt de functie automatisch getriggerd telkens wanneer een bericht wordt gepubliceerd. Dankzij de serverloze aanpak van Lambda hoef je geen infrastructuur te beheren voor berichtverwerking; het schaalt automatisch mee met het aantal berichten.

Begin met het aanmaken van een Lambda-functie:

Afbeelding 24 - Een Lambda-functie aanmaken

Vul deze vervolgens met code zoals dit:

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"}

Afbeelding 25 - Code van de Lambda-functie

Als je code klaar is, klik je op de knop "Add trigger" om de Lambda-functie met SNS te verbinden:

Afbeelding 26 - SNS koppelen aan Lambda

De functie is nu gekoppeld aan de queue, wat betekent dat je een testmelding kunt sturen:

Afbeelding 27 - Testmelding

Lambda-functies bieden logmonitoring, wat betekent dat je recente functieaanroepen kunt bekijken—het resultaat van het versturen van een melding:

Afbeelding 28 - Lambda-functielogs

Lambda-functies kunnen vrijwel alles met deze berichten doen: ze opslaan in een database, andere AWS-services triggeren, e-mails versturen of zelfs externe API's aanroepen. Dat maakt SNS en Lambda samen tot een krachtige combinatie voor event-driven architecturen. Je kunt meer over Lambda-functies leren in de tutorial Aan de slag met AWS Lambda. 

Straks leer je de basis van SNS-monitoring en -logging.

SNS-activiteit monitoren en loggen

Het bijhouden van je SNS-activiteit is essentieel om een betrouwbaar notificatiesysteem te onderhouden.

Amazon CloudWatch gebruiken met SNS

Amazon CloudWatch biedt uitgebreide monitoring voor al je AWS-services, inclusief SNS. Door CloudWatch met SNS in te richten, krijg je zicht op belangrijke operationele metrics zoals berichtleveringspercentages, fouten en API-gebruikspatronen.

Om te beginnen met CloudWatch-monitoring voor SNS, ga je naar de CloudWatch-console in je AWS-account. Daar heb je toegang tot de vooraf geconfigureerde SNS-metrics die AWS automatisch voor je verzamelt.

De meest waardevolle SNS-metrics om te monitoren zijn onder andere:

• NumberOfMessagesPublished: Houdt bij hoeveel berichten naar je topics worden gepubliceerd.
• NumberOfNotificationsDelivered: Toont succesvolle berichtleveringen aan subscribers.
• NumberOfNotificationsFailed: Benadrukt mislukte leveringspogingen, wat kan wijzen op configuratieproblemen.
• PublishSize: Meet de grootte van gepubliceerde berichten, zodat je binnen servicelimieten blijft.

Afbeelding 29 - Standaard CloudWatch-dashboard voor SNS

Het instellen van CloudWatch-alarms stelt je in staat snel te reageren op potentiële problemen voordat ze je gebruikers raken. Je kunt bijvoorbeeld een alarm maken dat afgaat wanneer mislukte leveringen een bepaalde drempel overschrijden:

1. Ga in de CloudWatch-console naar de sectie "Alarms".
2. Klik op "Create alarm" en selecteer de SNS-metric die je wilt monitoren.
3. Definieer je drempel (bijv. meer dan 5 mislukte leveringen in 5 minuten).
4. Configureer notificatieacties, zoals het sturen van een alert naar een operations-team.

Als je liever afbeeldingen volgt: begin met het aanmaken van een alarm voor een interessante metric, zoals NumberOfNotificationsFailed. Stel de drempels in die het alarm activeren:

Afbeelding 30 - Alarm aanmaken

En dat is het—het alarm is nu aangemaakt en actief:

Afbeelding 31 - Alarm aanmaken (2)

Deze alarms kunnen het verschil maken tussen proactief een probleem aanpakken en er pas via ontevreden gebruikers achter komen.

SNS-logs bekijken

AWS CloudTrail legt alle API-activiteit in je AWS-account vast, inclusief acties binnen de SNS-service.

Elke bewerking op je SNS-topics—of die nu via de console, CLI of SDK gebeurt—genereert een entry in CloudTrail-logs. Deze logs bieden waardevolle informatie voor beveiligingsanalyse, het bijhouden van resourcewijzigingen en compliance-audits.

Zo krijg je toegang tot SNS-logs in CloudTrail:

1. Open de CloudTrail-console in je AWS-account (waarschijnlijk moet je een nieuwe trail aanmaken).
2. Ga naar "Event history" om recente SNS-activiteit te bekijken.
3. Filter de events door "Event source" te selecteren en "sns.amazonaws.com" te typen.

Als tekstinstructies niet genoeg zijn, bekijk dan de onderstaande afbeeldingen. Begin met het aanmaken van een nieuwe trail:

Afbeelding 32 - Een nieuwe trail aanmaken

Filter vervolgens onder "Event history" de events zodat alleen die voor SNS overblijven:

Afbeelding 33 - Logs filteren

Logs worden automatisch opgeslagen in een S3-bucket, wat betekent dat deze aanpak permanente opslag biedt en geavanceerder queryen mogelijk maakt.

> Hoe werkt opslag op AWS? Lees onze gids over S3 en EFS.

Kortom, door CloudWatch-metrics te combineren met CloudTrail-logs creëer je een uitgebreid monitoringsysteem dat helpt je SNS-infrastructuur betrouwbaar te laten draaien.

Best practices voor het gebruik van AWS SNS

Je kent nu de basis- en geavanceerde functies van AWS SNS. Wat rest zijn de best practices voor het aanmaken van topics en het versturen van berichten.

SNS-topics beveiligen

Beveiliging moet een topprioriteit zijn bij het inrichten van je SNS-infrastructuur. Zonder de juiste controles kunnen je topics kwetsbaar zijn voor ongeautoriseerde toegang—een enorm beveiligingsrisico.

AWS Identity and Access Management (IAM) biedt de tools die je nodig hebt om je SNS-topics te beveiligen. Begin met policies die het principe van least privilege volgen—geef alleen de specifieke permissies die nodig zijn voor elke gebruiker of service. Zo wil je sommige applicaties misschien alleen laten publiceren, terwijl andere alleen hoeven te abonneren op topics.

Hier is een voorbeeld van een IAM-policy die publiceren naar een specifiek topic beperkt:

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

Je kunt ook topic policies gebruiken om te bepalen welke AWS-accounts zich op je topics mogen abonneren. Dit is vooral belangrijk als je data over organisatorische grenzen heen deelt.

Vergeet niet regelmatig permissies te auditen met AWS CloudTrail en toegang te verwijderen die niet langer nodig is. 

Berichtvolume beheren

Hoge berichtvolumes kunnen subscribers overweldigen als je ze niet goed afhandelt. Dit is waar het combineren van SNS met andere AWS-services essentieel wordt.

Een populair patroon is de "fanout"-architectuur, waarbij je berichten publiceert naar een SNS-topic met meerdere SQS-queues als subscribers. Elke queue kan dan verschillende verwerkingssystemen voeden op hun eigen tempo. Dit ontkoppelt je publishers van je consumers en biedt een buffer tijdens piekbelasting.

Voor realtime verwerkingsbehoeften kun je Lambda-functies abonneren op je topics. Lambda schaalt automatisch mee met je berichtvolume, zodat je geen servers hoeft te voorzien of te beheren.

Kosten verlagen

SNS is kosteneffectief, maar de kosten kunnen snel oplopen naarmate je berichtvolume groeit. Met een paar strategische keuzes houd je de kosten in toom.

Wees om te beginnen selectief met je subscription-protocollen. HTTP/HTTPS-endpoints zijn over het algemeen het meest kosteneffectief. E-mailmeldingen zijn handig, maar gebruik ze met beleid omdat ze hogere kosten per bericht met zich meebrengen.

Berichtfiltering is nog een krachtige manier om kosten te besparen. Door filter policies op je subscriptions te implementeren, zorg je dat berichten alleen worden geleverd aan geïnteresseerde subscribers. Als je bijvoorbeeld een topic hebt voor alle systeemberichten, wil je misschien dat je on-call engineers tijdens hun shift alleen kritieke alerts ontvangen, niet elke melding:

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

Controleer tot slot regelmatig je SNS-gebruik in de AWS Cost Explorer en zoek naar mogelijkheden om topics te consolideren of ongebruikte subscriptions te verwijderen. Ongebruikte of dubbele resources verhogen niet alleen onnodig de kosten, maar maken je architectuur ook complexer.

Door deze best practices te volgen, bouw je een SNS-implementatie die veilig, schaalbaar en kosteneffectief is—alles wat je nodig hebt voor een betrouwbare notificatieservice zonder onverwachte kosten of beveiligingszorgen.

AWS SNS samengevat

Als je realtime meldingen nodig hebt voor gedistribueerde applicaties, zoek dan niet verder dan AWS SNS. Het is eenvoudig te gebruiken, integreert goed met andere AWS-services en schaalt onbeperkt mee met je behoeften.

Het publish-subscribe-model in SNS maakt het eenvoudig om notificatiesystemen te implementeren die meerdere kanalen tegelijk kunnen bereiken. Van topics aanmaken en subscribers beheren tot geavanceerde functies zoals berichtfiltering en dead-letter queues—je hebt nu de kennis om een robuuste notificatie-infrastructuur te bouwen.

Je hebt ook geleerd over de cruciale aspecten van monitoring, beveiliging en kostenbeheer die ervoor zorgen dat je SNS-implementatie betrouwbaar en efficiënt blijft in productieomgevingen.

Naarmate applicaties meer event-driven architecturen omarmen, worden services zoals SNS steeds waardevoller. Of je nu een eenvoudig alert-systeem bouwt of complexe microservices, de patronen in deze tutorial vormen een basis voor effectieve communicatie tussen je systeemcomponenten.

Wil je meer leren over AWS? Volg deze cursussen van DataCamp:

• Introductie tot AWS
• AWS Cloud Technology and Services
• AWS Security and Cost Management

Je kunt met DataCamp zelfs voorbereiden op AWS-certificeringen—AWS Cloud Practitioner (CLF-C02).