Lambda med SQS-/SNS-utløsere
Konfigurer Lambda-funksjoner til å utløses av SQS-køer og SNS-emner, slik at du kan opprette effektive hendelsesdrevne arbeidsflyter.
Lambda med SQS-/SNS-utløsere er en gratis leksjon i Serverløs backend med AWS Lambda & API Gateway på CoddyKit. Dette er leksjon 3 av 4. Du kan lese hele leksjonen gratis nedenfor – og deretter øve praktisk i nettleseren med en innebygd kodeeditor og en AI-veileder som er tilgjengelig døgnet rundt. Den er en del av læringsløpet i Serverløs backend med AWS Lambda & API Gateway, og fremdriften din synkroniseres mellom nettet og CoddyKit-appen. Kurset i Serverløs backend med AWS Lambda & API Gateway inneholder totalt 4 leksjoner.
Hendelsesdrevne Lambda-utløsere
Lambda-funksjoner står sentralt i serverless, men hvordan vet de når de skal kjøre? De reagerer på hendelser!
En hendelse er alt som skjer i AWS-miljøet ditt, for eksempel at en fil lastes opp til S3, at et nytt element legges til i DynamoDB, eller, i denne leksjonen, at en melding ankommer i SQS eller SNS.
Ved å bruke SQS og SNS til å utløse Lambda kan du bygge kraftige hendelsesdrevne arkitekturer. Det betyr at tjenester kommuniserer gjennom hendelser, slik at systemene blir mer fleksible og skalerbare.
SQS-utløsere for Lambda
Amazon SQS (Simple Queue Service) er en administrert meldingstjeneste med køer. Når du konfigurerer en SQS-kø som en Lambda-utløser, poller Lambda køen etter meldinger.
Slik fungerer det:
- Lambda kontrollerer SQS-køen kontinuerlig.
- Når meldinger er tilgjengelige, henter Lambda en batch av dem.
- Deretter aktiverer Lambda funksjonen din for hver batch eller for enkeltmeldinger, avhengig av konfigurasjonen.
- Etter vellykket behandling sletter Lambda meldingene fra køen.
Konfigurere en SQS-utløser
For å koble en SQS-kø til en Lambda-funksjon gjør du dette vanligvis via AWS Management Console, AWS CLI eller Infrastructure as Code (for eksempel AWS SAM eller CloudFormation).
Viktige konfigurasjoner omfatter:
- Batch size: Hvor mange meldinger Lambda henter om gangen (for eksempel 1 til 10).
- Batch window: Hvor lenge Lambda venter på å samle en batch (opptil 5 minutter).
- Polling frequency: Lambda administrerer dette automatisk.
Dette oppsettet gjør at funksjonen din kan behandle meldinger asynkront og frakobler meldingsprodusenten fra konsumenten.
Behandle SQS-meldinger
Lambda-funksjonen din mottar SQS-meldinger i et event-objekt. Dette objektet inneholder en Records-array, der hvert element er en SQS-melding.
La oss se på et enkelt Python-eksempel som behandler meldinger fra en SQS-kø. Se for deg at disse meldingene inneholder bruker-ID-er som skal behandles.
import json
def lambda_handler(event, context):
print("Received SQS event:")
for record in event['Records']:
message_body = record['body']
print(f"Processing message: {message_body}")
# Example: parse JSON body if expected
try:
data = json.loads(message_body)
user_id = data.get('userId')
print(f"Extracted userId: {user_id}")
# Add your business logic here
except json.JSONDecodeError:
print(f"Message body is not valid JSON: {message_body}")
return {
'statusCode': 200,
'body': json.dumps('Messages processed successfully!')
}
# --- For local testing (simulated event) ---
if __name__ == '__main__':
# Simulate an SQS event
simulated_sqs_event = {
"Records": [
{
"messageId": "19dd0b57-b21e-4ac1-bd88-01bbb068cb78",
"receiptHandle": "AQEBwJnKyrgtLvC5...",
"body": '{"userId": "user123", "action": "signup"}',
"attributes": {
"ApproximateReceiveCount": "1",
"SentTimestamp": "1523232000000",
"SenderId": "AIDAIY234234234234234",
"ApproximateFirstReceiveTimestamp": "1523232000001"
},
"messageAttributes": {},
"md5OfBody": "098f6bcd4621d373cade4e832627b4f6",
"eventSource": "aws:sqs",
"eventSourceARN": "arn:aws:sqs:us-east-1:123456789012:my-queue",
"awsRegion": "us-east-1"
},
{
"messageId": "19dd0b57-b21e-4ac1-bd88-01bbb068cb79",
"receiptHandle": "AQEBwJnKyrgtLvC5...",
"body": '{"userId": "user456", "action": "login"}',
"attributes": {
"ApproximateReceiveCount": "1",
"SentTimestamp": "1523232000000",
"SenderId": "AIDAIY234234234234234",
"ApproximateFirstReceiveTimestamp": "1523232000001"
},
"messageAttributes": {},
"md5OfBody": "098f6bcd4621d373cade4e832627b4f6",
"eventSource": "aws:sqs",
"eventSourceARN": "arn:aws:sqs:us-east-1:123456789012:my-queue",
"awsRegion": "us-east-1"
}
]
}
lambda_handler(simulated_sqs_event, None)Detaljer om SQS-hendelser
La oss se nærmere på de viktigste delene av en SQS-hendelse som sendes til Lambda-funksjonen din:
event['Records']: En liste over SQS-meldinger. Funksjonen din går gjennom denne listen.record['body']: Selve meldingsinnholdet, vanligvis en JSON-streng som du må analysere.record['messageId']: En unik ID for meldingen. Nyttig for logging og idempotens.record['attributes']: Inneholder metadata somSentTimestamp.record['eventSource']: Alltid «aws:sqs» for SQS-utløsere.
Gå alltid ut fra at body er en streng, og analyser den hvis du forventer JSON.
SNS-utløsere for Lambda
Amazon SNS (Simple Notification Service) er en fullstendig administrert pub/sub-meldingstjeneste. I motsetning til SQS bruker SNS en push-modell for å levere varsler.
Når et SNS-emne mottar en melding, sender det meldingen umiddelbart til alle abonnerte endepunkter, som kan inkludere Lambda-funksjoner.
Dette passer perfekt til:
- Fan-out-scenarioer (én melding utløser flere handlinger).
- Utsending av varsler eller meldinger.
- Frakobling av utgivere fra flere abonnenter.
Konfigurere en SNS-utløser
Det er enkelt å koble et SNS-emne til en Lambda-funksjon. De abonnerer Lambda-funksjonen på SNS-emnet.
Fremgangsmåte:
- Opprett et SNS-emne.
- Opprett Lambda-funksjonen.
- Legg til en SNS-utløser for Lambda-funksjonen, og velg emnet.
- Kontroller at kjøringsrollen for Lambda har tillatelse til å bli kalt av SNS.
Når dette er konfigurert, vil alle meldinger som publiseres til SNS-emnet, automatisk kalle Lambda-funksjonen.
Behandle SNS-varsler
Når Lambda-funksjonen utløses av SNS, mottar den et event-objekt som inneholder detaljer om varslingen. Den viktigste delen er feltet Message i Sns-objektet.
Her er et Python-eksempel som logger et SNS-varsel.
import json
def lambda_handler(event, context):
print("Received SNS event:")
for record in event['Records']:
sns_message = record['Sns']
message_id = sns_message['MessageId']
topic_arn = sns_message['TopicArn']
subject = sns_message.get('Subject', 'No Subject')
message_body = sns_message['Message']
timestamp = sns_message['Timestamp']
print(f"Message ID: {message_id}")
print(f"Topic ARN: {topic_arn}")
print(f"Subject: {subject}")
print(f"Message: {message_body}")
print(f"Timestamp: {timestamp}")
# Add your business logic here, e.g., send an email, update a database
return {
'statusCode': 200,
'body': json.dumps('SNS notification processed!')
}
# --- For local testing (simulated event) ---
if __name__ == '__main__':
# Simulate an SNS event
simulated_sns_event = {
"Records": [
{
"EventSource": "aws:sns",
"EventVersion": "1.0",
"EventSubscriptionArn": "arn:aws:sns:us-east-1:123456789012:my-topic:xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx",
"Sns": {
"Type": "Notification",
"MessageId": "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx",
"TopicArn": "arn:aws:sns:us-east-1:123456789012:my-topic",
"Subject": "New Order Confirmation",
"Message": "{\"orderId\": \"ORD-789\", \"customer\": \"Jane Doe\"}",
"Timestamp": "2023-10-27T10:00:00.000Z",
"SignatureVersion": "1",
"Signature": "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx",
"SigningCertUrl": "https://sns.us-east-1.amazonaws.com/SimpleNotificationService-xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx.pem",
"UnsubscribeUrl": "https://sns.us-east-1.amazonaws.com/?Action=Unsubscribe&SubscriptionArn=arn:aws:sns:us-east-1:123456789012:my-topic:xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx",
"MessageAttributes": {
"EventType": {"Type": "String", "Value": "OrderCreated"}
}
}
}
]
}
lambda_handler(simulated_sns_event, None)Detaljer om SNS-hendelser
I likhet med SQS inneholder også SNS-hendelsen en Records-matrise, men strukturen inni er annerledes:
event['Records']: En liste som vanligvis inneholder ett SNS-varsel per kjøring.record['Sns']: Dette objektet inneholder de viktigste detaljene om varslingen.record['Sns']['MessageId']: Unik ID for SNS-meldingen.record['Sns']['TopicArn']: ARN-en til SNS-emnet som publiserte meldingen.record['Sns']['Subject']: Emnet for varslingen (valgfritt).record['Sns']['Message']: Det faktiske innholdet i varslingen, ofte en JSON-streng.
Husk å tolke Message hvis du forventer strukturerte data.
Beste praksis for utløsere
Ha disse anbefalte fremgangsmåtene i tankene når du bruker SQS og SNS til å utløse Lambda:
- Idempotens: Utform Lambda slik at den håndterer dupliserte meldinger uten utilsiktede bivirkninger, siden meldinger noen ganger kan leveres mer enn én gang.
- Feilhåndtering: Konfigurer en Dead-Letter Queue (DLQ) for Lambda-funksjonen som utløses av SQS. Mislykkede meldinger sendes dit for senere undersøkelse.
- Batchbehandling: Behandle SQS-meldinger effektivt i grupper. Hvis én melding i en gruppe mislykkes, kan hele gruppen bli forsøkt på nytt.
- Tillatelser: Kontroller at kjøringsrollen for Lambda har tillatelse til å få tilgang til SQS/SNS og andre tjenester den samhandler med.
Quiz om utløsere for Lambda
Test kunnskapene dine om SQS- og SNS-utløsere for Lambda!
Oppsummering og neste steg
Godt jobbet! Du har lært hvordan du kan utnytte kraften i hendelsesstyring ved å integrere Lambda med SQS og SNS.
- SQS-utløsere: Muliggjør asynkron og frikoblet meldingsbehandling ved at Lambda henter meldinger fra køer.
- SNS-utløsere: Legger til rette for sanntidsvarsler til flere mottakere ved å sende meldinger til Lambda.
- Du har også sett de ulike hendelsesstrukturene og viktig beste praksis for å bygge robuste hendelsesstyrte serverløse applikasjoner.
Det er avgjørende å beherske disse integrasjonene for å bygge skalerbare og robuste serverløse backend-systemer!
Lær deg Serverløs backend med AWS Lambda & API Gateway med en AI-veileder – gratis
Skriv og kjør ekte kode i nettleseren, få umiddelbar hjelp fra en AI-veileder som er tilgjengelig døgnet rundt, og fortsett der du slapp – på nettet eller i appen.
- Kurs
- 12
- Leksjoner
- 48
Ofte stilte spørsmål
Er leksjonen «Lambda med SQS-/SNS-utløsere» gratis?
Ja – hele teksten i «Lambda med SQS-/SNS-utløsere» er gratis å lese her på nettet. For å øve interaktivt med en innebygd kodeeditor og en AI-veileder som er tilgjengelig døgnet rundt, og for å låse opp resten av Serverløs backend med AWS Lambda & API Gateway-kurset, kan du oppgradere til CoddyKit PRO. Kurset i Serverløs backend med AWS Lambda & API Gateway inneholder totalt 4 leksjoner.
Hva lærer jeg i «Lambda med SQS-/SNS-utløsere»?
Konfigurer Lambda-funksjoner til å utløses av SQS-køer og SNS-emner, slik at du kan opprette effektive hendelsesdrevne arbeidsflyter. Du øver på Serverløs backend med AWS Lambda & API Gateway med praktisk kode som du kjører direkte i nettleseren, mens en AI-veileder som er tilgjengelig døgnet rundt, svarer på spørsmålene dine mens du jobber deg gjennom leksjonen.
Trenger jeg erfaring for å begynne med Serverløs backend med AWS Lambda & API Gateway?
Ingen tidligere erfaring er nødvendig. Serverløs backend med AWS Lambda & API Gateway på CoddyKit er lagt opp for både nybegynnere og viderekomne, så De kan begynne her eller helt fra start og lære i Deres eget tempo. Dette er leksjon 3 av 4.
Hvor lang tid tar leksjonen «Lambda med SQS-/SNS-utløsere»?
De fleste CoddyKit-leksjoner tar omtrent 5–10 minutter. Hver leksjon er kort og interaktiv, slik at De gjør jevne fremskritt og kan fortsette akkurat der De slapp – både på nettet og i appen.
Kan jeg skrive og kjøre kode i denne Serverløs backend med AWS Lambda & API Gateway-leksjonen?
Ja. Alle Serverløs backend med AWS Lambda & API Gateway-leksjoner har en innebygd kodeeditor, slik at De kan skrive og kjøre ekte kode direkte i nettleseren og få umiddelbar tilbakemelding fra AI – uten lokal konfigurering.
Alle leksjonene i dette kurset
- SQS for frakobling av tjenester
- SNS for Pub/Sub-meldinger
- Lambda med SQS-/SNS-utløsere
- Dead-letter-køer og feilhåndtering